---

PsNameServerT.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 PsNameServerTHEADER
#define PsNameServerTHEADER

#include <map>
#include "PsNameServer.h"
#include "PsnMutexLock.h"

using namespace std ;
#ifdef _OLDALLOCATORS
template <class STLallocator >
#else
template <template <typename T> class STLallocator >
#endif
class PsNameServerT : public PsNameServer  {
public:
   PsNameServerT();


   PsNameServerT(const PsNameServer::CanonicalRepresentationType * );


   virtual ~PsNameServerT();


   virtual long getIdentifier(const PsString &);


   virtual long getSystemIdentifier(const PsString &);


   virtual long getIdentifierAsFrom(const PsString &, long * nextId);


   virtual const PsString & getStringAssociatedTo (PsName::idType id) const;


   void * operator new(size_t);


   void operator delete(void * ptr, size_t n);


   virtual void created(PsName::idType id, PsName * );


   virtual void deleted(PsName::idType id, PsName * );


   CanonicalRepresentationType * getCanonicalRepresentation () const ;


   virtual const list<PsName *> & getNamesOfId (PsName::idType) const ;

protected:
   virtual void lock() const ;

   virtual void unlock() const ;

   mutable PsnMutexLock _ourDataLock ;

   long _nextIdentifier ;

   long _nextSystemIdentifier ;


#ifdef _OLDALLOCATORS

   //typedef hash_map<PsString, long, PsString_hash, equal_to<PsString>, STLallocator> correspondenceContainerType;
   typedef hash_map<PsString, long, PsString_hash > correspondenceContainerType ;

   typedef map<long,correspondenceContainerType::iterator> fastStringAccessTableType;

   typedef hash_map<PsName::idType, int> referenceCountingContainerType;
   
   typedef hash_map<PsName::idType, list<PsName *> * > placeOfNamesContainerType;
   
#else

   typedef hash_map<PsString,long, PsString_hash ,equal_to<PsString>,STLallocator<pair <PsString,long> > > correspondenceContainerType;

   typedef map<long, typename correspondenceContainerType::iterator,less<long>,STLallocator<pair<const long, typename correspondenceContainerType::iterator> > > fastStringAccessTableType;

   typedef hash_map<PsName::idType, int, hash<PsName::idType>,equal_to<PsName::idType>,STLallocator<pair<PsName::idType,int> > > referenceCountingContainerType;
 
   typedef hash_map<PsName::idType, list<PsName *> *, hash<PsName::idType>,equal_to<PsName::idType>,STLallocator<pair<PsName::idType,int> > > placeOfNamesContainerType ;
   

#endif

   fastStringAccessTableType _fastStringAccessTable ;

   correspondenceContainerType _stringToIdCorrespondenceContainer ;

   referenceCountingContainerType _tableNbInstances;

   placeOfNamesContainerType _idToNamesUsingIdContainer ;

};



#ifdef _OLDALLOCATORS
template <class STLallocator >
#else
template <template <typename T> class STLallocator >
#endif
PsNameServerT<STLallocator>::PsNameServerT() 
{
   //cerr<<"PsNameServerT<STLallocator>:"<<this<<":PsNameServerT() "<<endl;
   _nextIdentifier = PsName::_maxReservedId + 1 ;
   _nextSystemIdentifier = 1 ;

   // keep id 0 reserved and associated to the string "Uninitialised PsName"
   _tableNbInstances.insert (referenceCountingContainerType::value_type(0, 0) );
#ifdef _TYPENAMENOTIMPLICIT
   typename correspondenceContainerType::iterator i=(_stringToIdCorrespondenceContainer.insert(typename correspondenceContainerType::value_type(PsString("Uninitialised PsName"),0))).first;
   _fastStringAccessTable.clear();
   _fastStringAccessTable.insert(pair<const long, typename correspondenceContainerType::iterator>(0,i));
#else
   correspondenceContainerType::iterator i=(_stringToIdCorrespondenceContainer.insert(correspondenceContainerType::value_type(PsString("Uninitialised PsName"),0))).first;   
   _fastStringAccessTable.clear();
   _fastStringAccessTable.insert(pair<const long, correspondenceContainerType::iterator>(0,i));
#endif
}



