ConfigAdmin.cpp

Go to the documentation of this file.

// -*- C++ -*-
#include <rtm/ConfigAdmin.h>
#include <algorithm>
#include <assert.h>
#include <string.h>

namespace RTC
{
  ConfigAdmin::ConfigAdmin(coil::Properties& configsets)
    : m_configsets(configsets), m_activeId("default"),
      m_active(true), m_changed(false)
  {
  }
  
  ConfigAdmin::~ConfigAdmin(void)
  {
    for (int i(0), len(m_params.size()); i < len; ++i)
      {
        if (m_params[i] != NULL) { delete m_params[i]; }
      }
    m_params.clear();
  }
  

  void ConfigAdmin::update(void)
  {
    if (m_changed && m_active)
      {
        update(m_activeId.c_str());
        m_changed = false;
      }
    return;
  }


  void ConfigAdmin::update(const char* config_set)
  {
    if (m_configsets.hasKey(config_set) == NULL) { return; }
    
    coil::Properties& prop(m_configsets.getNode(config_set));
    
    for (int i(0), len(m_params.size()); i < len; ++i)
      {
        if (prop.hasKey(m_params[i]->name) != NULL)
          {
            m_params[i]->update(prop[m_params[i]->name].c_str());
            onUpdate(config_set);
          }
      }
  }


  void ConfigAdmin::update(const char* config_set, const char* config_param)
  {
    if ((config_set == 0) || (config_param == 0)) { return; }

    std::string key(config_set);
    key += "."; key += config_param;
    
    std::vector<ConfigBase*>::iterator it;
    it = std::find_if(m_params.begin(), m_params.end(),
                      find_conf(config_param));
    if (it != m_params.end())
      {
        (*it)->update(m_configsets[key].c_str());
        onUpdateParam(config_set, config_param);
        return;
      }
  }


  bool ConfigAdmin::isExist(const char* param_name)
  {
    std::vector<ConfigBase*>::iterator it;
    it = std::find_if(m_params.begin(), m_params.end(),
                      find_conf(param_name));
    if (it != m_params.end())
      {
        return true;
      }
    return false;
  }
  
  
  const std::vector<coil::Properties*>& ConfigAdmin::getConfigurationSets(void)
  {
    return m_configsets.getLeaf();
  }
  
  const coil::Properties&
  ConfigAdmin::getConfigurationSet(const char* config_id)
  {
    coil::Properties* p(m_configsets.findNode(config_id));
    if (p == 0) { return m_emptyconf; }
    return *p;
  }
  
  bool
  ConfigAdmin::setConfigurationSetValues(const coil::Properties& config_set)
  {
    std::string node(config_set.getName());
    if (node.empty()) { return false; }
    
    coil::Properties& p(m_configsets.getNode(config_set.getName()));

    p << config_set;
    m_changed = true;
    m_active = false;
    onSetConfigurationSet(config_set);
    return true;
  }
  
  const coil::Properties& ConfigAdmin::getActiveConfigurationSet(void)
  {
    coil::Properties& p(m_configsets.getNode(m_activeId));

    return p;
  }
  
  bool ConfigAdmin::addConfigurationSet(const coil::Properties& config_set)
  {
    std::string node(config_set.getName());
    if (node.empty()) { return false; }
    if (m_configsets.hasKey(node.c_str()) != 0) { return false; }
    
    coil::Properties& p(m_configsets.getNode(node));
    p << config_set;
    m_newConfig.push_back(node);
    
    m_changed = true;
    m_active = false;
    onAddConfigurationSet(config_set);
    return true;
  }
  
  bool ConfigAdmin::removeConfigurationSet(const char* config_id)
  {
    if (strcmp(config_id, "default") == 0) return false;
    if (m_activeId == config_id) return false;

    // removeable config-set is only config-sets newly added
    std::vector<std::string>::iterator it;
    it = std::find(m_newConfig.begin(), m_newConfig.end(), config_id);
    if (it == m_newConfig.end()) { return false; }
    
    coil::Properties* p(m_configsets.removeNode(config_id));
    if (p != NULL) { delete p; }
    m_newConfig.erase(it);
    
    m_changed = true;
    m_active = false;
    onRemoveConfigurationSet(config_id);
    return true;
  }
  
  bool ConfigAdmin::activateConfigurationSet(const char* config_id)
  {
    if (config_id == NULL) { return false; }
    // '_<conf_name>' is special configuration set name
    if (config_id[0] == '_') { return false; }

    if (m_configsets.hasKey(config_id) == 0) { return false; }
    m_activeId = config_id;
    m_active = true;
    m_changed = true;
    onActivateSet(config_id);
    return true;
  }

