ExploitationEntry.h

Go to the documentation of this file.

/* Copyright (C) 2002 Dominic Letourneau (dominic.letourneau@usherbrooke.ca)

   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
*/
#ifndef _EXPLOITATIONENTRY_H_
#define _EXPLOITATIONENTRY_H_

#include "Object.h"
#include "Node.h"
#include <string>
#include <list>


namespace RobotFlow {

/**
    * 
    * \brief ExploitationEntry refers to a certain output (from a node) calculated at a certain iteration count.
    *
    * Higher intelligence modules need to know which node have produced an output at a certain iteration count.
    * ExploitationEntry contains the node, output_id and count required to process data from the exploitation mechanism.
    * 
    * \author Dominic Létourneau
    * \version $Revision: 1.3 $
    * $Date: 2005/03/29 15:20:19 $
    * \par History: 
    * $Revision: 1.3 $
    * <ul>
    *   <li>12/05/2003 Added doxygen documentation.
    *   <li>12/05/2003 Created new file ExploitationEntry.h, class extracted from Exploitation.h
    * </ul>
    */
class ExploitationEntry {

 public:

  /** 
   * Constructor with count, node, output_id args.
   * 
   * \param count The iteration count of the entry
   * \param node The node (behavior) where the exploitation occurs
   * \param output_id The output_id from the exploited node (behavior)
   */
  ExploitationEntry(int count, FD::Node *node, int output_id) 
    : m_node(node), m_count(count), m_output_id(output_id) {
    
  }

  /** 
   * Copy constructor.
   * 
   * \param cpy The ExploitationEntry to copy
   */
  ExploitationEntry (const ExploitationEntry& cpy) {
    m_node = cpy.m_node;
    m_count = cpy.m_count;
    m_output_id = cpy.m_output_id;
  }


  /** 
   * = operator between two ExploitationEntr(ies)
   * 
   * \param eqs The ExploitationEntry to copy
   * \retval ExploitationEntry & self reference
   */
  ExploitationEntry & operator= (const ExploitationEntry &eqs) {
    m_node = eqs.m_node;
    m_count = eqs.m_count;
    m_output_id = eqs.m_output_id;

    return *this;
  }
  
  /** 
   * Node accessor from the ExploitationEntry class
   * 
   * \retval Node* The node pointer corresponding to the entry
   */
  FD::Node* getNode() {return m_node;}


  /** 
   * Iteration count accessor from the ExploitationEntry class
   * 
   * \retval int The iteration count corresponding to the entry
   */
  int getCount() {return m_count;}


  /** 
   * Output ID accessor from the ExploitationEntry class
   * 
   * \retval int The output identification of corresponding to the entry (related to the node)
   */
  int getOutputID() {return m_output_id;}


  /** 
   * Printing object to an output stream in the Overflow format.
   * 
   * \param out The output stream to write to.
   */
  void printOn(std::ostream &out = std::cout) const {
    out<<"<ExploitationEntry ";
    out<<"<Node "<<m_node<<" ("<<m_node->getName()<<")"<<" >"<<std::endl;
    out<<"<Count "<<m_count<<" >"<<std::endl;
    out<<"<OutputID "<<m_output_id<<" >"<<std::endl;
    out<<" >"<<std::endl;
  }

 private:
  
  ///The node pointer where the exploitation entry is related
  FD::Node *m_node;

  ///The iteration counter where the exploitation occured 
  int m_count;

  ///The output_id of the exploitation output
  int m_output_id;

};

}//namespace RobotFlow

#endif

---