void visual_studio_project_generator::
populate(const unsigned int position, result_type& v) {
    dogen::yarn::element_generator::populate(position, v);
    v.project_guid(create_std_string(position + 0));
    v.project_name(create_std_string(position + 1));
    v.tools_version(create_std_string(position + 2));
}

void outputting_properties_generator::
populate(const unsigned int position, result_type& v) {
    v.force_write(create_bool(position + 0));
    v.delete_extra_files(create_bool(position + 1));
    v.ignore_files_matching_regex(create_std_vector_std_string(position + 2));
    v.delete_empty_directories(create_bool(position + 3));
}

void enumerator_info_generator::
populate(const unsigned int position, result_type& v) {
    v.name(create_std_string(position + 0));
    v.qualified_name(create_std_string(position + 1));
    v.documentation(create_std_string(position + 2));
    v.value(create_std_string(position + 3));
}

void qname_generator::
populate(const unsigned int position, result_type& v) {
    v.model_name(create_std_string(position + 0));
    v.external_module_path(create_std_list_std_string(position + 1));
    v.module_path(create_std_list_std_string(position + 2));
    v.simple_name(create_std_string(position + 3));
}

void class_d_generator::
populate(const unsigned int position, result_type& v) {
    v.prop_0(create_boost_optional_int(position + 0));
    v.prop_1(create_boost_optional_dogen_test_models_boost_model_class_a(position + 1));
    v.prop_2(create_boost_optional_dogen_test_models_boost_model_pkg1_class_c(position + 2));
    v.prop_3(create_boost_optional_std_vector_dogen_test_models_boost_model_class_a_(position + 3));
}

void input_settings_generator::
populate(const unsigned int position, result_type& v) {
    v.target(create_boost_filesystem_path(position + 0));
    v.external_module_path(create_std_string(position + 1));
    v.references(create_std_vector_dogen_config_reference(position + 2));
    v.disable_model_module(create_bool(position + 3));
}

void knitting_options_generator::
populate(const unsigned int position, result_type& v) {
    v.verbose(create_bool(position + 0));
    v.input(create_dogen_config_input_options(position + 1));
    v.output(create_dogen_config_output_options(position + 2));
    v.cpp(create_dogen_config_cpp_options(position + 3));
}

void processed_comment_generator::
populate(const unsigned int position, result_type& v) {
    v.documentation(create_std_string(position + 0));
    v.key_value_pairs(create_std_list_std_pair_std_string_std_string_(position + 1));
    v.applicable_to_parent_object(create_bool(position + 2));
    v.original_content(create_std_string(position + 3));
}

void formatter_properties_generator::
populate(const unsigned int position, result_type& v) {
    v.enabled(create_bool(position + 0));
    v.file_path(create_boost_filesystem_path(position + 1));
    v.header_guard(create_boost_optional_std_string(position + 2));
    v.inclusion_dependencies(create_std_list_std_string(position + 3));
    v.integrated_facets(create_std_unordered_set_std_string(position + 4));
}

void artefact_properties_generator::
populate(const unsigned int position, result_type& v) {
    v.enabled(create_bool(position + 0));
    v.overwrite(create_bool(position + 1));
    v.file_path(create_boost_filesystem_path(position + 2));
    v.formatting_style(create_dogen_coding_meta_model_formatting_styles(position + 3));
    v.formatting_input(create_std_string(position + 4));
}

void repository_generator::
populate(const unsigned int position, result_type& v) {
    v.all_field_definitions(create_std_list_dogen_dynamic_field_definition(position + 0));
    v.field_definitions_by_name(create_std_unordered_map_std_string_dogen_dynamic_field_definition(position + 1));
    v.field_definitions_by_facet_name(create_std_unordered_map_std_string_std_list_dogen_dynamic_field_definition_(position + 2));
    v.field_definitions_by_formatter_name(create_std_unordered_map_std_string_std_list_dogen_dynamic_field_definition_(position + 3));
    v.field_definitions_by_model_name(create_std_unordered_map_std_string_std_list_dogen_dynamic_field_definition_(position + 4));
}

