1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
// Macros to help static Handles not to be "constructed" before main run
// In order to avoid it, the Handle to be statically reserved is encapsulated
// in a structure itself designated through a Null Pointer :
// Only the pointer is declared static, and initialized to NULL : then,
// there is no routine to call for static construction
// Remember that the objet designated by a static Handle should not be created
// in the static declaration, but must anyway be created, during main run,
// once before its first use : this is the initialization step.
// This set of macros allows user to simply declare and use "static" Handles.
// It is available once having included this file :
// ***************************************************
// #include <Interface_Statics.hxx>
// Static construction is replaced by using the macro StaticHandle :
// ***************************************************
// Old statement : static Handle(pk_class) object;
// Is replaced by : StaticHandle(pk_class,object);
// which creates a null pointer called 'object_s' and typed 'pk_class_struc'
// For first initialisation and use, several ways are available, all of them
// give an access to the Handle through a reference.
// It is required to initialize the static structure once, the macros Init*
// assume that it is created once and only once, even if they are called
// more than once.
// It is possible : to create the object at initialization time by a macro,
// or to create it after the macro call through its reference :
// ***************************************************
// Old statement (in a routine, not static) :
// if (object.IsNull()) object = new pk_class (..args if any..);
// can be maintained, but preceeded by an initialization :
// InitHandle(pk_class,object); // -> Null Handle
// ***************************************************
// or it can be replaced by a direct formula (creation called only once) :
// InitHandleVoid(pk_class,object); // for a void constructor
// or InitHandleArgs(pk_class,object,(..args..));
// (the arglist between embedded parentheses)
// or InitHandleVal(pk_class,object,val); // i.e. object = val;
// To simply use this pseudo-static object, consider
// either the static variable object_s->H
// ***************************************************
// or take it by the macro (which does not initialize it)
// UseHandle(pk_class,object);
// Declaration of a static Handle : first use for a given type
#define StaticHandle(type,var) static struct type##_struc { Handle(type) H; } *var##_s = NULL
// Another declaration for an already declared type (with StaticHandle)
#define StaticHandleA(type,var) static struct type##_struc *var##_s = NULL
// Using it (IT MUST HAVE BEEN FORMERLY INITIALIZED)
#define UseHandle(type,var) Handle(type)& var = var##_s->H
// Initializing it (as Null Handle)
#define InitHandle(type,var) \
if(!var##_s) { var##_s=new type##_struc; }\
Handle(type)& var = var##_s->H;
// Initializing it and Creating it by a Void Constructor
#define InitHandleVoid(type,var) \
if(!var##_s) { var##_s=new type##_struc; var##_s->H=new type; }\
Handle(type)& var = var##_s->H;
// Initializing it and Creating it by a Constructor with Arguments
// (give them grouped in their parentheses)
#define InitHandleArgs(type,var,args) \
if(!var##_s) { var##_s=new type##_struc; var##_s->H=new type args; }\
Handle(type)& var = var##_s->H;
// Initializing it from an already determined Value
#define InitHandleVal(type,var,value) \
if(!var##_s) { var##_s=new type##_struc; var##_s->H=value; }\
Handle(type)& var = var##_s->H;
|
