ColCOWS_NodeDesc.cc

//===========================================================================//
//    
//    Description: interface for user defined event handling classes
//    Filename: colcows/ColCOWS_NodeDesc .cc
//    Authors: Michael Dussere and Aurélien Esnard
//    
//===========================================================================//
//    
//    Copyright (C) 2003 INRIA and CNRS
//    
//    This library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//    
//    This library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//    
//    You should have received a copy of the GNU Lesser General Public
//    License along with this library; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//    
//===========================================================================//

#include "ColCOWS_NodeDesc.hh" 
#include "ColCOWS_Corba.hh" 

using namespace std;

__COLCOWS_BEGIN__

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

void NodeDesc::getObjectDescVec(  ExtObjectDescVec & object_desc_vec, std::string obj_id, std::string obj_kind ) const
{
  COLCOWS_IN_DEBUG( );

  for( const_iterator it = begin(); it != end(); ++it ) 
    {
      if ( ( obj_id.empty()   || (obj_id == it->second.obj_id)     ) &&
           ( obj_kind.empty() || (obj_kind == it->second.obj_kind) )    ) 
        {
          ExtObjectDesc new_desc = it->second ;
          new_desc.num_node = _num_node;
          object_desc_vec.push_back(new_desc);
        }
    }
  
  COLCOWS_OUT_DEBUG( );
  return;
}

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

void NodeDesc::convertFromIdl( const IdlNodeDesc & idl_node_desc ) 
{ 
  COLCOWS_IN_DEBUG( );

  clear();

  _node_kind = idl_node_desc.node_kind;
  _num_node = idl_node_desc.num_node;
  _max_descendant = idl_node_desc.max_descendant;
  _activated = idl_node_desc.activated;

  for(unsigned int i = 0 ; i < idl_node_desc.ref_seq.length(); ++i )
    {
      string id              = (const char *) idl_node_desc.ref_seq[i].obj_id;
      string kind            = (const char *) idl_node_desc.ref_seq[i].obj_kind;
      CORBA::Object_ptr  ref;
      idl_node_desc.ref_seq[i].obj_ref >>= CORBA::Any::to_object(ref); 

      insert(make_pair(id, ObjectDesc(id, kind, ref)));
    }

 COLCOWS_OUT_DEBUG( );
}

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

void NodeDesc::convertToIdl( IdlNodeDesc & idl_node_desc  ) const
{ 
  COLCOWS_IN_DEBUG( );

  idl_node_desc.node_kind = CORBA::string_dup( _node_kind.c_str() );
  idl_node_desc.num_node = _num_node;
  idl_node_desc.max_descendant = _max_descendant;
  idl_node_desc.activated = _activated;
  //  idl_node_desc. = ;

  idl_node_desc.ref_seq.length( size() );

  unsigned int i;
  const_iterator it;

  for( i = 0 , it = begin() ; (i < idl_node_desc.ref_seq.length()) && (it != end()); ++i , ++it )
    {
      idl_node_desc.ref_seq[i].obj_id   = CORBA::string_dup( it->second.obj_id.c_str() );
      idl_node_desc.ref_seq[i].obj_kind = CORBA::string_dup( it->second.obj_kind.c_str() );
      idl_node_desc.ref_seq[i].obj_ref <<= it->second.obj_ref;
    }

  return;
  COLCOWS_OUT_DEBUG( );
}

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

void NodeDesc::updateIdl( IdlNodeDesc & idl_node_desc ) const
{ 
  COLCOWS_IN_DEBUG( );

  COLCOWS_ASSERT( ( _node_kind == (char*)idl_node_desc.node_kind ), "Node kinds do not match" );
  COLCOWS_ASSERT( ( _num_node == idl_node_desc.num_node ), "Node numbers do not match" );
  COLCOWS_ASSERT( ( !idl_node_desc.activated ), "IDL node description is activated" );
  
  idl_node_desc.ref_seq.length( size() );

  unsigned int i;
  const_iterator it;

  for( i = 0 , it = begin() ; (i < idl_node_desc.ref_seq.length()) && (it != end()); ++i , ++it )
    {
      idl_node_desc.ref_seq[i].obj_id   = CORBA::string_dup( it->second.obj_id.c_str() );
      idl_node_desc.ref_seq[i].obj_kind = CORBA::string_dup( it->second.obj_kind.c_str() );
      idl_node_desc.ref_seq[i].obj_ref <<= it->second.obj_ref;
    }

  return;
  COLCOWS_OUT_DEBUG( );
}

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

void NodeDesc::addReference( std::string obj_id, std::string obj_kind, CORBA::Object * ref)
{
  COLCOWS_IN_DEBUG( );

  COLCOWS_ASSERT( !_activated , "Node description is activated" );
  COLCOWS_ASSERT( (find(obj_id) == end()) , "Reference " << obj_id << " already in this node description");

  insert(make_pair(obj_id, ObjectDesc(obj_id, obj_kind, ref)));

  return;
  COLCOWS_OUT_DEBUG( );
}

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

CORBA::Object * NodeDesc::getReference( std::string obj_id ) const
{
  COLCOWS_IN_DEBUG( );

  const_iterator it = find(obj_id);

  COLCOWS_ASSERT( (it != end()) , "Cannot find reference " << obj_id << " in this node description");
  
  return it->second.obj_ref;
  COLCOWS_OUT_DEBUG( );
}

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

void NodeDesc::clearReferences( )
{
  COLCOWS_IN_DEBUG( );

  COLCOWS_ASSERT( !_activated , "Node description is activated" );
  clear();

  return;
  COLCOWS_OUT_DEBUG( );
}
  
//===========================================================================//

void NodeDesc::printself( std::ostream & stream, int indent ) const
{ 
  std::string space; 
  for(int i = 0; i < indent; i++, space += COLCOWS_TAB);

  stream << space << "node kind: " << _node_kind << std::endl;
  stream << space << "num node: " << _num_node << std::endl;
  stream << space << "activated: " << boolalpha << _activated << std::endl;
  stream << space << "objects: " << std::endl;
  
  for( const_iterator it = begin(); it != end() ; ++it ) {
    stream << "-" ;
    it->second.printself(stream, indent + 1);
    stream << endl;
  }
}

//===========================================================================//
__COLCOWS_END__

// EOF

---