  //------------------------------------------------------------
  // obsolete functions
  //
  void ConfigAdmin::setOnUpdate(OnUpdateCallback* cb)
  {
    std::cerr << "setOnUpdate function is obsolete." << std::endl;
    std::cerr << "Use addConfigurationSetNameListener instead." << std::endl;
    m_listeners.configsetname_[ON_UPDATE_CONFIG_SET].addListener(cb, false);
  }

  void ConfigAdmin::setOnUpdateParam(OnUpdateParamCallback* cb)
  {
    std::cerr << "setOnUpdateParam function is obsolete." << std::endl;
    std::cerr << "Use addConfigurationParamListener instead." << std::endl;
    m_listeners.configparam_[ON_UPDATE_CONFIG_PARAM].addListener(cb, false);
  }

  void ConfigAdmin::setOnSetConfigurationSet(OnSetConfigurationSetCallback* cb)
  {
    std::cerr << "setOnSetConfigurationSet function is obsolete." << std::endl;
    std::cerr << "Use addConfigurationSetListener instead." << std::endl;
    m_listeners.configset_[ON_SET_CONFIG_SET].addListener(cb, false);
  }

  void ConfigAdmin::setOnAddConfigurationSet(OnAddConfigurationAddCallback* cb)
  {
    std::cerr << "setOnAddConfigurationSet function is obsolete." << std::endl;
    std::cerr << "Use addConfigurationSetListener instead." << std::endl;
    m_listeners.configset_[ON_ADD_CONFIG_SET].addListener(cb, false);
  }

  void
  ConfigAdmin::setOnRemoveConfigurationSet(OnRemoveConfigurationSetCallback* cb)
  {
    std::cerr << "setOnRemoveConfigurationSet function is obsolete."<<std::endl;
    std::cerr << "Use addConfigurationSetNameListener instead." << std::endl;
    m_listeners.configsetname_[ON_REMOVE_CONFIG_SET].addListener(cb, false);
  }

  void ConfigAdmin::setOnActivateSet(OnActivateSetCallback* cb)
  {
    std::cerr << "setOnActivateSet function is obsolete." << std::endl;
    std::cerr << "Use addConfigurationSetNameListener instead." << std::endl;
    m_listeners.configsetname_[ON_ACTIVATE_CONFIG_SET].addListener(cb, false);
  }
  //
  // end of obsolete functions
  //------------------------------------------------------------

  void ConfigAdmin::
  addConfigurationParamListener(ConfigurationParamListenerType type,
                                ConfigurationParamListener* listener,
                                bool autoclean)
  {
    m_listeners.configparam_[type].addListener(listener, autoclean);
  }

  void ConfigAdmin::
  removeConfigurationParamListener(ConfigurationParamListenerType type,
                                   ConfigurationParamListener* listener)
  {
    m_listeners.configparam_[type].removeListener(listener);
  }
    
  void ConfigAdmin::
  addConfigurationSetListener(ConfigurationSetListenerType type,
                              ConfigurationSetListener* listener,
                              bool autoclean)
  {
    m_listeners.configset_[type].addListener(listener, autoclean);
  }

  void ConfigAdmin::
  removeConfigurationSetListener(ConfigurationSetListenerType type,
                                 ConfigurationSetListener* listener)
  {
    m_listeners.configset_[type].removeListener(listener);
  }
    
  void ConfigAdmin::
  addConfigurationSetNameListener(ConfigurationSetNameListenerType type,
                                  ConfigurationSetNameListener* listener,
                                  bool autoclean)
  {
    m_listeners.configsetname_[type].addListener(listener, autoclean);
  }

  void ConfigAdmin::
  removeConfigurationSetNameListener(ConfigurationSetNameListenerType type,
                                     ConfigurationSetNameListener* listener)
  {
    m_listeners.configsetname_[type].removeListener(listener);
  }

  //------------------------------------------------------------
  // protected functions
  void ConfigAdmin::onUpdate(const char* config_set)
  {
    m_listeners.configsetname_[ON_UPDATE_CONFIG_SET].notify(config_set);
  }

  void
  ConfigAdmin::onUpdateParam(const char* config_set, const char* config_param)
  {
    m_listeners.configparam_[ON_UPDATE_CONFIG_PARAM].notify(config_set,
                                                            config_param);
  }

  void ConfigAdmin::onSetConfigurationSet(const coil::Properties& config_set)
  {
    m_listeners.configset_[ON_SET_CONFIG_SET].notify(config_set);
  }

  void ConfigAdmin::onAddConfigurationSet(const coil::Properties& config_set)
  {
    m_listeners.configset_[ON_ADD_CONFIG_SET].notify(config_set);
  }

  void ConfigAdmin::onRemoveConfigurationSet(const char* config_id)
  {
    m_listeners.configsetname_[ON_REMOVE_CONFIG_SET].notify(config_id);
  }

  void ConfigAdmin::onActivateSet(const char* config_id)
  {
    m_listeners.configsetname_[ON_ACTIVATE_CONFIG_SET].notify(config_id);
  }
  

}; // namespace RTC