---

PsNoRefCountingNameServer.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 PsNoRefCountingNameServerHEADER
#define PsNoRefCountingNameServerHEADER

#include "PsNameServer.h"

using namespace std ;

#ifdef _OLDALLOCATORS
template <class STLallocator >
#else
template <template <typename T> class STLallocator >
#endif
class PsNoRefCountingNameServer : public PsNameServer
{
public:
   virtual ~PsNoRefCountingNameServer() ;

   PsNoRefCountingNameServer(const PsNameServer::CanonicalRepresentationType * canonicalRepresentation) ;

   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 > correspondenceContainerType ;

   typedef map<long,correspondenceContainerType::iterator> fastStringAccessTableType;
#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;
#endif

   fastStringAccessTableType _fastStringAccessTable ;

   correspondenceContainerType _stringToIdCorrespondenceContainer ;

};


#ifdef _OLDALLOCATORS
template <class STLallocator >
#else
template <template <typename T> class STLallocator >
#endif
PsNoRefCountingNameServer<STLallocator>::PsNoRefCountingNameServer(const PsNameServer::CanonicalRepresentationType * canonicalRepresentation)  
{
   //cerr<<"PsNoRefCountingNameServer<STLallocator>:"<<this<<":PsNoRefCountingNameServer(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 in 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

         //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
PsNoRefCountingNameServer<STLallocator>::~PsNoRefCountingNameServer() 
{
   //nothing to do   
}


#ifdef _OLDALLOCATORS
template <class STLallocator >
#else
template <template <typename T> class STLallocator >
#endif
PsName::idType 
PsNoRefCountingNameServer<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 
PsNoRefCountingNameServer<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 
PsNoRefCountingNameServer<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 & 
PsNoRefCountingNameServer<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 * 
PsNoRefCountingNameServer<STLallocator>::getCanonicalRepresentation() const 
{
   PsNameServer::CanonicalRepresentationType * canonicalRepresentation = new PsNameServer::CanonicalRepresentationType () ;
#ifdef _TYPENAMENOTIMPLICIT
   typename
#endif
   PsNoRefCountingNameServer<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),1)) ;
      }
   canonicalRepresentation->sort() ;
   return canonicalRepresentation ;
}



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



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

#ifdef _OLDALLOCATORS
template <class STLallocator >
#else
template <template <typename T> class STLallocator >
#endif
void PsNoRefCountingNameServer<STLallocator>::created(PsName::idType id, PsName * name) 
{
}

#ifdef _OLDALLOCATORS
template <class STLallocator >
#else
template <template <typename T> class STLallocator >
#endif
void PsNoRefCountingNameServer<STLallocator>::deleted(PsName::idType id, PsName * name) 
{
}


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


#ifdef _OLDALLOCATORS
template <class STLallocator >
#else
template <template <typename T> class STLallocator >
#endif
void PsNoRefCountingNameServer<STLallocator>::unlock () const 
{
   _ourDataLock.unprotect() ;
}
#ifdef _OLDALLOCATORS
template <class STLallocator >
#else
template <template <typename T> class STLallocator >
#endif
const list<PsName *> & PsNoRefCountingNameServer<STLallocator>::getNamesOfId (PsName::idType id) const 
{
   static list<PsName *> emptyResult ;
   return emptyResult ;
}

#endif

---