src/main/activemq/wireformat/openwire/marshal/BaseDataStreamMarshaller.h

Go to the documentation of this file.

#ifndef _ACTIVEMQ_WIREFORMAT_OPENWIRE_MARSHAL_BASEDATASTREAMMARSHALLER_H_
#define _ACTIVEMQ_WIREFORMAT_OPENWIRE_MARSHAL_BASEDATASTREAMMARSHALLER_H_

#include <activemq/wireformat/openwire/marshal/DataStreamMarshaller.h>
#include <activemq/wireformat/openwire/utils/HexTable.h>
#include <activemq/commands/MessageId.h>
#include <activemq/commands/ProducerId.h>
#include <activemq/commands/TransactionId.h>
#include <activemq/util/Config.h>

namespace activemq{
namespace wireformat{
namespace openwire{
namespace marshal{

    class AMQCPP_API BaseDataStreamMarshaller: public DataStreamMarshaller {
    private:

        // Table for converting bytes to Hex Strings.
        static utils::HexTable hexTable;

    public:

        virtual ~BaseDataStreamMarshaller() {}

        virtual int tightMarshal1(OpenWireFormat* format AMQCPP_UNUSED, commands::DataStructure* command AMQCPP_UNUSED, utils::BooleanStream* bs AMQCPP_UNUSED) {
            return 0;
        }

        virtual void tightMarshal2(OpenWireFormat* format AMQCPP_UNUSED,
                                   commands::DataStructure* command AMQCPP_UNUSED,
                                   decaf::io::DataOutputStream* ds AMQCPP_UNUSED,
                                   utils::BooleanStream* bs AMQCPP_UNUSED) {}

        virtual void tightUnmarshal(OpenWireFormat* format AMQCPP_UNUSED,
                                    commands::DataStructure* command AMQCPP_UNUSED,
                                    decaf::io::DataInputStream* dis AMQCPP_UNUSED,
                                    utils::BooleanStream* bs AMQCPP_UNUSED) {}

        virtual void looseMarshal(OpenWireFormat* format AMQCPP_UNUSED,
                                  commands::DataStructure* command AMQCPP_UNUSED,
                                  decaf::io::DataOutputStream* ds AMQCPP_UNUSED) {}

        virtual void looseUnmarshal(OpenWireFormat* format AMQCPP_UNUSED,
                                    commands::DataStructure* command AMQCPP_UNUSED,
                                    decaf::io::DataInputStream* dis AMQCPP_UNUSED) {}

    public:
        // Statics

        static std::string toString(const commands::MessageId* id);

        static std::string toString(const commands::ProducerId* id);

        static std::string toString(const commands::TransactionId* txnId);

        static std::string toHexFromBytes(const std::vector<unsigned char>& data);

    protected:

        virtual commands::DataStructure* tightUnmarshalCachedObject(OpenWireFormat* wireFormat, decaf::io::DataInputStream* dataIn, utils::BooleanStream* bs);

        virtual int tightMarshalCachedObject1(OpenWireFormat* wireFormat, commands::DataStructure* data, utils::BooleanStream* bs);

        virtual void tightMarshalCachedObject2(OpenWireFormat* wireFormat, commands::DataStructure* data, decaf::io::DataOutputStream* dataOut,utils::BooleanStream* bs);

        virtual void looseMarshalCachedObject(OpenWireFormat* wireFormat, commands::DataStructure* data, decaf::io::DataOutputStream* dataOut);

        virtual commands::DataStructure* looseUnmarshalCachedObject(OpenWireFormat* wireFormat, decaf::io::DataInputStream* dataIn);

        virtual int tightMarshalNestedObject1(OpenWireFormat* wireFormat, commands::DataStructure* object, utils::BooleanStream* bs);

        virtual void tightMarshalNestedObject2(OpenWireFormat* wireFormat, commands::DataStructure* object, decaf::io::DataOutputStream* dataOut,
                utils::BooleanStream* bs);

        virtual commands::DataStructure* tightUnmarshalNestedObject(OpenWireFormat* wireFormat, decaf::io::DataInputStream* dataIn, utils::BooleanStream* bs);

        virtual commands::DataStructure* looseUnmarshalNestedObject(OpenWireFormat* wireFormat, decaf::io::DataInputStream* dataIn);

        virtual void looseMarshalNestedObject(OpenWireFormat* wireFormat, commands::DataStructure* object, decaf::io::DataOutputStream* dataOut);

        virtual std::string tightUnmarshalString(decaf::io::DataInputStream* dataIn, utils::BooleanStream* bs);

        virtual int tightMarshalString1(const std::string& value, utils::BooleanStream* bs);

        virtual void tightMarshalString2(const std::string& value, decaf::io::DataOutputStream* dataOut, utils::BooleanStream* bs);

        virtual void looseMarshalString(const std::string value, decaf::io::DataOutputStream* dataOut);

