bindings/eina_cxx/eina_array.hh \
bindings/eina_cxx/eina_clone_allocators.hh \
bindings/eina_cxx/eina_error.hh \
-bindings/eina_cxx/eina_eo_base_fwd.hh \
+bindings/eina_cxx/eina_eo_concrete_fwd.hh \
bindings/eina_cxx/eina_fold.hh \
bindings/eina_cxx/eina_inarray.hh \
bindings/eina_cxx/eina_inlist.hh \
+### Generated Headers
+
+generated_eo_cxx_bindings = \
+lib/eo/eo_base.eo.hh \
+lib/eo/eo_abstract_class.eo.hh
+
+CLEANFILES += $(generated_eo_cxx_bindings)
+
+installed_eocxxheadersdir = $(includedir)/eo-cxx-@VMAJ@
+nodist_installed_eocxxheaders_DATA = $(generated_eo_cxx_bindings)
+
### Library
if HAVE_CXX11
installed_eocxxheadersdir = $(includedir)/eo-cxx-@VMAJ@/
dist_installed_eocxxheaders_DATA = \
-bindings/eo_cxx/eo_base.hh \
+bindings/eo_cxx/eo_concrete.hh \
bindings/eo_cxx/eo_event.hh \
bindings/eo_cxx/eo_init.hh \
bindings/eo_cxx/eo_wref.hh \
lib/eolian_cxx/grammar/eo_class_constructors_generator.hh \
lib/eolian_cxx/grammar/eo_class_events_generator.hh \
lib/eolian_cxx/grammar/eo_class_functions_generator.hh \
+lib/eolian_cxx/grammar/namespace_generator.hh \
lib/eolian_cxx/grammar/eo_class_generator.hh \
lib/eolian_cxx/grammar/eo_header_generator.hh \
lib/eolian_cxx/grammar/inheritance_base_generator.hh \
extern efl::eina::log_domain domain;
+void
+remove_repeated_base(const char* klass_name, efl::eolian::parents_container_type& cont)
+{
+ Eolian_Class const* klass = ::eolian_class_get_by_name(klass_name);
+ if (!klass)
+ {
+ std::cerr << "Error: could not get eolian class name `" << klass_name << "'" << std::endl;
+ return;
+ }
+
+ Eina_Iterator* inheritances = ::eolian_class_inherits_get(klass);
+ void* curr = 0;
+
+ EINA_ITERATOR_FOREACH(inheritances, curr)
+ {
+ if (!curr)
+ continue;
+
+ const char* parent = static_cast<const char*>(curr);
+ cont.erase(
+ std::remove(cont.begin(), cont.end(), safe_lower(class_format_cxx(parent)))
+ , cont.end());
+
+ remove_repeated_base(parent, cont);
+ }
+ eina_iterator_free(inheritances);
+}
+
static efl::eolian::parameters_container_type
_convert_eolian_parameters(Eina_Iterator *parameters,
Eolian_Function_Type func_type)
return get_;
}
-static std::string
-_convert_class_name(std::string const& name)
-{
- return (name == "eo_base" || name == "eo::base" || name == "")
- ? "efl::eo::base"
- : name;
-}
void
convert_eolian_inheritances(efl::eolian::eo_class& cls, Eolian_Class const& klass)
::eolian_class_inherits_get(&klass);
void *curr;
- if (!eina_iterator_next(inheritances, &curr) || !curr)
+ EINA_ITERATOR_FOREACH(inheritances, curr)
{
- cls.parent = "efl::eo::base";
- eina_iterator_free(inheritances);
- return;
+ std::string parent = safe_lower(static_cast<const char*>(curr));
+ cls.parents.push_back(class_format_cxx(parent));
}
- else
+ eina_iterator_free(inheritances);
+
+ if (cls.parents.empty())
+ return;
+
+ inheritances = ::eolian_class_inherits_get(&klass);
+ EINA_ITERATOR_FOREACH(inheritances, curr)
{
- // First element is the parent
- const char *ptr = static_cast<const char*>(curr);
- cls.parent = _convert_class_name(class_format_cxx(safe_lower(ptr)));
-
- EINA_ITERATOR_FOREACH(inheritances, curr)
- {
- std::string extension = safe_lower(static_cast<const char*>(curr));
- cls.extensions.push_back(_convert_class_name(class_format_cxx(extension)));
- }
+ if (curr)
+ remove_repeated_base(static_cast<const char*>(curr), cls.parents);
}
eina_iterator_free(inheritances);
}
Eolian_Function const& func = *first;
Eolian_Function_Type const func_type = function_op_type(func);
+ if (!function_is_visible(func, func_type))
+ continue;
+
if (function_is_constructor(klass, func))
{
cls.constructors.push_back({
convert_comments_function(klass, func)
});
}
- else if (function_is_visible(func, func_type))
+ else
{
cls.functions.push_back({
function_type(func),
Eolian_Function const& func = *first;
Eolian_Function_Type t = ::eolian_function_type_get(&func);
+ if (!function_is_visible(func, t))
+ continue;
+
if(t == EOLIAN_PROP_GET)
{
cls.functions.push_back
std::string eo_parent_file = class_base_file(*ext);
if (!eo_parent_file.empty())
{
- // we have our own eo_base.hh
- std::string eo_base_eo = "eo_base.eo";
- if (eo_parent_file.length() < eo_base_eo.length() ||
- !std::equal(eo_base_eo.begin(), eo_base_eo.end(),
- eo_parent_file.end() - eo_base_eo.length()))
- {
- gen_opts.cxx_headers.push_back(eo_parent_file + ".hh");
- }
+ gen_opts.cxx_headers.push_back(eo_parent_file + ".hh");
}
else
{
{
if (type.front().native == "char *")
type = { efl::eolian::type_to_native(type) };
- type.front().is_out = true;
+ type.is_out = true;
type.front().native += "*";
}
if (parameter_is_const(parameter, func_type))
{
- type[0].native.insert(0, "const ");
- if (!type[0].binding.empty())
- type[0].binding.insert(0, "const ");
+ type.front().native.insert(0, "const ");
+ if (!type.front().binding.empty())
+ type.front().binding.insert(0, "const ");
}
return type;
}
efl::eolian::eolian_type_instance v(types.size());
for (std::size_t i = 0; i != types.size(); ++i)
{
- v[i] = type_find(lut.begin(), lut.end(), type_from_eolian(*types[i]));
+ v.parts[i] = type_find(lut.begin(), lut.end(), type_from_eolian(*types[i]));
}
// Let's degrade to opaque classes when not enough information
// is available for complex types
- if(v.size() == 1 && type_is_complex(v[0]))
+ if(v.parts.size() == 1 && type_is_complex(v.front()))
{
- efl::eolian::eolian_type tmp = v[0];
+ efl::eolian::eolian_type tmp = v.front();
return {efl::eolian::type_to_native(tmp)};
}
{"Ecore_Task_Cb", eolian_type::callback_, {"Ecore.h"}},
{"Ecore_Timeline_Cb", eolian_type::callback_, {"Ecore.h"}},
{"Edje_Signal_Cb", eolian_type::callback_, {"Edje.h"}},
- {"Eina_Accessor *", eolian_type::complex_, false, false, "efl::eina::accessor", {"eina-cxx/eina_accessor.hh"}},
- {"Eina_Bool", eolian_type::simple_, false, false, "bool", {}},
- {"Eina_Bool *", eolian_type::simple_, false, false, "bool*", {}},
- {"Eina_Inlist *", eolian_type::complex_, false, false, "efl::eina::range_inlist", {"eina-cxx/eina_inlist.hh"}},
- {"Eina_Inlist *", eolian_type::complex_, false, true, "efl::eina::inlist", {"eina-cxx/eina_inlist.hh"}},
- {"Eina_Iterator *", eolian_type::complex_, false, false, "efl::eina::iterator", {"eina-cxx/eina_iterator.hh"}},
- {"Eina_List *", eolian_type::complex_, false, false, "efl::eina::range_list", {"eina-cxx/eina_list.hh"}},
- {"Eina_List *", eolian_type::complex_, false, true, "efl::eina::list", {"eina-cxx/eina_list.hh"}},
- {"const Eina_List *", eolian_type::complex_, true, false, "efl::eina::crange_list", {"eina-cxx/eina_list.hh"}},
+ {"Eina_Accessor *", eolian_type::complex_, false, false, true, "::efl::eina::accessor", {"eina-cxx/eina_accessor.hh"}},
+ {"Eina_Bool", eolian_type::simple_, false, false, false, "bool", {}},
+ {"Eina_Bool *", eolian_type::simple_, false, false, false, "bool*", {}},
+ {"Eina_Inlist *", eolian_type::complex_, false, false, true, "::efl::eina::range_inlist", {"eina-cxx/eina_inlist.hh"}},
+ {"Eina_Inlist *", eolian_type::complex_, false, true, true, "::efl::eina::inlist", {"eina-cxx/eina_inlist.hh"}},
+ {"Eina_Iterator *", eolian_type::complex_, false, false, true, "::efl::eina::iterator", {"eina-cxx/eina_iterator.hh"}},
+ {"Eina_List *", eolian_type::complex_, false, false, true, "::efl::eina::range_list", {"eina-cxx/eina_list.hh"}},
+ {"Eina_List *", eolian_type::complex_, false, true, true, "::efl::eina::list", {"eina-cxx/eina_list.hh"}},
+ {"const Eina_List *", eolian_type::complex_, true, false, true, "::efl::eina::crange_list", {"eina-cxx/eina_list.hh"}},
{"Eio_Filter_Direct_Cb", eolian_type::callback_, {"Eio.h"}},
- {"Emodel *", eolian_type::simple_, false, false, "emodel", {"Emodel.hh"}},
- {"Eo *", eolian_type::simple_, false, true, "efl::eo::base", {"eo_base.hh"}},
- {"Eo *", eolian_type::simple_, false, false, "efl::eo::base", {"eo_base.hh"}},
+ {"Emodel *", eolian_type::simple_, false, false, true, "::emodel", {"Emodel.hh"}},
+ {"Eo *", eolian_type::simple_, false, true, true, "::efl::eo::concrete", {"eo_concrete.hh"}},
+ {"Eo *", eolian_type::simple_, false, false, true, "::efl::eo::concrete", {"eo_concrete.hh"}},
//{"Evas_Object_Box_Layout", eolian_type::callback_, {"Evas.h"}},
- {"Evas_Object *", eolian_type::simple_, false, false, "evas::object", {"canvas/evas_object.eo.hh"}},
- {"char *", eolian_type::simple_, false, true, "std::unique_ptr<char*>", {"memory"}},
- {"const Eina_Inlist *", eolian_type::complex_, false, false, "efl::eina::range_inlist", {"eina-cxx/eina_inlist.hh"}},
- {"const Eina_List *", eolian_type::complex_, false, false, "efl::eina::range_list", {"eina-cxx/eina_ptrlist.hh"}},
- {"const char *", eolian_type::simple_, false, false, "std::string", {"string"}},
+ {"Evas_Object *", eolian_type::simple_, false, false, true, "::evas::object", {"canvas/evas_object.eo.hh"}},
+ {"char *", eolian_type::simple_, false, true, true, "std::unique_ptr<char*>", {"memory"}},
+ {"const Eina_Inlist *", eolian_type::complex_, false, false, true, "::efl::eina::range_inlist", {"eina-cxx/eina_inlist.hh"}},
+ {"const Eina_List *", eolian_type::complex_, false, false, true, "::efl::eina::range_list", {"eina-cxx/eina_ptrlist.hh"}},
+ {"const char *", eolian_type::simple_, false, false, true, "std::string", {"string"}},
};
}
#include <Eina.h>
#include <eina_error.hh>
#include <eina_throw.hh>
-#include <eina_eo_base_fwd.hh>
+#include <eina_eo_concrete_fwd.hh>
#include <memory>
#include <iterator>
struct accessor;
template <typename T>
-struct accessor<T, typename std::enable_if< ! std::is_base_of<efl::eo::base, T>::value, T>::type>
+struct accessor<T, typename std::enable_if< ! std::is_base_of<::efl::eo::concrete, T>::value, T>::type>
: accessor_common_base<T>
{
typedef accessor_common_base<T> _base_type;
};
template <typename T>
-struct accessor<T, typename std::enable_if<std::is_base_of<efl::eo::base, T>::value, T>::type>
+struct accessor<T, typename std::enable_if<std::is_base_of<::efl::eo::concrete, T>::value, T>::type>
: accessor_common_base<T>
{
typedef accessor_common_base<T> _base_type;
* Random access iterator for <tt>eina::accessor</tt>.
*/
template <typename T>
-struct accessor_iterator<T, typename std::enable_if< ! std::is_base_of<efl::eo::base, T>::value, T>::type>
+struct accessor_iterator<T, typename std::enable_if< ! std::is_base_of<::efl::eo::concrete, T>::value, T>::type>
{
typedef T value_type; /**< Type of the elements. */
typedef value_type* pointer; /**< Pointer to element type. */
};
/**
- * Specialization for all data types that are not derivated from efl::eo::base.
+ * Specialization for all data types that are not derivated from efl::eo::concrete.
*/
template <typename T>
-struct accessor_iterator<T, typename std::enable_if<std::is_base_of<efl::eo::base, T>::value, T>::type>
+struct accessor_iterator<T, typename std::enable_if<std::is_base_of<::efl::eo::concrete, T>::value, T>::type>
{
typedef T value_type; /**< Type of the elements. */
typedef value_type* pointer; /**< Pointer to element type. */
#include <Eo.h>
#include <eina_ptrarray.hh>
-#include <eina_eo_base_fwd.hh>
+#include <eina_eo_concrete_fwd.hh>
#include <iostream>
};
template <typename T, typename CloneAllocator>
-class array<T, CloneAllocator, typename std::enable_if<std::is_base_of<efl::eo::base, T>::value>::type>
+class array<T, CloneAllocator, typename std::enable_if<std::is_base_of<::efl::eo::concrete, T>::value>::type>
: ptr_array<Eo, typename std::conditional
<std::is_same<CloneAllocator, default_clone_allocator_placeholder>::value
, eo_clone_allocator, CloneAllocator>::type>
+++ /dev/null
-#ifndef EINA_EO_BASE_FWD_HH
-#define EINA_EO_BASE_FWD_HH
-
-#include <Eo.h>
-#include <type_traits>
-
-namespace efl { namespace eo {
-
-struct base;
-
-} }
-
-namespace std {
-template <>
-struct is_base_of< ::efl::eo::base, ::Eo > : std::false_type {};
-template <>
-struct is_base_of< ::efl::eo::base, const ::Eo > : std::false_type {};
-template <>
-struct is_base_of< ::efl::eo::base, volatile ::Eo > : std::false_type {};
-template <>
-struct is_base_of< ::efl::eo::base, const volatile ::Eo > : std::false_type {};
-
-template <>
-struct is_base_of< const ::efl::eo::base, ::Eo > : std::false_type {};
-template <>
-struct is_base_of< const ::efl::eo::base, const ::Eo > : std::false_type {};
-template <>
-struct is_base_of< const ::efl::eo::base, volatile ::Eo > : std::false_type {};
-template <>
-struct is_base_of< const ::efl::eo::base, const volatile ::Eo > : std::false_type {};
-}
-
-#endif
--- /dev/null
+#ifndef EINA_EO_CONCRETE_FWD_HH
+#define EINA_EO_CONCRETE_FWD_HH
+
+#include <Eo.h>
+#include <type_traits>
+
+namespace efl { namespace eo {
+
+struct concrete;
+
+} }
+
+namespace std {
+template <>
+struct is_base_of< ::efl::eo::concrete, ::Eo > : std::false_type {};
+template <>
+struct is_base_of< ::efl::eo::concrete, const ::Eo > : std::false_type {};
+template <>
+struct is_base_of< ::efl::eo::concrete, volatile ::Eo > : std::false_type {};
+template <>
+struct is_base_of< ::efl::eo::concrete, const volatile ::Eo > : std::false_type {};
+
+template <>
+struct is_base_of< const ::efl::eo::concrete, ::Eo > : std::false_type {};
+template <>
+struct is_base_of< const ::efl::eo::concrete, const ::Eo > : std::false_type {};
+template <>
+struct is_base_of< const ::efl::eo::concrete, volatile ::Eo > : std::false_type {};
+template <>
+struct is_base_of< const ::efl::eo::concrete, const volatile ::Eo > : std::false_type {};
+}
+
+#endif
};
template <typename T, typename CloneAllocator>
-class list<T, CloneAllocator, typename std::enable_if<std::is_base_of<efl::eo::base, T>::value>::type>
+class list<T, CloneAllocator, typename std::enable_if<std::is_base_of<::efl::eo::concrete, T>::value>::type>
: ptr_list<Eo, typename std::conditional
<std::is_same<CloneAllocator, default_clone_allocator_placeholder>::value
, eo_clone_allocator, CloneAllocator>::type>
};
template <typename T>
-class range_list<T, typename std::enable_if<std::is_base_of<efl::eo::base, T>::value>::type>
+class range_list<T, typename std::enable_if<std::is_base_of<::efl::eo::concrete, T>::value>::type>
: range_ptr_list<typename std::conditional<std::is_const<T>::value, Eo const, Eo>::type>
{
typedef range_ptr_list<typename std::conditional<std::is_const<T>::value, Eo const, Eo>::type> _base_type;
#include <eina_lists_auxiliary.hh>
#include <eina_type_traits.hh>
#include <eina_accessor.hh>
-#include <eina_eo_base_fwd.hh>
+#include <eina_eo_concrete_fwd.hh>
#include <eina_iterator.hh>
#include <eina_throw.hh>
#ifndef EFL_CXX_EO_HH
#define EFL_CXX_EO_HH
-#include <eo_base.hh>
+#include <eo_concrete.hh>
#include <eo_init.hh>
#include <eo_wref.hh>
#include <eo_inherit.hh>
-
///
-/// @file eo_base.hh
+/// @file eo_concrete.hh
///
-#ifndef EFL_CXX_EO_BASE_HH
-#define EFL_CXX_EO_BASE_HH
+#ifndef EFL_CXX_EO_CONCRETE_HH
+#define EFL_CXX_EO_CONCRETE_HH
#include <cassert>
#include <stdexcept>
/// @addtogroup Efl_Cxx_API
/// @{
-/// @brief A binding to the <em>EO Base Class</em>.
+/// @brief Creates concrete versions for <em>Eo</em> wrappers.
///
-/// This class implements C++ wrappers to all the <em>EO Base</em>
-/// operations.
+/// This class creates the concrete version of all C++ <em>Eo</em> wrappers.
+/// It holds the Eo pointer that is used on all operations and provides some
+/// functions for manipulating it.
///
-struct base
+struct concrete
{
/// @brief Class constructor.
///
/// @param eo The <em>EO Object</em>.
///
- /// efl::eo::base constructors semantics are that of stealing the
+ /// efl::eo::concrete constructors semantics are that of stealing the
/// <em>EO Object</em> lifecycle management. Its constructors do not
/// increment the <em>EO</em> reference counter but the destructors
/// do decrement.
///
- explicit base(Eo* eo) : _eo_raw(eo)
+ explicit concrete(Eo* eo) : _eo_raw(eo)
{
}
/// @brief Class destructor.
///
- ~base()
+ ~concrete()
{
if(_eo_raw)
detail::unref(_eo_raw);
}
- base(base const& other)
+ concrete(concrete const& other)
{
if(other._eo_raw)
_eo_raw = detail::ref(other._eo_raw);
}
- base(base&& other)
+ concrete(concrete&& other)
{
if(_eo_raw) detail::unref(_eo_raw);
_eo_raw = other._eo_raw;
/// @brief Assignment operator.
///
- base& operator=(base const& other)
+ concrete& operator=(concrete const& other)
{
if(_eo_raw)
{
return *this;
}
- base& operator=(base&& other)
+ concrete& operator=(concrete&& other)
{
if(_eo_raw)
{
///
Eo* _eo_ptr() const { return _eo_raw; }
- /// @brief Releases the reference from this wrapper object and
+ /// @brief Releases the reference from this concrete object and
/// return the pointer to the <em>EO Object</em> stored in this
/// instance.
///
///
/// @param parent The new parent.
///
- void parent_set(base parent)
+ void parent_set(concrete parent)
{
detail::parent_set(_eo_raw, parent._eo_ptr());
}
/// @brief Get the parent of this object.
///
- /// @return An @ref efl::eo::base instance that binds the parent
+ /// @return An @ref efl::eo::concrete instance that binds the parent
/// object. Returns NULL if there is no parent.
///
- eina::optional<base> parent_get()
+ eina::optional<concrete> parent_get()
{
Eo *r = detail::parent_get(_eo_raw);
if(!r) return nullptr;
else
{
detail::ref(r); // XXX eo_parent_get does not call eo_ref so we may.
- return base(r);
+ return concrete(r);
}
}
- /// @brief Set generic data to object.
- ///
- /// @param key The key associated with the data.
- /// @param data The data to set.
- /// @param free_func A pointer to the function that frees the
- /// data. @c (::eo_key_data_free_func*)0 is valid.
- ///
- void base_data_set(const char *key, const void *data, ::eo_key_data_free_func func)
- {
- detail::base_data_set(_eo_raw, key, data, func);
- }
-
- /// @brief Get generic data from object.
- ///
- /// @param key The key associated with desired data.
- /// @return A void pointer to the data.
- ///
- void* base_data_get(const char *key)
- {
- return detail::base_data_get(_eo_raw, key);
- }
-
- /// @brief Delete generic data from object.
- ///
- /// @param key The key associated with the data.
- ///
- void base_data_del(const char *key)
- {
- detail::base_data_del(_eo_raw, key);
- }
-
- /// @brief Freeze any event directed to this object.
- ///
- /// Prevents event callbacks from being called for this object.
- ///
- void event_freeze()
- {
- detail::event_freeze(_eo_raw);
- }
-
- /// @brief Thaw the events of this object.
- ///
- /// Let event callbacks be called for this object.
- ///
- void event_thaw()
- {
- detail::event_thaw(_eo_raw);
- }
-
- /// @brief Get the event freeze count for this object.
- ///
- /// @return The event freeze count for this object.
- ///
- int event_freeze_get()
- {
- return detail::event_freeze_get(_eo_raw);
- }
-
/// @brief Get debug information of this object.
///
/// @return The root node of the debug information tree.
}
protected:
Eo* _eo_raw; ///< The opaque <em>EO Object</em>.
-
};
-inline bool operator==(base const& lhs, base const& rhs)
+inline bool operator==(concrete const& lhs, concrete const& rhs)
{
return lhs._eo_ptr() == rhs._eo_ptr();
}
-inline bool operator!=(base const& lhs, base const& rhs)
+inline bool operator!=(concrete const& lhs, concrete const& rhs)
{
return !(lhs == rhs);
}
struct extension_inheritance;
template<>
-struct extension_inheritance<base>
+struct extension_inheritance<concrete>
{
template <typename T>
struct type
{
- operator base() const
+ operator concrete() const
{
- return base(eo_ref(static_cast<T const*>(this)->_eo_ptr()));
+ return concrete(eo_ref(static_cast<T const*>(this)->_eo_ptr()));
}
};
}
///
-/// @brief Type used to hold the parent passed to base Eo C++
+/// @brief Type used to hold the parent passed to concrete Eo C++
/// constructors.
///
struct parent_type
///
/// @brief The expression type declaring the assignment operator used
-/// in the parent argument of the base Eo C++ class.
+/// in the parent argument of the concrete Eo C++ class.
///
struct parent_expr
{
- parent_type operator=(efl::eo::base const& parent) const
+ parent_type operator=(efl::eo::concrete const& parent) const
{
return { parent._eo_ptr() };
}
} } // namespace efl { namespace eo {
-#endif // EFL_CXX_EO_BASE_HH
+#endif // EFL_CXX_EO_CONCRETE_HH
}
template <typename T>
-T to_c(T const& v, typename std::enable_if<!std::is_convertible<T*, efl::eo::base*>::value>::type* = 0)
+T to_c(T const& v, typename std::enable_if<!std::is_convertible<T*, ::efl::eo::concrete*>::value>::type* = 0)
{
return v;
}
template <typename T>
-Eo* to_c(T const& v, typename std::enable_if<std::is_convertible<T*, efl::eo::base*>::value>::type* = 0)
+Eo* to_c(T const& v, typename std::enable_if<std::is_convertible<T*, ::efl::eo::concrete*>::value>::type* = 0)
{
return v._eo_ptr();
}
template <typename T>
-Eo** to_c(T* v, typename std::enable_if<std::is_convertible<T*, efl::eo::base*>::value>::type* = 0)
+Eo** to_c(T* v, typename std::enable_if<std::is_convertible<T*, ::efl::eo::concrete*>::value>::type* = 0)
{
static_assert(sizeof(T) == sizeof(Eo*), "");
return static_cast<Eo**>(static_cast<void*>(v));
template <typename T>
struct traits
- <T, typename std::enable_if<std::is_base_of<efl::eo::base, T>::value>::type>
+ <T, typename std::enable_if<std::is_base_of<::efl::eo::concrete, T>::value>::type>
{
typedef Eo* type;
};
template <typename T, typename ...Args>
T
to_cxx(Eo const* x, std::tuple<std::false_type, Args...>, tag< T >
- , typename std::enable_if<std::is_base_of<efl::eo::base, T>::value>* = 0)
+ , typename std::enable_if<std::is_base_of<::efl::eo::concrete, T>::value>* = 0)
{
// Workaround for erroneous constness
return T{ ::eo_ref(const_cast<Eo*>(x))};
template <typename T, typename ...Args>
T
to_cxx(Eo const* x, std::tuple<std::true_type, Args...>, tag< T >
- , typename std::enable_if<std::is_base_of<efl::eo::base, T>::value>* = 0)
+ , typename std::enable_if<std::is_base_of<::efl::eo::concrete, T>::value>* = 0)
{
// Workaround for erroneous constness
return T{const_cast<Eo*>(x)};
///
/// The derived class @p D will inherit all EO operations and event
/// callbacks from the parent class @p P, as well as from the <c>Base
-/// Class</c> (@ref efl::eo::base) since every EO C++ Class must
+/// Class</c> (@ref efl::eo::concrete) since every EO C++ Class must
/// inherit from it.
///
/// efl::eo::inherit makes use of meta-template elements to build (in
struct eo_function;
struct eo_event;
-typedef std::vector<std::string> extensions_container_type;
+typedef std::vector<std::string> parents_container_type;
typedef std::vector<std::string> includes_container_type;
typedef std::vector<eo_constructor> constructors_container_type;
typedef std::vector<eo_function> functions_container_type;
, category(unknown_)
, is_const(false)
, is_own(false)
- , is_out(false)
+ , is_class(false)
, binding()
, includes()
{}
category_type category_,
bool is_const_,
bool is_own_,
+ bool is_class_,
std::string binding_,
includes_container_type includes_)
: native(native_)
, category(category_)
, is_const(is_const_)
, is_own(is_own_)
- , is_out(false)
+ , is_class(is_class_)
, binding(binding_)
, includes(includes_)
{
eolian_type(std::string native_,
category_type category_,
includes_container_type const& includes_)
- : eolian_type(native_, category_, false, false, "", includes_)
+ : eolian_type(native_, category_, false, false, false, "", includes_)
{
assert(category == callback_);
}
category_type category;
bool is_const;
bool is_own;
- bool is_out;
+ bool is_class;
std::string binding;
includes_container_type includes;
};
-typedef std::vector<eolian_type> eolian_type_instance;
+typedef std::vector<eolian_type> eolian_type_container;
+
+struct eolian_type_instance
+{
+ eolian_type_instance()
+ : is_out(false)
+ , parts()
+ {}
+
+ eolian_type_instance(std::initializer_list<eolian_type> il,
+ bool is_out_ = false)
+ : is_out(is_out_)
+ , parts(il)
+ {}
+
+ explicit eolian_type_instance(std::size_t size)
+ : is_out(false)
+ , parts(size)
+ {}
+
+ bool empty() const { return parts.empty(); }
+ std::size_t size() const { return parts.size(); }
+
+ eolian_type& front() { return parts.front(); }
+ eolian_type const& front() const { return parts.front(); }
+
+ bool is_out;
+ eolian_type_container parts;
+};
const efl::eolian::eolian_type
-void_type { "void", efl::eolian::eolian_type::simple_, false, false, "", {} };
+void_type { "void", efl::eolian::eolian_type::simple_, false, false, false, "", {} };
inline bool
type_is_void(eolian_type_instance const& type)
{
- return type.empty() || type[0].native.compare("void") == 0;
+ return type.empty() || type.front().native.compare("void") == 0;
}
inline bool
}
inline bool
-type_is_out(eolian_type const& type)
+type_is_out(eolian_type_instance const& type)
{
return type.is_out;
}
inline bool
-type_is_out(eolian_type_instance const& type)
+type_is_class(eolian_type const& type)
+{
+ return type.is_class;
+}
+
+inline bool
+type_is_class(eolian_type_instance const& type)
{
assert(!type.empty());
- return type_is_out(type.front());
+ return type_is_class(type.front());
}
inline eolian_type
eolian_type native(type);
native.binding.clear();
native.category = eolian_type::simple_;
+ native.is_class = false;
return native;
}
eo_class_type type;
std::string name;
std::string eo_name;
- std::string parent;
- extensions_container_type extensions;
+ parents_container_type parents;
constructors_container_type constructors;
functions_container_type functions;
events_container_type events;
inline bool
function_is_void(eo_function const& func)
{
- return func.ret.empty() || func.ret[0].native.compare("void") == 0;
+ return func.ret.empty() || func.ret.front().native.compare("void") == 0;
}
inline bool
{
// if (type.empty() || (*type.rbegin()).category == eolian_type::complex_)
// return false;
- for (auto rit = type.rbegin(), last = type.rend(); rit != last; ++rit)
+ for (auto rit = type.parts.rbegin(), last = type.parts.rend(); rit != last; ++rit)
{
if ((*rit).binding.empty() && (*rit).category == eolian_type::complex_)
return false;
#include "tab.hh"
#include "comment.hh"
#include "parameters_generator.hh"
+#include "namespace_generator.hh"
namespace efl { namespace eolian { namespace grammar {
return out;
}
-struct class_extensions
-{
- eo_class const& _cls;
- class_extensions(eo_class const& cls)
- : _cls(cls)
- {}
-};
-
-inline std::ostream&
-operator<<(std::ostream& out, class_extensions const& x)
-{
- eo_class const& cls = x._cls;
- extensions_container_type::const_iterator it, first = cls.extensions.begin();
- extensions_container_type::const_iterator last = cls.extensions.end();
- for (it = first; it != last; ++it)
- {
- if (it != first) out << ",\n";
- out << tab(2)
- << "efl::eo::detail::extension_inheritance<"
- << *it << ">::template type< ::";
- if(!cls.name_space.empty())
- out << cls.name_space << "::";
- out << cls.name << ">";
- }
- out << endl;
- return out;
-}
-
struct class_inheritance
{
eo_class const& _cls;
{
eo_class const& cls = x._cls;
- out << class_name(cls.parent);
- if (cls.extensions.size() > 0)
+ parents_container_type::const_iterator it,
+ first = cls.parents.cbegin(),
+ last = cls.parents.cend();
+ for (it = first; it != last; ++it)
{
- out << "," << endl << class_extensions(cls);
+ out << tab(2) << (it == first ? ": " : ", ")
+ << "::" << abstract_namespace << "::" << *it << endl;
}
- out << endl;
return out;
}
return out;
}
-struct functions_constructor_methods
+struct constructor_method_function_declarations
{
eo_class const& _cls;
- functions_constructor_methods(eo_class const& cls) : _cls(cls) {}
+ constructor_method_function_declarations(eo_class const& cls) : _cls(cls) {}
};
inline std::ostream&
-operator<<(std::ostream& out, functions_constructor_methods const& x)
+operator<<(std::ostream& out, constructor_method_function_declarations const& x)
{
constructors_container_type::const_iterator it,
first = x._cls.constructors.cbegin(),
{
eo_constructor const& c = *it;
- out << comment(c.comment, 1)
+ // "eo_constructor" is already called in the eo_add_ref macro (used in
+ // _ctors_call).
+ // Creating a function with this name yields an error in the eo_add_ref
+ // macro expansion, because "eo_constructor" will refers to the class
+ // function instead of the Eo.Base function which is intended.
+ if (c.name == "eo_constructor")
+ {
+ continue;
+ }
+
+ out << comment(c.comment, 0)
<< template_parameters_declaration(c.params, 1)
<< tab(1) << constructor_functor_type_decl(c) << " " << c.name << "("
- << parameters_declaration(c.params) << ")" << endl
- << tab(1) << "{" << endl
- << tab(2) << "return " << constructor_functor_type_decl(c) << "("
+ << parameters_declaration(c.params) << ") const;" << endl << endl;
+ }
+
+ return out;
+}
+
+struct constructor_method_function_definitions
+{
+ eo_class const& _cls;
+ constructor_method_function_definitions(eo_class const& cls) : _cls(cls) {}
+};
+
+inline std::ostream&
+operator<<(std::ostream& out, constructor_method_function_definitions const& x)
+{
+ constructors_container_type::const_iterator it,
+ first = x._cls.constructors.cbegin(),
+ last = x._cls.constructors.cend();
+ for (it = first; it != last; ++it)
+ {
+ eo_constructor const& c = *it;
+
+ // Same explanation as the one in constructor_method_function_declarations
+ if (c.name == "eo_constructor")
+ {
+ continue;
+ }
+
+ out << template_parameters_declaration(c.params, 0)
+ << "inline " << abstract_full_name(x._cls)
+ << "::" << constructor_functor_type_decl(c) << " "
+ << abstract_full_name(x._cls, false) << "::" << c.name << "("
+ << parameters_declaration(c.params) << ") const" << endl
+ << "{" << endl
+ << tab(1) << "return " << constructor_functor_type_decl(c) << "("
<< parameters_forward(c.params) << ");" << endl
- << tab(1) << "}" << endl << endl;
+ << "}" << endl << endl;
}
return out;
inline std::ostream&
operator<<(std::ostream& out, constructor_with_constructor_methods const& x)
{
- //
- // TODO Require constructor methods of all base classes ?
- //
-
unsigned cb_count = 0;
constructors_container_type::const_iterator it,
}
assert(cb_idx == cb_count);
}
- out << "efl::eo::parent_type _p = (efl::eo::parent = nullptr))" << endl
+ out << "::efl::eo::parent_type _p = (::efl::eo::parent = nullptr))" << endl
<< tab(2) << ": " << x._cls.name << "(_ctors_call(";
for (it = first; it != last; ++it)
{
out << comment(doc, 1)
<< tab(1)
<< "explicit " << x._cls.name << "(Eo* eo)" << endl
- << tab(2) << ": " << class_name(x._cls.parent) << "(eo)" << endl
+ << tab(2) << ": ::efl::eo::concrete(eo)" << endl
<< tab(1) << "{}" << endl << endl;
out << comment(
)
<< tab(1)
<< "explicit " << x._cls.name << "(std::nullptr_t)" << endl
- << tab(2) << ": " << class_name(x._cls.parent) << "(nullptr)" << endl
+ << tab(2) << ": ::efl::eo::concrete(nullptr)" << endl
<< tab(1) << "{}" << endl << endl;
return out;
}
out << comment(doc, 1)
<< tab(1)
<< x._cls.name << "(" << x._cls.name << " const& other)" << endl
- << tab(2) << ": " << class_name(x._cls.parent)
+ << tab(2) << ": " << x._cls.name
<< "(eo_ref(other._eo_ptr()))" << endl
<< tab(1) << "{}" << endl << endl;
return out;
}
assert(cb_idx == cb_count);
- out << "efl::eo::parent_type _p)" << endl
+ out << "::efl::eo::parent_type _p)" << endl
<< tab(1) << "{" << endl
<< tab(2) << "Eo* _ret_eo = eo_add_ref(" << x._cls.eo_name << ", _p._eo_raw, ";
for (it = first; it != last; ++it)
d.out << tab(2)
<< "eo_do(_ret_eo," << endl
<< tab(3) << "eo_event_callback_add(EO_EV_DEL, "
- << "&efl::eolian::free_callback_calback<F" << cb_idx++
+ << "&::efl::eolian::free_callback_calback<F" << cb_idx++
<< ">, _c" << (it-first) << "." << callback_tmp(d.name)
<< "));" << endl;
})
#include <iosfwd>
-#include "eo_types.hh"
+#include "type_generator.hh"
#include "tab.hh"
#include "comment.hh"
<< tab(1) << "{" << endl
<< tab(2) << "typedef typename std::remove_reference<F>::type function_type;" << endl
<< tab(2) << "::std::unique_ptr<function_type> f ( new function_type(std::move(callback_)) );" << endl
- << tab(2) << "eo_do(" << add_cast_to_t(x._add_cast_to_t) << "_eo_ptr()," << endl
+ << tab(2) << "eo_do(" << add_cast_to_t(x._add_cast_to_t) << "_concrete_eo_ptr()," << endl
<< tab(4) << "eo_event_callback_priority_add" << endl
<< tab(4) << "(" << x._event.eo_name << ", priority_," << endl
- << tab(4) << "&efl::eo::_detail::event_callback<" << x._cls.name_space << "::" << x._cls.name << ", function_type>, f.get()));" << endl
+ << tab(4) << "&::efl::eo::_detail::event_callback<" << full_name(x._cls) << ", function_type>, f.get()));" << endl
<< tab(2) << "return ::efl::eo::make_signal_connection" << endl
<< tab(3) << "(f, " << add_cast_to_t(x._add_cast_to_t)
- << "_eo_ptr(), &efl::eo::_detail::event_callback<"
- << x._cls.name_space << "::" << x._cls.name << ", function_type>," << endl
+ << "_concrete_eo_ptr(), &::efl::eo::_detail::event_callback<"
+ << full_name(x._cls) << ", function_type>," << endl
<< tab(3) << x._event.eo_name << " );" << endl
<< tab(1) << "}" << endl;
return out;
<< tab(1) << "void" << endl
<< tab(1) << "callback_" << x._event.name << "_call(T* info)" << endl
<< tab(1) << "{" << endl
- << tab(2) << "eo_do(" << add_cast_to_t(x._add_cast_to_t) << "_eo_ptr(), eo_event_callback_call" << endl
+ << tab(2) << "eo_do(" << add_cast_to_t(x._add_cast_to_t) << "_concrete_eo_ptr(), eo_event_callback_call" << endl
<< tab(4) << "(" << x._event.eo_name << ", info));" << endl
<< tab(1) << "}" << endl;
return out;
out << event_callback_add(e, x._cls, x._add_cast_to_t) << endl
<< event_callback_call(e, x._add_cast_to_t);
}
+ out << endl;
return out;
}
#include "comment.hh"
#include "parameters_generator.hh"
#include "type_generator.hh"
+#include "namespace_generator.hh"
namespace efl { namespace eolian { namespace grammar {
<< "(" << parameters_forward_to_c(x._func.params) << ")";
}
-struct function
+struct function_declaration
{
+ eo_class const& _cls;
eo_function const& _func;
- function(eo_function const& func) : _func(func) {}
+ function_declaration(eo_class const& cls, eo_function const& func)
+ : _cls(cls), _func(func)
+ {}
};
inline std::ostream&
-operator<<(std::ostream& out, function const& x)
+operator<<(std::ostream& out, function_declaration const& x)
{
eo_function const& func = x._func;
- out << comment(x._func.comment, 1);
- out << template_parameters_declaration(func.params, 1);
+ out << comment(x._func.comment, 1)
+ << template_parameters_declaration(func.params, 1)
+ << tab(1);
- if (function_is_static(func))
- out << tab(1) << "static ";
+ bool is_static = function_is_static(func);
+ if (is_static)
+ out << "static ";
- out << tab(1)
- << reinterpret_type(func.ret) << " " << func.name << "("
+ out << reinterpret_type(func.ret) << " " << func.name << "("
<< parameters_declaration(func.params)
- << ") const" << endl
- << tab(1) << "{" << endl;
+ << (is_static ? ");" : ") const;") << endl << endl;
+
+ return out;
+}
+
+struct function_definition
+{
+ eo_class const& _cls;
+ eo_function const& _func;
+ function_definition(eo_class const& cls, eo_function const& func)
+ : _cls(cls), _func(func)
+ {}
+};
+
+inline std::ostream&
+operator<<(std::ostream& out, function_definition const& x)
+{
+ eo_function const& func = x._func;
+
+ bool is_static = function_is_static(func);
+
+ out << template_parameters_declaration(func.params, 0)
+ << "inline " << reinterpret_type(func.ret) << " "
+ << abstract_full_name(x._cls, false) << "::" << func.name << "("
+ << parameters_declaration(func.params)
+ << (is_static ? ")" : ") const") << endl
+ << "{" << endl;
if (!function_is_void(func))
- out << tab(2)
+ out << tab(1)
<< func.ret.front().native << " _tmp_ret;" << endl;
- out << callbacks_heap_alloc("_eo_ptr()", func.params, 2);
+ if (!is_static)
+ out << callbacks_heap_alloc("_concrete_eo_ptr()", func.params, 1);
+
+ // TODO : register free callback for static methods
- out << tab(2)
- << "eo_do(_eo_ptr(), " << function_call(x._func) << ");" << endl;
+ out << tab(1) << "eo_do("
+ << (is_static ? "_eo_class(), " : "_concrete_eo_ptr(), ")
+ << function_call(x._func) << ");" << endl;
if (!function_is_void(func))
- out << tab(2) << "return " << to_cxx(func.ret, "_tmp_ret") << ";" << endl;
+ out << tab(1) << "return " << to_cxx(func.ret, "_tmp_ret") << ";" << endl;
+
+ out << "}" << endl << endl;
+ return out;
+}
+
+struct function_declarations
+{
+ eo_class const& _cls;
+ function_declarations(eo_class const& cls)
+ : _cls(cls)
+ {}
+};
- out << tab(1) << "}" << endl;
+inline std::ostream&
+operator<<(std::ostream& out, function_declarations const& x)
+{
+ for (eo_function const& f : x._cls.functions)
+ {
+ out << function_declaration(x._cls, f) << endl;
+ }
return out;
}
-struct functions
+struct function_definitions
{
- functions_container_type const& _funcs;
- functions(functions_container_type const& funcs) : _funcs(funcs) {}
+ eo_class const& _cls;
+ function_definitions(eo_class const& cls)
+ : _cls(cls)
+ {}
};
inline std::ostream&
-operator<<(std::ostream& out, functions const& x)
+operator<<(std::ostream& out, function_definitions const& x)
{
- functions_container_type::const_iterator it,
- first = x._funcs.begin(),
- last = x._funcs.end();
- for (it = first; it != last; it++)
+ for (eo_function const& f : x._cls.functions)
{
- out << function(*it) << endl;
+ out << function_definition(x._cls, f) << endl;
}
return out;
}
#include "eo_types.hh"
#include "tab.hh"
#include "comment.hh"
+#include "namespace_generator.hh"
#include "eo_class_constructors_generator.hh"
#include "eo_class_functions_generator.hh"
#include "eo_class_events_generator.hh"
return out;
}
+struct concrete_eo_ptr_getter
+{
+ eo_class const& _cls;
+ concrete_eo_ptr_getter(eo_class const& cls) : _cls(cls) {}
+};
+
+inline std::ostream&
+operator<<(std::ostream& out, concrete_eo_ptr_getter const&)
+{
+ out << tab(1) << "Eo* _concrete_eo_ptr() const" << endl
+ << tab(1) << "{" << endl
+ << tab(2) << "return static_cast<::efl::eo::concrete const*>(static_cast<void const*>(this))->_eo_ptr();" << endl
+ << tab(1) << "}" << endl << endl;
+ return out;
+}
+
+struct class_implicit_conversion_declaration
+{
+ eo_class const& _cls;
+ class_implicit_conversion_declaration(eo_class const& cls) : _cls(cls) {}
+};
+
+inline std::ostream&
+operator<<(std::ostream& out, class_implicit_conversion_declaration const& x)
+{
+ out << tab(1) << "operator " << full_name(x._cls) << "() const;" << endl;
+ out << tab(1) << "operator " << full_name(x._cls) << "&();" << endl;
+ out << tab(1) << "operator " << full_name(x._cls) << " const&() const;" << endl;
+ return out << endl;
+}
+
+struct class_implicit_conversion_definition
+{
+ eo_class const& _cls;
+ class_implicit_conversion_definition(eo_class const& cls) : _cls(cls) {}
+};
+
+inline std::ostream&
+operator<<(std::ostream& out, class_implicit_conversion_definition const& x)
+{
+ out << "inline " << abstract_full_name(x._cls) << "::operator "
+ << full_name(x._cls) << "() const" << endl
+ << "{" << endl
+ << tab(1) << "return *static_cast<" << full_name(x._cls)
+ << " const*>(static_cast<void const*>(this));" << endl
+ << "}" << endl << endl;
+
+ out << "inline " << abstract_full_name(x._cls) << "::operator "
+ << full_name(x._cls) << "&()" << endl
+ << "{" << endl
+ << tab(1) << "return *static_cast<" << full_name(x._cls)
+ << "*>(static_cast<void*>(this));" << endl
+ << "}" << endl << endl;
+
+ out << "inline " << abstract_full_name(x._cls) << "::operator "
+ << full_name(x._cls) << " const&() const" << endl
+ << "{" << endl
+ << tab(1) << "return *static_cast<" << full_name(x._cls)
+ << " const*>(static_cast<void const*>(this));" << endl
+ << "}" << endl << endl;
+
+ return out;
+}
+
inline void
eo_class_generator(std::ostream& out, eo_class const& cls)
{
- out << comment(cls.comment)
+ out << namespace_head(cls)
+ << "struct " << cls.name << ";" << endl << endl
+ << namespace_tail(cls)
+ << "namespace " << abstract_namespace << " {" << endl << endl
+ << namespace_head(cls)
+ << comment(cls.comment)
<< "struct " << cls.name << endl
- << tab(2) << ": " << class_inheritance(cls)
+ << class_inheritance(cls)
<< '{' << endl
<< functors_constructor_methods(cls)
- << functions_constructor_methods(cls)
+ << constructor_method_function_declarations(cls)
+ << function_declarations(cls)
+ << events(cls)
+ << eo_class_getter(cls)
+ << class_implicit_conversion_declaration(cls)
+ << "private:" << endl
+ << concrete_eo_ptr_getter(cls)
+ << "};" << endl << endl
+ << namespace_tail(cls)
+ << "}" << endl << endl
+ << namespace_head(cls)
+ << "struct " << cls.name << endl
+ << tab(2) << ": " << abstract_full_name(cls) << endl
+ << tab(2) << ", ::efl::eo::concrete" << endl
+ << '{' << endl
<< constructor_with_constructor_methods(cls)
<< constructor_eo(cls)
<< copy_constructor(cls)
<< destructor(cls)
- << functions(cls.functions)
- << events(cls)
- << eo_class_getter(cls)
<< "private:" << endl
<< function_call_constructor_methods(cls)
- << "};" << endl
- << "static_assert(sizeof(" << cls.name << ") == sizeof(Eo*), \"sizeof(" << cls.name << ") != sizeof(Eo*)\");" << endl
- << "static_assert(std::is_standard_layout<" << cls.name << ">::value, \"'" << cls.name << "' is not standard layout\");"
- << endl << endl;
+ << "};" << endl << endl
+ << "static_assert(sizeof(" << full_name(cls) << ") == sizeof(Eo*), \"\");" << endl
+ << "static_assert(std::is_standard_layout<" << full_name(cls) << ">::value, \"\");" << endl
+ << endl
+ << namespace_tail(cls)
+ << constructor_method_function_definitions(cls)
+ << function_definitions(cls)
+ << class_implicit_conversion_definition(cls);
}
} } } // namespace efl { namespace eolian { namespace grammar {
it != last; ++it)
for (auto it_p = (*it).params.begin(), last_p = (*it).params.end();
it_p != last_p; ++it_p)
- for (eolian_type const& subtype : (*it_p).type)
+ for (eolian_type const& subtype : (*it_p).type.parts)
for (std::string header : subtype.includes)
headers.insert(header);
it != last; ++it)
for (auto it_p = (*it).params.begin(), last_p = (*it).params.end();
it_p != last_p; ++it_p)
- for (eolian_type const& subtype : (*it_p).type)
+ for (eolian_type const& subtype : (*it_p).type.parts)
for (std::string header : subtype.includes)
headers.insert(header);
}
inline void
-namespace_head(std::ostream& out, eo_class const& cls)
-{
- if (cls.name_space != "")
- {
- std::string ns = cls.name_space;
- size_t pos = 0;
- while ((pos = ns.find("::")) != std::string::npos)
- {
- out << "namespace " << ns.substr(0, pos) << " { ";
- ns.erase(0, pos+2);
- }
- out << "namespace " << ns << " {" << endl << endl;
- }
-}
-
-inline void
-namespace_tail(std::ostream& out, eo_class const& cls)
-{
- if (cls.name_space != "")
- {
- std::string ns = cls.name_space;
- size_t pos = 0;
- while ((pos = ns.find("::")) != std::string::npos)
- {
- out << "} ";
- ns.erase(0, pos+2);
- }
- out << "} " << endl << endl;
- }
-}
-
-inline void
include_headers(std::ostream& out,
eo_class const& cls EINA_UNUSED,
eo_generator_options const& opts)
{
onceguard_head(out, cls);
include_headers(out, cls, opts);
- namespace_head(out, cls);
eo_class_generator(out, cls);
- namespace_tail(out, cls);
eo_inheritance_detail_generator(out, cls);
onceguard_tail(out, cls);
out << endl;
operator<<(std::ostream& out, inheritance_operations_description const& x)
{
out << "template <typename T>"
- << endl << "int initialize_operation_description(efl::eo::detail::tag<"
- << x._cls.name_space << "::" << x._cls.name << ">" << endl
+ << endl << "int initialize_operation_description(::efl::eo::detail::tag<"
+ << full_name(x._cls) << ">" << endl
<< tab(11)
<< ", Eo_Op_Description* ops)" << endl
<< "{" << endl
<< _ns_as_prefix(x._cls) << "_"
<< x._cls.name << "_" << func.name
<< "_wrapper(Eo* objid EINA_UNUSED, "
- << "efl::eo::detail::Inherit_Private_Data* self"
+ << "::efl::eo::detail::Inherit_Private_Data* self"
<< (func.params.size() ? ", " : "")
<< parameters_c_declaration(func.params)
<< ")" << endl
<< tab(2) << "}" << endl
<< tab(1) << "catch (...)" << endl
<< tab(2) << "{" << endl
- << tab(3) << "eina_error_set( efl::eina::unknown_error() );" << endl
+ << tab(3) << "eina_error_set( ::efl::eina::unknown_error() );" << endl
<< tab(2) << "}" << endl;
if (!function_is_void(func))
{
out << "template<>"
<< endl << "struct operation_description_class_size< "
- << x._cls.name_space << "::" << x._cls.name << " >" << endl
+ << full_name(x._cls) << " >" << endl
<< "{" << endl
<< tab(1) << "static const int value = "
<< x._cls.functions.size()
{
out << "template<>" << endl
<< "struct operations< "
- << x._cls.name_space << "::" << x._cls.name << " >" << endl
+ << full_name(x._cls) << " >" << endl
<< "{" << endl
<< tab(1) << "template <typename T>" << endl
<< tab(1) << "struct type" << endl
eo_constructor const& ctor = *it;
out << "inline void" << endl
<< "call_constructor(tag< "
- << x._cls.name_space << "::" << x._cls.name << " >" << endl
+ << full_name(x._cls) << " >" << endl
<< tab(5) << ", Eo* eo, Eo_Class const* cls EINA_UNUSED," << endl
<< tab(5) << "args_class<"
- << x._cls.name_space << "::" << x._cls.name
+ << full_name(x._cls)
<< ", ::std::tuple<"
<< parameters_types(ctor.params)
<< "> > const& args)" << endl
out << "inline void" << endl
<< "call_constructor(tag< "
- << x._cls.name_space << "::" << x._cls.name << " >" << endl
+ << full_name(x._cls) << " >" << endl
<< tab(5) << ", Eo* eo, Eo_Class const* cls EINA_UNUSED," << endl
<< tab(5) << "args_class<"
- << x._cls.name_space << "::" << x._cls.name
- << ", ::std::tuple<efl::eo::parent_type> > const& args)" << endl
+ << full_name(x._cls)
+ << ", ::std::tuple<::efl::eo::parent_type> > const& args)" << endl
<< "{" << endl
<< tab(1) << "eo_do_super(eo, cls, ::eo_constructor());" << endl
<< tab(1) << "eo_do(eo, ::eo_parent_set(args.get<0>()._eo_raw));" << endl
inline std::ostream&
operator<<(std::ostream& out, inheritance_extension const& x)
{
- std::string cls = x._cls.name_space + "::" + x._cls.name;
+ full_name const cls(x._cls);
out << "template<>" << endl
<< "struct extension_inheritance< "
<< cls << ">" << endl
operator<<(std::ostream& out, inheritance_eo_class_getter const& x)
{
out << "inline Eo_Class const* get_eo_class(tag<"
- << x._cls.name_space << "::" << x._cls.name << ">)" << endl
+ << full_name(x._cls) << ">)" << endl
<< "{" << endl
<< tab(1) << "return (" << x._cls.eo_name << ");" << endl
<< "}" << endl << endl;
--- /dev/null
+
+#ifndef EOLIAN_CXX_NAMESPACE_GENERATOR_HH
+#define EOLIAN_CXX_NAMESPACE_GENERATOR_HH
+
+#include "eo_types.hh"
+#include "tab.hh"
+
+namespace efl { namespace eolian { namespace grammar {
+
+struct abstract_namespace_type {};
+
+abstract_namespace_type const abstract_namespace = {};
+
+inline std::ostream&
+operator<<(std::ostream& out, abstract_namespace_type const&)
+{
+ return out << "eo_cxx";
+}
+
+struct namespace_head
+{
+ namespace_head(eo_class const& cls) : _cls(cls) {}
+ eo_class const& _cls;
+};
+
+inline std::ostream&
+operator<<(std::ostream& out, namespace_head const& x)
+{
+ if (x._cls.name_space != "")
+ {
+ std::string ns = x._cls.name_space;
+ size_t pos = 0;
+ while ((pos = ns.find("::")) != std::string::npos)
+ {
+ out << "namespace " << ns.substr(0, pos) << " { ";
+ ns.erase(0, pos+2);
+ }
+ out << "namespace " << ns << " {" << endl << endl;
+ }
+ return out;
+}
+
+struct namespace_tail
+{
+ namespace_tail(eo_class const& cls) : _cls(cls) {}
+ eo_class const& _cls;
+};
+
+inline std::ostream&
+operator<<(std::ostream& out, namespace_tail const& x)
+{
+ if (x._cls.name_space != "")
+ {
+ std::string ns = x._cls.name_space;
+ size_t pos = 0;
+ while ((pos = ns.find("::")) != std::string::npos)
+ {
+ out << "} ";
+ ns.erase(0, pos+2);
+ }
+ out << "}" << endl << endl;
+ }
+ return out;
+}
+
+} } } // namespace efl { namespace eolian { namespace grammar {
+
+#endif
operator<<(std::ostream& out, callback_parameter_free_ev_add const& x)
{
out << "eo_do(" << x._eo_raw_expr
- << ", eo_event_callback_add(EO_EV_DEL, &efl::eolian::free_callback_calback<"
+ << ", eo_event_callback_add(EO_EV_DEL, &::efl::eolian::free_callback_calback<"
<< parameter_no_ref_type(x._type, x._name) << ">, "
<< callback_tmp(x._name) << "));";
return out;
#include <iosfwd>
#include "eo_types.hh"
+#include "namespace_generator.hh"
namespace efl { namespace eolian { namespace grammar {
using std::endl;
+struct full_name
+{
+ eo_class const& _cls;
+ full_name(eo_class const& cls) : _cls(cls) {}
+};
+
+inline std::ostream&
+operator<<(std::ostream& out, full_name const& x)
+{
+ if(!x._cls.name_space.empty())
+ out << "::" << x._cls.name_space;
+ return out << "::" << x._cls.name;
+}
+
+struct abstract_full_name
+{
+ eo_class const& _cls;
+ bool _from_golbal;
+ abstract_full_name(eo_class const& cls, bool from_golbal = true)
+ : _cls(cls), _from_golbal(from_golbal) {}
+};
+
+inline std::ostream&
+operator<<(std::ostream& out, abstract_full_name const& x)
+{
+ if (x._from_golbal)
+ out << "::";
+ return out << abstract_namespace << full_name(x._cls);
+}
+
struct c_type
{
eolian_type_instance const& _list;
{
assert(x._list.size() > 0);
std::string res;
- for (auto rit = x._list.rbegin(), last = x._list.rend(); rit != last; ++rit)
+ for (auto rit = x._list.parts.rbegin(), last = x._list.parts.rend(); rit != last; ++rit)
{
res = /*type_is_binding(*rit) ? (*rit).binding :*/ (*rit).native;
}
struct reinterpret_type
{
- eolian_type_instance const& _list;
- reinterpret_type(eolian_type_instance const& list)
- : _list(list)
+ eolian_type_instance const& _type;
+ reinterpret_type(eolian_type_instance const& type)
+ : _type(type)
{}
};
inline std::ostream&
operator<<(std::ostream& out, efl::eolian::grammar::reinterpret_type const& x)
{
- assert(x._list.size() > 0);
+ assert(x._type.size() > 0);
std::string res;
- for (auto rit = x._list.rbegin(), last = x._list.rend(); rit != last; ++rit)
+ for (auto rit = x._type.parts.rbegin(), last = x._type.parts.rend(); rit != last; ++rit)
{
eolian_type const& t = *rit;
if (type_is_complex(t))
- res = t.binding + "< " + res + " >" + (t.is_out ? "*" : "");
+ res = t.binding + "< " + res + " >";
else
- res = type_is_binding(t) ? t.binding + (t.is_out ? "*" : "")
+ res = type_is_binding(t) ? t.binding
: t.native;
}
assert(!res.empty());
+
+ if (x._type.is_out && type_is_binding(x._type.front()))
+ res += "*";
+
return out << res;
}
operator<<(std::ostream& out, type_ownership const& x)
{
out << "std::tuple<";
- for (auto it=x._type.begin(), last=x._type.end(); it != last; ++it)
+ for (auto it=x._type.parts.begin(), last=x._type.parts.end(); it != last; ++it)
{
- if (it != x._type.begin())
+ if (it != x._type.parts.begin())
out << ", ";
out << ((*it).is_own ? "std::true_type" : "std::false_type");
}
{
if (type_is_binding(x._type))
{
- out << "efl::eolian::to_cxx<"
+ out << "::efl::eolian::to_cxx<"
<< reinterpret_type(x._type)
<< ">(" << x._varname
<< ", " << type_ownership(x._type) << ")";
operator<<(std::ostream& out, to_c const& x)
{
if (type_is_callback(x._type))
- out << "efl::eolian::get_callback<" << type_to_native_str(x._type)
+ out << "::efl::eolian::get_callback<" << type_to_native_str(x._type)
<< ", " << parameter_no_ref_type(x._type, x._varname) << " >()";
else if (type_is_complex(x._type) && type_is_binding(x._type))
- out << "efl::eolian::to_native<" << c_type(x._type) << ">(" << x._varname << ")";
+ out << "::efl::eolian::to_native<" << c_type(x._type) << ">(" << x._varname << ")";
else if (type_is_binding(x._type))
- out << "efl::eolian::to_c(" << x._varname << ")";
+ out << "::efl::eolian::to_c(" << x._varname << ")";
else
out << x._varname;
return out;
const Eo_Class *simple_class_get(void);
#define MY_CLASS simple_class_get()
-struct wrapper : efl::eo::base
+struct wrapper : efl::eo::concrete
{
explicit wrapper(Eo* o)
- : base(o) {}
+ : concrete(o) {}
};
START_TEST(eina_cxx_accessor_indexing)
const Eo_Class *simple_class_get(void);
#define MY_CLASS simple_class_get()
-struct wrapper : efl::eo::base
+struct wrapper : efl::eo::concrete
{
explicit wrapper(Eo* o)
- : base(o) {}
+ : concrete(o) {}
};
START_TEST(eina_cxx_ptrarray_push_back)
EO_DEFINE_CLASS(simple_class_get, &class_desc, EO_CLASS, NULL);
-struct wrapper : efl::eo::base
+struct wrapper : efl::eo::concrete
{
explicit wrapper(Eo* o)
- : base(o) {}
+ : concrete(o) {}
};
START_TEST(eina_cxx_ptrlist_push_back)
{
efl::eo::eo_init init;
- ::efl::eo::base b(nullptr);
+ ::efl::eo::concrete b(nullptr);
::callback c;
fail_if(sizeof(b) != sizeof(Eo*));