OMKControlTakeOverPrm.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 "OMKControlTakeOverPrm.h"
#include "OMKSimulatedObject.h"
#include "OMKParametersAccessor.inl"
#include <vector>
#include <string>
#include <iostream>
using namespace OMK ;
using namespace OMK::Type ;

//========================================================================
// AccessGroup
//========================================================================

//========================================================================
// Default constructor
AccessGroup::AccessGroup()
: _groupName( "" ),
  _level( 0 )
{
}

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

//------------------------------------------------------------------------
// Constructor with the parameters
AccessGroup::AccessGroup( const Name& groupName,
                          int level )
: _groupName( groupName ),
  _level( level )
{
}

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

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

//------------------------------------------------------------------------
// Protected copy methods
void AccessGroup::_copy( const AccessGroup& ref )
{
  _groupName = ref._groupName ; 
  _level = ref._level ; 
}

//========================================================================
namespace OMK
{
namespace Type
{
//------------------------------------------------------------------------
// != operator
bool operator != ( const AccessGroup& a0, const AccessGroup& a1 )
{
  return a0._groupName != a1._groupName
      || a0._level != a1._level ;
}

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

//------------------------------------------------------------------------
// insert in stream
std::ostream& operator << ( std::ostream& out, const OMK::Type::AccessGroup& a )
{
  out << a._groupName << " "
      << a._level << " "
      << " " ;
  return out ;
}

//------------------------------------------------------------------------
// extract from a 
std::istream& operator >> ( std::istream& in, OMK::Type::AccessGroup& a )
{
  in >> a._groupName
     >> a._level ;
  return in ;
}

//------------------------------------------------------------------------
// insert in stream
OMK::OutgoingSynchronisationMessage& operator << ( OMK::OutgoingSynchronisationMessage& out, const OMK::Type::AccessGroup& a )
{
  out << a._groupName
      << a._level ;
  return out ;
}

//------------------------------------------------------------------------
// extract from a 
OMK::IncomingSynchronisationMessage& operator >> ( OMK::IncomingSynchronisationMessage& in, OMK::Type::AccessGroup& a )
{
  in >> a._groupName
     >> a._level ;
  return in ;
}

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

//========================================================================
// ParametersAccessor specific implementation for OMK::Type::AccessGroup.
template<>
bool OMK::ParametersAccessor::getValue< OMK::Type::AccessGroup >
                    ( const ConfigurationParameterDescriptor * nodeValue, 
                      OMK::Type::AccessGroup& 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 || 2 <= tmpNode->getNumberOfSubItems() ) ;
    if ( !ok && errorStr.empty() )
    {
      errorStr = "Bad format of AccessGroup which needs 2 arguments" ;
    }

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

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


//========================================================================
// TwoIdsPrm
//========================================================================

//========================================================================
// Default constructor
TwoIdsPrm::TwoIdsPrm()
: _id( OMK::Name() ),
  _secondId( OMK::Name() )
{
}

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

//------------------------------------------------------------------------
// Constructor with the parameters
TwoIdsPrm::TwoIdsPrm( OMK::Name id,
                      OMK::Name secondId )
: _id( id ),
  _secondId( secondId )
{
}

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

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

//------------------------------------------------------------------------
// Protected copy methods
void TwoIdsPrm::_copy( const TwoIdsPrm& ref )
{
  _id = ref._id ; 
  _secondId = ref._secondId ; 
}

//========================================================================
namespace OMK
{
namespace Type
{
//------------------------------------------------------------------------
// != operator
bool operator != ( const TwoIdsPrm& t0, const TwoIdsPrm& t1 )
{
  return t0._id != t1._id
      || t0._secondId != t1._secondId ;
}

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

//------------------------------------------------------------------------
// insert in stream
std::ostream& operator << ( std::ostream& out, const OMK::Type::TwoIdsPrm& t )
{
  out << t._id << " "
      << t._secondId << " "
      << " " ;
  return out ;
}

//------------------------------------------------------------------------
// extract from a 
std::istream& operator >> ( std::istream& in, OMK::Type::TwoIdsPrm& t )
{
  in >> t._id
     >> t._secondId ;
  return in ;
}

//------------------------------------------------------------------------
// insert in stream
OMK::OutgoingSynchronisationMessage& operator << ( OMK::OutgoingSynchronisationMessage& out, const OMK::Type::TwoIdsPrm& t )
{
  out << t._id
      << t._secondId ;
  return out ;
}

//------------------------------------------------------------------------
// extract from a 
OMK::IncomingSynchronisationMessage& operator >> ( OMK::IncomingSynchronisationMessage& in, OMK::Type::TwoIdsPrm& t )
{
  in >> t._id
     >> t._secondId ;
  return in ;
}

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

//========================================================================
// ParametersAccessor specific implementation for OMK::Type::TwoIdsPrm.
template<>
bool OMK::ParametersAccessor::getValue< OMK::Type::TwoIdsPrm >
                    ( const ConfigurationParameterDescriptor * nodeValue, 
                      OMK::Type::TwoIdsPrm& 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 || 2 <= tmpNode->getNumberOfSubItems() ) ;
    if ( !ok && errorStr.empty() )
    {
      errorStr = "Bad format of TwoIdsPrm which needs 2 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 ) ) ;

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



//========================================================================
// ControlTakeOverPrm
//========================================================================

//========================================================================
// Default constructor
ControlTakeOverPrm::ControlTakeOverPrm()
: OMK::Type::TwoIdsPrm(),
  _accessGroup()
{
}

//------------------------------------------------------------------------
// Copy constructor
ControlTakeOverPrm::ControlTakeOverPrm( const ControlTakeOverPrm& ref )
: OMK::Type::TwoIdsPrm(),
  _accessGroup()
{
  _copy( ref ) ;
}

//------------------------------------------------------------------------
// Constructor with the parameters
ControlTakeOverPrm::ControlTakeOverPrm( const Name& id, const Name& secondId )
: OMK::Type::TwoIdsPrm( id, secondId ),
  _accessGroup()
{
}

//------------------------------------------------------------------------
// Constructor with the parameters
ControlTakeOverPrm::ControlTakeOverPrm( const Name& id, const Name& secondId,
                                        const AccessGroupLevel& accessGroup )
: OMK::Type::TwoIdsPrm( id, secondId ),
  _accessGroup( accessGroup )
{
}

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

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

//------------------------------------------------------------------------
// Protected copy methods
void ControlTakeOverPrm::_copy( const ControlTakeOverPrm& ref )
{
  OMK::Type::TwoIdsPrm::_copy( ref ) ;
  _accessGroup = ref._accessGroup ; 
}

//========================================================================
namespace OMK
{
namespace Type
{
//------------------------------------------------------------------------
// != operator
bool operator != ( const ControlTakeOverPrm& c0, const ControlTakeOverPrm& c1 )
{
  return (OMK::Type::TwoIdsPrm)c0 != (OMK::Type::TwoIdsPrm)c1
      || c0._accessGroup != c1._accessGroup ;
}

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

//------------------------------------------------------------------------
// insert in stream
std::ostream& operator << ( std::ostream& out, const OMK::Type::ControlTakeOverPrm& c )
{
  out << (OMK::Type::TwoIdsPrm)c
      << c._accessGroup << " "
      << " " ;
  return out ;
}

//------------------------------------------------------------------------
// extract from a 
std::istream& operator >> ( std::istream& in, OMK::Type::ControlTakeOverPrm& c )
{
  in >> (OMK::Type::TwoIdsPrm&)c
     >> c._accessGroup ;
  return in ;
}

//------------------------------------------------------------------------
// insert in stream
OMK::OutgoingSynchronisationMessage& operator << ( OMK::OutgoingSynchronisationMessage& out, const OMK::Type::ControlTakeOverPrm& c )
{
  out << (OMK::Type::TwoIdsPrm)c
      << c._accessGroup ;
  return out ;
}

//------------------------------------------------------------------------
// extract from a 
OMK::IncomingSynchronisationMessage& operator >> ( OMK::IncomingSynchronisationMessage& in, OMK::Type::ControlTakeOverPrm& c )
{
  in >> (OMK::Type::TwoIdsPrm&)c
     >> c._accessGroup ;
  return in ;
}

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

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

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

---