transmissible.hpp

#ifndef __TRANSMISSIBLE_HPP__
#define __TRANSMISSIBLE_HPP__

namespace ipsi
{
  class Connection;
  
  struct sendable
  {
    virtual void send ( const Connection& c ) const = 0;
    
    virtual ~sendable()
    {}
  };
  
  
  struct receivable
  {
    virtual void receive ( const Connection& c ) = 0;
    
    virtual ~receivable()
    {}
  };
  
  struct transmissible : public sendable, public receivable
  {
    virtual ~transmissible()
    {}
  };
  
                         // Ensemble de meta-fonctions permettant de trouver comment envoyer un objet
  namespace inner
  {
    template<class T, class U>
    struct help_conversion
    {
      typedef char Small;
      struct Big
      {
        char dummy[2];
      };
      static Big   Test(...);
      static Small Test(U)  ;
      static T     MakeT()  ;
    };
  }
  
  
  template<class T, class U>
  struct is_same
  {
    typedef inner::help_conversion<T, U> H;
    static const bool val =
      sizeof(typename H::Small) == sizeof((H::Test(H::MakeT())));
  };
  
  
  //*********SENDER***************************************************************
  
  template<class T, class C, bool ID = is_same<T*,sendable*>::val>
  struct sender
  {
    static void Run( const C& c, const T& data )
    {
      c.send( &data, 1 );
    }
  };
  
  
  template<class T,class C>
  struct sender<T,C,true>
  {
    static void Run( const C& c, const T& data )
    {
      data.send(c);
    }
  };
  
  
  //*********RECEIVER*************************************************************
  
  template<class T, class C, bool ID = is_same<T*,receivable*>::val>
  struct receiver
  {
    static void Run(  C& c, T& data )
    {
      c.receive( &data, 1 );
    }
  };
  
  
  template<class T,class C>
  struct receiver<T,C,true>
  {
    static void Run(  C& c, T& data )
    {
      data.receive(c);
    }
  };
}
#endif

---