fork download
copy 
  1. #include <iostream>
  2. #include <map>
  3. #include <functional>
  4. #include <memory>
  5.  
  6. using namespace std;
  7. using namespace std::placeholders;
  8.  
  9. #define REGISTER_CONNECTOR(map, connector, id) \
  10. { \
  11. 	ConnectorFunc connectorFunc = {}; \
  12. 	connectorFunc.openFunc = std::bind(&decltype(connector)::open, connector); \
  13. 	connectorFunc.recvFunc = std::bind(&decltype(connector)::recv, connector, _1, _2); \
  14. 	connectorFunc.sendFunc = std::bind(&decltype(connector)::send, connector, _1, _2); \
  15. 	connectorFunc.closeFunc = std::bind(&decltype(connector)::close, connector); \
  16. 	map.insert(std::make_pair(id, connectorFunc)); \
  17. }
  18.  
  19. #define GET_CONNECTOR_FUNC(map, id, connectorFunc)  \
  20. { \
  21. 	auto iter = funcMap.find(type); \
  22. 	if(iter != funcMap.end()) \
  23. 	{ \
  24. 		connectorFunc = iter->second; \
  25. 	} \
  26. }
  27.  
  28. typedef void (OPEN_FUNC)();
  29. typedef size_t (RECV_FUNC)(void*, size_t);
  30. typedef void (SEND_FUNC)(void*, size_t);
  31. typedef void (CLOSE_FUNC)();
  32.  
  33. struct ConnectorFunc
  34. {
  35. 	std::function<OPEN_FUNC> openFunc;
  36. 	std::function<RECV_FUNC> recvFunc;
  37. 	std::function<SEND_FUNC> sendFunc;
  38. 	std::function<CLOSE_FUNC> closeFunc;
  39. };
  40.  
  41. typedef enum { TCP, SERIAL, CONNECT_COUNT} CONNECT_TYPE;
  42.  
  43. // Define interface
  44. class IConnector
  45. {
  46. public:
  47. 	virtual void open() = 0;
  48. 	virtual size_t recv(void* buffer, size_t size) = 0;
  49. 	virtual void send(void* buffer, size_t size) = 0;
  50. 	virtual void close() = 0;
  51. };
  52.  
  53. // Define CSerial
  54. class CSerial	/*: public IConnector*/ // From 3rd?
  55. {
  56. public:
  57. 	void open();
  58. 	size_t recv(void* buffer, size_t size);
  59. 	void send(void* buffer, size_t size);
  60. 	void close();
  61. };
  62.  
  63. // Define CTcp
  64. class CTcp	   /*: public IConnector*/ // From 3rd?
  65. {
  66. public:
  67. 	void open();
  68. 	size_t recv(void* buffer, size_t size);
  69. 	void send(void* buffer, size_t size);
  70. 	void close();
  71. };
  72.  
  73. // Define CConnector
  74. class CConnector: public IConnector
  75. {
  76. public:
  77. 	CConnector();
  78. 	void open();
  79. 	size_t recv(void* buffer, size_t size);
  80. 	void send(void* buffer, size_t size);
  81. 	void close();
  82. 	void setType(CONNECT_TYPE type);
  83.  
  84. private:
  85. 	CONNECT_TYPE mType;
  86. 	CTcp mTcp;
  87. 	CSerial mSerial;
  88. 	std::map<CONNECT_TYPE, ConnectorFunc> funcMap;
  89. 	ConnectorFunc connectorFunc;
  90. };
  91.  
  92. // Implement CSerial
  93. void CSerial::open()
  94. {
  95. 	cout <<	"CSerial::" <<  __func__ << endl;
  96. }
  97.  
  98. size_t CSerial::recv(void* buffer, size_t size)
  99. {
  100. 	cout << "CSerial::" << __func__ << endl;
  101. 	return 0;
  102. }
  103.  
  104. void CSerial::send(void* buffer, size_t size)
  105. {
  106. 	cout << "CSerial::" << __func__ << endl;
  107. }
  108.  
  109. void CSerial::close()
  110. {
  111. 	cout << "CSerial::" << __func__ << endl;
  112. }
  113.  
  114. // Implement CTcp
  115. void CTcp::open()
  116. {
  117. 	cout << "CTcp::" <<  __func__ << endl;
  118. }
  119.  
  120. size_t CTcp::recv(void* buffer, size_t size)
  121. {
  122. 	cout << "CTcp::" << __func__ << endl;
  123. 	return 0;
  124. }
  125.  
  126. void CTcp::send(void* buffer, size_t size)
  127. {
  128. 	cout << "CTcp::" << __func__ << endl;
  129. }
  130.  
  131. void CTcp::close()
  132. {
  133. 	cout << "CTcp::" << __func__ << endl;
  134. }
  135.  
  136. // Implement CConnector
  137. CConnector::CConnector(): mType(CONNECT_TYPE::TCP), mTcp(), mSerial(), connectorFunc()
  138. {
  139. 	REGISTER_CONNECTOR(funcMap, mTcp, CONNECT_TYPE::TCP);
  140. 	REGISTER_CONNECTOR(funcMap, mSerial, CONNECT_TYPE::SERIAL);
  141. }
  142.  
  143. void CConnector::open()
  144. {
  145. 	if(connectorFunc.openFunc != NULL)
  146. 		connectorFunc.openFunc();
  147. }
  148.  
  149. size_t CConnector::recv(void* buffer, size_t size)
  150. {
  151. 	if(connectorFunc.recvFunc != NULL)
  152. 		return connectorFunc.recvFunc(buffer, size);
  153. 	return -1;
  154. }
  155.  
  156. void CConnector::send(void* buffer, size_t size)
  157. {
  158. 	if(connectorFunc.sendFunc != NULL)
  159. 		connectorFunc.sendFunc(buffer, size);
  160. }
  161.  
  162. void CConnector::close()
  163. {
  164. 	if(connectorFunc.closeFunc != NULL)
  165. 		connectorFunc.closeFunc();
  166. }
  167.  
  168. void CConnector::setType(CONNECT_TYPE type)
  169. {
  170. 	mType = type;
  171. 	GET_CONNECTOR_FUNC(funcMap, type, connectorFunc);
  172. }
  173.  
  174. void testTCP()
  175. {
  176. 	CConnector* conector = new CConnector();
  177. 	conector->setType(CONNECT_TYPE::TCP);
  178. 	conector->open();
  179. 	conector->recv(NULL, 0);
  180. 	conector->send(NULL, 0);
  181. 	conector->close();
  182. 	delete conector;
  183. 	cout << endl;
  184. }
  185.  
  186. void testSerial()
  187. {
  188. 	CConnector* conector = new CConnector();
  189. 	conector->setType(CONNECT_TYPE::SERIAL);
  190. 	conector->open();
  191. 	conector->recv(NULL, 0);
  192. 	conector->send(NULL, 0);
  193. 	conector->close();
  194. 	delete conector;
  195. 	cout << endl;
  196. }
  197.  
  198. int main(int argc, char* argv[])
  199. {
  200. 	testTCP();
  201. 	testSerial();
  202.  
  203. 	return 0;
  204. }
Success #stdin #stdout 0s 3240KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
CTcp::open
CTcp::recv
CTcp::send
CTcp::close

CSerial::open
CSerial::recv
CSerial::send
CSerial::close
https://ideone.com/zZtcvk
language:
C++14 (gcc 8.3)
created:
10 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!