mirror/doc/concepts.hpp

Go to the documentation of this file.

#ifndef MIRROR_DOC_CONCEPTS_1011291729_HPP
#define MIRROR_DOC_CONCEPTS_1011291729_HPP

#include <mirror/config.hpp>
#include <mirror/doc/concepts_fwd.hpp>

// This section is here for documentation purposes only
#ifdef MIRROR_DOCUMENTATION_ONLY

MIRROR_NAMESPACE_BEGIN


struct MetaObject
{

    friend struct is_a<MetaObject, ConceptTag>;

    friend meta_object_tag categorize_meta_object(MetaObject);
};


struct MetaNamedObject
 : virtual public MetaObject
{

    static std::string base_name(void);

    friend meta_named_object_tag categorize_meta_object(MetaNamedObject);
};


struct MetaMetaObject
 : virtual public MetaNamedObject
{

    static std::string construct_name(void);


    friend struct generalizations<MetaMetaObject>;


    typedef unspecified_type category;

    friend meta_meta_object_tag
    categorize_meta_object(MetaMetaObject);
};



struct MetaScopedObject
 : virtual public MetaObject
{

    typedef MetaScope scope;


    friend struct scope<MetaScopedObject>;

    friend meta_scoped_object_tag categorize_meta_object(MetaScopedObject);
};


struct MetaNamedScopedObject
 : virtual public MetaNamedObject
 , virtual public MetaScopedObject
{

    static std::string full_name(void);


    static std::string local_name(void);

    friend meta_named_scoped_object_tag
    categorize_meta_object(MetaNamedScopedObject);
};


struct MetaScope
 : virtual public MetaNamedScopedObject
{

    friend struct members<MetaScope>;

    friend meta_scope_tag categorize_meta_object(MetaScope);
};


struct MetaNamespace
 : virtual public MetaScope
{
    typedef MetaNamespace scope;

    friend struct namespaces<MetaNamespace>;

    friend struct free_variables<MetaNamespace>;

    friend struct free_functions<MetaNamespace>;

    friend meta_namespace_tag categorize_meta_object(MetaNamespace);
};


struct MetaGlobalScope
 : virtual public MetaNamespace
{
    typedef MetaGlobalScope scope;

    friend meta_global_scope_tag categorize_meta_object(MetaNamespace);
};


struct MetaType
 : virtual public MetaNamedScopedObject
{
    typedef unspecified_type original_type;


    friend struct original_type<MetaType>;

    friend struct apply_modifier<MetaType, ModifierLambdaExpression>;

    friend struct constructors<MetaClass>;


    friend struct container_kind<MetaType>;

    friend struct containers<MetaType>;


    friend int traverse_elements(
        MetaType meta_type,
        MetaType::original_type& container,
        TernaryFunctor elem_func,
        BinaryFunctor empty_func
    );

    friend meta_type_tag categorize_meta_object(MetaType);
};


struct MetaTypedef
 : virtual public MetaType
{
    typedef MetaType type;

    friend meta_typedef_tag categorize_meta_object(MetaTypedef);
};


struct MetaTemplatedType
 : virtual public MetaType
{
    typedef MetaTypeTemplate type_template;


    friend struct type_template<MetaTemplatedType>;

    friend struct template_parameters<MetaTemplatedType>;

    friend meta_templated_type_tag
    categorize_meta_object(MetaTemplatedType);
};


struct MetaTypeTemplate
 : virtual public MetaNamedScopedObject
{

    template <typename ... P>
    struct reflected_template
    {
        typedef unspecified_type type;
    };


    friend meta_type_template_tag
    categorize_meta_object(MetaTypeTemplate);
};


struct MetaClass
 : virtual public MetaType
 , virtual public MetaScope
{

    typedef ElaboratedTypeTag elaborated_type;


    friend struct elaborated_type<MetaClass>;

    friend struct base_classes<MetaClass>;

    friend struct member_variables<MetaClass>;

    friend struct all_member_variables<MetaClass>;

    friend struct member_functions<MetaClass>;

    friend struct all_member_functions<MetaClass>;


    friend struct all_containers<MetaClass>;

    friend meta_class_tag categorize_meta_object(MetaClass);
};


struct MetaClassMember
 : virtual public MetaNamedScopedObject
{
    typedef MetaClass scope;


    friend struct scope<MetaClassMember>;


    typedef AccessTypeTag access_type;


    friend struct access_type<MetaClassMember>;

    friend meta_class_member_tag categorize_meta_object(MetaClassMember);
};


