Exploitation.h

Go to the documentation of this file.

/* Copyright (C) 2003 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 _EXPLOITATION_H_
#define _EXPLOITATION_H_

#include "ExploitationEntry.h"
#include <string>
#include <list>


namespace RobotFlow {

/**
    * 
    * \brief Exploitation contains a list of ExploitationEntr(ies) for Behavior derived classes.
    *
    * Higher intelligence modules need to know which node have produced an output at a certain iteration count.
    * The Exploitation class is responsible of "remembering" which output of a node have been used over a certain period of time.
    * 
    * \author Dominic Létourneau
    * \version $Revision: 1.6 $
    * $Date: 2005/03/29 15:20:19 $
    * \par History: 
    * $Revision: 1.6 $
    * <ul>
    *   <li>12/05/2003 Added doxygen documentation.
    *   <li>12/05/2003 Created new file ExploitationEntry.h, class extracted from Exploitation.h
    * </ul>
    */
  class Exploitation : public FD::Object {

 public:

  /** 
   * Constructor with maximum ExploitationEntry in the exploitation registery
   * 
   * \param max_element The maximum ExploitationEntry in the exploitation registery
   */
  Exploitation(int max_element = 100);

  /** 
   * Copy Constructor
   * 
   * \param cpy The Exploitation object to copy
   */
  Exploitation(const Exploitation& cpy);

   /** 
   * = operator
   * 
   * \param eq The Exploitation object to copy
   * \retval Exploitation& self reference
   */
  Exploitation &operator =(const Exploitation &eq);
  
  /** 
   * Destructor
   * 
   */
  virtual ~Exploitation();

  /** 
   * Printing object to an output stream in the Overflow format.
   * 
   * \param out The output stream to write to.
   */
  virtual void printOn(std::ostream &out=std::cout) const;

 /** 
   * 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)
   */
  void add_entry(int count, FD::Node *node, int output_id);

  /** 
   * Sets the maximum number ExploitationEntry in the registery
   *
   * \param max_element The maximum number of ExploitationEntry in the registery
   */
  void set_max_element(int max_element);

 /** 
   * Returns a reference to the list of ExloitationEntry
   * 
   * \retval list<ExploitationEntry>& The reference to the list of ExloitationEntry
   */
  std::list<ExploitationEntry> & get_exploitation(){return m_exploitation;}

 /** 
   * Get the maximum number of elements in the ExploitationEntry list
   * 
   * \retval int The maximum number of elements in the ExploitationEntry list
   */
  int get_max_element() {return m_max_element;}

 /** 
   * Get the number of ExploitationEntry in the list
   * 
   * \retval int The number of ExploitationEntry in the list
   */
  int get_size() {return m_exploitation.size();}

  /**
   Is the Exploitation object valid ?
   \retval bool the isnil flag
  */
  virtual bool isNil() const;

  void clearNilFlag();

 private:

  ///The list of ExploitationEntry (ies)
  std::list<ExploitationEntry> m_exploitation;

  ///maximum exploitation entries in the list
  int m_max_element;

  ///the isNil flag
  bool m_isNilFlag;


};

}//namespace RobotFlow

#endif

---