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

// [License]
// 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.
// [License]

#ifndef MESSAGE_H_
#define MESSAGE_H_

// library includes
#include<new>
#include<string>
#include<iostream>
#include<boost/shared_array.hpp>

// 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"

// reboost messages
#include "ariba/utility/transport/messages/message.hpp"


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 );

        // payload
        bool legacy_payload_disabled;
        bool releasePayload;
        Data payload; //< messages binary data
        
        // XXX testing...
        reboost::message_t newstyle_payload;
        bool wrapped_up;

        // addresses and control info
        const Address* srcAddr;
        const Address* destAddr;

public:
        /**
         * Constructor initializing name of message to the given one
         */
        inline Message() :
            legacy_payload_disabled(false), releasePayload(true), payload(),
            newstyle_payload(), wrapped_up(false), srcAddr(NULL),destAddr(NULL) {
        }

        /**
         * Constructs a new "root" message by copying the data described by
         * data.
         */
        explicit inline Message( const Data& data ) :
        legacy_payload_disabled(false), releasePayload(true),
        newstyle_payload(), wrapped_up(false), srcAddr(NULL),destAddr(NULL) {  // FIXME newstyle_payload..?
                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;
        }

        /**
         * 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>();
        }
        
        
        // XXX testing
        void set_payload_message(reboost::message_t msg)
        {
            newstyle_payload = msg;
        }
        
        void append_buffer(reboost::shared_buffer_t buff)
        {
            newstyle_payload.push_back(buff);
        }
        
        
        // XXX testing... packs this message into the payload message (do not use twice!!)
        virtual reboost::message_t wrap_up_for_sending();
        
        
        /**
         * Uses the old serialization system to serialize itself into a (new style) shared buffer.
         */
        virtual reboost::shared_buffer_t serialize_into_shared_buffer();
        
        /*
         * XXX experimental
         * 
         * Uses the old serialization system to deserialize itself out of a (new style) shared buffer.
         * @return remaining sub-buffer (the "payload")
         * 
         * Note: This is some kind of a hack! handle with care.
         */
        virtual reboost::shared_buffer_t deserialize_from_shared_buffer(reboost::shared_buffer_t buff);
        

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 == ~(size_t)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 )
        {
//          assert( ! legacy_payload_disabled );  // FIXME aktuell
            
                return PayloadSerializer( this, length );
        }

};

NAMESPACE_END

sznBeginDefault(ariba::utility::Message, X) {
        X && Payload();
} sznEnd();

#endif /* MESSAGE_H_ */