mirror/mirror_fwd.hpp

Go to the documentation of this file.

#ifndef MIRROR_MIRROR_FWD_1011291729_HPP
#define MIRROR_MIRROR_FWD_1011291729_HPP

#include <mirror/config.hpp>
#include <mirror/meta_object_tags.hpp>
#include <mirror/specifier_tags.hpp>

MIRROR_NAMESPACE_BEGIN

template <typename MetaObjectCategory>
struct meta_meta_object;

//  Specialization of meta_object_category for meta_namespaces
template <typename MetaObjectCategory>
struct meta_object_category< meta_meta_object<MetaObjectCategory> >
{
    // returns meta_global_scope_tag
    typedef meta_meta_object_tag type;
};

//  Namespace containing the implementation details
/*  This namespace contains internal implementation
 *  details of various parts of the Mirror library.
 *  Do not use anything defined inside of this namespace
 *  because these implementation details are subject to
 *  change without any notice.
 */
namespace aux { }


template <template <class> class Getter>
struct required_param_of;

//  Forward declaration of the meta_namespace template class
template <class Namespace>
struct meta_namespace;

//  Specialization of meta_object_category for meta_namespaces
template <class Namespace>
struct meta_object_category< meta_namespace<Namespace> >
{
    typedef meta_namespace_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaScope>
struct members
{
    typedef Range<MetaScopedObject> type;
};
#else
template <class MetaScope>
struct members;
#endif

template <>
struct required_param_of<members>
{
    typedef mirror::meta_scope_tag type;
};

//  Namespace containing basic meta-data about registered namespaces
/*  Every namespace registered with Mirror has its counterpart inside
 *  of this (Mirror's internal _namespace) namespace. Each of this
 *  counterparts must contain a structure called _ (a single underscore)
 *  which provides the basic meta-data about the namespace.
 *  Do NOT use the contents of this namespace directly for anything
 *  else than registering the namespaces. Use the meta_namespace
 *  template for reflecting of namespaces.
 */
namespace _namespace {

// This structure provides basic meta-data about the global scope namespace
struct _;
// This structure provides basic meta-data about an unspecified scope
struct _unspec_scope;

} // namespace _namespace

template <>
struct meta_object_category< meta_namespace<_namespace::_> >
{
    typedef meta_global_scope_tag type;
};

template <>
struct meta_object_category< meta_namespace<_namespace::_unspec_scope> >
{
    typedef meta_unspecified_scope_tag type;
};

//  Forward declaration of the meta_type template class
template <class Type>
struct meta_type;

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaTemplatedType>
struct template_parameters
{
    typedef Range<MetaType> type;
};
#else
template <class MetaTemplatedType>
struct template_parameters;
#endif

template <>
struct required_param_of<template_parameters>
{
    typedef mirror::meta_templated_type_tag type;
};

//  Namespace containing basic meta-data about registered types
/*  Every type registered with Mirror has a separate specialization
 *  of a helper structure containing the basic meta-data about
 *  the registered type
 */
namespace _type {

// Specialization of this structure provide basic meta-data about types
template <typename Type>
struct _;

} // namespace _type

//  Specialization of meta_object_category for meta_types
template <class Type>
struct meta_object_category< meta_type<Type> >
{
    // returns meta_type_tag/meta_templated_type_tag/...
    typedef typename meta_type<Type>::_type_category type;
};

//  Namespace containing basic meta-data about registered typedefs
/*  Every typedef registered with Mirror has a separate specialization
 *  of a helper structure containing the basic meta-data about
 *  the registered typedefined type
 */
namespace _typedef {

// This type is used for distinguishing typedefined types from other T<x>
// template types
template <typename BaseTypedef>
struct _selector;

} // namespace _typedef

//  Specialization of meta_object_category for meta_types
template <class BaseTypedef>
struct meta_object_category<
    meta_type<_typedef::_selector<BaseTypedef> >
>
{
    // meta_typedef_tag
    typedef meta_typedef_tag type;
};


//  Forward declaration of the meta_type_template template class
template <template <typename ...> class Template>
struct meta_type_template;

//  Namespace containing basic meta-data about registered templates
/*  Every template type registered with Mirror has a separate specialization
 *  of a helper structure containing the basic meta-data about
 *  the registered template type
 */
namespace _template {

// Specialization of this structure provide basic meta-data about templates
template <template <typename ...> class Template>
struct _;

} // namespace _template


//  Specialization of meta_object_category for meta_types
template <template <typename ...> class Template>
struct meta_object_category< meta_type_template<Template> >
{
    // returns meta_type_template_tag
    typedef meta_type_template_tag type;
};


// Forward declaration of the meta_class template
template <class Class>
struct meta_class;

//  Namespace containing basic meta-data about registered elaborate types
/*  Every class registered with Mirror has a separate specialization
 *  of a helper structure containing the basic meta-data about
 *  the registered elaborated type
 */
namespace _class {

// Specialization of this structure provide basic meta-data about classes
template <typename Class>
struct _;

} // namespace _class

//  Specialization of meta_object_category for meta_classes
template <class Class>
struct meta_object_category< meta_class<Class> >
{
    // returns meta_class_tag/meta_templated_class_tag
    typedef typename meta_class<Class>::_class_category type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaNamespace>
struct namespaces
{
    typedef Range<MetaNamespace> type;
};
#else
template <class MetaNamespace>
struct namespaces;
#endif

template <>
struct required_param_of<namespaces>
{
    typedef mirror::meta_namespace_tag type;
};


template <class VariableSelector>
struct meta_free_variable;

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaNamespace>
struct free_variables
{
    typedef Range<MetaFreeVariable> type;
};
#else
template <class MetaNamespace>
struct free_variables;
#endif

template <>
struct required_param_of<free_variables>
{
    typedef mirror::meta_namespace_tag type;
};

template <class VariableSelector>
struct meta_free_variable;

//  Namespace containing basic meta-data about registered free variables
/*  Every free variable registered with Mirror is registered inside
 *  of this (Mirror's internal _variable) namespace.
 *  Do NOT use the contents of this namespace directly for anything
 *  else than registering the variables.
 */
namespace _variable { }

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaNamespace>
struct free_functions
{
    typedef Range<MetaOverloadedFunctions> type;
};
#else
template <class MetaNamespace>
struct free_functions;
#endif

template <>
struct required_param_of<free_functions>
{
    typedef mirror::meta_namespace_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaOverloadedFunctions>
struct overloads
{
    typedef Range<MetaFunction> type;
};
#else
template <class MetaOverloadedFunctions>
struct overloads;
#endif

template <>
struct required_param_of<overloads>
{
    typedef mirror::meta_class_tag type;
};

template <class VariableSelector>
struct meta_ovlded_free_funcs;

//  Specialization of meta_object_category for meta_ovlded_free_funcs'
template <typename Selector>
struct meta_object_category<meta_ovlded_free_funcs<Selector> >
{
    typedef meta_overloaded_functions_tag type;
};

template <class VariableSelector, int Index>
struct meta_free_function;

template <typename FunctionSelector, int FuncIndex>
struct meta_object_category<
    meta_free_function<FunctionSelector, FuncIndex>
>
{
    typedef meta_function_tag type;
};

// Forward declaration of the meta_free_func_param template
template <typename FunctionSelector, int FuncIndex, int ParamIndex>
struct meta_free_func_param;

template <typename FunctionSelector, int FuncIndex, int ParamIndex>
struct meta_object_category<
    meta_free_func_param<FunctionSelector, FuncIndex, ParamIndex>
>
{
    typedef meta_parameter_tag type;
};

//  Namespace containing basic meta-data about registered free functions
/*  Every (overloaded) free function registered with Mirror is registered inside
 *  of this (Mirror's internal _function) namespace.
 *  Do NOT use the contents of this namespace directly for anything
 *  else than registering the variables.
 */
namespace _function { }

//  Namespace containing basic meta-data about registered container classes
/*  Every container registered with Mirror is registered inside of this
 *  (Mirror's internal) namespace .
 *  Do NOT use the contents of this namespace directly for anything
 *  else than registering the containers.
 */
namespace _container {

template <typename Container>
struct _;

} // namespace _container

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaClass>
struct base_classes
{
    typedef Range<MetaInheritance> type;
};
#else
template <class MetaClass>
struct base_classes;
#endif

template <>
struct required_param_of<base_classes>
{
    typedef mirror::meta_class_tag type;
};

// Forward declaration of the meta_inheritance template
template <class Class, class BaseMetaInheritance>
struct meta_inheritance;


//  Specialization of meta_object_category for meta_inheritances
template <class Class, class BaseMetaInheritance>
struct meta_object_category< meta_inheritance<Class, BaseMetaInheritance> >
{
    typedef meta_inheritance_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaType>
struct original_type
{
    typedef unspecified type;
};
#else
template <class MetaType>
struct original_type;
#endif

template <>
struct required_param_of<original_type>
{
    typedef mirror::meta_type_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaNamedObject>
struct static_name
{
    typedef CompileTimeString type;
};
#else
template <class MetaNamedObject>
struct static_name;
#endif

template <>
struct required_param_of<static_name>
{
    typedef mirror::meta_named_object_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaScopedObject>
struct scope
{
    typedef MetaScope type;
};
#else
template <class MetaScopedObject>
struct scope;
#endif

template <>
struct required_param_of<scope>
{
    typedef mirror::meta_scoped_object_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaType, class ModifierLambdaExpression>
struct apply_modifier
{
    typedef MetaType type;
};
#else
template <class MetaType, class ModifierLambdaExpression>
struct apply_modifier;
#endif

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaType>
struct container_kind
{
    typedef ContainerTypeTag type;
};
#else
template <class MetaType>
struct container_kind;
#endif

template <>
struct required_param_of<container_kind>
{
    typedef mirror::meta_type_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaClass>
struct elaborated_type
{
    typedef ElaboratedTypeTag type;
};
#else
template <class MetaClass>
struct elaborated_type;
#endif

template <>
struct required_param_of<elaborated_type>
{
    typedef mirror::meta_class_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaVariable>
struct storage_class
{
    typedef StorageClassTag type;
};
#else
template <class MetaVariable>
struct storage_class;
#endif

template <>
struct required_param_of<storage_class>
{
    typedef mirror::meta_variable_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaFunction>
struct linkage
{
    typedef StorageClassTag type;
};
#else
template <class MetaFunction>
struct linkage;
#endif

template <>
struct required_param_of<linkage>
{
    typedef mirror::meta_function_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaMemberFunction>
struct constness
{
    typedef ConstnessTag type;
};
#else
template <class MetaMemberFunction>
struct constness;
#endif

template <>
struct required_param_of<constness>
{
    typedef mirror::meta_member_function_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaInheritance>
struct inheritance_type
{
    typedef InheritanceTypeTag type;
};
#else
template <class MetaInheritance>
struct inheritance_type;
#endif

template <>
struct required_param_of<inheritance_type>
{
    typedef mirror::meta_inheritance_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaInheritance>
struct base_class
{
    typedef MetaClass type;
};
#else
template <class MetaInheritance>
struct base_class;
#endif

template <>
struct required_param_of<base_class>
{
    typedef mirror::meta_inheritance_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaInheritance>
struct derived_class
{
    typedef MetaClass type;
};
#else
template <class MetaInheritance>
struct derived_class;
#endif

template <>
struct required_param_of<derived_class>
{
    typedef mirror::meta_inheritance_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaInheritance>
struct base_class_access_type
{
    typedef AccessTypeTag type;
};
#else
template <class MetaInheritance>
struct base_class_access_type;
#endif

template <>
struct required_param_of<base_class_access_type>
{
    typedef mirror::meta_inheritance_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaClassMember>
struct class_member_access_type
{
    typedef AccessTypeTag type;
};
#else
template <class MetaClassMember>
struct class_member_access_type;
#endif

template <>
struct required_param_of<class_member_access_type>
{
    typedef mirror::meta_class_member_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaTemplatedType>
struct type_template
{
    typedef MetaTypeTemplate type;
};
#else
template <class MetaTemplatedType>
struct type_template;
#endif

template <>
struct required_param_of<type_template>
{
    typedef mirror::meta_templated_type_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaParameter>
struct parameter_position
{
    typedef IntegralConstantType type;
};
#else
template <class MetaParameter>
struct parameter_position;
#endif

template <>
struct required_param_of<parameter_position>
{
    typedef mirror::meta_parameter_tag type;
};


#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaClass>
struct member_variables
{
    typedef Range<MetaMemberVariable> type;
};
#else
template <class MetaClass>
struct member_variables;
#endif

template <>
struct required_param_of<member_variables>
{
    typedef mirror::meta_class_tag type;
};

// Forward declaration of the meta_member_variable template
template <class Class, int Index>
struct meta_member_variable;


// The specialization of meta_object_category for meta_member_variabless
// is defined in meta_class.hpp

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaClass>
struct class_layout
{
    typedef Range<MetaClass> type;
};
#else
template <class MetaClass>
struct class_layout;
#endif

template <>
struct required_param_of<class_layout>
{
    typedef mirror::meta_class_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaClass>
struct all_member_variables
{
    typedef Range<MetaMemberVariable> type;
};
#else
template <class MetaClass>
struct all_member_variables;
#endif

template <>
struct required_param_of<all_member_variables>
{
    typedef mirror::meta_class_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaClass>
struct constructors
{
    typedef Range<MetaConstructor> type;
};
#else
template <class MetaClass>
struct constructors;
#endif

template <>
struct required_param_of<constructors>
{
    typedef mirror::meta_class_tag type;
};

// Forward declaration of the meta_constructor template
template <class Class, int Index>
struct meta_constructor;

template <class Class, int Index>
struct meta_object_category< meta_constructor<Class, Index> >
{
    typedef meta_constructor_tag type;
};

// Forward declaration of the meta_constructor_param template
template <typename Type, int ConstrIndex, int ParamIndex>
struct meta_constructor_param;

template <typename Type, int ConstrIndex, int ParamIndex>
struct meta_object_category<
    meta_constructor_param<Type, ConstrIndex, ParamIndex>
>
{
    typedef meta_parameter_tag type;
};

template <class Class>
struct meta_initializer;

template <class Class>
struct meta_object_category< meta_initializer<Class> >
{
    typedef meta_constructor_tag type;
};

// Forward declaration of the meta_constructor_param template
template <typename Type>
struct meta_initializer_param;

template <typename Type>
struct meta_object_category<meta_initializer_param<Type> >
{
    typedef meta_parameter_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaClass>
struct member_functions
{
    typedef Range<MetaMemberFunction> type;
};
#else
template <class MetaClass>
struct member_functions;
#endif

template <>
struct required_param_of<member_functions>
{
    typedef mirror::meta_class_tag type;
};

template <class Class, int FuncIndex>
struct meta_ovlded_mem_funcs;

//  Specialization of meta_object_category for meta_ovlded_mem_funcs'
template <typename Class, int FuncIndex>
struct meta_object_category<meta_ovlded_mem_funcs<Class, FuncIndex> >
{
    typedef meta_overloaded_functions_tag type;
};

// Forward declaration of the meta_member_function template
template <class Class, int FuncIndex, int OvldIndex>
struct meta_member_function;

//  Specialization of meta_object_category for meta_member_functions
template <class Class, int FuncIndex, int OvldIndex>
struct meta_object_category< meta_member_function<Class, FuncIndex, OvldIndex> >
{
    typedef meta_member_function_tag type;
};

// Forward declaration of the meta_mem_function_param template
template <typename Type, int FnIndex, int OvldIndex, int ParamIndex>
struct meta_mem_function_param;

//  Specialization of meta_object_category for meta_inheritances
template <typename Type, int FnIndex, int OvldIndex, int ParamIndex>
struct meta_object_category<
    meta_mem_function_param<Type, FnIndex, OvldIndex, ParamIndex>
>
{
    typedef meta_parameter_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaClass>
struct conversions
{
    typedef Range<MetaMemberFunction> type;
};
#else
template <class MetaClass>
struct conversions;
#endif

template <>
struct required_param_of<conversions>
{
    typedef mirror::meta_class_tag type;
};

// Forward declaration of the meta_conversion_operator template
template <class Class, class Result>
struct meta_conversion_operator;

// Specialization of meta_object_category for meta_conversion_operators
template <class Class, class Result>
struct meta_object_category< meta_conversion_operator<Class, Result> >
{
    typedef meta_conversion_operator_tag type;
};


#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaFunction>
struct parameters
{
    typedef Range<MetaParameter> type;
};
#else
template <class MetaFunction>
struct parameters;
#endif

template <>
struct required_param_of<parameters>
{
    typedef mirror::meta_class_tag type;
};


// Forward declaration of the meta_enum template
template <class Enum>
struct meta_enum;

//  Namespace containing basic meta-data about registered enum classes
/*  Every enum registered with Mirror has a separate specialization
 *  of a helper structure containing the basic meta-data about
 *  the registered enumeration
 */
namespace _enum {

// Specialization of this structure provide basic meta-data about enumerations
template <typename Enum>
struct _;

} // namespace _enum

//  Specialization of meta_object_category for meta_enums
template <class Enum>
struct meta_object_category< meta_enum<Enum> >
{
    typedef meta_enum_tag type;
};

// Forward declaration of the meta_enum_value template
template <class Enum, int Index>
struct meta_enum_value;

//  Specialization of meta_object_category for meta_enums
template <class Enum, int Index>
struct meta_object_category< meta_enum_value<Enum, Index> >
{
    typedef meta_enum_value_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaEnum>
struct enum_values
{
    typedef Range<MetaEnumValue> type;
};
#else
template <class MetaEnum>
struct enum_values;
#endif

template <>
struct required_param_of<enum_values>
{
    typedef mirror::meta_enum_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaVariable>
struct type_of
{
    typedef MetaType type;
};
#else
template <class MetaVariable>
struct type_of;
#endif

template <>
struct required_param_of<type_of>
{
    typedef mirror::meta_variable_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaFunction>
struct result_type
{
    typedef MetaType type;
};
#else
template <class MetaFunction>
struct result_type;
#endif

template <>
struct required_param_of<result_type>
{
    typedef mirror::meta_function_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaEnum>
struct enum_size
{
    typedef IntegralConstantType type;
};
#else
template <class MetaEnum>
struct enum_size;
#endif

template <>
struct required_param_of<enum_size>
{
    typedef mirror::meta_enum_tag type;
};

template <class Container, class IsSpecial, int Index>
struct meta_container;

template <class Container, class IsSpecial, int Index>
struct meta_object_category<meta_container<Container, IsSpecial, Index> >
{
    typedef meta_container_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaType>
struct containers
{
    typedef Range<MetaContainer> type;
};
#else
template <class MetaType>
struct containers;
#endif

template <>
struct required_param_of<containers>
{
    typedef mirror::meta_type_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaClass>
struct all_containers
{
    typedef Range<MetaContainer> type;
};
#else
template <class MetaClass>
struct all_containers;
#endif

template <>
struct required_param_of<all_containers>
{
    typedef mirror::meta_class_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaContainer>
struct default_traversal
{
    typedef MetaTraversal type;
};
#else
template <class MetaContainer>
struct default_traversal;
#endif

template <>
struct required_param_of<default_traversal>
{
    typedef mirror::meta_container_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaContainer>
struct traversals
{
    typedef Range<MetaTraversal> type;
};
#else
template <class MetaContainer>
struct traversals;
#endif

template <>
struct required_param_of<traversals>
{
    typedef mirror::meta_container_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaContainer>
struct locators
{
    typedef Range<MetaLocator> type;
};
#else
template <class MetaContainer>
struct locators;
#endif

template <>
struct required_param_of<locators>
{
    typedef mirror::meta_container_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaContainer>
struct inserters
{
    typedef Range<MetaInserter> type;
};
#else
template <class MetaContainer>
struct inserters;
#endif

template <>
struct required_param_of<inserters>
{
    typedef mirror::meta_container_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaContainer>
struct erasers
{
    typedef Range<MetaEraser> type;
};
#else
template <class MetaContainer>
struct erasers;
#endif

template <>
struct required_param_of<erasers>
{
    typedef mirror::meta_container_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaMetaObject>
struct generalizations
{
    typedef Range<MetaEraser> type;
};
#else
template <class MetaMetaObject>
struct generalizations;
#endif

template <>
struct required_param_of<generalizations>
{
    typedef mirror::meta_meta_object_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <class MetaObject>
struct tags
{
    typedef Range<Tag> type;
};
#else
template <class MetaObject>
struct tags;
#endif

template <>
struct required_param_of<tags>
{
    typedef mirror::meta_object_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <typename Type>
struct reflected
{
    typedef MetaType type;
};
#else
template <typename Type>
struct reflected;
#endif

template <>
struct required_param_of<reflected>
{
    typedef mirror::non_meta_object_tag type;
};

#ifdef MIRROR_DOCUMENTATION_ONLY


template <typename Type>
struct reflected_type
{ };
#else
template <typename Type>
struct reflected_type;
#endif

MIRROR_NAMESPACE_END

#endif //include guard