OMKAccessibleParameterPrm.cpp

Go to the documentation of this file.

/************************************************************************/
/* This file is part of openMask(c) 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   */
/* Universite Rennes 1 for the software may use this file in            */
/* acordance with that specific license                                 */
/************************************************************************/              

#include "OMKAccessibleParameterPrm.h"
#include "OMKParametersAccessor.inl"
#include "OMKOutgoingSynchronisationMessage.h"
#include "OMKIncomingSynchronisationMessage.h"
#include "OMKSimpleTypeT.inl"
#include "OMKIConnectors.h"

using namespace OMK::Type ;
using namespace OMK::Iii ;
using namespace OMK ;
//========================================================================
// Default constructor
AccessibleParameterPrm::AccessibleParameterPrm()
: _id( OMK::Name() ),
  _category( OMK::Name() ),
  _type( OMK::Name() ),
  _accessible( false ),
  _levels(),
  _toolsInUse()
{
}

//------------------------------------------------------------------------
// Copy constructor
AccessibleParameterPrm::AccessibleParameterPrm( const AccessibleParameterPrm& ref )
{
  _copy( ref ) ;
}

//------------------------------------------------------------------------
// Constructor with the parameters
AccessibleParameterPrm::AccessibleParameterPrm( const IConnector* connector, 
                                                const AccessGroup& accessGroup ) 
: _id( connector->id() ),
  _category( connector->category() ),
  _type( connector->type() ),
  _accessible( connector->getAccessRule().isAccessGranted( accessGroup._level, accessGroup._groupName ) ),
  _levels( connector->getAccessRule().getCurrentAccessLevel() ),
  _toolsInUse( connector->getToolsInUse() )
{
}

//------------------------------------------------------------------------
// Constructor with the parameters
AccessibleParameterPrm::AccessibleParameterPrm( OMK::Name id,
                                                OMK::Name category,
                                                OMK::Name type,
                                                bool accessible,
                                                const std::map< OMK::Name, int >& levels,
                                                const std::list< OMK::Name >& toolsInUse )
: _id( id ),
  _category( category ),
  _type( type ),
  _accessible( accessible ),
  _levels( levels ),
  _toolsInUse( toolsInUse )
{
}

//------------------------------------------------------------------------
// Destructor
AccessibleParameterPrm::~AccessibleParameterPrm()
{
}

//------------------------------------------------------------------------
// copy operator
AccessibleParameterPrm& AccessibleParameterPrm::operator = ( const AccessibleParameterPrm& ref )
{
  if ( this != &ref )
  {
    _copy( ref ) ;
  }
  return *this ;
}

//------------------------------------------------------------------------
// Protected copy methods
void AccessibleParameterPrm::_copy( const AccessibleParameterPrm& ref )
{
  _id = ref._id ; 
  _category = ref._category ; 
  _type = ref._type ; 
  _accessible = ref._accessible ; 
  _levels = ref._levels ; 
  _toolsInUse = ref._toolsInUse ; 
}

//========================================================================
namespace OMK
{
namespace Type
{
//------------------------------------------------------------------------
// != operator
bool operator != ( const AccessibleParameterPrm& a0, const AccessibleParameterPrm& a1 )
{
  return a0._id != a1._id
      || a0._category != a1._category
      || a0._type != a1._type
      || a0._accessible != a1._accessible
      || a0._levels != a1._levels
      || a0._toolsInUse != a1._toolsInUse ;
}

} //namespace OMK
} //namespace Type
//========================================================================

//------------------------------------------------------------------------
// insert in stream
std::ostream& operator << ( std::ostream& out, const OMK::Type::AccessibleParameterPrm& a )
{
  out << a._id << " "
      << a._category << " "
      << a._type << " "
      << a._accessible << " "
      << a._levels << " "
      << a._toolsInUse << " "
      << " " ;
  return out ;
}

//------------------------------------------------------------------------
// extract from a 
std::istream& operator >> ( std::istream& in, OMK::Type::AccessibleParameterPrm& a )
{
  in >> a._id
     >> a._category
     >> a._type
     >> a._accessible
     >> a._levels
     >> a._toolsInUse ;
  return in ;
}

