SerialNeutronExchanger.hh

/*
 * $Id:$
 */

#if !defined(SERIALNEUTRONEXCHANGER)
#define SERIALNEUTRONEXCHANGER


#include <iostream>
#include <string>
#include <vector>

// boost asio
#include <boost/asio.hpp>

// boost serialization
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/vector.hpp>
//  boost archive
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>

#include "Header.hh"
#include "ElementContainer.hh"
#include "ElementContainerArray.hh"
#include "ElementContainerMatrix.hh"
#include "UInt4Container.hh"
#include "UInt4ContainerArray.hh"
#include "UInt4ContainerMatrix.hh"

class ASIO_local {
private:
  boost::asio::ip::tcp::iostream  *h;

public:
  /*
   * @param host hostname string to send(transmit)
   * @param port port number as a string of the remote host to send(transmit)
   */
  ASIO_local(const std::string &host, const std::string &port) {
        h  = new boost::asio::ip::tcp::iostream (host, port);
  }
  ~ASIO_local() {
        delete h;
  }

  bool stat(void) const { return *h; };

  friend class SerialNeutronExchanger;
  friend class SerialPythonServerClient;
};


class ASIO_remote {
private:
  boost::asio::io_service io;
  boost::asio::ip::tcp::acceptor *acc;

  boost::asio::ip::tcp::iostream  *h;

public:
  /*
   * @param port port number to listen to
   */
  ASIO_remote(const UInt4 port) {
        h  = new boost::asio::ip::tcp::iostream;

        acc = new boost::asio::ip::tcp::acceptor
          (io, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port));

        acc->accept( *h->rdbuf() );

  }
  ~ASIO_remote() {
        delete h;
        delete acc;
  }
  std::string from_host(void) const { /*
        boost::asio::ip::tcp::endpoint T  = h->rdbuf()->remote_endpoint();
        boost::asio::ip::address A = T.address();
        return A.to_string(); */
        return h->rdbuf()->remote_endpoint().address().to_string();
  }

  friend class SerialNeutronExchanger;
};

class SerialNeutronExchanger {
private:
  boost::asio::ip::tcp::iostream  *h;

public:
  SerialNeutronExchanger(ASIO_local &Al) {
        h = Al.h;
  }
  SerialNeutronExchanger(ASIO_remote &Ar) {
        h = Ar.h;
  }
  /*
   * @param *_h pointer to the boost::asio::ip::tcp::iostream in ASIO_local or ASIO_remote
   */
  SerialNeutronExchanger(boost::asio::ip::tcp::iostream  *_h) : h(_h) {
  }



  template <typename T>
  void Transmit(const T &val) {
        boost::archive::binary_oarchive *oa = new boost::archive::binary_oarchive (*h);
        *oa << val;
        delete oa;
  }

  template <typename T>
  void Receive(T &val) {
        try {
          boost::archive::binary_iarchive *ia = new boost::archive::binary_iarchive (*h);
          *ia >> val;
          delete ia;
        }
        catch (boost::archive::archive_exception &N) {
          std::cerr << "SerialNeutronExchanger CAUGHT Exception!: Receive Failed" << std::endl;
          T nulval;
          val = nulval;
        }
  }


  UInt4 ReceiveUInt4(void) {
        UInt4 data;
        Receive(data);
        return data;
  }
  Int4  ReceiveInt4(void) {
        Int4 data;
        Receive(data);
        return data;
  }
  std::string  ReceiveString(void) {
        std::string data;
        Receive(data);
        return data;
  }
  Double ReceiveDouble(void) {
        Double data;
        Receive(data);
        return data;
  }

};


#endif /* SERIALNEUTRONEXCHANGER */