Behavior.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 _BEHAVIOR_H_
#define _BEHAVIOR_H_

#include "BufferedNode.h"
#include "Exploitation.h"
//#include <vector>
#include "Vector.h"
#include <string>


namespace RobotFlow {

//The Sub classes must always contain in the input/output overflow toolbox definitions :

/*
 *
 * @input_name ACTIVATED
 * @input_description No description available
 *
 * @output_name EXPLOITATION
 * @output_description No description available
 *
*/

/**
    * 
    * \brief Behavior base class, every behavior should derive from this class.
    *
    * This class offers basic functionnality that every behavior should have. This class takes care to 
    * update the exploitation value and verifies if the Behavior is activated before
    * calling calculate_behavior method. Users should always provide the input/output/parameters overflow description
    * at the beginning of the class as usual Overflow nodes. Also, a Behavior should always register itself with the
    * REGISTER_BEHAVIOR(BehaviorClassName) macro.
    * 
    * 
    * \author Dominic Létourneau
    * \version $Revision: 1.7 $
    * \date $Date: 2005/03/29 15:20:18 $
    * \par History: 
    * version $Revision: 1.7 $
    * <ul>
    *   <li>07/05/2003 Added doxygen documentation.
    *   <li>07/05/2003 Fixed member variable names with m_
    * </ul>
    */
class Behavior : public FD::BufferedNode {

 public:

  /** 
   * Constructor, called from the overflow core modules.
   *
   * \param nodeName The name (alias) given to the node by the overflow core modules.
   * \param params Parameters passed to the node for its construction.
   * \param BehaviorName The behavior name should be the name of the class. 
   * Every behavior should have a different name.
   */
   Behavior(std::string nodeName, FD::ParameterSet params, std::string BehaviorName);

  /** 
   * This function is required by the BufferedNode class. That's the core
   * processing function called by the overflow engine. This function takes care to 
   * update the exploitation value and verifies if the Behavior is activated before
   * calling calculate_behavior.
   * 
   * \param output_id The output identification we are interested in.
   * \param count The iteration number we are calculating.
   * \param out The output buffer where th put the result.
   */
   virtual void calculate(int output_id, int count, FD::Buffer &out);

  /** 
   * calculate_behavior is a pure virtual function. It should be implemented in
   * every derived class. Processing of the behaviors is done inside this function.
   * 
   * \param output_id The output identification we are interested in.
   * \param count The iteration number we are calculating.
   * \param out The output buffer where th put the result.
   */
   virtual void calculate_behavior(int output_id, int count, FD::Buffer &out) = 0;

  /** 
   * This function is called by the REGISTER_BEHAVIOR macro. It should not be called
   * from anything else.
   * 
   * \param name The name of the behavior we want to register.
   * \retval int The identification number of the new behavior.
   */
  static int register_behavior(const std::string &name);

  /**
   * Translation of the behavior name into the behavior identification number.
   *
   * \param name The behavior name that we are looking for.
   * \retval int the behavior identification number.
   */
  static int find_behavior(const std::string &name);

  /**
   * Verifies if a behavior is registered.
   *
   * \param name The behavior name that we are looking for.
   * \retval bool Returns true if the behavior name is registered, else returns false.
   */
  static bool behavior_exists(const std::string &name);


  /**
   * Returns the number of registered behaviors.
   *
   * \retval int The number of registered behaviors.
   */
  static int get_behavior_size() {return get_behaviors().size();}

  /**
   * Returns the data structure containing the registered behavior names. This function should not be used by derived classes.
   *
   * \retval std::vector<std::string>& The data structure containing the registered behavior names.
   */
  static FD::Vector<std::string>& get_behaviors();

  /**
   * Remove the behavior
   *
   * \param name The behavior name that we want remove
   */
  static void remove_behavior(const std::string &name);

  /**
   * Get the behavior id
   *
   * \retval int The behavior id
   */
  int get_behavior_id();

 protected:

  /** activation vector or bool input */
  int m_activationID;

  /** exploitation output */
  int m_exploitationID;

  /** last exploitation output id */
  int m_last_exploitation;

  /** behavior identification number */
  int m_behaviorID;

  /** last exploitation value */
  FD::ObjectRef m_exploitationValue;

};

/**
This macro is useful to automatically register a behavior when the dynamic library is opened. The static integer
dummy_behavior_initializer_for_??? (??? = NodeTypeName = class name) is initialized by calling the Behavior::register_behavior function.
If this macro is not called, behavior will be unknown by the system.
*/
#define REGISTER_BEHAVIOR(NodeTypeName) int dummy_behavior_initializer_for ## NodeTypeName = \
               Behavior::register_behavior (# NodeTypeName);



}//namespace RobotFlow

#endif

---