Mirror reflection library 0.5.13

mirror/mirror_fwd.hpp

Go to the documentation of this file.
00001 
00011 #ifndef MIRROR_MIRROR_FWD_1011291729_HPP
00012 #define MIRROR_MIRROR_FWD_1011291729_HPP
00013 
00014 #include <mirror/config.hpp>
00015 #include <mirror/meta_object_tags.hpp>
00016 #include <mirror/specifier_tags.hpp>
00017 
00018 MIRROR_NAMESPACE_BEGIN
00019 
00020 template <typename MetaObjectCategory>
00021 struct meta_meta_object;
00022 
00023 //  Specialization of meta_object_category for meta_namespaces
00024 template <typename MetaObjectCategory>
00025 struct meta_object_category< meta_meta_object<MetaObjectCategory> >
00026 {
00027     // returns meta_global_scope_tag
00028     typedef meta_meta_object_tag type;
00029 };
00030 
00031 //  Namespace containing the implementation details
00032 /*  This namespace contains internal implementation
00033  *  details of various parts of the Mirror library.
00034  *  Do not use anything defined inside of this namespace
00035  *  because these implementation details are subject to
00036  *  change without any notice.
00037  */
00038 namespace aux { }
00039 
00041 
00048 template <template <class> class Getter>
00049 struct required_param_of;
00050 
00051 //  Forward declaration of the meta_namespace template class
00052 template <class Namespace>
00053 struct meta_namespace;
00054 
00055 //  Specialization of meta_object_category for meta_namespaces
00056 template <class Namespace>
00057 struct meta_object_category< meta_namespace<Namespace> >
00058 {
00059     typedef meta_namespace_tag type;
00060 };
00061 
00062 #ifdef MIRROR_DOCUMENTATION_ONLY
00063 
00064 
00071 template <class MetaScope>
00072 struct members
00073 {
00075     typedef Range<MetaScopedObject> type;
00076 };
00077 #else
00078 template <class MetaScope>
00079 struct members;
00080 #endif
00081 
00082 template <>
00083 struct required_param_of<members>
00084 {
00085     typedef mirror::meta_scope_tag type;
00086 };
00087 
00088 //  Namespace containing basic meta-data about registered namespaces
00089 /*  Every namespace registered with Mirror has its counterpart inside
00090  *  of this (Mirror's internal _namespace) namespace. Each of this
00091  *  counterparts must contain a structure called _ (a single underscore)
00092  *  which provides the basic meta-data about the namespace.
00093  *  Do NOT use the contents of this namespace directly for anything
00094  *  else than registering the namespaces. Use the meta_namespace
00095  *  template for reflecting of namespaces.
00096  */
00097 namespace _namespace {
00098 
00099 // This structure provides basic meta-data about the global scope namespace
00100 struct _;
00101 // This structure provides basic meta-data about an unspecified scope
00102 struct _unspec_scope;
00103 
00104 } // namespace _namespace
00105 
00106 template <>
00107 struct meta_object_category< meta_namespace<_namespace::_> >
00108 {
00109     typedef meta_global_scope_tag type;
00110 };
00111 
00112 template <>
00113 struct meta_object_category< meta_namespace<_namespace::_unspec_scope> >
00114 {
00115     typedef meta_unspecified_scope_tag type;
00116 };
00117 
00118 //  Forward declaration of the meta_type template class
00119 template <class Type>
00120 struct meta_type;
00121 
00122 #ifdef MIRROR_DOCUMENTATION_ONLY
00123 
00124 
00131 template <class MetaTemplatedType>
00132 struct template_parameters
00133 {
00135     typedef Range<MetaType> type;
00136 };
00137 #else
00138 template <class MetaTemplatedType>
00139 struct template_parameters;
00140 #endif
00141 
00142 template <>
00143 struct required_param_of<template_parameters>
00144 {
00145     typedef mirror::meta_templated_type_tag type;
00146 };
00147 
00148 //  Namespace containing basic meta-data about registered types
00149 /*  Every type registered with Mirror has a separate specialization
00150  *  of a helper structure containing the basic meta-data about
00151  *  the registered type
00152  */
00153 namespace _type {
00154 
00155 // Specialization of this structure provide basic meta-data about types
00156 template <typename Type>
00157 struct _;
00158 
00159 } // namespace _type
00160 
00161 //  Specialization of meta_object_category for meta_types
00162 template <class Type>
00163 struct meta_object_category< meta_type<Type> >
00164 {
00165     // returns meta_type_tag/meta_templated_type_tag/...
00166     typedef typename meta_type<Type>::_type_category type;
00167 };
00168 
00169 //  Namespace containing basic meta-data about registered typedefs
00170 /*  Every typedef registered with Mirror has a separate specialization
00171  *  of a helper structure containing the basic meta-data about
00172  *  the registered typedefined type
00173  */
00174 namespace _typedef {
00175 
00176 // This type is used for distinguishing typedefined types from other T<x>
00177 // template types
00178 template <typename BaseTypedef>
00179 struct _selector;
00180 
00181 } // namespace _typedef
00182 
00183 //  Specialization of meta_object_category for meta_types
00184 template <class BaseTypedef>
00185 struct meta_object_category<
00186     meta_type<_typedef::_selector<BaseTypedef> >
00187 >
00188 {
00189     // meta_typedef_tag
00190     typedef meta_typedef_tag type;
00191 };
00192 
00193 
00194 //  Forward declaration of the meta_type_template template class
00195 template <template <typename ...> class Template>
00196 struct meta_type_template;
00197 
00198 //  Namespace containing basic meta-data about registered templates
00199 /*  Every template type registered with Mirror has a separate specialization
00200  *  of a helper structure containing the basic meta-data about
00201  *  the registered template type
00202  */
00203 namespace _template {
00204 
00205 // Specialization of this structure provide basic meta-data about templates
00206 template <template <typename ...> class Template>
00207 struct _;
00208 
00209 } // namespace _template
00210 
00211 
00212 //  Specialization of meta_object_category for meta_types
00213 template <template <typename ...> class Template>
00214 struct meta_object_category< meta_type_template<Template> >
00215 {
00216     // returns meta_type_template_tag
00217     typedef meta_type_template_tag type;
00218 };
00219 
00220 
00221 // Forward declaration of the meta_class template
00222 template <class Class>
00223 struct meta_class;
00224 
00225 //  Namespace containing basic meta-data about registered elaborate types
00226 /*  Every class registered with Mirror has a separate specialization
00227  *  of a helper structure containing the basic meta-data about
00228  *  the registered elaborated type
00229  */
00230 namespace _class {
00231 
00232 // Specialization of this structure provide basic meta-data about classes
00233 template <typename Class>
00234 struct _;
00235 
00236 } // namespace _class
00237 
00238 //  Specialization of meta_object_category for meta_classes
00239 template <class Class>
00240 struct meta_object_category< meta_class<Class> >
00241 {
00242     // returns meta_class_tag/meta_templated_class_tag
00243     typedef typename meta_class<Class>::_class_category type;
00244 };
00245 
00246 #ifdef MIRROR_DOCUMENTATION_ONLY
00247 
00248 
00255 template <class MetaNamespace>
00256 struct namespaces
00257 {
00259     typedef Range<MetaNamespace> type;
00260 };
00261 #else
00262 template <class MetaNamespace>
00263 struct namespaces;
00264 #endif
00265 
00266 template <>
00267 struct required_param_of<namespaces>
00268 {
00269     typedef mirror::meta_namespace_tag type;
00270 };
00271 
00272 
00273 template <class VariableSelector>
00274 struct meta_free_variable;
00275 
00276 #ifdef MIRROR_DOCUMENTATION_ONLY
00277 
00278 
00286 template <class MetaNamespace>
00287 struct free_variables
00288 {
00290     typedef Range<MetaFreeVariable> type;
00291 };
00292 #else
00293 template <class MetaNamespace>
00294 struct free_variables;
00295 #endif
00296 
00297 template <>
00298 struct required_param_of<free_variables>
00299 {
00300     typedef mirror::meta_namespace_tag type;
00301 };
00302 
00303 template <class VariableSelector>
00304 struct meta_free_variable;
00305 
00306 //  Namespace containing basic meta-data about registered free variables
00307 /*  Every free variable registered with Mirror is registered inside
00308  *  of this (Mirror's internal _variable) namespace.
00309  *  Do NOT use the contents of this namespace directly for anything
00310  *  else than registering the variables.
00311  */
00312 namespace _variable { }
00313 
00314 #ifdef MIRROR_DOCUMENTATION_ONLY
00315 
00316 
00324 template <class MetaNamespace>
00325 struct free_functions
00326 {
00328     typedef Range<MetaOverloadedFunctions> type;
00329 };
00330 #else
00331 template <class MetaNamespace>
00332 struct free_functions;
00333 #endif
00334 
00335 template <>
00336 struct required_param_of<free_functions>
00337 {
00338     typedef mirror::meta_namespace_tag type;
00339 };
00340 
00341 #ifdef MIRROR_DOCUMENTATION_ONLY
00342 
00343 
00351 template <class MetaOverloadedFunctions>
00352 struct overloads
00353 {
00355     typedef Range<MetaFunction> type;
00356 };
00357 #else
00358 template <class MetaOverloadedFunctions>
00359 struct overloads;
00360 #endif
00361 
00362 template <>
00363 struct required_param_of<overloads>
00364 {
00365     typedef mirror::meta_class_tag type;
00366 };
00367 
00368 template <class VariableSelector>
00369 struct meta_ovlded_free_funcs;
00370 
00371 //  Specialization of meta_object_category for meta_ovlded_free_funcs'
00372 template <typename Selector>
00373 struct meta_object_category<meta_ovlded_free_funcs<Selector> >
00374 {
00375     typedef meta_overloaded_functions_tag type;
00376 };
00377 
00378 template <class VariableSelector, int Index>
00379 struct meta_free_function;
00380 
00381 template <typename FunctionSelector, int FuncIndex>
00382 struct meta_object_category<
00383     meta_free_function<FunctionSelector, FuncIndex>
00384 >
00385 {
00386     typedef meta_function_tag type;
00387 };
00388 
00389 // Forward declaration of the meta_free_func_param template
00390 template <typename FunctionSelector, int FuncIndex, int ParamIndex>
00391 struct meta_free_func_param;
00392 
00393 template <typename FunctionSelector, int FuncIndex, int ParamIndex>
00394 struct meta_object_category<
00395     meta_free_func_param<FunctionSelector, FuncIndex, ParamIndex>
00396 >
00397 {
00398     typedef meta_parameter_tag type;
00399 };
00400 
00401 //  Namespace containing basic meta-data about registered free functions
00402 /*  Every (overloaded) free function registered with Mirror is registered inside
00403  *  of this (Mirror's internal _function) namespace.
00404  *  Do NOT use the contents of this namespace directly for anything
00405  *  else than registering the variables.
00406  */
00407 namespace _function { }
00408 
00409 //  Namespace containing basic meta-data about registered container classes
00410 /*  Every container registered with Mirror is registered inside of this
00411  *  (Mirror's internal) namespace .
00412  *  Do NOT use the contents of this namespace directly for anything
00413  *  else than registering the containers.
00414  */
00415 namespace _container {
00416 
00417 template <typename Container>
00418 struct _;
00419 
00420 } // namespace _container
00421 
00422 #ifdef MIRROR_DOCUMENTATION_ONLY
00423 
00424 
00431 template <class MetaClass>
00432 struct base_classes
00433 {
00435     typedef Range<MetaInheritance> type;
00436 };
00437 #else
00438 template <class MetaClass>
00439 struct base_classes;
00440 #endif
00441 
00442 template <>
00443 struct required_param_of<base_classes>
00444 {
00445     typedef mirror::meta_class_tag type;
00446 };
00447 
00448 // Forward declaration of the meta_inheritance template
00449 template <class Class, class BaseMetaInheritance>
00450 struct meta_inheritance;
00451 
00452 
00453 //  Specialization of meta_object_category for meta_inheritances
00454 template <class Class, class BaseMetaInheritance>
00455 struct meta_object_category< meta_inheritance<Class, BaseMetaInheritance> >
00456 {
00457     typedef meta_inheritance_tag type;
00458 };
00459 
00467 #ifdef MIRROR_DOCUMENTATION_ONLY
00468 
00469 
00477 template <class MetaType>
00478 struct original_type
00479 {
00481     typedef unspecified type;
00482 };
00483 #else
00484 template <class MetaType>
00485 struct original_type;
00486 #endif
00487 
00488 template <>
00489 struct required_param_of<original_type>
00490 {
00491     typedef mirror::meta_type_tag type;
00492 };
00493 
00494 #ifdef MIRROR_DOCUMENTATION_ONLY
00495 
00496 
00504 template <class MetaNamedObject>
00505 struct static_name
00506 {
00508     typedef CompileTimeString type;
00509 };
00510 #else
00511 template <class MetaNamedObject>
00512 struct static_name;
00513 #endif
00514 
00515 template <>
00516 struct required_param_of<static_name>
00517 {
00518     typedef mirror::meta_named_object_tag type;
00519 };
00520 
00521 #ifdef MIRROR_DOCUMENTATION_ONLY
00522 
00523 
00531 template <class MetaScopedObject>
00532 struct scope
00533 {
00535     typedef MetaScope type;
00536 };
00537 #else
00538 template <class MetaScopedObject>
00539 struct scope;
00540 #endif
00541 
00542 template <>
00543 struct required_param_of<scope>
00544 {
00545     typedef mirror::meta_scoped_object_tag type;
00546 };
00547 
00548 #ifdef MIRROR_DOCUMENTATION_ONLY
00549 
00550 
00570 template <class MetaType, class ModifierLambdaExpression>
00571 struct apply_modifier
00572 {
00574     typedef MetaType type;
00575 };
00576 #else
00577 template <class MetaType, class ModifierLambdaExpression>
00578 struct apply_modifier;
00579 #endif
00580 
00581 #ifdef MIRROR_DOCUMENTATION_ONLY
00582 
00583 
00591 template <class MetaType>
00592 struct container_kind
00593 {
00595     typedef ContainerTypeTag type;
00596 };
00597 #else
00598 template <class MetaType>
00599 struct container_kind;
00600 #endif
00601 
00602 template <>
00603 struct required_param_of<container_kind>
00604 {
00605     typedef mirror::meta_type_tag type;
00606 };
00607 
00608 #ifdef MIRROR_DOCUMENTATION_ONLY
00609 
00610 
00618 template <class MetaClass>
00619 struct elaborated_type
00620 {
00622     typedef ElaboratedTypeTag type;
00623 };
00624 #else
00625 template <class MetaClass>
00626 struct elaborated_type;
00627 #endif
00628 
00629 template <>
00630 struct required_param_of<elaborated_type>
00631 {
00632     typedef mirror::meta_class_tag type;
00633 };
00634 
00635 #ifdef MIRROR_DOCUMENTATION_ONLY
00636 
00637 
00645 template <class MetaVariable>
00646 struct storage_class
00647 {
00649     typedef StorageClassTag type;
00650 };
00651 #else
00652 template <class MetaVariable>
00653 struct storage_class;
00654 #endif
00655 
00656 template <>
00657 struct required_param_of<storage_class>
00658 {
00659     typedef mirror::meta_variable_tag type;
00660 };
00661 
00662 #ifdef MIRROR_DOCUMENTATION_ONLY
00663 
00664 
00672 template <class MetaFunction>
00673 struct linkage
00674 {
00676     typedef StorageClassTag type;
00677 };
00678 #else
00679 template <class MetaFunction>
00680 struct linkage;
00681 #endif
00682 
00683 template <>
00684 struct required_param_of<linkage>
00685 {
00686     typedef mirror::meta_function_tag type;
00687 };
00688 
00689 #ifdef MIRROR_DOCUMENTATION_ONLY
00690 
00691 
00698 template <class MetaMemberFunction>
00699 struct constness
00700 {
00702     typedef ConstnessTag type;
00703 };
00704 #else
00705 template <class MetaMemberFunction>
00706 struct constness;
00707 #endif
00708 
00709 template <>
00710 struct required_param_of<constness>
00711 {
00712     typedef mirror::meta_member_function_tag type;
00713 };
00714 
00715 #ifdef MIRROR_DOCUMENTATION_ONLY
00716 
00717 
00725 template <class MetaInheritance>
00726 struct inheritance_type
00727 {
00729     typedef InheritanceTypeTag type;
00730 };
00731 #else
00732 template <class MetaInheritance>
00733 struct inheritance_type;
00734 #endif
00735 
00736 template <>
00737 struct required_param_of<inheritance_type>
00738 {
00739     typedef mirror::meta_inheritance_tag type;
00740 };
00741 
00742 #ifdef MIRROR_DOCUMENTATION_ONLY
00743 
00744 
00753 template <class MetaInheritance>
00754 struct base_class
00755 {
00757     typedef MetaClass type;
00758 };
00759 #else
00760 template <class MetaInheritance>
00761 struct base_class;
00762 #endif
00763 
00764 template <>
00765 struct required_param_of<base_class>
00766 {
00767     typedef mirror::meta_inheritance_tag type;
00768 };
00769 
00770 #ifdef MIRROR_DOCUMENTATION_ONLY
00771 
00772 
00781 template <class MetaInheritance>
00782 struct derived_class
00783 {
00785     typedef MetaClass type;
00786 };
00787 #else
00788 template <class MetaInheritance>
00789 struct derived_class;
00790 #endif
00791 
00792 template <>
00793 struct required_param_of<derived_class>
00794 {
00795     typedef mirror::meta_inheritance_tag type;
00796 };
00797 
00798 #ifdef MIRROR_DOCUMENTATION_ONLY
00799 
00800 
00809 template <class MetaInheritance>
00810 struct base_class_access_type
00811 {
00813     typedef AccessTypeTag type;
00814 };
00815 #else
00816 template <class MetaInheritance>
00817 struct base_class_access_type;
00818 #endif
00819 
00820 template <>
00821 struct required_param_of<base_class_access_type>
00822 {
00823     typedef mirror::meta_inheritance_tag type;
00824 };
00825 
00826 #ifdef MIRROR_DOCUMENTATION_ONLY
00827 
00828 
00837 template <class MetaClassMember>
00838 struct class_member_access_type
00839 {
00841     typedef AccessTypeTag type;
00842 };
00843 #else
00844 template <class MetaClassMember>
00845 struct class_member_access_type;
00846 #endif
00847 
00848 template <>
00849 struct required_param_of<class_member_access_type>
00850 {
00851     typedef mirror::meta_class_member_tag type;
00852 };
00853 
00854 #ifdef MIRROR_DOCUMENTATION_ONLY
00855 
00856 
00865 template <class MetaTemplatedType>
00866 struct type_template
00867 {
00869     typedef MetaTypeTemplate type;
00870 };
00871 #else
00872 template <class MetaTemplatedType>
00873 struct type_template;
00874 #endif
00875 
00876 template <>
00877 struct required_param_of<type_template>
00878 {
00879     typedef mirror::meta_templated_type_tag type;
00880 };
00881 
00882 #ifdef MIRROR_DOCUMENTATION_ONLY
00883 
00884 
00893 template <class MetaParameter>
00894 struct parameter_position
00895 {
00897     typedef IntegralConstantType type;
00898 };
00899 #else
00900 template <class MetaParameter>
00901 struct parameter_position;
00902 #endif
00903 
00904 template <>
00905 struct required_param_of<parameter_position>
00906 {
00907     typedef mirror::meta_parameter_tag type;
00908 };
00909 
00910 
00911 #ifdef MIRROR_DOCUMENTATION_ONLY
00912 
00913 
00923 template <class MetaClass>
00924 struct member_variables
00925 {
00927     typedef Range<MetaMemberVariable> type;
00928 };
00929 #else
00930 template <class MetaClass>
00931 struct member_variables;
00932 #endif
00933 
00934 template <>
00935 struct required_param_of<member_variables>
00936 {
00937     typedef mirror::meta_class_tag type;
00938 };
00939 
00940 // Forward declaration of the meta_member_variable template
00941 template <class Class, int Index>
00942 struct meta_member_variable;
00943 
00944 
00945 // The specialization of meta_object_category for meta_member_variabless
00946 // is defined in meta_class.hpp
00947 
00948 #ifdef MIRROR_DOCUMENTATION_ONLY
00949 
00950 
00958 template <class MetaClass>
00959 struct class_layout
00960 {
00962     typedef Range<MetaClass> type;
00963 };
00964 #else
00965 template <class MetaClass>
00966 struct class_layout;
00967 #endif
00968 
00969 template <>
00970 struct required_param_of<class_layout>
00971 {
00972     typedef mirror::meta_class_tag type;
00973 };
00974 
00975 #ifdef MIRROR_DOCUMENTATION_ONLY
00976 
00977 
00987 template <class MetaClass>
00988 struct all_member_variables
00989 {
00991     typedef Range<MetaMemberVariable> type;
00992 };
00993 #else
00994 template <class MetaClass>
00995 struct all_member_variables;
00996 #endif
00997 
00998 template <>
00999 struct required_param_of<all_member_variables>
01000 {
01001     typedef mirror::meta_class_tag type;
01002 };
01003 
01004 #ifdef MIRROR_DOCUMENTATION_ONLY
01005 
01006 
01014 template <class MetaClass>
01015 struct constructors
01016 {
01018     typedef Range<MetaConstructor> type;
01019 };
01020 #else
01021 template <class MetaClass>
01022 struct constructors;
01023 #endif
01024 
01025 template <>
01026 struct required_param_of<constructors>
01027 {
01028     typedef mirror::meta_class_tag type;
01029 };
01030 
01031 // Forward declaration of the meta_constructor template
01032 template <class Class, int Index>
01033 struct meta_constructor;
01034 
01035 template <class Class, int Index>
01036 struct meta_object_category< meta_constructor<Class, Index> >
01037 {
01038     typedef meta_constructor_tag type;
01039 };
01040 
01041 // Forward declaration of the meta_constructor_param template
01042 template <typename Type, int ConstrIndex, int ParamIndex>
01043 struct meta_constructor_param;
01044 
01045 template <typename Type, int ConstrIndex, int ParamIndex>
01046 struct meta_object_category<
01047     meta_constructor_param<Type, ConstrIndex, ParamIndex>
01048 >
01049 {
01050     typedef meta_parameter_tag type;
01051 };
01052 
01053 template <class Class>
01054 struct meta_initializer;
01055 
01056 template <class Class>
01057 struct meta_object_category< meta_initializer<Class> >
01058 {
01059     typedef meta_constructor_tag type;
01060 };
01061 
01062 // Forward declaration of the meta_constructor_param template
01063 template <typename Type>
01064 struct meta_initializer_param;
01065 
01066 template <typename Type>
01067 struct meta_object_category<meta_initializer_param<Type> >
01068 {
01069     typedef meta_parameter_tag type;
01070 };
01071 
01072 #ifdef MIRROR_DOCUMENTATION_ONLY
01073 
01074 
01082 template <class MetaClass>
01083 struct member_functions
01084 {
01086     typedef Range<MetaMemberFunction> type;
01087 };
01088 #else
01089 template <class MetaClass>
01090 struct member_functions;
01091 #endif
01092 
01093 template <>
01094 struct required_param_of<member_functions>
01095 {
01096     typedef mirror::meta_class_tag type;
01097 };
01098 
01099 template <class Class, int FuncIndex>
01100 struct meta_ovlded_mem_funcs;
01101 
01102 //  Specialization of meta_object_category for meta_ovlded_mem_funcs'
01103 template <typename Class, int FuncIndex>
01104 struct meta_object_category<meta_ovlded_mem_funcs<Class, FuncIndex> >
01105 {
01106     typedef meta_overloaded_functions_tag type;
01107 };
01108 
01109 // Forward declaration of the meta_member_function template
01110 template <class Class, int FuncIndex, int OvldIndex>
01111 struct meta_member_function;
01112 
01113 //  Specialization of meta_object_category for meta_member_functions
01114 template <class Class, int FuncIndex, int OvldIndex>
01115 struct meta_object_category< meta_member_function<Class, FuncIndex, OvldIndex> >
01116 {
01117     typedef meta_member_function_tag type;
01118 };
01119 
01120 // Forward declaration of the meta_mem_function_param template
01121 template <typename Type, int FnIndex, int OvldIndex, int ParamIndex>
01122 struct meta_mem_function_param;
01123 
01124 //  Specialization of meta_object_category for meta_inheritances
01125 template <typename Type, int FnIndex, int OvldIndex, int ParamIndex>
01126 struct meta_object_category<
01127     meta_mem_function_param<Type, FnIndex, OvldIndex, ParamIndex>
01128 >
01129 {
01130     typedef meta_parameter_tag type;
01131 };
01132 
01133 #ifdef MIRROR_DOCUMENTATION_ONLY
01134 
01135 
01143 template <class MetaClass>
01144 struct conversions
01145 {
01147     typedef Range<MetaMemberFunction> type;
01148 };
01149 #else
01150 template <class MetaClass>
01151 struct conversions;
01152 #endif
01153 
01154 template <>
01155 struct required_param_of<conversions>
01156 {
01157     typedef mirror::meta_class_tag type;
01158 };
01159 
01160 // Forward declaration of the meta_conversion_operator template
01161 template <class Class, class Result>
01162 struct meta_conversion_operator;
01163 
01164 // Specialization of meta_object_category for meta_conversion_operators
01165 template <class Class, class Result>
01166 struct meta_object_category< meta_conversion_operator<Class, Result> >
01167 {
01168     typedef meta_conversion_operator_tag type;
01169 };
01170 
01171 
01172 #ifdef MIRROR_DOCUMENTATION_ONLY
01173 
01174 
01181 template <class MetaFunction>
01182 struct parameters
01183 {
01185     typedef Range<MetaParameter> type;
01186 };
01187 #else
01188 template <class MetaFunction>
01189 struct parameters;
01190 #endif
01191 
01192 template <>
01193 struct required_param_of<parameters>
01194 {
01195     typedef mirror::meta_class_tag type;
01196 };
01197 
01198 
01199 // Forward declaration of the meta_enum template
01200 template <class Enum>
01201 struct meta_enum;
01202 
01203 //  Namespace containing basic meta-data about registered enum classes
01204 /*  Every enum registered with Mirror has a separate specialization
01205  *  of a helper structure containing the basic meta-data about
01206  *  the registered enumeration
01207  */
01208 namespace _enum {
01209 
01210 // Specialization of this structure provide basic meta-data about enumerations
01211 template <typename Enum>
01212 struct _;
01213 
01214 } // namespace _enum
01215 
01216 //  Specialization of meta_object_category for meta_enums
01217 template <class Enum>
01218 struct meta_object_category< meta_enum<Enum> >
01219 {
01220     typedef meta_enum_tag type;
01221 };
01222 
01223 // Forward declaration of the meta_enum_value template
01224 template <class Enum, int Index>
01225 struct meta_enum_value;
01226 
01227 //  Specialization of meta_object_category for meta_enums
01228 template <class Enum, int Index>
01229 struct meta_object_category< meta_enum_value<Enum, Index> >
01230 {
01231     typedef meta_enum_value_tag type;
01232 };
01233 
01234 #ifdef MIRROR_DOCUMENTATION_ONLY
01235 
01236 
01243 template <class MetaEnum>
01244 struct enum_values
01245 {
01247     typedef Range<MetaEnumValue> type;
01248 };
01249 #else
01250 template <class MetaEnum>
01251 struct enum_values;
01252 #endif
01253 
01254 template <>
01255 struct required_param_of<enum_values>
01256 {
01257     typedef mirror::meta_enum_tag type;
01258 };
01259 
01260 #ifdef MIRROR_DOCUMENTATION_ONLY
01261 
01262 
01269 template <class MetaVariable>
01270 struct type_of
01271 {
01273     typedef MetaType type;
01274 };
01275 #else
01276 template <class MetaVariable>
01277 struct type_of;
01278 #endif
01279 
01280 template <>
01281 struct required_param_of<type_of>
01282 {
01283     typedef mirror::meta_variable_tag type;
01284 };
01285 
01286 #ifdef MIRROR_DOCUMENTATION_ONLY
01287 
01288 
01295 template <class MetaFunction>
01296 struct result_type
01297 {
01299     typedef MetaType type;
01300 };
01301 #else
01302 template <class MetaFunction>
01303 struct result_type;
01304 #endif
01305 
01306 template <>
01307 struct required_param_of<result_type>
01308 {
01309     typedef mirror::meta_function_tag type;
01310 };
01311 
01312 #ifdef MIRROR_DOCUMENTATION_ONLY
01313 
01314 
01320 template <class MetaEnum>
01321 struct enum_size
01322 {
01324     typedef IntegralConstantType type;
01325 };
01326 #else
01327 template <class MetaEnum>
01328 struct enum_size;
01329 #endif
01330 
01331 template <>
01332 struct required_param_of<enum_size>
01333 {
01334     typedef mirror::meta_enum_tag type;
01335 };
01336 
01337 template <class Container, class IsSpecial, int Index>
01338 struct meta_container;
01339 
01340 template <class Container, class IsSpecial, int Index>
01341 struct meta_object_category<meta_container<Container, IsSpecial, Index> >
01342 {
01343     typedef meta_container_tag type;
01344 };
01345 
01346 #ifdef MIRROR_DOCUMENTATION_ONLY
01347 
01348 
01357 template <class MetaType>
01358 struct containers
01359 {
01361     typedef Range<MetaContainer> type;
01362 };
01363 #else
01364 template <class MetaType>
01365 struct containers;
01366 #endif
01367 
01368 template <>
01369 struct required_param_of<containers>
01370 {
01371     typedef mirror::meta_type_tag type;
01372 };
01373 
01374 #ifdef MIRROR_DOCUMENTATION_ONLY
01375 
01376 
01386 template <class MetaClass>
01387 struct all_containers
01388 {
01390     typedef Range<MetaContainer> type;
01391 };
01392 #else
01393 template <class MetaClass>
01394 struct all_containers;
01395 #endif
01396 
01397 template <>
01398 struct required_param_of<all_containers>
01399 {
01400     typedef mirror::meta_class_tag type;
01401 };
01402 
01403 #ifdef MIRROR_DOCUMENTATION_ONLY
01404 
01405 
01413 template <class MetaContainer>
01414 struct default_traversal
01415 {
01417     typedef MetaTraversal type;
01418 };
01419 #else
01420 template <class MetaContainer>
01421 struct default_traversal;
01422 #endif
01423 
01424 template <>
01425 struct required_param_of<default_traversal>
01426 {
01427     typedef mirror::meta_container_tag type;
01428 };
01429 
01430 #ifdef MIRROR_DOCUMENTATION_ONLY
01431 
01432 
01440 template <class MetaContainer>
01441 struct traversals
01442 {
01444     typedef Range<MetaTraversal> type;
01445 };
01446 #else
01447 template <class MetaContainer>
01448 struct traversals;
01449 #endif
01450 
01451 template <>
01452 struct required_param_of<traversals>
01453 {
01454     typedef mirror::meta_container_tag type;
01455 };
01456 
01457 #ifdef MIRROR_DOCUMENTATION_ONLY
01458 
01459 
01466 template <class MetaContainer>
01467 struct locators
01468 {
01470     typedef Range<MetaLocator> type;
01471 };
01472 #else
01473 template <class MetaContainer>
01474 struct locators;
01475 #endif
01476 
01477 template <>
01478 struct required_param_of<locators>
01479 {
01480     typedef mirror::meta_container_tag type;
01481 };
01482 
01483 #ifdef MIRROR_DOCUMENTATION_ONLY
01484 
01485 
01493 template <class MetaContainer>
01494 struct inserters
01495 {
01497     typedef Range<MetaInserter> type;
01498 };
01499 #else
01500 template <class MetaContainer>
01501 struct inserters;
01502 #endif
01503 
01504 template <>
01505 struct required_param_of<inserters>
01506 {
01507     typedef mirror::meta_container_tag type;
01508 };
01509 
01510 #ifdef MIRROR_DOCUMENTATION_ONLY
01511 
01512 
01520 template <class MetaContainer>
01521 struct erasers
01522 {
01524     typedef Range<MetaEraser> type;
01525 };
01526 #else
01527 template <class MetaContainer>
01528 struct erasers;
01529 #endif
01530 
01531 template <>
01532 struct required_param_of<erasers>
01533 {
01534     typedef mirror::meta_container_tag type;
01535 };
01536 
01537 #ifdef MIRROR_DOCUMENTATION_ONLY
01538 
01539 
01545 template <class MetaMetaObject>
01546 struct generalizations
01547 {
01549     typedef Range<MetaEraser> type;
01550 };
01551 #else
01552 template <class MetaMetaObject>
01553 struct generalizations;
01554 #endif
01555 
01556 template <>
01557 struct required_param_of<generalizations>
01558 {
01559     typedef mirror::meta_meta_object_tag type;
01560 };
01561 
01562 #ifdef MIRROR_DOCUMENTATION_ONLY
01563 
01564 
01571 template <class MetaObject>
01572 struct tags
01573 {
01575     typedef Range<Tag> type;
01576 };
01577 #else
01578 template <class MetaObject>
01579 struct tags;
01580 #endif
01581 
01582 template <>
01583 struct required_param_of<tags>
01584 {
01585     typedef mirror::meta_object_tag type;
01586 };
01587 
01588 #ifdef MIRROR_DOCUMENTATION_ONLY
01589 
01590 
01604 template <typename Type>
01605 struct reflected
01606 {
01608     typedef MetaType type;
01609 };
01610 #else
01611 template <typename Type>
01612 struct reflected;
01613 #endif
01614 
01615 template <>
01616 struct required_param_of<reflected>
01617 {
01618     typedef mirror::non_meta_object_tag type;
01619 };
01620 
01621 #ifdef MIRROR_DOCUMENTATION_ONLY
01622 
01623 
01643 template <typename Type>
01644 struct reflected_type
01645 { };
01646 #else
01647 template <typename Type>
01648 struct reflected_type;
01649 #endif
01650 
01651 MIRROR_NAMESPACE_END
01652 
01653 #endif //include guard
01654 

Copyright © 2006-2011 Matus Chochlik, University of Zilina, Zilina, Slovakia.
<matus.chochlik -at- fri.uniza.sk>
<chochlik -at -gmail.com>
Documentation generated on Fri Dec 16 2011 by Doxygen (version 1.7.3).
Important note: Although the 'boostified' version of Mirror uses the Boost C++ libraries Coding Guidelines and is implemented inside of the boost namespace, it IS NOT an officially reviewed and accepted Boost library. Mirror is being developed with the intention to be submitted for review for inclusion to the Boost C++ libraries.