---

PsList.h

Go to the documentation of this file.

/*
 * This file is part of openMask © 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 Université de Rennes 1 
 * for the software may use this file in accordance with that specific license 
 *
 */
#ifndef PsListHEADER
#define PsListHEADER

#include <Psn.h>
#include <PsType.h>

#include <list>
#include <PsPolator.h>

//-----------------------------------------------------------------

#ifdef _OLDALLOCATORS
template <typename Type, typename allocator=STL_ALLOC > class PsList : public list <Type, STL_ALLOC>, public PsType
#else
template <typename Type, typename allocator=STL_ALLOC<Type> > class PsList : public list <Type, allocator >, public PsType
#endif
{
public:

  PsList  () 
   {
   }

#ifdef _OLDALLOCATORS
   PsList (const int n, const Type & initialValue): list<Type, STL_ALLOC>(n,initialValue) 
#else
   PsList (const int n, const Type & initialValue): list<Type, allocator >(n,initialValue) 
#endif
   {
   };

#ifdef _OLDALLOCATORS
   PsList (const list<Type, STL_ALLOC> &l): list<Type, STL_ALLOC>(l) {};
#else
   PsList (const list<Type, allocator > &l): list<Type, allocator >(l) {};
#endif

#ifdef _OLDALLOCATORS
  PsList (const PsList<Type> &l): list<Type, STL_ALLOC>(l) {};
#else
  PsList (const PsList<Type> &l): list<Type, allocator >(l) {};
#endif

   virtual ~PsList() {}
   
   virtual PsPolatorNT * createPolator(void) 
   {
      return (PsPolatorNT *) new PsPolator< PsList<Type> >() ;
   } ;
   
   
   virtual void pack (PsOutgoingSynchronisationMessage & out ) const ;

   virtual void unpack (PsIncomingSynchronisationMessage & in ) ;

   virtual void insertInStream (ostream & = cout) const ;
   
   
   virtual void extract (istream & = cin) ;
   
   
   virtual PsList <Type,allocator> & operator = (const PsList <Type,allocator> &) ;
   
};


template <typename Type, typename allocator >
inline void PsList <Type,allocator>::insertInStream (ostream & out) const {
   out << size () << " " ;
#ifdef _TYPENAMENOTIMPLICIT
   typename  PsList <Type,allocator>::
#endif
      const_iterator i = begin () ;
   while (i != end ()) {
      out << *i << " " ;
      i ++ ;
   }
}

template <typename Type, typename allocator >
inline void PsList <Type,allocator>::extract (istream & in) {
   int nbElements ;
   Type elem ;
   clear () ;
   in >> nbElements ;
   for (int j = 0 ; j < nbElements ; j ++) {
      in >> elem ;
      push_back (elem) ;
   }
}

template <typename Type, typename allocator >
void PsList <Type,allocator>::pack (PsOutgoingSynchronisationMessage & out ) const 
{
   out << size () ;
#ifdef _TYPENAMENOTIMPLICIT
   typename  PsList <Type,allocator>::const_iterator i = begin () ;
#else
   const_iterator i = begin () ;
#endif
   while (i != end ()) 
      {
         out << *i ;
         i ++ ;
      }
   
}

template <typename Type, typename allocator >
void PsList <Type,allocator>::unpack (PsIncomingSynchronisationMessage & in ) 
{
   size_t numberOfElements ;
   in >> numberOfElements ;
   resize (numberOfElements) ;
   for (typename PsList <Type,allocator>::iterator i = begin() ; i != end() ; ++i)
      {
         (*i).unpack ( in ) ; 
      }
}

//-----------------------------------------------------------------------

// TDTD 1997/9/4 inherit frome PsType : redefine mandatory methods

template <typename Type, typename allocator >
inline PsList <Type,allocator> & PsList <Type,allocator>::operator = (const PsList <Type,allocator> & p)
{
#ifdef _OLDALLOCATORS
  list <Type, STL_ALLOC>::operator = (p) ; // TDTD DANGER resolved on 1999/9/8
#else
  list <Type, allocator >::operator = (p) ; // TDTD DANGER resolved on 1999/9/8
#endif
  return *this ;
}


//  //TD added during update 1999/5/5 : otherwise, lists with pointer are seen as list of bool by implicit conversion
//  inline istream & operator >> (istream & in, void *) {
//     cerr << "WARNING : on ne doit pas passer ici, il ne s'y passe rien" << endl ;
//     return in ;
//  }


#endif

---