setting.h

Go to the documentation of this file.

#ifndef ION_BASE_SETTING_H_
#define ION_BASE_SETTING_H_

#include <functional>
#include <map>
#include <sstream>
#include <string>

#include "base/macros.h"
#include "ion/base/serialize.h"
#include "ion/base/shareable.h"
#include "ion/base/sharedptr.h"
#include "ion/base/stringutils.h"
#include "ion/port/atomic.h"
#include "ion/port/environment.h"

namespace ion {
namespace base {

class ION_API SettingBase {
 public:
  typedef std::function<void(SettingBase* setting)> Listener;
  struct ListenerInfo {
    ListenerInfo() : enabled(false) {}
    ListenerInfo(const Listener& listener_in, bool enabled_in)
        : listener(listener_in), enabled(enabled_in) {}
    Listener listener;
    bool enabled;
  };

  const std::string& GetName() const { return name_; }

  const std::string& GetDocString() const { return doc_string_; }

  void SetTypeDescriptor(const std::string& desc) { type_descriptor_ = desc; }
  const std::string& GetTypeDescriptor() const { return type_descriptor_; }

  void RegisterListener(const std::string& key, const Listener& listener);
  void EnableListener(const std::string& key, bool enable);
  void UnregisterListener(const std::string& key);

  void NotifyListeners();

  virtual const std::string ToString() const = 0;
  virtual bool FromString(const std::string& str) = 0;

 protected:
  SettingBase(const std::string& name, const std::string& doc_string);
  virtual ~SettingBase();

 private:
  typedef std::map<std::string, ListenerInfo> ListenerMap;

  std::string name_;
  std::string doc_string_;
  std::string type_descriptor_;
  ListenerMap listeners_;

  friend class SettingManager;
  SharedPtr<Shareable> data_ref_;

  DISALLOW_IMPLICIT_CONSTRUCTORS(SettingBase);
};

class ION_API SettingGroup {
 public:
  explicit SettingGroup(const std::string& name) : group_(name) {
    while (base::EndsWith(group_, "/"))
      base::RemoveSuffix("/", &group_);
  }
  SettingGroup(const SettingGroup& parent_group, std::string name) {
    while (base::StartsWith(name, "/"))
      base::RemovePrefix("/", &name);
    while (base::EndsWith(name, "/"))
      base::RemoveSuffix("/", &name);
    group_ = parent_group.GetGroupName() + "/" + name;
  }
  ~SettingGroup() {}

  const std::string GetGroupName() const { return group_; }

 private:
  std::string group_;
};

template <typename T> class Setting;
template <typename SettingType>
void SetTypeDescriptorForType(SettingType* setting);

template <typename T>
class Setting : public SettingBase {
 public:
  Setting(const std::string& name, const T& value,
          const std::string& doc_string)
      : SettingBase(name, doc_string), value_(value) {
    SetTypeDescriptorForType(this);
  }

  Setting(const SettingGroup* group, const std::string& name, const T& value,
          const std::string& doc_string)
      : SettingBase(group->GetGroupName() + '/' + name, doc_string),
        value_(value) {
    SetTypeDescriptorForType(this);
  }

  Setting(const std::string& name, const T& value)
      : SettingBase(name, std::string()), value_(value) {
    SetTypeDescriptorForType(this);
  }

  Setting(const SettingGroup* group, const std::string& name, const T& value)
      : SettingBase(group->GetGroupName()  + '/' + name, std::string()),
        value_(value) {
    SetTypeDescriptorForType(this);
  }

  ~Setting() override {}

  const std::string ToString() const override { return ValueToString(value_); }

  bool FromString(const std::string& str) override {
    T value = T();
    std::istringstream in(str);
    if (StringToValue(in, &value)) {
      SetValue(value);
      return true;
    }
    return false;
  }

  T* GetMutableValue() { return &value_; }
  const T& GetValue() const { return value_; }
  void SetValue(const T& value) {
    value_ = value;
    NotifyListeners();
  }
  operator T() const { return value_; }
  void operator=(const T& value) {
    value_ = value;
    NotifyListeners();
  }

