OMKNameServer.cpp

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
 *
 */
#include <OMKNameServer.h>
#include "OMKTracer.h"

using namespace std ;
using namespace OMK ;



NameServer::NameServer() 
{
        _nextIdentifier = Name::_maxReservedId + 1 ;
        _nextSystemIdentifier = 1 ;

        // keep id 0 reserved and associated to the string "Uninitialised Name"
        _tableNbInstances.insert ( referenceCountingContainerType::value_type(0, 0) );
  correspondenceContainerType::iterator i=(_stringToIdCorrespondenceContainer.insert( correspondenceContainerType::value_type( std::string( "Uninitialised Name" ), 0 ) ) ).first;
        _fastStringAccessTable.clear();
        _fastStringAccessTable.insert(std::pair<Name::idType, correspondenceContainerType::iterator>(0,i));
}

NameServer::NameServer(const NameServer::CanonicalRepresentationType * canonicalRepresentation)  
{
        for ( CanonicalRepresentationType::const_iterator i = canonicalRepresentation->begin() ;
                i != canonicalRepresentation->end() ;
                i++ )
        {
                //(*i) is < <Name::idType,std::string> , numberOfInstances> therefore
                //(*i).first.first is the id,
                //(*i).first.second is the associated string
                //(*i).second is the number of instances of OMKNames with id as id

                //first create an entry is the hash_table for the associated string
                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(std::pair<Name::idType, correspondenceContainerType::iterator>((*i).first.first,ii));      

                //then take care of keeping care of the number of copies of id in the system
                _tableNbInstances[(*i).first.first] = (*i).second ;

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

NameServer::~NameServer() 
{
        //nothing to do   
}

Name::idType 
NameServer::getIdentifier(const std::string & name) 
{
        return getIdentifierAsFrom( name, &_nextIdentifier ) ;
}

Name::idType 
NameServer::getSystemIdentifier(const std::string & name) 
{

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

        return result ;
}

Name::idType 
NameServer::getIdentifierAsFrom (const std::string & name, Name::idType * nextId ) 
{
        correspondenceContainerType::iterator i = _stringToIdCorrespondenceContainer.find( name.c_str() );

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

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

                if (i == _stringToIdCorrespondenceContainer.end() ) //we have to add name
                { 
                        std::pair<correspondenceContainerType::iterator,bool> res = _stringToIdCorrespondenceContainer.insert(correspondenceContainerType::value_type(name,*nextId)) ; 

                        _fastStringAccessTable[*nextId] = res.first ;

                        *nextId = *nextId + 1 ;

                        i = res.first ;
                }

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

const std::string& NameServer::getStringAssociatedTo (Name::idType id) const 
{
        OMASSERTM( id<_nextIdentifier, "" ) ;
        return  (*(*_fastStringAccessTable.find(id)).second).first ;
}

NameServer::CanonicalRepresentationType * 
NameServer::getCanonicalRepresentation() const 
{
        NameServer::CanonicalRepresentationType * canonicalRepresentation = new NameServer::CanonicalRepresentationType() ;
        NameServer::correspondenceContainerType::const_iterator i;
        for (i=_stringToIdCorrespondenceContainer.begin(); i!=_stringToIdCorrespondenceContainer.end();i++) 
        {
    canonicalRepresentation->push_back(CanonicalRepresentationItemType(std::pair<Name::idType,std::string>((*i).second,(*i).first),(*(_tableNbInstances.find((*i).second))).second)) ;
        }
        canonicalRepresentation->sort() ;
        return canonicalRepresentation ;
}

void NameServer::created(Name::idType id, Name * name) 
{
        //lock() ;
        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
        placeOfNamesContainerType::iterator j = _idToNamesUsingIdContainer.find(id);
        if ( j == _idToNamesUsingIdContainer.end() ) 
        {
                j = _idToNamesUsingIdContainer.insert(placeOfNamesContainerType::value_type(id,new std::list<Name *>() ) ).first ;
        }
        OMASSERTM( (*j).second != NULL, "" ) ;
        (*j).second->push_front( name ) ;

        //unlock() ;
}

void NameServer::deleted(Name::idType id, Name * name) 
{
        //lock() ;

        referenceCountingContainerType::iterator i( _tableNbInstances.find( id ) ) ;
        if ( i != _tableNbInstances.end() )
        {
                --( i->second );

                //must remove name from _idToNamesUsingIdContainer, once
                placeOfNamesContainerType::iterator j = _idToNamesUsingIdContainer.find(id);
                if ( j != _idToNamesUsingIdContainer.end() ) 
                {
                        OMASSERTM((*j).second != NULL, "a problem has occured" ) ; 
                        std::list<Name *>::iterator k = (*j).second->begin() ;
                        while ( *k != name ) 
                        {
                                OMASSERTM( k != (*j).second->end(), "" ) ;
                                ++k ;
                        }

                        OMASSERTM( k != (*j).second->end(), "a problem has occured" ) ; 

                        (*j).second->erase ( k ) ;
                }
                else
                {
                        //there has been a problem
                        OMASSERTM( false, "" ) ;
                }

                //keep the string associated to id 0
                if( ( (*i).second <= 0) && ( id != 0 ) ) 
                { 
                        //if a string correponds, delete it
                        if ( _fastStringAccessTable.find(id) != _fastStringAccessTable.end() )
                        {
                                _stringToIdCorrespondenceContainer.erase(_fastStringAccessTable[id]);
                                _fastStringAccessTable.erase(_fastStringAccessTable.find(id));
                        }

                        _tableNbInstances.erase(i);

                        OMASSERTM((*j).second != NULL, "a problem has occured" ) ;
                        delete (*j).second ;
                        _idToNamesUsingIdContainer.erase (j) ;

                        OMASSERTM( _tableNbInstances.find(id) == _tableNbInstances.end(), "" ) ;

                        if (id==_nextIdentifier-1) 
                        {
                                _nextIdentifier=_nextIdentifier-1;
                        }
                }
        }
        else
        {
                OMERROR( id ) ;
        }

        //unlock() ;
}

const std::list<Name *> & NameServer::getNamesOfId (Name::idType id) const 
{
        placeOfNamesContainerType::const_iterator j = _idToNamesUsingIdContainer.find(id);

        OMASSERTM( j != _idToNamesUsingIdContainer.end(), "" ) ; 

        OMASSERTM( (*j).second != NULL, "" ) ;

        return *(*j).second ;
}


bool OMK::operator == (const NameServer & source1, const NameServer & source2) 
{
   NameServer::CanonicalRepresentationType * canonicalRepresentation1 = source1.getCanonicalRepresentation() ;
   NameServer::CanonicalRepresentationType * canonicalRepresentation2 = source2.getCanonicalRepresentation() ;
   bool resul = *canonicalRepresentation1 == *canonicalRepresentation2 ;
   delete canonicalRepresentation1 ;
   delete canonicalRepresentation2 ;
   return resul ;
}



bool NameServer::includes (const NameServer & otherNameServer ) 
{
  OMTRACEID( OMK_DEBUG_OMK_NAME, "NameServer::includes" ) ;
  NameServer::CanonicalRepresentationType * canonicalRepresentation1 = otherNameServer.getCanonicalRepresentation() ;
  NameServer::CanonicalRepresentationType * canonicalRepresentation2 = getCanonicalRepresentation() ;
  NameServer::CanonicalRepresentationType::const_iterator iter1 = canonicalRepresentation1->begin() ;
  NameServer::CanonicalRepresentationType::const_iterator iter2 = canonicalRepresentation2->begin() ;
  bool noMissingPairFound = true ;
  bool found ;
  while ( noMissingPairFound && ( iter1 != canonicalRepresentation1->end() ) )
  {
    // make sure (*iter1).first is in canonicalRepresentation2
    OMTRACEID( OMK_DEBUG_OMK_NAME, "looking for <" <<(*iter1).first.first << "," << (*iter1).first.second<< ">" ) ;
    found = false ;
    while ( (iter2 != canonicalRepresentation2->end()) && !found )
    {
      OMTRACEID( OMK_DEBUG_OMK_NAME, "examined <"<<(*iter2).first.first<<","<<(*iter2).first.second<<"> " ) ;
      if ( (*iter2).first == (*iter1).first )
      {
        OMTRACEID( OMK_DEBUG_OMK_NAME, "identic" ) ;
        found = true ;
      }
      ++iter2 ;
    }
    if ( ( iter2 == canonicalRepresentation2->end() ) && !found )
    {
      noMissingPairFound = false ;
#if !defined NDEBUG
      std::ostringstream msg ;
      msg << "<"<<(*iter1).first.first<<","<<(*iter1).first.second<<"> not found in " ;
      otherNameServer.printToStream( msg, " " );
      OMTRACEID( OMK_DEBUG_OMK_NAME, msg.str() ) ;
#endif
    }
    else
    {
      ++iter1 ;
    }
  }
  delete canonicalRepresentation1 ;
  delete canonicalRepresentation2 ;
  return noMissingPairFound ;
}



void
NameServer::printToStream ( ostream & out , const std::string & separator) const 
{
  //lock() ;
  CanonicalRepresentationType * canonicalRepresentation = getCanonicalRepresentation() ;
  for ( CanonicalRepresentationType::const_iterator i = canonicalRepresentation->begin() ;
        i != canonicalRepresentation->end() ;
        i++ )
  {
    out << i->first.first << " " << i->first.second << " " << i->second << separator;
  } 
  out<<endl;
  delete canonicalRepresentation;
  //unlock() ;
}

void NameServer::changeNamesId ( Name * namePointer, Name::idType oldId, Name::idType newId )
{
   OMASSERTM( namePointer != NULL, "Must be a valid pointer" ) ;
   namePointer->changeId ( oldId, newId ) ;
}

---