theKernel 10.0
Loading...
Searching...
No Matches
Topics | Data Structures | Macros | Functions
MkTypeC_C_API
MK_C_API

MkTypeS - class known as typ or type is used as class-base for a Managed-Object-Technology (MOT) type … More...

+ Collaboration diagram for MkTypeC_C_API:

Topics

 MkTypeC_Class_C_API
 MkTypeS - define the class …
 
 MkTypeC_TOR_C_API
 MkTypeS - various functions to create, initialize and destroy a type …
 
 MkTypeC_Misc_C_API
 MkTypeS - various functions to work on type-data …
 
 MkTypeC_Class_Define_C_API
 MkTypeS - low level definition, access and cast …
 
 MkTypeDefC_Class_Define_C_API
 MkTypeDefS - low level definition, access and cast …
 

Data Structures

struct  MkTypeS
 MkTypeS - class known as typ or type is used as class-base for a Managed-Object-Technology (MOT) type … More...
 
struct  MkTypeDefS
 super-class-base, the MkTypeS using the super-macro-syntax for all non specific types … More...
 

Macros

#define MkDbgTyp2(t, c)
 
#define MkDbgTyp(t)
 
#define MkDbgTypListAll2(t, c)
 
#define MkDbgTypListAll(t)
 
#define MkDbgTypInstances_2(t, c)
 
#define MkDbgTypInstances(t)
 
#define MkTYP_R(x)
 cast a known-managed-object into an MkTypeS reference
 
#define MkTYP(x)
 cast a known-managed-object into an MkTypeS pointer
 
#define MkTYP_O(o)
 cast an o-instance into an MkTypeS pointer
 
#define MkTYP_X(x)
 cast an x-instance into an MkTypeS pointer
 
#define MkTypeSlotResolve(_tt, fptr, force)
 search and return functionPtr(slot) for the tt-type.
 
#define MkTypeSlotCall(_tt, fptr, ...)
 

Functions

static MK_TYP MkTyp (const MK_MNG mng)
 type-check and cast a unknown-managed-object into an MkTypeS pointer or None if not possible
 
static MK_TYPN MkTypN (const MK_MNGN mng)
 type-check and cast a unknown-managed-object into an MkTypeS pointer or None if not possible
 
MK_PTR MkTypeSlotResolveP (MK_RT mkrt, MK_TYPN const type, size_t const offset, bool const force)
 hidden function for MkTypeSlotResolve
 

Detailed Description

MkTypeS - class known as typ or type is used as class-base for a Managed-Object-Technology (MOT) type …

In Managed-Object-Technology (MOT) everything is a struct, there is a class-type-struc and a instance-type-struc:

The class-type is derived from the MkTypeS and provide the type-property (static-property) and the type-method (slot).

The instance-type is derived from the MkObjectS and provide the instance-property and the instance-method.

The instance is full defined by min 4 structs and optional multiple base-structs/type(s) :

  1. instance-type -> instance-base(s) -> instance-final (MkObjectS)
  2. class-type -> class-base(s) -> class-final (MkTypeS)
  3. example:
    // instance-type | class-type
    // --------------------------------- | ---------------------------
    // |
    struct MyClassS { | struct MyClassTypeS { // default: MkTypeDefS
    union { | union {
    // required 'instance-final' | // always MkObjectS, a 'type' is also an 'object' !!
    struct MkObjectS { | struct MkObjectS obj;
    ... (pointer) | // required 'class-final'
    MK_TYP type; -> | struct MkTypeS typ;
    ... | ...
    } obj; | ...
    // optional 'instance-base' | // optional 'class-base'
    struct MyBaseClassS base; | struct MyBaseTypeS base;
    ... | ...
    } super; | } super;
    ... | ...
    } | }
    MkObjectS
    object header …
    Definition LibMkKernel_mk.h:3381
    MkTypeS
    MkTypeS - class known as typ or type is used as class-base for a Managed-Object-Technology (MOT) type...
    Definition LibMkKernel_mk.h:3945

The following naming-convention exist for the C-API (example: MkBufferC)

