guwhiteboardtypelist_generated.h

Go to the documentation of this file.

 
#ifndef WB_GUWHITEBOARDTYPELIST_GENERATED_H
#define WB_GUWHITEBOARDTYPELIST_GENERATED_H
 
#include "guWhiteboard_gugenericwhiteboardobject.h"
 
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wpadded"
#pragma clang diagnostic ignored "-Wc++98-compat"
 
#undef CPP_WHITEBOARD_NAMESPACE
#define CPP_WHITEBOARD_NAMESPACE guWhiteboard
 
extern "C"
{
#include "guwhiteboardtypelist_c_generated.h"
}
 
namespace guWhiteboard {
 
 
typedef ::wb_types wb_types;
 
typedef wb_types WBTypes;
 
 
    class wb_reserved_SubscribeToAllTypes_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        wb_reserved_SubscribeToAllTypes_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_wb_reserved_SubscribeToAllTypes_v, true) {}
wb_reserved_SubscribeToAllTypes_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_wb_reserved_SubscribeToAllTypes_v, wbd, true) {}
 
        static const wb_types slot = kwb_wb_reserved_SubscribeToAllTypes_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[wb_reserved_SubscribeToAllTypes_t::slot];
        }
    };
 
    class Print_t: public  wb_generic_whiteboard_object<std::string > {
        public: 
        Print_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<std::string >(wbd, kwb_Print_v, true) {}
Print_t(std::string value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<std::string >(value, kwb_Print_v, wbd, true) {}
 
        static const wb_types slot = kwb_Print_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Print_t::slot];
        }
    };
 
    class Say_t: public  wb_generic_whiteboard_object<std::string > {
        public: 
        Say_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<std::string >(wbd, kwb_Say_v, true) {}
Say_t(std::string value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<std::string >(value, kwb_Say_v, wbd, true) {}
 
        static const wb_types slot = kwb_Say_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Say_t::slot];
        }
    };
 
    class Speech_t: public  wb_generic_whiteboard_object<std::string > {
        public: 
        Speech_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<std::string >(wbd, kwb_Speech_v, true) {}
Speech_t(std::string value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<std::string >(value, kwb_Speech_v, wbd, true) {}
 
        static const wb_types slot = kwb_Speech_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Speech_t::slot];
        }
    };
 
    class QSay_t: public  wb_generic_whiteboard_object<std::string > {
        public: 
        QSay_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<std::string >(wbd, kwb_QSay_v, true) {}
QSay_t(std::string value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<std::string >(value, kwb_QSay_v, wbd, true) {}
 
        static const wb_types slot = kwb_QSay_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[QSay_t::slot];
        }
    };
 
    class QSpeech_t: public  wb_generic_whiteboard_object<std::string > {
        public: 
        QSpeech_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<std::string >(wbd, kwb_QSpeech_v, true) {}
QSpeech_t(std::string value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<std::string >(value, kwb_QSpeech_v, wbd, true) {}
 
        static const wb_types slot = kwb_QSpeech_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[QSpeech_t::slot];
        }
    };
 
    class SpeechOutput_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        SpeechOutput_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_SpeechOutput_v, false) {}
SpeechOutput_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_SpeechOutput_v, wbd, false) {}
 
        static const wb_types slot = kwb_SpeechOutput_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[SpeechOutput_t::slot];
        }
    };
 
    class GCGameState_t: public  wb_generic_whiteboard_object<class GCGameState > {
        public: 
        GCGameState_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class GCGameState >(wbd, kwb_GCGameState_v, false) {}
        
 
        static const wb_types slot = kwb_GCGameState_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[GCGameState_t::slot];
        }
    };
 
    class SensorsHandSensors_t: public  wb_generic_whiteboard_object<class SensorsHandSensors > {
        public: 
        SensorsHandSensors_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class SensorsHandSensors >(wbd, kwb_SensorsHandSensors_v, false) {}
        
 
        static const wb_types slot = kwb_SensorsHandSensors_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[SensorsHandSensors_t::slot];
        }
    };
 
    class SensorsHeadSensors_t: public  wb_generic_whiteboard_object<class SensorsHeadSensors > {
        public: 
        SensorsHeadSensors_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class SensorsHeadSensors >(wbd, kwb_SensorsHeadSensors_v, false) {}
        
 
        static const wb_types slot = kwb_SensorsHeadSensors_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[SensorsHeadSensors_t::slot];
        }
    };
 
    class MOTION_Commands_t: public  wb_generic_whiteboard_object<class MOTION_Commands > {
        public: 
        MOTION_Commands_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class MOTION_Commands >(wbd, kwb_MOTION_Commands_v, false) {}
        
 
        static const wb_types slot = kwb_MOTION_Commands_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[MOTION_Commands_t::slot];
        }
    };
 
    class MOTION_Status_t: public  wb_generic_whiteboard_object<class MOTION_Status > {
        public: 
        MOTION_Status_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class MOTION_Status >(wbd, kwb_MOTION_Status_v, false) {}
        
 
        static const wb_types slot = kwb_MOTION_Status_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[MOTION_Status_t::slot];
        }
    };
 
    class HAL_HeadTarget_t: public  wb_generic_whiteboard_object<class HAL_HeadTarget > {
        public: 
        HAL_HeadTarget_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class HAL_HeadTarget >(wbd, kwb_HAL_HeadTarget_v, false) {}
        
 
        static const wb_types slot = kwb_HAL_HeadTarget_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[HAL_HeadTarget_t::slot];
        }
    };
 
    class SensorsFootSensors_t: public  wb_generic_whiteboard_object<class SensorsFootSensors > {
        public: 
        SensorsFootSensors_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class SensorsFootSensors >(wbd, kwb_SensorsFootSensors_v, false) {}
        
 
        static const wb_types slot = kwb_SensorsFootSensors_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[SensorsFootSensors_t::slot];
        }
    };
 
    class SensorsBodySensors_t: public  wb_generic_whiteboard_object<class SensorsBodySensors > {
        public: 
        SensorsBodySensors_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class SensorsBodySensors >(wbd, kwb_SensorsBodySensors_v, false) {}
        
 
        static const wb_types slot = kwb_SensorsBodySensors_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[SensorsBodySensors_t::slot];
        }
    };
 
    class SENSORSLedsSensors_t: public  wb_generic_whiteboard_object<class SENSORSLedsSensors > {
        public: 
        SENSORSLedsSensors_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class SENSORSLedsSensors >(wbd, kwb_SENSORSLedsSensors_v, false) {}
        
 
        static const wb_types slot = kwb_SENSORSLedsSensors_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[SENSORSLedsSensors_t::slot];
        }
    };
 
    class SENSORSLegJointTemps_t: public  wb_generic_whiteboard_object<class SENSORSLegJointTemps > {
        public: 
        SENSORSLegJointTemps_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class SENSORSLegJointTemps >(wbd, kwb_SENSORSLegJointTemps_v, false) {}
        
 
        static const wb_types slot = kwb_SENSORSLegJointTemps_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[SENSORSLegJointTemps_t::slot];
        }
    };
 
    class SENSORSTorsoJointTemps_t: public  wb_generic_whiteboard_object<class SENSORSTorsoJointTemps > {
        public: 
        SENSORSTorsoJointTemps_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class SENSORSTorsoJointTemps >(wbd, kwb_SENSORSTorsoJointTemps_v, false) {}
        
 
        static const wb_types slot = kwb_SENSORSTorsoJointTemps_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[SENSORSTorsoJointTemps_t::slot];
        }
    };
 
    class SENSORSLegJointSensors_t: public  wb_generic_whiteboard_object<class SENSORSLegJointSensors > {
        public: 
        SENSORSLegJointSensors_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class SENSORSLegJointSensors >(wbd, kwb_SENSORSLegJointSensors_v, false) {}
        
 
        static const wb_types slot = kwb_SENSORSLegJointSensors_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[SENSORSLegJointSensors_t::slot];
        }
    };
 
    class SENSORSTorsoJointSensors_t: public  wb_generic_whiteboard_object<class SENSORSTorsoJointSensors > {
        public: 
        SENSORSTorsoJointSensors_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class SENSORSTorsoJointSensors >(wbd, kwb_SENSORSTorsoJointSensors_v, false) {}
        
 
        static const wb_types slot = kwb_SENSORSTorsoJointSensors_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[SENSORSTorsoJointSensors_t::slot];
        }
    };
 
    class SENSORSSonarSensors_t: public  wb_generic_whiteboard_object<class SENSORSSonarSensors > {
        public: 
        SENSORSSonarSensors_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class SENSORSSonarSensors >(wbd, kwb_SENSORSSonarSensors_v, false) {}
        
 
        static const wb_types slot = kwb_SENSORSSonarSensors_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[SENSORSSonarSensors_t::slot];
        }
    };
 
    class FSM_Control_t: public  wb_generic_whiteboard_object<class FSMControlStatus > {
        public: 
        FSM_Control_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class FSMControlStatus >(wbd, kwb_FSM_Control_v, true) {}
        
 
        static const wb_types slot = kwb_FSM_Control_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[FSM_Control_t::slot];
        }
    };
 
    class FSM_Status_t: public  wb_generic_whiteboard_object<class FSMControlStatus > {
        public: 
        FSM_Status_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class FSMControlStatus >(wbd, kwb_FSM_Status_v, true) {}
        
 
        static const wb_types slot = kwb_FSM_Status_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[FSM_Status_t::slot];
        }
    };
 
    class FSM_Names_t: public  wb_generic_whiteboard_object<class FSMNames > {
        public: 
        FSM_Names_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class FSMNames >(wbd, kwb_FSM_Names_v, true) {}
        
 
        static const wb_types slot = kwb_FSM_Names_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[FSM_Names_t::slot];
        }
    };
 
    class SoloTypeExample_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        SoloTypeExample_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_SoloTypeExample_v, false) {}
