lagoon/interfaces.hpp

Go to the documentation of this file.

#ifndef LAGOON_INTERFACES_1011291729_HPP
#define LAGOON_INTERFACES_1011291729_HPP

#include <lagoon/lagoon_fwd.hpp>
#include <lagoon/categories.hpp>
#include <lagoon/specifiers.hpp>
#include <lagoon/utils.hpp>
#include <puddle/categories.hpp>
#include <mirror/type_traits.hpp>
#include <mirror/meta_object_tags.hpp>
#include <string>
#include <memory>

#if LAGOON_MT_WITH_MAKE_FACTORY
#include <lagoon/polymorph_factory.hpp>
#endif

LAGOON_NAMESPACE_BEGIN



struct meta_meta_object
{
private:
    const std::string _base_name;
    const std::string _ctrt_name;
    meta_object_category _category;

    static inline bool category_matches(unsigned a, unsigned b)
    {
        return (a & b) == b;
    }
protected:
    template <typename MetaObjectTag>
    static meta_object_category get_category(MetaObjectTag tag)
    {
        return puddle::get_category(tag);
    }

    template <typename MetaMetaObject, typename Interface>
    friend shared<Interface> aux::get_meta_object(mirror::meta_meta_object_tag);

    template <typename MetaMetaObject>
    inline meta_meta_object(MetaMetaObject)
     : _base_name(MetaMetaObject::base_name())
     , _ctrt_name(MetaMetaObject::construct_name())
     , _category(get_category(typename MetaMetaObject::category()))
    { }

public:
#if LAGOON_POLYMORPHIC_MMO
    virtual ~meta_meta_object(void)
    { }
#endif


    std::string base_name(void) const
    {
        return _base_name;
    }


    std::string construct_name(void) const
    {
        return _ctrt_name;
    }

#if LAGOON_MMO_WITH_GENERALIZATIONS || MIRROR_DOCUMENTATION_ONLY


    virtual range<meta_meta_object> generalizations(void) const = 0;
#endif


    meta_object_category category(void) const
    {
        return _category;
    }

    inline bool is_a(meta_object_category cat) const
    {
        return category_matches(
            unsigned(category()),
            unsigned(cat)
        );
    }

#define LAGOON_HELPER_MAKE_MMO_IS_META_OBJECT(OBJECT, I, X) \
    inline bool is_meta_## OBJECT(void) const \
    { \
        return is_a(meta_object_category::meta_ ## OBJECT ## _tag); \
    }
MIRROR_FOR_EACH_META_OBJECT(LAGOON_HELPER_MAKE_MMO_IS_META_OBJECT, _)
#undef LAGOON_HELPER_MAKE_MMO_IS_META_OBJECT

};



struct meta_object
{
protected:
    // Helper function used in the cast_to function
    static void* _sel_ptr(void)
    {
        return nullptr;
    }

    // Helper function used in the cast_to function
    template <typename ... P>
    static void* _sel_ptr(void* p,  P* ... pp)
    {
        if(p != nullptr) return p;
        return _sel_ptr(pp...);
    }

#if MIRROR_NO_RTTI
// Helper macro used to implement the cast_to member function
#define LAGOON_HLPR_MO_IMPL_CAST_TO_CALL_BASE(OBJECT, X) \
    meta_ ## OBJECT::cast_to(cat)

// Helper macro used to implement the cast_to member function
#define LAGOON_HLPR_MO_IMPL_CAST_TO(OBJECT) \
    virtual void* cast_to(meta_object_category cat) \
    { \
        if(cat == meta_object_category::meta_##OBJECT##_tag) \
            return static_cast<meta_##OBJECT*>(this); \
        return _sel_ptr( \
            MIRROR_FOR_EACH_META_OBJECT_BASE( \
                OBJECT, \
                LAGOON_HLPR_MO_IMPL_CAST_TO_CALL_BASE, \
                _, \
                MIRROR_PP_COMMA \
            ) \
        ); \
    }
#else
#define LAGOON_HLPR_MO_IMPL_CAST_TO(OBJECT)
#endif

public:

    // virtual destructor assuring proper cleanup
    virtual ~meta_object(void) { }

    virtual shared<meta_meta_object> self(void) const = 0;

    LAGOON_HLPR_MO_IMPL_CAST_TO(object)

    

#define LAGOON_HELPER_MO_IS_OBJECT(OBJECT, I, X) \
    inline bool is_## OBJECT(void) const \
    { \
        return self()->is_meta_ ## OBJECT(); \
    }
MIRROR_FOR_EACH_META_OBJECT(LAGOON_HELPER_MO_IS_OBJECT, _)
#undef LAGOON_HELPER_MO_IS_OBJECT

};

struct meta_named_object
 : virtual meta_object
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(named_object)

    

