TCPServer.h

Go to the documentation of this file.

// g++ -Wall -g -I/usr/local/boost_1_53_0 -c data/TCPServer.cpp -o data/TCPServer.o
//
// First implementation come from tutorial boost. TCP server async.\n

// Not so easy to run and stop the server in the same thread
// Should use some loop to check at some internal bool variable (is_running for instance)
// certainly condition variable
// http://en.cppreference.com/w/cpp/thread/condition_variable
// something like in this example
// http://www.cplusplus.com/forum/general/87747


#ifndef TCPSERVER_H_
#define TCPSERVER_H_

#include <string>

// from the example, need perror (not used now)
//#include <stdio.h>
//#include <stdlib.h>
//#include <ctime>

#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/asio.hpp>
#include <boost/thread/thread.hpp>

//c++11 thread
#include <thread>
#include <mutex>
#include <condition_variable>

using boost::asio::ip::tcp;

class StockManager;


class tcp_connection
  : public boost::enable_shared_from_this<tcp_connection>
{
public:
  typedef boost::shared_ptr<tcp_connection> pointer;

  virtual ~tcp_connection() {
#ifdef DEBUG_CPP
          std::cout << "Call public destructor tcp_connection " << std::endl;
#endif
}
  static pointer create(boost::asio::io_service& io_service);
  tcp::socket& socket() { return socket_; }

  // to modify for my purpose, in RealTime case, nothing to send back ! or just ok, no error !
  void start();

  tcp::socket& GetSocket() {return socket_;}


private:
  tcp_connection(boost::asio::io_service& io_service)
    : socket_(io_service) {
#ifdef DEBUG_CPP
    std::cout << "Call private constructor tcp_connection " << std::endl;
#endif
  }
  void handle_write(const boost::system::error_code& error,
                    size_t bytes_transferred);

  tcp::socket socket_;
  std::string message_;
};

class TCPServer {

  public :
        TCPServer ( StockManager *sm, unsigned int iport );

    TCPServer ( StockManager *sm, unsigned int iport, boost::asio::io_service& io_service );
    virtual ~TCPServer();
    
   //{@
   void StartServer();
   // trick to not have the TCP recreating when deleting
   // connection is still alive : 1- check is running, 2- delete connection
   void StopServer();
   bool IsRunning() {return is_running;}

   // need to store error in connection and other
   // a global error message not bad... to send to StockManager
   // see c++ book exception and threads
   /*
    void error(const char *msg) {
        perror(msg);
        exit(0);
    }
    */

  private:

    void start_accept();
    void handle_accept(tcp_connection::pointer new_connection,
                       const boost::system::error_code& error);
    void LoopThread();


    StockManager *f_sm;
    unsigned int port;
    // seems important to be declared and created before acceptor_
    boost::asio::io_service my_io_service;
    // example acceptor contains io_service ?? for async call ?
    // seems important to be declared in initializer list. Or I never found the correct syntax...
    tcp::acceptor acceptor_;
        bool is_running;
        bool want_exit;

    std::thread t_;
    // try to own and delete the connection, not promising
    //tcp_connection::pointer _connection;
    std::mutex loop_mutex;
    std::condition_variable loop_cv;
};

#endif /* TCPSERVER_H_ */