OMKSimpleTypeT.inl

Go to the documentation of this file.

/************************************************************************/
/* This file is part of openMask(c) INRIA, CNRS, Universite de Rennes 1 */
/* 1993-2002, thereinafter the Software                                 */
/*                                                                      */
/* The Software has been developped within the Siames Project.          */
/* INRIA, the University of Rennes 1 and CNRS jointly hold intellectual */
/* property rights                                                      */
/*                                                                      */
/* The Software has been registered with the Agence pour la Protection  */
/* des Programmes (APP) under registration number                       */
/* IDDN.FR.001.510008.00.S.P.2001.000.41200                             */
/*                                                                      */
/* This file may be distributed under the terms of the Q Public License */
/* version 1.0 as defined by Trolltech AS of Norway and appearing in    */
/* the file LICENSE.QPL included in the packaging of this file.         */
/*                                                                      */
/* Licensees holding valid specific licenses issued by INRIA, CNRS or   */
/* Universite Rennes 1 for the software may use this file in            */
/* acordance with that specific license                                 */
/************************************************************************/
                
#if !defined _SIMPLETYPET_INL_
#define _SIMPLETYPET_INL_

#include "OMKSimpleTypeT.h"
#include <list>
#include <map>
#include <vector>
#include "OMKOutgoingSynchronisationMessage.h"
#include "OMKIncomingSynchronisationMessage.h"
#include "OMKPolator.h"

//=============================================================================
// stream operators for string
//-----------------------------------------------------------------------------
inline OMK::OutgoingSynchronisationMessage& 
operator << ( OMK::OutgoingSynchronisationMessage& out, const std::string& value )
{
  out.pack( value ) ; 
  return out ;
}
//-----------------------------------------------------------------------------
inline OMK::IncomingSynchronisationMessage& 
operator >> ( OMK::IncomingSynchronisationMessage& in, std::string& value ) 
{ 
  in.get( value ) ;
  return in ;
}
//=============================================================================

//=============================================================================
// stream operators for pair
//-----------------------------------------------------------------------------
template< typename T1, typename T2 >
std::ostream& operator << ( std::ostream& out, const std::pair< T1, T2 >& value )
{
  out << value.first << " " << value.second << " " ; 
  return out ;
}
//-----------------------------------------------------------------------------
template< typename T1, typename T2 >
std::istream& operator >> ( std::istream& in, std::pair< T1, T2 >& value )
{ 
  in >> value.first >> value.second ; 
  return in ;
}
//-----------------------------------------------------------------------------
template< typename T1, typename T2 >
OMK::OutgoingSynchronisationMessage& 
operator << ( OMK::OutgoingSynchronisationMessage& out, const std::pair< T1, T2 >& value )
{
  out << value.first << value.second ; 
  return out ;
}
//-----------------------------------------------------------------------------
template< typename T1, typename T2 >
OMK::IncomingSynchronisationMessage& 
operator >> ( OMK::IncomingSynchronisationMessage& in, std::pair< T1, T2 >& value ) 
{ 
  in >> value.first >> value.second ; 
  return in ;
}
//=============================================================================

//=============================================================================
// stream operators for list
//-----------------------------------------------------------------------------
template< typename T >
std::ostream& operator << ( std::ostream& out, const std::list< T >& values )
{
  out << values.size() << " " ; 
  for( typename std::list< T >::const_iterator i( values.begin() ) ;
       i != values.end() ;
       ++i )
  {
    out << (*i) << " " ;
  }
  return out ;
}
//-----------------------------------------------------------------------------
template< typename T >
std::istream& operator >> ( std::istream& in, std::list< T >& values )
{
  // we do not want any element in the proposed list to avoid accumulation
  values.clear() ;
  unsigned int size( 0 ) ;
  in >> size ; 
  for( unsigned int i( 0 ) ; i < size ; ++i )
  {
    T value ;
    in >> value ;
    values.push_back( value ) ;
  }
  return in ;
}
//-----------------------------------------------------------------------------
template< typename T >
OMK::OutgoingSynchronisationMessage& 
operator << ( OMK::OutgoingSynchronisationMessage& out, const std::list< T >& values )
{
  out << values.size() ; 
  for( typename std::list< T >::const_iterator i( values.begin() ) ;
       i != values.end() ;
       ++i )
  {
    out << (*i) ;
  }
  return out ;
}
//-----------------------------------------------------------------------------
template< typename T >
OMK::IncomingSynchronisationMessage& 
operator >> ( OMK::IncomingSynchronisationMessage& in, std::list< T >& values ) 
{
  // we do not want any element in the proposed list to avoid accumulation
  values.clear() ;
  unsigned int size( 0 ) ;
  in >> size ;
  for( unsigned int i( 0 ) ; i < size ; ++i )
  {
    T value ;
    in >> value ;
    values.push_back( value ) ;
  }
  return in ;
}
//=============================================================================

