ome-xml 5.2.3

UnitsFrequency.h
1 /*
2 * #%L
3 * OME-XML C++ library for working with OME-XML metadata structures.
4 * %%
5 * Copyright © 2006 - 2016 Open Microscopy Environment:
6 * - Massachusetts Institute of Technology
7 * - National Institutes of Health
8 * - University of Dundee
9 * - Board of Regents of the University of Wisconsin-Madison
10 * - Glencoe Software, Inc.
11 * %%
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions are met:
14 *
15 * 1. Redistributions of source code must retain the above copyright notice,
16 * this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright notice,
18 * this list of conditions and the following disclaimer in the documentation
19 * and/or other materials provided with the distribution.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
25 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 * POSSIBILITY OF SUCH DAMAGE.
32 *
33 * The views and conclusions contained in the software and documentation are
34 * those of the authors and should not be interpreted as representing official
35 * policies, either expressed or implied, of any organization.
36 * #L%
37 */
38
39 /*─────────────────────────────────────────────────────────────────────────────
40 *
41 * THIS IS AUTOMATICALLY GENERATED CODE. DO NOT MODIFY.
42 *
43 *─────────────────────────────────────────────────────────────────────────────
44 */
45
46 #ifndef OME_XML_MODEL_ENUMS_UNITSFREQUENCY_H
47 #define OME_XML_MODEL_ENUMS_UNITSFREQUENCY_H
48
49 #include <ostream>
50 #include <map>
51 #include <string>
52
53 #include <ome/common/log.h>
54
55 #include <ome/xml/model/enums/EnumerationException.h>
56
57 #include <ome/xml/model/primitives/Quantity.h>
58
59 // All values in the UnitsFrequency enumeration.
60 #define OME_XML_MODEL_ENUMS_UNITSFREQUENCY_VALUES (YOTTAHERTZ)(ZETTAHERTZ)(EXAHERTZ)(PETAHERTZ)(TERAHERTZ)(GIGAHERTZ)(MEGAHERTZ)(KILOHERTZ)(HECTOHERTZ)(DECAHERTZ)(HERTZ)(DECIHERTZ)(CENTIHERTZ)(MILLIHERTZ)(MICROHERTZ)(NANOHERTZ)(PICOHERTZ)(FEMTOHERTZ)(ATTOHERTZ)(ZEPTOHERTZ)(YOCTOHERTZ)
61
62 namespace ome
63 {
64 namespace xml
65 {
66 namespace model
67 {
68 namespace enums
69 {
70
74 class UnitsFrequency
75 {
76 public:
78 enum enum_value
79 {
83 YOTTAHERTZ,
87 ZETTAHERTZ,
91 EXAHERTZ,
95 PETAHERTZ,
99 TERAHERTZ,
103 GIGAHERTZ,
107 MEGAHERTZ,
111 KILOHERTZ,
115 HECTOHERTZ,
119 DECAHERTZ,
123 HERTZ,
127 DECIHERTZ,
131 CENTIHERTZ,
135 MILLIHERTZ,
139 MICROHERTZ,
143 NANOHERTZ,
147 PICOHERTZ,
151 FEMTOHERTZ,
155 ATTOHERTZ,
159 ZEPTOHERTZ,
163 YOCTOHERTZ
164 };
165
171 UnitsFrequency (enum_value value);
172
187 UnitsFrequency (const std::string& name, bool strict = true);
188
194 UnitsFrequency (const UnitsFrequency& original);
195
200 inline UnitsFrequency&
201 operator= (const UnitsFrequency& rhs)
202 {
203 this->value = rhs.value;
204 this->name = rhs.name;
205 return *this;
206 }
207
213 inline
214 operator enum_value () const
215 {
216 return this->value;
217 }
218
224 inline
225 operator const std::string& () const
226 {
227 return *this->name;
228 }
229
231 typedef std::map<std::string, UnitsFrequency::enum_value> string_map_type;
233 typedef std::map<UnitsFrequency::enum_value, std::string> value_map_type;
234
240 static const string_map_type&
241 strings();
242
248 static const value_map_type&
249 values();
250
251 private:
257 static const string_map_type&
258 lowercase_strings();
259
261 enum_value value;
263 const std::string *name;
264 };
265
273 inline bool
274 operator== (const UnitsFrequency& lhs,
275 const UnitsFrequency& rhs)
276 {
277 return static_cast<UnitsFrequency::enum_value>(lhs) == static_cast<UnitsFrequency::enum_value>(rhs);
278 }
279
287 inline bool
288 operator== (const UnitsFrequency& lhs,
289 const UnitsFrequency::enum_value& rhs)
290 {
291 return static_cast<UnitsFrequency::enum_value>(lhs) == rhs;
292 }
293
301 inline bool
302 operator== (const UnitsFrequency::enum_value& lhs,
303 const UnitsFrequency& rhs)
304 {
305 return lhs == static_cast<UnitsFrequency::enum_value>(rhs);
306 }
307
315 inline bool
316 operator== (const UnitsFrequency& lhs,
317 const std::string& rhs)
318 {
319 return static_cast<const std::string&>(lhs) == rhs;
320 }
321
329 inline bool
330 operator== (const std::string& lhs,
331 const UnitsFrequency& rhs)
332 {
333 return lhs == static_cast<const std::string&>(rhs);
334 }
335
343 inline bool
344 operator!= (const UnitsFrequency& lhs,
345 const UnitsFrequency& rhs)
346 {
347 return static_cast<UnitsFrequency::enum_value>(lhs) != static_cast<UnitsFrequency::enum_value>(rhs);
348 }
349
357 inline bool
358 operator!= (const UnitsFrequency& lhs,
359 const UnitsFrequency::enum_value& rhs)
360 {
361 return static_cast<UnitsFrequency::enum_value>(lhs) != rhs;
362 }
363
371 inline bool
372 operator!= (const UnitsFrequency::enum_value& lhs,
373 const UnitsFrequency& rhs)
374 {
375 return lhs != static_cast<UnitsFrequency::enum_value>(rhs);
376 }
377
385 inline bool
386 operator!= (const UnitsFrequency& lhs,
387 const std::string& rhs)
388 {
389 return static_cast<const std::string&>(lhs) != rhs;
390 }
391
399 inline bool
400 operator!= (const std::string& lhs,
401 const UnitsFrequency& rhs)
402 {
403 return lhs != static_cast<const std::string&>(rhs);
404 }
405
413 template<class charT, class traits>
414 inline std::basic_ostream<charT,traits>&
415 operator<< (std::basic_ostream<charT,traits>& os,
416 const UnitsFrequency& enumeration)
417 {
418 return os << static_cast<const std::string&>(enumeration);
419 }
420
428 template<class charT, class traits>
429 inline std::basic_istream<charT,traits>&
430 operator>> (std::basic_istream<charT,traits>& is,
431 UnitsFrequency& enumeration)
432 {
433 std::string value;
434 is >> value;
435 if (is)
436 {
437 try
438 {
439 enumeration = UnitsFrequency(value, false);
440 }
441 catch (const EnumerationException&)
442 {
443 is.setstate(std::ios::failbit);
444 }
445 }
446
447 return is;
448 }
449
450 }
451 }
452 }
453 }
454
455 #include <ome/xml/model/enums/UnitsFrequencyConvert.h>
456
457 #endif // OME_XML_MODEL_ENUMS_UNITSFREQUENCY_H
458
459 /*
460 * Local Variables:
461 * mode:C++
462 * End:
463 */
ome::xml::model::enums::operator>>
std::basic_istream< charT, traits > & operator>>(std::basic_istream< charT, traits > &is, AcquisitionMode &enumeration)
Set AcquisitionMode from input stream.
Definition: AcquisitionMode.h:390
ome::xml::model::enums::UnitsFrequency::ZETTAHERTZ
zettahertz unit.
Definition: UnitsFrequency.h:87
ome::xml::model::enums::UnitsFrequency::NANOHERTZ
nanohertz unit.
Definition: UnitsFrequency.h:143
ome::xml::model::enums::operator!=
bool operator!=(const AcquisitionMode &lhs, const AcquisitionMode &rhs)
Compare two AcquisitionMode objects for non-equality.
Definition: AcquisitionMode.h:304
ome::xml::model::enums::UnitsFrequency::strings
static const string_map_type & strings()
Get a map of valid string names and enum values.
Definition: UnitsFrequency.cpp:138
ome::xml::model::enums::UnitsFrequency::string_map_type
std::map< std::string, UnitsFrequency::enum_value > string_map_type
String map type.
Definition: UnitsFrequency.h:231
ome::xml::model::enums::UnitsFrequency::YOCTOHERTZ
yoctohertz unit.
Definition: UnitsFrequency.h:163
ome::xml::model::enums::UnitsFrequency::PETAHERTZ
petahertz unit.
Definition: UnitsFrequency.h:95
ome::xml::model::enums::EnumerationException
EnumerationException is thrown when an enumeration is invalid or not found.
Definition: EnumerationException.h:74
ome::xml::model::enums::UnitsFrequency::FEMTOHERTZ
femtohertz unit.
Definition: UnitsFrequency.h:151
ome::xml::model::enums::UnitsFrequency::PICOHERTZ
picohertz unit.
Definition: UnitsFrequency.h:147
ome::xml::model::enums::UnitsFrequency::CENTIHERTZ
centihertz unit.
Definition: UnitsFrequency.h:131
ome::xml::model::enums::UnitsFrequency::GIGAHERTZ
gigahertz unit.
Definition: UnitsFrequency.h:103
ome::xml::model::enums::UnitsFrequency::ATTOHERTZ
attohertz unit.
Definition: UnitsFrequency.h:155
ome::xml::model::enums::UnitsFrequency::YOTTAHERTZ
yottahertz unit.
Definition: UnitsFrequency.h:83
ome::xml::model::enums::UnitsFrequency::lowercase_strings
static const string_map_type & lowercase_strings()
Get a map of valid lowercased string names and enum values.
Definition: UnitsFrequency.cpp:206
ome::xml::model::enums::UnitsFrequency::DECAHERTZ
decahertz unit.
Definition: UnitsFrequency.h:119
ome::xml::model::enums::UnitsFrequency::HERTZ
hertz unit.
Definition: UnitsFrequency.h:123
ome::xml::model::enums::UnitsFrequency::MEGAHERTZ
megahertz unit.
Definition: UnitsFrequency.h:107
ome::xml::model::enums::UnitsFrequency::name
const std::string * name
Enumeration name.
Definition: UnitsFrequency.h:263
ome::xml::model::enums::UnitsFrequency::values
static const value_map_type & values()
Get a map of valid enum values and string names.
Definition: UnitsFrequency.cpp:172
ome
Open Microscopy Environment C++ implementation.
ome::xml::model::enums::UnitsFrequency::value_map_type
std::map< UnitsFrequency::enum_value, std::string > value_map_type
Value map type.
Definition: UnitsFrequency.h:233
ome::xml::model::enums::operator==
bool operator==(const AcquisitionMode &lhs, const AcquisitionMode &rhs)
Compare two AcquisitionMode objects for equality.
Definition: AcquisitionMode.h:234
ome::xml::model::enums::UnitsFrequency::HECTOHERTZ
hectohertz unit.
Definition: UnitsFrequency.h:115
ome::xml::model::enums::UnitsFrequency::MICROHERTZ
microhertz unit.
Definition: UnitsFrequency.h:139
ome::xml::model::enums::UnitsFrequency::operator=
UnitsFrequency & operator=(const UnitsFrequency &rhs)
Assignment operator.
Definition: UnitsFrequency.h:201
ome::xml::model::enums::UnitsFrequency::MILLIHERTZ
millihertz unit.
Definition: UnitsFrequency.h:135
ome::xml::model::enums::UnitsFrequency::EXAHERTZ
exahertz unit.
Definition: UnitsFrequency.h:91
ome::xml::model::enums::UnitsFrequency
UnitsFrequency enumeration.
Definition: UnitsFrequency.h:74
ome::xml::model::enums::UnitsFrequency::value
enum_value value
Enumeration value.
Definition: UnitsFrequency.h:261
ome::xml::model::enums::UnitsFrequency::DECIHERTZ
decihertz unit.
Definition: UnitsFrequency.h:127
log.h
ome::xml::model::enums::UnitsFrequency::UnitsFrequency
UnitsFrequency(enum_value value)
Construct a UnitsFrequency enumeration by an enumeration value.
Definition: UnitsFrequency.cpp:75
ome::xml::model::enums::UnitsFrequency::enum_value
enum_value
Enumeration values.
Definition: UnitsFrequency.h:78
ome::xml::model::enums::UnitsFrequency::KILOHERTZ
kilohertz unit.
Definition: UnitsFrequency.h:111
ome::xml::model::enums::UnitsFrequency::TERAHERTZ
terahertz unit.
Definition: UnitsFrequency.h:99
ome::xml::model::enums::UnitsFrequency::ZEPTOHERTZ
zeptohertz unit.
Definition: UnitsFrequency.h:159