connect_options.h

Go to the documentation of this file.

/*******************************************************************************
 * Copyright (c) 2013-2016 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_connect_options_h
#define __mqtt_connect_options_h

#include "MQTTAsync.h"
#include "mqtt/types.h"
#include "mqtt/message.h"
#include "mqtt/topic.h"
#include "mqtt/token.h"
#include "mqtt/string_collection.h"
#include "mqtt/will_options.h"
#include "mqtt/ssl_options.h"
#include <vector>
#include <chrono>

namespace mqtt {


class connect_options
{
    static const MQTTAsync_connectOptions DFLT_C_STRUCT ;

    MQTTAsync_connectOptions opts_;

    will_options will_;

    ssl_options ssl_;

    string_ref userName_;

    binary_ref password_;

    token_ptr tok_;

    const_string_collection_ptr serverURIs_;

    friend class async_client;
    friend class connect_options_test;
    friend class token_test;

    const char* c_str(const string_ref& sr) {
        return sr.empty() ? nullptr : sr.c_str();
    }

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

    connect_options();
    connect_options(string_ref userName, binary_ref password);
    connect_options(const connect_options& opt);
    connect_options(connect_options&& opt);
    connect_options& operator=(const connect_options& opt);
    connect_options& operator=(connect_options&& opt);
    std::chrono::seconds get_keep_alive_interval() const {
        return std::chrono::seconds(opts_.keepAliveInterval);
    }
    std::chrono::seconds get_connect_timeout() const {
        return std::chrono::seconds(opts_.connectTimeout);
    }
    string get_user_name() const { return userName_ ? userName_.to_string() : string(); }
    binary_ref get_password() const { return password_; }
    string get_password_str() const {
        return password_ ? password_.to_string() : string();
    }
    int get_max_inflight() const { return opts_.maxInflight; }
    string get_will_topic() const {
        return will_.get_topic();
    }
    const_message_ptr get_will_message() const {
        return will_.get_message();
    }
    const will_options& get_will_options() const { return will_; }
    const ssl_options& get_ssl_options() const { return ssl_; }
    void set_ssl(const ssl_options& ssl);
    bool is_clean_session() const { return to_bool(opts_.cleansession); }
    token_ptr get_token() const { return tok_; }
    const_string_collection_ptr get_servers() const { return serverURIs_; }
    int get_mqtt_version() const { return opts_.MQTTVersion; }
    bool get_automatic_reconnect() const { return to_bool(opts_.automaticReconnect); }
    std::chrono::seconds get_min_retry_interval() const {
        return std::chrono::seconds(opts_.minRetryInterval);
    }
    std::chrono::seconds get_max_retry_interval() const {
        return std::chrono::seconds(opts_.maxRetryInterval);
    }

    void set_clean_session(bool cleanSession) {
        opts_.cleansession = to_int(cleanSession);
    }
    void set_connection_timeout(int timeout) {
        opts_.connectTimeout = timeout;
    }
    void set_keep_alive_interval(int keepAliveInterval) {
        opts_.keepAliveInterval = keepAliveInterval;
    }
    template <class Rep, class Period>
    void set_keep_alive_interval(const std::chrono::duration<Rep, Period>& interval) {
        // TODO: Check range
        set_keep_alive_interval((int) to_seconds_count(interval));
    }
    void set_connect_timeout(int to) {
        opts_.connectTimeout = to;
    }
    template <class Rep, class Period>
    void set_connect_timeout(const std::chrono::duration<Rep, Period>& to) {
        // TODO: check range
        set_connect_timeout((int) to_seconds_count(to));
    }
    void set_user_name(string_ref userName);
    void set_password(binary_ref password);
    void set_max_inflight(int n) { opts_.maxInflight = n; }
    void set_will(const will_options& will);
    void set_token(const token_ptr& tok);
    void set_servers(const_string_collection_ptr serverURIs);
    void set_mqtt_version(int mqttVersion) { opts_.MQTTVersion = mqttVersion; }
    void set_automatic_reconnect(bool on) {
        opts_.automaticReconnect = on ? !0 : 0;
    }
    void set_automatic_reconnect(int minRetryInterval, int maxRetryInterval);
    template <class Rep1, class Period1, class Rep2, class Period2>
    void set_automatic_reconnect(const std::chrono::duration<Rep1, Period1>& minRetryInterval,
                                 const std::chrono::duration<Rep2, Period2>& maxRetryInterval) {
        set_automatic_reconnect((int) to_seconds_count(minRetryInterval),
                                (int) to_seconds_count(maxRetryInterval));
    }
    string to_string() const;
};

using connect_options_ptr = connect_options::ptr_t;

// end namespace mqtt
}

#endif      // __mqtt_connect_options_h