#ifdef _OLDALLOCATORS
template <class STLallocator >
#else
template <template <typename T> class STLallocator >
#endif
PsNameServerT<STLallocator>::PsNameServerT(const PsNameServer::CanonicalRepresentationType * canonicalRepresentation)  
{
   //cerr<<"PsNameServerT<STLallocator>:"<<this<<":PsNameServerT(const PsNameServer::CanonicalRepresentationType * canonicalRepresentation)"<<endl;
    for ( CanonicalRepresentationType::const_iterator i = canonicalRepresentation->begin() ;
         i != canonicalRepresentation->end() ;
         i++ )
      {
         //(*i) is < <PsName::idType,PsString> , numberOfInstances> therefore
         //(*i).first.first is the id,
         //(*i).first.second is the associated string
         //(*i).second is the number of instances of PsNames with id as id

         //first create an entry is the hash_table for the associated string
#ifdef _TYPENAMENOTIMPLICIT
         typename correspondenceContainerType::iterator ii=(_stringToIdCorrespondenceContainer.insert(typename correspondenceContainerType::value_type((*i).first.second,(*i).first.first))).first;
         // then reference that entry in the iterator table 
         _fastStringAccessTable.insert(pair<const long, typename correspondenceContainerType::iterator>((*i).first.first,ii));   
#else
         correspondenceContainerType::iterator ii=(_stringToIdCorrespondenceContainer.insert(correspondenceContainerType::value_type((*i).first.second,(*i).first.first))).first;
         // then reference that entry in the iterator table 
         _fastStringAccessTable.insert(pair<const long, correspondenceContainerType::iterator>((*i).first.first,ii));    
#endif
         //then take care of keeping care of the number of copies of id in the system
         _tableNbInstances[(*i).first.first] = (*i).second ;

         //cerr<<"PsNameServerT<STLallocator>::PsNameServerT "<<(*i).second<<" references to "<<(*i).first.first<<endl;

         //try and find a reasonnable next id
         _nextIdentifier = (*i).first.first + 1 ;
      }
}


#ifdef _OLDALLOCATORS
template <class STLallocator >
#else
template <template <typename T> class STLallocator >
#endif
PsNameServerT<STLallocator>::~PsNameServerT() 
{
   //nothing to do   
}


#ifdef _OLDALLOCATORS
template <class STLallocator >
#else
template <template <typename T> class STLallocator >
#endif
PsName::idType 
PsNameServerT<STLallocator>::getIdentifier(const PsString & name) 
{
   PsName::idType res;
   //cerr<<this<<" "<<_nextIdentifier<<" ";
   res = getIdentifierAsFrom(name, &_nextIdentifier) ;
   //cerr<<"("<<res<<","<<name<<") added to name server "<<_nextIdentifier<<endl;
   return res;
}


#ifdef _OLDALLOCATORS
template <class STLallocator >
#else
template <template <typename T> class STLallocator >
#endif
PsName::idType 
PsNameServerT<STLallocator>::getSystemIdentifier(const PsString & name) 
{

   PsName::idType result = getIdentifierAsFrom(name, &_nextSystemIdentifier) ;
   // this assertion could fail if a PsName corresponding to a reserved id was staticaly created
   assert ( result <= PsName::_maxReservedId ) ;
   //this would fail if more reserved Id's are created than originaly planned for
   assert ( _nextSystemIdentifier <= PsName::_maxReservedId ) ;

   return result ;
}


#ifdef _OLDALLOCATORS
template <class STLallocator >
#else
template <template <typename T> class STLallocator >
#endif
PsName::idType 
PsNameServerT<STLallocator>::getIdentifierAsFrom (const PsString & name, long * nextId ) {

#ifdef _TYPENAMENOTIMPLICIT
   typename
#endif
   correspondenceContainerType::iterator i = _stringToIdCorrespondenceContainer.find( name );

   if (i == _stringToIdCorrespondenceContainer.end()) 
      {
         //we are going to change the values contained in the PsNameServer
         lock() ; 

         i = _stringToIdCorrespondenceContainer.find( name ) ; //name might have been added by an other process

         if (i == _stringToIdCorrespondenceContainer.end() ) //we have to add name
            { 

#ifdef _TYPENAMENOTIMPLICIT
               pair<typename correspondenceContainerType::iterator,bool> res = _stringToIdCorrespondenceContainer.insert(typename correspondenceContainerType::value_type(name,*nextId)) ;
#else
               pair<correspondenceContainerType::iterator,bool> res = _stringToIdCorrespondenceContainer.insert(correspondenceContainerType::value_type(name,*nextId)) ;
#endif
 
               _fastStringAccessTable[*nextId] = res.first ;

               *nextId = *nextId + 1 ;
               
               i = res.first ;
         }

         unlock() ;
      }
   return (*i).second;
}