SoloTypeExample_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_SoloTypeExample_v, wbd, false) {}
 
        static const wb_types slot = kwb_SoloTypeExample_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[SoloTypeExample_t::slot];
        }
    };
 
    class FilteredGoalSighting_t: public  wb_generic_whiteboard_object<class FilteredArrayOneDimObjects > {
        public: 
        FilteredGoalSighting_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class FilteredArrayOneDimObjects >(wbd, kwb_FilteredGoalSighting_v, false) {}
        
 
        static const wb_types slot = kwb_FilteredGoalSighting_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[FilteredGoalSighting_t::slot];
        }
    };
 
    class NAO_State_t: public  wb_generic_whiteboard_object<class NAO_State > {
        public: 
        NAO_State_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class NAO_State >(wbd, kwb_NAO_State_v, false) {}
        
 
        static const wb_types slot = kwb_NAO_State_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[NAO_State_t::slot];
        }
    };
 
    class UDPRN_t: public  wb_generic_whiteboard_object<class GCGameState > {
        public: 
        UDPRN_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class GCGameState >(wbd, kwb_UDPRN_v, false) {}
        
 
        static const wb_types slot = kwb_UDPRN_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[UDPRN_t::slot];
        }
    };
 
    class PlayerNumber_t: public  wb_generic_whiteboard_object<int8_t > {
        public: 
        PlayerNumber_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<int8_t >(wbd, kwb_PlayerNumber_v, false) {}
PlayerNumber_t(int8_t value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<int8_t >(value, kwb_PlayerNumber_v, wbd, false) {}
 
        static const wb_types slot = kwb_PlayerNumber_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[PlayerNumber_t::slot];
        }
    };
 
    class ManuallyPenalized_t: public  wb_generic_whiteboard_object<int8_t > {
        public: 
        ManuallyPenalized_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<int8_t >(wbd, kwb_ManuallyPenalized_v, false) {}
ManuallyPenalized_t(int8_t value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<int8_t >(value, kwb_ManuallyPenalized_v, wbd, false) {}
 
        static const wb_types slot = kwb_ManuallyPenalized_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[ManuallyPenalized_t::slot];
        }
    };
 
    class VisionControl_t: public  wb_generic_whiteboard_object<class VisionControlStatus > {
        public: 
        VisionControl_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class VisionControlStatus >(wbd, kwb_VisionControl_v, false) {}
        
 
        static const wb_types slot = kwb_VisionControl_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[VisionControl_t::slot];
        }
    };
 
    class VisionStatus_t: public  wb_generic_whiteboard_object<class VisionControlStatus > {
        public: 
        VisionStatus_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class VisionControlStatus >(wbd, kwb_VisionStatus_v, false) {}
        
 
        static const wb_types slot = kwb_VisionStatus_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[VisionStatus_t::slot];
        }
    };
 
    class FFTStatus_t: public  wb_generic_whiteboard_object<class FFTStatus > {
        public: 
        FFTStatus_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class FFTStatus >(wbd, kwb_FFTStatus_v, false) {}
        
 
        static const wb_types slot = kwb_FFTStatus_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[FFTStatus_t::slot];
        }
    };
 
    class FSOsighting_t: public  wb_generic_whiteboard_object<class FilteredArrayOneDimSonar > {
        public: 
        FSOsighting_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class FilteredArrayOneDimSonar >(wbd, kwb_FSOsighting_v, false) {}
        
 
        static const wb_types slot = kwb_FSOsighting_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[FSOsighting_t::slot];
        }
    };
 
    class TopParticles_t: public  wb_generic_whiteboard_object<class TopParticles > {
        public: 
        TopParticles_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class TopParticles >(wbd, kwb_TopParticles_v, false) {}
        
 
        static const wb_types slot = kwb_TopParticles_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[TopParticles_t::slot];
        }
    };
 
    class FilteredBallSighting_t: public  wb_generic_whiteboard_object<class FilteredArrayBallSightings > {
        public: 
        FilteredBallSighting_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class FilteredArrayBallSightings >(wbd, kwb_FilteredBallSighting_v, false) {}
        
 
        static const wb_types slot = kwb_FilteredBallSighting_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[FilteredBallSighting_t::slot];
        }
    };
 
    class PF_ControlStatus_Modes_t: public  wb_generic_whiteboard_object<int32_t > {
        public: 
        PF_ControlStatus_Modes_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<int32_t >(wbd, kwb_PF_ControlStatus_Modes_v, false) {}
PF_ControlStatus_Modes_t(int32_t value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<int32_t >(value, kwb_PF_ControlStatus_Modes_v, wbd, false) {}
 
        static const wb_types slot = kwb_PF_ControlStatus_Modes_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[PF_ControlStatus_Modes_t::slot];
        }
    };
 
    class WEBOTS_NXT_bridge_t: public  wb_generic_whiteboard_object<class WEBOTS_NXT_bridge > {
        public: 
        WEBOTS_NXT_bridge_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class WEBOTS_NXT_bridge >(wbd, kwb_WEBOTS_NXT_bridge_v, false) {}
        
 
        static const wb_types slot = kwb_WEBOTS_NXT_bridge_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[WEBOTS_NXT_bridge_t::slot];
        }
    };
 
    class WEBOTS_NXT_encoders_t: public  wb_generic_whiteboard_object<class WEBOTS_NXT_encoders > {
        public: 
        WEBOTS_NXT_encoders_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class WEBOTS_NXT_encoders >(wbd, kwb_WEBOTS_NXT_encoders_v, false) {}
        
 
        static const wb_types slot = kwb_WEBOTS_NXT_encoders_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[WEBOTS_NXT_encoders_t::slot];
        }
    };
 
    class WEBOTS_NXT_camera_t: public  wb_generic_whiteboard_object<class WEBOTS_NXT_camera > {
        public: 
        WEBOTS_NXT_camera_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class WEBOTS_NXT_camera >(wbd, kwb_WEBOTS_NXT_camera_v, false) {}
        
 
        static const wb_types slot = kwb_WEBOTS_NXT_camera_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[WEBOTS_NXT_camera_t::slot];
        }
    };
 
    class WEBOTS_NXT_walk_isRunning_t: public  wb_generic_whiteboard_object<class WEBOTS_NXT_walk_isRunning > {
        public: 
        WEBOTS_NXT_walk_isRunning_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class WEBOTS_NXT_walk_isRunning >(wbd, kwb_WEBOTS_NXT_walk_isRunning_v, false) {}
        
 
        static const wb_types slot = kwb_WEBOTS_NXT_walk_isRunning_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[WEBOTS_NXT_walk_isRunning_t::slot];
        }
    };
 
    class WEBOTS_NXT_deadReakoning_walk_t: public  wb_generic_whiteboard_object<class WEBOTS_NXT_deadReakoning_walk > {
        public: 
        WEBOTS_NXT_deadReakoning_walk_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class WEBOTS_NXT_deadReakoning_walk >(wbd, kwb_WEBOTS_NXT_deadReakoning_walk_v, false) {}
        
 
        static const wb_types slot = kwb_WEBOTS_NXT_deadReakoning_walk_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[WEBOTS_NXT_deadReakoning_walk_t::slot];
        }
    };
 
    class WEBOTS_NXT_colorLine_walk_t: public  wb_generic_whiteboard_object<class WEBOTS_NXT_colorLine_walk > {
        public: 
        WEBOTS_NXT_colorLine_walk_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class WEBOTS_NXT_colorLine_walk >(wbd, kwb_WEBOTS_NXT_colorLine_walk_v, false) {}
        
 
        static const wb_types slot = kwb_WEBOTS_NXT_colorLine_walk_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[WEBOTS_NXT_colorLine_walk_t::slot];
        }
    };
 
    class WEBOTS_NXT_gridMotions_t: public  wb_generic_whiteboard_object<class WEBOTS_NXT_gridMotions > {
        public: 
        WEBOTS_NXT_gridMotions_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class WEBOTS_NXT_gridMotions >(wbd, kwb_WEBOTS_NXT_gridMotions_v, false) {}
        
 
        static const wb_types slot = kwb_WEBOTS_NXT_gridMotions_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[WEBOTS_NXT_gridMotions_t::slot];
        }
    };
 
    class VisionBall_t: public  wb_generic_whiteboard_object<class VisionBall > {
        public: 
        VisionBall_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class VisionBall >(wbd, kwb_VisionBall_v, false) {}
        
 
        static const wb_types slot = kwb_VisionBall_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[VisionBall_t::slot];
        }
    };
 
    class VisionGoals_t: public  wb_generic_whiteboard_object<class VisionGoals > {
        public: 
        VisionGoals_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class VisionGoals >(wbd, kwb_VisionGoals_v, false) {}
        
 
        static const wb_types slot = kwb_VisionGoals_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[VisionGoals_t::slot];
        }
    };
 
    class WalkData_t: public  wb_generic_whiteboard_object<class WalkData > {
        public: 
        WalkData_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class WalkData >(wbd, kwb_WalkData_v, false) {}
        
 
        static const wb_types slot = kwb_WalkData_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[WalkData_t::slot];
        }
    };
 
    class TeleoperationControlStatus_t: public  wb_generic_whiteboard_object<class TeleoperationControlStatus > {
        public: 
        TeleoperationControlStatus_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class TeleoperationControlStatus >(wbd, kwb_TeleoperationControlStatus_v, false) {}
        
 
        static const wb_types slot = kwb_TeleoperationControlStatus_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[TeleoperationControlStatus_t::slot];
        }
    };
 
    class TeleoperationConnection_t: public  wb_generic_whiteboard_object<int8_t > {
        public: 
        TeleoperationConnection_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<int8_t >(wbd, kwb_TeleoperationConnection_v, false) {}
TeleoperationConnection_t(int8_t value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<int8_t >(value, kwb_TeleoperationConnection_v, wbd, false) {}
 
        static const wb_types slot = kwb_TeleoperationConnection_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[TeleoperationConnection_t::slot];
        }
    };
 
    class UDPWBNumber_t: public  wb_generic_whiteboard_object<int8_t > {
        public: 
        UDPWBNumber_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<int8_t >(wbd, kwb_UDPWBNumber_v, false) {}
UDPWBNumber_t(int8_t value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<int8_t >(value, kwb_UDPWBNumber_v, wbd, false) {}
 
        static const wb_types slot = kwb_UDPWBNumber_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[UDPWBNumber_t::slot];
        }
    };
 
    class WEBOTS_NXT_bumper_t: public  wb_generic_whiteboard_object<class WEBOTS_NXT_bumper > {
        public: 
        WEBOTS_NXT_bumper_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class WEBOTS_NXT_bumper >(wbd, kwb_WEBOTS_NXT_bumper_v, false) {}
        
 
        static const wb_types slot = kwb_WEBOTS_NXT_bumper_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[WEBOTS_NXT_bumper_t::slot];
        }
    };
 
    class WEBOTS_NXT_vector_bridge_t: public  wb_generic_whiteboard_object<class WEBOTS_NXT_vector_bridge > {
        public: 
        WEBOTS_NXT_vector_bridge_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class WEBOTS_NXT_vector_bridge >(wbd, kwb_WEBOTS_NXT_vector_bridge_v, false) {}
        
 
        static const wb_types slot = kwb_WEBOTS_NXT_vector_bridge_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[WEBOTS_NXT_vector_bridge_t::slot];
        }
    };
 
    class TopVisionLines_t: public  wb_generic_whiteboard_object<class VisionLines > {
        public: 
        TopVisionLines_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class VisionLines >(wbd, kwb_TopVisionLines_v, false) {}
        
 
        static const wb_types slot = kwb_TopVisionLines_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[TopVisionLines_t::slot];
        }
    };
 
    class BottomVisionLines_t: public  wb_generic_whiteboard_object<class VisionLines > {
        public: 
        BottomVisionLines_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class VisionLines >(wbd, kwb_BottomVisionLines_v, false) {}
        
 
        static const wb_types slot = kwb_BottomVisionLines_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[BottomVisionLines_t::slot];
        }
    };
 
    class DifferentialRobotStatus_t: public  wb_generic_whiteboard_object<class DifferentialRobotControlStatus > {
        public: 
        DifferentialRobotStatus_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class DifferentialRobotControlStatus >(wbd, kwb_DifferentialRobotStatus_v, false) {}
        
 
        static const wb_types slot = kwb_DifferentialRobotStatus_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[DifferentialRobotStatus_t::slot];
        }
    };
 
    class DifferentialRobotControl_t: public  wb_generic_whiteboard_object<class DifferentialRobotControlStatus > {
        public: 
        DifferentialRobotControl_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class DifferentialRobotControlStatus >(wbd, kwb_DifferentialRobotControl_v, false) {}
        
 
        static const wb_types slot = kwb_DifferentialRobotControl_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[DifferentialRobotControl_t::slot];
        }
    };
 
    class XEyesPos_t: public  wb_generic_whiteboard_object<class Point2D > {
        public: 
        XEyesPos_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class Point2D >(wbd, kwb_XEyesPos_v, true) {}
        
 
        static const wb_types slot = kwb_XEyesPos_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[XEyesPos_t::slot];
        }
    };
 
    class VisionFace_t: public  wb_generic_whiteboard_object<std::vector<int> > {
        public: 
        VisionFace_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<std::vector<int> >(wbd, kwb_VisionFace_v, true) {}
VisionFace_t(std::vector<int> value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<std::vector<int> >(value, kwb_VisionFace_v, wbd, true) {}
 
        static const wb_types slot = kwb_VisionFace_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[VisionFace_t::slot];
        }
    };
 
    class Draw_t: public  wb_generic_whiteboard_object<std::string > {
        public: 
        Draw_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<std::string >(wbd, kwb_Draw_v, true) {}
Draw_t(std::string value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<std::string >(value, kwb_Draw_v, wbd, true) {}
 
        static const wb_types slot = kwb_Draw_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Draw_t::slot];
        }
    };
 
    class FSM_States_t: public  wb_generic_whiteboard_object<class FSMState > {
        public: 
        FSM_States_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class FSMState >(wbd, kwb_FSM_States_v, true) {}
        
 
        static const wb_types slot = kwb_FSM_States_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[FSM_States_t::slot];
        }
    };
 
    class Giraff_Interface_Status_t: public  wb_generic_whiteboard_object<class Giraff_MainSerialInterface > {
        public: 
        Giraff_Interface_Status_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class Giraff_MainSerialInterface >(wbd, kwb_Giraff_Interface_Status_v, false) {}
        
 
        static const wb_types slot = kwb_Giraff_Interface_Status_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Giraff_Interface_Status_t::slot];
        }
    };
 
    class Giraff_Interface_Command_t: public  wb_generic_whiteboard_object<class Giraff_MainSerialInterface > {
        public: 
        Giraff_Interface_Command_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class Giraff_MainSerialInterface >(wbd, kwb_Giraff_Interface_Command_v, false) {}
        
 
        static const wb_types slot = kwb_Giraff_Interface_Command_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Giraff_Interface_Command_t::slot];
        }
    };
 
    class NXT_Status_t: public  wb_generic_whiteboard_object<class NXT_Interface > {
        public: 
        NXT_Status_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class NXT_Interface >(wbd, kwb_NXT_Status_v, false) {}
        
 
        static const wb_types slot = kwb_NXT_Status_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[NXT_Status_t::slot];
        }
    };
 
    class NXT_Command_t: public  wb_generic_whiteboard_object<class NXT_Interface > {
        public: 
        NXT_Command_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class NXT_Interface >(wbd, kwb_NXT_Command_v, false) {}
        
 
        static const wb_types slot = kwb_NXT_Command_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[NXT_Command_t::slot];
        }
    };
 
    class APM_Status_t: public  wb_generic_whiteboard_object<class APM_Interface > {
        public: 
        APM_Status_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class APM_Interface >(wbd, kwb_APM_Status_v, false) {}
        
 
        static const wb_types slot = kwb_APM_Status_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[APM_Status_t::slot];
        }
    };
 
    class APM_Command_t: public  wb_generic_whiteboard_object<class APM_Interface > {
        public: 
        APM_Command_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class APM_Interface >(wbd, kwb_APM_Command_v, false) {}
        
 
        static const wb_types slot = kwb_APM_Command_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[APM_Command_t::slot];
        }
    };
 
    class REMOVED3_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        REMOVED3_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_REMOVED3_v, false) {}