void cpp_options_generator::
populate(const unsigned int position, result_type& v) {
    v.split_project(create_bool(position + 0));
    v.project_directory_path(create_boost_filesystem_path(position + 1));
    v.source_directory_path(create_boost_filesystem_path(position + 2));
    v.include_directory_path(create_boost_filesystem_path(position + 3));
    v.disable_cmakelists(create_bool(position + 4));
}

void modeline_generator::
populate(const unsigned int position, result_type& v) {
    dogen::coding::meta_model::element_generator::populate(position, v);
    v.editor(create_dogen_coding_meta_model_decoration_editor(position + 0));
    v.location(create_dogen_coding_meta_model_decoration_modeline_location(position + 1));
    v.fields(create_std_list_dogen_coding_meta_model_decoration_modeline_field(position + 2));
    v.technical_space(create_dogen_coding_meta_model_technical_space(position + 3));
}

	result_type operator() (const result_type& str) const {
		std::vector<result_type> v;
		result_type::const_iterator
			first = str.begin(),
				  last  = str.end();
		qi::parse(first, last, +(char_-',')%',', v);

		return v[8];
	}

void truncated_cone_generator::
populate(const unsigned int position, result_type& v) {
    neurite::geometry::solid_generator::populate(position, v);
    v.first(create_neurite_geometry_vector3d(position + 0));
    v.first_radius(create_double(position + 1));
    v.second_radius(create_double(position + 2));
    v.second(create_neurite_geometry_vector3d(position + 3));
    v.height(create_double(position + 4));
}

// Computing residuals in high precision
void printResidual(result_type y1, result_type y2, Real aa, Real bb, Real cc)
{
  auto a=static_cast<long double>(aa);
  auto b=static_cast<long double>(bb);
  auto c=static_cast<long double>(cc);
  auto x1=std::complex<long double>(static_cast<long double>(y1.real()),static_cast<long double>(y1.imag()));
  auto x2=std::complex<long double>(static_cast<long double>(y2.real()),static_cast<long double>(y2.imag()));
  std::cout<<"Residuals: "<< a*x1*x1+b*x1+c<<", "<<
    a*x2*x2+b*x2+c<<std::endl<<std::endl;
}

void attribute_generator::
populate(const unsigned int position, result_type& v) {
    v.documentation(create_std_string(position + 0));
    v.configuration(create_boost_shared_ptr_dogen_variability_meta_model_configuration(position + 1));
    v.name(create_dogen_coding_meta_model_name(position + 2));
    v.static_stereotypes(create_std_list_dogen_coding_meta_model_static_stereotypes(position + 3));
    v.dynamic_stereotypes(create_std_list_std_string(position + 4));
    v.unparsed_type(create_std_string(position + 5));
    v.parsed_type(create_dogen_coding_meta_model_name_tree(position + 6));
    v.is_immutable(create_bool(position + 7));
    v.is_fluent(create_bool(position + 8));
    v.orm_properties(create_boost_optional_dogen_coding_meta_model_orm_attribute_properties(position + 9));
}

void rOctree<T>::QueryItemsWithRay(const ray_type& r , result_type& result) {
    result.clear();

    if (! m_root || !rIntersection::RayIntersectsAlignedBox(r , m_root->m_volume))
        return;

    AddNodeItemsToResultSet( m_root,result);
    QueryItemsWithRayRec(r , result, m_root);
}

					int operator()() const {
						v.insert(value_type(types::node_type(), indexes::variant_node_index));
						v.insert(value_type(types::bin_type(), indexes::variant_bin_index));
						v.insert(value_type(types::int_type(), indexes::variant_int_index));
						v.insert(value_type(types::uint_type(), indexes::variant_uint_index));
						return 0;
					}