PrimitiveValueNode.h

Go to the documentation of this file.

 
#ifndef _ACTIVEMQ_UTIL_PRIMITIVEVALUENODE_H_
#define _ACTIVEMQ_UTIL_PRIMITIVEVALUENODE_H_
 
#include <activemq/util/Config.h>
#include <decaf/util/NoSuchElementException.h>
#include <decaf/util/Map.h>
#include <decaf/util/List.h>
 
namespace activemq {
namespace util {
 
    class AMQCPP_API PrimitiveValueNode {
    public:
 
        enum PrimitiveType{
            NULL_TYPE          = 0,
            BOOLEAN_TYPE       = 1,
            BYTE_TYPE          = 2,
            CHAR_TYPE          = 3,
            SHORT_TYPE         = 4,
            INTEGER_TYPE       = 5,
            LONG_TYPE          = 6,
            DOUBLE_TYPE        = 7,
            FLOAT_TYPE         = 8,
            STRING_TYPE        = 9,
            BYTE_ARRAY_TYPE    = 10,
            MAP_TYPE           = 11,
            LIST_TYPE          = 12,
            BIG_STRING_TYPE    = 13
        };
 
        union PrimitiveValue {
 
            bool boolValue;
            unsigned char byteValue;
            char charValue;
            short shortValue;
            int intValue;
            long long longValue;
            double doubleValue;
            float floatValue;
            std::string* stringValue;
            std::vector<unsigned char>* byteArrayValue;
            decaf::util::List<PrimitiveValueNode>* listValue;
            decaf::util::Map<std::string, PrimitiveValueNode>* mapValue;
 
        };
 
    private:
 
        PrimitiveType valueType;
        PrimitiveValue value;
 
    public:
 
        PrimitiveValueNode();
 
        PrimitiveValueNode(bool value);
 
        PrimitiveValueNode(unsigned char value);
 
        PrimitiveValueNode(char value);
 
        PrimitiveValueNode(short value);
 
        PrimitiveValueNode(int value);
 
        PrimitiveValueNode(long long value);
 
        PrimitiveValueNode(float value);
 
        PrimitiveValueNode(double value);
 
        PrimitiveValueNode(const char* value);
 
        PrimitiveValueNode(const std::string& value);
 
        PrimitiveValueNode(const std::vector<unsigned char>& value);
 
        PrimitiveValueNode(const decaf::util::List<PrimitiveValueNode>& value);
 
        PrimitiveValueNode(const decaf::util::Map<std::string, PrimitiveValueNode>& value);
 
        PrimitiveValueNode(const PrimitiveValueNode& node);
 
        ~PrimitiveValueNode() {
            clear();
        }
 
        PrimitiveValueNode& operator =(const PrimitiveValueNode& node);
 
        bool operator==(const PrimitiveValueNode& node) const;
 
        PrimitiveType getType() const {
            return valueType;
        }
 
        PrimitiveValue getValue() const {
            return this->value;
        }
 
        void setValue(const PrimitiveValue& value, PrimitiveType valueType);
 
        void clear();
 
        void setBool(bool value);
 
        bool getBool() const;
 
        void setByte(unsigned char value);
 
        unsigned char getByte() const;
 
        void setChar(char value);
 
        char getChar() const;
 
        void setShort(short value);
 
        short getShort() const;
 
        void setInt(int value);
 
        int getInt() const;
 
        void setLong(long long value);
 
        long long getLong() const;
 
        void setFloat(float value);
 
        float getFloat() const;
 
        void setDouble(double value);
 
        double getDouble() const;
 
        void setString(const std::string& value);
 
        std::string getString() const;
 
        void setByteArray(const std::vector<unsigned char>& value);
 
        std::vector<unsigned char> getByteArray() const;
 
        void setList(const decaf::util::List<PrimitiveValueNode>& value);
 
        const decaf::util::List<PrimitiveValueNode>& getList() const;
 
        void setMap(const decaf::util::Map<std::string, PrimitiveValueNode>& value);
 
        const decaf::util::Map<std::string, PrimitiveValueNode>& getMap() const;
 
        std::string toString() const;
 
    };
 
}}
 
#endif /*_ACTIVEMQ_UTIL_PRIMITIVEVALUENODE_H_*/