Core class for runtime type information in byeol language. More...
#include <type.hpp>
Public Member Functions | |
| virtual nbool | operator== (const me &rhs) const |
| Checks if two type objects represent the same type. | |
| nbool | operator!= (const me &rhs) const |
| virtual nbool | isTemplate () const =0 |
| virtual nbool | isAbstract () const =0 |
| virtual const std::string & | getName () const |
| virtual void * | make () const =0 |
| create an instance to be refered this type. | |
| template<typename T > | |
| T * | makeAs () const |
| virtual ncnt | size () const =0 |
| virtual nbool | init () |
| Initializes type metadata and constructs class hierarchy. | |
| virtual nbool | rel () |
| virtual const type & | getSuper () const =0 |
| virtual const nbool & | isInit () const =0 |
| const types & | getLeafs () const |
| Returns all most derived classes (leaf nodes) from this class. | |
| const types & | getSubs () const |
| const types & | getSupers () const |
| virtual nbool | isSuper (const type &it) const |
| Checks if this type is a super class of the given type. | |
| nbool | isSuper (const type *it) const BY_SIDE_FUNC(isSuper) |
| template<typename T > | |
| nbool | isSuper () const |
| nbool | isSub (const type &it) const |
| Checks if this type is a sub class of the given type. | |
| nbool | isSub (const type *it) const BY_SIDE_FUNC(isSub) |
| template<typename T > | |
| nbool | isSub () const |
| const type & | getStatic () const BY_CONST_FUNC(_getStatic()) virtual const nchar *getMetaTypeName() const |
| Get meta type name for efficient type checking. | |
Protected Member Functions | |
| virtual types & | _getSubs ()=0 |
| virtual types & | _getSupers ()=0 |
| virtual type & | _getStatic () const =0 |
| void | _setInit (nbool newState) |
| virtual void | _onAddSubClass (const me &subClass) |
| Hook method called when a new subclass is registered with this type. | |
| virtual types ** | _onGetLeafs () const =0 |
| void | _setLeafs (types *newLeafs) const |
| virtual const std::string & | _getNativeName () const |
Detailed Description
Core class for runtime type information in byeol language.
The central class of the meta module. Provides fundamental type information APIs.
Basic type identification
- isTemplate(): Returns whether this is a template class
- isAbstract(): Returns whether this is an abstract class
- getName(): Returns class name (demangled)
Class hierarchy information
- getSupers(): Returns list of super classes, with direct parent at the end
- getSubs(): Returns list of sub classes, with closest descendants first
- isSuper(const type& rhs): Checks if this is a super class of rhs
- isSub(const type& rhs): Checks if this is a sub class of rhs
Performance note: isSuper() and isSub() are more efficient than dynamic_cast. While dynamic_cast typically loops through vtables, the meta module uses a tier algorithm that compares tier values and char* addresses for O(1) type checking.
Instance creation
- make(): Creates instance using default constructor. Returns nullptr if no default constructor exists.
Meta type information management
- init(): Initializes type information
- rel(): Releases type information
These are typically handled automatically via BY_INIT_META macro and rarely need direct invocation.
How meta information is generated
Type information like isTemplate(), isAbstract(), and getName() is filled by ttypeBase<T> through metaprogramming. The purpose of type::init() is to construct the class hierarchy.
The hierarchy is built using the constraint that "all classes must define super as a typedef". With super defined for all classes, ttype<super>().init() can be called, enabling recursive class hierarchy construction:
Automatic meta information generation
Type objects are initialized via init() calls, but manually calling init() for every class would be inefficient. The BY_INIT_META macro solves this by using BY_INITIATOR to execute init() before main() via static object initialization with lambda functions.
The constraint is that each class declaration must include BY_INIT_META(MyClass). These meta DSL-style macros are executed through the BY macro convention, and core module adds additional meta DSL macros, so use BY(CLASS()) or BY(ADT()) instead of calling BY_INIT_META directly.
Adding custom meta information
While type provides substantial type information, language implementations like byeol may need additional information like parameters or return types. You might think to inherit from type, but since the user entry point must always be ttype<T>, and you cannot modify ttype<T> code from modules depending on meta, inheritance isn't possible. Instead, inject custom meta types.
The core code is in ttypeBase<T>:
tmetaTypeDef returns T::metaType if it exists, otherwise returns type. ttype inherits from ttypeBase, which inherits from tmetaTypeDef<T>::is. When calling ttype<T>, if class T defines typedef metaType MyType, the ttype<T> object will be based on MyType.
This feature is actually used in the core module to inject ntype. See ntype for details.
Member Function Documentation
◆ _onAddSubClass()
Hook method called when a new subclass is registered with this type.
Derived type classes can override this method to perform custom actions (e.g., updating internal structures or caches) whenever a new subClass is added to its hierarchy.
- Parameters
-
subClass The new subclass being added.
◆ getLeafs()
| const types & by::type::getLeafs | ( | ) | const |
Returns all most derived classes (leaf nodes) from this class.
- Returns
- Vector of type pointers representing all leaf classes in hierarchy
◆ getStatic()
Get meta type name for efficient type checking.
This returns metaTypename. metaTypename can be used like 'dynamic_cast<yourType>'. as you may know, c++'s dynamic_cast is slow. because normally compilers tries to loop in order to figure out which type is fit to given your type parameter. 'meta' library, however, uses 'tier' algorithm and it's O(1), so it's faster.
you can use your own metaType to represent more data on type class. for instance, 'core' module uses 'ntype' custom type class. but in that case, when you compare custom type class, you must compare extended data to 'rhs' variable to base type class, 'type'.
so how can you know that 'type' is actually instance of your derived custom type class in 'tier' algorithm? please don't think about 'dynamic_cast'. it'll vanish our effectiveness to use 'tier' algorithm. that's why I make 'getMetaTypeName()' func.
- Returns
- static literal c-style string for meta type name. so you are able to use c-style casting if address of 'rhs' variables's getMetaTypeName() isn just same to yours.
◆ init()
Initializes type metadata and constructs class hierarchy.
- Returns
- true on success, false if already initialized
- Note
- Recursively initializes super class hierarchy. Automatically called via BY_INIT_META macro before main(). Sets up super/sub relationships.
◆ isSub()
Checks if this type is a sub class of the given type.
- Returns
- true if this is a sub class of it, false otherwise
- Note
- Uses O(1) tier algorithm. Implemented as it.isSuper(*this).
◆ isSuper()
Checks if this type is a super class of the given type.
- Returns
- true if this is a super class of it, false otherwise
- Note
- Uses O(1) tier algorithm comparing tier values, much faster than dynamic_cast which typically loops through vtables.
◆ make()
create an instance to be refered this type.
- Remarks
- available when the type defines a ctor without any params.
- Returns
- return an address of new instance, however, if ctor without any params isn't defined, then returns null.
Implemented in by::ttypeBase< void, type >.
◆ operator==()
Checks if two type objects represent the same type.
This comparison typically checks if the underlying type information (e.g., name, template status) is identical.
- Parameters
-
rhs The other type object to compare with.
- Returns
- true if both type objects represent the same type, false otherwise.
The documentation for this class was generated from the following file:
- /home/runner/work/stela/stela/module/meta/type/type.hpp