OMKMultipleConfigurationParameter.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 <sstream>

#include "OMKTracer.h"
#include "OMKMultipleConfigurationParameter.h"
#include "OMKBaseType.h"
#include "OMKtokens.h"
#include "string"

#include "stdio.h"
#include "OMKgenericKernelParser.h"
#include "OMKKernelIstreamLexer.h"
#include "OMKDLGLexer.h"
#include "ATokenBuffer.h"
#include "ATokPtr.h"
using namespace std ;
using namespace OMK ;


MultipleConfigurationParameter::MultipleConfigurationParameter(const MultipleConfigurationParameter & orig ) :
   ConfigurationParameterDescriptor ( 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)
      {
         ConfigurationParameterDescriptor * 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 ) ) ;
            }
      }
}


ConfigurationParameterDescriptor * MultipleConfigurationParameter::clone() const 
{
   return new MultipleConfigurationParameter( *this ) ;
}




MultipleConfigurationParameter::MultipleConfigurationParameter( ) :
   ConfigurationParameterDescriptor (),
   _subDescriptors (),
   _associatedStringValid ( false ) 
{

}

MultipleConfigurationParameter::~MultipleConfigurationParameter() 
{
   DataContainerType::iterator i ;
   for ( i = _subDescriptors.begin() ;
         i != _subDescriptors.end() ;
         i++ )
      {
    OMTRACEID("Deleting", i->first << " Config* ");
          if ( i->second)
      delete i->second ;
      }
}



