settingmanager.cc

Go to the documentation of this file.

#include "ion/base/settingmanager.h"

#include <set>
#include <vector>

#include "ion/base/allocator.h"
#include "ion/base/lockguards.h"
#include "ion/base/logging.h"
#include "ion/base/shareable.h"
#include "ion/base/staticsafedeclare.h"
#include "ion/base/stringutils.h"
#include "ion/port/mutex.h"

namespace ion {
namespace base {

namespace {

static const char kListenerKey[] = "SettingManager";

}  // anonymous namespace

class SettingManager::SettingData : public Shareable {
 public:
  void SettingListener(SettingBase* setting);

  SettingBase* GetSetting(const std::string& name);
  void RegisterSetting(SettingBase* setting);
  void UnregisterSetting(SettingBase* setting);
  void RegisterGroupListener(const std::string& group,
                             const std::string& key,
                             const SettingBase::Listener& listener);
  void EnableGroupListener(const std::string& group, const std::string& key,
                           bool enable);
  void UnregisterGroupListener(const std::string& group,
                               const std::string& key);

  const SettingMap& GetAllSettings() { return settings_; }

  void UnregisterSettingLocked(SettingBase* setting);

 private:
  typedef std::map<std::string, std::vector<std::string> > GroupMap;

  struct SettingGroupInfo {
    typedef std::map<std::string, SettingBase::ListenerInfo> ListenerMap;
    std::set<SettingBase*> settings;
    ListenerMap listeners;
  };
  typedef std::map<std::string, SettingGroupInfo> SettingGroupMap;

  typedef base::SharedPtr<SettingData> SettingDataPtr;

  ~SettingData() override {}

  port::Mutex mutex_;
  SettingMap settings_;
  GroupMap setting_groups_;
  SettingGroupMap groups_;
};




void SettingManager::SettingData::SettingListener(SettingBase* setting) {
  SettingMap::iterator it = settings_.find(setting->GetName());
  DCHECK(it != settings_.end());
  const std::vector<std::string>& group_names =
      setting_groups_[setting->GetName()];
  const size_t count = group_names.size();
  for (size_t i = 0; i < count; ++i) {
    const SettingGroupInfo& group_info = groups_[group_names[i]];
    for (SettingGroupInfo::ListenerMap::const_iterator it =
             group_info.listeners.begin(); it != group_info.listeners.end();
         ++it)
      if (it->second.enabled)
        it->second.listener(setting);
  }
}

SettingBase* SettingManager::SettingData::GetSetting(const std::string& name) {
  SettingMap::const_iterator it = settings_.find(name);
  return it == settings_.end() ? NULL : it->second;
}

void SettingManager::SettingData::RegisterSetting(SettingBase* setting) {
  DCHECK(setting);
  const std::string& name = setting->GetName();

  {
    LockGuard lock(&mutex_);

    SettingMap::const_iterator it = settings_.find(name);
    if (it != settings_.end()) {
      LOG(WARNING) << "Duplicate setting named '" << name
                   << "' registered in SettingManager";
      UnregisterSettingLocked(setting);
    }
    std::vector<std::string> group_names = SplitString(name, "/");
    if (group_names.size() > 1)
      group_names.pop_back();

    const size_t count = group_names.size();
    for (size_t i = 0; i < count; ++i) {
      if (i)
        group_names[i] = group_names[i - 1U] + "/" + group_names[i];
      groups_[group_names[i]].settings.insert(setting);
    }

    settings_[name] = setting;
    setting_groups_[name] = group_names;

    setting->RegisterListener(
        kListenerKey,
        std::bind(&SettingData::SettingListener, this, std::placeholders::_1));

    setting->data_ref_ = this;
  }  // unlock mutex
}

void SettingManager::SettingData::UnregisterSetting(SettingBase* setting) {
  DCHECK(setting);

  LockGuard lock(&mutex_);
  UnregisterSettingLocked(setting);
}

void SettingManager::SettingData::UnregisterSettingLocked(
    SettingBase* setting) {
  DCHECK(mutex_.IsLocked());
  SettingMap::iterator it = settings_.find(setting->GetName());
  if (it != settings_.end() && it->second == setting) {
    const std::vector<std::string>& group_names =
        setting_groups_[setting->GetName()];

    const size_t count = group_names.size();
    for (size_t i = 0; i < count; ++i)
      groups_[group_names[i]].settings.erase(it->second);

    settings_.erase(it);
  }
  setting->UnregisterListener(kListenerKey);
}

void SettingManager::SettingData::RegisterGroupListener(
    const std::string& group,
    const std::string& key,
    const SettingBase::Listener& listener) {
  SettingGroupMap::iterator it = groups_.find(group);
  if (it != groups_.end())
    it->second.listeners[key] = SettingBase::ListenerInfo(listener, true);
}

void SettingManager::SettingData::EnableGroupListener(const std::string& group,
                                                      const std::string& key,
                                                      bool enable) {
  SettingGroupMap::iterator it = groups_.find(group);
  if (it != groups_.end())
    it->second.listeners[key].enabled = enable;
}

void SettingManager::SettingData::UnregisterGroupListener(
    const std::string& group,
    const std::string& key) {
  SettingGroupMap::iterator it = groups_.find(group);
  if (it != groups_.end())
    it->second.listeners.erase(key);
}




SettingManager::SettingManager() : data_(new SettingData) {
}

SettingManager::~SettingManager() {
}

SettingBase* SettingManager::GetSetting(const std::string& name) {
  return GetInstance()->data_->GetSetting(name);
}

const SettingManager::SettingMap& SettingManager::GetAllSettings() {
  return GetInstance()->data_->GetAllSettings();
}

void SettingManager::RegisterSetting(SettingBase* setting) {
  GetInstance()->data_->RegisterSetting(setting);
}

void SettingManager::UnregisterSetting(SettingBase* setting) {
  SettingData* data = static_cast<SettingData*>(setting->data_ref_.Get());
  data->UnregisterSetting(setting);
}

void SettingManager::RegisterGroupListener(
    const std::string& group,
    const std::string& key,
    const SettingBase::Listener& listener) {
  GetInstance()->data_->RegisterGroupListener(group, key, listener);
}

void SettingManager::EnableGroupListener(const std::string& group,
                                         const std::string& key,
                                         bool enable) {
  GetInstance()->data_->EnableGroupListener(group, key, enable);
}

void SettingManager::UnregisterGroupListener(const std::string& group,
                                             const std::string& key) {
  GetInstance()->data_->UnregisterGroupListener(group, key);
}

SettingManager* SettingManager::GetInstance() {
  ION_DECLARE_SAFE_STATIC_POINTER(SettingManager, manager);
  return manager;
}

}  // namespace base
}  // namespace ion