src/main/activemq/util/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_*/

---