message.hpp

Go to the documentation of this file.

/*
 * Title:        bits/message.hpp
 * Description:  C++ header-only wrapper for C-ABI data_t type
 * $Copyright (c) 2015-2017 Software AG, Darmstadt, Germany and/or Software AG USA Inc., Reston, VA, USA, and/or its subsidiaries and/or its affiliates and/or their licensors.$
 * Use, reproduction, transfer, publication or disclosure is prohibited except as specifically provided for in your License Agreement with Software AG
 * @Version:     $Id: message.hpp 302187 2017-02-15 10:49:57Z rit $
 */

#ifndef _DATAT_BITS_INCLUDE_TAG
#error Must only be included from sag_connectivity_cpp.hpp, use that instead
#endif

class Message: protected sag_underlying_message_t
{
public:
        typedef com::softwareag::connectivity::metadata_t metadata_t;
        typedef com::softwareag::connectivity::map_t map_t;
        typedef data_t payload_t;
        Message();

        explicit Message(payload_t &&_payload);

        Message(payload_t &&_payload, metadata_t &&_metadata);
        Message(payload_t &&_payload, map_t &&_metadata);

        ~Message();

        Message(Message &&other);

        Message &operator=(Message &&other)
        {
                Message tmp;
                swap(std::move(tmp));
                swap(std::move(other));
                return *this;
        }
        const payload_t &getPayload() const;
        const metadata_t &getMetadata() const { return reinterpret_cast<const metadata_t&>(metadata); }

        payload_t &getPayload() { return static_cast<payload_t&>(payload); }
        metadata_t &getMetadata() { return reinterpret_cast<metadata_t&>(metadata); }
        map_t &getMetadataMap() { return static_cast<map_t&>(metadata); }
        const map_t &getMetadataMap() const { return static_cast<const map_t&>(metadata); }

        void setPayload(payload_t &&_payload);
        void setMetadata(metadata_t &&_metadata);
        void setMetadata(map_t &&_metadata);

        void swap(Message &&other);

        Message copy() const
        {
                return Message(getPayload().copy(), getMetadata().copy());
        }

        static const char *HOST_MESSAGE_TYPE() {
                return "sag.type";
        }

        static const char *CHANNEL() {
                return "sag.channel";
        }

        static const char *CONTROL_TYPE() {
                return "sag.control.type";
        }

        static const char* MESSAGE_ID() {
                return "sag.messageId";
        }

        static const char* REQUEST_ID() {
                return "sag.requestId";
        }

        static const char* CONTROL_TYPE_FLUSH() {
                return "Flush";
        }

        static const char* CONTROL_TYPE_FLUSH_ACK() {
                return "FlushAck";
        }

        static const char* CONTROL_TYPE_ACK_REQUIRED() {
                return "AckRequired";
        }

        static const char* CONTROL_TYPE_ACK_UPTO() {
                return "AckUpTo";
        }

        Message &putMetadataValue(const char *key, const char *value);

        Message &putMetadataValue(data_t &&key, data_t &&value);

        Message &putMetadataValue(const std::string &key, const std::string &value) { return putMetadataValue(key.c_str(), value.c_str()); }
private:
        Message(const Message &other) { abort(); }
        Message &operator=(const Message &other) { abort(); }
};