Mirror reflection library 0.5.13
|
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