root/trunk/libffado/src/libutil/OptionContainer.cpp

Revision 742, 12.3 kB (checked in by ppalmers, 13 years ago)

- Remove some obsolete support files and dirs

- Clean up the license statements in the source files. Everything is

GPL version 3 now.

- Add license and copyright notices to scons scripts

- Clean up some other text files

Line 
1 /*
2  * Copyright (C) 2005-2007 by Pieter Palmers
3  *
4  * This file is part of FFADO
5  * FFADO = Free Firewire (pro-)audio drivers for linux
6  *
7  * FFADO is based upon FreeBoB.
8  *
9  * This program is free software: you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation, either version 3 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
21  *
22  */
23
24 #include "OptionContainer.h"
25
26 #include <iostream>
27 #include <sstream>
28
29 namespace Util {
30
31 IMPL_DEBUG_MODULE( OptionContainer, OptionContainer, DEBUG_LEVEL_NORMAL );
32
33 OptionContainer::Option::Option()
34     : m_Name(""),
35     m_stringValue(""),
36     m_boolValue(false),
37     m_doubleValue(0.0),
38     m_intValue(0),
39     m_uintValue(0),
40     m_Type(EInvalid)
41 {}
42
43 OptionContainer::Option::Option(std::string n)
44     : m_Name(n),
45     m_stringValue(""),
46     m_boolValue(false),
47     m_doubleValue(0.0),
48     m_intValue(0),
49     m_uintValue(0),
50     m_Type(EInvalid)
51 {}
52
53 OptionContainer::Option::Option(std::string n, std::string v)
54     : m_Name(n),
55     m_stringValue(v),
56     m_boolValue(false),
57     m_doubleValue(0.0),
58     m_intValue(0),
59     m_uintValue(0),
60     m_Type(EString)
61 {}
62
63 OptionContainer::Option::Option(std::string n, bool v)
64     : m_Name(n),
65     m_stringValue(""),
66     m_boolValue(v),
67     m_doubleValue(0.0),
68     m_intValue(0),
69     m_uintValue(0),
70     m_Type(EBool)
71 {}
72
73 OptionContainer::Option::Option(std::string n, double v)
74     : m_Name(n),
75     m_stringValue(""),
76     m_boolValue(false),
77     m_doubleValue(v),
78     m_intValue(0),
79     m_uintValue(0),
80     m_Type(EDouble)
81 {}
82
83 OptionContainer::Option::Option(std::string n, int64_t v)
84     : m_Name(n),
85     m_stringValue(""),
86     m_boolValue(false),
87     m_doubleValue(0.0),
88     m_intValue(v),
89     m_uintValue(0),
90     m_Type(EInt)
91 {}
92
93 OptionContainer::Option::Option(std::string n, uint64_t v)
94     : m_Name(n),
95     m_stringValue(""),
96     m_boolValue(false),
97     m_doubleValue(0.0),
98     m_intValue(0),
99     m_uintValue(v),
100     m_Type(EUInt)
101 {}
102
103 void OptionContainer::Option::set(std::string v) { m_stringValue = v; m_Type=EString;}
104 void OptionContainer::Option::set(bool v)        { m_boolValue = v; m_Type=EBool;}
105 void OptionContainer::Option::set(double v)      { m_doubleValue = v; m_Type=EDouble;}
106 void OptionContainer::Option::set(int64_t v)     { m_intValue = v; m_Type=EInt;}
107 void OptionContainer::Option::set(uint64_t v)    { m_uintValue = v; m_Type=EUInt;}
108
109 bool
110 OptionContainer::Option::serialize( Glib::ustring basePath, Util::IOSerialize& ser ) const
111 {
112     bool result;
113     result  = ser.write( basePath + "m_Name", Glib::ustring(m_Name) );
114     result &= ser.write( basePath + "m_stringValue", Glib::ustring(m_stringValue) );
115     result &= ser.write( basePath + "m_boolValue", m_boolValue );
116     result &= ser.write( basePath + "m_doubleValue", m_doubleValue );
117     result &= ser.write( basePath + "m_intValue", m_intValue );
118     result &= ser.write( basePath + "m_uintValue", m_uintValue );
119     result &= ser.write( basePath + "m_Type", m_Type );
120
121     return result;
122 }
123
124
125 OptionContainer::Option
126 OptionContainer::Option::deserialize( Glib::ustring basePath,
127                      Util::IODeserialize& deser )
128 {
129     bool result;
130     Option op=Option();
131     Glib::ustring tmpstr;
132
133     result  = deser.read( basePath + "m_Name", tmpstr );
134     op.m_Name = tmpstr;
135     result &= deser.read( basePath + "m_stringValue", tmpstr );
136     op.m_stringValue = tmpstr;
137     result &= deser.read( basePath + "m_boolValue", op.m_boolValue );
138     result &= deser.read( basePath + "m_doubleValue", op.m_doubleValue );
139     result &= deser.read( basePath + "m_intValue", op.m_intValue );
140     result &= deser.read( basePath + "m_uintValue", op.m_uintValue );
141     result &= deser.read( basePath + "m_Type", op.m_Type );
142
143     if(result) {
144         return op;
145     } else {
146         return Option();
147     }
148 }
149
150 // ------------------------
151 OptionContainer::OptionContainer() {
152
153 }
154
155 OptionContainer::~OptionContainer() {
156
157 }
158
159 // -------------- SETTERS --------------------
160 bool OptionContainer::setOption(std::string name, std::string v) {
161     Option o=getOption(name);
162     if (o.getType()==OptionContainer::Option::EInvalid) return false;
163     o.set(v);
164     return setOption(o);
165 }
166
167 bool OptionContainer::setOption(std::string name, bool v) {
168     Option o=getOption(name);
169     if (o.getType()==OptionContainer::Option::EInvalid) return false;
170     o.set(v);
171     return setOption(o);
172 }
173
174 bool OptionContainer::setOption(std::string name, double v) {
175     Option o=getOption(name);
176     if (o.getType()==OptionContainer::Option::EInvalid) return false;
177     o.set(v);
178     return setOption(o);
179 }
180
181 bool OptionContainer::setOption(std::string name, int64_t v) {
182     Option o=getOption(name);
183     if (o.getType()==OptionContainer::Option::EInvalid) return false;
184     o.set((int64_t)v);
185     return setOption(o);
186 }
187
188 bool OptionContainer::setOption(std::string name, uint64_t v) {
189     Option o=getOption(name);
190     if (o.getType()==OptionContainer::Option::EInvalid) return false;
191     o.set((uint64_t)v);
192     return setOption(o);
193 }
194
195 bool OptionContainer::setOption(std::string name, int32_t v) {
196     Option o=getOption(name);
197     if (o.getType()==OptionContainer::Option::EInvalid) return false;
198     o.set((int64_t)v);
199     return setOption(o);
200 }
201
202 bool OptionContainer::setOption(std::string name, uint32_t v) {
203     Option o=getOption(name);
204     if (o.getType()==OptionContainer::Option::EInvalid) return false;
205     o.set((uint64_t)v);
206     return setOption(o);
207 }
208
209 bool OptionContainer::setOption(std::string name, int16_t v) {
210     Option o=getOption(name);
211     if (o.getType()==OptionContainer::Option::EInvalid) return false;
212     o.set((int64_t)v);
213     return setOption(o);
214 }
215
216 bool OptionContainer::setOption(std::string name, uint16_t v) {
217     Option o=getOption(name);
218     if (o.getType()==OptionContainer::Option::EInvalid) return false;
219     o.set((uint64_t)v);
220     return setOption(o);
221 }
222
223 bool OptionContainer::setOption(std::string name, int8_t v) {
224     Option o=getOption(name);
225     if (o.getType()==OptionContainer::Option::EInvalid) return false;
226     o.set((int64_t)v);
227     return setOption(o);
228 }
229
230 bool OptionContainer::setOption(std::string name, uint8_t v) {
231     Option o=getOption(name);
232     if (o.getType()==OptionContainer::Option::EInvalid) return false;
233     o.set((uint64_t)v);
234     return setOption(o);
235 }
236
237 // -------------- GETTERS --------------------
238
239 bool OptionContainer::getOption(std::string name, std::string &v) {
240     Option o=getOption(name);
241     if (o.getType()!=OptionContainer::Option::EString) return false;
242     v=o.getString();
243     return true;
244 }
245
246 bool OptionContainer::getOption(std::string name, bool &v) {
247     Option o=getOption(name);
248     if (o.getType()!=OptionContainer::Option::EBool) return false;
249     v=o.getBool();
250     return true;
251 }
252
253 bool OptionContainer::getOption(std::string name, double &v) {
254     Option o=getOption(name);
255     if (o.getType()!=OptionContainer::Option::EDouble) return false;
256     v=o.getDouble();
257     return true;
258 }
259 bool OptionContainer::getOption(std::string name, float &v) {
260     Option o=getOption(name);
261     if (o.getType()!=OptionContainer::Option::EDouble) return false;
262     v=o.getDouble();
263     return true;
264 }
265
266 bool OptionContainer::getOption(std::string name, int64_t &v) {
267     Option o=getOption(name);
268     if (o.getType()!=OptionContainer::Option::EInt) return false;
269     v=o.getInt();
270     return true;
271 }
272 bool OptionContainer::getOption(std::string name, int32_t &v) {
273     Option o=getOption(name);
274     if (o.getType()!=OptionContainer::Option::EInt) return false;
275     v=o.getInt();
276     return true;
277 }
278 bool OptionContainer::getOption(std::string name, int16_t &v) {
279     Option o=getOption(name);
280     if (o.getType()!=OptionContainer::Option::EInt) return false;
281     v=o.getInt();
282     return true;
283 }
284 bool OptionContainer::getOption(std::string name, int8_t &v) {
285     Option o=getOption(name);
286     if (o.getType()!=OptionContainer::Option::EInt) return false;
287     v=o.getInt();
288     return true;
289 }
290
291 bool OptionContainer::getOption(std::string name, uint64_t &v) {
292     Option o=getOption(name);
293     if (o.getType()!=OptionContainer::Option::EUInt) return false;
294     v=o.getUInt();
295     return true;
296 }
297 bool OptionContainer::getOption(std::string name, uint32_t &v) {
298     Option o=getOption(name);
299     if (o.getType()!=OptionContainer::Option::EUInt) return false;
300     v=o.getUInt();
301     return true;
302 }
303 bool OptionContainer::getOption(std::string name, uint16_t &v) {
304     Option o=getOption(name);
305     if (o.getType()!=OptionContainer::Option::EUInt) return false;
306     v=o.getUInt();
307     return true;
308 }
309 bool OptionContainer::getOption(std::string name, uint8_t &v) {
310     Option o=getOption(name);
311     if (o.getType()!=OptionContainer::Option::EUInt) return false;
312     v=o.getUInt();
313     return true;
314 }
315
316 OptionContainer::Option::EType OptionContainer::getOptionType(std::string name) {
317     Option o=getOption(name);
318     return o.getType();
319
320 }
321
322 OptionContainer::Option OptionContainer::getOption(std::string name) {
323     int i=findOption(name);
324     if (i<0) {
325         return Option();
326     } else {
327         return m_Options.at(i);
328     }
329 }
330
331 bool OptionContainer::addOption(Option o) {
332     if (o.getType()==OptionContainer::Option::EInvalid) {
333         return false;
334     }
335     if (hasOption(o)){
336         return false;
337     }
338
339     m_Options.push_back(o);
340
341     return true;
342 }
343
344 bool OptionContainer::setOption(Option o) {
345     int i=findOption(o);
346     if (i<0) {
347         return false;
348     } else {
349         m_Options.erase(m_Options.begin()+i);
350         m_Options.push_back(o);
351         return true;
352     }
353 }
354
355 bool OptionContainer::removeOption(Option o) {
356     int i=findOption(o);
357     if (i<0) {
358         return false;
359     } else {
360         m_Options.erase(m_Options.begin()+i);
361         return true;
362     }
363 }
364
365 bool OptionContainer::removeOption(std::string name) {
366     int i=findOption(name);
367     if (i<0) {
368         return false;
369     } else {
370         m_Options.erase(m_Options.begin()+i);
371         return true;
372     }
373 }
374
375 bool OptionContainer::hasOption(std::string name) {
376     return (findOption(name) >= 0);
377 }
378
379 bool OptionContainer::hasOption(Option o) {
380     return (findOption(o) >= 0);
381 }
382
383 int OptionContainer::findOption(Option o) {
384     int i=0;
385     for ( OptionVectorIterator it = m_Options.begin();
386       it != m_Options.end();
387       ++it )
388     {
389         if((*it).getName() == o.getName()) {
390             return i;
391         }
392         i++;
393     }
394     return -1;
395 }
396
397 int OptionContainer::findOption(std::string name) {
398     int i=0;
399     for ( OptionVectorIterator it = m_Options.begin();
400       it != m_Options.end();
401       ++it )
402     {
403         if((*it).getName() == name) {
404             return i;
405         }
406         i++;
407     }
408     return -1;
409 }
410
411 // serialization support
412
413 bool
414 OptionContainer::serializeOptions( Glib::ustring basePath,
415                                    Util::IOSerialize& ser) const
416 {
417     bool result = true;
418     int i = 0;
419
420     for ( OptionVector::const_iterator it = m_Options.begin();
421           it != m_Options.end();
422           ++it )
423     {
424         const Option& pOption = *it;
425
426         std::ostringstream strstrm;
427         strstrm << basePath << "/" << "Option" << i;
428         result &= pOption.serialize( strstrm.str() + "/", ser );
429         i++;
430     }
431
432     return result;
433 }
434
435 bool
436 OptionContainer::deserializeOptions( Glib::ustring basePath,
437                                      Util::IODeserialize& deser,
438                                      OptionContainer& container)
439 {
440     int i = 0;
441     bool bFinished = false;
442     bool result=true;
443     do {
444         std::ostringstream strstrm;
445         strstrm << basePath << "/" << "Option" << i;
446
447         if ( deser.isExisting( strstrm.str() ) ) {
448             Option pOption = Option::deserialize( strstrm.str() + "/",
449                                                   deser );
450             if ( pOption.getType() != Option::EInvalid ) {
451                 result &= container.addOption(pOption);
452                 i++;
453             } else {
454                 bFinished = true;
455             }
456         } else {
457             bFinished = true;
458         }
459     } while ( !bFinished );
460
461     return result;
462 }
463
464
465 } // end of namespace Util
Note: See TracBrowser for help on using the browser.