//------------------------------------------------------------------
structure_processor::structure_processor(const config& cfg,
const element& e,
content_storage& result) :
m_cfg(cfg),
m_result(result)
{
m_result.reserve(e.total_len());
e.process(*this);
}
//------------------------------------------------------------------
code_colorer::code_colorer(const config& cfg,
const element& e,
content_storage& result) :
m_cfg(cfg),
m_result(result),
m_coloring_element(0)
{
m_result.reserve(e.total_len());
e.process(*this);
}
//------------------------------------------------------------------
table_structurizer::table_structurizer(const config& cfg,
const element& e,
content_storage& result) :
m_cfg(cfg),
m_result(result),
m_skip_element(0)
{
m_result.reserve(e.total_len());
e.process(*this);
}
double
element::chemicalMass( const element& e )
{
std::pair<double, double> sum
= std::accumulate( e.isotopes().begin(), e.isotopes().end()
, std::make_pair( 0.0, 0.0 )
, []( const std::pair<double, double>& a, const toe::isotope& i ){
return std::make_pair( a.first + (i.mass * i.abundance), a.second + i.abundance ); });
//assert( adportable::compare<double>::approximatelyEqual( sum.second, 1.0 ) );
return sum.first;
}
//------------------------------------------------------------------
void index_storage::end_element(const element& e)
{
if(str_cmp(e.name(), e.name_len(), keyword_dir) == 0)
{
if(m_path.size()) m_path.pop_back();
}
else
if(str_cmp(e.name(), e.name_len(), keyword_file) == 0)
{
m_file_name.erase();
m_file_ext.erase();
}
}
//------------------------------------------------------------------
void table_structurizer::start_element(const element& e)
{
if(m_skip_element) return;
// if(m_cfg.keyword_exists(keyword_formatless_elements, e.name(), e.name_len()))
if(m_cfg.is_solid_element(e.name(), e.name_len()))
{
element_serializer s(m_result, e);
m_skip_element = &e;
return;
}
if(str_cmp(e.name(), e.name_len(), keyword_ssv_table) == 0)
{
process_ssv_table(e);
m_skip_element = &e;
}
else
if(str_cmp(e.name(), e.name_len(), keyword_vbar_table) == 0)
{
process_vbar_table(e);
m_skip_element = &e;
}
else
if(str_cmp(e.name(), e.name_len(), keyword_eln_table) == 0)
{
process_eln_table(e);
m_skip_element = &e;
}
else
{
m_result.add_element_header(e);
}
}
/**
* @brief Given the merit function associated with the rezone data, this function is in the correct form for gsl to parse
*
* @param i_rezone_data A pointer to the rezone data
* @return The merit value that the merit function has returned, summed over all elements
*/
static double func (void *i_rezone_data) {
element *element_ptr = ((rezone_data *) i_rezone_data)->element_ptr;
mpi::messenger *messenger_ptr = element_ptr->messenger_ptr;
double value = ((rezone_data *)i_rezone_data)->merit_func (element_ptr, element_ptr->make_rezoned_virtual_file (((rezone_data *)i_rezone_data)->positions, &*(element_ptr->rezone_virtual_file), profile_only));
messenger_ptr->sum (&value);
return value;
}
element_state get_state(void)
{
assert(lock_ != nullptr);
return utils::spinlock_exec([this](void) -> element_state {
return element_->get_state();
}, *lock_);
}
inline
void update(element& elem)
{
boost::optional<HWND> wnd = elem.window();
if (wnd) {
::UpdateWindow(*wnd);
return;
}
boost::optional<element&> pa = elem.parent();
if (!pa) {
BOOST_ASSERT(false); // todo
return;
}
hamburger::update(*pa);
}
//------------------------------------------------------------------
void structure_processor::end_element(const element& e)
{
const string_type* p;
if(e.name_len())
{
m_result.add_element_footer(e);
p = m_cfg.find(e.name(), e.name_len(), keyword_close_suffix);
m_result.add(p);
m_result.add(close_brace);
}
else
{
p = m_cfg.find(keyword_page_close.name);
m_result.add(p);
}
}
void
print()
{
if (l != NULL)
l->print();
cout << el->f() << " " << s << "\n";
if (r != NULL)
r->print();
}
//------------------------------------------------------------------
index_storage::index_storage(const element& e)
{
e.process(*this);
unsigned i;
for(i = 0; i < m_data.size(); ++i)
{
m_key_anchor.insert(&m_data[i]);
m_key_category.insert(&m_data[i]);
}
}
//------------------------------------------------------------------
void structure_processor::start_element(const element& e)
{
const string_type* p;
if(e.name_len())
{
m_result.add_element_header(e);
p = m_cfg.find(e.name(), e.name_len(), keyword_open_suffix);
m_result.add(p);
m_result.add(backslash);
m_result.add(keyword_cntn.name, keyword_cntn.len);
m_result.add(open_brace);
}
else
{
p = m_cfg.find(keyword_page_open.name);
m_result.add(p);
}
}
//------------------------------------------------------------------
void code_colorer::start_element(const element& e)
{
if(e.name_len())
{
if(m_coloring_element == 0)
{
if(m_cfg.keyword_exists(keyword_code, e.name(), e.name_len()) ||
str_cmp(e.name(), e.name_len(), keyword_code) == 0 ||
str_cmp(e.name(), e.name_len(), keyword_m) == 0)
{
m_coloring_element = &e;
color_code(e);
}
else
{
m_result.add_element_header(e);
}
}
}
}
//------------------------------------------------------------------
void table_structurizer::process_table_header(const element& e)
{
m_result.add(backslash);
m_result.add(keyword_table.name, keyword_table.len);
if(e.attr_len())
{
m_result.add(open_bracket);
m_result.add(e.attr(), e.attr_len());
m_result.add(close_bracket);
}
m_result.add(open_brace);
m_result.add(lf);
if(m_header.length())
{
m_result.add(backslash);
m_result.add(keyword_trh.name, keyword_trh.len);
m_result.add(open_brace);
parse_double_vbar(m_header.text(), m_header.length(), &keyword_th);
m_result.add(close_brace);
}
}
//------------------------------------------------------------------
void table_content_extractor::start_element(const element& e)
{
if(m_skip_element) return;
if(str_cmp(e.name(), e.name_len(), keyword_th) == 0)
{
element_serializer(m_header, e, false);
m_skip_element = &e;
}
else
if(str_cmp(e.name(), e.name_len(), keyword_al) == 0)
{
content_storage st;
element_serializer(st, e, false);
const char_type* str = st.text();
while(*str)
{
char_type c = *str++;
if(c == open_angle ||
c == close_angle ||
c == vbar ||
c == minus)
{
m_align.push_back(c);
}
}
m_skip_element = &e;
}
else
{
if(m_level)
{
m_table.add_element_header(e);
}
++m_level;
}
}
//------------------------------------------------------------------
table_content_extractor::table_content_extractor(const element& e,
content_storage& header,
content_storage& table,
string_buffer_type& align) :
m_header(header),
m_table(table),
m_align(align),
m_skip_element(0),
m_level(0)
{
m_header.clear();
m_table.clear();
m_align.clear();
e.process(*this);
}
//------------------------------------------------------------------
void code_colorer::end_element(const element& e)
{
if(e.name_len())
{
if(m_coloring_element == 0)
{
m_result.add(close_brace);
}
else
{
if(m_coloring_element == &e)
{
m_coloring_element = 0;
}
}
}
}
double match(element elem)
{
elements.clear();
auto elems = elem.elements();
double res = 1.0;
assert(subhandler != nullptr);
while(!elems.empty())
{
res *= subhandler->match(elems.front());
if(res > 0.0)
{
elements.push_back(elems.front());
elems.step_front();
}
else return 0.0;
}
return res;
}
void step(F forward_or_backward)
{
const auto state = get_state();
if (state == element_state::boundary) {
auto next_block =
utils::spinlock_exec([this](void) -> typename element<T>::next_type {
return element_->get_next();
}, *lock_);
element_ = std::get<decltype(element_)>(next_block);
lock_ = std::get<decltype(lock_)>(next_block);
if (element_ == nullptr) {
return;
}
}
forward_or_backward();
}
// static
double
element::monoIsotopicMass( const element& e, int isotope )
{
if ( isotope == 0 ) {
// return most abundunt
auto it = std::max_element( e.isotopes().begin(), e.isotopes().end(), []( const toe::isotope& a, const toe::isotope& b ){ return a.abundance < b.abundance; });
if ( it != e.isotopes().end() )
return it->mass;
} else {
// find specified isotope
auto it = std::find_if( e.isotopes().begin(), e.isotopes().end(), [=]( const toe::isotope& a ){ return int ( a.mass + 0.3 ) == isotope; });
if ( it != e.isotopes().end() )
return it->mass;
}
return 0;
}
void dehydrator::dehydrate_element(const intermediate_model& im,
const element& e, const std::string& meta_type, std::ostream& s) const {
formatters::utility_formatter uf(s);
uf.insert_quoted("name");
s << " : ";
dehydrate_name(e.name(), s);
s << comma_space;
uf.insert_quoted("meta_type");
s << ": ";
uf.insert_quoted(meta_type);
if (!e.documentation().empty()) {
s << comma_space;
uf.insert_quoted("documentation");
s << " : ";
uf.insert_quoted(tidy_up_string(e.documentation()));
}
if (!e.stereotypes().empty()) {
s << comma_space;
uf.insert_quoted("stereotypes");
s << " : [ ";
bool is_first(true);
for (const auto& stereotype : e.stereotypes()) {
if (!is_first)
s << comma_space;
uf.insert_quoted(stereotype);
is_first = false;
}
s << " ] ";
}
dehydrate_annotations(im, e.name().id(), s);
}
bool is_leaf(const element& x) {
return x.which() == 0;
}
T operator*(void)
{
return utils::spinlock_exec([this](void) {
return element_->get_data();
}, *lock_);
}
void
add(element<T>* e)
{
s++;
if (this->l == NULL)
{
if (el->f() > e->f())
{
l = new heap(el);
l->p = this;
l->el->root = l;
el = e;
el->root = this;
}
else
{
l = new heap(e);
l->p = this;
l->el->root = l;
}
}
else if (r == NULL)
{
if (el->f() > e->f())
{
r = new heap(el);
r->p = this;
r->el->root = r;
el = e;
this->el->root = this;
}
else
{
r = new heap(e);
r->p = this;
r->el->root = r;
}
}
else if (l->s > r->s)
{
if (el->f() > e->f())
{
r->add(el);
el = e;
this->el->root = this;
}
else
{
r->add(e);
}
}
else
{
if (el->f() > e->f())
{
l->add(el);
el = e;
this->el->root = this;
}
else
{
l->add(e);
}
}
}
//------------------------------------------------------------------
void index_storage::start_element(const element& e)
{
string_type ts;
index_element ie;
if(str_cmp(e.name(), e.name_len(), keyword_dir) == 0)
{
parse_and_find_attr_content(e.attr(), e.attr_len(), ts);
clean_and_trim_string(ts);
if(ts.empty())
{
e.throw_exception(e.name(), "index_storage: \\dir: No directory name");
}
trim_ending_slashes(ts);
m_path.push_back(ts);
}
else
if(str_cmp(e.name(), e.name_len(), keyword_file) == 0)
{
parse_and_find_attr_content(e.attr(), e.attr_len(), ts);
clean_and_trim_string(ts);
if(ts.empty())
{
e.throw_exception(e.name(), "index_storage: \\file: No file name");
}
m_file_name = ts;
if(parse_and_find_attr_variable(e.attr(), e.attr_len(), keyword_ext, ts))
{
clean_and_trim_string(ts);
m_file_ext = ts;
}
ie.category.assign(keyword_file.name, keyword_file.len);
ie.anchor.assign(m_file_name);
ie.comment.erase();
ie.comment.assign(m_file_name);
make_full_path(ie.full_path);
m_data.push_back(ie);
}
else
if(str_cmp(e.name(), e.name_len(), keyword_title) == 0)
{
if(m_file_name.empty())
{
e.throw_exception(e.name(), "index_storage: \\title: Illegal outside of \\file");
}
extract_element_content(e, ts);
ie.category.assign(keyword_title.name, keyword_title.len);
ie.anchor.assign(m_file_name);
ie.comment.assign(ts);
make_full_path(ie.full_path);
m_data.push_back(ie);
}
else
if(str_cmp(e.name(), e.name_len(), keyword_label) == 0)
{
if(m_file_name.empty())
{
e.throw_exception(e.name(), "index_storage: \\title: Illegal outside of \\file");
}
if(parse_and_find_attr_variable(e.attr(), e.attr_len(), keyword_category, ts))
{
clean_and_trim_string(ts);
if(ts.empty())
{
e.throw_exception(e.name(), "index_storage: \\label: No 'category' attribute");
}
ie.category.assign(ts);
}
if(parse_and_find_attr_variable(e.attr(), e.attr_len(), keyword_anchor, ts))
{
clean_and_trim_string(ts);
if(ts.empty())
{
e.throw_exception(e.name(), "index_storage: \\label: No 'anchor' attribute");
}
ie.anchor.assign(ts);
}
extract_element_content(e, ts);
ie.comment.assign(ts);
make_full_path(ie.full_path);
m_data.push_back(ie);
}
}
void set_next(typename vector_list<T>::next_type&& nt)
{
utils::spinlock_exec([this](auto nt) -> void {
element_->set_next(nt);
}, *lock_, nt);
}
//------------------------------------------------------------------
void index_storage::extract_element_content(const element& e, string_type& ret) const
{
ret.assign(e.content(), e.content_len());
clean_and_trim_string(ret);
}
//------------------------------------------------------------------
void code_colorer::color_code(const element& e)
{
m_language.assign(e.name(), e.name_len());
m_block_comments = m_cfg.strlist(string_type(e.name(), e.name_len()),
keyword_block_comments_suffix);
m_line_comments = m_cfg.strlist(string_type(e.name(), e.name_len()),
keyword_line_comments_suffix);
m_string_quotation = m_cfg.strlist(string_type(e.name(), e.name_len()),
keyword_strings_suffix);
m_string_mask = m_cfg.strlist(string_type(e.name(), e.name_len()),
keyword_string_mask_suffix);
m_operators = m_cfg.strlist(string_type(e.name(), e.name_len()),
keyword_operators_suffix);
replace_strlist_keysym(m_block_comments);
replace_strlist_keysym(m_line_comments);
replace_strlist_keysym(m_string_quotation);
replace_strlist_keysym(m_string_mask);
replace_strlist_keysym(m_operators);
m_identifier_charset.clear();
add_to_identifier_charset(keyword_kw1_suffix);
add_to_identifier_charset(keyword_kw2_suffix);
add_to_identifier_charset(keyword_kw3_suffix);
add_to_identifier_charset(keyword_kw4_suffix);
m_operator_charset.clear();
unsigned i;
for(i = 0; i < m_operators.size(); ++i)
{
const string_type& str = m_operators[i];
for(unsigned j = 0; j < str.length(); j++)
{
char_type c = str[j];
if(!is_alnum(c))
{
m_operator_charset.insert(replace_keysym(c));
}
}
}
content_storage code;
element_serializer ser(code, e, false, false);
code.replace_text_keysym();
m_result.add(backslash);
if(str_cmp(m_language, keyword_m) == 0)
{
m_result.add(keyword_m.name, keyword_m.len);
m_result.add(open_brace);
m_result.add(code.text());
m_result.add(close_brace);
}
else
if(str_cmp(m_language, keyword_code) == 0)
{
m_result.add(keyword_code.name, keyword_code.len);
if(e.attr_len())
{
m_result.add(open_bracket);
m_result.add(e.attr(), e.attr_len());
m_result.add(close_bracket);
}
m_result.add(open_brace);
m_result.add(code.text());
m_result.add(close_brace);
}
else
{
m_result.add(keyword_code.name, keyword_code.len);
if(e.attr_len())
{
m_result.add(open_bracket);
m_result.add(e.attr(), e.attr_len());
m_result.add(close_bracket);
}
m_result.add(open_brace);
color_code(code.text());
m_result.add(close_brace);
}
}
