OptionValue.hpp

#pragma once
 
#include <utility>
 
namespace delpi {

template <typename T>
class OptionValue {
 public:
  enum class Type {
    DEFAULT,            
    FROM_FILE,          
    FROM_COMMAND_LINE,  
    FROM_CODE,          
  };

  explicit OptionValue(T value) : value_{std::move(value)}, type_{Type::DEFAULT} {}

  OptionValue(const OptionValue &) = default;
  OptionValue(OptionValue &&) noexcept = default;
  OptionValue &operator=(const OptionValue &) = default;
  OptionValue &operator=(OptionValue &&) noexcept = default;

  OptionValue &operator=(const T &value) {
    value_ = value;
    type_ = Type::FROM_CODE;
    return *this;
  }

  OptionValue &operator=(T &&value) {
    value_ = std::move(value);
    type_ = Type::FROM_CODE;
    return *this;
  }

  const T &get() const { return value_; }
  const T &operator*() const { return value_; }

  void SetFromCommandLine(const T &value) {
    if (type_ != Type::FROM_CODE) {
      value_ = value;
      type_ = Type::FROM_COMMAND_LINE;
    }
  }

  void SetFromFile(const T &value) {
    switch (type_) {
      case Type::DEFAULT:
      case Type::FROM_FILE:
        value_ = value;
        type_ = Type::FROM_FILE;
        return;
 
      case Type::FROM_COMMAND_LINE:
      case Type::FROM_CODE:
        // No operation.
        return;
    }
  }
 
 private:
  T value_;    
  Type type_;  
};
 
}  // namespace delpi