REMOVED3_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_REMOVED3_v, wbd, false) {}
 
        static const wb_types slot = kwb_REMOVED3_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[REMOVED3_t::slot];
        }
    };
 
    class REMOVED4_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        REMOVED4_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_REMOVED4_v, false) {}
REMOVED4_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_REMOVED4_v, wbd, false) {}
 
        static const wb_types slot = kwb_REMOVED4_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[REMOVED4_t::slot];
        }
    };
 
    class CBall_t: public  wb_generic_whiteboard_object<int8_t > {
        public: 
        CBall_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<int8_t >(wbd, kwb_CBall_v, true) {}
CBall_t(int8_t value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<int8_t >(value, kwb_CBall_v, wbd, true) {}
 
        static const wb_types slot = kwb_CBall_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[CBall_t::slot];
        }
    };
 
    class OculusPrime_Command_t: public  wb_generic_whiteboard_object<class OculusPrimeInterface > {
        public: 
        OculusPrime_Command_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class OculusPrimeInterface >(wbd, kwb_OculusPrime_Command_v, false) {}
        
 
        static const wb_types slot = kwb_OculusPrime_Command_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[OculusPrime_Command_t::slot];
        }
    };
 
    class Input3D_t: public  wb_generic_whiteboard_object<class Input3D > {
        public: 
        Input3D_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class Input3D >(wbd, kwb_Input3D_v, false) {}
        
 
        static const wb_types slot = kwb_Input3D_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Input3D_t::slot];
        }
    };
 
    class Oculus_Prime_Command_t: public  wb_generic_whiteboard_object<class Oculus_PrimeSerialInterface > {
        public: 
        Oculus_Prime_Command_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class Oculus_PrimeSerialInterface >(wbd, kwb_Oculus_Prime_Command_v, false) {}
        
 
        static const wb_types slot = kwb_Oculus_Prime_Command_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Oculus_Prime_Command_t::slot];
        }
    };
 
    class IOPins_t: public  wb_generic_whiteboard_object<class IOPins > {
        public: 
        IOPins_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class IOPins >(wbd, kwb_IOPins_v, false) {}
        
 
        static const wb_types slot = kwb_IOPins_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[IOPins_t::slot];
        }
    };
 
    class NXT_Two_Touch_Status_t: public  wb_generic_whiteboard_object<class NXT_Two_Touch_Status > {
        public: 
        NXT_Two_Touch_Status_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class NXT_Two_Touch_Status >(wbd, kwb_NXT_Two_Touch_Status_v, false) {}
        
 
        static const wb_types slot = kwb_NXT_Two_Touch_Status_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[NXT_Two_Touch_Status_t::slot];
        }
    };
 
    class NXT_Sound_Control_t: public  wb_generic_whiteboard_object<class NXT_Sound_Control > {
        public: 
        NXT_Sound_Control_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class NXT_Sound_Control >(wbd, kwb_NXT_Sound_Control_v, false) {}
        
 
        static const wb_types slot = kwb_NXT_Sound_Control_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[NXT_Sound_Control_t::slot];
        }
    };
 
    class NXT_Lights_Control_t: public  wb_generic_whiteboard_object<class NXT_Lights_Control > {
        public: 
        NXT_Lights_Control_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class NXT_Lights_Control >(wbd, kwb_NXT_Lights_Control_v, false) {}
        
 
        static const wb_types slot = kwb_NXT_Lights_Control_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[NXT_Lights_Control_t::slot];
        }
    };
 
    class Clocks_t: public  wb_generic_whiteboard_object<class Clocks > {
        public: 
        Clocks_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class Clocks >(wbd, kwb_Clocks_v, false) {}
        
 
        static const wb_types slot = kwb_Clocks_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Clocks_t::slot];
        }
    };
 
    class Channels_t: public  wb_generic_whiteboard_object<class Channels > {
        public: 
        Channels_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class Channels >(wbd, kwb_Channels_v, false) {}
        
 
        static const wb_types slot = kwb_Channels_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Channels_t::slot];
        }
    };
 
    class SwitchSubsumption_t: public  wb_generic_whiteboard_object<class SwitchSubsumption > {
        public: 
        SwitchSubsumption_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class SwitchSubsumption >(wbd, kwb_SwitchSubsumption_v, false) {}
        
 
        static const wb_types slot = kwb_SwitchSubsumption_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[SwitchSubsumption_t::slot];
        }
    };
 
    class TotoDoingMotion_t: public  wb_generic_whiteboard_object<class TotoDoingMotion > {
        public: 
        TotoDoingMotion_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class TotoDoingMotion >(wbd, kwb_TotoDoingMotion_v, false) {}
        
 
        static const wb_types slot = kwb_TotoDoingMotion_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[TotoDoingMotion_t::slot];
        }
    };
 
    class Count_t: public  wb_generic_whiteboard_object<class Count > {
        public: 
        Count_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class Count >(wbd, kwb_Count_v, false) {}
        
 
        static const wb_types slot = kwb_Count_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Count_t::slot];
        }
    };
 
    class GreenEWon_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        GreenEWon_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_GreenEWon_v, false) {}
