ConfigAdmin.h

[詳解]

// -*- C++ -*-
#ifndef RTC_CONFIGADMIN_H
#define RTC_CONFIGADMIN_H
 
#include <coil/Properties.h>
#include <coil/stringutil.h>
#include <rtm/ConfigurationListener.h>
 
#include <string>
#include <vector>
#include <iostream>
 
namespace RTC
{
  using OnUpdateCallback = ConfigurationSetNameListener;
 
  using OnUpdateParamCallback = ConfigurationParamListener;
 
  using OnSetConfigurationSetCallback = ConfigurationSetListener;
 
  using OnAddConfigurationAddCallback = ConfigurationSetListener;
 
  using OnRemoveConfigurationSetCallback = ConfigurationSetNameListener;
 
  using OnActivateSetCallback = ConfigurationSetNameListener;
 
  // forward decl
  class ConfigAdmin;
 
  //============================================================
  // ConfigBase class
  //============================================================
  struct ConfigBase
  {
    ConfigBase(const char* name_, const char* def_val)
      : name(name_), default_value(def_val),
        string_value(""), m_admin(nullptr), m_callback(nullptr)
    {}
 
    virtual ~ConfigBase() = default;
 
    // typedef of ConfigAdmin's member function
    using CallbackFunc = void (ConfigAdmin::*)(const char *, const char*);
 
    void setCallback(ConfigAdmin* cadmin, CallbackFunc cbf);
 
    void notifyUpdate(const char* key, const char* val);
 
    virtual bool update(const char* val) = 0;
 
    const char* name;
 
    const char* default_value;
 
  protected:
    std::string string_value;
    ConfigAdmin* m_admin;
    CallbackFunc m_callback;
  };
 
  //============================================================
  // Config template class
  //============================================================
  template <typename VarType,
            typename TransFunc = bool (*)(VarType&, const char*)>
  class Config
    : public ConfigBase
  {
  public:
    Config(const char* conf_name, VarType& var, const char* def_val,
           TransFunc trans = coil::stringTo)
      : ConfigBase(conf_name, def_val), m_var(var), m_trans(trans)
    {
    }
 
    ~Config() override = default;
 
    bool update(const char* val) override
    {
      if (string_value == val) { return true; }
      string_value = val;
      // value changed
      if ((*m_trans)(m_var, val))
        {
          notifyUpdate(name, val);
          return true;
        }
      (*m_trans)(m_var, default_value);
      notifyUpdate(name, val);
      return false;
    }
 
  protected:
    VarType& m_var;
 
    TransFunc m_trans;
  };
 
  //============================================================
  // ConfigAdmin class
  //============================================================
  class ConfigAdmin
  {
  public:
    explicit ConfigAdmin(coil::Properties& configsets);
 
    ~ConfigAdmin();
 
    template <typename VarType>
    bool bindParameter(const char* param_name, VarType& var,
                       const char* def_val,
                       bool (*trans)(VarType&, const char*) = coil::stringTo)
    {
      if (param_name == nullptr) { return false; }
      if (def_val == nullptr) { return false; }
      if (isExist(param_name)) { return false; }
      if (!trans(var, def_val)) { return false; }
      Config<VarType>* c = new Config<VarType>(param_name, var, def_val, trans);
      m_params.emplace_back(c);
      c->setCallback(this, &RTC::ConfigAdmin::onUpdateParam);
      update(getActiveId(), param_name);
      return true;
    }
 
    bool unbindParameter(const char* param_name);
 
    void update();
 
    void update(const char* config_set);
 
    void update(const char* config_set, const char* config_param);
 
    bool isExist(const char* param_name);
 
    bool isChanged() {return m_changed;}
 
    coil::vstring& changedParameters() { return m_changedParam; }
 
    const char* getActiveId() {return m_activeId.c_str();}
 
    bool haveConfig(const char* config_id)
    {
      return (m_configsets.hasKey(config_id) == nullptr) ? false : true;
    }
 
    bool isActive()
    {
      return m_active;
    }
 
    const std::vector<coil::Properties*>& getConfigurationSets();
 
    const coil::Properties& getConfigurationSet(const char* config_id);
 
    bool setConfigurationSetValues(const coil::Properties& config_set);
 
    const coil::Properties& getActiveConfigurationSet();
 
    bool addConfigurationSet(const coil::Properties& config_set);
 
    bool removeConfigurationSet(const char* config_id);
 
    bool activateConfigurationSet(const char* config_id);
 
    //------------------------------------------------------------
    // obsolete functions
    //
    void setOnUpdate(OnUpdateCallback* cb);
 
    void setOnUpdateParam(OnUpdateParamCallback* cb);
 
    void setOnSetConfigurationSet(OnSetConfigurationSetCallback* cb);
 
    void setOnAddConfigurationSet(OnAddConfigurationAddCallback* cb);
 
    void setOnRemoveConfigurationSet(OnRemoveConfigurationSetCallback* cb);
 
    void setOnActivateSet(OnActivateSetCallback* cb);
    //
    // end of obsolete functions
    //------------------------------------------------------------
 
    void addConfigurationParamListener(ConfigurationParamListenerType type,
                                       ConfigurationParamListener* listener,
                                       bool autoclean = true);
 
    void removeConfigurationParamListener(ConfigurationParamListenerType type,
                                          ConfigurationParamListener* listener);
 
    void addConfigurationSetListener(ConfigurationSetListenerType type,
                                     ConfigurationSetListener* listener,
                                     bool autoclean = true);
 
    void removeConfigurationSetListener(ConfigurationSetListenerType type,
                                        ConfigurationSetListener* listener);
 
    void
    addConfigurationSetNameListener(ConfigurationSetNameListenerType type,
                                    ConfigurationSetNameListener* listener,
                                    bool autoclean = true);
 
    void
    removeConfigurationSetNameListener(ConfigurationSetNameListenerType type,
                                       ConfigurationSetNameListener* listener);
 
  protected:
    void onUpdate(const char* config_set);
 
    void onUpdateParam(const char* config_param, const char* config_value);
 
    void onSetConfigurationSet(const coil::Properties& config_set);
 
    void onAddConfigurationSet(const coil::Properties& config_set);
 
    void onRemoveConfigurationSet(const char* config_id);
 
    void onActivateSet(const char* config_id);
 
  private:
    ConfigAdmin(const ConfigAdmin& ca) = delete;
    ConfigAdmin& operator=(const ConfigAdmin& ca) = delete;
 
    struct find_conf
    {
      std::string m_name;
      explicit find_conf(const char* name) : m_name(name) {}
      bool operator()(ConfigBase* conf)
      {
        if (conf == nullptr) { return false; }
        return (m_name == conf->name);
      }
    };
 
    coil::Properties& m_configsets;
    coil::Properties  m_emptyconf;
    std::vector<ConfigBase*> m_params;
    std::string m_activeId;
    bool m_active;
    bool m_changed;
    coil::vstring m_changedParam;
    coil::vstring m_newConfig;
    ConfigurationListeners m_listeners;
 
  };
} // namespace RTC
#endif  // RTC_CONFIGADMIN_H