#include <reflection_handler.h>
Classes | |
| struct | nesting_info |
| for each nesting during traversal a nesting info is pushed back to the end of the nesting info stack More... | |
Public Types | |
| enum | GroupTraversal |
| different values for group traversal strategy More... | |
| enum | GroupKind |
| different support group types | |
Static Public Member Functions | |
| static std::string | group_traversal_name (GroupTraversal gt) |
| return the group traversals as a string | |
| static const char * | group_kind_name (GroupKind gk) |
| return the group kind as a string | |
| static bool | is_array_kind (GroupKind gk) |
| check whether a group kind is of array or vector kind | |
interface to be implemented by derived reflection handlers | |
| virtual int | reflect_group_begin (GroupKind group_kind, const std::string &group_name, void *group_ptr, abst_reflection_traits *rt, unsigned grp_size=-1) |
| abstract interface to start reflection of a group of members. More... | |
| virtual void | reflect_group_end (GroupKind group_kind) |
| abstract interface to terminate reflection of a group of members More... | |
| virtual bool | reflect_member_void (const std::string &member_name, void *member_ptr, abst_reflection_traits *rt)=0 |
| virtual bool | reflect_method_void (const std::string &method_name, method_interface *mi_ptr, abst_reflection_traits *return_traits, const std::vector< abst_reflection_traits * > ¶m_value_traits)=0 |
| virtual | ~reflection_handler () |
| declare virtual destructor | |
interface used by reflect and self_reflect functions | |
| virtual bool | is_creative () const |
| give information on whether reflection_handler creates object (defaults to false) More... | |
| template<typename T > | |
| bool | reflect_member (const std::string &member_name, T &member_ref, bool hard_cast=false) |
| template<typename M > | |
| bool | reflect_method (const std::string &method_name, M m) |
| template<typename B > | |
| bool | reflect_base (B &base_ref) |
| reflect a base class with its members | |
| template<typename T , unsigned n> | |
| bool | reflect_member (const std::string &member_name, T(&member_ref)[n]) |
| reflect a member of constant size array type | |
| template<typename T > | |
| bool | reflect_member (const std::string &member_name, std::vector< T > &member_ref) |
| reflect a member of vector type | |
| template<typename T > | |
| bool | reflect_member (const std::string &member_name, T *&member_ref) |
| reflect a member of pointer type. More... | |
| template<typename T , typename S > | |
| bool | reflect_array (const std::string &member_name, T *&member_ref, S &size) |
| reflect a dynamic array member of vector type | |
Detailed Description
the self reflection handler is passed to the virtual self_reflect() method of cgv::base::base. It is used to process type information by describing member variables and function (methods) to the handler with its templated methods reflect_member() and reflect_method() or the non templated versions with the suffix _void.
Member Enumeration Documentation
◆ GroupTraversal
different values for group traversal strategy
@ basic types with helper functions
Member Function Documentation
◆ is_creative()
|
virtual |
give information on whether reflection_handler creates object (defaults to false)
give information on whether reflection_handler creates object
Reimplemented in cgv::data::ascii_read_reflection_handler, and cgv::data::binary_read_reflection_handler.
◆ reflect_group_begin()
|
protectedvirtual |
abstract interface to start reflection of a group of members.
The return value gives information about further traversal of the group:
- GT_TERMINATE ... terminate traversal completely
- GT_SKIP ... skip traversal of group
- GT_COMPLETE ... traverse group completely
- index i >= 0 ... traverse only the i-th member of the group. Depending on the group kind, the remaining parameters are given as follows:
- GK_BASE_CLASS ... group_name and grp_size are undefined, group_ptr is pointer to instance of base class, rt reflects base class
- GK_STRUCTURE ... group_name is instance name, group_ptr is pointer to instance, rt reflects type of structure, grp_size is undefined,
- GK_VECTOR ... group_name is vector name, group_ptr is pointer to vector data structure, rt reflects element type, grp_size is size of vector
- GK_ARRAY ... group_name is array name, group_ptr is pointer to first array element, rt reflects element type, grp_size is size of array.
- GK_POINTER ... group_name is pointer name, group_ptr is pointer to first array element, rt reflects type to which pointer poits, grp_size is undefined.
Reimplemented in cgv::data::ascii_write_reflection_handler, cgv::data::ascii_read_reflection_handler, cgv::data::ascii_reflection_handler, and cgv::reflect::debug_reflection_handler.
◆ reflect_group_end()
|
protectedvirtual |
abstract interface to terminate reflection of a group of members
This function should only be called if group is traversed completely.
Reimplemented in cgv::data::ascii_reflection_handler, and cgv::reflect::debug_reflection_handler.
◆ reflect_member() [1/2]
| bool cgv::reflect::reflection_handler::reflect_member | ( | const std::string & | member_name, |
| T & | member_ref, | ||
| bool | hard_cast = false |
||
| ) |
call this to reflect a member by member name and reference to the member. The member type is deduced from the reference via templates. The method uses reflect_member_impl to dispath types with implementation of a self_reflect method and types without. For polymorphic objects with a polymorphic self_reflect() method the parameter hard_cast steers whether the concrete implementation T::self_reflect() is used or the overloaded function member_ref.self_reflect(). This is important for self reflection of base classes in polymorphic objects where hard_cast is set to true. In most other cases one can use the default argument false.
◆ reflect_member() [2/2]
| bool cgv::reflect::reflection_handler::reflect_member | ( | const std::string & | member_name, |
| T *& | member_ref | ||
| ) |
reflect a member of pointer type.
This is only a minimal implementation that allows pointers to memory allocated with new. No reference counting or pointers into memory ranges allocated differently are supported. This will be later on.
◆ reflect_member_void()
|
protectedpure virtual |
abstract interface to reflect a member variable, where the member type is specified as a string. Returns whether to continue the reflection.
Implemented in cgv::data::ascii_write_reflection_handler, cgv::data::ascii_read_reflection_handler, cgv::data::binary_write_reflection_handler, cgv::data::binary_read_reflection_handler, cgv::reflect::find_reflection_handler, and cgv::reflect::debug_reflection_handler.
◆ reflect_method()
| bool cgv::reflect::reflection_handler::reflect_method | ( | const std::string & | method_name, |
| M | m | ||
| ) |
call this to reflect a method by method name and reference to the member. The method type is deduced from the reference via templates. This only works, if you additionally include the header <cgv/reflect/method_interface_impl.h>, where the template code is located. This header is not included automatically, because of its length.
To give names to the parameters, append them to the name enclosed in parenthesis, i.e. "sin(x)" or "dot_prod(p,q)".
◆ reflect_method_void()
|
protectedpure virtual |
abstract interface to reflect a method, where return and parameter types are specified as strings. Returns whether to continue the reflection.
Implemented in cgv::reflect::find_reflection_handler, cgv::reflect::debug_reflection_handler, and cgv::data::io_reflection_handler.
The documentation for this class was generated from the following files:
- D:/develop/projects/git/cgv/cgv/reflect/reflection_handler.h
- D:/develop/projects/git/cgv/cgv/reflect/reflection_handler.cxx
