bool instantiator::is_instantiable(const field_definition& fd) const {
return
fd.definition_type() == field_definition_types::global_template ||
fd.definition_type() == field_definition_types::model_template ||
fd.definition_type() == field_definition_types::facet_template ||
fd.definition_type() == field_definition_types::formatter_template;
}
void mock_repository_factory::add_field_definition(
const field_definition& fd, repository& rp) const {
const auto n(fd.name().qualified());
const auto pair(std::make_pair(n, fd));
const auto result(rp.field_definitions_by_name().insert(pair));
if (!result.second) {
BOOST_LOG_SEV(lg, error) << duplicate_qualified_name << n;
BOOST_THROW_EXCEPTION(workflow_error(duplicate_qualified_name + n));
}
const auto& oh(fd.ownership_hierarchy());
rp.field_definitions_by_facet_name()[oh.facet_name()].push_back(fd);
rp.field_definitions_by_formatter_name()[oh.formatter_name()]
.push_back(fd);
}
std::list<field_definition>
instantiator::instantiate_formatter_template(const field_definition& fd) const {
std::list<field_definition> r;
for (const auto oh : ownership_hierarchy_) {
if (!fd.ownership_hierarchy().model_name().empty() &&
fd.ownership_hierarchy().model_name() != oh.model_name())
continue;
if (!fd.ownership_hierarchy().facet_name().empty() &&
fd.ownership_hierarchy().facet_name() != oh.facet_name())
continue;
auto instance_fd(fd);
instance_fd.definition_type(field_definition_types::instance);
const auto fn(oh.formatter_name());
instance_fd.name().qualified(fn + "." + fd.name().simple());
instance_fd.ownership_hierarchy(oh);
r.push_back(instance_fd);
}
return r;
}
std::list<field_definition>
instantiator::instantiate_facet_template(const field_definition& fd) const {
std::list<field_definition> r;
for (const auto pair : facet_names_by_model_name_) {
const auto model_name(pair.first);
if (!fd.ownership_hierarchy().model_name().empty() &&
fd.ownership_hierarchy().model_name() != model_name)
continue;
const auto& facet_names(pair.second);
for (const auto facet_name : facet_names) {
auto instance_fd(fd);
instance_fd.definition_type(field_definition_types::instance);
instance_fd.name().qualified(facet_name + "." + fd.name().simple());
instance_fd.ownership_hierarchy().model_name(model_name);
instance_fd.ownership_hierarchy().facet_name(facet_name);
instance_fd.ownership_hierarchy().formatter_name(empty);
r.push_back(instance_fd);
}
}
return r;
}
std::size_t field_definition_hasher::hash(const field_definition& v) {
std::size_t seed(0);
combine(seed, v.name());
combine(seed, v.value_type());
combine(seed, v.scope());
combine(seed, v.ownership_hierarchy());
combine(seed, hash_boost_shared_ptr_dogen_dynamic_value(v.default_value()));
combine(seed, v.definition_type());
return seed;
}
std::list<field_definition>
instantiator::instantiate(const field_definition& fd) const {
validate(fd);
BOOST_LOG_SEV(lg, debug) << "Instantiating template: " << fd;
std::list<field_definition> r;
const auto dt(fd.definition_type());
if (dt == field_definition_types::global_template)
r = instantiate_global_template(fd);
else if (dt == field_definition_types::facet_template)
r = instantiate_facet_template(fd);
else if (dt == field_definition_types::formatter_template)
r = instantiate_formatter_template(fd);
else {
BOOST_LOG_SEV(lg, error) << unsupported_definition_type << dt;
BOOST_THROW_EXCEPTION(instantiation_error(unsupported_definition_type +
boost::lexical_cast<std::string>(dt)));
}
BOOST_LOG_SEV(lg, debug) << "Instantiation result: " << r;
return r;
}
void instantiator::validate(const field_definition& fd) const {
const auto sn(fd.name().simple());
if (fd.name().simple().empty()) {
BOOST_LOG_SEV(lg, error) << empty_simple_name;
BOOST_THROW_EXCEPTION(instantiation_error(empty_simple_name));
}
if (!is_instantiable(fd)) {
BOOST_LOG_SEV(lg, error) << field_not_instantiable << sn;
BOOST_THROW_EXCEPTION(instantiation_error(field_not_instantiable + sn));
}
if (!fd.name().qualified().empty()) {
BOOST_LOG_SEV(lg, error) << qualified_name_not_empty << sn;
BOOST_THROW_EXCEPTION(
instantiation_error(qualified_name_not_empty + sn));
}
if (fd.definition_type() == field_definition_types::global_template) {
if (!fd.ownership_hierarchy().facet_name().empty()) {
BOOST_LOG_SEV(lg, error) << facet_name_not_empty << sn;
BOOST_THROW_EXCEPTION(
instantiation_error(facet_name_not_empty + sn));
}
if (!fd.ownership_hierarchy().formatter_name().empty()) {
BOOST_LOG_SEV(lg, error) << formatter_name_not_empty << sn;
BOOST_THROW_EXCEPTION(
instantiation_error(formatter_name_not_empty + sn));
}
if (!fd.ownership_hierarchy().formatter_group_name().empty()) {
BOOST_LOG_SEV(lg, error) << formatter_group_not_empty << sn;
BOOST_THROW_EXCEPTION(
instantiation_error(formatter_group_not_empty + sn));
}
}
if (fd.definition_type() == field_definition_types::facet_template) {
if (!fd.ownership_hierarchy().facet_name().empty()) {
BOOST_LOG_SEV(lg, error) << facet_name_not_empty << sn;
BOOST_THROW_EXCEPTION(
instantiation_error(facet_name_not_empty + sn));
}
if (!fd.ownership_hierarchy().formatter_group_name().empty()) {
BOOST_LOG_SEV(lg, error) << formatter_group_not_empty << sn;
BOOST_THROW_EXCEPTION(
instantiation_error(formatter_group_not_empty + sn));
}
if (!fd.ownership_hierarchy().formatter_name().empty()) {
BOOST_LOG_SEV(lg, error) << formatter_name_not_empty << sn;
BOOST_THROW_EXCEPTION(
instantiation_error(formatter_name_not_empty + sn));
}
}
if (fd.definition_type() == field_definition_types::formatter_template) {
if (!fd.ownership_hierarchy().formatter_name().empty()) {
BOOST_LOG_SEV(lg, error) << formatter_name_not_empty << sn;
BOOST_THROW_EXCEPTION(
instantiation_error(formatter_name_not_empty + sn));
}
}
}