        virtual std::string looseUnmarshalString(decaf::io::DataInputStream* dataIn);

        virtual int tightMarshalLong1(OpenWireFormat* wireFormat, long long value, utils::BooleanStream* bs);

        virtual void tightMarshalLong2(OpenWireFormat* wireFormat, long long value, decaf::io::DataOutputStream* dataOut, utils::BooleanStream* bs);

        virtual long long tightUnmarshalLong(OpenWireFormat* wireFormat, decaf::io::DataInputStream* dataIn, utils::BooleanStream* bs);

        virtual void looseMarshalLong(OpenWireFormat* wireFormat, long long value, decaf::io::DataOutputStream* dataOut);

        virtual long long looseUnmarshalLong(OpenWireFormat* wireFormat, decaf::io::DataInputStream* dataIn);

        virtual std::vector<unsigned char> tightUnmarshalByteArray(decaf::io::DataInputStream* dataIn, utils::BooleanStream* bs);

        virtual std::vector<unsigned char> looseUnmarshalByteArray(decaf::io::DataInputStream* dataIn);

        virtual std::vector<unsigned char> tightUnmarshalConstByteArray(decaf::io::DataInputStream* dataIn, utils::BooleanStream* bs, int size);

        virtual std::vector<unsigned char> looseUnmarshalConstByteArray(decaf::io::DataInputStream* dataIn, int size);

        virtual commands::DataStructure* tightUnmarshalBrokerError(OpenWireFormat* wireFormat, decaf::io::DataInputStream* dataIn, utils::BooleanStream* bs);

        virtual int tightMarshalBrokerError1(OpenWireFormat* wireFormat, commands::DataStructure* data, utils::BooleanStream* bs);

        virtual void tightMarshalBrokerError2(OpenWireFormat* wireFormat, commands::DataStructure* data, decaf::io::DataOutputStream* dataOut,utils::BooleanStream* bs);

        virtual commands::DataStructure* looseUnmarshalBrokerError(OpenWireFormat* wireFormat, decaf::io::DataInputStream* dataIn);

        virtual void looseMarshalBrokerError(OpenWireFormat* wireFormat, commands::DataStructure* data, decaf::io::DataOutputStream* dataOut);

        template<typename T>
        int tightMarshalObjectArray1(OpenWireFormat* wireFormat, std::vector<T> objects, utils::BooleanStream* bs) {

            try {
                if (!objects.empty()) {
                    int rc = 0;
                    bs->writeBoolean(true);
                    rc += 2;
                    for (std::size_t i = 0; i < objects.size(); ++i) {
                        rc += tightMarshalNestedObject1(wireFormat, objects[i].get(), bs);
                    }
                    return rc;

                } else {
                    bs->writeBoolean(false);
                    return 0;
                }
            }
            AMQ_CATCH_RETHROW(decaf::io::IOException)
            AMQ_CATCH_EXCEPTION_CONVERT(decaf::lang::Exception, decaf::io::IOException)
            AMQ_CATCHALL_THROW(decaf::io::IOException)
        }

        template<typename T>
        void tightMarshalObjectArray2(OpenWireFormat* wireFormat, std::vector<T> objects, decaf::io::DataOutputStream* dataOut, utils::BooleanStream* bs) {

            try {

                if (bs->readBoolean()) {

                    dataOut->writeShort((short) objects.size());
                    for (std::size_t i = 0; i < objects.size(); ++i) {
                        tightMarshalNestedObject2(wireFormat, objects[i].get(), dataOut, bs);
                    }
                }
            }
            AMQ_CATCH_RETHROW(decaf::io::IOException)
            AMQ_CATCH_EXCEPTION_CONVERT(decaf::lang::Exception, decaf::io::IOException)
            AMQ_CATCHALL_THROW(decaf::io::IOException)
        }

        template<typename T>
        void looseMarshalObjectArray(OpenWireFormat* wireFormat, std::vector<T> objects, decaf::io::DataOutputStream* dataOut) {

            try {

                dataOut->writeBoolean(!objects.empty());
                if (!objects.empty()) {

                    dataOut->writeShort((short) objects.size());
                    for (std::size_t i = 0; i < objects.size(); ++i) {
                        looseMarshalNestedObject(wireFormat, objects[i].get(), dataOut);
                    }
                }
            }
            AMQ_CATCH_RETHROW(decaf::io::IOException)
            AMQ_CATCH_EXCEPTION_CONVERT(decaf::lang::Exception, decaf::io::IOException)
            AMQ_CATCHALL_THROW(decaf::io::IOException)
        }

    protected:

        virtual std::string readAsciiString(decaf::io::DataInputStream* dataIn);

    };

}}}}

#endif /*_ACTIVEMQ_WIREFORMAT_OPENWIRE_MARSHAL_BASEDATASTREAMMARSHALLER_H_*/

---