DataArrayTcpClient.h

/*
Copyright (c) 2026 Alexandr Kuzmuk
 
This file is part of the AsyncFw project. Licensed under the MIT License.
See {Link: LICENSE file https://mit-license.org} in the project root for full license information.
*/
 
#pragma once
 
#include "DataArrayAbstractTcp.h"
 
namespace AsyncFw {
class DataArrayTcpClient : public DataArrayAbstractTcp {
protected:
  class Thread : public DataArrayAbstractTcp::Thread {
    friend class DataArrayTcpClient;
 
  public:
    inline DataArrayTcpClient *client() { return static_cast<DataArrayTcpClient *>(pool); }
 
  private:
    using DataArrayAbstractTcp::Thread::Thread;
    ~Thread() override;
    DataArraySocket *createSocket();
  };
  virtual void socketStateChanged(const DataArraySocket *);
 
public:
  enum Result { ErrorExchangeNotActive = -103, ErrorExchangeTransmit = -104, ErrorExchangeConnectionClose = -105, ErrorExchangeTimeout = -106, ErrorExchangeThread = -107 };
  DataArrayTcpClient(const std::string & = "TcpClient");
  void connectToHost(DataArraySocket *socket, const std::string &, uint16_t, int = 0);
  void connectToHost(const DataArraySocket *, int = 0);
  Thread *createThread();
  DataArraySocket *createSocket(Thread *thread = nullptr);
  void removeSocket(DataArraySocket *);
  FunctionConnectorProtected<DataArrayTcpClient>::Connector<const DataArraySocket *> connectionStateChanged {AbstractFunctionConnector::DirectOnly};
  int exchange(const DataArraySocket *, const DataArray &, const DataArray *, uint32_t, int = 5000);
  std::size_t socketLimit() { return maxSockets; }
  int connectTimeout() const { return waitForConnectTimeoutInterval; }
  void setConnectTimeout(int timeout) { waitForConnectTimeoutInterval = timeout; }
  int reconnectTimeout() const { return reconnectTimeoutInterval; }
  void setReconnectTimeout(int timeout) { reconnectTimeoutInterval = timeout; }
 
private:
  int waitForConnectTimeoutInterval = 10000;
  int reconnectTimeoutInterval = 10000;
};
}  // namespace AsyncFw