name definition
MkTypeDefS super-class-base, add the super.typ macro-syntay to the MkTypeS
— —
MkBufferS instance-type → This is the main-struct to define an instance
MkBufferST instance-type as MkTypeDefS-class-type
MkBufferSTT instance-type as MkTypeS-class-type (cast from MkBufferST into MkTypeS)
— —
MkBufferC_T class as MkTypeDefS-class-type, useable in a class-macro as: class##_T
MkBufferC_TT class as MkTypeS-class-type, useable in a class-macro as: class##_TT
— —
MK_BUF class-shortcut for struct MkBufferS *, all shortcut using the XX_YYY syntax (only for public API)
MK_BUFR class-shortcut for const struct MkBufferS *, all const shortcut using the XX_YYYC syntax (only for public API) …
MkBufferCR reference-shortcut for struct MkBufferS, all shortcut using the XX_YYYR syntax (only for public API)
— —
MkBufferCT_X(instance) cast from an instance into the MkTypeDefS-class-type
MkBufferCTT_X(instance) cast from an instance into the MkTypeS-class-type
MkBufferCT_TT(typ) cast from an MkTypeS-class-type into an MkTypeDefS-class-type
— —
MkBufferCT class as MkTypeDefS-class-type for MkBufferC in the Target-Programming-Language (TPL)
MkBufferCTT class as MkTypeS-class-type for MkBufferC in the Target-Programming-Language (TPL)

The struct(s) are defined as:

The class-type is able to create the instance.
  • The class-final is a type not able to create an instance but used as base-class for the class-type and the class-base
  • The class-base is a type and is used to initialize the type-properties and type-methods (called slots).
    • slot is a method predefined in the type like constructor.
    • A list of all slots are defined in MkTypeS.
  • Example MkBufferC : class == MkTypeS -> MkTypeDefS -> MkObjectST -> MkBufferST
The instance-type is able to configure the instance and provide access to the methods and slots.
  • The instance is a link between the instance-type and the class-type
  • Example MkBufferC : instance == MkBufferST + MkBufferS
  • The instance-base is a type and is used to provide the base-instance-properties
    • Example: The base MyBaseStruct add MyBaseStruct-properties
      struct MyBaseStruct {
      union {
      struct MkObjectS obj
      } super;
      // MyBaseStruct-properties
      }
      struct MyInstanceStruct {
      union {
      struct MkObjectS obj
      struct MyBaseStruct bse
      } super;
      // MyInstanceStruct-properties
      }

To use the specific-class-type as argument to a function or as property in a struct the common-class-type of type MkTypeS is used. To cast a specific-class-type into a common-class-type use:

  1. the path: type->super.typ
  2. the shortcut: MkTYP(type)->XYZ (pointer) or MkTYP_R(type).XYZ (reference)

To get the common-class-type from the instance use:

  1. the path: instance->super.obj.type
  2. the shortcut: MkOBJ(instance)->type (pointer) or MkOBJ_R(instance).type (reference)

To get the class-base from the class-type use:

  1. the path: instance->super.obj.type->type_base
  2. the shortcut: MkOBJ(instance)->type->type_base (pointer) or MkOBJ_R(instance).type->type_base (reference)

The predefined class-type is an instance of the default-class-type (MkTypeDefS) …

_struct MkRuntimeS {
...
struct MkTypeDefS _MkBufferST;
...
}
MkRuntimeS
The MkRuntimeS provide a per-thread environment for pymkkernel …
Definition LibMkKernel_mk.h:12051
MkTypeDefS
super-class-base, the MkTypeS using the super-macro-syntax for all non specific types …
Definition LibMkKernel_mk.h:4120

The properties and slots of the class-type are predefined by the class-base and may be overwritten …

MkInstanceTypeInit ( MkBufferC, MkObjectC ) ;
MkTYP_R(MkBufferST).destructor = (MkDestructorF) MkBufferDelete_RT ;
MkTYP_R(MkBufferST).dup = (MkDupF) MkBufferDup_RT ;
MkTYP_R(MkBufferST).merge = (MkMergeF) MkBufferMerge_RT ;
MkTYP_R(MkBufferST).copy = (MkCopyF) MkBufferCopy_RT ;
MkTYP_R(MkBufferST).reset = (MkResetF) MkBufferReset_RT ;
MkTYP_R(MkBufferST).log = (MkLogF) MkBufferLog_RT ;
MkTYP_R(MkBufferST).toString = (MkToStringF) MkBufferToString_RT ;

