message.h

Go to the documentation of this file.

/*******************************************************************************
 * Copyright (c) 2013-2017 Frank Pagliughi <fpagliughi@mindspring.com>
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * and Eclipse Distribution License v1.0 which accompany this distribution.
 *
 * The Eclipse Public License is available at
 *    http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 *   http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *    Frank Pagliughi - initial implementation and documentation
 *******************************************************************************/

#ifndef __mqtt_message_h
#define __mqtt_message_h

#include "MQTTAsync.h"
#include "mqtt/buffer_ref.h"
#include "mqtt/exception.h"
#include <memory>

namespace mqtt {


class message
{
public:
    static constexpr int DFLT_QOS = 0;
    static constexpr bool DFLT_RETAINED = false;

private:
    static const MQTTAsync_message DFLT_C_STRUCT;

    static const string EMPTY_STR;
    static const binary EMPTY_BIN;

    MQTTAsync_message msg_;
    string_ref topic_;
    binary_ref payload_;

    friend class async_client;
    friend class message_test;

    void set_duplicate(bool dup) { msg_.dup = to_int(dup); }

public:
    using ptr_t = std::shared_ptr<message>;
    using const_ptr_t = std::shared_ptr<const message>;

    message();
    message(string_ref topic, const void* payload, size_t len,
            int qos, bool retained);
    message(string_ref topic, const void* payload, size_t len)
        : message(std::move(topic), payload, len, DFLT_QOS, DFLT_RETAINED) {}
    message(string_ref topic, binary_ref payload, int qos, bool retained);
    message(string_ref topic, binary_ref payload)
        : message(std::move(topic), std::move(payload), DFLT_QOS, DFLT_RETAINED) {}
    message(string_ref topic, const MQTTAsync_message& msg);
    message(const message& other);
    message(message&& other);
    ~message() {}

    static ptr_t create(string_ref topic, const void* payload, size_t len,
                        int qos, bool retained) {
        return std::make_shared<message>(std::move(topic), payload, len,
                                         qos, retained);
    }
    static ptr_t create(string_ref topic, const void* payload, size_t len) {
        return std::make_shared<message>(std::move(topic), payload, len,
                                         DFLT_QOS, DFLT_RETAINED);
    }
    static ptr_t create(string_ref topic, binary_ref payload, int qos, bool retained) {
        return std::make_shared<message>(std::move(topic), std::move(payload),
                                         qos, retained);
    }
    static ptr_t create(string_ref topic, binary_ref payload) {
        return std::make_shared<message>(std::move(topic), std::move(payload),
                                         DFLT_QOS, DFLT_RETAINED);
    }
    static ptr_t create(string_ref topic, const MQTTAsync_message& msg) {
        return std::make_shared<message>(std::move(topic), msg);
    }
    message& operator=(const message& rhs);
    message& operator=(message&& rhs);
    void set_topic(string_ref topic) {
        topic_ = topic_ ? std::move(topic) : string_ref(string());
    }
    const string_ref& get_topic_ref() const { return topic_; }
    const string& get_topic() const { 
        return topic_ ? topic_.str() : EMPTY_STR; 
    }
    void clear_payload();
    const binary_ref& get_payload_ref() const { return payload_; }
    const binary& get_payload() const { 
        return payload_ ? payload_.str() : EMPTY_BIN; 
    }
    const string& get_payload_str() const { 
        return payload_ ? payload_.str() : EMPTY_STR;
    }
    int get_qos() const { return msg_.qos; }
    bool is_duplicate() const { return to_bool(msg_.dup); }
    bool is_retained() const { return to_bool(msg_.retained); }
    void set_payload(binary_ref payload);
    void set_payload(const void* payload, size_t n) {
        set_payload(binary_ref(static_cast<const binary_ref::value_type*>(payload), n));
    }
    void set_qos(int qos) {
        validate_qos(qos);
        msg_.qos = qos;
    }
    void set_retained(bool retained) { msg_.retained = to_int(retained); }
    string to_string() const { return get_payload_str(); }
    static void validate_qos(int qos) {
        if (qos < 0 || qos > 2)
            throw exception(MQTTASYNC_BAD_QOS, "Bad QoS");
    }
};

using message_ptr = message::ptr_t;

using const_message_ptr = message::const_ptr_t;

inline message_ptr make_message(string_ref topic, const void* payload, size_t len) {
    return mqtt::message::create(std::move(topic), payload, len);
}

inline message_ptr make_message(string_ref topic, const void* payload, size_t len,
                                int qos, bool retained) {
    return mqtt::message::create(std::move(topic), payload, len, qos, retained);
}

inline message_ptr make_message(string_ref topic, binary_ref payload) {
    return mqtt::message::create(std::move(topic), std::move(payload));
}

inline message_ptr make_message(string_ref topic, binary_ref payload,
                                int qos, bool retained) {
    return mqtt::message::create(std::move(topic), std::move(payload), qos, retained);
}

// end namespace mqtt
}

#endif      // __mqtt_message_h