PahoMqttCpp
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-2024 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 <chrono>
28#include <map>
29#include <vector>
30
31#include "MQTTAsync.h"
32#include "mqtt/message.h"
33#include "mqtt/platform.h"
34#include "mqtt/ssl_options.h"
36#include "mqtt/token.h"
37#include "mqtt/topic.h"
38#include "mqtt/types.h"
39#include "mqtt/will_options.h"
40
41namespace mqtt {
42
44
50{
52 static constexpr MQTTAsync_connectOptions DFLT_C_STRUCT
53 MQTTAsync_connectOptions_initializer;
54
56 static constexpr MQTTAsync_connectOptions DFLT_C_STRUCT5
57 MQTTAsync_connectOptions_initializer5;
58
60 static constexpr MQTTAsync_connectOptions DFLT_C_STRUCT_WS
61 MQTTAsync_connectOptions_initializer_ws;
62
64 static constexpr MQTTAsync_connectOptions DFLT_C_STRUCT5_WS
65 MQTTAsync_connectOptions_initializer5_ws;
66
68 MQTTAsync_connectOptions opts_;
69
71 will_options will_;
72
74 ssl_options ssl_;
75
77 string_ref userName_;
78
80 binary_ref password_;
81
83 token_ptr tok_;
84
87
89 properties props_;
90
92 name_value_collection httpHeaders_;
93
95 string httpProxy_;
96
98 string httpsProxy_;
99
101 friend class async_client;
102
113 const char* c_str(const string_ref& sr) { return sr.empty() ? nullptr : sr.c_str(); }
114 const char* c_str(const string& s) { return s.empty() ? nullptr : s.c_str(); }
118 void update_c_struct();
119
124 connect_options(const MQTTAsync_connectOptions& copts) : opts_(copts) {}
125
126public:
128 using ptr_t = std::shared_ptr<connect_options>;
130 using const_ptr_t = std::shared_ptr<const connect_options>;
131
137 explicit connect_options(int ver = MQTTVERSION_DEFAULT);
144 connect_options(string_ref userName, binary_ref password, int ver = MQTTVERSION_DEFAULT);
159 static connect_options v3() { return connect_options(DFLT_C_STRUCT); }
164 static connect_options v5() { return connect_options(DFLT_C_STRUCT5); }
173 static connect_options ws() { return connect_options(DFLT_C_STRUCT_WS); }
182 static connect_options v5_ws() { return connect_options(DFLT_C_STRUCT5_WS); }
196#if defined(UNIT_TESTS)
197 const MQTTAsync_connectOptions& c_struct() const { return opts_; }
198#endif
203 std::chrono::seconds get_keep_alive_interval() const {
204 return std::chrono::seconds(opts_.keepAliveInterval);
205 }
212 std::chrono::seconds get_connect_timeout() const {
213 return std::chrono::seconds(opts_.connectTimeout);
214 }
219 string get_user_name() const { return userName_ ? userName_.to_string() : string(); }
224 binary_ref get_password() const { return password_; }
229 string get_password_str() const { return password_ ? password_.to_string() : string(); }
235 int get_max_inflight() const { return opts_.maxInflight; }
240 string get_will_topic() const { return will_.get_topic(); }
250 const will_options& get_will_options() const { return will_; }
255 const ssl_options& get_ssl_options() const { return ssl_; }
263 void set_ssl(const ssl_options& ssl);
271 void set_ssl(ssl_options&& ssl);
277 bool is_clean_session() const { return to_bool(opts_.cleansession); }
283 bool is_clean_start() const { return to_bool(opts_.cleanstart); }
288 token_ptr get_token() const { return tok_; }
296 const_string_collection_ptr get_servers() const { return serverURIs_; }
305 int get_mqtt_version() const { return opts_.MQTTVersion; }
312 bool get_automatic_reconnect() const { return to_bool(opts_.automaticReconnect); }
318 std::chrono::seconds get_min_retry_interval() const {
319 return std::chrono::seconds(opts_.minRetryInterval);
320 }
326 std::chrono::seconds get_max_retry_interval() const {
327 return std::chrono::seconds(opts_.maxRetryInterval);
328 }
339 void set_clean_session(bool cleanSession);
353 void set_clean_start(bool cleanStart);
361 void set_keep_alive_interval(int keepAliveInterval) {
362 opts_.keepAliveInterval = keepAliveInterval;
363 }
371 template <class Rep, class Period>
372 void set_keep_alive_interval(const std::chrono::duration<Rep, Period>& interval) {
373 // TODO: Check range
375 }
382 void set_connect_timeout(int timeout) { opts_.connectTimeout = timeout; }
389 template <class Rep, class Period>
390 void set_connect_timeout(const std::chrono::duration<Rep, Period>& timeout) {
391 // TODO: check range
393 }
398 void set_user_name(string_ref userName);
403 void set_password(binary_ref password);
409 void set_max_inflight(int n) { opts_.maxInflight = n; }
414 void set_will(const will_options& will);
419 void set_will(will_options&& will);
424 void set_will_message(const message& msg) { set_will(will_options(msg)); }
430 if (msg)
431 set_will(will_options(*msg));
432 }
437 void set_token(const token_ptr& tok);
466 void set_mqtt_version(int mqttVersion);
472 void set_automatic_reconnect(bool on) { opts_.automaticReconnect = to_int(on); }
480 void set_automatic_reconnect(int minRetryInterval, int maxRetryInterval);
488 template <class Rep1, class Period1, class Rep2, class Period2>
490 const std::chrono::duration<Rep1, Period1>& minRetryInterval,
491 const std::chrono::duration<Rep2, Period2>& maxRetryInterval
492 ) {
494 (int)to_seconds_count(minRetryInterval), (int)to_seconds_count(maxRetryInterval)
495 );
496 }
501 const properties& get_properties() const { return props_; }
506 properties& get_properties() { return props_; }
511 void set_properties(const properties& props);
521 const name_value_collection& get_http_headers() const { return httpHeaders_; }
526 void set_http_headers(const name_value_collection& httpHeaders) {
527 httpHeaders_ = httpHeaders;
528 opts_.httpHeaders = httpHeaders_.empty() ? nullptr : httpHeaders_.c_arr();
529 }
535 httpHeaders_ = std::move(httpHeaders);
536 opts_.httpHeaders = httpHeaders_.empty() ? nullptr : httpHeaders_.c_arr();
537 }
542 string get_http_proxy() const { return httpProxy_; }
548 void set_http_proxy(const string& httpProxy);
553 string get_https_proxy() const { return httpsProxy_; }
559 void set_https_proxy(const string& httpsProxy);
560};
561
564
566
571{
573 PAHO_MQTTPP_EXPORT static constexpr MQTTAsync_connectData DFLT_C_STRUCT
574 MQTTAsync_connectData_initializer;
575
577 MQTTAsync_connectData data_{DFLT_C_STRUCT};
578
580 string_ref userName_;
581
583 binary_ref password_;
584
586 friend class async_client;
587
591 void update_c_struct();
592
598 connect_data(const MQTTAsync_connectData& cdata);
599
600public:
609 explicit connect_data(string_ref userName);
615 connect_data(string_ref userName, binary_ref password);
631 string get_user_name() const { return userName_ ? userName_.to_string() : string(); }
636 binary_ref get_password() const { return password_; }
641 void set_user_name(string_ref userName);
646 void set_password(binary_ref password);
647};
648
650
655{
656 connect_options opts_;
657
658public:
667 explicit connect_options_builder(int ver = MQTTVERSION_DEFAULT) : opts_(ver) {}
671 explicit connect_options_builder(const connect_options& opts) : opts_(opts) {}
675 explicit connect_options_builder(const connect_options&& opts) : opts_(std::move(opts)) {}
722 auto clean_session(bool on = true) -> self& {
723 opts_.set_clean_session(on);
724 return *this;
725 }
733 template <class Rep, class Period>
734 auto keep_alive_interval(const std::chrono::duration<Rep, Period>& interval) -> self& {
735 opts_.set_keep_alive_interval(interval);
736 return *this;
737 }
744 template <class Rep, class Period>
745 auto connect_timeout(const std::chrono::duration<Rep, Period>& timeout) -> self& {
746 opts_.set_connect_timeout(timeout);
747 return *this;
748 }
753 auto user_name(string_ref userName) -> self& {
754 opts_.set_user_name(userName);
755 return *this;
756 }
762 opts_.set_password(password);
763 return *this;
764 }
770 auto max_inflight(int n) -> self& {
771 opts_.set_max_inflight(n);
772 return *this;
773 }
778 auto will(const will_options& will) -> self& {
779 opts_.set_will(will);
780 return *this;
781 }
787 opts_.set_will(std::move(will));
788 return *this;
789 }
794 auto will(const message& msg) -> self& {
795 opts_.set_will_message(msg);
796 return *this;
797 }
804 auto ssl(const ssl_options& ssl) -> self& {
805 opts_.set_ssl(ssl);
806 return *this;
807 }
814 auto ssl(ssl_options&& ssl) -> self& {
815 opts_.set_ssl(std::move(ssl));
816 return *this;
817 }
822 auto token(const token_ptr& tok) -> self& {
823 opts_.set_token(tok);
824 return *this;
825 }
835 opts_.set_servers(serverURIs);
836 return *this;
837 }
857 auto mqtt_version(int ver) -> self& {
858 opts_.set_mqtt_version(ver);
859 return *this;
860 }
866 auto automatic_reconnect(bool on = true) -> self& {
867 opts_.set_automatic_reconnect(on);
868 return *this;
869 }
877 template <class Rep1, class Period1, class Rep2, class Period2>
879 const std::chrono::duration<Rep1, Period1>& minRetryInterval,
880 const std::chrono::duration<Rep2, Period2>& maxRetryInterval
881 ) -> self& {
882 opts_.set_automatic_reconnect(minRetryInterval, maxRetryInterval);
883 return *this;
884 }
890 auto clean_start(bool on = true) -> self& {
891 opts_.set_clean_start(on);
892 return *this;
893 }
898 auto properties(const mqtt::properties& props) -> self& {
899 opts_.set_properties(props);
900 return *this;
901 }
906 auto properties(mqtt::properties&& props) -> self& {
907 opts_.set_properties(std::move(props));
908 return *this;
909 }
914 auto http_headers(const name_value_collection& headers) -> self& {
915 opts_.set_http_headers(headers);
916 return *this;
917 }
923 opts_.set_http_headers(std::move(headers));
924 return *this;
925 }
931 auto http_proxy(const string& httpProxy) -> self& {
932 opts_.set_http_proxy(httpProxy);
933 return *this;
934 }
940 auto https_proxy(const string& httpsProxy) -> self& {
941 opts_.set_https_proxy(httpsProxy);
942 return *this;
943 }
948 connect_options finalize() { return opts_; }
949};
950
952} // namespace mqtt
953
954#endif // __mqtt_connect_options_h
Definition async_client.h:137
const char * c_str() const
Definition buffer_ref.h:264
const blob & to_string() const
Definition buffer_ref.h:258
bool empty() const
Definition buffer_ref.h:233
Definition connect_options.h:571
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:631
connect_data & operator=(const connect_data &rhs)
connect_data(string_ref userName)
binary_ref get_password() const
Definition connect_options.h:636
Definition connect_options.h:655
auto clean_session(bool on=true) -> self &
Definition connect_options.h:722
auto ssl(ssl_options &&ssl) -> self &
Definition connect_options.h:814
auto http_proxy(const string &httpProxy) -> self &
Definition connect_options.h:931
auto token(const token_ptr &tok) -> self &
Definition connect_options.h:822
connect_options_builder(int ver=MQTTVERSION_DEFAULT)
Definition connect_options.h:667
auto clean_start(bool on=true) -> self &
Definition connect_options.h:890
auto http_headers(const name_value_collection &headers) -> self &
Definition connect_options.h:914
auto will(const will_options &will) -> self &
Definition connect_options.h:778
static connect_options_builder v3()
Definition connect_options.h:680
auto properties(mqtt::properties &&props) -> self &
Definition connect_options.h:906
auto http_headers(name_value_collection &&headers) -> self &
Definition connect_options.h:922
auto automatic_reconnect(bool on=true) -> self &
Definition connect_options.h:866
auto https_proxy(const string &httpsProxy) -> self &
Definition connect_options.h:940
connect_options_builder(const connect_options &opts)
Definition connect_options.h:671
static connect_options_builder v5()
Definition connect_options.h:687
auto max_inflight(int n) -> self &
Definition connect_options.h:770
auto ssl(const ssl_options &ssl) -> self &
Definition connect_options.h:804
auto connect_timeout(const std::chrono::duration< Rep, Period > &timeout) -> self &
Definition connect_options.h:745
auto password(binary_ref password) -> self &
Definition connect_options.h:761
connect_options_builder(const connect_options &&opts)
Definition connect_options.h:675
static connect_options_builder v5_ws()
Definition connect_options.h:713
connect_options finalize()
Definition connect_options.h:948
auto will(const message &msg) -> self &
Definition connect_options.h:794
auto keep_alive_interval(const std::chrono::duration< Rep, Period > &interval) -> self &
Definition connect_options.h:734
auto properties(const mqtt::properties &props) -> self &
Definition connect_options.h:898
auto automatic_reconnect(const std::chrono::duration< Rep1, Period1 > &minRetryInterval, const std::chrono::duration< Rep2, Period2 > &maxRetryInterval) -> self &
Definition connect_options.h:878
auto will(will_options &&will) -> self &
Definition connect_options.h:786
static connect_options_builder ws()
Definition connect_options.h:700
auto servers(const_string_collection_ptr serverURIs) -> self &
Definition connect_options.h:834
auto user_name(string_ref userName) -> self &
Definition connect_options.h:753
auto mqtt_version(int ver) -> self &
Definition connect_options.h:857
Definition connect_options.h:50
const will_options & get_will_options() const
Definition connect_options.h:250
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:212
void set_keep_alive_interval(const std::chrono::duration< Rep, Period > &interval)
Definition connect_options.h:372
void set_http_headers(name_value_collection &&httpHeaders)
Definition connect_options.h:534
static connect_options ws()
Definition connect_options.h:173
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:489
void set_will(will_options &&will)
void set_clean_session(bool cleanSession)
void set_connect_timeout(int timeout)
Definition connect_options.h:382
static connect_options v5_ws()
Definition connect_options.h:182
const name_value_collection & get_http_headers() const
Definition connect_options.h:521
std::shared_ptr< const connect_options > const_ptr_t
Definition connect_options.h:130
bool is_clean_session() const
Definition connect_options.h:277
void set_properties(const properties &props)
std::chrono::seconds get_max_retry_interval() const
Definition connect_options.h:326
binary_ref get_password() const
Definition connect_options.h:224
connect_options(string_ref userName, binary_ref password, int ver=MQTTVERSION_DEFAULT)
const properties & get_properties() const
Definition connect_options.h:501
void set_automatic_reconnect(bool on)
Definition connect_options.h:472
bool get_automatic_reconnect() const
Definition connect_options.h:312
std::chrono::seconds get_min_retry_interval() const
Definition connect_options.h:318
string get_https_proxy() const
Definition connect_options.h:553
string get_user_name() const
Definition connect_options.h:219
void set_keep_alive_interval(int keepAliveInterval)
Definition connect_options.h:361
void set_https_proxy(const string &httpsProxy)
connect_options(const connect_options &opt)
void set_max_inflight(int n)
Definition connect_options.h:409
const_message_ptr get_will_message() const
Definition connect_options.h:245
void set_will_message(const_message_ptr msg)
Definition connect_options.h:429
string get_will_topic() const
Definition connect_options.h:240
std::shared_ptr< connect_options > ptr_t
Definition connect_options.h:128
static connect_options v3()
Definition connect_options.h:159
int get_mqtt_version() const
Definition connect_options.h:305
void set_servers(const_string_collection_ptr serverURIs)
void set_will(const will_options &will)
int get_max_inflight() const
Definition connect_options.h:235
connect_options(int ver=MQTTVERSION_DEFAULT)
const ssl_options & get_ssl_options() const
Definition connect_options.h:255
void set_ssl(const ssl_options &ssl)
static connect_options v5()
Definition connect_options.h:164
string get_password_str() const
Definition connect_options.h:229
void set_connect_timeout(const std::chrono::duration< Rep, Period > &timeout)
Definition connect_options.h:390
properties & get_properties()
Definition connect_options.h:506
void set_mqtt_version(int mqttVersion)
void set_automatic_reconnect(int minRetryInterval, int maxRetryInterval)
token_ptr get_token() const
Definition connect_options.h:288
std::chrono::seconds get_keep_alive_interval() const
Definition connect_options.h:203
void set_ssl(ssl_options &&ssl)
void set_password(binary_ref password)
string get_http_proxy() const
Definition connect_options.h:542
void set_http_proxy(const string &httpProxy)
const_string_collection_ptr get_servers() const
Definition connect_options.h:296
void set_http_headers(const name_value_collection &httpHeaders)
Definition connect_options.h:526
void set_will_message(const message &msg)
Definition connect_options.h:424
bool is_clean_start() const
Definition connect_options.h:283
Definition message.h:57
Definition string_collection.h:267
bool empty() const
Definition string_collection.h:352
const MQTTAsync_nameValue * c_arr() const
Definition string_collection.h:387
Definition properties.h:293
Definition ssl_options.h:47
Definition will_options.h:50
const_message_ptr get_message() const
Definition will_options.h:223
string get_topic() const
Definition will_options.h:198
#define PAHO_MQTTPP_EXPORT
Definition export.h:40
Definition async_client.h:60
connect_options::ptr_t connect_options_ptr
Definition connect_options.h:563
long to_seconds_count(const std::chrono::duration< Rep, Period > &dur)
Definition types.h:73
string_collection::const_ptr_t const_string_collection_ptr
Definition string_collection.h:259
bool to_bool(int n)
Definition types.h:107
token::ptr_t token_ptr
Definition token.h:513
std::string string
Definition types.h:43
message::const_ptr_t const_message_ptr
Definition message.h:372
int to_int(bool b)
Definition types.h:113