The following relationship between the three different struct exists:

  1. The class-type and the class-base have the super-class MkTypeS and the instance not.
  2. The class-final is a super-class of an class-type.
  3. The class-type has the 3 attributes MkTypeS::objsig, MkTypeS::objmask and MkTypeS::objsize defined, the class-final not.
  4. The instance has access to the class-type using the cast (example MkBufferCT_X(instance))
  5. The class-type has access to the class-base using MkTypeS::type_base and to the type using MkObjectS::type.

Macro Definition Documentation

◆ MkDbgTyp

#define MkDbgTyp ( t)
Value:
MkDbgTyp2(t,MK_COLOR_LIGHT_CYAN)
MkDbgTyp2
#define MkDbgTyp2(t, c)
Definition LibMkKernel_mk.h:3905

Definition at line 3909 of file LibMkKernel_mk.h.

◆ MkDbgTyp2

#define MkDbgTyp2 ( t,
c )
Value:
mk_dbg_color_ln(c,"MkDbgTyp[%-32s]: typ<ID=%-2d,P=%-14p,RT=%p> type_class<%s:%p>, " #t, \
MK_TRIM_LEFT(32,(t)->type_name), (t)->type_id, t, MkRT_X(t), \
(t)->type_class->type_name, (t)->type_class)
MkRT_X
#define MkRT_X(x)
Definition LibMkKernel_mk.h:12425

Definition at line 3905 of file LibMkKernel_mk.h.

3905#define MkDbgTyp2(t,c) \
3906 mk_dbg_color_ln(c,"MkDbgTyp[%-32s]: typ<ID=%-2d,P=%-14p,RT=%p> type_class<%s:%p>, " #t, \
3907 MK_TRIM_LEFT(32,(t)->type_name), (t)->type_id, t, MkRT_X(t), \
3908 (t)->type_class->type_name, (t)->type_class)

◆ MkDbgTypInstances

#define MkDbgTypInstances ( t)
Value:
MkDbgTypInstances_2(t,MK_COLOR_CYAN)
MkDbgTypInstances_2
#define MkDbgTypInstances_2(t, c)
Definition LibMkKernel_mk.h:3920

Definition at line 3940 of file LibMkKernel_mk.h.

◆ MkDbgTypInstances_2

#define MkDbgTypInstances_2 ( t,
c )
Value:
do { \
MK_TYP _typ = (t); \
if (_typ) { \
mk_dbg_start_2(c,"MkDbgTypInstances: %s[%p] ", _typ->type_name, _typ); \
int max=5; \
for (MK_OBJ obj=MkTypeInstances(_typ); obj; obj=MkObjectNext(obj)) { \
mk_dbg_next_2(c,"%p,",obj); \
max--; \
if(max==0) { \
mk_dbg_next_2(MK_COLOR_RED,"%s", "break"); \
break; \
} \
} \
mk_dbg_end(); \
} else { \
mk_dbg_color_ln(c,"MkDbgTypInstances: %s[%p] ", #t, _typ); \
} \
} while (0)
MkObjectNext
static MK_OBJ MkObjectNext(MK_OBJ const obj)
get next instance from linked-list of MkObjectS type
Definition LibMkKernel_mk.h:13364
MkTypeInstances
static MK_OBJ MkTypeInstances(MK_TYP const typ)
access the instance attribute of the type…
Definition LibMkKernel_mk.h:5114
MkTypeS::type_name
MK_STRB type_name[MkTypeS_name_size]
public name of the type like TclMqContextC
Definition LibMkKernel_mk.h:3956

Definition at line 3920 of file LibMkKernel_mk.h.

3920#define MkDbgTypInstances_2(t,c) \
3921do { \
3922 MK_TYP _typ = (t); \
3923 if (_typ) { \
3924 mk_dbg_start_2(c,"MkDbgTypInstances: %s[%p] ", _typ->type_name, _typ); \
3925 int max=5; \
3926 for (MK_OBJ obj=MkTypeInstances(_typ); obj; obj=MkObjectNext(obj)) { \
3927 mk_dbg_next_2(c,"%p,",obj); \
3928 max--; \
3929 if(max==0) { \
3930 mk_dbg_next_2(MK_COLOR_RED,"%s", "break"); \
3931 break; \
3932 } \
3933 } \
3934 mk_dbg_end(); \
3935 } else { \
3936 mk_dbg_color_ln(c,"MkDbgTypInstances: %s[%p] ", #t, _typ); \
3937 } \
3938} while (0)

◆ MkDbgTypListAll

#define MkDbgTypListAll ( t)
Value:
MkDbgTypListAll2(t,MK_COLOR_GREEN)
MkDbgTypListAll2
#define MkDbgTypListAll2(t, c)
Definition LibMkKernel_mk.h:3910

Definition at line 3918 of file LibMkKernel_mk.h.

◆ MkDbgTypListAll2

#define MkDbgTypListAll2 ( t,
c )
Value:
do { \
MK_OBJ o; \
MkRuntimeLogBufferPush(); \
DL_FOREACH2((t)->type_class->instancesR,o,obj_protect.next) { \
MkDbgTyp2(MkTyp(o),c); \
} \
MkRuntimeLogBufferPop(); \
} while (0)
MkTyp
static MK_TYP MkTyp(const MK_MNG mng)
type-check and cast a unknown-managed-object into an MkTypeS pointer or None if not possible
Definition LibMkKernel_mk.h:4085

Definition at line 3910 of file LibMkKernel_mk.h.

3910#define MkDbgTypListAll2(t,c) do { \
3911 MK_OBJ o; \
3912 MkRuntimeLogBufferPush(); \
3913 DL_FOREACH2((t)->type_class->instancesR,o,obj_protect.next) { \
3914 MkDbgTyp2(MkTyp(o),c); \
3915 } \
3916 MkRuntimeLogBufferPop(); \
3917} while (0)

