ColCOWS_WorkspaceDesc.cc

//===========================================================================//
//    
//    Description: interface for user defined event handling classes
//    Filename: colcows/ColCOWS_WorkspaceDesc .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_WorkspaceDesc.hh" 
#include "ColCOWS_Corba.hh" 

using namespace std;

__COLCOWS_BEGIN__

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

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

  unsigned int init_size = object_desc_vec.size();

  for( const_iterator it = begin(); it != end(); ++it ) 
    {
      if ( node_kind.empty() || ( it->getKind() == node_kind )) 
        {
          it->getObjectDescVec(object_desc_vec, obj_id, obj_kind );
        }
    }
  
  for( unsigned int i = init_size; i < object_desc_vec.size(); ++i )
    object_desc_vec[i].num_connection = _num_connection;

  COLCOWS_OUT_DEBUG( );
  return;
}

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

void WorkspaceDesc::convertFromIdl( const IdlWorkspaceDesc & idl_ws_desc ) 
{ 
  COLCOWS_IN_DEBUG( );

  clear();

  _ws_id = idl_ws_desc.ws_id;
  _ws_kind = idl_ws_desc.ws_kind;
  _nb_nodes = idl_ws_desc.nb_nodes;
  _activated = idl_ws_desc.activated;
  _num_connection = idl_ws_desc.num_connection;
  //  _enter_node_ref = idl_ws_desc.enter_node_ref;

  //==== Walk through the node hierarchy ===//

  const IdlNodeDesc * node_desc = &(idl_ws_desc.enter_node);
    
  stack< const IdlNodeDesc * > node_desc_stack;
  stack< unsigned long > num_child_stack;
  
  unsigned long num_child = 0;
  unsigned long current_num_node = node_desc->num_node;
  unsigned long max_descendant = node_desc->max_descendant ;  
    
  while ( max_descendant >= current_num_node ) {
    COLCOWS_DEBUG( dblTest, "passing on node " << node_desc->num_node );

    if (node_desc->num_node == current_num_node) {
     
      // node is the one i was looking for
      push_back(*node_desc);

      // increment
      current_num_node ++;
    }
      
    if (num_child < node_desc->children_seq.length()){
      // node has another child, go down
        
      node_desc_stack.push(node_desc);
      num_child_stack.push(num_child + 1);
     
      node_desc = &(node_desc->children_seq[num_child]);
      num_child = 0;
     
    }
    else if ( node_desc_stack.empty() == false) {
      // no more child, go up
     
      node_desc = node_desc_stack.top();
      num_child = num_child_stack.top();
     
      node_desc_stack.pop();
      num_child_stack.pop();
     
    }
    else if ( node_desc_stack.empty() == true) {
      // stack empty
      COLCOWS_DEBUG( dblTest, "stack empty all the tree has been run through ..." );    
      break ;
    }
    else {
      COLCOWS_DEBUG( dblWarning, "Cannot find node in the Workspace." );    
      COLCOWS_OUT_DEBUG();  
      return ;
    }
  }

  COLCOWS_OUT_DEBUG( );
}

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

unsigned long WorkspaceDesc::getNbNodes( std::string node_kind ) const
{
  COLCOWS_IN_DEBUG();

  unsigned long nb_nodes = 0;

  if ( node_kind.empty() ) {
    nb_nodes = size();
  }
  else {
    for ( const_iterator it = begin() ; it != end(); ++it )
      if ( it->getKind() == node_kind ) ++nb_nodes;
  }

  COLCOWS_OUT_DEBUG();  
  return nb_nodes;
}

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

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

  stream << space << "workspace ID: " << _ws_id << std::endl;
  stream << space << "workspace kind: " << _ws_kind << std::endl;
  stream << space << "nb nodes: " << _nb_nodes << std::endl;
  stream << space << "activated: " << boolalpha << _activated << std::endl;
  stream << space << "nodes: " << std::endl;
  
  for( const_iterator it = begin(); it != end() ; ++it ){
    stream << "+" ;
    it->printself(stream, indent+1);
    stream << endl;
  }    
}

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

__COLCOWS_END__

// EOF

---