---

PsMultipleConfigurationParameter.cxx

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
 *
 */

#ifdef _USESSTREAM
#include <sstream>
#else
#include <strstream>
#endif

#include "PsMultipleConfigurationParameter.h"
#include "PsController.h"
#include "tokens.h"
#include "string"

#include "stdio.h"
#include "genericKernelParser.h"
#include "KernelIstreamLexer.h"
#include "DLGLexer.h"
#include "ATokenBuffer.h"
#include "ATokPtr.h"

PsMultipleConfigurationParameter::PsMultipleConfigurationParameter(const PsMultipleConfigurationParameter & orig ) :
   PsConfigurationParameterDescriptor ( orig ),
   _subDescriptors ()
{
   if (orig._associatedStringValid)
      {
         _associatedStringValid = true ;
         _associatedString= orig._associatedString ;
      }
   else 
      {
         _associatedStringValid = false ;
      }

   //reconstruct the data containers after having duplicated the subdescriptors
   FastAccessContainer::const_iterator j ;
   for (DataContainerType::const_iterator i = orig._subDescriptors.begin() ;
        i != orig._subDescriptors.end() ;
        ++i)
      {
         PsConfigurationParameterDescriptor * subdescriptorCopy = (*i).second->clone() ;
         _subDescriptors.push_back( DataContainerType::value_type( (*i).first,
                                                                  subdescriptorCopy )
                                    ) ;

         j = orig._hashtable.find ((*i).first ) ;
         if ( j != orig._hashtable.end() )
            {
               _hashtable.insert ( FastAccessContainer::value_type ( (*i).first,
                                                                     subdescriptorCopy )
                                   ) ;

            }
      }
}


PsConfigurationParameterDescriptor * PsMultipleConfigurationParameter::clone() const 
{
   return new PsMultipleConfigurationParameter( *this ) ;
}




PsMultipleConfigurationParameter::PsMultipleConfigurationParameter( ) :
   PsConfigurationParameterDescriptor (),
   _subDescriptors (),
   _associatedStringValid ( false ) 
{

}

PsMultipleConfigurationParameter::~PsMultipleConfigurationParameter() 
{
   DataContainerType::iterator i ;
   for ( i = _subDescriptors.begin() ;
         i != _subDescriptors.end() ;
         i++ )
      {
         delete i->second ;
      }
}



const string & PsMultipleConfigurationParameter::getAssociatedString () const 
{
   if ( ! _associatedStringValid ) 
      {
         string emptyString ;
         int numberOfSubItems = getNumberOfSubItems() ;
         _associatedString = "{ \n" ;
         DataContainerType::const_iterator i = _subDescriptors.begin() ;
         for ( int j = 0 ;
               j != numberOfSubItems - 1;
               ++j )
            {
               //indent the subdescriptors
               _associatedString += "   " ;
               if ( i-> first != emptyString ) 
                  {
                     _associatedString += i-> first ;
                     _associatedString += " = " ;
                  }
               _associatedString += i->second->getAssociatedString() ;
               _associatedString += ",\n" ;
               i++ ;
            }
         //print the last item
         _associatedString += "   " ;
         if ( i-> first != emptyString ) 
            {
               _associatedString += i-> first ;
               _associatedString += " = " ;
            }
         _associatedString += i->second->getAssociatedString() ;
         _associatedString += "\n" ;
         
         
         _associatedString += "}" ;
      }
   _associatedStringValid = true ; 
   return _associatedString ;
} 