GreenEWon_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_GreenEWon_v, wbd, false) {}
 
        static const wb_types slot = kwb_GreenEWon_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[GreenEWon_t::slot];
        }
    };
 
    class WarnEW_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        WarnEW_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_WarnEW_v, false) {}
WarnEW_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_WarnEW_v, wbd, false) {}
 
        static const wb_types slot = kwb_WarnEW_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[WarnEW_t::slot];
        }
    };
 
    class TimeGTthirty_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        TimeGTthirty_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_TimeGTthirty_v, false) {}
TimeGTthirty_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_TimeGTthirty_v, wbd, false) {}
 
        static const wb_types slot = kwb_TimeGTthirty_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[TimeGTthirty_t::slot];
        }
    };
 
    class AmberEWon_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        AmberEWon_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_AmberEWon_v, false) {}
AmberEWon_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_AmberEWon_v, wbd, false) {}
 
        static const wb_types slot = kwb_AmberEWon_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[AmberEWon_t::slot];
        }
    };
 
    class TurnRedEW_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        TurnRedEW_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_TurnRedEW_v, false) {}
TurnRedEW_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_TurnRedEW_v, wbd, false) {}
 
        static const wb_types slot = kwb_TurnRedEW_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[TurnRedEW_t::slot];
        }
    };
 
    class TimeGTfive_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        TimeGTfive_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_TimeGTfive_v, false) {}
TimeGTfive_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_TimeGTfive_v, wbd, false) {}
 
        static const wb_types slot = kwb_TimeGTfive_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[TimeGTfive_t::slot];
        }
    };
 
    class RedEWon_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        RedEWon_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_RedEWon_v, false) {}
RedEWon_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_RedEWon_v, wbd, false) {}
 
        static const wb_types slot = kwb_RedEWon_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[RedEWon_t::slot];
        }
    };
 
    class GreenNSon_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        GreenNSon_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_GreenNSon_v, false) {}
GreenNSon_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_GreenNSon_v, wbd, false) {}
 
        static const wb_types slot = kwb_GreenNSon_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[GreenNSon_t::slot];
        }
    };
 
    class WarnNS_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        WarnNS_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_WarnNS_v, false) {}