#ifdef _OLDALLOCATORS
template <class STLallocator >
#else
template <template <typename T> class STLallocator >
#endif
const PsString & 
PsNameServerT<STLallocator>::getStringAssociatedTo (PsName::idType id) const 
{
   assert ( id<_nextIdentifier) ;
   //assert ( _fastStringAccessTable.find(id) != _fastStringAccessTable.end() ) ;
   return  (*(*_fastStringAccessTable.find(id)).second).first ;
}

#ifdef _OLDALLOCATORS
template <class STLallocator >
#else
template <template <typename T> class STLallocator >
#endif
PsNameServer::CanonicalRepresentationType * 
PsNameServerT<STLallocator>::getCanonicalRepresentation() const 
{
   PsNameServer::CanonicalRepresentationType * canonicalRepresentation = new PsNameServer::CanonicalRepresentationType () ;
#ifdef _TYPENAMENOTIMPLICIT
   typename
#endif
   PsNameServerT<STLallocator>::correspondenceContainerType::const_iterator i;
   for (i=_stringToIdCorrespondenceContainer.begin(); i!=_stringToIdCorrespondenceContainer.end();i++) 
      {
         canonicalRepresentation->push_back(PsPair<PsPair<PsName::idType,PsString>, int>(PsPair<PsName::idType,PsString>((*i).second,(*i).first),(*(_tableNbInstances.find((*i).second))).second)) ;
      }
   canonicalRepresentation->sort() ;
   return canonicalRepresentation ;
}



#ifdef _OLDALLOCATORS
template <class STLallocator >
void *
PsNameServerT<STLallocator>::operator new(size_t size) 
{
   return STLallocator::allocate(size);
}
#else
template <template <typename T> class STLallocator >
void *
PsNameServerT<STLallocator>::operator new(size_t size) 
{
   STLallocator<PsNameServerT<STLallocator> > anAllocator;
   return anAllocator.allocate(size);
}
#endif



#ifdef _OLDALLOCATORS
template <class STLallocator >
void PsNameServerT<STLallocator>::operator delete(void * ptr, size_t n) 
{
   STLallocator::deallocate(ptr,n);
}
#else
template <template <typename T> class STLallocator >
void PsNameServerT<STLallocator>::operator delete(void * ptr, size_t n) 
{
   STLallocator<PsNameServerT<STLallocator> > anAllocator;
   anAllocator.deallocate((PsNameServerT<STLallocator> *)ptr,n);
}
#endif

#ifdef _OLDALLOCATORS
template <class STLallocator >
#else
template <template <typename T> class STLallocator >
#endif
void PsNameServerT<STLallocator>::created(PsName::idType id, PsName * name) 
{
   lock() ;
#ifdef _TYPENAMENOTIMPLICIT
   typename
#endif
   referenceCountingContainerType::iterator i = _tableNbInstances.find(id);
   if ( i == _tableNbInstances.end() ) 
      {
         i =  _tableNbInstances.insert(referenceCountingContainerType::value_type(id,1)).first;
      }
   else 
      {
         ++(*i).second;
      }
   // do the same for _idToNamesUsingIdContainer
#ifdef _TYPENAMENOTIMPLICIT
   typename
#endif
   placeOfNamesContainerType::iterator j = _idToNamesUsingIdContainer.find(id);
   if ( j == _idToNamesUsingIdContainer.end() ) 
      {
         j = _idToNamesUsingIdContainer.insert(placeOfNamesContainerType::value_type(id,new list<PsName *>() ) ).first ;
      }
   assert ( (*j).second != NULL ) ;
   (*j).second->push_front( name ) ;

   unlock() ;
   //cerr<<"PsNameServerT<"<<this<<">::created called for "<<getStringAssociatedTo(id)<<" "<<name<<" of id "<<id<<" with "<<(*i).second<<" instances now and "<<(*j).second->size( )<<" registred PsNames"<< endl;
}

