<< scope_tab << "public static implicit operator " << alias_type << "(" << alias_name << " value)\n"
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "return value.payload;\n"
- << scope_tab << "}\n\n"
- << "}\n\n"
+ << scope_tab << "}\n"
+ << "}\n"
).generate(sink, alias, context))
return false;
int scope_size = 0;
- documentation_generator(int scope_size)
+ documentation_generator(int scope_size = 0)
: scope_size(scope_size) {}
else
ref = "<see cref=\"" + ref + "\" />";
- if (!as_generator(
- scope_tab << "/// <param name=\"" << constructor_parameter_name(ctor) << "\">" << summary << " See " << ref << "</param>\n"
- ).generate(sink, param, context))
+ if (!as_generator(scope_tab(scope_size) << "/// <param name=\"" << constructor_parameter_name(ctor) << "\">" << summary << " See " << ref << "</param>\n")
+ .generate(sink, param, context))
return false;
}
return true;
return false;
}
- if(!as_generator("}\n\n").generate(sink, attributes::unused, context)) return false;
+ if(!as_generator("}\n").generate(sink, attributes::unused, context)) return false;
if(!name_helpers::close_namespaces(sink, enum_.namespaces, context))
return false;
<< scope_tab << "/// <summary>Actual event payload.</summary>\n"
<< scope_tab << "/// <value>" << documentation_string << "</value>\n"
<< scope_tab << "public " << type << " arg { get; set; }\n"
- << "}\n"
+ << "}\n\n"
).generate(sink, std::make_tuple(evt.documentation.summary, *etype), context);
}
} const event_argument_wrapper {};
if (evt.type.is_engaged())
wrapper_args_type = "<" + name_helpers::managed_event_args_name(evt) + ">";
- if (!as_generator(
- documentation(1)
- ).generate(sink, evt, context)) return false;
+ if (!as_generator(documentation(1))
+ .generate(sink, evt, context)) return false;
if (evt.type.is_engaged())
if (!as_generator(
scope_tab << "/// <value><see cref=\"" << name_helpers::managed_event_args_name(evt) << "\"/></value>\n"
<< scope_tab << scope_tab << scope_tab << "return;\n"
<< scope_tab << scope_tab << "}\n\n"
<< event_native_call
- << scope_tab << "}\n"
+ << scope_tab << "}\n\n"
).generate(sink, nullptr, context))
return false;
<< scope_tab << scope_tab << scope_tab << scope_tab << "RemoveNativeEventHandler(" << library_name << ", key, value);\n"
<< scope_tab << scope_tab << scope_tab << "}\n" // End of lock block
<< scope_tab << scope_tab << "}\n"
- << scope_tab << "}\n"
+ << scope_tab << "}\n\n"
).generate(sink, attributes::unused, context);
}
};
if(f.scope != attributes::member_scope::scope_public)
return true;
- if(!as_generator(documentation).generate(sink, f, context))
+ if(!as_generator(documentation(1)).generate(sink, f, context))
return false;
return as_generator
- (eolian_mono::type(true) << " " << string << "(" << (parameter % ", ") << ");\n")
+ (scope_tab << eolian_mono::type(true) << " " << string << "(" << (parameter % ", ") << ");\n\n")
.generate(sink, std::make_tuple(f.return_type, name_helpers::managed_method_name(f), f.parameters), context);
}
};
<< indent << scope_tab << "var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);\n"
<< indent << scope_tab << "if (ws != null)\n"
<< indent << scope_tab << "{\n"
- << eolian_mono::native_function_definition_preamble()
+ << indent << scope_tab << scope_tab << eolian_mono::native_function_definition_preamble() << "\n"
<< indent << scope_tab << scope_tab << "try\n"
<< indent << scope_tab << scope_tab << "{\n"
<< indent << scope_tab << scope_tab << scope_tab << (return_type != "void" ? "_ret_var = " : "")
<< indent << scope_tab << scope_tab << scope_tab << "Eina.Log.Warning($\"Callback error: {e.ToString()}\");\n"
<< indent << scope_tab << scope_tab << scope_tab << "Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);\n"
<< indent << scope_tab << scope_tab << "}\n\n"
- << eolian_mono::native_function_definition_epilogue(*klass) << "\n"
+ << indent << eolian_mono::native_function_definition_epilogue(*klass) << "\n"
<< indent << scope_tab << "}\n"
<< indent << scope_tab << "else\n"
<< indent << scope_tab << "{\n"
if(!as_generator
(scope_tab << eolian_mono::function_scope_get(f) << ((do_super && !f.is_static) ? "virtual " : "") << (f.is_static ? "static " : "") << return_type << " " << string << "(" << (parameter % ", ")
- << ") {\n "
- << eolian_mono::function_definition_preamble()
+ << ") {\n"
+ << scope_tab(2) << eolian_mono::function_definition_preamble()
<< klass_full_native_inherit_name(f.klass) << "." << string << "_ptr.Value.Delegate("
<< self
<< ((!f.is_static && (f.parameters.size() > 0)) ? "," : "")
<< (argument_invocation % ", ") << ");\n"
- << eolian_mono::function_definition_epilogue()
- << " }\n")
+ << scope_tab(2) << eolian_mono::function_definition_epilogue()
+ << scope_tab(1) << "}\n\n")
.generate(sink, std::make_tuple(name_helpers::managed_method_name(f), f.parameters, f, f.c_name, f.parameters, f), context))
return false;
if (property.setter.is_engaged())
{
attributes::type_def prop_type = property.setter->parameters[0].type;
- if (!as_generator("public static Efl.BindableProperty<" << type(true) << "> " << managed_name << "<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<"
- << name_helpers::klass_full_concrete_or_interface_name(cls)
- << ", T>magic = null) where T : " << name_helpers::klass_full_concrete_or_interface_name(cls) << " {\n"
+ if (!as_generator(scope_tab << "public static Efl.BindableProperty<" << type(true) << "> " << managed_name << "<T>(this Efl.Ui.ItemFactory<T> fac, Efl.Csharp.ExtensionTag<"
+ << name_helpers::klass_full_concrete_or_interface_name(cls)
+ << ", T>magic = null) where T : " << name_helpers::klass_full_concrete_or_interface_name(cls) << " {\n"
<< scope_tab << scope_tab << "return new Efl.BindableProperty<" << type(true) << ">(\"" << property.name << "\", fac);\n"
- << scope_tab << "}\n"
+ << scope_tab << "}\n\n"
).generate(sink, std::make_tuple(prop_type, prop_type), context))
return false;
}
if (property.setter.is_engaged())
{
attributes::type_def prop_type = property.setter->parameters[0].type;
- if (!as_generator("public static Efl.BindableProperty<" << type(true) << "> " << managed_name << "<T>(this Efl.BindablePart<T> part, Efl.Csharp.ExtensionTag<"
- << name_helpers::klass_full_concrete_or_interface_name(cls)
- << ", T>magic = null) where T : " << name_helpers::klass_full_concrete_or_interface_name(cls) << " {\n"
+ if (!as_generator(scope_tab << "public static Efl.BindableProperty<" << type(true) << "> " << managed_name << "<T>(this Efl.BindablePart<T> part, Efl.Csharp.ExtensionTag<"
+ << name_helpers::klass_full_concrete_or_interface_name(cls)
+ << ", T>magic = null) where T : " << name_helpers::klass_full_concrete_or_interface_name(cls) << " {\n"
<< scope_tab << scope_tab << "return new Efl.BindableProperty<" << type(true) << ">(part.PartName, \"" << property.name << "\", part.Binder);\n"
- << scope_tab << "}\n"
+ << scope_tab << "}\n\n"
).generate(sink, std::make_tuple(prop_type, prop_type), context))
return false;
}
return false;
}
- if (!as_generator(scope_tab << "}\n").generate(sink, attributes::unused, context))
+ if (!as_generator(scope_tab << "}\n\n").generate(sink, attributes::unused, context))
return false;
return true;
return false;
if (!as_generator(
- *(scope_tab << scope_tab << native_convert_in_variable)
- << *(scope_tab << scope_tab << native_convert_out_variable)
- << *(scope_tab << scope_tab << native_convert_function_pointer)
- << scope_tab << scope_tab << scope_tab << native_convert_return_variable
+ *(native_convert_in_variable)
+ << *(native_convert_out_variable)
+ << *(native_convert_function_pointer)
+ << native_convert_return_variable
).generate(sink, std::make_tuple(f.parameters, f.parameters, f.parameters, f.return_type), context))
return false;
- return as_generator("\n").generate(sink, attributes::unused, context);
+ return as_generator("").generate(sink, attributes::unused, context);
}
};
return false;
if (!as_generator(
- *(scope_tab << scope_tab << convert_in_variable)
- << *(scope_tab << scope_tab << convert_out_variable)
- << *(scope_tab << scope_tab << convert_function_pointer)
- << scope_tab << scope_tab << convert_return_variable
- ).generate(sink, std::make_tuple(f.parameters, f.parameters, f.parameters, f.return_type), context))
+ *(convert_in_variable)
+ << *(convert_out_variable)
+ << *(convert_function_pointer)
+ << convert_return_variable
+ ).generate(sink, std::make_tuple(f.parameters, f.parameters, f.parameters, f.return_type), context))
return false;
return true;
return false;
if (!as_generator(
- *(scope_tab << scope_tab << native_convert_out_assign(*klass))
- << *(scope_tab << scope_tab << native_convert_in_ptr_assign)
- << scope_tab << scope_tab << native_convert_return(*klass)
+ *(native_convert_out_assign(*klass))
+ << *(native_convert_in_ptr_assign)
+ << scope_tab(2) << native_convert_return(*klass)
).generate(sink, std::make_tuple(f.parameters, f.parameters, f.return_type), context))
return false;
bool generate(OutputIterator sink, attributes::function_def const& f, Context const& context) const
{
if (!as_generator(
- scope_tab << scope_tab << "Eina.Error.RaiseIfUnhandledException();\n"
- << *(scope_tab << scope_tab << convert_out_assign)
- << *(scope_tab << scope_tab << convert_in_ptr_assign)
- << scope_tab << scope_tab << convert_return
+ "Eina.Error.RaiseIfUnhandledException();\n"
+ << *(convert_out_assign)
+ << *(convert_in_ptr_assign)
+ << scope_tab(2) << convert_return << "\n"
).generate(sink, std::make_tuple(f.parameters, f.parameters, f.return_type), context))
return false;
if(!as_generator("\n{\n").generate(sink, attributes::unused, iface_cxt))
return false;
- if(!as_generator(*(scope_tab << function_declaration)).generate(sink, cls.functions, iface_cxt))
+ if(!as_generator(*(function_declaration)).generate(sink, cls.functions, iface_cxt))
return false;
- if(!as_generator(*(scope_tab << async_function_declaration)).generate(sink, cls.functions, iface_cxt))
+ if(!as_generator(*(async_function_declaration)).generate(sink, cls.functions, iface_cxt))
return false;
if(!as_generator(*(event_declaration)).generate(sink, cls.events, iface_cxt))
return false;
// End of interface declaration
- if(!as_generator("}\n").generate(sink, attributes::unused, iface_cxt)) return false;
+ if(!as_generator("}\n\n").generate(sink, attributes::unused, iface_cxt)) return false;
}
// Events arguments go in the top namespace to avoid the Concrete suffix clutter in interface events.
(
scope_tab << "[System.Runtime.InteropServices.DllImport(" << context_find_tag<library_context>(concrete_cxt).actual_library_name(cls.filename)
<< ")] internal static extern System.IntPtr\n"
- << scope_tab << scope_tab << name_helpers::klass_get_name(cls) << "();\n"
+ << scope_tab << scope_tab << name_helpers::klass_get_name(cls) << "();\n\n"
<< scope_tab << "/// <summary>Initializes a new instance of the <see cref=\"" << interface_name << "\"/> class.\n"
<< scope_tab << "/// Internal usage: This is used when interacting with C code and should not be used directly.</summary>\n"
<< scope_tab << "/// <param name=\"wh\">The native pointer to be wrapped.</param>\n"
scope_tab << "private static IntPtr GetEflClassStatic()\n"
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "return " << name_helpers::klass_get_full_name(cls) << "();\n"
- << scope_tab << "}\n"
+ << scope_tab << "}\n\n"
).generate(sink, attributes::unused, concrete_cxt))
return false;
scope_tab << "private static IntPtr GetEflClassStatic()\n"
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "return " << name_helpers::klass_get_full_name(cls) << "();\n"
- << scope_tab << "}\n"
+ << scope_tab << "}\n\n"
).generate(sink, attributes::unused, inherit_cxt))
return false;
<< "#pragma warning disable CS1591\n" // Disabling warnings as DocFx will hide these classes
<<"public static class " << (string % "_") << name_helpers::klass_inherit_name(cls)
<< "_ExtensionMethods {\n"
- << *((scope_tab << property_extension_method_definition(cls)) << "\n")
- << *((scope_tab << part_extension_method_definition(cls)) << "\n")
+ << *(property_extension_method_definition(cls))
+ << *(part_extension_method_definition(cls))
<< "}\n"
<< "#pragma warning restore CS1591\n"
<< "#endif\n")
{
if(!as_generator(
indent << scope_tab << "private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule("
- << indent << context_find_tag<library_context>(context).actual_library_name(cls.filename) << ");\n"
+ << context_find_tag<library_context>(context).actual_library_name(cls.filename) << ");\n\n"
).generate(sink, attributes::unused, inative_cxt))
return false;
}
if(!as_generator(
indent << scope_tab << scope_tab << "return descs;\n"
- << indent << scope_tab << "}\n"
+ << indent << scope_tab << "}\n\n"
).generate(sink, attributes::unused, inative_cxt))
return false;
if(!as_generator(
scope_tab << "[System.Runtime.InteropServices.DllImport(" << context_find_tag<library_context>(context).actual_library_name(cls.filename)
<< ")] internal static extern System.IntPtr\n"
- << scope_tab << scope_tab << name_helpers::klass_get_name(cls) << "();\n"
+ << scope_tab << scope_tab << name_helpers::klass_get_name(cls) << "();\n\n"
).generate(sink, attributes::unused, context))
return false;
return true;
// Self events
- if (!as_generator(*(event_definition(cls, cls))).generate(sink, cls.events, context))
+ if (!as_generator(*(event_definition(cls, cls)) << "\n").generate(sink, cls.events, context))
return false;
// Inherited events
template<typename OutputIterator, typename Context>
bool close_namespaces(OutputIterator sink, std::vector<std::string> const& namespaces, Context const& context)
{
- auto close_namespace = (lit("}") % "\n\n" ) << "\n\n";
+ auto close_namespace = (lit("}") % "\n" ) << "\n\n";
return as_generator(close_namespace).generate(sink, namespaces, context);
}
else if (helpers::need_struct_conversion(regular))
{
return as_generator(
- "return _ret_var;\n"
+ "return _ret_var;"
).generate(sink, nullptr, context);
}
else if (ret_type.c_type == "Eina_Binbuf *" || ret_type.c_type == "const Eina_Binbuf *")
}
else if (ret_type.c_type != "void")
{
- return as_generator("return _ret_var;\n").generate(sink, ret_type, context);
+ return as_generator("return _ret_var;").generate(sink, ret_type, context);
}
return true;
}
if (ret_type.is_ptr && helpers::need_pointer_conversion(regular) && !helpers::need_struct_conversion_in_return(ret_type, attributes::parameter_direction::unknown) )
{
return as_generator(
- "return Eina.PrimitiveConversion.ManagedToPointerAlloc(_ret_var);\n"
+ "return Eina.PrimitiveConversion.ManagedToPointerAlloc(_ret_var);"
).generate(sink, attributes::unused, context);
}
else if (helpers::need_struct_conversion(regular))
{
return as_generator(
- "return _ret_var;\n"
+ "return _ret_var;"
).generate(sink, nullptr, context);
}
else if (ret_type.c_type == "const char *")
return false;
}
return as_generator(
- "return _ret_var;\n"
+ "return _ret_var;"
).generate(sink, attributes::unused, context);
}
else
{
- return as_generator("return _ret_var;\n"
+ return as_generator("return _ret_var;"
).generate(sink, attributes::unused, context);
}
}
return false;
}
return as_generator(
- "return _ret_var;\n"
+ "return _ret_var;"
).generate(sink, attributes::unused, context);
}
else
{
- return as_generator("return _ret_var;\n")
+ return as_generator("return _ret_var;")
.generate(sink, attributes::unused, context);
}
}
.generate(sink, attributes::unused, context))
return false;
- return as_generator("return _ret_var.Handle;\n")
+ return as_generator("return _ret_var.Handle;")
.generate(sink, attributes::unused, context);
}
else if (ret_type.c_type == "Eina_Hash *" || ret_type.c_type == "const Eina_Hash *")
.generate(sink, attributes::unused, context))
return false;
- return as_generator("return _ret_var.Handle;\n")
+ return as_generator("return _ret_var.Handle;")
.generate(sink, attributes::unused, context);
}
else if (ret_type.c_type == "Eina_Array *" || ret_type.c_type == "const Eina_Array *"
return false;
}
- return as_generator("return _ret_var.Handle;\n")
+ return as_generator("return _ret_var.Handle;")
.generate(sink, attributes::unused, context);
}
else if (ret_type.c_type != "void")
- return as_generator("return _ret_var;\n").generate(sink, ret_type, context);
+ return as_generator("return _ret_var;").generate(sink, ret_type, context);
return true;
}
<< ", T> x=null) where T : " << name_helpers::klass_full_concrete_or_interface_name(cls) << "\n"
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "return new " << bindableClass << "<" << part_klass_name << ">(\"" << part.name << "\" ,fac);\n"
- << scope_tab << "}\n"
+ << scope_tab << "}\n\n"
).generate(sink, attributes::unused, context))
return false;
}
if (!as_generator(indent << scope_tab << scope_tab << "return _external_struct;\n"
- << indent << scope_tab << "}\n\n").generate(sink, nullptr, context))
+ << indent << scope_tab << "}\n").generate(sink, nullptr, context))
return false;
// close internal class
- if(!as_generator(indent << "}\n\n"
- << indent << "#pragma warning restore CS1591\n\n"
+ if(!as_generator(indent << "}\n"
+ << indent << "#pragma warning restore CS1591\n"
).generate(sink, attributes::unused, context)) return false;
return true;
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 << "\">" << documentation_string << "</param>")
+ if (!as_generator(current_indentation(context) << "/// <param name=\"" << string << "\">" << documentation_string << "</param>")
.generate(sink, std::make_tuple(name_helpers::to_field_name(field.name), field.documentation.summary), context))
return false;
return true;