WarnNS_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_WarnNS_v, wbd, false) {}
 
        static const wb_types slot = kwb_WarnNS_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[WarnNS_t::slot];
        }
    };
 
    class AmberNSon_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        AmberNSon_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_AmberNSon_v, false) {}
AmberNSon_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_AmberNSon_v, wbd, false) {}
 
        static const wb_types slot = kwb_AmberNSon_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[AmberNSon_t::slot];
        }
    };
 
    class TurnRedNS_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        TurnRedNS_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_TurnRedNS_v, false) {}
TurnRedNS_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_TurnRedNS_v, wbd, false) {}
 
        static const wb_types slot = kwb_TurnRedNS_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[TurnRedNS_t::slot];
        }
    };
 
    class RedNSon_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        RedNSon_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_RedNSon_v, false) {}
RedNSon_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_RedNSon_v, wbd, false) {}
 
        static const wb_types slot = kwb_RedNSon_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[RedNSon_t::slot];
        }
    };
 
    class TimerReset_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        TimerReset_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_TimerReset_v, false) {}
TimerReset_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_TimerReset_v, wbd, false) {}
 
        static const wb_types slot = kwb_TimerReset_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[TimerReset_t::slot];
        }
    };
 
    class SLOT_UNUSED_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        SLOT_UNUSED_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_SLOT_UNUSED_v, false) {}
SLOT_UNUSED_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_SLOT_UNUSED_v, wbd, false) {}
 
        static const wb_types slot = kwb_SLOT_UNUSED_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[SLOT_UNUSED_t::slot];
        }
    };
 
    class CarSensorPressed_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        CarSensorPressed_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_CarSensorPressed_v, false) {}
CarSensorPressed_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_CarSensorPressed_v, wbd, false) {}
 
        static const wb_types slot = kwb_CarSensorPressed_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[CarSensorPressed_t::slot];
        }
    };
 
    class SwitchSubsumptionTrafficLights_t: public  wb_generic_whiteboard_object<class SwitchSubsumptionTrafficLights > {
        public: 
        SwitchSubsumptionTrafficLights_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class SwitchSubsumptionTrafficLights >(wbd, kwb_SwitchSubsumptionTrafficLights_v, false) {}
        
 
        static const wb_types slot = kwb_SwitchSubsumptionTrafficLights_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[SwitchSubsumptionTrafficLights_t::slot];
        }
    };
 
    class Ball_Found_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        Ball_Found_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_Ball_Found_v, false) {}
Ball_Found_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_Ball_Found_v, wbd, false) {}
 
        static const wb_types slot = kwb_Ball_Found_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Ball_Found_t::slot];
        }
    };
 
    class Ball_Calibration_File_t: public  wb_generic_whiteboard_object<std::string > {
        public: 
        Ball_Calibration_File_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<std::string >(wbd, kwb_Ball_Calibration_File_v, false) {}
Ball_Calibration_File_t(std::string value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<std::string >(value, kwb_Ball_Calibration_File_v, wbd, false) {}
 
        static const wb_types slot = kwb_Ball_Calibration_File_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Ball_Calibration_File_t::slot];
        }
    };
 
    class Ball_Calibration_Num_t: public  wb_generic_whiteboard_object<int32_t > {
        public: 
        Ball_Calibration_Num_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<int32_t >(wbd, kwb_Ball_Calibration_Num_v, false) {}
Ball_Calibration_Num_t(int32_t value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<int32_t >(value, kwb_Ball_Calibration_Num_v, wbd, false) {}
 
        static const wb_types slot = kwb_Ball_Calibration_Num_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Ball_Calibration_Num_t::slot];
        }
    };
 
    class Ball_Color_Num_t: public  wb_generic_whiteboard_object<int32_t > {
        public: 
        Ball_Color_Num_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<int32_t >(wbd, kwb_Ball_Color_Num_v, false) {}
Ball_Color_Num_t(int32_t value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<int32_t >(value, kwb_Ball_Color_Num_v, wbd, false) {}
 
        static const wb_types slot = kwb_Ball_Color_Num_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Ball_Color_Num_t::slot];
        }
    };
 
    class HAL_LArmTarget_Ctrl_t: public  wb_generic_whiteboard_object<class HalArmTarget > {
        public: 
        HAL_LArmTarget_Ctrl_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class HalArmTarget >(wbd, kwb_HAL_LArmTarget_Ctrl_v, false) {}
        
 
        static const wb_types slot = kwb_HAL_LArmTarget_Ctrl_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[HAL_LArmTarget_Ctrl_t::slot];
        }
    };
 
    class HAL_LArmTarget_Stat_t: public  wb_generic_whiteboard_object<class HalArmTarget > {
        public: 
        HAL_LArmTarget_Stat_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class HalArmTarget >(wbd, kwb_HAL_LArmTarget_Stat_v, false) {}
        
 
        static const wb_types slot = kwb_HAL_LArmTarget_Stat_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[HAL_LArmTarget_Stat_t::slot];
        }
    };
 
    class HAL_LArmTarget_Tolr_t: public  wb_generic_whiteboard_object<class HalArmTarget > {
        public: 
        HAL_LArmTarget_Tolr_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class HalArmTarget >(wbd, kwb_HAL_LArmTarget_Tolr_v, false) {}
        
 
        static const wb_types slot = kwb_HAL_LArmTarget_Tolr_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[HAL_LArmTarget_Tolr_t::slot];
        }
    };
 
    class HAL_RArmTarget_Ctrl_t: public  wb_generic_whiteboard_object<class HalArmTarget > {
        public: 
        HAL_RArmTarget_Ctrl_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class HalArmTarget >(wbd, kwb_HAL_RArmTarget_Ctrl_v, false) {}
        
 
        static const wb_types slot = kwb_HAL_RArmTarget_Ctrl_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[HAL_RArmTarget_Ctrl_t::slot];
        }
    };
 
    class HAL_RArmTarget_Stat_t: public  wb_generic_whiteboard_object<class HalArmTarget > {
        public: 
        HAL_RArmTarget_Stat_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class HalArmTarget >(wbd, kwb_HAL_RArmTarget_Stat_v, false) {}
        
 
        static const wb_types slot = kwb_HAL_RArmTarget_Stat_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[HAL_RArmTarget_Stat_t::slot];
        }
    };
 
    class HAL_RArmTarget_Tolr_t: public  wb_generic_whiteboard_object<class HalArmTarget > {
        public: 
        HAL_RArmTarget_Tolr_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class HalArmTarget >(wbd, kwb_HAL_RArmTarget_Tolr_v, false) {}
        
 
        static const wb_types slot = kwb_HAL_RArmTarget_Tolr_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[HAL_RArmTarget_Tolr_t::slot];
        }
    };
 
    class VisionFieldFeatures_t: public  wb_generic_whiteboard_object<class VisionFieldFeatures > {
        public: 
        VisionFieldFeatures_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class VisionFieldFeatures >(wbd, kwb_VisionFieldFeatures_v, false) {}
        
 
        static const wb_types slot = kwb_VisionFieldFeatures_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[VisionFieldFeatures_t::slot];
        }
    };
 
    class WhistleBlown_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        WhistleBlown_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_WhistleBlown_v, false) {}
