paho-mqtt-cpp
MQTT C++ Client for POSIX and Windows
connect_options.h
Go to the documentation of this file.
1 
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"
32 #include "mqtt/string_collection.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 
40 namespace 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 
81  const_string_collection_ptr serverURIs_;
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 
125 public:
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  );
151  connect_options(const connect_options& opt);
161  static connect_options v3();
166  static connect_options v5();
175  static connect_options ws() {
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
205 
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
386  set_keep_alive_interval((int) to_seconds_count(interval));
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
406  set_connect_timeout((int) to_seconds_count(timeout));
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) {
439  set_will(will_options(msg));
440  }
446  if (msg) set_will(will_options(*msg));
447  }
452  void set_token(const token_ptr& tok);
461  void set_servers(const_string_collection_ptr serverURIs);
481  void set_mqtt_version(int mqttVersion);
487  void set_automatic_reconnect(bool on) {
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);
530  void set_properties(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 
615 public:
619  connect_data();
624  explicit connect_data(string_ref userName);
630  connect_data(string_ref userName, binary_ref password);
635  connect_data(const connect_data& other);
641  connect_data& operator=(const connect_data& rhs);
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 
673 public:
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  }
775  auto password(binary_ref password) -> self& {
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  }
800  auto will(will_options&& will) -> self& {
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  }
848  auto servers(const_string_collection_ptr serverURIs) -> self& {
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  }
934  auto http_headers(name_value_collection&& headers) -> self& {
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 
auto ssl(const ssl_options &ssl) -> self &
Definition: connect_options.h:818
message::const_ptr_t const_message_ptr
Definition: message.h:368
bool get_automatic_reconnect() const
Definition: connect_options.h:324
string get_will_topic() const
Definition: connect_options.h:248
const will_options & get_will_options() const
Definition: connect_options.h:262
auto servers(const_string_collection_ptr serverURIs) -> self &
Definition: connect_options.h:848
Definition: async_client.h:107
auto will(const will_options &will) -> self &
Definition: connect_options.h:792
std::shared_ptr< connect_options > ptr_t
Definition: connect_options.h:127
void set_clean_session(bool cleanSession)
void set_http_headers(name_value_collection &&httpHeaders)
Definition: connect_options.h:550
connect_options_builder(const connect_options &opts)
Definition: connect_options.h:686
string get_user_name() const
Definition: connect_options.h:225
void set_max_inflight(int n)
Definition: connect_options.h:423
static connect_options_builder v5_ws()
Definition: connect_options.h:728
bool to_bool(int n)
Definition: types.h:161
auto http_headers(name_value_collection &&headers) -> self &
Definition: connect_options.h:934
std::string string
Definition: types.h:40
auto properties(const mqtt::properties &props) -> self &
Definition: connect_options.h:910
void set_connect_timeout(int timeout)
Definition: connect_options.h:394
const properties & get_properties() const
Definition: connect_options.h:515
Definition: ssl_options.h:45
binary_ref get_password() const
Definition: connect_options.h:651
std::chrono::seconds get_keep_alive_interval() const
Definition: connect_options.h:209
auto will(will_options &&will) -> self &
Definition: connect_options.h:800
binary_ref get_password() const
Definition: connect_options.h:230
int get_max_inflight() const
Definition: connect_options.h:243
const_message_ptr get_will_message() const
Definition: connect_options.h:255
void set_password(binary_ref password)
auto automatic_reconnect(const std::chrono::duration< Rep1, Period1 > &minRetryInterval, const std::chrono::duration< Rep2, Period2 > &maxRetryInterval) -> self &
Definition: connect_options.h:892
void set_clean_start(bool cleanStart)
string get_topic() const
Definition: will_options.h:196
string_collection::const_ptr_t const_string_collection_ptr
Definition: string_collection.h:234
bool is_clean_start() const
Definition: connect_options.h:295
void set_http_proxy(const string &httpProxy)
void set_http_headers(const name_value_collection &httpHeaders)
Definition: connect_options.h:542
static connect_options_builder v5()
Definition: connect_options.h:702
void set_keep_alive_interval(int keepAliveInterval)
Definition: connect_options.h:373
std::shared_ptr< const connect_options > const_ptr_t
Definition: connect_options.h:129
const blob & to_string() const
Definition: buffer_ref.h:251
properties & get_properties()
Definition: connect_options.h:520
Definition: connect_options.h:48
connect_options & operator=(const connect_options &opt)
const MQTTAsync_nameValue * c_arr() const
Definition: string_collection.h:368
auto http_headers(const name_value_collection &headers) -> self &
Definition: connect_options.h:926
void set_servers(const_string_collection_ptr serverURIs)
connect_options finalize()
Definition: connect_options.h:960
const name_value_collection & get_http_headers() const
Definition: connect_options.h:535
auto connect_timeout(const std::chrono::duration< Rep, Period > &timeout) -> self &
Definition: connect_options.h:760
int get_mqtt_version() const
Definition: connect_options.h:317
bool is_clean_session() const
Definition: connect_options.h:289
std::chrono::seconds get_connect_timeout() const
Definition: connect_options.h:218
auto max_inflight(int n) -> self &
Definition: connect_options.h:784
connect_options_builder(int ver=MQTTVERSION_DEFAULT)
Definition: connect_options.h:682
static connect_options v5_ws()
Definition: connect_options.h:186
static connect_options v5()
const_message_ptr get_message() const
Definition: will_options.h:221
void set_token(const token_ptr &tok)
Definition: properties.h:255
auto https_proxy(const string &httpsProxy) -> self &
Definition: connect_options.h:952
void set_mqtt_version(int mqttVersion)
std::chrono::seconds get_min_retry_interval() const
Definition: connect_options.h:330
token_ptr get_token() const
Definition: connect_options.h:300
static connect_options_builder v3()
Definition: connect_options.h:695
auto properties(mqtt::properties &&props) -> self &
Definition: connect_options.h:918
void set_automatic_reconnect(const std::chrono::duration< Rep1, Period1 > &minRetryInterval, const std::chrono::duration< Rep2, Period2 > &maxRetryInterval)
Definition: connect_options.h:506
Definition: message.h:55
void set_ssl(const ssl_options &ssl)
auto password(binary_ref password) -> self &
Definition: connect_options.h:775
void set_will_message(const message &msg)
Definition: connect_options.h:438
token::ptr_t token_ptr
Definition: token.h:506
auto token(const token_ptr &tok) -> self &
Definition: connect_options.h:836
static connect_options v3()
bool empty() const
Definition: buffer_ref.h:226
auto ssl(ssl_options &&ssl) -> self &
Definition: connect_options.h:828
void set_automatic_reconnect(bool on)
Definition: connect_options.h:487
auto user_name(string_ref userName) -> self &
Definition: connect_options.h:768
string get_user_name() const
Definition: connect_options.h:646
auto will(const message &msg) -> self &
Definition: connect_options.h:808
#define PAHO_MQTTPP_EXPORT
Definition: export.h:40
void set_password(binary_ref password)
void set_will_message(const_message_ptr msg)
Definition: connect_options.h:445
void set_will(const will_options &will)
void set_user_name(string_ref userName)
static connect_options_builder ws()
Definition: connect_options.h:715
void set_user_name(string_ref userName)
auto clean_start(bool on=true) -> self &
Definition: connect_options.h:902
Definition: connect_options.h:669
string get_http_proxy() const
Definition: connect_options.h:558
long to_seconds_count(const std::chrono::duration< Rep, Period > &dur)
Definition: types.h:127
Definition: connect_options.h:586
connect_data & operator=(const connect_data &rhs)
int to_int(bool b)
Definition: types.h:167
string get_https_proxy() const
Definition: connect_options.h:569
const char * c_str() const
Definition: buffer_ref.h:257
const ssl_options & get_ssl_options() const
Definition: connect_options.h:267
Definition: async_client.h:49
static connect_options ws()
Definition: connect_options.h:175
void set_https_proxy(const string &httpsProxy)
auto mqtt_version(int ver) -> self &
Definition: connect_options.h:871
auto keep_alive_interval(const std::chrono::duration< Rep, Period > &interval) -> self &
Definition: connect_options.h:749
void set_connect_timeout(const std::chrono::duration< Rep, Period > &timeout)
Definition: connect_options.h:404
bool empty() const
Definition: string_collection.h:333
connect_options::ptr_t connect_options_ptr
Definition: connect_options.h:579
const_string_collection_ptr get_servers() const
Definition: connect_options.h:308
connect_options_builder(const connect_options &&opts)
Definition: connect_options.h:690
string get_password_str() const
Definition: connect_options.h:235
auto http_proxy(const string &httpProxy) -> self &
Definition: connect_options.h:943
void set_keep_alive_interval(const std::chrono::duration< Rep, Period > &interval)
Definition: connect_options.h:384
void set_properties(const properties &props)
auto automatic_reconnect(bool on=true) -> self &
Definition: connect_options.h:880
auto clean_session(bool on=true) -> self &
Definition: connect_options.h:737
Definition: will_options.h:49
std::chrono::seconds get_max_retry_interval() const
Definition: connect_options.h:338
Definition: string_collection.h:241