tcp_socket.h

Go to the documentation of this file.

/*
 * Copyright 2019, FZI Forschungszentrum Informatik (refactor)
 *
 * Copyright 2017, 2018 Simon Rasmussen (refactor)
 *
 * Copyright 2015, 2016 Thomas Timm Andersen (original version)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
#include <atomic>
#include <chrono>
#include <mutex>
#include <string>
#include <memory>
 
#include "ur_client_library/comm/socket_t.h"
 
namespace urcl
{
namespace comm
{
enum class SocketState
{
  Invalid,       
  Connected,     
  Disconnected,  
  Closed         
};
 
class TCPSocket
{
private:
  std::atomic<socket_t> socket_fd_;
  std::atomic<SocketState> state_;
  std::chrono::milliseconds reconnection_time_;
  bool reconnection_time_modified_deprecated_ = false;
 
  void setupOptions();
 
protected:
  static bool open(socket_t socket_fd, struct sockaddr* address, size_t address_len)
  {
    return ::connect(socket_fd, address, static_cast<socklen_t>(address_len)) == 0;
  }
 
  bool setup(const std::string& host, const int port, const size_t max_num_tries = 0,
             const std::chrono::milliseconds reconnection_time = DEFAULT_RECONNECTION_TIME);
 
  std::unique_ptr<timeval> recv_timeout_;
 
public:
  static constexpr std::chrono::milliseconds DEFAULT_RECONNECTION_TIME{ 10000 };
  TCPSocket();
  virtual ~TCPSocket();
 
  SocketState getState()
  {
    return state_;
  }
 
  socket_t getSocketFD()
  {
    return socket_fd_;
  }
 
  std::string getIP() const;
 
  bool read(char* character);
 
  bool read(uint8_t* buf, const size_t buf_len, size_t& read);
 
  bool write(const uint8_t* buf, const size_t buf_len, size_t& written);
 
  void close();
 
  void setReceiveTimeout(const timeval& timeout);
 
  [[deprecated("Reconnection time is passed to setup directly now.")]] void
  setReconnectionTime(const std::chrono::milliseconds reconnection_time);
};
}  // namespace comm
}  // namespace urcl