behaviour_common.h

Go to the documentation of this file.

// Behaviour Control Framework - Common definitions
// Author: Philipp Allgeuer <pallgeuer@ais.uni-bonn.de>

// Ensure header is only included once
#ifndef BEHAVIOUR_COMMON_H
#define BEHAVIOUR_COMMON_H

// Includes
#include <cstddef> // For std::size_t
#include <vector>  // For std::vector
#include <string>  // For std::string
#include <sstream> // For std::ostringstream
#include <typeinfo> // For std::type_info
#include <boost/static_assert.hpp> // For BOOST_STATIC_ASSERT_MSG()
#include <boost/type_traits.hpp> // For checking template types
#include <boost/utility/enable_if.hpp> // For boost::enable_if

// Define a macro to retrieve the executing function name
#if defined(_MSC_VER) || (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 600)) || (defined(__IBMCPP__) && (__IBMCPP__ >= 500))
#define CURRENT_FUNC __FUNCTION__
#elif defined(__GNUC__) || defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901) || (defined(__ICC) && (__ICC >= 600))
#define CURRENT_FUNC __func__
#else
#define CURRENT_FUNC "<unknown>"
#endif

#define REPORT_ERROR(MBasePtr, msg)          (MBasePtr)->reportError((msg),true,CURRENT_FUNC,__FILE__,__LINE__)  
#define REPORT_ERROR_(MBase, msg)            (MBase).reportError((msg),true,CURRENT_FUNC,__FILE__,__LINE__)      
#define REPORT_WARNING(MBasePtr, msg)        (MBasePtr)->reportError((msg),false,CURRENT_FUNC,__FILE__,__LINE__) 
#define REPORT_WARNING_(MBase, msg)          (MBase).reportError((msg),false,CURRENT_FUNC,__FILE__,__LINE__)     
#define ASSERT_ERROR(cond, MBasePtr, msg)    if(!(cond)) { REPORT_ERROR((MBasePtr),msg); return; }               
#define ASSERT_ERROR_(cond, MBase, msg)      if(!(cond)) { REPORT_ERROR_((MBase),msg); return; }                 
#define ASSERT_WARNING(cond, MBasePtr, msg)  if(!(cond)) { REPORT_WARNING((MBasePtr),msg); return; }             
#define ASSERT_WARNING_(cond, MBase, msg)    if(!(cond)) { REPORT_WARNING_((MBase),msg); return; }               

// Behaviour control namespace
namespace behaviourcontrol
{
    //
    // Class declarations
    //
    class SensorManager;
    class SensorBase;
    template <class T> class Sensor;
    class ActuatorManager;
    class ActuatorBase;
    template <class T> class Actuator;
    class BehaviourManager;
    class BehaviourLayer;
    class Behaviour;

    //
    // Enumerations
    //
    enum FuncReturnID              
    {
        RET_OK = 0,                
        RET_MISC_FAILURE,          
        RET_NULL_POINTER,          
        RET_PREVIOUS_FATAL_ERROR,  
        RET_ALREADY_INITIALISED,   
        RET_BIND_FAILED_NS,        
        RET_BIND_FAILED_ANF,       
        RET_BIND_FAILED_ASI,       
        RET_INHIBITION_CYCLE       
    };

    //
    // Type definitions
    //

    typedef Sensor<bool>                 SensorBool;      
    typedef Sensor<int>                  SensorInt;       
    typedef Sensor<unsigned int>         SensorUInt;      
    typedef Sensor<long>                 SensorLong;      
    typedef Sensor<unsigned long>        SensorULong;     
    typedef Sensor<long long>            SensorLLong;     
    typedef Sensor<unsigned long long>   SensorULLong;    
    typedef Sensor<float>                SensorFloat;     
    typedef Sensor<double>               SensorDouble;    
    typedef Sensor<long double>          SensorLDouble;   

    typedef Actuator<bool>               ActuatorBool;    
    typedef Actuator<int>                ActuatorInt;     
    typedef Actuator<unsigned int>       ActuatorUInt;    
    typedef Actuator<long>               ActuatorLong;    
    typedef Actuator<unsigned long>      ActuatorULong;   
    typedef Actuator<long long>          ActuatorLLong;   
    typedef Actuator<unsigned long long> ActuatorULLong;  
    typedef Actuator<float>              ActuatorFloat;   
    typedef Actuator<double>             ActuatorDouble;  
    typedef Actuator<long double>        ActuatorLDouble; 

    typedef std::size_t index_t; 
    typedef float level_t;       
    typedef int ret_t;           

    //
    // Constants
    //
    const std::string nullString = "";    
    const level_t LVL_ACTIVE = 1.0;       
    const level_t LVL_INACTIVE = 0.0;     
    const bool AGGREGATABLE = true;       
    const bool NOT_AGGREGATABLE = false;  

    //
    // Functions
    //

    // Function: addIfUnique()
    template <class T>
    void addIfUnique(std::vector<T>& V, T& value)
    {
        // Declare variables
        bool duplicate;
        index_t i;

        // Check whether an equivalent element already exists in the vector
        duplicate = false;
        for(i = 0;i < V.size();i++)
        {
            if(V[i] == value)
            {
                duplicate = true;
                break;
            }
        }

        // Add the element to the vector if no duplicate was found
        if(!duplicate)
            V.push_back(value);
    }
}

#endif /* BEHAVIOUR_COMMON_H */
// EOF