#include <find_reflection_handler.h>
Public Types | |
| enum | GroupTraversal |
| different values for group traversal strategy More... | |
| enum | GroupKind |
| different support group types | |
Public Member Functions | |
| find_reflection_handler (const std::string &_target) | |
| construct from textual target description | |
| find_reflection_handler (const void *_target_ptr, bool _traverse_matched_groups) | |
| construct from member pointer and boolean flag that tells whether groups should be traversed in case that group pointer matches target | |
| bool | found_target () const |
| return whether target has been found | |
| bool | found_valid_target () const |
| return whether a valid target has been found. The semantic of being valid is defined in derived classes. | |
| void * | get_member_ptr () const |
| in case a valid target has been found, return a pointer to the member | |
| const std::string & | get_member_name () const |
| in case a valid target has been found, return the name of the member | |
| abst_reflection_traits * | get_reflection_traits () const |
| in case a valid target has been found, return a point to the reflection traits describing the type of the member | |
| virtual void | process_member_void (const std::string &member_name, void *member_ptr, abst_reflection_traits *rt, GroupKind group_kind=GK_NO_GROUP, unsigned grp_size=-1) |
| virtual method that is overloaded by derived classes to handle the target member | |
| int | reflect_group_begin (GroupKind group_kind, const std::string &group_name, void *group_ptr, abst_reflection_traits *rt, unsigned grp_size) |
| overload to navigate grouped reflection information | |
| void | reflect_group_end (GroupKind group_kind) |
| ensure that matched group pointers are found also in case that groups are traversed further and no group member corresponds to target pointer | |
| bool | reflect_member_void (const std::string &member_name, void *member_ptr, abst_reflection_traits *rt) |
| check for target during member reflection | |
| 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) |
| ignore methods | |
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 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 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 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 , 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 cgv::reflect::find_reflection_hander steers traversal to a specific member and calls the virtual function process_member() that can be overloaded by derived classes such as cgv::reflect::get_reflection_handler. The target member is specified in the constructor by a string. This can be either directly the name of the member or recursively use the dot and array operators to access members of members or elements of array members. A typical example could be complex_pnt_arr[4].x.re. Here the real part of the x coordinate of the 5th (indices start with 0) point is addressed.
Member Enumeration Documentation
◆ GroupTraversal
|
inherited |
different values for group traversal strategy
@ basic types with helper functions
Member Function Documentation
◆ is_creative()
|
virtualinherited |
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()
|
protectedvirtualinherited |
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()
|
protectedvirtualinherited |
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]
|
inherited |
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]
|
inherited |
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_method()
|
inherited |
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)".
The documentation for this class was generated from the following files:
- D:/develop/projects/git/cgv/cgv/reflect/find_reflection_handler.h
- D:/develop/projects/git/cgv/cgv/reflect/find_reflection_handler.cxx
