Changes having to due with my new 2-pass function relocator code.
[dyninst.git] / pdutil / h / tunableConst.h
1 /*
2  * tunableConstant - a constant that might be changed during execution.
3  *
4  * $Log: tunableConst.h,v $
5  * Revision 1.10  1994/12/21 07:10:06  tamches
6  * Made the "allConstants" variable protected and added a few member
7  * functions to let outside code access it (safely) in a manner useful
8  * for doing iterations through all tunable-constants.
9  *
10  * Revision 1.9  1994/12/21  00:31:44  tamches
11  * Greatly cleaned up the interface; no data members are public any more.
12  * Also some minor changes, such as using g++'s built-in "bool" instead
13  * of "Boolean".
14  *
15  * Revision 1.8  1994/11/04  15:52:51  tamches
16  * setValue() for boolean tc's now correctly invokes its callback function, if any.
17  *
18  * Revision 1.7  1994/11/01  16:07:35  markc
19  * Added Object classes that provide os independent symbol tables.
20  * Added stl-like container classes with iterators.
21  *
22  * Revision 1.6  1994/10/26  22:32:50  tamches
23  * Defaulted min&max to 0 for floats with no min/max in constructor.
24  * Wrote min() and max() functions.
25  * Wrote use() function
26  * other minor changes to get to work with new tclTunable code
27  *
28  * Revision 1.5  1994/09/22  03:15:59  markc
29  * changed char* to const char *
30  *
31  * Revision 1.4  1994/08/05  16:01:55  hollings
32  * More consistant use of stringHandle vs. char *.
33  *
34  * Revision 1.3  1994/08/03  18:37:30  hollings
35  * split tunable constant into Boolean and Float sub-classes.
36  *
37  * Revision 1.2  1994/02/28  23:58:28  hollings
38  * Changed global list to be a pointer to a list because I couldn't rely on
39  * the order of global constructors.
40  *
41  * Revision 1.1  1994/02/25  00:25:58  hollings
42  * added tunable constants.
43  *
44  *
45  */
46 #ifndef TUNABLE_CONST_H
47 #define TUNABLE_CONST_H
48
49 #include <assert.h>
50 #include "util/h/stringPool.h"
51 #include "util/h/list.h"
52
53 typedef enum tunableUse { developerConstant, userConstant };
54 typedef enum tunableType { tunableBoolean, tunableFloat };
55
56 //
57 // Note: this is an abstract class, and can NOT be directly created.
58 //
59 class tunableConstant {
60  protected:
61    char *desc;
62    char *name;
63    tunableType typeName;
64    tunableUse use;
65
66    static stringPool *pool; // made protected
67
68    static List<tunableConstant*> *allConstants; // NEEDS TO BE MADE PROTECTED
69
70  public:
71    tunableConstant() {}
72    virtual ~tunableConstant() {}
73
74    const char *getDesc() const {
75       return desc;
76    }
77    const char *getName() const {
78       return name;
79    }
80    tunableUse getUse() const {
81       return use;
82    }
83    tunableType getType() const {
84       return typeName;
85    }
86
87    static tunableConstant *findTunableConstant(const char *name);
88       // returns NULL if not found
89
90    static List<tunableConstant *> beginIteration() {
91       assert(allConstants);
92
93       List <tunableConstant *> iterList = *allConstants;
94          // make a copy of the list for iteration purposes
95          // (actually, it just copies the head element, which itself
96          // is merely a pointer)
97
98       return iterList;
99    }
100
101    static int numTunables() {
102       assert(allConstants);
103       return allConstants->count();
104    }
105
106    virtual void print() = NULL;
107 };
108
109
110 // Shouldn't the string pools be made part of the base class?
111
112 typedef bool (*isValidFunc)(float newVal);
113 typedef void (*booleanChangeValCallBackFunc)(bool value);
114 typedef void (*floatChangeValCallBackFunc)(float value);
115
116 class tunableBooleanConstant : public tunableConstant {
117  private:
118    bool value;
119    booleanChangeValCallBackFunc newValueCallBack;
120
121  public:
122
123    tunableBooleanConstant(bool initialValue, 
124                           booleanChangeValCallBackFunc cb,
125                           tunableUse type,
126                           const char *name,
127                           const char *desc);
128    bool getValue() { return value; }
129    bool setValue(bool newVal) {
130       value = newVal;
131       if (newValueCallBack)
132          newValueCallBack(newVal);
133       return true;
134    }
135
136    virtual void print();
137 };
138
139 class tunableFloatConstant : public tunableConstant {
140  private:
141    float value;
142    float min, max;
143    isValidFunc isValidValue;
144
145    floatChangeValCallBackFunc newValueCallBack;
146    bool simpleRangeCheck(float val);
147
148  public:
149
150    tunableFloatConstant(float initialValue, 
151                         float min, 
152                         float max, 
153                         floatChangeValCallBackFunc cb,
154                         tunableUse type,
155                         const char *name,
156                         const char *desc);
157    tunableFloatConstant(float initialValue, 
158                         isValidFunc, 
159                         floatChangeValCallBackFunc cb,
160                         tunableUse type,
161                         const char *name,
162                         const char *desc);
163    float getValue() { return value; }
164    bool setValue(float newVal) {
165       if (isValidValue && isValidValue(newVal)) {
166          value = newVal;
167          if (newValueCallBack)
168             newValueCallBack(newVal);
169          return true;
170       }
171       else if (simpleRangeCheck(newVal)) {
172          value = newVal;
173          if (newValueCallBack)
174             newValueCallBack(newVal);
175          return true;
176       }
177       else
178          return false;
179    }
180
181    float getMin() {return min;}
182    float getMax() {return max;}
183
184    virtual void print();
185 };
186
187 #endif