]> git.cworth.org Git - apitrace/blob - trace_model.hpp
Unify Enum::Signature into EnumSig.
[apitrace] / trace_model.hpp
1 /**************************************************************************
2  *
3  * Copyright 2010 VMware, Inc.
4  * All Rights Reserved.
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22  * THE SOFTWARE.
23  *
24  **************************************************************************/
25
26 /*
27  * Object hierarchy for describing the traces in memory.
28  */
29
30 #ifndef _TRACE_MODEL_HPP_
31 #define _TRACE_MODEL_HPP_
32
33
34 #include <assert.h>
35
36 #include <map>
37 #include <list>
38 #include <vector>
39 #include <iostream>
40
41 #include "trace_writer.hpp"
42
43
44 namespace Trace {
45
46
47 class Visitor;
48
49
50 class Value
51 {
52 public:
53     virtual ~Value() {}
54     virtual void visit(Visitor &visitor) = 0;
55
56     virtual bool toBool(void) const = 0;
57     virtual signed long long toSInt(void) const;
58     virtual unsigned long long toUInt(void) const;
59     virtual float toFloat(void) const;
60     virtual double toDouble(void) const;
61
62     virtual void *toPointer(void) const;
63     virtual unsigned long long toUIntPtr(void) const;
64     virtual const char *toString(void) const;
65
66     const Value & operator[](size_t index) const;
67 };
68
69
70 class Null : public Value
71 {
72 public:
73     bool toBool(void) const;
74     signed long long toSInt(void) const;
75     unsigned long long toUInt(void) const;
76     virtual float toFloat(void) const;
77     virtual double toDouble(void) const;
78     void *toPointer(void) const;
79     unsigned long long toUIntPtr(void) const;
80     const char *toString(void) const;
81     void visit(Visitor &visitor);
82 };
83
84
85 class Bool : public Value
86 {
87 public:
88     Bool(bool _value) : value(_value) {}
89
90     bool toBool(void) const;
91     signed long long toSInt(void) const;
92     unsigned long long toUInt(void) const;
93     virtual float toFloat(void) const;
94     virtual double toDouble(void) const;
95     void visit(Visitor &visitor);
96
97     bool value;
98 };
99
100
101 class SInt : public Value
102 {
103 public:
104     SInt(signed long long _value) : value(_value) {}
105
106     bool toBool(void) const;
107     signed long long toSInt(void) const;
108     unsigned long long toUInt(void) const;
109     virtual float toFloat(void) const;
110     virtual double toDouble(void) const;
111     void visit(Visitor &visitor);
112
113     signed long long value;
114 };
115
116
117 class UInt : public Value
118 {
119 public:
120     UInt(unsigned long long _value) : value(_value) {}
121
122     bool toBool(void) const;
123     signed long long toSInt(void) const;
124     unsigned long long toUInt(void) const;
125     virtual float toFloat(void) const;
126     virtual double toDouble(void) const;
127     void visit(Visitor &visitor);
128
129     unsigned long long value;
130 };
131
132
133 class Float : public Value
134 {
135 public:
136     Float(double _value) : value(_value) {}
137
138     bool toBool(void) const;
139     signed long long toSInt(void) const;
140     unsigned long long toUInt(void) const;
141     virtual float toFloat(void) const;
142     virtual double toDouble(void) const;
143     void visit(Visitor &visitor);
144
145     double value;
146 };
147
148
149 class String : public Value
150 {
151 public:
152     String(const char * _value) : value(_value) {}
153
154     bool toBool(void) const;
155     const char *toString(void) const;
156     void visit(Visitor &visitor);
157
158     const char * value;
159 };
160
161
162 class Enum : public Value
163 {
164 public:
165     Enum(const EnumSig *_sig) : sig(_sig) {}
166
167     bool toBool(void) const;
168     signed long long toSInt(void) const;
169     unsigned long long toUInt(void) const;
170     virtual float toFloat(void) const;
171     virtual double toDouble(void) const;
172     void visit(Visitor &visitor);
173
174     const EnumSig *sig;
175 };
176
177
178 class Bitmask : public UInt
179 {
180 public:
181     Bitmask(const BitmaskSig *_sig, unsigned long long _value) : UInt(_value), sig(_sig) {}
182
183     void visit(Visitor &visitor);
184
185     const BitmaskSig *sig;
186 };
187
188
189 class Struct : public Value
190 {
191 public:
192     struct Signature {
193         const char *name;
194         std::vector<const char *> member_names;
195     };
196
197     Struct(Signature *_sig) : sig(_sig), members(_sig->member_names.size()) { }
198     ~Struct();
199
200     bool toBool(void) const;
201     void visit(Visitor &visitor);
202
203     const Signature *sig;
204     std::vector<Value *> members;
205 };
206
207
208 class Array : public Value
209 {
210 public:
211     Array(size_t len) : values(len) {}
212     ~Array();
213
214     bool toBool(void) const;
215     void visit(Visitor &visitor);
216
217     std::vector<Value *> values;
218 };
219
220
221 class Blob : public Value
222 {
223 public:
224     Blob(size_t _size) {
225         size = _size;
226         buf = new char[_size];
227     }
228
229     ~Blob();
230
231     bool toBool(void) const;
232     void *toPointer(void) const;
233     void visit(Visitor &visitor);
234
235     size_t size;
236     char *buf;
237 };
238
239
240 class Pointer : public UInt
241 {
242 public:
243     Pointer(unsigned long long value) : UInt(value) {}
244
245     bool toBool(void) const;
246     void *toPointer(void) const;
247     unsigned long long toUIntPtr(void) const;
248     void visit(Visitor &visitor);
249 };
250
251
252 class Visitor
253 {
254 public:
255     virtual void visit(Null *);
256     virtual void visit(Bool *);
257     virtual void visit(SInt *);
258     virtual void visit(UInt *);
259     virtual void visit(Float *);
260     virtual void visit(String *);
261     virtual void visit(Enum *);
262     virtual void visit(Bitmask *);
263     virtual void visit(Struct *);
264     virtual void visit(Array *);
265     virtual void visit(Blob *);
266     virtual void visit(Pointer *);
267
268 protected:
269     inline void _visit(Value *value) {
270         if (value) { 
271             value->visit(*this); 
272         }
273     }
274 };
275
276
277 std::ostream & operator <<(std::ostream &os, Value *value);
278
279
280 class Call
281 {
282 public:
283     struct Signature {
284         const char * name;
285         std::vector<const char *> arg_names;
286     };
287
288     unsigned no;
289     const Signature *sig;
290     std::vector<Value *> args;
291     Value *ret;
292
293     Call(Signature *_sig) : sig(_sig), args(_sig->arg_names.size()), ret(0) { }
294     ~Call();
295
296     inline const char * name(void) const {
297         return sig->name;
298     }
299
300     inline Value & arg(unsigned index) {
301         assert(index < args.size());
302         return *(args[index]);
303     }
304 };
305
306
307 std::ostream & operator <<(std::ostream &os, Call &call);
308
309
310 } /* namespace Trace */
311
312 #endif /* _TRACE_MODEL_HPP_ */