/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/wall/data_client

Go to the documentation of this file.

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file inlib.license for terms.

#ifndef inlib_wall_data_client
#define inlib_wall_data_client

#include "../net/inet_socket"
#include "protocol"
#include "../smanip" //words

namespace inlib {
namespace wall {

class data_client {
public:
  data_client(std::ostream& a_out,
              bool a_verbose,
              bool a_warn) //warn if received an unknow prot.
  :m_out(a_out)
  ,m_socket(a_out,a_verbose)
  ,m_warn(a_warn)
  {}
  virtual ~data_client(){}
protected:
  data_client(const data_client& a_from)
  :m_out(a_from.m_out)
  ,m_socket(a_from.m_out,false)
  ,m_warn(a_from.m_warn)
  {}
private:
  data_client& operator=(const data_client&){return *this;}
public:
  inlib::net::inet_socket& socket() {return m_socket;}
  std::ostream& out() {return m_out;}
  bool initialize(const std::string& a_server,unsigned int a_port) {
    if(!m_socket.connect(a_server,a_port,20,1)) return false;
    if(m_socket.verbose()) {
      m_out << "inlib::data_client::initialize :"
            << " connected."
            << std::endl;
    }
    return true;
  }

  bool steer() {
    while(true){
      std::string prot;
      if(!m_socket.fetch_string(prot)) {
        m_out << "inlib::data_client::steer :"
              << " fetch failed"
              << std::endl;       
        m_socket.disconnect();
        return false;
      }
  
      if(m_socket.verbose()) {
        m_out << "inlib::data_client::steer :"
              << " received prot " << inlib::sout(prot)
              << std::endl;       
      }
  
      bool handled;
      if(!dispatch(prot,handled)) {
        m_out << "inlib::data_client::steer :"
              << " distpatch failed"
              << std::endl;       
        m_socket.disconnect();
        return false;
      }
  
    }
  
    m_socket.disconnect();
  
    return true;
  }

  bool poll() {
    while(true){
      bool have_input;
      if(!m_socket.is_there_input(have_input)) {
        m_out << "inlib::data_client::poll :"
              << " is_there_input failed"
              << std::endl;       
        m_socket.disconnect();
        return false;
      }
      if(!have_input) return true;

      std::string prot;
      if(!m_socket.fetch_string(prot)) {
        m_out << "inlib::data_client::poll :"
              << " fetch failed"
              << std::endl;       
        m_socket.disconnect();
        return false;
      }
  
      if(m_socket.verbose()) {
        m_out << "inlib::data_client::poll :"
              << " received prot " << prot
              << std::endl;       
      }  

      bool handled;
      if(!dispatch(prot,handled)) {
        m_out << "inlib::data_client::poll :"
              << " distpatch failed"
              << std::endl;       
        m_socket.disconnect();
        return false;
      }
      //could have received a inlib::wall::protocol::disconnect()
      if(!m_socket.is_connected()) return true;
  
    }  
  }

/*
  bool send_doc(const std::string& a_file,
                       const std::string& a_options = "") {
    if(!m_socket.send_string(inlib::wall::protocol::doc())) {
      m_out << "inlib::data_client::send_doc :"
            << " send_string() failed."
            << std::endl;
      return false;
    }

    if(!m_socket.send_string(a_options)) {
      m_out << "inlib::data_client::send_doc :"
            << " send_string() failed."
            << std::endl;
      return false;
    }

    if(!m_socket.send_file(a_file)) {
      m_out << "inlib::data_client::send_doc :"
            << " send_file() failed."
            << std::endl;
      return false;
    }

    return true;
  }
*/

  bool send_buffer_doc(inlib::uint64 a_length,
                              const char* a_buffer,
                              const std::string& a_options = "") {
    if(!m_socket.send_string(inlib::wall::protocol::doc())) {
      m_out << "inlib::data_client::send_doc :"
            << " send_string() failed."
            << std::endl;
      return false;
    }

    if(!m_socket.send_string(a_options)) {
      m_out << "inlib::data_client::send_doc :"
            << " send_string() failed."
            << std::endl;
      return false;
    }

    if(!m_socket.send<inlib::uint64>(a_length)) {
      m_out << "inlib::data_client::send_doc :"
            << " send lengtj failed."
            << std::endl;
      return false;
    }
    if(!m_socket.send_buffer(a_buffer,a_length)) {
      m_out << "inlib::data_client::send_doc :"
            << " send_buffer() failed."
            << std::endl;
      return false;
    }

    return true;
  }

protected:
  virtual bool dispatch(const std::string& a_prot,bool& a_handled) {
    if(a_prot==inlib::wall::protocol::disconnect()) {
      m_socket.disconnect();
      a_handled = true;

    } else if(a_prot==inlib::wall::protocol::start()) {
  
      a_handled = true;

    } else {
      if(m_warn) {
        m_out << "inlib::data_client::dispatch :"
              << " unknown prot " << inlib::sout(a_prot) << "."
              << std::endl;
      }
      a_handled = false;
    }

    return true;
  }
protected:
  std::ostream& m_out;
  inlib::net::inet_socket m_socket;
private:
  bool m_warn;
};

}}

#endif


/* example to override :
  class data_client : public inlib::wall::data_client {
  public:
    data_client(std::ostream& a_out,bool a_verbose = false)
    : inlib::wall::data_client(a_out,a_verbose){}
    virtual ~data_client(){}
  private:
    data_client(const data_client& a_from)
    : inlib::wall::data_client(a_from){}
    data_client& operator=(const data_client&){return *this;}
  protected:
    virtual bool dispatch(const std::string& a_prot,bool& a_handled) {
      if(!inlib::wall::data_client::dispatch(a_prot,a_handled)) return false;
      if(a_handled) return true;
  
      //if(a_prot==inlib_net_protocol_cbk) {
      //} else {
        m_out << "exlib::geant4::session::data_client::dispatch :"
              << " unknown prot " << inlib::sout(a_prot) << "."
              << std::endl;
        a_handled = false;
      //}
      return true;
    }
  };
*/