root/OpenSceneGraph/trunk/include/osgDB/Serializer @ 8896

Revision 8896, 10.0 kB (checked in by robert, 5 years ago)

Moved Serializer header from VPB into osgDB.

Line 
1/* -*-c++-*- VirtualPlanetBuilder - Copyright (C) 1998-2007 Robert Osfield
2 *
3 * This library is open source and may be redistributed and/or modified under 
4 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
5 * (at your option) any later version.  The full license is in LICENSE file
6 * included with this distribution, and on the openscenegraph.org website.
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
11 * OpenSceneGraph Public License for more details.
12*/
13
14#ifndef SERIALIZER_H
15#define SERIALIZER_H 1
16
17#include <osgDB/Input>
18#include <osgDB/Output>
19#include <osgDB/ParameterOutput>
20
21namespace osgDB
22{
23
24class IntLookup
25{
26public:
27
28    typedef int Value;
29
30    IntLookup(Value defaultValue):
31        _default(defaultValue) {}
32
33    typedef std::map<std::string, Value> StringToValue;
34    typedef std::map<Value, std::string> ValueToString;
35
36    StringToValue   _stringToValue;
37    ValueToString   _valueToString;
38   
39    void add(Value value, const char* str)
40    {
41        _stringToValue[str] = value;
42        _valueToString[value] = str;
43    }
44   
45    Value getValue(const char* str)
46    {
47        StringToValue::iterator itr = _stringToValue.find(str);
48        if (itr==_stringToValue.end()) return _default;
49        return itr->second;
50    }
51   
52    const std::string& getString(Value value)
53    {
54        ValueToString::iterator itr = _valueToString.find(value);
55        if (itr==_valueToString.end()) return _valueToString[_default];
56        return itr->second;
57    }
58   
59    Value _default;
60
61};
62
63class Serializer : public osg::Referenced
64{
65public:
66
67     Serializer() {}
68     
69     virtual bool write(osgDB::Output&, const osg::Object&) = 0;
70     virtual bool read(osgDB::Input&, osg::Object&, bool&) = 0;
71};
72
73template<typename C, typename P>
74class EnumSerializer : public Serializer
75{
76public:
77
78     typedef P (C::*GetterFunctionType)() const;
79     typedef void (C::*SetterFunctionType)(P);
80
81     EnumSerializer(const char* fieldName, P defaultValue, GetterFunctionType getter, SetterFunctionType setter):
82        _fieldName(fieldName),
83        _default(defaultValue),
84        _getter(getter),
85        _setter(setter),
86        _lookup(defaultValue) {}
87     
88    void add(P value, const char* str)
89    {
90        _lookup.add(static_cast<IntLookup::Value>(value), str);
91    }
92
93    P getValue(const char* str)
94    {
95        return static_cast<P>(_lookup.getValue(str));
96    }
97
98    const std::string& getString(P value)
99    {
100        return _lookup.getString(static_cast<IntLookup::Value>(value));
101    }
102
103    bool write(osgDB::Output& fw, const osg::Object& obj)
104    {
105        const C& object = static_cast<const C&>(obj);
106
107        if (fw.getWriteOutDefaultValues() ||
108            _default != (object.*_getter)())
109        {
110            fw.indent()<<_fieldName<<" "<<getString((object.*_getter)())<<std::endl;
111        }
112       
113        return true;
114    }
115
116    bool read(osgDB::Input& fr, osg::Object& obj, bool& itrAdvanced)
117    {
118        C& object = static_cast<C&>(obj);
119        if (fr[0].matchWord(_fieldName.c_str()) && fr[1].isWord())
120        {
121            (object.*_setter)(getValue(fr[1].getStr()));
122            fr += 2;
123            itrAdvanced = true;
124        }
125       
126        return true;
127    }
128
129    std::string        _fieldName;
130    P                  _default;
131    GetterFunctionType _getter;
132    SetterFunctionType _setter;
133    IntLookup          _lookup;
134};
135
136
137template<typename C>
138class StringSerializer : public Serializer
139{
140public:
141
142     typedef const std::string& P;
143     typedef P (C::*GetterFunctionType)() const;
144     typedef void (C::*SetterFunctionType)(P);
145
146     StringSerializer(const char* fieldName, P defaultValue, GetterFunctionType getter, SetterFunctionType setter):
147        _fieldName(fieldName),
148        _default(defaultValue),
149        _getter(getter),
150        _setter(setter) {}
151     
152     bool write(osgDB::Output& fw, const osg::Object& obj)
153     {
154        const C& object = static_cast<const C&>(obj);
155        if (fw.getWriteOutDefaultValues() ||
156            _default != (object.*_getter)())
157        {
158            fw.indent()<<_fieldName<<" "<<fw.wrapString((object.*_getter)())<<std::endl;
159        }
160       
161        return true;
162     }
163
164    bool read(osgDB::Input& fr, osg::Object& obj, bool& itrAdvanced)
165    {
166        C& object = static_cast<C&>(obj);
167        if (fr[0].matchWord(_fieldName.c_str()) && (fr[1].isWord() || fr[1].isString()))
168        {
169            (object.*_setter)(fr[1].getStr());
170            fr += 2;
171            itrAdvanced = true;
172        }
173       
174        return true;
175     }
176     
177     std::string        _fieldName;
178     std::string        _default;
179     GetterFunctionType _getter;
180     SetterFunctionType _setter;
181};
182
183
184template<typename C, typename P>
185class TemplateSerializer : public Serializer
186{
187public:
188
189     typedef P (C::*GetterFunctionType)() const;
190     typedef void (C::*SetterFunctionType)(P);
191
192     TemplateSerializer(const char* fieldName, P defaultValue, GetterFunctionType getter, SetterFunctionType setter):
193        _fieldName(fieldName),
194        _default(defaultValue),
195        _getter(getter),
196        _setter(setter) {}
197     
198     bool write(osgDB::Output& fw, const osg::Object& obj)
199     {
200        const C& object = static_cast<const C&>(obj);
201        if (fw.getWriteOutDefaultValues() ||
202            _default != (object.*_getter)())
203        {
204            fw.indent()<<_fieldName<<" "<<(object.*_getter)()<<std::endl;
205        }
206       
207        return true;
208     }
209
210    bool read(osgDB::Input& fr, osg::Object& obj, bool& itrAdvanced)
211    {
212        C& object = static_cast<C&>(obj);
213        P value;
214        if (fr.read(_fieldName.c_str(), value))
215        {
216            (object.*_setter)(value);
217            itrAdvanced = true;
218        }
219       
220        return true;
221     }
222     
223     std::string        _fieldName;
224     P                  _default;
225     GetterFunctionType _getter;
226     SetterFunctionType _setter;
227};
228
229template<typename C>
230class Vec4Serializer : public Serializer
231{
232public:
233
234     typedef osg::Vec4 V;
235     typedef const V& P;
236     typedef P (C::*GetterFunctionType)() const;
237     typedef void (C::*SetterFunctionType)(P);
238
239     Vec4Serializer(const char* fieldName, P defaultValue, GetterFunctionType getter, SetterFunctionType setter):
240        _fieldName(fieldName),
241        _default(defaultValue),
242        _getter(getter),
243        _setter(setter) {}
244     
245     bool write(osgDB::Output& fw, const osg::Object& obj)
246     {
247        const C& object = static_cast<const C&>(obj);
248        if (fw.getWriteOutDefaultValues() ||
249            _default != (object.*_getter)())
250        {
251            fw.indent()<<_fieldName<<" "<<(object.*_getter)()<<std::endl;
252        }
253       
254        return true;
255     }
256
257    bool read(osgDB::Input& fr, osg::Object& obj, bool& itrAdvanced)
258    {
259        C& object = static_cast<C&>(obj);
260        V value;
261        if (fr.read(_fieldName.c_str(), value[0], value[1], value[2], value[3]))
262        {
263            (object.*_setter)(value);
264            fr += 2;
265            itrAdvanced = true;
266        }
267       
268        return true;
269     }
270     
271     std::string        _fieldName;
272     V                  _default;
273     GetterFunctionType _getter;
274     SetterFunctionType _setter;
275};
276
277
278template<typename C>
279class BoolSerializer : public Serializer
280{
281public:
282
283     typedef bool P;
284     typedef P (C::*GetterFunctionType)() const;
285     typedef void (C::*SetterFunctionType)(P);
286
287     BoolSerializer(const char* fieldName, P defaultValue, GetterFunctionType getter, SetterFunctionType setter):
288        _fieldName(fieldName),
289        _default(defaultValue),
290        _getter(getter),
291        _setter(setter) {}
292     
293     bool write(osgDB::Output& fw, const osg::Object& obj)
294     {
295        const C& object = static_cast<const C&>(obj);
296        if (fw.getWriteOutDefaultValues() ||
297            _default != (object.*_getter)())
298        {
299            fw.indent()<<_fieldName<<" "<<((object.*_getter)() ? "TRUE" : "FALSE")<<std::endl;
300        }
301       
302        return true;
303     }
304
305    bool read(osgDB::Input& fr, osg::Object& obj, bool& itrAdvanced)
306    {
307        C& object = static_cast<C&>(obj);
308        if (fr[0].matchWord(_fieldName.c_str()) && fr[1].isWord())
309        {
310            (object.*_setter)(fr[1].matchWord("TRUE") || fr[1].matchWord("True") || fr[1].matchWord("true"));
311            fr += 2;
312            itrAdvanced = true;
313        }
314       
315        return true;
316     }
317     
318     std::string        _fieldName;
319     P                  _default;
320     GetterFunctionType _getter;
321     SetterFunctionType _setter;
322};
323
324#define CREATE_STRING_SERIALIZER(CLASS,PROPERTY,PROTOTYPE) \
325    new osgDB::StringSerializer<CLASS>( \
326    #PROPERTY, \
327    PROTOTYPE.get##PROPERTY(), \
328    &CLASS::get##PROPERTY, \
329    &CLASS::set##PROPERTY)
330
331#define CREATE_UINT_SERIALIZER(CLASS,PROPERTY,PROTOTYPE) \
332    new osgDB::TemplateSerializer<CLASS,unsigned int>( \
333    #PROPERTY, \
334    PROTOTYPE.get##PROPERTY(), \
335    &CLASS::get##PROPERTY, \
336    &CLASS::set##PROPERTY)
337
338#define CREATE_INT_SERIALIZER(CLASS,PROPERTY,PROTOTYPE) \
339    new osgDB::TemplateSerializer<CLASS, int>( \
340    #PROPERTY, \
341    PROTOTYPE.get##PROPERTY(), \
342    &CLASS::get##PROPERTY, \
343    &CLASS::set##PROPERTY)
344
345#define CREATE_FLOAT_SERIALIZER(CLASS,PROPERTY,PROTOTYPE) \
346    new osgDB::TemplateSerializer<CLASS,float>( \
347    #PROPERTY, \
348    PROTOTYPE.get##PROPERTY(), \
349    &CLASS::get##PROPERTY, \
350    &CLASS::set##PROPERTY)
351
352#define CREATE_DOUBLE_SERIALIZER(CLASS,PROPERTY,PROTOTYPE) \
353    new osgDB::TemplateSerializer<CLASS, double>( \
354    #PROPERTY, \
355    PROTOTYPE.get##PROPERTY(), \
356    &CLASS::get##PROPERTY, \
357    &CLASS::set##PROPERTY)
358
359#define CREATE_VEC4_SERIALIZER(CLASS,PROPERTY,PROTOTYPE) \
360    new osgDB::Vec4Serializer<CLASS>( \
361    #PROPERTY, \
362    PROTOTYPE.get##PROPERTY(), \
363    &CLASS::get##PROPERTY, \
364    &CLASS::set##PROPERTY)
365
366#define CREATE_BOOL_SERIALIZER(CLASS,PROPERTY,PROTOTYPE) \
367    new osgDB::BoolSerializer<CLASS>( \
368    #PROPERTY, \
369    PROTOTYPE.get##PROPERTY(), \
370    &CLASS::get##PROPERTY, \
371    &CLASS::set##PROPERTY)
372
373
374}
375
376#endif
377
Note: See TracBrowser for help on using the browser.