view/connection/ConnectionLogger.cpp

/*!
  \file
  \brief 通信の記録

  \author Satofumi KAMIMURA

  $Id$
*/

#include "ConnectionLogger.h"
#include "TcpipCtrl.h"
#include <string>
#include <fstream>

using namespace beego;


/*!
  \brief ConnectionLogger の内部クラス
*/
struct ConnectionLogger::pImpl {
  ConnectionInterface* con;
  std::string base_name;
  std::fstream fd_recv;
  std::fstream fd_send;

  pImpl(ConnectionInterface* con_obj, bool open_logfile)
    : con(con_obj), base_name("connection") {
    if (con == NULL) {
      // !!! LogManager
      throw;
    }
    if (open_logfile) {
      open();
    }
  }

  ~pImpl(void) {
    terminate();
    delete con;
  }

  void open(void) {
    if (! fd_recv.is_open()) {
      std::string recv_file = base_name + "_recv.txt";
      fd_recv.open(recv_file.c_str(), std::ios::out | std::ios::binary);

      std::string send_file = base_name + "_send.txt";
      fd_send.open(send_file.c_str(), std::ios::out | std::ios::binary);
    }
  }

  void terminate(void) {
    if (fd_recv.is_open()) {
      fd_recv.close();
      fd_send.close();
    }
  }
};


ConnectionLogger::ConnectionLogger(ConnectionInterface* con,
                                   bool open_logfile)
  : pimpl(new pImpl(con, open_logfile)) {
}


ConnectionLogger::~ConnectionLogger(void) {
}


const char* ConnectionLogger::what(void) {
  return pimpl->con->what();
}


bool ConnectionLogger::connect(const char* host, long port) {

  pimpl->open();
  return pimpl->con->connect(host, port);
}


void ConnectionLogger::disconnect(void) {
  pimpl->con->disconnect();
}


bool ConnectionLogger::isConnected(void) {
  return pimpl->con->isConnected();
}


bool ConnectionLogger::changeBaudrate(long baudrate) {
  return pimpl->con->changeBaudrate(baudrate);
}


int ConnectionLogger::send(const char* data, int size) {

  if (size > 0) {
    // data の内容をファイルに書き出す
    pimpl->fd_send.write(data, size);
    pimpl->fd_send.flush();
  }
  return pimpl->con->send(data, size);
}


int ConnectionLogger::recv(char* data, int size, int timeout) {

  int n = pimpl->con->recv(data, size, timeout);

  if (n > 0) {
    // data の内容をファイルに書き出す
    pimpl->fd_recv.write(data, n);
    pimpl->fd_recv.flush();
  }
  return n;
}


int ConnectionLogger::size(int timeout) {
  return pimpl->con->size(timeout);
}


void ConnectionLogger::clear(void) {
  return pimpl->con->clear();
}


void ConnectionLogger::setLogfileName(const char* logfileName) {
  pimpl->base_name = logfileName;
}


void ConnectionLogger::skip(int total_timeout) {
  return pimpl->con->skip(total_timeout);
}


void ConnectionLogger::flush(void) {
  pimpl->con->flush();
}