  bool operator==(const T& value) const { return value_ == value; }
  friend bool operator==(const T& value, const Setting<T>& setting) {
    return setting.value_ == value;
  }

 private:
  T value_;

  DISALLOW_IMPLICIT_CONSTRUCTORS(Setting<T>);
};

template <typename T>
class Setting<std::atomic<T> > : public SettingBase {
 public:
  Setting(const std::string& name, const T& value,
          const std::string& doc_string)
      : SettingBase(name, doc_string), value_(value) {
    SetTypeDescriptorForType(this);
  }

  Setting(const SettingGroup* group, const std::string& name, const T& value,
          const std::string& doc_string)
      : SettingBase(group->GetGroupName() + '/' + name, doc_string),
        value_(value) {
    SetTypeDescriptorForType(this);
  }

  Setting(const std::string& name, const T& value)
      : SettingBase(name, std::string()), value_(value) {
    SetTypeDescriptorForType(this);
  }

  Setting(const SettingGroup* group, const std::string& name, const T& value)
      : SettingBase(group->GetGroupName()  + '/' + name, std::string()),
        value_(value) {
    SetTypeDescriptorForType(this);
  }

  ~Setting() override {}

  const std::string ToString() const override {
    return ValueToString(value_.load());
  }

  bool FromString(const std::string& str) override {
    T value = T();
    std::istringstream in(str);
    if (StringToValue(in, &value)) {
      SetValue(value);
      return true;
    }
    return false;
  }

  std::atomic<T>* GetMutableValue() { return &value_; }
  const std::atomic<T>& GetValue() const { return value_; }
  void SetValue(const T& value) {
    value_ = value;
    NotifyListeners();
  }
  operator T() const { return value_.load(); }
  void operator=(const T& value) {
    value_ = value;
    NotifyListeners();
  }

  bool operator==(const T& value) const { return value_ == value; }
  friend bool operator==(const T& value,
                         const Setting<std::atomic<T> >& setting) {
    return setting.value_ == value;
  }

 private:
  std::atomic<T> value_;

  DISALLOW_IMPLICIT_CONSTRUCTORS(Setting<std::atomic<T> >);
};

template <typename T>
class EnvironmentSetting : public Setting<T> {
 public:
  EnvironmentSetting(const std::string& setting_name,
                     const std::string& env_var_name,
                     const T& default_value,
                     const std::string& doc_string)
     : Setting<T>(setting_name, default_value, doc_string) {
    const std::string env_value =
        port::GetEnvironmentVariableValue(env_var_name);
    this->FromString(env_value);
  }

  bool operator==(const T& value) const {
    return Setting<T>::operator==(value);
  }
  friend bool operator==(const T& value, const EnvironmentSetting<T>& setting) {
    return setting == value;
  }

 private:
  DISALLOW_IMPLICIT_CONSTRUCTORS(EnvironmentSetting<T>);
};

template <typename T>
class ScopedSettingValue {
 public:
  ScopedSettingValue(Setting<T>* setting, const T& value)
    : setting_(setting) {
    if (setting_) {
      original_value_ = setting_->GetValue();
      setting_->SetValue(value);
    }
  }

  ~ScopedSettingValue() {
    if (setting_) {
      setting_->SetValue(original_value_);
    }
  }

 private:
  Setting<T>* setting_;

  T original_value_;
};

template <typename SettingType>
inline void SetTypeDescriptorForType(SettingType* setting) {
}

template <>
inline void SetTypeDescriptorForType(Setting<bool>* setting) {
  setting->SetTypeDescriptor("bool");
}

template <>
inline void SetTypeDescriptorForType(Setting<std::atomic<bool> >* setting) {
  setting->SetTypeDescriptor("bool");
}

}  // namespace base
}  // namespace ion

#endif  // ION_BASE_SETTING_H_