WhistleBlown_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_WhistleBlown_v, wbd, false) {}
 
        static const wb_types slot = kwb_WhistleBlown_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[WhistleBlown_t::slot];
        }
    };
 
    class VolumeControl_t: public  wb_generic_whiteboard_object<uint8_t > {
        public: 
        VolumeControl_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<uint8_t >(wbd, kwb_VolumeControl_v, false) {}
VolumeControl_t(uint8_t value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<uint8_t >(value, kwb_VolumeControl_v, wbd, false) {}
 
        static const wb_types slot = kwb_VolumeControl_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[VolumeControl_t::slot];
        }
    };
 
    class VisionRobots_t: public  wb_generic_whiteboard_object<class VisionRobots > {
        public: 
        VisionRobots_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class VisionRobots >(wbd, kwb_VisionRobots_v, false) {}
        
 
        static const wb_types slot = kwb_VisionRobots_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[VisionRobots_t::slot];
        }
    };
 
    class VisionDetectionHorizons_t: public  wb_generic_whiteboard_object<class VisionDetectionHorizons > {
        public: 
        VisionDetectionHorizons_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class VisionDetectionHorizons >(wbd, kwb_VisionDetectionHorizons_v, false) {}
        
 
        static const wb_types slot = kwb_VisionDetectionHorizons_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[VisionDetectionHorizons_t::slot];
        }
    };
 
    class NaoWalkCommand_t: public  wb_generic_whiteboard_object<class NaoWalkCommand > {
        public: 
        NaoWalkCommand_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class NaoWalkCommand >(wbd, kwb_NaoWalkCommand_v, false) {}
        
 
        static const wb_types slot = kwb_NaoWalkCommand_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[NaoWalkCommand_t::slot];
        }
    };
 
    class NaoWalkStatus_t: public  wb_generic_whiteboard_object<class NaoWalkStatus > {
        public: 
        NaoWalkStatus_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class NaoWalkStatus >(wbd, kwb_NaoWalkStatus_v, false) {}
        
 
        static const wb_types slot = kwb_NaoWalkStatus_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[NaoWalkStatus_t::slot];
        }
    };
 
    class HAL_LLegTarget_Ctrl_t: public  wb_generic_whiteboard_object<class HalLegTarget > {
        public: 
        HAL_LLegTarget_Ctrl_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class HalLegTarget >(wbd, kwb_HAL_LLegTarget_Ctrl_v, false) {}
        
 
        static const wb_types slot = kwb_HAL_LLegTarget_Ctrl_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[HAL_LLegTarget_Ctrl_t::slot];
        }
    };
 
    class HAL_LLegTarget_Stat_t: public  wb_generic_whiteboard_object<class HalLegTarget > {
        public: 
        HAL_LLegTarget_Stat_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class HalLegTarget >(wbd, kwb_HAL_LLegTarget_Stat_v, false) {}
        
 
        static const wb_types slot = kwb_HAL_LLegTarget_Stat_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[HAL_LLegTarget_Stat_t::slot];
        }
    };
 
    class HAL_LLegTarget_Tolr_t: public  wb_generic_whiteboard_object<class HalLegTarget > {
        public: 
        HAL_LLegTarget_Tolr_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class HalLegTarget >(wbd, kwb_HAL_LLegTarget_Tolr_v, false) {}
        
 
        static const wb_types slot = kwb_HAL_LLegTarget_Tolr_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[HAL_LLegTarget_Tolr_t::slot];
        }
    };
 
    class HAL_RLegTarget_Ctrl_t: public  wb_generic_whiteboard_object<class HalLegTarget > {
        public: 
        HAL_RLegTarget_Ctrl_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class HalLegTarget >(wbd, kwb_HAL_RLegTarget_Ctrl_v, false) {}
        
 
        static const wb_types slot = kwb_HAL_RLegTarget_Ctrl_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[HAL_RLegTarget_Ctrl_t::slot];
        }
    };
 
    class HAL_RLegTarget_Stat_t: public  wb_generic_whiteboard_object<class HalLegTarget > {
        public: 
        HAL_RLegTarget_Stat_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class HalLegTarget >(wbd, kwb_HAL_RLegTarget_Stat_v, false) {}
        
 
        static const wb_types slot = kwb_HAL_RLegTarget_Stat_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[HAL_RLegTarget_Stat_t::slot];
        }
    };
 
    class HAL_RLegTarget_Tolr_t: public  wb_generic_whiteboard_object<class HalLegTarget > {
        public: 
        HAL_RLegTarget_Tolr_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class HalLegTarget >(wbd, kwb_HAL_RLegTarget_Tolr_v, false) {}
        
 
        static const wb_types slot = kwb_HAL_RLegTarget_Tolr_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[HAL_RLegTarget_Tolr_t::slot];
        }
    };
 
    class VisionDetectionGoals_t: public  wb_generic_whiteboard_object<class VisionDetectionGoals > {
        public: 
        VisionDetectionGoals_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class VisionDetectionGoals >(wbd, kwb_VisionDetectionGoals_v, false) {}
        
 
        static const wb_types slot = kwb_VisionDetectionGoals_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[VisionDetectionGoals_t::slot];
        }
    };
 
    class TeleoperationControl_t: public  wb_generic_whiteboard_object<class TeleoperationControl > {
        public: 
        TeleoperationControl_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class TeleoperationControl >(wbd, kwb_TeleoperationControl_v, false) {}
        
 
        static const wb_types slot = kwb_TeleoperationControl_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[TeleoperationControl_t::slot];
        }
    };
 
    class TeleoperationStatus_t: public  wb_generic_whiteboard_object<class TeleoperationStatus > {
        public: 
        TeleoperationStatus_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class TeleoperationStatus >(wbd, kwb_TeleoperationStatus_v, false) {}
        
 
        static const wb_types slot = kwb_TeleoperationStatus_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[TeleoperationStatus_t::slot];
        }
    };
 
    class VisionDetectionBalls_t: public  wb_generic_whiteboard_object<class VisionDetectionBalls > {
        public: 
        VisionDetectionBalls_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class VisionDetectionBalls >(wbd, kwb_VisionDetectionBalls_v, false) {}
        
 
        static const wb_types slot = kwb_VisionDetectionBalls_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[VisionDetectionBalls_t::slot];
        }
    };
 
    class TeleoperationControlVR_t: public  wb_generic_whiteboard_object<class TeleoperationControlVR > {
        public: 
        TeleoperationControlVR_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class TeleoperationControlVR >(wbd, kwb_TeleoperationControlVR_v, false) {}
        
 
        static const wb_types slot = kwb_TeleoperationControlVR_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[TeleoperationControlVR_t::slot];
        }
    };
 
    class ParticleOutputMap_t: public  wb_generic_whiteboard_object<uint64_t > {
        public: 
        ParticleOutputMap_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<uint64_t >(wbd, kwb_ParticleOutputMap_v, false) {}
ParticleOutputMap_t(uint64_t value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<uint64_t >(value, kwb_ParticleOutputMap_v, wbd, false) {}
 
        static const wb_types slot = kwb_ParticleOutputMap_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[ParticleOutputMap_t::slot];
        }
    };
 
    class ParticleOutputMapControl_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        ParticleOutputMapControl_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_ParticleOutputMapControl_v, false) {}
ParticleOutputMapControl_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_ParticleOutputMapControl_v, wbd, false) {}
 
        static const wb_types slot = kwb_ParticleOutputMapControl_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[ParticleOutputMapControl_t::slot];
        }
    };
 
    class FFTControl_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        FFTControl_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_FFTControl_v, false) {}