void PsMultipleConfigurationParameter::printToStream (ostream & out, int offset ) const 
{
   string emptyString ;
   int numberOfSubItems = getNumberOfSubItems() ;

   DataContainerType::const_iterator i = _subDescriptors.begin() ;
   if ( i != _subDescriptors.end () ) 
      {
         bool inList ;
         if ( i->first == emptyString )
            {
               if ( ! _hashtable.empty() )
                  {
                     out<<endl;
                     printTabToStream(out,offset) ;
                     out << "{"  ;
                     out<<endl;
                     printTabToStream(out,offset+2) ;
                  }
               out << "[ " ;
               inList = true ;
            }
         else
            {
               out<<endl;
               printTabToStream(out,offset) ;
               out << "{"  ;
               inList = false ;
            }
         
         for ( int j = 0 ;
               j != numberOfSubItems ;
               ++j )
            {
               //at each step, if not printing a list of unamed values, new line has just been inserted
               if ( inList ) 
                  {
                     if ( i-> first != emptyString ) 
                        {
                           // the list was finished by the preceeding value
                           out << "]" ;
                           inList = false ;
                           out<<endl;
                           printTabToStream (out, offset + 2 ) ;
                           out<< i->first <<" ";
                           i->second->printToStream (out, offset + 2  ) ;
                        }
                     else 
                        {
                           i->second->printToStream (out, offset + 4  ) ;
                           out<<" ";
                        }
                  }
               else 
                  {
                     if ( i-> first == emptyString )
                        {
                           //starting a list
                           out << "[ " ;
                           inList = true ;
                           i->second->printToStream (out, offset + 4  ) ;
                           out<<" ";
                        }
                     else
                        {
                           out << endl ;
                           printTabToStream (out, offset + 2 ) ;
                           out<< i->first <<" " ;
                           i->second->printToStream (out, offset + 4  ) ;
                        }
                  }
               i++ ;
            }
         if (inList)
            {
               out<<"]";
               if ( ! _hashtable.empty() )
                  {
                     out<<endl;
                     printTabToStream (out, offset ) ;
                     out<<"}";
                  }
            }
         else
            {
               out<<endl;
               printTabToStream (out, offset ) ;
               out<<"}";
            }
      }
   else 
      {
         out<<" - undefined - ";
      }
}



const PsConfigurationParameterDescriptor * PsMultipleConfigurationParameter::getSubDescriptorByName (const string & descriptorName ) const 
{
   PsConfigurationParameterDescriptor * result = NULL ;
   FastAccessContainer::const_iterator i ;
   i = _hashtable.find (descriptorName) ;
   if ( i != _hashtable.end() )
      {
         result = i->second ;
         assert ( result != NULL ) ;
      }
   else
      {
        result = NULL ;
      }
   return result ;
}


PsConfigurationParameterDescriptor * PsMultipleConfigurationParameter::getSubDescriptorByName (const string & descriptorName )
{
   PsConfigurationParameterDescriptor * result = NULL ;
   FastAccessContainer::const_iterator i ;
   i = _hashtable.find (descriptorName) ;
   if ( i != _hashtable.end() )
      {
         result = i->second ;
         assert ( result != NULL ) ;
      }
   else
      {
        result = NULL ;
      }
   return result ;
}



const PsConfigurationParameterDescriptor * PsMultipleConfigurationParameter::getSubDescriptorByPosition (int descriptorPosition) const 
{
   if (descriptorPosition >= _subDescriptors.size() ) 
      {
         return NULL ;
      }
   else
      {
         assert ( _subDescriptors[descriptorPosition].second != NULL ) ;
         return _subDescriptors[descriptorPosition].second ;
      }
}

const string & PsMultipleConfigurationParameter::getNameOfSubDescriptor (int descriptorPosition) const 
{
   assert (descriptorPosition < _subDescriptors.size() )  ;
   return _subDescriptors[descriptorPosition].first ;
}


PsConfigurationParameterDescriptor * PsMultipleConfigurationParameter::getSubDescriptorByPosition (int descriptorPosition) 
{
   if (descriptorPosition >= _subDescriptors.size() ) 
      {
         return NULL ;
      }
   else
      {
         assert ( _subDescriptors[descriptorPosition].second != NULL ) ;
         return _subDescriptors[descriptorPosition].second ;
      }
}



int PsMultipleConfigurationParameter::getNumberOfSubItems () const 
{
   return _subDescriptors.size() ;
}



int PsMultipleConfigurationParameter::appendSubDescriptor(PsConfigurationParameterDescriptor * subDescriptor ) 
{
   assert ( subDescriptor != NULL ) ;
   _subDescriptors.push_back ( DataContainedType ( string() ,subDescriptor ) ) ;
   return _subDescriptors.size() - 1 ;
}