    virtual std::string base_name(void) = 0;
};

struct meta_scoped_object
 : virtual meta_object
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(scoped_object)

    
    virtual shared<meta_scope> scope(void) = 0;
};

struct meta_named_scoped_object
 : virtual meta_named_object
 , virtual meta_scoped_object
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(named_scoped_object)

    
    virtual std::string full_name(void) = 0;


#if LAGOON_MNSO_WITH_LOCAL_NAME || \
    MIRROR_DOCUMENTATION_ONLY


    virtual std::string local_name(void) = 0;
#endif
};

struct meta_scope
 : virtual meta_named_scoped_object
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(scope)

    
    virtual range<meta_named_scoped_object> members(void) = 0;


    template <typename Interface>
    shared<Interface> find_member(const std::string& name)
    {
        auto r(this->members());
        while(!r.empty())
        {
            if(r.front()->base_name() == name)
                return r.front().as<Interface>();
            r.step_front();
        }
        return shared<Interface>();
    }
};

struct meta_unspecified_scope
 : virtual meta_scope
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(unspecified_scope)
};

struct meta_namespace
 : virtual meta_scope
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(namespace)

    
    virtual range<meta_namespace> namespaces(void) = 0;

    virtual range<meta_free_variable> free_variables(void) = 0;

    virtual range<meta_overloaded_functions> free_functions(void) = 0;

    inline shared<meta_free_variable> variable_(const std::string& name)
    {
        return find_member<meta_free_variable>(name);
    }

    inline shared<meta_namespace> namespace_(const std::string& name)
    {
        return find_member<meta_namespace>(name);
    }

    inline shared<meta_type> type_(const std::string& name)
    {
        return find_member<meta_type>(name);
    }

    inline shared<meta_class> class_(const std::string& name)
    {
        return type_(name).as<meta_class>();
    }

    inline shared<meta_typedef> typedef_(const std::string& name)
    {
        return find_member<meta_typedef>(name);
    }

    inline shared<meta_type_template> template_(const std::string& name)
    {
        return find_member<meta_type_template>(name);
    }
};

struct meta_global_scope
 : virtual meta_namespace
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(global_scope)
};

struct meta_type
 : virtual meta_named_scoped_object
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(type)

    
    virtual range<meta_constructor> constructors(void) = 0;

#if LAGOON_ALL_TYPE_TRAITS || \
    LAGOON_MT_WITH_IS_DEFAULT_CONSTRUCTIBLE || \
    MIRROR_DOCUMENTATION_ONLY


    virtual bool is_default_constructible(void) = 0;
#endif

#if LAGOON_ALL_TYPE_TRAITS || \
    LAGOON_MT_WITH_IS_COPY_CONSTRUCTIBLE || \
    MIRROR_DOCUMENTATION_ONLY


    virtual bool is_copy_constructible(void) = 0;
#endif

#if LAGOON_MT_WITH_NEW || \
    MIRROR_DOCUMENTATION_ONLY


    virtual raw_ptr new_(void) = 0;
#endif

#if LAGOON_MT_WITH_NEW_COPY || \
    MIRROR_DOCUMENTATION_ONLY


    virtual raw_ptr new_copy(raw_ptr source) = 0;
#endif

#if LAGOON_MT_WITH_DEFAULT || \
    MIRROR_DOCUMENTATION_ONLY


    virtual boost::any default_(void) = 0;
#endif

#if LAGOON_MT_WITH_DELETE || \
    MIRROR_DOCUMENTATION_ONLY


    virtual void delete_(raw_ptr ptr) = 0;
#endif

#if LAGOON_MT_WITH_MAKE_SHARED || \
    MIRROR_DOCUMENTATION_ONLY


    virtual shared_raw_ptr make_shared(raw_ptr source) = 0;
#endif

