if (!as_generator
(
documentation(indent.n + 1)
+ << indent << scope_tab << "/// <value>" << string << "</value>\n"
<< indent << scope_tab << "public " << type << " " << string << ";\n"
)
- .generate(sink, std::make_tuple(field, field.type, name_helpers::to_field_name(field.name)), context))
+ .generate(sink, std::make_tuple(field, field.type.doc_summary, field.type, name_helpers::to_field_name(field.name)), context))
return false;
}
// Constructor with default parameters for easy struct initialization
if(!as_generator(
indent << scope_tab << "/// <summary>Constructor for " << string << ".</summary>\n"
+ << *(indent << scope_tab << field_argument_docs << ";\n")
<< indent << scope_tab << "public " << string << "(\n"
<< ((indent << scope_tab << scope_tab << field_argument_default) % ",\n")
<< indent << scope_tab << ")\n"
<< indent << scope_tab << "{\n"
<< *(indent << scope_tab << scope_tab << field_argument_assignment << ";\n")
<< indent << scope_tab << "}\n\n")
- .generate(sink, std::make_tuple(struct_name, struct_name, struct_.fields, struct_.fields), context))
+ .generate(sink, std::make_tuple(struct_name, struct_.fields, struct_name, struct_.fields, struct_.fields), context))
return false;
}
}
} const field_argument_assignment {};
+struct field_argument_docs_generator
+{
+ template<typename OutputIterator, typename Context>
+ bool generate(OutputIterator sink, attributes::struct_field_def const& field, Context const& context) const
+ {
+ if (!as_generator("/// <param name=\"" << string << "\">" << string << "</param>")
+ .generate(sink, std::make_tuple(name_helpers::to_field_name(field.name), field.documentation.summary), context))
+ return false;
+ return true;
+ }
+} const field_argument_docs {};
+
}
namespace efl { namespace eolian { namespace grammar {
template<>
struct is_generator< ::eolian_mono::field_argument_assignment_generator> : std::true_type {};
+template<>
+struct is_eager_generator< ::eolian_mono::field_argument_docs_generator> : std::true_type {};
+template<>
+struct is_generator< ::eolian_mono::field_argument_docs_generator> : std::true_type {};
+
namespace type_traits {
template <>
template <>
struct attributes_needed< ::eolian_mono::field_argument_assignment_generator> : std::integral_constant<int, 1> {};
+template <>
+struct attributes_needed< ::eolian_mono::field_argument_docs_generator> : std::integral_constant<int, 1> {};
+
}
} } }
bool has_own;
bool is_ptr;
bool is_beta;
+ std::string doc_summary;
type_def() = default;
- type_def(variant_type original_type, std::string c_type, bool has_own, bool is_ptr, bool is_beta)
- : original_type(original_type), c_type(c_type), has_own(has_own), is_ptr(is_ptr), is_beta(is_beta) {}
+ type_def(variant_type original_type, std::string c_type, bool has_own, bool is_ptr, bool is_beta, std::string doc_summary)
+ : original_type(original_type), c_type(c_type), has_own(has_own), is_ptr(is_ptr), is_beta(is_beta), doc_summary(doc_summary) {}
type_def(Eolian_Type const* eolian_type, Eolian_Unit const* unit, Eolian_C_Type_Type ctype)
{
return !(lhs == rhs);
}
-type_def const void_ {attributes::regular_type_def{"void", {qualifier_info::is_none, {}}, {}}, "void", false, false, false};
+type_def const void_ {attributes::regular_type_def{"void", {qualifier_info::is_none, {}}, {}}, "void", false, false, false, ""};
inline void type_def::set(Eolian_Type const* eolian_type, Eolian_Unit const* unit, Eolian_C_Type_Type ctype)
{
Eolian_Typedecl const* decl = eolian_type_typedecl_get(eolian_type);
is_beta = decl && eolian_object_is_beta(EOLIAN_OBJECT(decl));
+ if (decl)
+ {
+ documentation_def documentation = eolian_typedecl_documentation_get(decl);
+ doc_summary = documentation.summary;
+ }
switch( ::eolian_type_type_get(eolian_type))
{
case EOLIAN_TYPE_VOID: