ConfigurationListener.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef RTC_CONFIGURATIONLISTENER_H
#define RTC_CONFIGURATIONLISTENER_H
 
#include <coil/Properties.h>
#include <mutex>
 
#include <utility>
#include <vector>
#include <array>
 
namespace RTC
{
  //============================================================
  enum class ConfigurationParamListenerType : uint8_t
    {
      ON_UPDATE_CONFIG_PARAM,
      CONFIG_PARAM_LISTENER_NUM
    };
 
 
  class ConfigurationParamListener
  {
  public:
    static const char* toString(ConfigurationParamListenerType type)
    {
      if (type < ConfigurationParamListenerType::CONFIG_PARAM_LISTENER_NUM)
        {
          static const char* const typeString[] =
          {
            "ON_UPDATE_CONFIG_PARAM",
            "CONFIG_PARAM_LISTENER_NUM"
          };
          return typeString[static_cast<uint8_t>(type)];
        }
      return "";
    }
 
    virtual ~ConfigurationParamListener();
 
    virtual void operator()(const char* config_set_name,
                            const char* config_param_name) = 0;
  };
 
 
  //============================================================
  enum class ConfigurationSetListenerType : uint8_t
    {
      ON_SET_CONFIG_SET,
      ON_ADD_CONFIG_SET,
      CONFIG_SET_LISTENER_NUM
    };
 
  class ConfigurationSetListener
  {
  public:
    static const char* toString(ConfigurationSetListenerType type)
    {
      if (type < ConfigurationSetListenerType::CONFIG_SET_LISTENER_NUM)
        {
          static const char* const typeString[] =
          {
            "ON_SET_CONFIG_SET",
            "ON_ADD_CONFIG_SET",
            "CONFIG_SET_LISTENER_NUM"
          };
          return typeString[static_cast<uint8_t>(type)];
        }
      return "";
    }
 
    virtual ~ConfigurationSetListener();
 
    virtual void operator()(const coil::Properties& config_set) = 0;
  };
 
 
  //============================================================
  enum class ConfigurationSetNameListenerType : uint8_t
    {
      ON_UPDATE_CONFIG_SET,
      ON_REMOVE_CONFIG_SET,
      ON_ACTIVATE_CONFIG_SET,
      CONFIG_SET_NAME_LISTENER_NUM
    };
 
  class ConfigurationSetNameListener
  {
  public:
    static const char* toString(ConfigurationSetNameListenerType type)
    {
      if (type < ConfigurationSetNameListenerType::CONFIG_SET_NAME_LISTENER_NUM)
        {
          static const char* const typeString[] =
          {
            "ON_UPDATE_CONFIG_SET",
            "ON_REMOVE_CONFIG_SET",
            "ON_ACTIVATE_CONFIG_SET",
            "CONFIG_SET_NAME_LISTENER_NUM"
          };
          return typeString[static_cast<uint8_t>(type)];
        }
      return "";
    }
 
    virtual ~ConfigurationSetNameListener();
 
    virtual void operator()(const char* config_set_name) = 0;
  };
 
 
  class ConfigurationParamListenerHolder
  {
    using Entry = std::pair<ConfigurationParamListener*, bool>;
  public:
    ConfigurationParamListenerHolder();
    virtual ~ConfigurationParamListenerHolder();
 
    void addListener(ConfigurationParamListener* listener, bool autoclean);
 
    void removeListener(ConfigurationParamListener* listener);
 
    void notify(const char* config_set_name, const char* config_param_name);
 
  private:
    std::vector<Entry> m_listeners;
    std::mutex m_mutex;
  };
 
 
  //============================================================
  class ConfigurationSetListenerHolder
  {
    using Entry = std::pair<ConfigurationSetListener*, bool>;
  public:
    ConfigurationSetListenerHolder();
    virtual ~ConfigurationSetListenerHolder();
 
    void addListener(ConfigurationSetListener* listener, bool autoclean);
 
    void removeListener(ConfigurationSetListener* listener);
 
    void notify(const coil::Properties& config_set);
 
  private:
    std::vector<Entry> m_listeners;
    std::mutex m_mutex;
  };
 
 
  //============================================================
  class ConfigurationSetNameListenerHolder
  {
    using Entry = std::pair<ConfigurationSetNameListener*, bool>;
  public:
    ConfigurationSetNameListenerHolder();
 
    virtual ~ConfigurationSetNameListenerHolder();
 
    void addListener(ConfigurationSetNameListener* listener, bool autoclean);
 
    void removeListener(ConfigurationSetNameListener* listener);
 
    void notify(const char* config_set_name);
 
  private:
    std::vector<Entry> m_listeners;
    std::mutex m_mutex;
  };
 
  //------------------------------------------------------------
  class ConfigurationListeners
  {
  public:
    ~ConfigurationListeners();
    bool addListener(ConfigurationParamListenerType type, ConfigurationParamListener* listener, bool autoclean=true);
    bool removeListener(ConfigurationParamListenerType type, ConfigurationParamListener* listener);
    bool addListener(ConfigurationSetListenerType type, ConfigurationSetListener* listener, bool autoclean=true);
    bool removeListener(ConfigurationSetListenerType type, ConfigurationSetListener* listener);
    bool addListener(ConfigurationSetNameListenerType type, ConfigurationSetNameListener* listener, bool autoclean=true);
    bool removeListener(ConfigurationSetNameListenerType type, ConfigurationSetNameListener* listener);
    inline bool notify(ConfigurationParamListenerType type, const char* config_set_name, const char* config_param_name)
    {
        if (static_cast<uint8_t>(type) < configparam_.size())
        {
            configparam_[static_cast<uint8_t>(type)].notify(config_set_name, config_param_name);
            return true;
        }
        return false;
    }
    inline bool notify(ConfigurationSetListenerType type, const coil::Properties& config_set)
    {
        if (static_cast<uint8_t>(type) < configset_.size())
        {
            configset_[static_cast<uint8_t>(type)].notify(config_set);
            return true;
        }
        return false;
    }
    inline bool notify(ConfigurationSetNameListenerType type, const char* config_set_name)
    {
        if (static_cast<uint8_t>(type) < configsetname_.size())
        {
            configsetname_[static_cast<uint8_t>(type)].notify(config_set_name);
            return true;
        }
        return false;
    }
  private:
    std::array<ConfigurationParamListenerHolder, static_cast<uint8_t>(ConfigurationParamListenerType::CONFIG_PARAM_LISTENER_NUM)> configparam_;
    std::array<ConfigurationSetListenerHolder, static_cast<uint8_t>(ConfigurationSetListenerType::CONFIG_SET_LISTENER_NUM)> configset_;
    std::array<ConfigurationSetNameListenerHolder, static_cast<uint8_t>(ConfigurationSetNameListenerType::CONFIG_SET_NAME_LISTENER_NUM)> configsetname_;
  };
 
 
} // namespace RTC
 
#endif  // RTC_CONFIGURATIONLISTENER_H