int PsMultipleConfigurationParameter::appendSubDescriptorNamed (const string & descriptorName, PsConfigurationParameterDescriptor * subDescriptor ) 
{
   assert ( subDescriptor != NULL ) ;
   pair<FastAccessContainer::iterator ,bool > result = _hashtable.insert( FastAccessContainer::value_type(descriptorName, subDescriptor) ) ;
   // only add the sub descriptor if no subsdescriptor with the same name was allready added
   if (result.second)
      {
         _subDescriptors.push_back ( DataContainedType ( descriptorName, subDescriptor ) ) ;
      }
   else
      {
         replaceSubDescriptorNamed ( descriptorName, subDescriptor ) ;
      }
   return _subDescriptors.size() - 1 ;
}


int PsMultipleConfigurationParameter::appendSubDescriptorsOf (const PsMultipleConfigurationParameter & otherDescriptor)
{
   if ( _hashtable.size() == 0 )
      {
         *this = otherDescriptor ;
      }
   else
      {
         string emptyString ; 
         for ( DataContainerType::const_iterator i = otherDescriptor._subDescriptors.begin() ;
               i != otherDescriptor._subDescriptors.end() ;
               ++i)
            {
               //_subDescriptors.push_back ( *i ) ;
               if ( (*i).first != emptyString )
                  {
                     PsConfigurationParameterDescriptor * existingDescriptor = getSubDescriptorByName ((*i).first) ;
                     if ( existingDescriptor == NULL )
                        {
                           PsConfigurationParameterDescriptor * newDescriptor =  (*i).second->clone() ;
                           
                           _hashtable.insert( FastAccessContainer::value_type ( (*i).first , newDescriptor ) ) ;
                           
                           _subDescriptors.push_back( DataContainedType((*i).first,newDescriptor) ) ;   
                        }
                     else
                        {
#ifdef _USESSTREAM
                           ostringstream warningMessage ;
#else                
                           ostrstream warningMessage ;
#endif
                           warningMessage << "While merging two PsMultipleConfigurationParameter: "
                                          <<"2 subdescriptors named "<<(*i).first<<" found: ";
                           
                           PsMultipleConfigurationParameter * originalDescriptor ;
                           originalDescriptor = dynamic_cast<PsMultipleConfigurationParameter * > (existingDescriptor) ;
                           PsMultipleConfigurationParameter * appendedDescriptor ;
                           appendedDescriptor = dynamic_cast<PsMultipleConfigurationParameter * > ((*i).second) ;
                           if ( (originalDescriptor != NULL) &&
                                (appendedDescriptor != NULL) )
                              {
                                 if ( originalDescriptor->_hashtable.size() == 0 )
                                    {
                                       //it is a list of values, replace
                                       replaceSubDescriptorNamed ((*i).first, appendedDescriptor) ;
                                    }
                                 else
                                    {
                                       originalDescriptor->appendSubDescriptorsOf ( *appendedDescriptor ) ; 
                                    }
                              }
                           else 
                              {
                                 _hashtable.erase ( (*i).first ) ;      
                                 
                                 //find (*i).first in the vector
                                 DataContainerType::iterator j = _subDescriptors.begin() ;
                                 
                                 //(*i).first should be present in the vector
                                 assert ( j != _subDescriptors.end() );
                                 while ( (*j).first != (*i).first )
                              {
                                 ++j ;
                                 assert ( j != _subDescriptors.end() );
                              }
                                 
                                 PsConfigurationParameterDescriptor * newDescriptor =  (*i).second->clone() ;
                                 
                                 _hashtable.insert( FastAccessContainer::value_type ( (*i).first , newDescriptor ) ) ;

                                 (*j).second = newDescriptor ;
                                 
                                 warningMessage<<"Replaced original value: that was "<<existingDescriptor->getAssociatedString() ;
                                 assert ( existingDescriptor != NULL ) ;
                                 delete existingDescriptor ;
                              }
#ifdef _USESSTREAM
                           PsController::warning (warningMessage.str(), PsController::AllWarnings) ;
#else
                           warningMessage.put('\0') ;
                           PsController::warning (warningMessage.str(), PsController::AllWarnings) ;
                           delete warningMessage.str() ;
#endif
                        }
                  }
            }
      }
   return _subDescriptors.size() - 1 ;
}