◆ MkTYP

#define MkTYP ( x)
Value:
(&MkTYP_R(x))
MkTYP_R
#define MkTYP_R(x)
cast a known-managed-object into an MkTypeS reference
Definition LibMkKernel_mk.h:4106

cast a known-managed-object into an MkTypeS pointer

Definition at line 4108 of file LibMkKernel_mk.h.

◆ MkTYP_O

#define MkTYP_O ( o)
Value:
(*o).type

cast an o-instance into an MkTypeS pointer

Definition at line 4110 of file LibMkKernel_mk.h.

◆ MkTYP_R

#define MkTYP_R ( x)
Value:
(*(x)).super.typ

cast a known-managed-object into an MkTypeS reference

Definition at line 4106 of file LibMkKernel_mk.h.

◆ MkTYP_X

#define MkTYP_X ( x)
Value:
MkOBJ_R(x).type
MkOBJ_R
#define MkOBJ_R(x)
cast a known-object into an MkObjectS reference
Definition LibMkKernel_mk.h:3549

cast an x-instance into an MkTypeS pointer

Definition at line 4112 of file LibMkKernel_mk.h.

◆ MkTypeSlotCall

#define MkTypeSlotCall ( _tt,
fptr,
... )
Value:
do { \
typeof((_tt)->fptr) slot = MkTypeSlotResolve((_tt),fptr,false); \
if (slot) (*slot)(MK_RT_CALL __VA_ARGS__); \
} while (false)
MK_RT_CALL
#define MK_RT_CALL
Definition LibMkKernel_mk.h:895
MkTypeSlotResolve
#define MkTypeSlotResolve(_tt, fptr, force)
search and return functionPtr(slot) for the tt-type.
Definition LibMkKernel_mk.h:4207

Definition at line 4216 of file LibMkKernel_mk.h.

4216#define MkTypeSlotCall(_tt,fptr,...) do { \
4217 typeof((_tt)->fptr) slot = MkTypeSlotResolve((_tt),fptr,false); \
4218 if (slot) (*slot)(MK_RT_CALL __VA_ARGS__); \
4219} while (false)

◆ MkTypeSlotResolve

