std::list<std::string> name_builder::
namespace_list(const yarn::name& n, const bool detect_model_name) const {
const auto& l(n.location());
std::list<std::string> r(l.external_modules());
for (const auto& m : l.model_modules())
r.push_back(m);
for (const auto& m : l.internal_modules())
r.push_back(m);
if (!detect_model_name)
return r;
/* if the name belongs to the model's module, we need to remove the
* module's simple name from the module path (it is in both the
* module path and it is also the module's simple name).
*/
const bool no_internal_modules(l.internal_modules().empty());
const bool has_model_modules(!l.model_modules().empty());
const bool is_model_name(no_internal_modules && has_model_modules &&
n.simple() == l.model_modules().back());
if (is_model_name)
r.pop_back();
return r;
}
boost::filesystem::path path_derivatives_factory::
make_file_path(const settings::path_settings& ps,
const boost::filesystem::path& inclusion_path,
const yarn::name& n) const {
BOOST_LOG_SEV(lg, debug) << "Creating file path for: " << n.qualified();
boost::filesystem::path r;
const auto ft(ps.file_type());
const auto& mmp(n.location().model_modules());
switch (ft) {
case formatters::file_types::cpp_header:
r = options_.project_directory_path();
r /= boost::algorithm::join(mmp, dot);
r /= ps.include_directory_name();
break;
case formatters::file_types::cpp_implementation:
r = options_.project_directory_path();
r /= boost::algorithm::join(mmp, dot);
r /= ps.source_directory_name();
break;
default:
BOOST_LOG_SEV(lg, error) << unsupported_file_type << ft;
BOOST_THROW_EXCEPTION(building_error(unsupported_file_type +
boost::lexical_cast<std::string>(ft)));
}
r /= inclusion_path;
BOOST_LOG_SEV(lg, debug) << "Done creating file path. Result: " << r;
return r;
}
boost::filesystem::path class_implementation_formatter::inclusion_path(
const formattables::locator& /*l*/, const yarn::name& n) const {
using namespace dogen::utility::log;
static logger lg(
logger_factory(class_implementation_formatter::static_artefact()));
static const std::string not_supported("Inclusion path is not supported: ");
BOOST_LOG_SEV(lg, error) << not_supported << n.id();
BOOST_THROW_EXCEPTION(formatting_error(not_supported + n.id()));
}
boost::filesystem::path path_derivatives_factory::
make_inclusion_path(const settings::path_settings& ps,
const yarn::name& n) const {
BOOST_LOG_SEV(lg, debug) << "Making inclusion path for: " << n.qualified();
boost::filesystem::path r;
/* Header files require both the external module path and the
* model module path in the file name path.
*/
if (ps.file_type() == formatters::file_types::cpp_header) {
for (const auto& m : n.location().external_modules())
r /= m;
const auto& mmp(n.location().model_modules());
r /= boost::algorithm::join(mmp, dot);
}
/* If there is a facet directory, and it is configured to
* contribute to the file name path, add it.
*/
if (!ps.facet_directory().empty() && !ps.disable_facet_directories())
r /= ps.facet_directory();
// Add the module path of the modules internal to this model.
for (const auto& m : n.location().internal_modules())
r /= m;
/* Modules other than the model module contribute their simple
* names to the directories.
*/
if (n != model_.name()) {
const auto i(model_.elements().find(n.qualified()));
if (i != model_.elements().end() && is<yarn::module>(i->second))
r /= n.simple();
}
// handle the file name.
std::ostringstream stream;
stream << n.simple();
if (!ps.formatter_postfix().empty())
stream << underscore << ps.formatter_postfix();
if (!ps.facet_postfix().empty())
stream << underscore << ps.facet_postfix();
if (ps.file_type() == formatters::file_types::cpp_header)
stream << dot << ps.header_file_extension();
else if (ps.file_type() == formatters::file_types::cpp_implementation)
stream << dot << ps.implementation_file_extension();
r /= stream.str();
BOOST_LOG_SEV(lg, debug) << "Done making the inclusion path. Result: " << r;
return r;
}
void generalization_expander::populate_properties_up_the_generalization_tree(
const type_group& tg, const yarn::name& leaf,
intermediate_model& im, yarn::object& o) const {
/*
* Add the leaf to all nodes of the tree except for the leaf node
* itself.
*/
if (!o.is_leaf())
o.leaves().push_back(leaf);
/*
* If we do not have a parent we have reached the top of the
* generalisation tree.
*/
if (!o.parent()) {
/*
* If the leaf name belongs to the target model, add it to
* the model's list of leaves. Ignore non-target leaves.
*/
const auto& ll(leaf.location());
const auto& ml(im.name().location());
if (ll.model_modules() == ml.model_modules())
im.leaves().insert(leaf);
return;
}
const auto pid(o.parent()->id());
auto j(im.objects().find(pid));
if (j == im.objects().end()) {
BOOST_LOG_SEV(lg, error) << parent_not_found << pid;
BOOST_THROW_EXCEPTION(expansion_error(parent_not_found + pid));
}
auto& parent(j->second);
populate_properties_up_the_generalization_tree(tg, leaf, im, parent);
if (!parent.parent()) {
/*
* If our parent does not have a parent then it is our root
* parent.
*/
o.root_parent(parent.name());
} else {
/*
* On all other cases, inherit the root parent properties for
* our direct parent; these would have been populated from the
* root parent as per above.
*/
o.root_parent(parent.root_parent());
}
}
std::string name_builder::
qualified_name(const yarn::name& n) const {
std::list<std::string> l(namespace_list(n, true));
l.push_back(n.simple());
return boost::algorithm::join(l, scope_operator);
}