1 /*
2  * File:  Value.h
3  *
4  * Copyright (c) Freescale Semiconductor, Inc. All rights reserved.
5  * See included license file for license details.
6  */
7 #if !defined(_Value_h_)
8 #define _Value_h_
9 
10 #include "stdafx.h"
11 #include <string>
12 #include "int_size.h"
13 #include "Blob.h"
14 
15 namespace elftosb
16 {
17 
18 /*!
19  * \brief Abstract base class for values of arbitrary types.
20  */
21 class Value
22 {
23 public:
Value()24           Value() {}
~Value()25           virtual ~Value() {}
26 
27           virtual std::string getTypeName() const = 0;
28           virtual size_t getSize() const = 0;
29 };
30 
31 /*!
32  * \brief 32-bit signed integer value.
33  */
34 class IntegerValue : public Value
35 {
36 public:
IntegerValue()37           IntegerValue() : m_value(0) {}
IntegerValue(uint32_t value)38           IntegerValue(uint32_t value) : m_value(value) {}
IntegerValue(const IntegerValue & other)39           IntegerValue(const IntegerValue & other) : m_value(other.m_value) {}
40 
getTypeName()41           virtual std::string getTypeName() const { return "integer"; }
getSize()42           virtual size_t getSize() const { return sizeof(m_value); }
43 
getValue()44           inline uint32_t getValue() const { return m_value; }
45 
uint32_t()46           inline operator uint32_t () const { return m_value; }
47 
48           inline IntegerValue & operator = (uint32_t value) { m_value = value; return *this; }
49 
50 protected:
51           uint32_t m_value;   //!< The integer value.
52 };
53 
54 /*!
55  * \brief Adds a word size attribute to IntegerValue.
56  *
57  * The word size really only acts as an attribute that is carried along
58  * with the integer value. It doesn't affect the actual value at all.
59  * However, you can use the getWordSizeMask() method to mask off bits
60  * that should not be there.
61  *
62  * The word size defaults to a 32-bit word.
63  */
64 class SizedIntegerValue : public IntegerValue
65 {
66 public:
SizedIntegerValue()67           SizedIntegerValue() : IntegerValue(), m_size(kWordSize) {}
IntegerValue(value)68           SizedIntegerValue(uint32_t value, int_size_t size=kWordSize) : IntegerValue(value), m_size(size) {}
SizedIntegerValue(uint16_t value)69           SizedIntegerValue(uint16_t value) : IntegerValue(value), m_size(kHalfWordSize) {}
SizedIntegerValue(uint8_t value)70           SizedIntegerValue(uint8_t value) : IntegerValue(value), m_size(kByteSize) {}
SizedIntegerValue(const SizedIntegerValue & other)71           SizedIntegerValue(const SizedIntegerValue & other) : IntegerValue(other), m_size(other.m_size) {}
72 
getTypeName()73           virtual std::string getTypeName() const { return "sized integer"; }
74           virtual size_t getSize() const;
75 
getWordSize()76           inline int_size_t getWordSize() const { return m_size; }
setWordSize(int_size_t size)77           inline void setWordSize(int_size_t size) { m_size = size; }
78 
79           //! \brief Returns a 32-bit mask value dependant on the word size attribute.
80           uint32_t getWordSizeMask() const;
81 
82           //! \name Assignment operators
83           //! These operators set the word size as well as the integer value.
84           //@{
85           SizedIntegerValue & operator = (uint8_t value) { m_value = value; m_size = kByteSize; return *this; }
86           SizedIntegerValue & operator = (uint16_t value) { m_value = value; m_size = kHalfWordSize; return *this; }
87           SizedIntegerValue & operator = (uint32_t value) { m_value = value; m_size = kWordSize; return *this; }
88           //@}
89 
90 protected:
91           int_size_t m_size;  //!< Size of the integer.
92 };
93 
94 /*!
95  * \brief String value.
96  *
97  * Simply wraps the STL std::string class.
98  */
99 class StringValue : public Value
100 {
101 public:
StringValue()102           StringValue() : m_value() {}
StringValue(const std::string & value)103           StringValue(const std::string & value) : m_value(value) {}
StringValue(const std::string * value)104           StringValue(const std::string * value) : m_value(*value) {}
StringValue(const StringValue & other)105           StringValue(const StringValue & other) : m_value(other.m_value) {}
106 
getTypeName()107           virtual std::string getTypeName() const { return "string"; }
getSize()108           virtual size_t getSize() const { return m_value.size(); }
109 
110           operator const char * () const { return m_value.c_str(); }
111           operator const std::string & () const { return m_value; }
112           operator std::string & () { return m_value; }
113           operator const std::string * () { return &m_value; }
114           operator std::string * () { return &m_value; }
115 
116           StringValue & operator = (const StringValue & other) { m_value = other.m_value; return *this; }
117           StringValue & operator = (const std::string & value) { m_value = value; return *this; }
118           StringValue & operator = (const char * value) { m_value = value; return *this; }
119 
120 protected:
121           std::string m_value;
122 };
123 
124 /*!
125  * \brief Binary object value of arbitrary size.
126  */
127 class BinaryValue : public Value, public Blob
128 {
129 public:
BinaryValue()130           BinaryValue() : Value(), Blob() {}
131 
getTypeName()132           virtual std::string getTypeName() const { return "binary"; }
getSize()133           virtual size_t getSize() const { return getLength(); }
134 };
135 
136 }; // namespace elftosb
137 
138 #endif // _Value_h_
139