void merger::merge_model(const model& m) { const auto mn(m.name().model_name()); BOOST_LOG_SEV(lg, info) << "Merging model: '" << mn << " modules: " << m.modules().size() << " concepts: " << m.concepts().size() << " primitives: " << m.primitives().size() << " enumerations: " << m.enumerations().size() << " objects: " << m.objects().size(); for (const auto& c : m.concepts()) { check_qname(m.name().model_name(), c.first, c.second.name()); merged_model_.concepts().insert(c); } for (const auto& p : m.primitives()) { // FIXME: mega hack to handle primitive model. const auto pmn(mn == primitive_model_name ? empty : mn); check_qname(pmn, p.first, p.second.name()); merged_model_.primitives().insert(p); } for (const auto& p : m.enumerations()) { check_qname(mn, p.first, p.second.name()); merged_model_.enumerations().insert(p); } for (const auto& o : m.objects()) { check_qname(mn, o.first, o.second->name()); merged_model_.objects().insert(o); } }
void property_indexer::index_objects(model& m) { BOOST_LOG_SEV(lg, debug) << "Indexing objects: " << m.objects().size(); std::unordered_set<sml::qname> processed_qnames; for (auto& pair : m.objects()) { auto& o(pair.second); if (o.generation_type() == generation_types::no_generation) continue; index_object(o, m, processed_qnames); } }
void json_hydrator::post_process(model& m) const { update_containing_module(m, m.objects()); update_containing_module(m, m.primitives()); update_containing_module(m, m.enumerations()); update_containing_module(m, m.concepts()); update_containing_module(m, m.modules()); }
void modules_expander::expand_containing_module(model& m) const { update_containing_module(m, m.objects()); update_containing_module(m, m.primitives()); update_containing_module(m, m.enumerations()); update_containing_module(m, m.concepts()); update_containing_module(m, m.modules()); }
std::list<name> generalization_indexer:: recurse_generalization(const model& m, const name& leaf, const object& o, generalization_details& d) const { if (!o.is_child()) return std::list<name> { o.name() }; const auto i(o.relationships().find(relationship_types::parents)); if (i == o.relationships().end() || i->second.empty()) { const auto qn(o.name().qualified()); BOOST_LOG_SEV(lg, error) << child_with_no_parents << qn; BOOST_THROW_EXCEPTION(indexing_error(child_with_no_parents + qn)); } std::list<name> original_parents; for (const auto& parent : i->second) { auto j(m.objects().find(parent)); if (j == m.objects().end()) { const auto qn(parent.qualified()); BOOST_LOG_SEV(lg, error) << parent_not_found << qn; BOOST_THROW_EXCEPTION(indexing_error(parent_not_found + qn)); } const auto op(recurse_generalization(m, leaf, j->second, d)); if (op.empty()) { const auto qn(parent.qualified()); BOOST_LOG_SEV(lg, error) << child_with_no_original_parent << qn; BOOST_THROW_EXCEPTION( indexing_error(child_with_no_original_parent + qn)); } for (const auto qn : op) original_parents.push_back(qn); d.original_parents[parent] = op; BOOST_LOG_SEV(lg, debug) << "Type: " << parent.qualified() << " has original parents: " << op; d.leaves[parent].push_back(leaf); BOOST_LOG_SEV(lg, debug) << "Type is a leaf of: " << parent.qualified(); } d.original_parents[o.name()] = original_parents; return original_parents; }
void merger::merge_model(const model& m) { BOOST_LOG_SEV(lg, info) << "Merging model: '" << m.name().qualified() << " modules: " << m.modules().size() << " concepts: " << m.concepts().size() << " primitives: " << m.primitives().size() << " enumerations: " << m.enumerations().size() << " objects: " << m.objects().size(); const auto mn(m.name().location().original_model_name()); for (const auto& c : m.concepts()) { check_name(mn, c.first, c.second.name()); merged_model_.concepts().insert(c); } for (const auto& pair : m.primitives()) { // FIXME: mega hack to handle primitive model. const auto pmn(mn == hardware_model_name ? empty : mn); check_name(pmn, pair.first, pair.second.name()); merged_model_.primitives().insert(pair); } for (const auto& pair : m.enumerations()) { check_name(mn, pair.first, pair.second.name()); merged_model_.enumerations().insert(pair); } for (const auto& pair : m.objects()) { check_name(mn, pair.first, pair.second.name()); merged_model_.objects().insert(pair); } for (const auto& pair : m.modules()) { if (!pair.first.simple().empty()) check_name(mn, pair.first, pair.second.name()); merged_model_.modules().insert(pair); } }
void generalization_indexer:: populate(const generalization_details& d, model& m) const { for (const auto& pair : d.leaves) { const auto& n(pair.first); auto i(m.objects().find(n)); if (i == m.objects().end()) { const auto qn(n.qualified()); BOOST_LOG_SEV(lg, error) << object_not_found << qn; BOOST_THROW_EXCEPTION(indexing_error(object_not_found + qn)); } const auto rt(relationship_types::leaves); i->second.relationships()[rt] = pair.second; i->second.relationships()[rt].sort(); const auto omn(m.name().location().original_model_name()); for (const auto& l : pair.second) { if (l.location().original_model_name() == omn) m.leaves().insert(l); } } for (const auto& pair : d.original_parents) { const auto& n(pair.first); auto i(m.objects().find(n)); if (i == m.objects().end()) { const auto qn(n.qualified()); BOOST_LOG_SEV(lg, error) << object_not_found << qn; BOOST_THROW_EXCEPTION(indexing_error(object_not_found + qn)); } auto& o(i->second); if (!o.is_child()) { // a bit of a hack, top-level types have themselves as the // original parent of the container just to make our life easier BOOST_LOG_SEV(lg, debug) << "Type has parents but is not a child: " << n.qualified(); continue; } const auto rt(relationship_types::original_parents); o.relationships()[rt] = pair.second; for (const auto& opn : pair.second) { const auto j(m.objects().find(opn)); if (j == m.objects().end()) { const auto qn(opn.qualified()); BOOST_LOG_SEV(lg, error) << object_not_found << qn; BOOST_THROW_EXCEPTION(indexing_error(object_not_found + qn)); } o.is_original_parent_visitable(j->second.is_visitable()); } } }
void json_hydrator:: read_element(const boost::property_tree::ptree& pt, model& m) const { qname qn; qn.model_name(model_name(m)); read_module_path(pt, m, qn); const auto simple_name_value(pt.get<std::string>(simple_name_key)); qn.simple_name(simple_name_value); const auto documentation(pt.get_optional<std::string>(documentation_key)); const auto lambda([&](type& t) { BOOST_LOG_SEV(lg, debug) << "Processing type: " << sml::string_converter::convert(qn); t.name(qn); t.origin_type(m.origin_type()); t.generation_type(m.generation_type()); if (documentation) t.documentation(*documentation); const auto scope(dynamic::scope_types::entity); t.extensions(create_dynamic_extensions(pt, scope)); }); const auto meta_type_value(pt.get<std::string>(meta_type_key)); if (meta_type_value == meta_type_object_value) { object o; lambda(o); const auto ot(pt.get_optional<std::string>(object_type_key)); o.object_type(to_object_type(ot)); m.objects().insert(std::make_pair(qn, o)); } else if (meta_type_value == meta_type_primitive_value) { primitive p; lambda(p); m.primitives().insert(std::make_pair(qn, p)); } else { BOOST_LOG_SEV(lg, error) << invalid_meta_type << meta_type_value; BOOST_THROW_EXCEPTION( hydration_error(invalid_meta_type + meta_type_value)); } }
generalization_indexer::generalization_details generalization_indexer:: obtain_details(const model& m) const { BOOST_LOG_SEV(lg, debug) << "Obtaining leaves."; generalization_details r; for (auto& pair : m.objects()) { auto& o(pair.second); BOOST_LOG_SEV(lg, debug) << "Processing type: " << o.name().qualified(); if (!is_leaf(o)) continue; recurse_generalization(m, o.name(), o, r); } BOOST_LOG_SEV(lg, debug) << "Leaves: " << r.leaves; BOOST_LOG_SEV(lg, debug) << "Original parents: " << r.original_parents; BOOST_LOG_SEV(lg, debug) << "Finished obtaining details."; return r; }
std::size_t model_hasher::hash(const model& v) { std::size_t seed(0); combine(seed, v.documentation()); combine(seed, v.extensions()); combine(seed, v.name()); combine(seed, v.generation_type()); combine(seed, v.origin_type()); combine(seed, hash_boost_optional_dogen_tack_name(v.containing_module())); combine(seed, hash_std_unordered_map_dogen_tack_name_dogen_tack_origin_types(v.references())); combine(seed, hash_std_unordered_set_dogen_tack_name(v.leaves())); combine(seed, hash_std_unordered_map_dogen_tack_name_dogen_tack_module(v.modules())); combine(seed, hash_std_unordered_map_dogen_tack_name_dogen_tack_concept(v.concepts())); combine(seed, hash_std_unordered_map_dogen_tack_name_dogen_tack_primitive(v.primitives())); combine(seed, hash_std_unordered_map_dogen_tack_name_dogen_tack_enumeration(v.enumerations())); combine(seed, hash_std_unordered_map_dogen_tack_name_dogen_tack_object(v.objects())); combine(seed, v.is_target()); combine(seed, v.has_generatable_types()); return seed; }