FFTControl_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_FFTControl_v, wbd, false) {}
 
        static const wb_types slot = kwb_FFTControl_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[FFTControl_t::slot];
        }
    };
 
    class MachineFilteredNaoVision_t: public  wb_generic_whiteboard_object<class MachineFilteredVision > {
        public: 
        MachineFilteredNaoVision_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class MachineFilteredVision >(wbd, kwb_MachineFilteredNaoVision_v, false) {}
        
 
        static const wb_types slot = kwb_MachineFilteredNaoVision_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[MachineFilteredNaoVision_t::slot];
        }
    };
 
    class MicrowaveStatus_t: public  wb_generic_whiteboard_object<class MicrowaveStatus > {
        public: 
        MicrowaveStatus_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class MicrowaveStatus >(wbd, kwb_MicrowaveStatus_v, false) {}
        
 
        static const wb_types slot = kwb_MicrowaveStatus_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[MicrowaveStatus_t::slot];
        }
    };
 
    class Buttons_t: public  wb_generic_whiteboard_object<class Buttons > {
        public: 
        Buttons_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class Buttons >(wbd, kwb_Buttons_v, false) {}
        
 
        static const wb_types slot = kwb_Buttons_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Buttons_t::slot];
        }
    };
 
    class MachineFilteredLocalisationVision_t: public  wb_generic_whiteboard_object<class MachineFilteredLocalisationVision > {
        public: 
        MachineFilteredLocalisationVision_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class MachineFilteredLocalisationVision >(wbd, kwb_MachineFilteredLocalisationVision_v, false) {}
        
 
        static const wb_types slot = kwb_MachineFilteredLocalisationVision_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[MachineFilteredLocalisationVision_t::slot];
        }
    };
 
    class SensorsJointCurrent_t: public  wb_generic_whiteboard_object<class NaoJointListFloat > {
        public: 
        SensorsJointCurrent_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class NaoJointListFloat >(wbd, kwb_SensorsJointCurrent_v, false) {}
        
 
        static const wb_types slot = kwb_SensorsJointCurrent_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[SensorsJointCurrent_t::slot];
        }
    };
 
    class DataLogger_t: public  wb_generic_whiteboard_object<class DataLogger > {
        public: 
        DataLogger_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class DataLogger >(wbd, kwb_DataLogger_v, false) {}
        
 
        static const wb_types slot = kwb_DataLogger_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[DataLogger_t::slot];
        }
    };
 
    class MachineFilteredLines_t: public  wb_generic_whiteboard_object<class MachineFilteredLines > {
        public: 
        MachineFilteredLines_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class MachineFilteredLines >(wbd, kwb_MachineFilteredLines_v, false) {}
        
 
        static const wb_types slot = kwb_MachineFilteredLines_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[MachineFilteredLines_t::slot];
        }
    };
 
    class BallLocation_t: public  wb_generic_whiteboard_object<class Location > {
        public: 
        BallLocation_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class Location >(wbd, kwb_BallLocation_v, false) {}
        
 
        static const wb_types slot = kwb_BallLocation_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[BallLocation_t::slot];
        }
    };
 
    class LeftGoalPostLocation_t: public  wb_generic_whiteboard_object<class Location > {
        public: 
        LeftGoalPostLocation_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class Location >(wbd, kwb_LeftGoalPostLocation_v, false) {}
        
 
        static const wb_types slot = kwb_LeftGoalPostLocation_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[LeftGoalPostLocation_t::slot];
        }
    };
 
    class RightGoalPostLocation_t: public  wb_generic_whiteboard_object<class Location > {
        public: 
        RightGoalPostLocation_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class Location >(wbd, kwb_RightGoalPostLocation_v, false) {}
        
 
        static const wb_types slot = kwb_RightGoalPostLocation_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[RightGoalPostLocation_t::slot];
        }
    };
 
    class GoalLocation_t: public  wb_generic_whiteboard_object<class Location > {
        public: 
        GoalLocation_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class Location >(wbd, kwb_GoalLocation_v, false) {}
        
 
        static const wb_types slot = kwb_GoalLocation_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[GoalLocation_t::slot];
        }
    };
 
    class NaoSonarProtectedWalkCommand_t: public  wb_generic_whiteboard_object<class NaoSonarProtectedWalkCommand > {
        public: 
        NaoSonarProtectedWalkCommand_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class NaoSonarProtectedWalkCommand >(wbd, kwb_NaoSonarProtectedWalkCommand_v, false) {}
        
 
        static const wb_types slot = kwb_NaoSonarProtectedWalkCommand_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[NaoSonarProtectedWalkCommand_t::slot];
        }
    };
 
    class NaoObstacleDirection_t: public  wb_generic_whiteboard_object<class NaoObstacleDirection > {
        public: 
        NaoObstacleDirection_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class NaoObstacleDirection >(wbd, kwb_NaoObstacleDirection_v, false) {}
        
 
        static const wb_types slot = kwb_NaoObstacleDirection_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[NaoObstacleDirection_t::slot];
        }
    };
 
    class DominantFrequencies_t: public  wb_generic_whiteboard_object<class DominantFrequencies > {
        public: 
        DominantFrequencies_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class DominantFrequencies >(wbd, kwb_DominantFrequencies_v, false) {}
        
 
        static const wb_types slot = kwb_DominantFrequencies_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[DominantFrequencies_t::slot];
        }
    };
 
    class MissionPriorityForObstacles_t: public  wb_generic_whiteboard_object<class MissionPriorityForObstacles > {
        public: 
        MissionPriorityForObstacles_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class MissionPriorityForObstacles >(wbd, kwb_MissionPriorityForObstacles_v, false) {}
        
 
        static const wb_types slot = kwb_MissionPriorityForObstacles_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[MissionPriorityForObstacles_t::slot];
        }
    };
 
    class WavLoad_t: public  wb_generic_whiteboard_object<std::string > {
        public: 
        WavLoad_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<std::string >(wbd, kwb_WavLoad_v, true) {}
WavLoad_t(std::string value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<std::string >(value, kwb_WavLoad_v, wbd, true) {}
 
        static const wb_types slot = kwb_WavLoad_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[WavLoad_t::slot];
        }
    };
 
    class WavPlay_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        WavPlay_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_WavPlay_v, false) {}
WavPlay_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_WavPlay_v, wbd, false) {}
 
        static const wb_types slot = kwb_WavPlay_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[WavPlay_t::slot];
        }
    };
 
    class ReproduceWavNotSilent_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        ReproduceWavNotSilent_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_ReproduceWavNotSilent_v, false) {}
ReproduceWavNotSilent_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_ReproduceWavNotSilent_v, wbd, false) {}
 
        static const wb_types slot = kwb_ReproduceWavNotSilent_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[ReproduceWavNotSilent_t::slot];
        }
    };
 
    class FrequencyControl_t: public  wb_generic_whiteboard_object<class FrequencyLimits > {
        public: 
        FrequencyControl_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class FrequencyLimits >(wbd, kwb_FrequencyControl_v, false) {}
        
 
        static const wb_types slot = kwb_FrequencyControl_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[FrequencyControl_t::slot];
        }
    };
 
    class FrequencyStatus_t: public  wb_generic_whiteboard_object<class FrequencyLimits > {
        public: 
        FrequencyStatus_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class FrequencyLimits >(wbd, kwb_FrequencyStatus_v, false) {}
        
 
        static const wb_types slot = kwb_FrequencyStatus_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[FrequencyStatus_t::slot];
        }
    };
 
    class HeadJointSensors_t: public  wb_generic_whiteboard_object<class HeadJointSensors > {
        public: 
        HeadJointSensors_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class HeadJointSensors >(wbd, kwb_HeadJointSensors_v, false) {}
        
 
        static const wb_types slot = kwb_HeadJointSensors_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[HeadJointSensors_t::slot];
        }
    };
 
    class AdjustPositionConfidence_t: public  wb_generic_whiteboard_object<class AdjustPositionConfidence > {
        public: 
        AdjustPositionConfidence_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class AdjustPositionConfidence >(wbd, kwb_AdjustPositionConfidence_v, false) {}
        
 
        static const wb_types slot = kwb_AdjustPositionConfidence_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[AdjustPositionConfidence_t::slot];
        }
    };
 
    class GuVrTeleopVulkanControl_t: public  wb_generic_whiteboard_object<class GuVrTeleopVulkanControl > {
        public: 
        GuVrTeleopVulkanControl_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class GuVrTeleopVulkanControl >(wbd, kwb_GuVrTeleopVulkanControl_v, false) {}
        
 
        static const wb_types slot = kwb_GuVrTeleopVulkanControl_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[GuVrTeleopVulkanControl_t::slot];
        }
    };
 
    class TemperatureSensors_t: public  wb_generic_whiteboard_object<class TemperatureSensors > {
        public: 
        TemperatureSensors_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class TemperatureSensors >(wbd, kwb_TemperatureSensors_v, false) {}
        
 
        static const wb_types slot = kwb_TemperatureSensors_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[TemperatureSensors_t::slot];
        }
    };
 
    class Overheating_t: public  wb_generic_whiteboard_object<class Overheating > {
        public: 
        Overheating_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class Overheating >(wbd, kwb_Overheating_v, false) {}
        
 
        static const wb_types slot = kwb_Overheating_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Overheating_t::slot];
        }
    };
 
    class buttonPushed_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        buttonPushed_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_buttonPushed_v, false) {}
buttonPushed_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_buttonPushed_v, wbd, false) {}
 
        static const wb_types slot = kwb_buttonPushed_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[buttonPushed_t::slot];
        }
    };
 
    class doorOpen_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        doorOpen_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_doorOpen_v, false) {}
doorOpen_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_doorOpen_v, wbd, false) {}
 
        static const wb_types slot = kwb_doorOpen_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[doorOpen_t::slot];
        }
    };
 
    class timeLeft_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        timeLeft_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_timeLeft_v, false) {}
timeLeft_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_timeLeft_v, wbd, false) {}
 
        static const wb_types slot = kwb_timeLeft_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[timeLeft_t::slot];
        }
    };
 
    class motor_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        motor_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_motor_v, false) {}
motor_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_motor_v, wbd, false) {}
 
        static const wb_types slot = kwb_motor_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[motor_t::slot];
        }
    };
 
    class sound_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        sound_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_sound_v, false) {}
sound_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_sound_v, wbd, false) {}
 
        static const wb_types slot = kwb_sound_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[sound_t::slot];
        }
    };
 
    class light_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        light_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_light_v, false) {}
