paho-mqtt-cpp
MQTT C++ Client for POSIX and Windows
Loading...
Searching...
No Matches
connect_options.h
Go to the documentation of this file.
1
7
8/*******************************************************************************
9 * Copyright (c) 2013-2020 Frank Pagliughi <fpagliughi@mindspring.com>
10 *
11 * All rights reserved. This program and the accompanying materials
12 * are made available under the terms of the Eclipse Public License v2.0
13 * and Eclipse Distribution License v1.0 which accompany this distribution.
14 *
15 * The Eclipse Public License is available at
16 * http://www.eclipse.org/legal/epl-v20.html
17 * and the Eclipse Distribution License is available at
18 * http://www.eclipse.org/org/documents/edl-v10.php.
19 *
20 * Contributors:
21 * Frank Pagliughi - initial implementation and documentation
22 *******************************************************************************/
23
24#ifndef __mqtt_connect_options_h
25#define __mqtt_connect_options_h
26
27#include "MQTTAsync.h"
28#include "mqtt/types.h"
29#include "mqtt/message.h"
30#include "mqtt/topic.h"
31#include "mqtt/token.h"
33#include "mqtt/will_options.h"
34#include "mqtt/ssl_options.h"
35#include "mqtt/platform.h"
36#include <vector>
37#include <map>
38#include <chrono>
39
40namespace mqtt {
41
43
49{
51 PAHO_MQTTPP_EXPORT static const MQTTAsync_connectOptions DFLT_C_STRUCT;
52
54 PAHO_MQTTPP_EXPORT static const MQTTAsync_connectOptions DFLT_C_STRUCT5;
55
57 PAHO_MQTTPP_EXPORT static const MQTTAsync_connectOptions DFLT_C_STRUCT_WS;
58
60 PAHO_MQTTPP_EXPORT static const MQTTAsync_connectOptions DFLT_C_STRUCT5_WS;
61
63 MQTTAsync_connectOptions opts_;
64
66 will_options will_;
67
69 ssl_options ssl_;
70
72 string_ref userName_;
73
75 binary_ref password_;
76
78 token_ptr tok_;
79
82
84 properties props_;
85
87 name_value_collection httpHeaders_;
88
90 string httpProxy_;
91
93 string httpsProxy_;
94
96 friend class async_client;
97
108 const char* c_str(const string_ref& sr) {
109 return sr.empty() ? nullptr : sr.c_str();
110 }
111 const char* c_str(const string& s) {
112 return s.empty() ? nullptr : s.c_str();
113 }
117 void update_c_struct();
118
123 connect_options(const MQTTAsync_connectOptions& copts) : opts_(copts) {}
124
125public:
127 using ptr_t = std::shared_ptr<connect_options>;
129 using const_ptr_t = std::shared_ptr<const connect_options>;
130
136 explicit connect_options(int ver=MQTTVERSION_DEFAULT);
144 string_ref userName, binary_ref password,
145 int ver=MQTTVERSION_DEFAULT
146 );
176 return connect_options(DFLT_C_STRUCT_WS);
177 }
187 return connect_options(DFLT_C_STRUCT5_WS);
188 }
202 #if defined(UNIT_TESTS)
203 const MQTTAsync_connectOptions& c_struct() const { return opts_; }
204 #endif
209 std::chrono::seconds get_keep_alive_interval() const {
210 return std::chrono::seconds(opts_.keepAliveInterval);
211 }
218 std::chrono::seconds get_connect_timeout() const {
219 return std::chrono::seconds(opts_.connectTimeout);
220 }
225 string get_user_name() const { return userName_ ? userName_.to_string() : string(); }
230 binary_ref get_password() const { return password_; }
235 string get_password_str() const {
236 return password_ ? password_.to_string() : string();
237 }
243 int get_max_inflight() const { return opts_.maxInflight; }
248 string get_will_topic() const {
249 return will_.get_topic();
250 }
256 return will_.get_message();
257 }
262 const will_options& get_will_options() const { return will_; }
267 const ssl_options& get_ssl_options() const { return ssl_; }
275 void set_ssl(const ssl_options& ssl);
283 void set_ssl(ssl_options&& ssl);
289 bool is_clean_session() const { return to_bool(opts_.cleansession); }
295 bool is_clean_start() const { return to_bool(opts_.cleanstart); }
300 token_ptr get_token() const { return tok_; }
308 const_string_collection_ptr get_servers() const { return serverURIs_; }
317 int get_mqtt_version() const { return opts_.MQTTVersion; }
324 bool get_automatic_reconnect() const { return to_bool(opts_.automaticReconnect); }
330 std::chrono::seconds get_min_retry_interval() const {
331 return std::chrono::seconds(opts_.minRetryInterval);
332 }
338 std::chrono::seconds get_max_retry_interval() const {
339 return std::chrono::seconds(opts_.maxRetryInterval);
340 }
351 void set_clean_session(bool cleanSession);
365 void set_clean_start(bool cleanStart);
373 void set_keep_alive_interval(int keepAliveInterval) {
374 opts_.keepAliveInterval = keepAliveInterval;
375 }
383 template <class Rep, class Period>
384 void set_keep_alive_interval(const std::chrono::duration<Rep, Period>& interval) {
385 // TODO: Check range
387 }
394 void set_connect_timeout(int timeout) {
395 opts_.connectTimeout = timeout;
396 }
403 template <class Rep, class Period>
404 void set_connect_timeout(const std::chrono::duration<Rep, Period>& timeout) {
405 // TODO: check range
407 }
412 void set_user_name(string_ref userName);
417 void set_password(binary_ref password);
423 void set_max_inflight(int n) { opts_.maxInflight = n; }
428 void set_will(const will_options& will);
433 void set_will(will_options&& will);
438 void set_will_message(const message& msg) {
440 }
446 if (msg) set_will(will_options(*msg));
447 }
452 void set_token(const token_ptr& tok);
481 void set_mqtt_version(int mqttVersion);
488 opts_.automaticReconnect = to_int(on);
489 }
497 void set_automatic_reconnect(int minRetryInterval, int maxRetryInterval);
505 template <class Rep1, class Period1, class Rep2, class Period2>
506 void set_automatic_reconnect(const std::chrono::duration<Rep1, Period1>& minRetryInterval,
507 const std::chrono::duration<Rep2, Period2>& maxRetryInterval) {
508 set_automatic_reconnect((int) to_seconds_count(minRetryInterval),
509 (int) to_seconds_count(maxRetryInterval));
510 }
515 const properties& get_properties() const { return props_; }
520 properties& get_properties() { return props_; }
525 void set_properties(const properties& props);
536 return httpHeaders_;
537 }
542 void set_http_headers(const name_value_collection& httpHeaders) {
543 httpHeaders_ = httpHeaders;
544 opts_.httpHeaders = httpHeaders_.empty() ? nullptr : httpHeaders_.c_arr();
545 }
551 httpHeaders_ = std::move(httpHeaders);
552 opts_.httpHeaders = httpHeaders_.empty() ? nullptr : httpHeaders_.c_arr();
553 }
558 string get_http_proxy() const { return httpProxy_; }
564 void set_http_proxy(const string& httpProxy);
569 string get_https_proxy() const { return httpsProxy_; }
575 void set_https_proxy(const string& httpsProxy);
576};
577
580
582
587{
589 PAHO_MQTTPP_EXPORT static const MQTTAsync_connectData DFLT_C_STRUCT;
590
592 MQTTAsync_connectData data_;
593
595 string_ref userName_;
596
598 binary_ref password_;
599
601 friend class async_client;
602
606 void update_c_struct();
607
613 connect_data(const MQTTAsync_connectData& cdata);
614
615public:
624 explicit connect_data(string_ref userName);
630 connect_data(string_ref userName, binary_ref password);
646 string get_user_name() const { return userName_ ? userName_.to_string() : string(); }
651 binary_ref get_password() const { return password_; }
656 void set_user_name(string_ref userName);
661 void set_password(binary_ref password);
662};
663
665
670{
671 connect_options opts_;
672
673public:
682 explicit connect_options_builder(int ver=MQTTVERSION_DEFAULT) : opts_(ver) {}
686 explicit connect_options_builder(const connect_options& opts) : opts_(opts) {}
690 explicit connect_options_builder(const connect_options&& opts) : opts_(std::move(opts)) {}
697 }
704 }
717 }
730 }
737 auto clean_session(bool on=true) -> self& {
738 opts_.set_clean_session(on);
739 return *this;
740 }
748 template <class Rep, class Period>
749 auto keep_alive_interval(const std::chrono::duration<Rep, Period>& interval) -> self& {
750 opts_.set_keep_alive_interval(interval);
751 return *this;
752 }
759 template <class Rep, class Period>
760 auto connect_timeout(const std::chrono::duration<Rep, Period>& timeout) -> self& {
761 opts_.set_connect_timeout(timeout);
762 return *this;
763 }
768 auto user_name(string_ref userName) -> self& {
769 opts_.set_user_name(userName);
770 return *this;
771 }
776 opts_.set_password(password);
777 return *this;
778 }
784 auto max_inflight(int n) -> self& {
785 opts_.set_max_inflight(n);
786 return *this;
787 }
792 auto will(const will_options& will) -> self& {
793 opts_.set_will(will);
794 return *this;
795 }
801 opts_.set_will(std::move(will));
802 return *this;
803 }
808 auto will(const message& msg) -> self& {
809 opts_.set_will_message(msg);
810 return *this;
811 }
818 auto ssl(const ssl_options& ssl) -> self& {
819 opts_.set_ssl(ssl);
820 return *this;
821 }
828 auto ssl(ssl_options&& ssl) -> self& {
829 opts_.set_ssl(std::move(ssl));
830 return *this;
831 }
836 auto token(const token_ptr& tok) -> self& {
837 opts_.set_token(tok);
838 return *this;
839 }
849 opts_.set_servers(serverURIs);
850 return *this;
851 }
871 auto mqtt_version(int ver) -> self& {
872 opts_.set_mqtt_version(ver);
873 return *this;
874 }
880 auto automatic_reconnect(bool on=true) -> self& {
881 opts_.set_automatic_reconnect(on);
882 return *this;
883 }
891 template <class Rep1, class Period1, class Rep2, class Period2>
892 auto automatic_reconnect(const std::chrono::duration<Rep1, Period1>& minRetryInterval,
893 const std::chrono::duration<Rep2, Period2>& maxRetryInterval) -> self& {
894 opts_.set_automatic_reconnect(minRetryInterval, maxRetryInterval);
895 return *this;
896 }
902 auto clean_start(bool on=true) -> self& {
903 opts_.set_clean_start(on);
904 return *this;
905 }
910 auto properties(const mqtt::properties& props) -> self& {
911 opts_.set_properties(props);
912 return *this;
913 }
918 auto properties(mqtt::properties&& props) -> self& {
919 opts_.set_properties(std::move(props));
920 return *this;
921 }
926 auto http_headers(const name_value_collection& headers) -> self& {
927 opts_.set_http_headers(headers);
928 return *this;
929 }
935 opts_.set_http_headers(std::move(headers));
936 return *this;
937 }
943 auto http_proxy(const string& httpProxy) -> self& {
944 opts_.set_http_proxy(httpProxy);
945 return *this;
946 }
952 auto https_proxy(const string& httpsProxy) -> self& {
953 opts_.set_https_proxy(httpsProxy);
954 return *this;
955 }
960 connect_options finalize() { return opts_; }
961};
962
964// end namespace mqtt
965}
966
967#endif // __mqtt_connect_options_h
968
Definition: async_client.h:108
const char * c_str() const
Definition: buffer_ref.h:257
const blob & to_string() const
Definition: buffer_ref.h:251
bool empty() const
Definition: buffer_ref.h:226
Definition: connect_options.h:587
connect_data(const connect_data &other)
void set_user_name(string_ref userName)
connect_data(string_ref userName, binary_ref password)
void set_password(binary_ref password)
string get_user_name() const
Definition: connect_options.h:646
connect_data & operator=(const connect_data &rhs)
connect_data(string_ref userName)
binary_ref get_password() const
Definition: connect_options.h:651
Definition: connect_options.h:670
auto clean_session(bool on=true) -> self &
Definition: connect_options.h:737
auto ssl(ssl_options &&ssl) -> self &
Definition: connect_options.h:828
auto http_proxy(const string &httpProxy) -> self &
Definition: connect_options.h:943
auto token(const token_ptr &tok) -> self &
Definition: connect_options.h:836
connect_options_builder(int ver=MQTTVERSION_DEFAULT)
Definition: connect_options.h:682
auto clean_start(bool on=true) -> self &
Definition: connect_options.h:902
auto http_headers(const name_value_collection &headers) -> self &
Definition: connect_options.h:926
auto will(const will_options &will) -> self &
Definition: connect_options.h:792
static connect_options_builder v3()
Definition: connect_options.h:695
auto properties(mqtt::properties &&props) -> self &
Definition: connect_options.h:918
auto http_headers(name_value_collection &&headers) -> self &
Definition: connect_options.h:934
auto automatic_reconnect(bool on=true) -> self &
Definition: connect_options.h:880
auto https_proxy(const string &httpsProxy) -> self &
Definition: connect_options.h:952
connect_options_builder(const connect_options &opts)
Definition: connect_options.h:686
static connect_options_builder v5()
Definition: connect_options.h:702
auto max_inflight(int n) -> self &
Definition: connect_options.h:784
auto ssl(const ssl_options &ssl) -> self &
Definition: connect_options.h:818
auto connect_timeout(const std::chrono::duration< Rep, Period > &timeout) -> self &
Definition: connect_options.h:760
auto password(binary_ref password) -> self &
Definition: connect_options.h:775
connect_options_builder(const connect_options &&opts)
Definition: connect_options.h:690
static connect_options_builder v5_ws()
Definition: connect_options.h:728
connect_options finalize()
Definition: connect_options.h:960
auto will(const message &msg) -> self &
Definition: connect_options.h:808
auto keep_alive_interval(const std::chrono::duration< Rep, Period > &interval) -> self &
Definition: connect_options.h:749
auto properties(const mqtt::properties &props) -> self &
Definition: connect_options.h:910
auto automatic_reconnect(const std::chrono::duration< Rep1, Period1 > &minRetryInterval, const std::chrono::duration< Rep2, Period2 > &maxRetryInterval) -> self &
Definition: connect_options.h:892
auto will(will_options &&will) -> self &
Definition: connect_options.h:800
static connect_options_builder ws()
Definition: connect_options.h:715
auto servers(const_string_collection_ptr serverURIs) -> self &
Definition: connect_options.h:848
auto user_name(string_ref userName) -> self &
Definition: connect_options.h:768
auto mqtt_version(int ver) -> self &
Definition: connect_options.h:871
Definition: connect_options.h:49
const will_options & get_will_options() const
Definition: connect_options.h:262
void set_clean_start(bool cleanStart)
void set_user_name(string_ref userName)
void set_properties(properties &&props)
connect_options & operator=(connect_options &&opt)
std::chrono::seconds get_connect_timeout() const
Definition: connect_options.h:218
void set_keep_alive_interval(const std::chrono::duration< Rep, Period > &interval)
Definition: connect_options.h:384
void set_http_headers(name_value_collection &&httpHeaders)
Definition: connect_options.h:550
static connect_options ws()
Definition: connect_options.h:175
void set_token(const token_ptr &tok)
connect_options & operator=(const connect_options &opt)
connect_options(connect_options &&opt)
void set_automatic_reconnect(const std::chrono::duration< Rep1, Period1 > &minRetryInterval, const std::chrono::duration< Rep2, Period2 > &maxRetryInterval)
Definition: connect_options.h:506
void set_will(will_options &&will)
void set_clean_session(bool cleanSession)
void set_connect_timeout(int timeout)
Definition: connect_options.h:394
static connect_options v5_ws()
Definition: connect_options.h:186
const name_value_collection & get_http_headers() const
Definition: connect_options.h:535
std::shared_ptr< const connect_options > const_ptr_t
Definition: connect_options.h:129
bool is_clean_session() const
Definition: connect_options.h:289
void set_properties(const properties &props)
std::chrono::seconds get_max_retry_interval() const
Definition: connect_options.h:338
binary_ref get_password() const
Definition: connect_options.h:230
connect_options(string_ref userName, binary_ref password, int ver=MQTTVERSION_DEFAULT)
const properties & get_properties() const
Definition: connect_options.h:515
void set_automatic_reconnect(bool on)
Definition: connect_options.h:487
bool get_automatic_reconnect() const
Definition: connect_options.h:324
std::chrono::seconds get_min_retry_interval() const
Definition: connect_options.h:330
string get_https_proxy() const
Definition: connect_options.h:569
string get_user_name() const
Definition: connect_options.h:225
void set_keep_alive_interval(int keepAliveInterval)
Definition: connect_options.h:373
void set_https_proxy(const string &httpsProxy)
connect_options(const connect_options &opt)
void set_max_inflight(int n)
Definition: connect_options.h:423
const_message_ptr get_will_message() const
Definition: connect_options.h:255
void set_will_message(const_message_ptr msg)
Definition: connect_options.h:445
string get_will_topic() const
Definition: connect_options.h:248
std::shared_ptr< connect_options > ptr_t
Definition: connect_options.h:127
static connect_options v3()
int get_mqtt_version() const
Definition: connect_options.h:317
void set_servers(const_string_collection_ptr serverURIs)
void set_will(const will_options &will)
int get_max_inflight() const
Definition: connect_options.h:243
connect_options(int ver=MQTTVERSION_DEFAULT)
const ssl_options & get_ssl_options() const
Definition: connect_options.h:267
void set_ssl(const ssl_options &ssl)
static connect_options v5()
string get_password_str() const
Definition: connect_options.h:235
void set_connect_timeout(const std::chrono::duration< Rep, Period > &timeout)
Definition: connect_options.h:404
properties & get_properties()
Definition: connect_options.h:520
void set_mqtt_version(int mqttVersion)
void set_automatic_reconnect(int minRetryInterval, int maxRetryInterval)
token_ptr get_token() const
Definition: connect_options.h:300
std::chrono::seconds get_keep_alive_interval() const
Definition: connect_options.h:209
void set_ssl(ssl_options &&ssl)
void set_password(binary_ref password)
string get_http_proxy() const
Definition: connect_options.h:558
void set_http_proxy(const string &httpProxy)
const_string_collection_ptr get_servers() const
Definition: connect_options.h:308
void set_http_headers(const name_value_collection &httpHeaders)
Definition: connect_options.h:542
void set_will_message(const message &msg)
Definition: connect_options.h:438
bool is_clean_start() const
Definition: connect_options.h:295
Definition: message.h:56
Definition: string_collection.h:242
bool empty() const
Definition: string_collection.h:333
const MQTTAsync_nameValue * c_arr() const
Definition: string_collection.h:368
Definition: properties.h:256
Definition: ssl_options.h:46
Definition: will_options.h:50
const_message_ptr get_message() const
Definition: will_options.h:221
string get_topic() const
Definition: will_options.h:196
#define PAHO_MQTTPP_EXPORT
Definition: export.h:40
Definition: async_client.h:49
connect_options::ptr_t connect_options_ptr
Definition: connect_options.h:579
long to_seconds_count(const std::chrono::duration< Rep, Period > &dur)
Definition: types.h:127
string_collection::const_ptr_t const_string_collection_ptr
Definition: string_collection.h:234
bool to_bool(int n)
Definition: types.h:161
token::ptr_t token_ptr
Definition: token.h:506
std::string string
Definition: types.h:40
message::const_ptr_t const_message_ptr
Definition: message.h:368
int to_int(bool b)
Definition: types.h:167