#ifdef _OLDALLOCATORS
template <class STLallocator >
#else
template <template <typename T> class STLallocator >
#endif
void PsNameServerT<STLallocator>::deleted(PsName::idType id, PsName * name) 
{
   //cerr<<"PsNameServerT<"<<this<<">::deleted called for "<<getStringAssociatedTo(id)<<" "<<name<<" of id "<<id;
   lock() ;

#ifdef _TYPENAMENOTIMPLICIT
   typename
#endif
   referenceCountingContainerType::iterator i = _tableNbInstances.find(id);

   assert ( i != _tableNbInstances.end() ) ; 

   //cerr<<" with "<<(*i).second<<" instances left "<<&((*i).second)<<endl;
   --(*i).second;
   
   //must remove name from _idToNamesUsingIdContainer, once
#ifdef _TYPENAMENOTIMPLICIT
   typename
#endif
   placeOfNamesContainerType::iterator j = _idToNamesUsingIdContainer.find(id);
   if ( j != _idToNamesUsingIdContainer.end() ) 
      {
         assert ((*j).second != NULL ) ; //assert because otherwise it would meen a problem has occured
         //cerr<<"PsNameServerT<"<<this<<">::deleted " <<(*j).second->size()<<" PsNames referenced"<<endl;
         list<PsName *>::iterator k = (*j).second->begin() ;
         while ( *k != name ) 
            {
               assert ( k != (*j).second->end() ) ;
               ++k ;
            }
         
         assert ( k != (*j).second->end() ) ; //assert because otherwise it would meen a problem has occured
         
         (*j).second->erase ( k ) ;
      }
   else
      {
         //there has been a problem
         assert ( false ) ;
      }
   
   //keep the string associated to id 0
   if( ( (*i).second <= 0) && ( id != 0 ) ) 
      {
         //cerr<<"PsNameServerT<"<<">::deleting "<<getStringAssociatedTo(id)<<endl;
         

         //if a string correponds, delete it
         if ( _fastStringAccessTable.find(id) != _fastStringAccessTable.end() )
            {
               _stringToIdCorrespondenceContainer.erase(_fastStringAccessTable[id]);
               _fastStringAccessTable.erase(_fastStringAccessTable.find(id));
            }

         _tableNbInstances.erase(i);
         
         assert ((*j).second != NULL ) ; //assert because otherwise it would meen a problem has occured
         delete (*j).second ;
         _idToNamesUsingIdContainer.erase (j) ;
         
         assert ( _tableNbInstances.find(id) == _tableNbInstances.end() ) ;
         
         if (id==_nextIdentifier-1) 
            {
               _nextIdentifier=_nextIdentifier-1;
            }
      }

   unlock() ;
}


#ifdef _OLDALLOCATORS
template <class STLallocator >
#else
template <template <typename T> class STLallocator >
#endif
void 
PsNameServerT<STLallocator>::lock () const 
{
   _ourDataLock.protect() ;
}


#ifdef _OLDALLOCATORS
template <class STLallocator >
#else
template <template <typename T> class STLallocator >
#endif
void PsNameServerT<STLallocator>::unlock () const 
{
   _ourDataLock.unprotect() ;
}

#ifdef _OLDALLOCATORS
template <class STLallocator >
#else
template <template <typename T> class STLallocator >
#endif
const list<PsName *> & PsNameServerT<STLallocator>::getNamesOfId (PsName::idType id) const 
{
#ifdef _TYPENAMENOTIMPLICIT
   typename
#endif
   placeOfNamesContainerType::const_iterator j = _idToNamesUsingIdContainer.find(id);

   assert ( j != _idToNamesUsingIdContainer.end() ) ; 

   assert ( (*j).second != NULL ) ;

   return *(*j).second ;
}
#endif

---