]> git.mxchange.org Git - simgear.git/blob - simgear/hla/HLAArrayDataElement.cxx
Add an initial implementation of a rti/hla dispatcher.
[simgear.git] / simgear / hla / HLAArrayDataElement.cxx
1 // Copyright (C) 2009 - 2010  Mathias Froehlich - Mathias.Froehlich@web.de
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Library General Public
5 // License as published by the Free Software Foundation; either
6 // version 2 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Library General Public License for more details.
12 //
13 // You should have received a copy of the GNU General Public License
14 // along with this program; if not, write to the Free Software
15 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
16 //
17
18 #include "HLAArrayDataElement.hxx"
19
20 #include <simgear/debug/logstream.hxx>
21
22 namespace simgear {
23
24 HLAAbstractArrayDataElement::HLAAbstractArrayDataElement(const HLAArrayDataType* dataType) :
25     _dataType(dataType)
26 {
27 }
28
29 HLAAbstractArrayDataElement::~HLAAbstractArrayDataElement()
30 {
31 }
32
33 bool
34 HLAAbstractArrayDataElement::decode(HLADecodeStream& stream)
35 {
36     if (!_dataType.valid())
37         return false;
38     return _dataType->decode(stream, *this);
39 }
40
41 bool
42 HLAAbstractArrayDataElement::encode(HLAEncodeStream& stream) const
43 {
44     if (!_dataType.valid())
45         return false;
46     return _dataType->encode(stream, *this);
47 }
48
49 const HLAArrayDataType*
50 HLAAbstractArrayDataElement::getDataType() const
51 {
52     return _dataType.get();
53 }
54
55 bool
56 HLAAbstractArrayDataElement::setDataType(const HLADataType* dataType)
57 {
58     const HLAArrayDataType* arrayDataType = dynamic_cast<const HLAArrayDataType*>(dataType);
59     if (!arrayDataType) {
60         SG_LOG(SG_NETWORK, SG_WARN, "HLAArrayDataType: unable to set data type!");
61         return false;
62     }
63     _dataType = arrayDataType;
64     return true;
65 }
66
67 const HLADataType*
68 HLAAbstractArrayDataElement::getElementDataType() const
69 {
70     if (!_dataType.valid())
71         return 0;
72     return _dataType->getElementDataType();
73 }
74
75 ////////////////////////////////////////////////////////////////////////
76
77 HLAArrayDataElement::DataElementFactory::~DataElementFactory()
78 {
79 }
80
81 HLAArrayDataElement::HLAArrayDataElement(const HLAArrayDataType* dataType) :
82     HLAAbstractArrayDataElement(dataType)
83 {
84 }
85
86 HLAArrayDataElement::~HLAArrayDataElement()
87 {
88 }
89
90 bool
91 HLAArrayDataElement::setNumElements(unsigned size)
92 {
93     unsigned oldSize = _elementVector.size();
94     if (size == oldSize)
95         return true;
96     _elementVector.resize(size);
97     for (unsigned i = oldSize; i < size; ++i)
98         _elementVector[i] = newElement(i);
99     return true;
100 }
101
102 bool
103 HLAArrayDataElement::decodeElement(HLADecodeStream& stream, unsigned i)
104 {
105     HLADataElement* dataElement = getElement(i);
106     if (!dataElement)
107         return false;
108     return dataElement->decode(stream);
109 }
110
111 unsigned
112 HLAArrayDataElement::getNumElements() const
113 {
114     return _elementVector.size();
115 }
116
117 bool
118 HLAArrayDataElement::encodeElement(HLAEncodeStream& stream, unsigned i) const
119 {
120     const HLADataElement* dataElement = getElement(i);
121     if (!dataElement)
122         return false;
123     return dataElement->encode(stream);
124 }
125
126 const HLADataElement*
127 HLAArrayDataElement::getElement(unsigned index) const
128 {
129     if (_elementVector.size() <= index)
130         return 0;
131     return _elementVector[index].get();
132 }
133
134 HLADataElement*
135 HLAArrayDataElement::getElement(unsigned index)
136 {
137     if (_elementVector.size() <= index)
138         return 0;
139     return _elementVector[index].get();
140 }
141
142 HLADataElement*
143 HLAArrayDataElement::getOrCreateElement(unsigned index)
144 {
145     if (_elementVector.size() <= index)
146         if (!setNumElements(index + 1))
147             return 0;
148     return _elementVector[index].get();
149 }
150
151 void
152 HLAArrayDataElement::setElement(unsigned index, HLADataElement* value)
153 {
154     unsigned oldSize = _elementVector.size();
155     if (oldSize <= index) {
156         _elementVector.resize(index + 1);
157         for (unsigned j = oldSize; j < index; ++j)
158             _elementVector[j] = newElement(j);
159     }
160     _elementVector[index] = value;
161 }
162
163 void
164 HLAArrayDataElement::setDataElementFactory(HLAArrayDataElement::DataElementFactory* dataElementFactory)
165 {
166     _dataElementFactory = dataElementFactory;
167 }
168
169 HLAArrayDataElement::DataElementFactory*
170 HLAArrayDataElement::getDataElementFactory()
171 {
172     return _dataElementFactory.get();
173 }
174
175 HLADataElement*
176 HLAArrayDataElement::newElement(unsigned index)
177 {
178     if (!_dataElementFactory.valid())
179         return 0;
180     return _dataElementFactory->createElement(*this, index);
181 }
182
183 ////////////////////////////////////////////////////////////////////////
184
185 HLAVariantArrayDataElement::HLAVariantArrayDataElement() :
186     HLAAbstractArrayDataElement(0)
187 {
188 }
189
190 HLAVariantArrayDataElement::~HLAVariantArrayDataElement()
191 {
192 }
193
194 bool
195 HLAVariantArrayDataElement::setDataType(const HLADataType* dataType)
196 {
197     const HLAArrayDataType* arrayDataType = dataType->toArrayDataType();
198     if (!arrayDataType) {
199         SG_LOG(SG_NETWORK, SG_WARN, "HLAVariantArrayDataType: unable to set data type, dataType is not an array data type!");
200         return false;
201     }
202     const HLAVariantDataType* variantDataType = arrayDataType->getElementDataType()->toVariantDataType();
203     if (!variantDataType) {
204         SG_LOG(SG_NETWORK, SG_WARN, "HLAVariantArrayDataType: unable to set data type: arrayDataTypes element data type is no a variant data type!");
205         return false;
206     }
207     _dataType = arrayDataType;
208     return true;
209 }
210
211 bool
212 HLAVariantArrayDataElement::setNumElements(unsigned size)
213 {
214     unsigned oldSize = _elementVector.size();
215     if (size == oldSize)
216         return true;
217     _elementVector.resize(size);
218     for (unsigned i = oldSize; i < size; ++i)
219         _elementVector[i] = newElement();
220     return true;
221 }
222
223 bool
224 HLAVariantArrayDataElement::decodeElement(HLADecodeStream& stream, unsigned i)
225 {
226     HLAVariantDataElement* dataElement = getElement(i);
227     if (!dataElement)
228         return false;
229     return dataElement->decode(stream);
230 }
231
232 unsigned
233 HLAVariantArrayDataElement::getNumElements() const
234 {
235     return _elementVector.size();
236 }
237
238 bool
239 HLAVariantArrayDataElement::encodeElement(HLAEncodeStream& stream, unsigned i) const
240 {
241     const HLADataElement* dataElement = getElement(i);
242     if (!dataElement)
243         return false;
244     return dataElement->encode(stream);
245 }
246
247 const HLAVariantDataElement*
248 HLAVariantArrayDataElement::getElement(unsigned index) const
249 {
250     if (_elementVector.size() <= index)
251         return 0;
252     return _elementVector[index].get();
253 }
254
255 HLAVariantDataElement*
256 HLAVariantArrayDataElement::getElement(unsigned index)
257 {
258     if (_elementVector.size() <= index)
259         return 0;
260     return _elementVector[index].get();
261 }
262
263 HLAVariantDataElement*
264 HLAVariantArrayDataElement::getOrCreateElement(unsigned index)
265 {
266     if (_elementVector.size() <= index)
267         if (!setNumElements(index + 1))
268             return 0;
269     return _elementVector[index].get();
270 }
271
272 void
273 HLAVariantArrayDataElement::setElement(unsigned index, HLAVariantDataElement* value)
274 {
275     unsigned oldSize = _elementVector.size();
276     if (oldSize <= index) {
277         _elementVector.resize(index + 1);
278         for (unsigned j = oldSize; j < index; ++j)
279             _elementVector[j] = newElement();
280     }
281     _elementVector[index] = value;
282 }
283
284 void
285 HLAVariantArrayDataElement::setAlternativeDataElementFactory(HLAVariantArrayDataElement::AlternativeDataElementFactory* alternativeDataElementFactory)
286 {
287     _alternativeDataElementFactory = alternativeDataElementFactory;
288 }
289
290 HLAVariantArrayDataElement::AlternativeDataElementFactory*
291 HLAVariantArrayDataElement::getAlternativeDataElementFactory()
292 {
293     return _alternativeDataElementFactory.get();
294 }
295
296 HLAVariantDataElement*
297 HLAVariantArrayDataElement::newElement()
298 {
299     const HLAArrayDataType* arrayDataType = getDataType();
300     if (!arrayDataType)
301         return 0;
302     const HLADataType* elementDataType = arrayDataType->getElementDataType();
303     if (!elementDataType)
304         return 0;
305     const HLAVariantDataType* variantDataType = elementDataType->toVariantDataType();
306     if (!variantDataType)
307         return 0;
308     HLAVariantDataElement* variantDataElement = new HLAVariantDataElement(variantDataType);
309     variantDataElement->setDataElementFactory(_alternativeDataElementFactory.get());
310     return variantDataElement;
311 }
312
313 }