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_*/