//------------------------------------------------------------------------
// insert in stream
OMK::OutgoingSynchronisationMessage& operator << ( OMK::OutgoingSynchronisationMessage& out, const OMK::Type::AccessibleParameterPrm& a )
{
  out << a._id
      << a._category
      << a._type
      << a._accessible
      << a._levels
      << a._toolsInUse ;
  return out ;
}

//------------------------------------------------------------------------
// extract from a 
OMK::IncomingSynchronisationMessage& operator >> ( OMK::IncomingSynchronisationMessage& in, OMK::Type::AccessibleParameterPrm& a )
{
  in >> a._id
     >> a._category
     >> a._type
     >> a._accessible
     >> a._levels
     >> a._toolsInUse ;
  return in ;
}

//========================================================================

//========================================================================
// ParametersAccessor specific implementation for OMK::Type::AccessibleParameterPrm.
template<>
bool OMK::ParametersAccessor::getValue< OMK::Type::AccessibleParameterPrm >
                    ( const ConfigurationParameterDescriptor * nodeValue, 
                      OMK::Type::AccessibleParameterPrm& value, 
                      std::string& errorStr )
{
  bool ok = true ;
  const OMK::MultipleConfigurationParameter *tmpNode = 
    dynamic_cast< const OMK::MultipleConfigurationParameter * >( nodeValue ) ;
  ok = ok && tmpNode ;
  if( ok ) 
  {
    bool named = tmpNode && !tmpNode->getNameOfSubDescriptor( 0 ).empty() ;
    ok = ( named || 6 <= tmpNode->getNumberOfSubItems() ) ;
    if ( !ok && errorStr.empty() )
    {
      errorStr = "Bad format of AccessibleParameterPrm which needs 6 arguments" ;
    }

    // "Id" parameter (member "_id")
    const OMK::ConfigurationParameterDescriptor *dataNode = !ok ? 0 :
      ( named ?
        tmpNode->getSubDescriptorByName( "Id" ) :
        tmpNode->getSubDescriptorByPosition( 0 ) ) ;
    ok = ok 
      && ( ( !dataNode && named ) // optional parameter if named
        || getValue( dataNode, value._id, errorStr ) ) ;

    // "Category" parameter (member "_category")
    dataNode = !ok ? 0 :
      ( named ?
        tmpNode->getSubDescriptorByName( "Category" ) :
        tmpNode->getSubDescriptorByPosition( 1 ) ) ;
    ok = ok 
      && ( ( !dataNode && named ) // optional parameter if named
        || getValue( dataNode, value._category, errorStr ) ) ;

    // "Type" parameter (member "_type")
    dataNode = !ok ? 0 :
      ( named ?
        tmpNode->getSubDescriptorByName( "Type" ) :
        tmpNode->getSubDescriptorByPosition( 2 ) ) ;
    ok = ok 
      && ( ( !dataNode && named ) // optional parameter if named
        || getValue( dataNode, value._type, errorStr ) ) ;

    // "Accessible" parameter (member "_accessible")
    dataNode = !ok ? 0 :
      ( named ?
        tmpNode->getSubDescriptorByName( "Accessible" ) :
        tmpNode->getSubDescriptorByPosition( 3 ) ) ;
    ok = ok 
      && ( ( !dataNode && named ) // optional parameter if named
        || getValue( dataNode, value._accessible, errorStr ) ) ;

    // "Levels" parameter (member "_levels")
    dataNode = !ok ? 0 :
      ( named ?
        tmpNode->getSubDescriptorByName( "Levels" ) :
        tmpNode->getSubDescriptorByPosition( 4 ) ) ;
    ok = ok 
      && ( ( !dataNode && named ) // optional parameter if named
        || getValue( dataNode, value._levels, errorStr ) ) ;

    // "ToolsInUse" parameter (member "_toolsInUse")
    dataNode = !ok ? 0 :
      ( named ?
        tmpNode->getSubDescriptorByName( "ToolsInUse" ) :
        tmpNode->getSubDescriptorByPosition( 5 ) ) ;
    ok = ok 
      && ( ( !dataNode && named ) // optional parameter if named
        || getValue( dataNode, value._toolsInUse, errorStr ) ) ;
  }
  return ok ;
}

---