connection.hpp

#ifndef __CONNECTION_HPP__
#define __CONNECTION_HPP__

#include "transmissible.hpp"
#include "protocol.hpp"

#include <iostream>
#include <string>

namespace ipsi
{
  
  class Connection
  {
  private:
    
    std::string mIP;
    unsigned int mPort;
    Protocol* mProtocol;
    
  public:
    
    Connection ( const std::string& ip       ,
                 const unsigned int port     ,
                 Protocol*          protocol );
    
    
    virtual ~Connection (  );
    
    
    void drop (const size_t sz) const;
    
    void getInfo (  ) const;
    
    unsigned int getPort() const
    {
      return mPort;
    }
    
    std::string getIP() const
    {
      return mIP;
    }
    
    
    //*************SEND*************************************************************/
    
    template<class T>
    void send ( const T& data ) const
    {
      sender<T, Connection>::Run( *this, data);
    }
    
    template<class T, int N>
    void send ( const T (&data) [N] ) const
    {
      send(&data[0], N);
    }
    
    template<class T>
    void send ( const T* data, const size_t sz ) const
    {
      typedef char* ptr;
      mProtocol->send(ptr(data), sz*sizeof(T));
    }
    
    
    //*************RECEIVE**********************************************************/
    
    template<class T>
    void receive ( T& data )
    {
      receiver<T, Connection>::Run( *this, data);
    }
    
    template<class T, int N>
    void receive ( T (&data) [N] )
    {
      receive(&data[0], N);
    }
    
    template<class T>
    void receive ( T* data, size_t sz )
    {
      typedef unsigned char* ptr;
      size_t rsz;
      mProtocol->receive(sz*sizeof(T), ptr(data), &rsz);
    }
    
  }; // Fin class Connection
  
  
  //*************SURCHARGES OPERATEURS********************************************/
  
  template<class T>
  Connection& operator<<( Connection& c, const T& d)
  {
    c.send(d);
    return c;
  }
  template<class T>
  Connection& operator>>( Connection& c, T& d)
  {
    c.receive(d);
    return c;
  }
  
  
  //*************CLASS DROP*******************************************************/
  
  template<class T>
  class drop
  {
  private:
    size_t nbDrop;
    
  public :
    drop(size_t sz) : nbDrop(sz*sizeof(T))
    {}
    
    size_t operator()() const
    {
      return nbDrop;
    }
  };
  
  //*************CLASS ARRAY*****************************************************/
  
  template<class T>
  class array
  {
  private:
    size_t sz;
    T* data;
    
  public :
    array(T* ptr, size_t v) : sz(v), data(ptr)
    {}
    
    size_t size() const
    {
      return sz;
    }
    
    T* const_ptr() const
    {
      return data;
    }
    
    T* ptr()
    {
      return data;
    }
  };
  
  //*************SURCHARGES OPERATEURS********************************************
  
  template<class T>
  Connection& operator>>( Connection& c, const drop<T>& d )
  {
    c.drop(d());
    return c;
  }
  
  
  template<class T>
  Connection& operator>>( Connection& c, const array<T>& d )
  {
    c.receive(d.const_ptr(),d.size());
    return c;
  }
  
  template<class T>
  Connection& operator<<( Connection& c, const array<T>& d )
  {
    c.send(d.const_ptr(),d.size());
    return c;
  }
  
  
  template<class C,class T,class A>
  Connection& operator>>( Connection& c, std::basic_string<C,T,A>& d )
  {
    size_t sz;
    c.receive(sz);
    std::string r(sz,'\0');
    c.receive(&r[0],sz);
    d = r;
    return c;
  }
  
  template<class C,class T,class A>
  Connection& operator<<( Connection& c, const std::basic_string<C,T,A>& d )
  {
    std::cout << d.size() << ":" << d << std::endl;
    c.send(d.size());
    c.send(d.c_str(),d.size());
    return c;
  }
}
#endif

---