#define MkTypeSlotResolve ( _tt,
fptr,
force )
Value:
({ \
MK_TYP tt = (_tt) ; /* _tt my be long */ \
tt == NULL ? NULL : /* type not valid */ \
!force && tt->fptr == (MK_PTR) 0x1 ? NULL : /* already resolved, NOT found */ \
tt->fptr > (typeof(tt->fptr)) 0x1 ? tt->fptr : /* already resolved, NOT NULL, found */ \
tt == MkTypeSTT ? NULL : /* already at the ROOT of the type */ \
(typeof(tt->fptr)) MkTypeSlotResolveP(MK_RT_CALL tt, offsetof(struct MkTypeS, fptr), force); \
}) \
MK_PTR
MK_PTRB * MK_PTR
generic pointer data-type
Definition LibMkKernel_mk.h:1387
MkTypeSlotResolveP
MK_PTR MkTypeSlotResolveP(MK_RT mkrt, MK_TYPN const type, size_t const offset, bool const force)
hidden function for MkTypeSlotResolve
MkTypeSTT
#define MkTypeSTT
instance-type as MkTypeS-class-type
Definition LibMkKernel_mk.h:4029

search and return functionPtr(slot) for the tt-type.

The search start with tt-type and end with MkTypeS, the root of all types. With force=false the search is done only once and not-found is marked with 0x1. To be sure your functionPtr(slot) will be found add the slot very-early into the library boot. A good place will be at the Setup (constructor) or at the RuntimeSetup.

Returns
the functionPtr(slot) or None if not found
Parameters
[in]_ttthe start of the search, use MkTYP(mng) as input
[in]fptrthe attribute of tt to search for, use man offsetof for more info
[in]forceuse/notuse the 0x1 hint. If a new functionPtr(slot) was added the force=true will find it.
Attention
, this is a macro, only use arguments without overhead.

Definition at line 4207 of file LibMkKernel_mk.h.

4207#define MkTypeSlotResolve(_tt,fptr,force) ({ \
4208 MK_TYP tt = (_tt) ; /* _tt my be long */ \
4209 tt == NULL ? NULL : /* type not valid */ \
4210 !force && tt->fptr == (MK_PTR) 0x1 ? NULL : /* already resolved, NOT found */ \
4211 tt->fptr > (typeof(tt->fptr)) 0x1 ? tt->fptr : /* already resolved, NOT NULL, found */ \
4212 tt == MkTypeSTT ? NULL : /* already at the ROOT of the type */ \
4213 (typeof(tt->fptr)) MkTypeSlotResolveP(MK_RT_CALL tt, offsetof(struct MkTypeS, fptr), force); \
4214}) \
4215

Function Documentation

◆ MkTyp()

static MK_TYP MkTyp ( const MK_MNG mng)
inlinestatic

type-check and cast a unknown-managed-object into an MkTypeS pointer or None if not possible

Definition at line 4085 of file LibMkKernel_mk.h.

4085 {
4086 if (!MkObjCheck(mng)) return NULL;
4087 MK_OBJ obj = (MK_OBJ) mng;
4088 if (MkTypCheck(obj)) return (MK_TYP)obj;
4089 MK_TYP typ = obj->type;
4090 if (MkTypCheck(typ)) return typ;
4091 return NULL;
4092}
MK_OBJ
struct MkObjectS * MK_OBJ
class-shortcut for struct MkObjectS *, all shortcut using the XX_YYY syntax (only for public API) …
Definition LibMkKernel_mk.h:1506
MkObjCheck
static bool MkObjCheck(MK_MNGN mng)
check MkObjectS -> MkObjectS::signature …
Definition LibMkKernel_mk.h:3505
MkTypCheck
static bool MkTypCheck(MK_MNGN mng)
check MkTypeS -> MkObjectS::signature …
Definition LibMkKernel_mk.h:4060
MkObjectS::type
MK_TYP type
link to the object type
Definition LibMkKernel_mk.h:3391

◆ MkTypeSlotResolveP()

MK_PTR MkTypeSlotResolveP ( MK_RT mkrt,
MK_TYPN const type,
size_t const offset,
bool const force )

hidden function for MkTypeSlotResolve

◆ MkTypN()

static MK_TYPN MkTypN ( const MK_MNGN mng)
inlinestatic

type-check and cast a unknown-managed-object into an MkTypeS pointer or None if not possible

Definition at line 4096 of file LibMkKernel_mk.h.

4096 {
4097 if (!MkObjCheck(mng)) return NULL;
4098 MK_OBJ obj = (MK_OBJ) mng;
4099 if (MkTypCheck(obj)) return (MK_TYPN)obj;
4100 MK_TYPN typ = obj->type;
4101 if (MkTypCheck(typ)) return typ;
4102 return NULL;
4103}
Generated on Thu May 29 2025 13:13:26 for theKernel by doxygen 1.12.0