struct MetaTemplatedClass
 : virtual public MetaTemplatedType
 , virtual public MetaClass
{

    friend meta_templated_class_tag
    categorize_meta_object(MetaTemplatedClass);
};


struct MetaEnum
 : virtual public MetaType
 , virtual public MetaScope
{
    friend struct enum_values<MetaClass>;

    typedef IntegralConstantType size;


    friend struct enum_size<MetaEnum>;

    static UnspecifiedEnumType value(IntegralConstantType index);

    static UnspecifiedEnumType value(int index);

    static std::string value_name(IntegralConstantType index);

    static std::string value_name(int index);

    static std::string name_by_value(Enum x);

    static Enum value_by_name(const std::string& name);

    static bool has_value_name(const std::string& name);

    friend meta_enum_tag
    categorize_meta_object(MetaEnum);
};


struct MetaEnumValue
 : virtual public MetaNamedScopedObject
{
    typedef MetaEnum scope;

    typedef IntegralConstantType value;

    friend meta_enum_value_tag
    categorize_meta_object(MetaEnumValue);
};


struct MetaInheritance
 : virtual public MetaObject
{
    typedef MetaClass derived_class;


    friend struct derived_class<MetaInheritance>;


    typedef InheritanceTypeTag inheritance_type;


    friend struct inheritance_type<MetaInheritance>;


    typedef AccessTypeTag access_type;


    friend struct access_type<MetaInheritance>;

    typedef MetaClass base_class;


    friend struct base_class<MetaInheritance>;

    friend meta_inheritance_tag categorize_meta_object(MetaInheritance);
};



struct MetaVariable
 : virtual public MetaNamedScopedObject
{

    typedef StorageClassTag storage_class;


    friend struct storage_class<MetaVariable>;

    typedef MetaType type;


    friend struct type_of<MetaVariable>;

    friend meta_variable_tag
    categorize_meta_object(MetaVariable);
};


struct MetaFreeVariable
 : virtual public MetaVariable
{
    typedef MetaNamespace scope;


    static Type get(void);


    static void set(Type new_value);

    friend meta_free_variable_tag
    categorize_meta_object(MetaFreeVariable);
};


struct MetaPlainFreeVariable
 : virtual public MetaFreeVariable
{

    static Type* address(void);

    friend meta_plain_free_variable_tag
    categorize_meta_object(MetaPlainFreeVariable);
};


struct MetaMemberVariable
 : virtual public MetaClassMember
 , virtual public MetaVariable
{

    static Type get(const Class& instance);


    static void set(Class& instance, Type new_value);

    friend meta_member_variable_tag
    categorize_meta_object(MetaMemberVariable);
};


struct MetaPlainMemberVariable
 : virtual public MetaMemberVariable
{
    static ptrdiff_t offset(void);


    static Type* address(Class& instance);

    static const Type* address(const Class& instance);

    static MemberVariablePointer member_pointer(void);

    friend meta_plain_member_variable_tag
    categorize_meta_object(MetaPlainMemberVariable);
};


struct MetaParameter
 : virtual public MetaVariable
{
    typedef IntegralConstantType position;


    friend struct parameter_position<MetaParameter>;

    friend meta_parameter_tag
    categorize_meta_object(MetaParameter);
};


struct MetaFunction
 : virtual public MetaScope
{
    typedef MetaType result_type;


    friend struct result_type<MetaFunction>;


    typedef StorageClassTag storage_class;


    typedef StorageClassTag linkage;


    friend struct linkage<MetaFunction>;


    friend struct parameters<MetaFunction>;

    friend meta_function_tag
    categorize_meta_object(MetaFunction);
};


struct MetaMemberFunction
 : virtual public MetaClassMember
 , virtual public MetaFunction
{


    typedef ConstnessTag constness;


    friend struct constness<MetaMemberFunction>;

    friend meta_member_function_tag
    categorize_meta_object(MetaMemberFunction);
};


struct MetaConstructor
 : virtual public MetaFunction
 , virtual public MetaClassMember
{

    typedef MetaType result_type;

    friend meta_constructor_tag
    categorize_meta_object(MetaConstructor);
};


struct MetaConversionOperator
 : virtual public MetaMemberFunction
{

    friend meta_conversion_operator_tag
    categorize_meta_object(MetaConversionOperator);
};


struct MetaOverloadedFunctions
 : virtual public MetaNamedScopedObject
{

    friend struct overloads<MetaOverloadedFunctions>;
};

MIRROR_NAMESPACE_END

#endif // MIRROR_DOCUMENTATION_ONLY

#endif //include guard