source: source/ariba/utility/messages/Message.h@ 3055

// [Licence]

// The Ariba-Underlay Copyright

//

// Copyright (c) 2008-2009, Institute of Telematics, UniversitÀt Karlsruhe (TH)

//

// Institute of Telematics

// UniversitÀt Karlsruhe (TH)

// Zirkel 2, 76128 Karlsruhe

// Germany

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

// 1. Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

// 2. Redistributions in binary form must reproduce the above copyright

// notice, this list of conditions and the following disclaimer in the

// documentation and/or other materials provided with the distribution.

//

// THIS SOFTWARE IS PROVIDED BY THE INSTITUTE OF TELEMATICS ``AS IS'' AND

// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ARIBA PROJECT OR

// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//

// The views and conclusions contained in the software and documentation

// are those of the authors and should not be interpreted as representing

// official policies, either expressed or implied, of the Institute of

// Telematics.

// [Licence]



#ifndef MESSAGE_H_

#define MESSAGE_H_



// library includes

#include<new>

#include<string>

#include<iostream>

#include<boost/shared_array.hpp>





// local includes

#include "MessageControlInfo.h"



// forward declaration

#include "_namespace.h"

NAMESPACE_BEGIN

class Message;

typedef size_t seqnum_t;

NAMESPACE_END



// library includes

#include <cassert>

#include<boost/shared_array.hpp>

#include<boost/cstdint.hpp>



// common includes

#include "ariba/utility/types/Address.h"

#include "ariba/utility/serialization.h"



std::ostream& operator<<(std::ostream& stream, const ariba::utility::Message& msg );



#include "_namespace.h"

NAMESPACE_BEGIN



using_serialization;

using ariba::utility::Address;

using boost::shared_array;



/**

 * This class implements an abstract message format.

 *

 * @author Sebastian Mies

 */

class Message: public VSerializeable {

        VSERIALIZEABLE;



protected:

        friend std::ostream& ::operator<<(std::ostream& stream, const ariba::utility::Message& msg );



        // root binary data

        shared_array<uint8_t> root;



        // payload

        bool releasePayload;

        Data payload; //< messages binary data



        // addresses and control info

        const Address* srcAddr;

        const Address* destAddr;

        const MessageControlInfo* ctrlInfo;



public:

        /**

         * Constructor initializing name of message to the given one

         */

        inline Message() :

                root(), releasePayload(true), payload(), srcAddr(NULL),destAddr(NULL),ctrlInfo(NULL) {

        }



        /**

         * Constructs a new "root" message by copying the data described by

         * data.

         */

        inline Message( const Data& data ) :

                srcAddr(NULL),destAddr(NULL),ctrlInfo(NULL) {

                this->payload = data.clone();

//              this->root = shared_array<uint8_t>((uint8_t*)data.getBuffer());

        }



        inline void dropPayload() {

                if (this->releasePayload) payload.release();

        }



        inline void setReleasePayload( bool release ) {

                this->releasePayload = release;

        }



        inline Data getPayload() const {

                return payload;

        }



        inline void setPayload( const Data& payload ) {

                this->payload = payload;

        }



        /**

         * Default destructor.

         */

        virtual ~Message();



        std::string toString() const;



        /**

         * Sets the destination address

         *

         * @param An abstract address representation

         */

        inline void setDestinationAddress(const Address* addr) {

                destAddr = addr;

        }



        /**

         * Returns the optional abstract destination address or NULL

         *

         * @return the abstract destination address

         */

        inline const Address* getDestinationAddress() const {

                return destAddr;

        }



        /**

         * Set the source address of the message

         *

         * @param addr The abstract source address

         */

        inline void setSourceAddress(const Address* addr) {

                srcAddr = addr;

        }



        /**

         * Returns the optional abstract source address or NULL

         *

         * @return The abstract source address

         */

        inline const Address* getSourceAddress() const {

                return srcAddr;

        }



        /**

         * Set optional control information

         *

         * @parm ctrlInfo The optional control information

         */

        inline void setControlInfo(const MessageControlInfo* ctrlInfo) {

                this->ctrlInfo = ctrlInfo;

        }



        /**

         * Returns the optional control information or NULL

         *

         * @return The optional control information or NULL

         */

        inline const MessageControlInfo* getControlInfo() const {

                return ctrlInfo;

        }



        /**

         * Returns a short human-readable description of this message

         *

         * @return A short human-readable description of this message

         */

        virtual const char* getDescription() const;



        /**

         * Returns a return message, that can be used to send a message

         * back to the recipient or NULL if no message can be returned.

         * The default implementation returns NULL.

         *

         * @return Return message.

         */

        virtual Message* createReturnMessage() const;



        /**

         * Encapsulate a message into the payload.

         *

         * @param message The message to be encapsulated.

         */

        inline void encapsulate( Message* message, int variant = DEFAULT_V ) {

                if ( !payload.isUnspecified() ) throw "Error: Message already encapsulated";

                payload = data_serialize( message, variant );

                message->dropPayload();

        }



        /**

         * Decapsulates message. In case the message

         * has not been deserialized, this method class

         * serialization to get an object.

         *

         * @return The message object or NULL if a deserialization

         */

        template<class T>

        inline T* decapsulate() {

                if (!payload.isUnspecified()) {

                        T* payloadMsg = new T();

                        data_deserialize( payloadMsg, payload );

                        return payloadMsg;

                }

                return NULL;

        }

        

        /**

         * The same as decapsulate, but this function

         * is used in the samples to make the semantics easier

         * to understand. The semantics is shown to be: you get 

         * a message and convert it to your type. Not as: you 

         * get a message and have to extract your message from it.

         */  

        template<class T>

        inline T* convert() {

                return decapsulate<T>();        

        }



protected:

        /**

         * This class implements an explicit serializer for

         * the message's payload.

         */

        class PayloadSerializer: public ExplicitSerializer {

        private:

                Message* msg;

                size_t len;

        public:

                finline PayloadSerializer(Message* msg, size_t length = ~0) {

                        this->msg = msg;

                        this->len = length;

                }



                sznMethodBegin(X) {

                        if (X.isSerializer()) {

                                if (!msg->payload.isUnspecified()) X && msg->payload;

                        } else {

                                if (msg->payload.isUnspecified()) {

                                        size_t l = ((len == ~0) ? X.getRemainingLength() : len);

                                        msg->payload = X.getRemainingData(l);

                                        msg->releasePayload = false;

                                }

                        }

                }

                sznMethodEnd();

        };



        /**

         * Returns a serializer of the messages payload/encapsulated

         * message.

         *

         * @param length The length of the payload

         * @return A explicit payload serializer

         */

        finline PayloadSerializer Payload( size_t length = ~0 ) {

                return PayloadSerializer( this, length );

        }



};



NAMESPACE_END



sznBeginDefault(ariba::utility::Message, X) {

        X && Payload();

} sznEnd();



#endif /* MESSAGE_H_ */