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;
}