int PsMultipleConfigurationParameter::replaceSubDescriptorNamed (const string & descriptorName, PsConfigurationParameterDescriptor * subDescriptor)
{
   FastAccessContainer::iterator i ;
   i = _hashtable.find (descriptorName) ;
   if ( i == _hashtable.end() ) 
      {
         return appendSubDescriptorNamed ( descriptorName, subDescriptor) ;
      }
   else 
      {
         int result = 0 ;

         //find descriptorName in the vector
         DataContainerType::iterator j = _subDescriptors.begin() ;

         //It should be present
         assert ( j != _subDescriptors.end() );

         while ( (*j).first != descriptorName )
            {
               ++j ;
               ++result ;
               //descriptorName should be present
               assert ( j != _subDescriptors.end() );
            }
         
         //delete the old descriptor
         delete (*i).second ;
         
         //replace it
         (*i).second = subDescriptor ;
         (*j).second = subDescriptor ;

         assert (_subDescriptors[result].second == subDescriptor) ;
         return result ;
      }
}


int PsMultipleConfigurationParameter::replaceSubDescriptor (int position, PsConfigurationParameterDescriptor * subDescriptor) 
{
   assert (position < _subDescriptors.size() ) ;
   string descriptorName = _subDescriptors[position].first ;
   string emptyString ;
   PsConfigurationParameterDescriptor * replacedDescription = _subDescriptors[position].second ;

   if ( descriptorName != emptyString ) 
      {
         FastAccessContainer::iterator i ;
         i = _hashtable.find (descriptorName) ;
  
         //the descriptor should be present in the hash table
         assert ( i != _hashtable.end() ) ;
         (*i).second = subDescriptor ;
      }
   delete replacedDescription ; 
   _subDescriptors[position].second = subDescriptor ;    
   return position ;
}



void PsMultipleConfigurationParameter::pack ( PsOutgoingSynchronisationMessage & out) const
{
#ifdef _USESSTREAM
   ostringstream char_out ;
   printToStream ( char_out, 0 ) ;
   out<<char_out.str() ;
#else
   ostrstream char_out ;
   printToStream ( char_out, 0 ) ;
   char_out.put ('\0') ;
   char * C_string = char_out.str() ;
   assert (C_string[char_out.pcount()-1] == '\0') ;
   out<<char_out.pcount() ;
   out<<C_string;
   delete C_string ;
#endif
}

void PsMultipleConfigurationParameter::unpack ( PsIncomingSynchronisationMessage & in)
{
   _hashtable.clear () ;
   _subDescriptors.clear () ;

   int messageSize ;

#ifdef _USESSTREAM
   string messageBuffer ;
   in>>messageBuffer ;
   istringstream message ( messageBuffer ) ;
#else
   in>>messageSize ;
   char * messageBuffer = new char [messageSize + 1];
   in>>messageBuffer ;

   assert (messageBuffer[messageSize] == '\0' ) ; 

   istrstream message ( messageBuffer );
#endif
   extract (message ) ;
   
//     //this doesn't work, because a IncomingSynchronisationMessage dosn't known the size of what has to be extracted
//     KernelIstreamLexer<PsIncomingSynchronisationMessage> inputStream (in) ;
//     DLGLexer scan( & inputStream ) ;
//     ANTLRTokenBuffer pipe ( & scan ) ;
//     ANTLRTokenPtr aToken = new ANTLRToken() ;
//     scan.setToken(mytoken(aToken)) ;
//     genericKernelParser extractor  ( &pipe ) ;
//     extractor.init() ;
//     extractor.multipleValue ( this ) ;
}

void PsMultipleConfigurationParameter::insertInStream (ostream & out) const
{
   printToStream ( out, 0 ) ;
 }

void PsMultipleConfigurationParameter::extract (istream & in)
{
   _hashtable.clear () ;
   _subDescriptors.clear () ;

   KernelIstreamLexer<istream> inputStream (in) ;
   DLGLexer scan( & inputStream ) ;
   ANTLRTokenBuffer pipe ( & scan ) ;
   ANTLRTokenPtr aToken = new ANTLRToken() ;
   scan.setToken(mytoken(aToken)) ;
   genericKernelParser extractor  ( &pipe ) ;
   extractor.init() ;
   extractor.multipleValue ( this ) ;
}

---