const std::string & MultipleConfigurationParameter::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 MultipleConfigurationParameter::printToStream (ostream & out, int offset ) const 
{
   std::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 ConfigurationParameterDescriptor * MultipleConfigurationParameter::getSubDescriptorByName (const std::string & descriptorName ) const 
{
   ConfigurationParameterDescriptor * result = NULL ;
   FastAccessContainer::const_iterator i ;
   i = _hashtable.find (descriptorName) ;
   if ( i != _hashtable.end() )
      {
         result = i->second ;
         OMASSERT( result != NULL ) ;
      }
   else
      {
        result = NULL ;
      }
   return result ;
}


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



const ConfigurationParameterDescriptor * MultipleConfigurationParameter::getSubDescriptorByPosition (int descriptorPosition) const 
{
   if (((unsigned)descriptorPosition) >= _subDescriptors.size() ) 
      {
         return NULL ;
      }
   else
      {
         OMASSERT( _subDescriptors[descriptorPosition].second != NULL ) ;
         return _subDescriptors[descriptorPosition].second ;
      }
}

const std::string & MultipleConfigurationParameter::getNameOfSubDescriptor (int descriptorPosition) const 
{
   OMASSERT( ((unsigned)descriptorPosition) < _subDescriptors.size() )  ;
   return _subDescriptors[descriptorPosition].first ;
}


ConfigurationParameterDescriptor * MultipleConfigurationParameter::getSubDescriptorByPosition (int descriptorPosition) 
{
   if ( ((unsigned)descriptorPosition) >= _subDescriptors.size() ) 
      {
         return NULL ;
      }
   else
      {
         OMASSERT( _subDescriptors[descriptorPosition].second != NULL ) ;
         return _subDescriptors[descriptorPosition].second ;
      }
}



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



int MultipleConfigurationParameter::appendSubDescriptor(ConfigurationParameterDescriptor * subDescriptor ) 
{
   OMASSERT( subDescriptor != NULL ) ;
   _subDescriptors.push_back ( DataContainedType ( std::string() ,subDescriptor ) ) ;
   return _subDescriptors.size() - 1 ;
}



int MultipleConfigurationParameter::appendSubDescriptorNamed (const std::string & descriptorName, ConfigurationParameterDescriptor * subDescriptor ) 
{
   OMASSERT( 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 MultipleConfigurationParameter::appendSubDescriptorsOf (const MultipleConfigurationParameter & otherDescriptor)
{
   if ( _hashtable.size() == 0 )
      {
         *this = otherDescriptor ;
      }
   else
      {
         std::string emptyString ; 
         for ( DataContainerType::const_iterator i = otherDescriptor._subDescriptors.begin() ;
               i != otherDescriptor._subDescriptors.end() ;
               ++i)
            {
               //_subDescriptors.push_back ( *i ) ;
               if ( (*i).first != emptyString )
                  {
                     ConfigurationParameterDescriptor * existingDescriptor = getSubDescriptorByName ((*i).first) ;
                     if ( existingDescriptor == NULL )
                        {
                           ConfigurationParameterDescriptor * newDescriptor =  (*i).second->clone() ;
                           _hashtable.insert( FastAccessContainer::value_type ( (*i).first , newDescriptor ) ) ;           
                           _subDescriptors.push_back( DataContainedType((*i).first,newDescriptor) ) ;   
                        }
                     else
                        {
        ostringstream warningMessage ;
                           warningMessage << "While merging two MultipleConfigurationParameter: "
                                          <<"2 subdescriptors named "<<(*i).first<<" found: ";
                           
                           MultipleConfigurationParameter * originalDescriptor ;
                           originalDescriptor = dynamic_cast<MultipleConfigurationParameter * > (existingDescriptor) ;
                           MultipleConfigurationParameter * appendedDescriptor ;
                           appendedDescriptor = dynamic_cast<MultipleConfigurationParameter * > ((*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
                                 OMASSERT( j != _subDescriptors.end() );
                                 while ( (*j).first != (*i).first )
                              {
                                 ++j ;
                                 OMASSERT( j != _subDescriptors.end() );
                              }
                                 
                                 ConfigurationParameterDescriptor * newDescriptor =  (*i).second->clone() ;
                                 
                                 _hashtable.insert( FastAccessContainer::value_type ( (*i).first , newDescriptor ) ) ;

                                 (*j).second = newDescriptor ;
                                 
                                 warningMessage<<"Replaced original value: that was "<<existingDescriptor->getAssociatedString() ;
                                 OMASSERT( existingDescriptor != NULL ) ;
                                 delete existingDescriptor ;
                              }
          OMTRACEID( OMK_DEBUG_OMK_OBJ, warningMessage.str() ) ;
                        }
                  }
            }
      }
   return _subDescriptors.size() - 1 ;
}



int MultipleConfigurationParameter::replaceSubDescriptorNamed (const std::string & descriptorName, ConfigurationParameterDescriptor * 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
         OMASSERT( j != _subDescriptors.end() );

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

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


int MultipleConfigurationParameter::replaceSubDescriptor (int position, ConfigurationParameterDescriptor * subDescriptor) 
{
   OMASSERT( ((unsigned)position) < _subDescriptors.size() ) ;
   std::string descriptorName = _subDescriptors[position].first ;
   std::string emptyString ;
   ConfigurationParameterDescriptor * replacedDescription = _subDescriptors[position].second ;

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



void MultipleConfigurationParameter::pack ( OutgoingSynchronisationMessage & out) const
{
   ostringstream char_out ;
   printToStream ( char_out, 0 ) ;
   out << char_out.str() ;
}

void MultipleConfigurationParameter::unpack ( IncomingSynchronisationMessage & in)
{
   _hashtable.clear () ;
   _subDescriptors.clear () ;

   string messageBuffer ;
   in >> messageBuffer ;
   istringstream message ( messageBuffer ) ;
   extract (message ) ;
   
//     //this doesn't work, because a IncomingSynchronisationMessage dosn't known the size of what has to be extracted
//     KernelIstreamLexer<IncomingSynchronisationMessage> 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 MultipleConfigurationParameter::insertInStream (ostream & out) const
{
   printToStream ( out, 0 ) ;
 }

void MultipleConfigurationParameter::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 ) ;
}

---