light_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_light_v, wbd, false) {}
 
        static const wb_types slot = kwb_light_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[light_t::slot];
        }
    };
 
    class Arduino2Pin_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        Arduino2Pin_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_Arduino2Pin_v, false) {}
Arduino2Pin_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_Arduino2Pin_v, wbd, false) {}
 
        static const wb_types slot = kwb_Arduino2Pin_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Arduino2Pin_t::slot];
        }
    };
 
    class Arduino2PinValue_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        Arduino2PinValue_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_Arduino2PinValue_v, false) {}
Arduino2PinValue_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_Arduino2PinValue_v, wbd, false) {}
 
        static const wb_types slot = kwb_Arduino2PinValue_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Arduino2PinValue_t::slot];
        }
    };
 
    class Arduino3Pin_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        Arduino3Pin_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_Arduino3Pin_v, false) {}
Arduino3Pin_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_Arduino3Pin_v, wbd, false) {}
 
        static const wb_types slot = kwb_Arduino3Pin_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Arduino3Pin_t::slot];
        }
    };
 
    class Arduino3PinValue_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        Arduino3PinValue_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_Arduino3PinValue_v, false) {}
Arduino3PinValue_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_Arduino3PinValue_v, wbd, false) {}
 
        static const wb_types slot = kwb_Arduino3PinValue_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Arduino3PinValue_t::slot];
        }
    };
 
    class Arduino4Pin_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        Arduino4Pin_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_Arduino4Pin_v, false) {}
Arduino4Pin_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_Arduino4Pin_v, wbd, false) {}
 
        static const wb_types slot = kwb_Arduino4Pin_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Arduino4Pin_t::slot];
        }
    };
 
    class Arduino4PinValue_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        Arduino4PinValue_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_Arduino4PinValue_v, false) {}
Arduino4PinValue_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_Arduino4PinValue_v, wbd, false) {}
 
        static const wb_types slot = kwb_Arduino4PinValue_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Arduino4PinValue_t::slot];
        }
    };
 
    class Arduino5Pin_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        Arduino5Pin_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_Arduino5Pin_v, false) {}
Arduino5Pin_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_Arduino5Pin_v, wbd, false) {}
 
        static const wb_types slot = kwb_Arduino5Pin_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Arduino5Pin_t::slot];
        }
    };
 
    class Arduino5PinValue_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        Arduino5PinValue_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_Arduino5PinValue_v, false) {}
Arduino5PinValue_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_Arduino5PinValue_v, wbd, false) {}
 
        static const wb_types slot = kwb_Arduino5PinValue_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Arduino5PinValue_t::slot];
        }
    };
 
    class Arduino6Pin_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        Arduino6Pin_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_Arduino6Pin_v, false) {}
Arduino6Pin_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_Arduino6Pin_v, wbd, false) {}
 
        static const wb_types slot = kwb_Arduino6Pin_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Arduino6Pin_t::slot];
        }
    };
 
    class Arduino6PinValue_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        Arduino6PinValue_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_Arduino6PinValue_v, false) {}
Arduino6PinValue_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_Arduino6PinValue_v, wbd, false) {}
 
        static const wb_types slot = kwb_Arduino6PinValue_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Arduino6PinValue_t::slot];
        }
    };
 
    class Arduino7Pin_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        Arduino7Pin_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_Arduino7Pin_v, false) {}
Arduino7Pin_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_Arduino7Pin_v, wbd, false) {}
 
        static const wb_types slot = kwb_Arduino7Pin_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Arduino7Pin_t::slot];
        }
    };
 
    class Arduino7PinValue_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        Arduino7PinValue_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_Arduino7PinValue_v, false) {}
Arduino7PinValue_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_Arduino7PinValue_v, wbd, false) {}
 
        static const wb_types slot = kwb_Arduino7PinValue_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Arduino7PinValue_t::slot];
        }
    };
 
    class Arduino8Pin_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        Arduino8Pin_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_Arduino8Pin_v, false) {}
Arduino8Pin_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_Arduino8Pin_v, wbd, false) {}
 
        static const wb_types slot = kwb_Arduino8Pin_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Arduino8Pin_t::slot];
        }
    };
 
    class Arduino8PinValue_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        Arduino8PinValue_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_Arduino8PinValue_v, false) {}
Arduino8PinValue_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_Arduino8PinValue_v, wbd, false) {}
 
        static const wb_types slot = kwb_Arduino8PinValue_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Arduino8PinValue_t::slot];
        }
    };
 
    class Arduino9Pin_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        Arduino9Pin_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_Arduino9Pin_v, false) {}
Arduino9Pin_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_Arduino9Pin_v, wbd, false) {}
 
        static const wb_types slot = kwb_Arduino9Pin_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Arduino9Pin_t::slot];
        }
    };
 
    class Arduino9PinValue_t: public  wb_generic_whiteboard_object<bool > {
        public: 
        Arduino9PinValue_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(wbd, kwb_Arduino9PinValue_v, false) {}
Arduino9PinValue_t(bool value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<bool >(value, kwb_Arduino9PinValue_v, wbd, false) {}
 
        static const wb_types slot = kwb_Arduino9PinValue_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[Arduino9PinValue_t::slot];
        }
    };
 
    class BallPosition_t: public  wb_generic_whiteboard_object<class BallPosition > {
        public: 
        BallPosition_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class BallPosition >(wbd, kwb_BallPosition_v, false) {}
        
 
        static const wb_types slot = kwb_BallPosition_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[BallPosition_t::slot];
        }
    };
 
    class MemoryImageControl_t: public  wb_generic_whiteboard_object<class MemoryImageControlStatus > {
        public: 
        MemoryImageControl_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class MemoryImageControlStatus >(wbd, kwb_MemoryImageControl_v, false) {}
        
 
        static const wb_types slot = kwb_MemoryImageControl_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[MemoryImageControl_t::slot];
        }
    };
 
    class MemoryImageStatus_t: public  wb_generic_whiteboard_object<class MemoryImageControlStatus > {
        public: 
        MemoryImageStatus_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class MemoryImageControlStatus >(wbd, kwb_MemoryImageStatus_v, false) {}
        
 
        static const wb_types slot = kwb_MemoryImageStatus_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[MemoryImageStatus_t::slot];
        }
    };
 
    class LHandGripper_t: public  wb_generic_whiteboard_object<int8_t > {
        public: 
        LHandGripper_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<int8_t >(wbd, kwb_LHandGripper_v, false) {}
LHandGripper_t(int8_t value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<int8_t >(value, kwb_LHandGripper_v, wbd, false) {}
 
        static const wb_types slot = kwb_LHandGripper_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[LHandGripper_t::slot];
        }
    };
 
    class RHandGripper_t: public  wb_generic_whiteboard_object<int8_t > {
        public: 
        RHandGripper_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<int8_t >(wbd, kwb_RHandGripper_v, false) {}
RHandGripper_t(int8_t value, gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<int8_t >(value, kwb_RHandGripper_v, wbd, false) {}
 
        static const wb_types slot = kwb_RHandGripper_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[RHandGripper_t::slot];
        }
    };
 
    class MyPosition_t: public  wb_generic_whiteboard_object<class MyPosition > {
        public: 
        MyPosition_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class MyPosition >(wbd, kwb_MyPosition_v, false) {}
        
 
        static const wb_types slot = kwb_MyPosition_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[MyPosition_t::slot];
        }
    };
 
    class VisionDetectionLines_t: public  wb_generic_whiteboard_object<class VisionDetectionLines > {
        public: 
        VisionDetectionLines_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class VisionDetectionLines >(wbd, kwb_VisionDetectionLines_v, false) {}
        
 
        static const wb_types slot = kwb_VisionDetectionLines_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[VisionDetectionLines_t::slot];
        }
    };
 
    class VisionDetectionFeatures_t: public  wb_generic_whiteboard_object<class VisionDetectionFeatures > {
        public: 
        VisionDetectionFeatures_t(gu_simple_whiteboard_descriptor *wbd = NULLPTR): wb_generic_whiteboard_object<class VisionDetectionFeatures >(wbd, kwb_VisionDetectionFeatures_v, false) {}
        
 
        static const wb_types slot = kwb_VisionDetectionFeatures_v;
 
        u_int16_t eventCounter() const {
            return _wbd->wb->event_counters[VisionDetectionFeatures_t::slot];
        }
    };
 
 
 
} // guWhiteboard
 
 
#pragma clang diagnostic pop
 
#endif //WB_GUWHITEBOARDTYPELIST_GENERATED_H