#if LAGOON_MT_WITH_MAKE_UNIQUE || \
    MIRROR_DOCUMENTATION_ONLY


    virtual unique_raw_ptr make_unique(raw_ptr source) = 0;
#endif

#if LAGOON_MT_WITH_MAKE_FACTORY || \
    MIRROR_DOCUMENTATION_ONLY


    virtual std::unique_ptr<polymorph_factory> make_factory(
        polymorph_factory_builder& builder,
        raw_ptr build_data
    ) = 0;
#endif


    virtual std::size_t size_of(void) = 0;

#if LAGOON_ALL_TYPE_TRAITS || \
    LAGOON_MT_WITH_ALIGNMENT_OF || \
    MIRROR_DOCUMENTATION_ONLY


    virtual std::size_t alignment_of(void) = 0;
#endif

#if LAGOON_ALL_TYPE_TRAITS || \
    LAGOON_MT_WITH_IS_ARRAY || \
    MIRROR_DOCUMENTATION_ONLY


    virtual bool is_array(void) = 0;
#endif

#if LAGOON_ALL_TYPE_TRAITS || \
    LAGOON_MT_WITH_IS_CONST || \
    MIRROR_DOCUMENTATION_ONLY


    virtual bool is_const(void) = 0;
#endif

#if LAGOON_ALL_TYPE_TRAITS || \
    LAGOON_MT_WITH_IS_POINTER || \
    MIRROR_DOCUMENTATION_ONLY


    virtual bool is_pointer(void) = 0;
#endif

#if LAGOON_ALL_TYPE_TRAITS || \
    LAGOON_MT_WITH_IS_REFERENCE || \
    MIRROR_DOCUMENTATION_ONLY


    virtual bool is_reference(void) = 0;
#endif

#if LAGOON_ALL_TYPE_TRAITS || \
    LAGOON_MT_WITH_IS_VOLATILE || \
    MIRROR_DOCUMENTATION_ONLY


    virtual bool is_volatile(void) = 0;
#endif

#if LAGOON_ALL_TYPE_TRAITS || \
    LAGOON_MT_WITH_ADD_CONST || \
    MIRROR_DOCUMENTATION_ONLY


    virtual shared<meta_type> add_const(void) = 0;
#endif

#if LAGOON_ALL_TYPE_TRAITS || \
    LAGOON_MT_WITH_ADD_CV || \
    MIRROR_DOCUMENTATION_ONLY


    virtual shared<meta_type> add_cv(void) = 0;
#endif

#if LAGOON_ALL_TYPE_TRAITS || \
    LAGOON_MT_WITH_ADD_VOLATILE || \
    MIRROR_DOCUMENTATION_ONLY


    virtual shared<meta_type> add_volatile(void) = 0;
#endif

#if LAGOON_ALL_TYPE_TRAITS || \
    LAGOON_MT_WITH_REMOVE_CONST || \
    MIRROR_DOCUMENTATION_ONLY


    virtual shared<meta_type> remove_const(void) = 0;
#endif

#if LAGOON_ALL_TYPE_TRAITS || \
    LAGOON_MT_WITH_REMOVE_CV || \
    MIRROR_DOCUMENTATION_ONLY


    virtual shared<meta_type> remove_cv(void) = 0;
#endif

#if LAGOON_ALL_TYPE_TRAITS || \
    LAGOON_MT_WITH_REMOVE_POINTER || \
    MIRROR_DOCUMENTATION_ONLY


    virtual shared<meta_type> remove_pointer(void) = 0;
#endif

#if LAGOON_ALL_TYPE_TRAITS || \
    LAGOON_MT_WITH_REMOVE_REFERENCE || \
    MIRROR_DOCUMENTATION_ONLY


    virtual shared<meta_type> remove_reference(void) = 0;
#endif

#if LAGOON_ALL_TYPE_TRAITS || \
    LAGOON_MT_WITH_REMOVE_VOLATILE || \
    MIRROR_DOCUMENTATION_ONLY


    virtual shared<meta_type> remove_volatile(void) = 0;
#endif

#if LAGOON_ALL_TYPE_TRAITS || \
    LAGOON_MT_WITH_REMOVE_EXTENT || \
    MIRROR_DOCUMENTATION_ONLY


    virtual shared<meta_type> remove_extent(void) = 0;
