OptionValue.hpp

 
#pragma once
 
#include <iostream>
#include <utility>
 
namespace dlinear {
 
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() = 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;
    }
  }
 
  friend std::ostream &operator<<(std::ostream &os, Type type) {
    switch (type) {
      case OptionValue<T>::Type::DEFAULT:
        return os << "DEFAULT";
      case OptionValue<T>::Type::FROM_FILE:
        return os << "FROM_FILE";
      case OptionValue<T>::Type::FROM_COMMAND_LINE:
        return os << "FROM_COMMAND_LINE";
      case OptionValue<T>::Type::FROM_CODE:
        return os << "FROM_CODE";
    }
  }
 
 private:
  T value_;    
  Type type_;  
};
 
}  // namespace dlinear