summaryrefslogtreecommitdiff
path: root/src/3rd_party-static/MessageBroker/include/mb_client.hpp
blob: cd70a31cd834e7062a97c77a95c336e9d8f257fb (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
/**
 * \file mb_client.hpp
 * \brief MessageBroker client.
 * \author AKara
 */

#ifndef MB_CLIENT_H
#define MB_CLIENT_H

#if _MSC_VER >= 1400 // VC++ 8.0
typedef int ssize_t;
#endif 

#include "networking.h"

/**
 * \namespace NsMessageBroker
 * \brief MessageBroker related functions.
 */ 
namespace NsMessageBroker
{

   /**
    * \class Client
    * \brief Abstract MessageBroker client.
    */
   class Client
   {
      public:
         /**
         * \brief Constructor.
         * \param address remote network address or FQDN to contact
         * \param port remote local port to contact
         */
         Client(const std::string& address, uint16_t port);

         /**
         * \brief Destructor.
         */
         virtual ~Client();

         /**
         * \brief Get socket descriptor.
         * \return socket descriptor.
         */
         int GetSocket() const;

         /**
         * \brief Get the address.
         * \return address or FQDN
         */
         std::string GetAddress() const;

         /**
         * \brief Get the port.
         * \return local port
         */
         uint16_t GetPort() const;

         /**
         * \brief Connect to the remote machine
         * \return true if success, false otherwise
         * \note on connectionless protocol like UDP, this function
         * always returns true even if remote peer is not reachable.
         */
         virtual bool Connect();

         /**
         * \brief Receive data from the network.
         * \param data if data is received it will put in this reference
         * \return number of bytes received or -1 if error
         * \note This method will blocked until data comes.
         */
         virtual ssize_t Recv(std::string& data) = 0;

         /**
         * \brief Close socket.
         */
         virtual void Close();

      protected:
         /**
         * \brief Socket descriptor.
         */
         int m_sock;

         /**
         * \brief Transport protocol of the socket.
         */
         enum networking::TransportProtocol m_protocol; 

         /**
         * \brief Remote socket address.
         */
         struct sockaddr_storage m_sockaddr;

         /**
         * \brief Remote socket address length.
         */
         socklen_t m_sockaddrlen;

         /**
         * \brief Protected constructor so our inherited classes
         * don't need to call the default constructor
         */
         Client();

         /**
         * \brief Protected SetAddress so out inherited classes
         * don't need to call the default constructor
         */
         void SetAddress(const std::string& address);

         /**
         * \brief Protected SetPort so out inherited classes
         * don't need to call the default constructor
         */
         void SetPort(uint16_t port);
      
      private:  
    
         /**
         * \brief Network address or FQDN.
         */
         std::string m_address;

         /**
         * \brief Local port.
         */
         uint16_t m_port;
   };

} /* namespace NsMessageBroker */

#endif /* MB_CLIENT_H */