ConfigAdmin.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef RTC_CONFIGADMIN_H
#define RTC_CONFIGADMIN_H

#include <string>
#include <vector>
#include <iostream>
#include <coil/Properties.h>
#include <coil/stringutil.h>
#include <rtm/ConfigurationListener.h>

namespace RTC
{
  typedef ConfigurationSetNameListener OnUpdateCallback;

  typedef ConfigurationParamListener OnUpdateParamCallback;

  typedef ConfigurationSetListener OnSetConfigurationSetCallback;

  typedef ConfigurationSetListener OnAddConfigurationAddCallback;

  typedef ConfigurationSetNameListener OnRemoveConfigurationSetCallback;

  typedef ConfigurationSetNameListener OnActivateSetCallback;


  //============================================================
  // ConfigBase class
  //============================================================
  struct ConfigBase
  {
    ConfigBase(const char* name_, const char* def_val)
      : name(name_), default_value(def_val) {}
    
    virtual ~ConfigBase(void){};
    
    virtual bool update(const char* val) = 0;
    
    const char* name;
    
    const char* default_value;
  };
  
  //============================================================
  // Config template class
  //============================================================
  template <typename VarType,
            typename TransFunc = bool (*)(VarType&, const char*)>
  class Config
    : public ConfigBase
  {
  public:
    Config(const char* name, VarType& var, const char* def_val,
           TransFunc trans = coil::stringTo)
      : ConfigBase(name, def_val), m_var(var), m_trans(trans)
    {
    }
    
    virtual ~Config(void){}
    
    virtual bool update(const char* val)
    {
      if ((*m_trans)(m_var, val)) { return true; }
      (*m_trans)(m_var, default_value);
      return false;
    }
    
  protected:
    VarType& m_var;
    
    TransFunc m_trans;
  };
  
  //============================================================
  // ConfigAdmin class
  //============================================================
  class ConfigAdmin
  {
  public:
    ConfigAdmin(coil::Properties& prop);
    
    ~ConfigAdmin(void);
    
    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 == 0) { return false; }
      if (def_val == 0) { return false; }
      if (isExist(param_name)) { return false; }
      if (!trans(var, def_val)) { return false; }
      m_params.push_back(new Config<VarType>(param_name, var, def_val, trans));
      return true;
    }
        
    void update(void);

    void update(const char* config_set);
    
    void update(const char* config_set, const char* config_param);
    
    bool isExist(const char* name);
    
    bool isChanged(void) {return m_changed;}
    
    const char* getActiveId(void) {return m_activeId.c_str();}
    
    bool haveConfig(const char* config_id)
    {
      return (m_configsets.hasKey(config_id) == NULL) ? false : true;
    }
    
    bool isActive(void)
    {
      return m_active;
    }
    //    const std::vector<Properties*>* getConfigurationParameterValues();
    //    const Properties* getConfigurationParameterValue(const char* name);
    //    bool setConfigurationParameter(const char* name, const char* value);
    
    const std::vector<coil::Properties*>& getConfigurationSets(void);
    
    const coil::Properties& getConfigurationSet(const char* config_id);
    
    bool setConfigurationSetValues(const coil::Properties& configuration_set);
    
    const coil::Properties& getActiveConfigurationSet(void);
    
    bool addConfigurationSet(const coil::Properties& configuration_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_set, const char* config_param);

    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);
    ConfigAdmin& operator=(const ConfigAdmin& ca);
    
    struct find_conf
    {
      std::string m_name;
      find_conf(const char* name) : m_name(name) {};
      bool operator()(ConfigBase* conf)
      {
        if (conf == 0) { 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;
    std::vector<std::string> m_newConfig;
    ConfigurationListeners m_listeners;

  };
}; // namespace RTC
#endif // RTC_CONFIGADMIN_H