//=============================================================================
// stream operators for vector
//-----------------------------------------------------------------------------
template< typename T >
std::ostream& operator << ( std::ostream& out, const std::vector< T >& values )
{
  out << values.size() ;
  for( unsigned int i( 0 ) ; i < values.size() ; ++i )
  {
    out << values[ i ] << " " ;
  }
  return out ;
}
//-----------------------------------------------------------------------------
template< typename T >
std::istream& operator >> ( std::istream& in, std::vector< T >& values )
{
  // we do not want any element in the proposed vector to avoid accumulation
  values.clear() ;
  unsigned int size( 0 ) ;
  in >> size ;
  values.reserve( size ) ;
  for( unsigned int i( 0 ) ; i < size ; ++i )
  {
    T value ;
    in >> value ;
    values.push_back( value ) ;
  }
  return in ;
}
//-----------------------------------------------------------------------------
template< typename T >
OMK::OutgoingSynchronisationMessage& 
operator << ( OMK::OutgoingSynchronisationMessage& out, const std::vector< T >& values )
{
  out << values.size() ;
  for( unsigned int i( 0 ) ; i < values.size() ; ++i )
  {
    out << values[ i ] ;
  }
  return out ;
}
//-----------------------------------------------------------------------------
template< typename T >
OMK::IncomingSynchronisationMessage& 
operator >> ( OMK::IncomingSynchronisationMessage& in, std::vector< T >& values ) 
{ 
  // we do not want any element in the proposed vector to avoid accumulation
  values.clear() ;
  unsigned int size( 0 ) ;
  in >> size ;
  values.reserve( size ) ;
  for( unsigned int i( 0 ) ; i < size ; ++i )
  {
    T value ;
    in >> value ;
    values.push_back( value ) ;
  }
  return in ;
}
//=============================================================================

//=============================================================================
// stream operators for map
//-----------------------------------------------------------------------------
template< typename T1, typename T2 >
std::ostream& operator << ( std::ostream& out, const std::map< T1, T2 >& values )
{
  out << values.size() << " " ; 
  for( typename std::map< T1, T2 >::const_iterator i( values.begin() ) ;
       i != values.end() ;
       ++i )
  {
    out << i->first  << " "
        << i->second << " " ;
  }
  return out ;
}
//-----------------------------------------------------------------------------
template< typename T1, typename T2 >
std::istream& operator >> ( std::istream& in, std::map< T1, T2 >& values )
{
  // we do not want any element in the proposed map to avoid accumulation
  values.clear() ;
  unsigned int size( 0 ) ;
  in >> size ;
  for( unsigned int i( 0 ) ; i < size ; ++i )
  {
    T1 key ;
    T2 value ;
    in >> key >> value ;
    values[ key ] = value ;
  }
  return in ;
}
//-----------------------------------------------------------------------------
template< typename T1, typename T2 >
OMK::OutgoingSynchronisationMessage& 
operator << ( OMK::OutgoingSynchronisationMessage& out, const std::map< T1, T2 >& values )
{
  out << values.size() << " " ; 
  for( typename std::map< T1, T2 >::const_iterator i( values.begin() ) ;
       i != values.end() ;
       ++i )
  {
    out << i->first  << " "
        << i->second << " " ;
  }
  return out ;
}
//-----------------------------------------------------------------------------
template< typename T1, typename T2 >
OMK::IncomingSynchronisationMessage& 
operator >> ( OMK::IncomingSynchronisationMessage& in, std::map< T1, T2 >& values ) 
{
  // we do not want any element in the proposed map to avoid accumulation
  values.clear() ;
  unsigned int size( 0 ) ;
  in >> size ; 
  for( unsigned int i( 0 ) ; i < size ; ++i )
  {
    T1 key ;
    T2 value ;
    in >> key >> value ;
    values[ key ] = value ;
  }
  return in ;
}
//=============================================================================


//=============================================================================
// stream pack/unpack for SimpleTypeT
template< typename T >
void OMK::Type::SimpleTypeT< T >::insertInStream( std::ostream& out ) const 
{ 
  out << _value << " " << " " ; 
}
//-----------------------------------------------------------------------------
template< typename T >
void OMK::Type::SimpleTypeT< T >::extract( std::istream& in )
{ 
  in  >> _value ; 
}
//-----------------------------------------------------------------------------
template< typename T >
void OMK::Type::SimpleTypeT< T >::pack( OMK::OutgoingSynchronisationMessage& out ) const 
{ 
  out << _value ;
}
//-----------------------------------------------------------------------------
template< typename T >
void OMK::Type::SimpleTypeT< T >::unpack( OMK::IncomingSynchronisationMessage& in )       
{
  in  >> _value ; 
}
//-----------------------------------------------------------------------------
// Polator for SimpleTypeT
template< typename T >
OMK::Type::PolatorNT* OMK::Type::SimpleTypeT< T >::createPolator() 
{ 
  return new OMK::Type::Polator< OMK::Type::SimpleTypeT< T > >() ; 
}

#endif // defined _SIMPLETYPET_INL_

---