#endif

};

struct meta_type_template
 : virtual meta_named_scoped_object
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(type_template)

};


struct meta_typedef
 : virtual meta_type
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(typedef)

    
    virtual shared<meta_type> type(void) = 0;
};

struct meta_templated_type
 : virtual meta_type
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(templated_type)

    
    virtual shared<meta_type_template> type_template(void) = 0;

    virtual range<meta_type> template_parameters(void) = 0;
};

struct meta_inheritance
 : virtual meta_object
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(inheritance)

    
    virtual shared<inheritance_type_specifier> inheritance_type(void) = 0;

    virtual shared<access_type_specifier> access_type(void) = 0;

    virtual shared<meta_class> base_class(void) = 0;

    virtual shared<meta_class> derived_class(void) = 0;
};

struct meta_class_member
 : virtual meta_named_scoped_object
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(class_member)

    
    virtual shared<access_type_specifier> access_type(void) = 0;
};

struct meta_variable
 : virtual meta_named_scoped_object
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(variable)

    
    virtual shared<storage_class_specifier> storage_class(void) = 0;

    virtual shared<meta_type> type(void) = 0;
};

struct meta_free_variable
 : virtual meta_variable
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(free_variable)

    // TODO: get/set
};

struct meta_plain_free_variable
 : virtual meta_free_variable
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(plain_free_variable)
    // TODO: ref/address
};

struct meta_member_variable
 : virtual meta_variable
 , virtual meta_class_member
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(member_variable)
};

struct meta_parameter
 : virtual meta_variable
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(parameter)

    
    virtual int position(void) = 0;
};

struct meta_class
 : virtual meta_type
 , virtual meta_scope
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(class)

    
    virtual shared<elaborated_type_specifier> elaborated_type(void) = 0;

    virtual range<meta_inheritance> base_classes(void) = 0;

    virtual range<meta_class> class_layout(void) = 0;

    virtual range<meta_member_variable> member_variables(void) = 0;

#if LAGOON_MC_WITH_ALL_MEMBER_VARIABLES || \
    MIRROR_DOCUMENTATION_ONLY


    virtual range<meta_member_variable> all_member_variables(void) = 0;
#endif

    virtual range<meta_overloaded_functions> member_functions(void) = 0;

    virtual range<meta_conversion_operator> conversions(void) = 0;

};

struct meta_templated_class
 : virtual meta_templated_type
 , virtual meta_class
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(templated_class)
};

struct meta_enum
 : virtual meta_type
 , virtual meta_scope
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(enum)

    
    virtual int size(void) = 0;

    virtual int value(int index) = 0;

    virtual std::string value_name(int index) = 0;

    virtual int value_by_name(const std::string& name) = 0;

    virtual std::string name_by_value(int value) = 0;

    virtual bool has_value_name(const std::string& name) = 0;
};

struct meta_overloaded_functions
 : virtual meta_named_scoped_object
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(overloaded_functions)

    
    virtual range<meta_function> overloads(void) = 0;
};

struct meta_function
 : virtual meta_scope
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(function)

    
    virtual shared<meta_type> result_type(void) = 0;

    virtual range<meta_parameter> parameters(void) = 0;
};

struct meta_constructor
 : virtual meta_function
 , virtual meta_class_member
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(constructor)

    //virtual raw_ptr new_(...) = 0;

    
    virtual shared<access_type_specifier> access_type(void) = 0;
};

struct meta_member_function
 : virtual meta_function
 , virtual meta_class_member
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(member_function)

    
    virtual shared<storage_class_specifier> storage_class(void) = 0;

    inline shared<storage_class_specifier> linkage(void)
    {
        return this->storage_class();
    }

    virtual shared<constness_specifier> constness(void) = 0;
};

struct meta_conversion_operator
 : virtual meta_member_function
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(conversion_operator)
};

struct meta_locator
 : virtual meta_named_object
{
    LAGOON_HLPR_MO_IMPL_CAST_TO(locator)
};

#ifdef LAGOON_HLPR_MO_IMPL_CAST_TO_CALL_BASE
#undef LAGOON_HLPR_MO_IMPL_CAST_TO_CALL_BASE
#endif
#undef LAGOON_HLPR_MO_IMPL_CAST_TO

LAGOON_NAMESPACE_END

#endif //include guard