common_state_callbacks.h

Go to the documentation of this file.

#ifndef BEBOP_AUTONOMY_AUTOGENERATED_common_STATE_CALLBACKS_H
#define BEBOP_AUTONOMY_AUTOGENERATED_common_STATE_CALLBACKS_H

extern "C"
{
  #include "libARSAL/ARSAL.h"
  #include "libARController/ARController.h"
}

#include "bebop_driver/autogenerated/callbacks_common.h"
#include "bebop_driver/BebopArdrone3Config.h"

#include "bebop_msgs/CommonCommonStateAllStatesChanged.h"
#include "bebop_msgs/CommonCommonStateBatteryStateChanged.h"
#include "bebop_msgs/CommonCommonStateMassStorageStateListChanged.h"
#include "bebop_msgs/CommonCommonStateMassStorageInfoStateListChanged.h"
#include "bebop_msgs/CommonCommonStateCurrentDateChanged.h"
#include "bebop_msgs/CommonCommonStateCurrentTimeChanged.h"
#include "bebop_msgs/CommonCommonStateMassStorageInfoRemainingListChanged.h"
#include "bebop_msgs/CommonCommonStateWifiSignalChanged.h"
#include "bebop_msgs/CommonCommonStateSensorsStatesListChanged.h"
#include "bebop_msgs/CommonCommonStateProductModel.h"
#include "bebop_msgs/CommonCommonStateCountryListKnown.h"
#include "bebop_msgs/CommonCommonStateDeprecatedMassStorageContentChanged.h"
#include "bebop_msgs/CommonCommonStateMassStorageContent.h"
#include "bebop_msgs/CommonCommonStateMassStorageContentForCurrentRun.h"
#include "bebop_msgs/CommonCommonStateVideoRecordingTimestamp.h"
#include "bebop_msgs/CommonOverHeatStateOverHeatChanged.h"
#include "bebop_msgs/CommonOverHeatStateOverHeatRegulationChanged.h"
#include "bebop_msgs/CommonMavlinkStateMavlinkFilePlayingStateChanged.h"
#include "bebop_msgs/CommonMavlinkStateMavlinkPlayErrorStateChanged.h"
#include "bebop_msgs/CommonMavlinkStateMissionItemExecuted.h"
#include "bebop_msgs/CommonCalibrationStateMagnetoCalibrationStateChanged.h"
#include "bebop_msgs/CommonCalibrationStateMagnetoCalibrationRequiredState.h"
#include "bebop_msgs/CommonCalibrationStateMagnetoCalibrationAxisToCalibrateChanged.h"
#include "bebop_msgs/CommonCalibrationStateMagnetoCalibrationStartedChanged.h"
#include "bebop_msgs/CommonCalibrationStatePitotCalibrationStateChanged.h"
#include "bebop_msgs/CommonFlightPlanStateAvailabilityStateChanged.h"
#include "bebop_msgs/CommonFlightPlanStateComponentStateListChanged.h"
#include "bebop_msgs/CommonFlightPlanStateLockStateChanged.h"
#include "bebop_msgs/CommonARLibsVersionsStateControllerLibARCommandsVersion.h"
#include "bebop_msgs/CommonARLibsVersionsStateSkyControllerLibARCommandsVersion.h"
#include "bebop_msgs/CommonARLibsVersionsStateDeviceLibARCommandsVersion.h"
#include "bebop_msgs/CommonAudioStateAudioStreamingRunning.h"
#include "bebop_msgs/CommonHeadlightsStateintensityChanged.h"
#include "bebop_msgs/CommonAnimationsStateList.h"
#include "bebop_msgs/CommonAccessoryStateSupportedAccessoriesListChanged.h"
#include "bebop_msgs/CommonAccessoryStateAccessoryConfigChanged.h"
#include "bebop_msgs/CommonAccessoryStateAccessoryConfigModificationEnabled.h"
#include "bebop_msgs/CommonChargerStateMaxChargeRateChanged.h"
#include "bebop_msgs/CommonChargerStateCurrentChargeStateChanged.h"
#include "bebop_msgs/CommonChargerStateLastChargeRateChanged.h"
#include "bebop_msgs/CommonChargerStateChargingInfo.h"
#include "bebop_msgs/CommonRunStateRunIdChanged.h"

namespace bebop_driver
{
namespace cb
{


// All states have been sent.\n\n **Please note that you should not care about this event if you are using the libARController API as this library is handling the connection process for you.**
class CommonCommonStateAllStatesChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonCommonStateAllStatesChanged::Ptr msg_ptr;

public:

  CommonCommonStateAllStatesChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_ALLSTATESCHANGED)
  {
    if (priv_nh.getParam("states/enable_commonstate_allstateschanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonCommonStateAllStatesChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonCommonStateAllStatesChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonCommonStateAllStatesChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonCommonStateAllStatesChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonCommonStateAllStatesChanged


// Battery state.
class CommonCommonStateBatteryStateChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonCommonStateBatteryStateChanged::Ptr msg_ptr;

public:

  CommonCommonStateBatteryStateChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_BATTERYSTATECHANGED)
  {
    if (priv_nh.getParam("states/enable_commonstate_batterystatechanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonCommonStateBatteryStateChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonCommonStateBatteryStateChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonCommonStateBatteryStateChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonCommonStateBatteryStateChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_BATTERYSTATECHANGED_PERCENT, arg);
    if (arg)
    {
      msg_ptr->percent = arg->value.U8;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonCommonStateBatteryStateChanged


// Mass storage state list.
class CommonCommonStateMassStorageStateListChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonCommonStateMassStorageStateListChanged::Ptr msg_ptr;

public:

  CommonCommonStateMassStorageStateListChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGESTATELISTCHANGED)
  {
    if (priv_nh.getParam("states/enable_commonstate_massstoragestatelistchanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonCommonStateMassStorageStateListChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonCommonStateMassStorageStateListChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonCommonStateMassStorageStateListChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonCommonStateMassStorageStateListChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGESTATELISTCHANGED_MASS_STORAGE_ID, arg);
    if (arg)
    {
      msg_ptr->mass_storage_id = arg->value.U8;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGESTATELISTCHANGED_NAME, arg);
    if (arg)
    {
      msg_ptr->name = arg->value.String;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonCommonStateMassStorageStateListChanged


// Mass storage info state list.
class CommonCommonStateMassStorageInfoStateListChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonCommonStateMassStorageInfoStateListChanged::Ptr msg_ptr;

public:

  CommonCommonStateMassStorageInfoStateListChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGEINFOSTATELISTCHANGED)
  {
    if (priv_nh.getParam("states/enable_commonstate_massstorageinfostatelistchanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonCommonStateMassStorageInfoStateListChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonCommonStateMassStorageInfoStateListChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonCommonStateMassStorageInfoStateListChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonCommonStateMassStorageInfoStateListChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGEINFOSTATELISTCHANGED_MASS_STORAGE_ID, arg);
    if (arg)
    {
      msg_ptr->mass_storage_id = arg->value.U8;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGEINFOSTATELISTCHANGED_SIZE, arg);
    if (arg)
    {
      msg_ptr->size = arg->value.U32;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGEINFOSTATELISTCHANGED_USED_SIZE, arg);
    if (arg)
    {
      msg_ptr->used_size = arg->value.U32;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGEINFOSTATELISTCHANGED_PLUGGED, arg);
    if (arg)
    {
      msg_ptr->plugged = arg->value.U8;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGEINFOSTATELISTCHANGED_FULL, arg);
    if (arg)
    {
      msg_ptr->full = arg->value.U8;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGEINFOSTATELISTCHANGED_INTERNAL, arg);
    if (arg)
    {
      msg_ptr->internal = arg->value.U8;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonCommonStateMassStorageInfoStateListChanged


// Date changed.\n Corresponds to the latest date set on the drone.\n\n **Please note that you should not care about this event if you are using the libARController API as this library is handling the connection process for you.**
class CommonCommonStateCurrentDateChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonCommonStateCurrentDateChanged::Ptr msg_ptr;

public:

  CommonCommonStateCurrentDateChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_CURRENTDATECHANGED)
  {
    if (priv_nh.getParam("states/enable_commonstate_currentdatechanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonCommonStateCurrentDateChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonCommonStateCurrentDateChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonCommonStateCurrentDateChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonCommonStateCurrentDateChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_CURRENTDATECHANGED_DATE, arg);
    if (arg)
    {
      msg_ptr->date = arg->value.String;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonCommonStateCurrentDateChanged


// Time changed.\n Corresponds to the latest time set on the drone.\n\n **Please note that you should not care about this event if you are using the libARController API as this library is handling the connection process for you.**
class CommonCommonStateCurrentTimeChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonCommonStateCurrentTimeChanged::Ptr msg_ptr;

public:

  CommonCommonStateCurrentTimeChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_CURRENTTIMECHANGED)
  {
    if (priv_nh.getParam("states/enable_commonstate_currenttimechanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonCommonStateCurrentTimeChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonCommonStateCurrentTimeChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonCommonStateCurrentTimeChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonCommonStateCurrentTimeChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_CURRENTTIMECHANGED_TIME, arg);
    if (arg)
    {
      msg_ptr->time = arg->value.String;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonCommonStateCurrentTimeChanged


// Mass storage remaining data list.
class CommonCommonStateMassStorageInfoRemainingListChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonCommonStateMassStorageInfoRemainingListChanged::Ptr msg_ptr;

public:

  CommonCommonStateMassStorageInfoRemainingListChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGEINFOREMAININGLISTCHANGED)
  {
    if (priv_nh.getParam("states/enable_commonstate_massstorageinforemaininglistchanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonCommonStateMassStorageInfoRemainingListChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonCommonStateMassStorageInfoRemainingListChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonCommonStateMassStorageInfoRemainingListChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonCommonStateMassStorageInfoRemainingListChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGEINFOREMAININGLISTCHANGED_FREE_SPACE, arg);
    if (arg)
    {
      msg_ptr->free_space = arg->value.U32;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGEINFOREMAININGLISTCHANGED_REC_TIME, arg);
    if (arg)
    {
      msg_ptr->rec_time = arg->value.U16;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGEINFOREMAININGLISTCHANGED_PHOTO_REMAINING, arg);
    if (arg)
    {
      msg_ptr->photo_remaining = arg->value.U32;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonCommonStateMassStorageInfoRemainingListChanged


// Rssi (Wifi Signal between controller and product) changed.
class CommonCommonStateWifiSignalChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonCommonStateWifiSignalChanged::Ptr msg_ptr;

public:

  CommonCommonStateWifiSignalChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_WIFISIGNALCHANGED)
  {
    if (priv_nh.getParam("states/enable_commonstate_wifisignalchanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonCommonStateWifiSignalChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonCommonStateWifiSignalChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonCommonStateWifiSignalChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonCommonStateWifiSignalChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_WIFISIGNALCHANGED_RSSI, arg);
    if (arg)
    {
      msg_ptr->rssi = arg->value.I16;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonCommonStateWifiSignalChanged


// Sensors state list.
class CommonCommonStateSensorsStatesListChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonCommonStateSensorsStatesListChanged::Ptr msg_ptr;

public:

  CommonCommonStateSensorsStatesListChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_SENSORSSTATESLISTCHANGED)
  {
    if (priv_nh.getParam("states/enable_commonstate_sensorsstateslistchanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonCommonStateSensorsStatesListChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonCommonStateSensorsStatesListChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonCommonStateSensorsStatesListChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonCommonStateSensorsStatesListChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_SENSORSSTATESLISTCHANGED_SENSORNAME, arg);
    if (arg)
    {
      msg_ptr->sensorName = arg->value.I32;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_SENSORSSTATESLISTCHANGED_SENSORSTATE, arg);
    if (arg)
    {
      msg_ptr->sensorState = arg->value.U8;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonCommonStateSensorsStatesListChanged


// Product sub-model.\n This can be used to customize the UI depending on the product.
class CommonCommonStateProductModel : public AbstractState
{
private:
  ::bebop_msgs::CommonCommonStateProductModel::Ptr msg_ptr;

public:

  CommonCommonStateProductModel(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_PRODUCTMODEL)
  {
    if (priv_nh.getParam("states/enable_commonstate_productmodel", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonCommonStateProductModel>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonCommonStateProductModel::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonCommonStateProductModel::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonCommonStateProductModel());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_PRODUCTMODEL_MODEL, arg);
    if (arg)
    {
      msg_ptr->model = arg->value.I32;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonCommonStateProductModel


// List of countries known by the drone.
class CommonCommonStateCountryListKnown : public AbstractState
{
private:
  ::bebop_msgs::CommonCommonStateCountryListKnown::Ptr msg_ptr;

public:

  CommonCommonStateCountryListKnown(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_COUNTRYLISTKNOWN)
  {
    if (priv_nh.getParam("states/enable_commonstate_countrylistknown", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonCommonStateCountryListKnown>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonCommonStateCountryListKnown::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonCommonStateCountryListKnown::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonCommonStateCountryListKnown());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_COUNTRYLISTKNOWN_LISTFLAGS, arg);
    if (arg)
    {
      msg_ptr->listFlags = arg->value.U8;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_COUNTRYLISTKNOWN_COUNTRYCODES, arg);
    if (arg)
    {
      msg_ptr->countryCodes = arg->value.String;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonCommonStateCountryListKnown


// Mass storage content changed.
class CommonCommonStateDeprecatedMassStorageContentChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonCommonStateDeprecatedMassStorageContentChanged::Ptr msg_ptr;

public:

  CommonCommonStateDeprecatedMassStorageContentChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_DEPRECATEDMASSSTORAGECONTENTCHANGED)
  {
    if (priv_nh.getParam("states/enable_commonstate_deprecatedmassstoragecontentchanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonCommonStateDeprecatedMassStorageContentChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonCommonStateDeprecatedMassStorageContentChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonCommonStateDeprecatedMassStorageContentChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonCommonStateDeprecatedMassStorageContentChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_DEPRECATEDMASSSTORAGECONTENTCHANGED_MASS_STORAGE_ID, arg);
    if (arg)
    {
      msg_ptr->mass_storage_id = arg->value.U8;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_DEPRECATEDMASSSTORAGECONTENTCHANGED_NBPHOTOS, arg);
    if (arg)
    {
      msg_ptr->nbPhotos = arg->value.U16;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_DEPRECATEDMASSSTORAGECONTENTCHANGED_NBVIDEOS, arg);
    if (arg)
    {
      msg_ptr->nbVideos = arg->value.U16;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_DEPRECATEDMASSSTORAGECONTENTCHANGED_NBPUDS, arg);
    if (arg)
    {
      msg_ptr->nbPuds = arg->value.U16;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_DEPRECATEDMASSSTORAGECONTENTCHANGED_NBCRASHLOGS, arg);
    if (arg)
    {
      msg_ptr->nbCrashLogs = arg->value.U16;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonCommonStateDeprecatedMassStorageContentChanged


// Mass storage content.
class CommonCommonStateMassStorageContent : public AbstractState
{
private:
  ::bebop_msgs::CommonCommonStateMassStorageContent::Ptr msg_ptr;

public:

  CommonCommonStateMassStorageContent(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGECONTENT)
  {
    if (priv_nh.getParam("states/enable_commonstate_massstoragecontent", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonCommonStateMassStorageContent>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonCommonStateMassStorageContent::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonCommonStateMassStorageContent::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonCommonStateMassStorageContent());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGECONTENT_MASS_STORAGE_ID, arg);
    if (arg)
    {
      msg_ptr->mass_storage_id = arg->value.U8;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGECONTENT_NBPHOTOS, arg);
    if (arg)
    {
      msg_ptr->nbPhotos = arg->value.U16;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGECONTENT_NBVIDEOS, arg);
    if (arg)
    {
      msg_ptr->nbVideos = arg->value.U16;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGECONTENT_NBPUDS, arg);
    if (arg)
    {
      msg_ptr->nbPuds = arg->value.U16;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGECONTENT_NBCRASHLOGS, arg);
    if (arg)
    {
      msg_ptr->nbCrashLogs = arg->value.U16;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGECONTENT_NBRAWPHOTOS, arg);
    if (arg)
    {
      msg_ptr->nbRawPhotos = arg->value.U16;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonCommonStateMassStorageContent


// Mass storage content for current run.\n Only counts the files related to the current run (see [RunId](#0-30-0))
class CommonCommonStateMassStorageContentForCurrentRun : public AbstractState
{
private:
  ::bebop_msgs::CommonCommonStateMassStorageContentForCurrentRun::Ptr msg_ptr;

public:

  CommonCommonStateMassStorageContentForCurrentRun(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGECONTENTFORCURRENTRUN)
  {
    if (priv_nh.getParam("states/enable_commonstate_massstoragecontentforcurrentrun", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonCommonStateMassStorageContentForCurrentRun>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonCommonStateMassStorageContentForCurrentRun::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonCommonStateMassStorageContentForCurrentRun::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonCommonStateMassStorageContentForCurrentRun());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGECONTENTFORCURRENTRUN_MASS_STORAGE_ID, arg);
    if (arg)
    {
      msg_ptr->mass_storage_id = arg->value.U8;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGECONTENTFORCURRENTRUN_NBPHOTOS, arg);
    if (arg)
    {
      msg_ptr->nbPhotos = arg->value.U16;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGECONTENTFORCURRENTRUN_NBVIDEOS, arg);
    if (arg)
    {
      msg_ptr->nbVideos = arg->value.U16;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_MASSSTORAGECONTENTFORCURRENTRUN_NBRAWPHOTOS, arg);
    if (arg)
    {
      msg_ptr->nbRawPhotos = arg->value.U16;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonCommonStateMassStorageContentForCurrentRun


// Current or last video recording timestamp.\n Timestamp in milliseconds since 00:00:00 UTC on 1 January 1970.\n **Please note that values dont persist after drone reboot**
class CommonCommonStateVideoRecordingTimestamp : public AbstractState
{
private:
  ::bebop_msgs::CommonCommonStateVideoRecordingTimestamp::Ptr msg_ptr;

public:

  CommonCommonStateVideoRecordingTimestamp(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_VIDEORECORDINGTIMESTAMP)
  {
    if (priv_nh.getParam("states/enable_commonstate_videorecordingtimestamp", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonCommonStateVideoRecordingTimestamp>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonCommonStateVideoRecordingTimestamp::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonCommonStateVideoRecordingTimestamp::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonCommonStateVideoRecordingTimestamp());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_VIDEORECORDINGTIMESTAMP_STARTTIMESTAMP, arg);
    if (arg)
    {
      msg_ptr->startTimestamp = arg->value.U64;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_COMMONSTATE_VIDEORECORDINGTIMESTAMP_STOPTIMESTAMP, arg);
    if (arg)
    {
      msg_ptr->stopTimestamp = arg->value.U64;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonCommonStateVideoRecordingTimestamp


// Overheat temperature reached.
class CommonOverHeatStateOverHeatChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonOverHeatStateOverHeatChanged::Ptr msg_ptr;

public:

  CommonOverHeatStateOverHeatChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_OVERHEATSTATE_OVERHEATCHANGED)
  {
    if (priv_nh.getParam("states/enable_overheatstate_overheatchanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonOverHeatStateOverHeatChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonOverHeatStateOverHeatChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonOverHeatStateOverHeatChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonOverHeatStateOverHeatChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonOverHeatStateOverHeatChanged


// Overheat regulation type.
class CommonOverHeatStateOverHeatRegulationChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonOverHeatStateOverHeatRegulationChanged::Ptr msg_ptr;

public:

  CommonOverHeatStateOverHeatRegulationChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_OVERHEATSTATE_OVERHEATREGULATIONCHANGED)
  {
    if (priv_nh.getParam("states/enable_overheatstate_overheatregulationchanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonOverHeatStateOverHeatRegulationChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonOverHeatStateOverHeatRegulationChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonOverHeatStateOverHeatRegulationChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonOverHeatStateOverHeatRegulationChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_OVERHEATSTATE_OVERHEATREGULATIONCHANGED_REGULATIONTYPE, arg);
    if (arg)
    {
      msg_ptr->regulationType = arg->value.U8;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonOverHeatStateOverHeatRegulationChanged


// Playing state of a FlightPlan.
class CommonMavlinkStateMavlinkFilePlayingStateChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonMavlinkStateMavlinkFilePlayingStateChanged::Ptr msg_ptr;

public:

  CommonMavlinkStateMavlinkFilePlayingStateChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_MAVLINKSTATE_MAVLINKFILEPLAYINGSTATECHANGED)
  {
    if (priv_nh.getParam("states/enable_mavlinkstate_mavlinkfileplayingstatechanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonMavlinkStateMavlinkFilePlayingStateChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonMavlinkStateMavlinkFilePlayingStateChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonMavlinkStateMavlinkFilePlayingStateChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonMavlinkStateMavlinkFilePlayingStateChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_MAVLINKSTATE_MAVLINKFILEPLAYINGSTATECHANGED_STATE, arg);
    if (arg)
    {
      msg_ptr->state = arg->value.I32;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_MAVLINKSTATE_MAVLINKFILEPLAYINGSTATECHANGED_FILEPATH, arg);
    if (arg)
    {
      msg_ptr->filepath = arg->value.String;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_MAVLINKSTATE_MAVLINKFILEPLAYINGSTATECHANGED_TYPE, arg);
    if (arg)
    {
      msg_ptr->type = arg->value.I32;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonMavlinkStateMavlinkFilePlayingStateChanged


// FlightPlan error.
class CommonMavlinkStateMavlinkPlayErrorStateChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonMavlinkStateMavlinkPlayErrorStateChanged::Ptr msg_ptr;

public:

  CommonMavlinkStateMavlinkPlayErrorStateChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_MAVLINKSTATE_MAVLINKPLAYERRORSTATECHANGED)
  {
    if (priv_nh.getParam("states/enable_mavlinkstate_mavlinkplayerrorstatechanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonMavlinkStateMavlinkPlayErrorStateChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonMavlinkStateMavlinkPlayErrorStateChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonMavlinkStateMavlinkPlayErrorStateChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonMavlinkStateMavlinkPlayErrorStateChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_MAVLINKSTATE_MAVLINKPLAYERRORSTATECHANGED_ERROR, arg);
    if (arg)
    {
      msg_ptr->error = arg->value.I32;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonMavlinkStateMavlinkPlayErrorStateChanged


// Mission item has been executed.
class CommonMavlinkStateMissionItemExecuted : public AbstractState
{
private:
  ::bebop_msgs::CommonMavlinkStateMissionItemExecuted::Ptr msg_ptr;

public:

  CommonMavlinkStateMissionItemExecuted(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_MAVLINKSTATE_MISSIONITEMEXECUTED)
  {
    if (priv_nh.getParam("states/enable_mavlinkstate_missionitemexecuted", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonMavlinkStateMissionItemExecuted>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonMavlinkStateMissionItemExecuted::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonMavlinkStateMissionItemExecuted::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonMavlinkStateMissionItemExecuted());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_MAVLINKSTATE_MISSIONITEMEXECUTED_IDX, arg);
    if (arg)
    {
      msg_ptr->idx = arg->value.U32;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonMavlinkStateMissionItemExecuted


// Magneto calib process axis state.
class CommonCalibrationStateMagnetoCalibrationStateChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonCalibrationStateMagnetoCalibrationStateChanged::Ptr msg_ptr;

public:

  CommonCalibrationStateMagnetoCalibrationStateChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_CALIBRATIONSTATE_MAGNETOCALIBRATIONSTATECHANGED)
  {
    if (priv_nh.getParam("states/enable_calibrationstate_magnetocalibrationstatechanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonCalibrationStateMagnetoCalibrationStateChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonCalibrationStateMagnetoCalibrationStateChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonCalibrationStateMagnetoCalibrationStateChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonCalibrationStateMagnetoCalibrationStateChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_CALIBRATIONSTATE_MAGNETOCALIBRATIONSTATECHANGED_XAXISCALIBRATION, arg);
    if (arg)
    {
      msg_ptr->xAxisCalibration = arg->value.U8;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_CALIBRATIONSTATE_MAGNETOCALIBRATIONSTATECHANGED_YAXISCALIBRATION, arg);
    if (arg)
    {
      msg_ptr->yAxisCalibration = arg->value.U8;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_CALIBRATIONSTATE_MAGNETOCALIBRATIONSTATECHANGED_ZAXISCALIBRATION, arg);
    if (arg)
    {
      msg_ptr->zAxisCalibration = arg->value.U8;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_CALIBRATIONSTATE_MAGNETOCALIBRATIONSTATECHANGED_CALIBRATIONFAILED, arg);
    if (arg)
    {
      msg_ptr->calibrationFailed = arg->value.U8;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonCalibrationStateMagnetoCalibrationStateChanged


// Calibration required.
class CommonCalibrationStateMagnetoCalibrationRequiredState : public AbstractState
{
private:
  ::bebop_msgs::CommonCalibrationStateMagnetoCalibrationRequiredState::Ptr msg_ptr;

public:

  CommonCalibrationStateMagnetoCalibrationRequiredState(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_CALIBRATIONSTATE_MAGNETOCALIBRATIONREQUIREDSTATE)
  {
    if (priv_nh.getParam("states/enable_calibrationstate_magnetocalibrationrequiredstate", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonCalibrationStateMagnetoCalibrationRequiredState>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonCalibrationStateMagnetoCalibrationRequiredState::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonCalibrationStateMagnetoCalibrationRequiredState::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonCalibrationStateMagnetoCalibrationRequiredState());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_CALIBRATIONSTATE_MAGNETOCALIBRATIONREQUIREDSTATE_REQUIRED, arg);
    if (arg)
    {
      msg_ptr->required = arg->value.U8;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonCalibrationStateMagnetoCalibrationRequiredState


// Axis to calibrate during calibration process.
class CommonCalibrationStateMagnetoCalibrationAxisToCalibrateChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonCalibrationStateMagnetoCalibrationAxisToCalibrateChanged::Ptr msg_ptr;

public:

  CommonCalibrationStateMagnetoCalibrationAxisToCalibrateChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_CALIBRATIONSTATE_MAGNETOCALIBRATIONAXISTOCALIBRATECHANGED)
  {
    if (priv_nh.getParam("states/enable_calibrationstate_magnetocalibrationaxistocalibratechanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonCalibrationStateMagnetoCalibrationAxisToCalibrateChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonCalibrationStateMagnetoCalibrationAxisToCalibrateChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonCalibrationStateMagnetoCalibrationAxisToCalibrateChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonCalibrationStateMagnetoCalibrationAxisToCalibrateChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_CALIBRATIONSTATE_MAGNETOCALIBRATIONAXISTOCALIBRATECHANGED_AXIS, arg);
    if (arg)
    {
      msg_ptr->axis = arg->value.I32;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonCalibrationStateMagnetoCalibrationAxisToCalibrateChanged


// Calibration process state.
class CommonCalibrationStateMagnetoCalibrationStartedChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonCalibrationStateMagnetoCalibrationStartedChanged::Ptr msg_ptr;

public:

  CommonCalibrationStateMagnetoCalibrationStartedChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_CALIBRATIONSTATE_MAGNETOCALIBRATIONSTARTEDCHANGED)
  {
    if (priv_nh.getParam("states/enable_calibrationstate_magnetocalibrationstartedchanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonCalibrationStateMagnetoCalibrationStartedChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonCalibrationStateMagnetoCalibrationStartedChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonCalibrationStateMagnetoCalibrationStartedChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonCalibrationStateMagnetoCalibrationStartedChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_CALIBRATIONSTATE_MAGNETOCALIBRATIONSTARTEDCHANGED_STARTED, arg);
    if (arg)
    {
      msg_ptr->started = arg->value.U8;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonCalibrationStateMagnetoCalibrationStartedChanged


// 
class CommonCalibrationStatePitotCalibrationStateChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonCalibrationStatePitotCalibrationStateChanged::Ptr msg_ptr;

public:

  CommonCalibrationStatePitotCalibrationStateChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_CALIBRATIONSTATE_PITOTCALIBRATIONSTATECHANGED)
  {
    if (priv_nh.getParam("states/enable_calibrationstate_pitotcalibrationstatechanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonCalibrationStatePitotCalibrationStateChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonCalibrationStatePitotCalibrationStateChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonCalibrationStatePitotCalibrationStateChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonCalibrationStatePitotCalibrationStateChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_CALIBRATIONSTATE_PITOTCALIBRATIONSTATECHANGED_STATE, arg);
    if (arg)
    {
      msg_ptr->state = arg->value.I32;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_CALIBRATIONSTATE_PITOTCALIBRATIONSTATECHANGED_LASTERROR, arg);
    if (arg)
    {
      msg_ptr->lastError = arg->value.U8;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonCalibrationStatePitotCalibrationStateChanged


// FlightPlan availability.\n Availability is linked to GPS fix, magnetometer calibration, sensor states...
class CommonFlightPlanStateAvailabilityStateChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonFlightPlanStateAvailabilityStateChanged::Ptr msg_ptr;

public:

  CommonFlightPlanStateAvailabilityStateChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_FLIGHTPLANSTATE_AVAILABILITYSTATECHANGED)
  {
    if (priv_nh.getParam("states/enable_flightplanstate_availabilitystatechanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonFlightPlanStateAvailabilityStateChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonFlightPlanStateAvailabilityStateChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonFlightPlanStateAvailabilityStateChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonFlightPlanStateAvailabilityStateChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_FLIGHTPLANSTATE_AVAILABILITYSTATECHANGED_AVAILABILITYSTATE, arg);
    if (arg)
    {
      msg_ptr->AvailabilityState = arg->value.U8;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonFlightPlanStateAvailabilityStateChanged


// FlightPlan components state list.
class CommonFlightPlanStateComponentStateListChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonFlightPlanStateComponentStateListChanged::Ptr msg_ptr;

public:

  CommonFlightPlanStateComponentStateListChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_FLIGHTPLANSTATE_COMPONENTSTATELISTCHANGED)
  {
    if (priv_nh.getParam("states/enable_flightplanstate_componentstatelistchanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonFlightPlanStateComponentStateListChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonFlightPlanStateComponentStateListChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonFlightPlanStateComponentStateListChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonFlightPlanStateComponentStateListChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_FLIGHTPLANSTATE_COMPONENTSTATELISTCHANGED_COMPONENT, arg);
    if (arg)
    {
      msg_ptr->component = arg->value.I32;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_FLIGHTPLANSTATE_COMPONENTSTATELISTCHANGED_STATE, arg);
    if (arg)
    {
      msg_ptr->State = arg->value.U8;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonFlightPlanStateComponentStateListChanged


// FlightPlan lock state.\n Represents the fact that the controller is able or not to stop or pause a playing FlightPlan
class CommonFlightPlanStateLockStateChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonFlightPlanStateLockStateChanged::Ptr msg_ptr;

public:

  CommonFlightPlanStateLockStateChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_FLIGHTPLANSTATE_LOCKSTATECHANGED)
  {
    if (priv_nh.getParam("states/enable_flightplanstate_lockstatechanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonFlightPlanStateLockStateChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonFlightPlanStateLockStateChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonFlightPlanStateLockStateChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonFlightPlanStateLockStateChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_FLIGHTPLANSTATE_LOCKSTATECHANGED_LOCKSTATE, arg);
    if (arg)
    {
      msg_ptr->LockState = arg->value.U8;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonFlightPlanStateLockStateChanged


// 
class CommonARLibsVersionsStateControllerLibARCommandsVersion : public AbstractState
{
private:
  ::bebop_msgs::CommonARLibsVersionsStateControllerLibARCommandsVersion::Ptr msg_ptr;

public:

  CommonARLibsVersionsStateControllerLibARCommandsVersion(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_ARLIBSVERSIONSSTATE_CONTROLLERLIBARCOMMANDSVERSION)
  {
    if (priv_nh.getParam("states/enable_arlibsversionsstate_controllerlibarcommandsversion", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonARLibsVersionsStateControllerLibARCommandsVersion>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonARLibsVersionsStateControllerLibARCommandsVersion::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonARLibsVersionsStateControllerLibARCommandsVersion::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonARLibsVersionsStateControllerLibARCommandsVersion());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_ARLIBSVERSIONSSTATE_CONTROLLERLIBARCOMMANDSVERSION_VERSION, arg);
    if (arg)
    {
      msg_ptr->version = arg->value.String;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonARLibsVersionsStateControllerLibARCommandsVersion


// 
class CommonARLibsVersionsStateSkyControllerLibARCommandsVersion : public AbstractState
{
private:
  ::bebop_msgs::CommonARLibsVersionsStateSkyControllerLibARCommandsVersion::Ptr msg_ptr;

public:

  CommonARLibsVersionsStateSkyControllerLibARCommandsVersion(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_ARLIBSVERSIONSSTATE_SKYCONTROLLERLIBARCOMMANDSVERSION)
  {
    if (priv_nh.getParam("states/enable_arlibsversionsstate_skycontrollerlibarcommandsversion", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonARLibsVersionsStateSkyControllerLibARCommandsVersion>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonARLibsVersionsStateSkyControllerLibARCommandsVersion::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonARLibsVersionsStateSkyControllerLibARCommandsVersion::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonARLibsVersionsStateSkyControllerLibARCommandsVersion());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_ARLIBSVERSIONSSTATE_SKYCONTROLLERLIBARCOMMANDSVERSION_VERSION, arg);
    if (arg)
    {
      msg_ptr->version = arg->value.String;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonARLibsVersionsStateSkyControllerLibARCommandsVersion


// 
class CommonARLibsVersionsStateDeviceLibARCommandsVersion : public AbstractState
{
private:
  ::bebop_msgs::CommonARLibsVersionsStateDeviceLibARCommandsVersion::Ptr msg_ptr;

public:

  CommonARLibsVersionsStateDeviceLibARCommandsVersion(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_ARLIBSVERSIONSSTATE_DEVICELIBARCOMMANDSVERSION)
  {
    if (priv_nh.getParam("states/enable_arlibsversionsstate_devicelibarcommandsversion", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonARLibsVersionsStateDeviceLibARCommandsVersion>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonARLibsVersionsStateDeviceLibARCommandsVersion::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonARLibsVersionsStateDeviceLibARCommandsVersion::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonARLibsVersionsStateDeviceLibARCommandsVersion());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_ARLIBSVERSIONSSTATE_DEVICELIBARCOMMANDSVERSION_VERSION, arg);
    if (arg)
    {
      msg_ptr->version = arg->value.String;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonARLibsVersionsStateDeviceLibARCommandsVersion


// Audio stream direction.
class CommonAudioStateAudioStreamingRunning : public AbstractState
{
private:
  ::bebop_msgs::CommonAudioStateAudioStreamingRunning::Ptr msg_ptr;

public:

  CommonAudioStateAudioStreamingRunning(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_AUDIOSTATE_AUDIOSTREAMINGRUNNING)
  {
    if (priv_nh.getParam("states/enable_audiostate_audiostreamingrunning", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonAudioStateAudioStreamingRunning>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonAudioStateAudioStreamingRunning::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonAudioStateAudioStreamingRunning::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonAudioStateAudioStreamingRunning());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_AUDIOSTATE_AUDIOSTREAMINGRUNNING_RUNNING, arg);
    if (arg)
    {
      msg_ptr->running = arg->value.U8;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonAudioStateAudioStreamingRunning


// Lighting LEDs intensity.
class CommonHeadlightsStateintensityChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonHeadlightsStateintensityChanged::Ptr msg_ptr;

public:

  CommonHeadlightsStateintensityChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_HEADLIGHTSSTATE_INTENSITYCHANGED)
  {
    if (priv_nh.getParam("states/enable_headlightsstate_intensitychanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonHeadlightsStateintensityChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonHeadlightsStateintensityChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonHeadlightsStateintensityChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonHeadlightsStateintensityChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_HEADLIGHTSSTATE_INTENSITYCHANGED_LEFT, arg);
    if (arg)
    {
      msg_ptr->left = arg->value.U8;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_HEADLIGHTSSTATE_INTENSITYCHANGED_RIGHT, arg);
    if (arg)
    {
      msg_ptr->right = arg->value.U8;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonHeadlightsStateintensityChanged


// Paramaterless animations state list.
class CommonAnimationsStateList : public AbstractState
{
private:
  ::bebop_msgs::CommonAnimationsStateList::Ptr msg_ptr;

public:

  CommonAnimationsStateList(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_ANIMATIONSSTATE_LIST)
  {
    if (priv_nh.getParam("states/enable_animationsstate_list", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonAnimationsStateList>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonAnimationsStateList::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonAnimationsStateList::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonAnimationsStateList());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_ANIMATIONSSTATE_LIST_ANIM, arg);
    if (arg)
    {
      msg_ptr->anim = arg->value.I32;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_ANIMATIONSSTATE_LIST_STATE, arg);
    if (arg)
    {
      msg_ptr->state = arg->value.I32;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_ANIMATIONSSTATE_LIST_ERROR, arg);
    if (arg)
    {
      msg_ptr->error = arg->value.I32;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonAnimationsStateList


// Supported accessories list.
class CommonAccessoryStateSupportedAccessoriesListChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonAccessoryStateSupportedAccessoriesListChanged::Ptr msg_ptr;

public:

  CommonAccessoryStateSupportedAccessoriesListChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_ACCESSORYSTATE_SUPPORTEDACCESSORIESLISTCHANGED)
  {
    if (priv_nh.getParam("states/enable_accessorystate_supportedaccessorieslistchanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonAccessoryStateSupportedAccessoriesListChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonAccessoryStateSupportedAccessoriesListChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonAccessoryStateSupportedAccessoriesListChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonAccessoryStateSupportedAccessoriesListChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_ACCESSORYSTATE_SUPPORTEDACCESSORIESLISTCHANGED_ACCESSORY, arg);
    if (arg)
    {
      msg_ptr->accessory = arg->value.I32;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonAccessoryStateSupportedAccessoriesListChanged


// Accessory config.
class CommonAccessoryStateAccessoryConfigChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonAccessoryStateAccessoryConfigChanged::Ptr msg_ptr;

public:

  CommonAccessoryStateAccessoryConfigChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_ACCESSORYSTATE_ACCESSORYCONFIGCHANGED)
  {
    if (priv_nh.getParam("states/enable_accessorystate_accessoryconfigchanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonAccessoryStateAccessoryConfigChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonAccessoryStateAccessoryConfigChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonAccessoryStateAccessoryConfigChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonAccessoryStateAccessoryConfigChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_ACCESSORYSTATE_ACCESSORYCONFIGCHANGED_NEWACCESSORY, arg);
    if (arg)
    {
      msg_ptr->newAccessory = arg->value.I32;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_ACCESSORYSTATE_ACCESSORYCONFIGCHANGED_ERROR, arg);
    if (arg)
    {
      msg_ptr->error = arg->value.I32;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonAccessoryStateAccessoryConfigChanged


// Availability to declare or not an accessory.
class CommonAccessoryStateAccessoryConfigModificationEnabled : public AbstractState
{
private:
  ::bebop_msgs::CommonAccessoryStateAccessoryConfigModificationEnabled::Ptr msg_ptr;

public:

  CommonAccessoryStateAccessoryConfigModificationEnabled(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_ACCESSORYSTATE_ACCESSORYCONFIGMODIFICATIONENABLED)
  {
    if (priv_nh.getParam("states/enable_accessorystate_accessoryconfigmodificationenabled", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonAccessoryStateAccessoryConfigModificationEnabled>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonAccessoryStateAccessoryConfigModificationEnabled::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonAccessoryStateAccessoryConfigModificationEnabled::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonAccessoryStateAccessoryConfigModificationEnabled());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_ACCESSORYSTATE_ACCESSORYCONFIGMODIFICATIONENABLED_ENABLED, arg);
    if (arg)
    {
      msg_ptr->enabled = arg->value.U8;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonAccessoryStateAccessoryConfigModificationEnabled


// Max charge rate.
class CommonChargerStateMaxChargeRateChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonChargerStateMaxChargeRateChanged::Ptr msg_ptr;

public:

  CommonChargerStateMaxChargeRateChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_CHARGERSTATE_MAXCHARGERATECHANGED)
  {
    if (priv_nh.getParam("states/enable_chargerstate_maxchargeratechanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonChargerStateMaxChargeRateChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonChargerStateMaxChargeRateChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonChargerStateMaxChargeRateChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonChargerStateMaxChargeRateChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_CHARGERSTATE_MAXCHARGERATECHANGED_RATE, arg);
    if (arg)
    {
      msg_ptr->rate = arg->value.I32;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonChargerStateMaxChargeRateChanged


// Current charge state.
class CommonChargerStateCurrentChargeStateChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonChargerStateCurrentChargeStateChanged::Ptr msg_ptr;

public:

  CommonChargerStateCurrentChargeStateChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_CHARGERSTATE_CURRENTCHARGESTATECHANGED)
  {
    if (priv_nh.getParam("states/enable_chargerstate_currentchargestatechanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonChargerStateCurrentChargeStateChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonChargerStateCurrentChargeStateChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonChargerStateCurrentChargeStateChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonChargerStateCurrentChargeStateChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_CHARGERSTATE_CURRENTCHARGESTATECHANGED_STATUS, arg);
    if (arg)
    {
      msg_ptr->status = arg->value.I32;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_CHARGERSTATE_CURRENTCHARGESTATECHANGED_PHASE, arg);
    if (arg)
    {
      msg_ptr->phase = arg->value.I32;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonChargerStateCurrentChargeStateChanged


// Last charge rate.
class CommonChargerStateLastChargeRateChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonChargerStateLastChargeRateChanged::Ptr msg_ptr;

public:

  CommonChargerStateLastChargeRateChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_CHARGERSTATE_LASTCHARGERATECHANGED)
  {
    if (priv_nh.getParam("states/enable_chargerstate_lastchargeratechanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonChargerStateLastChargeRateChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonChargerStateLastChargeRateChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonChargerStateLastChargeRateChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonChargerStateLastChargeRateChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_CHARGERSTATE_LASTCHARGERATECHANGED_RATE, arg);
    if (arg)
    {
      msg_ptr->rate = arg->value.I32;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonChargerStateLastChargeRateChanged


// Charging information.
class CommonChargerStateChargingInfo : public AbstractState
{
private:
  ::bebop_msgs::CommonChargerStateChargingInfo::Ptr msg_ptr;

public:

  CommonChargerStateChargingInfo(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_CHARGERSTATE_CHARGINGINFO)
  {
    if (priv_nh.getParam("states/enable_chargerstate_charginginfo", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonChargerStateChargingInfo>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonChargerStateChargingInfo::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonChargerStateChargingInfo::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonChargerStateChargingInfo());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_CHARGERSTATE_CHARGINGINFO_PHASE, arg);
    if (arg)
    {
      msg_ptr->phase = arg->value.I32;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_CHARGERSTATE_CHARGINGINFO_RATE, arg);
    if (arg)
    {
      msg_ptr->rate = arg->value.I32;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_CHARGERSTATE_CHARGINGINFO_INTENSITY, arg);
    if (arg)
    {
      msg_ptr->intensity = arg->value.U8;
    }

    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_CHARGERSTATE_CHARGINGINFO_FULLCHARGINGTIME, arg);
    if (arg)
    {
      msg_ptr->fullChargingTime = arg->value.U8;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonChargerStateChargingInfo


// Current run id.\n A run id is uniquely identifying a run or a flight.\n For each run is generated on the drone a file which can be used by Academy to sum up the run.\n Also, each medias taken during a run has a filename containing the run id.
class CommonRunStateRunIdChanged : public AbstractState
{
private:
  ::bebop_msgs::CommonRunStateRunIdChanged::Ptr msg_ptr;

public:

  CommonRunStateRunIdChanged(::ros::NodeHandle& nh, ::ros::NodeHandle& priv_nh, const ::std::string& topic)
    : AbstractState(ARCONTROLLER_DICTIONARY_KEY_COMMON_RUNSTATE_RUNIDCHANGED)
  {
    if (priv_nh.getParam("states/enable_runstate_runidchanged", pub_enabled_) && pub_enabled_)
    {
      ARSAL_PRINT(ARSAL_PRINT_INFO, "CB" , "[STATES] Enabling %s", topic.c_str());
      ros_pub_ = nh.advertise<bebop_msgs::CommonRunStateRunIdChanged>(topic, 10, true);
    } // pub_enabled_ is false
  }

  ::bebop_msgs::CommonRunStateRunIdChanged::ConstPtr GetDataCstPtr() const
  {
    ::boost::lock_guard<boost::mutex> lock(mutex_);
    return msg_ptr;
  }

  void Update(const ARCONTROLLER_DICTIONARY_ARG_t *arguments, const ::ros::Time& t)
  {
    if (arguments == NULL)
    {
      ARSAL_PRINT(ARSAL_PRINT_WARNING, "CB", "CommonRunStateRunIdChanged::Update() arguments is NULL");
      return;
    }

    ::boost::lock_guard<boost::mutex> lock(mutex_);
    msg_ptr.reset(new ::bebop_msgs::CommonRunStateRunIdChanged());
    msg_ptr->header.stamp = t;
    msg_ptr->header.frame_id = "base_link";


    arg = NULL;
    HASH_FIND_STR (arguments, ARCONTROLLER_DICTIONARY_KEY_COMMON_RUNSTATE_RUNIDCHANGED_RUNID, arg);
    if (arg)
    {
      msg_ptr->runId = arg->value.String;
    }

    if (pub_enabled_) ros_pub_.publish(msg_ptr);
  }

};  // CommonRunStateRunIdChanged


}  // namespace cb
}  // namespace bebop_driver
#endif  // BEBOP_AUTONOMY_AUTOGENERATED_common_STATE_CALLBACKS_H