NetBurner 3.1
MockNamedValue.h
1 /*
2  * Copyright (c) 2007, Michael Feathers, James Grenning and Bas Vodde
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are met:
7  * * Redistributions of source code must retain the above copyright
8  * notice, this list of conditions and the following disclaimer.
9  * * Redistributions in binary form must reproduce the above copyright
10  * notice, this list of conditions and the following disclaimer in the
11  * documentation and/or other materials provided with the distribution.
12  * * Neither the name of the <organization> nor the
13  * names of its contributors may be used to endorse or promote products
14  * derived from this software without specific prior written permission.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE EARLIER MENTIONED AUTHORS ``AS IS'' AND ANY
17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19  * DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
20  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
23  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26  */
27 
28 #ifndef D_MockNamedValue_h
29 #define D_MockNamedValue_h
30 /*
31  * MockNamedValueComparator is an interface that needs to be used when creating Comparators.
32  * This is needed when comparing values of non-native type.
33  */
34 
35 class MockNamedValueComparator
36 {
37 public:
38  MockNamedValueComparator() {}
39  virtual ~MockNamedValueComparator() {}
40 
41  virtual bool isEqual(const void* object1, const void* object2)=0;
42  virtual SimpleString valueToString(const void* object)=0;
43 };
44 
45 /*
46  * MockNamedValueCopier is an interface that needs to be used when creating Copiers.
47  * This is needed when copying values of non-native type.
48  */
49 
50 class MockNamedValueCopier
51 {
52 public:
53  MockNamedValueCopier() {}
54  virtual ~MockNamedValueCopier() {}
55 
56  virtual void copy(void* out, const void* in)=0;
57 };
58 
59 
60 class MockFunctionComparator : public MockNamedValueComparator
61 {
62 public:
63  typedef bool (*isEqualFunction)(const void*, const void*);
64  typedef SimpleString (*valueToStringFunction)(const void*);
65 
66  MockFunctionComparator(isEqualFunction equal, valueToStringFunction valToString)
67  : equal_(equal), valueToString_(valToString) {}
68 
69  virtual bool isEqual(const void* object1, const void* object2) _override { return equal_(object1, object2); }
70  virtual SimpleString valueToString(const void* object) _override { return valueToString_(object); }
71 private:
72  isEqualFunction equal_;
73  valueToStringFunction valueToString_;
74 };
75 
76 class MockFunctionCopier : public MockNamedValueCopier
77 {
78 public:
79  typedef void (*copyFunction)(void*, const void*);
80 
81  MockFunctionCopier(copyFunction copier) : copier_(copier) {}
82 
83  virtual void copy(void* dst, const void* src) _override { copier_(dst, src); }
84 
85 private:
86  copyFunction copier_;
87 };
88 
89 /*
90  * MockNamedValue is the generic value class used. It encapsulates basic types and can use them "as if one"
91  * Also it enables other types by putting object pointers. They can be compared with comparators.
92  *
93  * Basically this class ties together a Name, a Value, a Type, and a Comparator
94  */
95 
96 class MockNamedValueComparatorsAndCopiersRepository;
97 class MockNamedValue
98 {
99 public:
100  MockNamedValue(const SimpleString& name);
101  DEFAULT_COPY_CONSTRUCTOR(MockNamedValue)
102  virtual ~MockNamedValue();
103 
104  virtual void setValue(bool value);
105  virtual void setValue(int value);
106  virtual void setValue(unsigned int value);
107  virtual void setValue(long int value);
108  virtual void setValue(unsigned long int value);
109  virtual void setValue(double value);
110  virtual void setValue(void* value);
111  virtual void setValue(const void* value);
112  virtual void setValue(void (*value)());
113  virtual void setValue(const char* value);
114  virtual void setMemoryBuffer(const unsigned char* value, size_t size);
115  virtual void setObjectPointer(const SimpleString& type, const void* objectPtr);
116  virtual void setSize(size_t size);
117 
118  virtual void setName(const char* name);
119 
120  virtual bool equals(const MockNamedValue& p) const;
121  virtual bool compatibleForCopying(const MockNamedValue& p) const;
122 
123  virtual SimpleString toString() const;
124 
125  virtual SimpleString getName() const;
126  virtual SimpleString getType() const;
127 
128  virtual bool getBoolValue() const;
129  virtual int getIntValue() const;
130  virtual unsigned int getUnsignedIntValue() const;
131  virtual long int getLongIntValue() const;
132  virtual unsigned long int getUnsignedLongIntValue() const;
133  virtual double getDoubleValue() const;
134  virtual const char* getStringValue() const;
135  virtual void* getPointerValue() const;
136  virtual const void* getConstPointerValue() const;
137  virtual void (*getFunctionPointerValue() const)();
138  virtual const unsigned char* getMemoryBuffer() const;
139  virtual const void* getObjectPointer() const;
140  virtual size_t getSize() const;
141 
142  virtual MockNamedValueComparator* getComparator() const;
143  virtual MockNamedValueCopier* getCopier() const;
144 
145  static void setDefaultComparatorsAndCopiersRepository(MockNamedValueComparatorsAndCopiersRepository* repository);
146 private:
147  SimpleString name_;
148  SimpleString type_;
149  union {
150  bool boolValue_;
151  int intValue_;
152  unsigned int unsignedIntValue_;
153  long int longIntValue_;
154  unsigned long int unsignedLongIntValue_;
155  double doubleValue_;
156  const char* stringValue_;
157  void* pointerValue_;
158  const void* constPointerValue_;
159  void (*functionPointerValue_)();
160  const unsigned char* memoryBufferValue_;
161  const void* objectPointerValue_;
162  const void* outputPointerValue_;
163  } value_;
164  size_t size_;
165  MockNamedValueComparator* comparator_;
166  MockNamedValueCopier* copier_;
167  static MockNamedValueComparatorsAndCopiersRepository* defaultRepository_;
168 };
169 
170 class MockNamedValueListNode
171 {
172 public:
173  MockNamedValueListNode(MockNamedValue* newValue);
174 
175  SimpleString getName() const;
176  SimpleString getType() const;
177 
178  MockNamedValueListNode* next();
179  MockNamedValue* item();
180 
181  void destroy();
182  void setNext(MockNamedValueListNode* node);
183 private:
184  MockNamedValue* data_;
185  MockNamedValueListNode* next_;
186 };
187 
188 class MockNamedValueList
189 {
190 public:
191  MockNamedValueList();
192 
193  MockNamedValueListNode* begin();
194 
195  void add(MockNamedValue* newValue);
196  void clear();
197 
198  MockNamedValue* getValueByName(const SimpleString& name);
199 
200 private:
201  MockNamedValueListNode* head_;
202 };
203 
204 /*
205  * MockParameterComparatorRepository is a class which stores comparators and copiers which can be used for comparing non-native types
206  *
207  */
208 
209 struct MockNamedValueComparatorsAndCopiersRepositoryNode;
210 class MockNamedValueComparatorsAndCopiersRepository
211 {
212  MockNamedValueComparatorsAndCopiersRepositoryNode* head_;
213 public:
214  MockNamedValueComparatorsAndCopiersRepository();
215  virtual ~MockNamedValueComparatorsAndCopiersRepository();
216 
217  virtual void installComparator(const SimpleString& name, MockNamedValueComparator& comparator);
218  virtual void installCopier(const SimpleString& name, MockNamedValueCopier& copier);
219  virtual void installComparatorsAndCopiers(const MockNamedValueComparatorsAndCopiersRepository& repository);
220  virtual MockNamedValueComparator* getComparatorForType(const SimpleString& name);
221  virtual MockNamedValueCopier* getCopierForType(const SimpleString& name);
222 
223  void clear();
224 };
225 
226 #endif