properties.h

// Copyright 2018 The Darwin Neuroevolution Framework Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#pragma once

#include "utils.h"
#include "exception.h"
#include "stringify.h"

#include <third_party/json/json.h>
using nlohmann::json;

#include <assert.h>
#include <iostream>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>
using namespace std;

namespace core {

class PropertySet;

template <class T>
class TypedProperty;

class Property {
 public:
  Property(PropertySet* parent, const char* name, const char* description)
      : parent_(parent), name_(name), description_(description) {
    CHECK(parent != nullptr);
    CHECK(!name_.empty());
    CHECK(!description_.empty());
  }

  virtual ~Property() = default;

  const string& name() const { return name_; }
  
  const string& description() const { return description_; }
  
  PropertySet* parent() const { return parent_; }

  virtual string value() const = 0;
  
  virtual string defaultValue() const = 0;
  
  virtual PropertySet* childPropertySet() const { return nullptr; }
  
  virtual void setValue(const string& str) = 0;
  
  virtual vector<string> knownValues() const = 0;

  virtual void copyFrom(const Property& src) = 0;
  
  virtual json toJson() const = 0;
  
  virtual void fromJson(const json& json_obj) = 0;

  template <class T>
  const T& nativeValue() const {
    auto typed_property = dynamic_cast<const TypedProperty<T>*>(this);
    if (typed_property == nullptr)
      throw core::Exception("Invalid property type");
    return typed_property->nativeValue();
  }

  template <class T>
  bool isA() const {
    return dynamic_cast<const TypedProperty<T>*>(this) != nullptr;
  }

 private:
  PropertySet* parent_ = nullptr;
  const string name_;
  const string description_;
};

template <class T>
class TypedProperty : public Property {
 public:
  TypedProperty(PropertySet* parent,
                const char* name,
                T default_value,
                T* value,
                const char* description)
      : Property(parent, name, description),
        default_value_(default_value),
        value_(value) {}

  string value() const override { return core::toString(*value_); }

  string defaultValue() const override { return core::toString(default_value_); }

  void setValue(const string& str) override;

  vector<string> knownValues() const override { return core::knownValues<T>(); }

  void copyFrom(const Property& src) override;
  
  json toJson() const override { return value(); }
  
  void fromJson(const json& json_obj) override { setValue(json_obj); }
  
  const T& nativeValue() const { return *value_; }

 private:
  T default_value_;
  T* value_ = nullptr;
};

template <class TAG>
class PropertySetVariant : public core::NonCopyable {
 public:
  using TagType = TAG;
  
 public:
  virtual ~PropertySetVariant() = default;

  TAG tag() const { return tag_; }

  void selectCase(TAG tag) {
    if (cases_.find(tag_) == cases_.end())
      throw core::Exception("Invalid variant case");
    tag_ = tag;
  }
  
  const PropertySet* activeCase() const {
    auto it = cases_.find(tag_);
    CHECK(it != cases_.end());
    return it->second;
  }

  PropertySet* activeCase() {
    auto it = cases_.find(tag_);
    CHECK(it != cases_.end());
    return it->second;
  }

  json toJson() const {
    json json_obj = json::object();
    json_obj["tag"] = core::toString(tag_);
    for (const auto& [case_tag, case_value] : cases_) {
      json_obj[core::toString(case_tag)] = case_value->toJson();
    }
    return json_obj;
  }

  void fromJson(const json& json_obj) {
    CHECK(json_obj.is_object());

    bool at_least_one_case = false;
    tag_ = core::fromString<TAG>(json_obj.at("tag"));
    for (auto& [case_tag, case_value] : cases_) {
      auto json_it = json_obj.find(core::toString(case_tag));
      if (json_it != json_obj.end()) {
        case_value->fromJson(json_it.value());
        at_least_one_case = true;
      } else {
        case_value->resetToDefaultValues();
      }
    }

    // sanity check
    CHECK(cases_.empty() || at_least_one_case);
  }

  void copyFrom(const PropertySetVariant& src) {
    CHECK(typeid(*this) == typeid(src));
    CHECK(cases_.size() == src.cases_.size());
    tag_ = src.tag_;
    for (const auto& [case_tag, case_value] : src.cases_) {
      cases_.at(case_tag)->copyFrom(*case_value);
    }
  }

 protected:
  bool registerCase(TAG tag, PropertySet* property_set) {
    CHECK(cases_.insert({ tag, property_set }).second, "Duplicate cases");
    tag_ = tag;
    return true;
  }

 private:
  TAG tag_ = TAG(-1);
  map<TAG, PropertySet*> cases_;
};

template <class T>
class VariantProperty : public Property {
  using TagType = typename T::TagType;

 public:
  VariantProperty(PropertySet* parent,
                  const char* name,
                  TagType default_case,
                  T* variant,
                  const char* description)
      : Property(parent, name, description),
        default_case_(default_case),
        variant_(variant) {}

  string value() const override { return core::toString(variant_->tag()); }

  string defaultValue() const override { return core::toString(default_case_); }

  PropertySet* childPropertySet() const override { return variant_->activeCase(); }

  void setValue(const string& str) override;

  vector<string> knownValues() const override { return core::knownValues<TagType>(); }

  void copyFrom(const Property& src) override;
  
  json toJson() const override { return variant_->toJson(); }
  
  void fromJson(const json& json_obj) override { variant_->fromJson(json_obj); }

 private:
  TagType default_case_;
  T* variant_ = nullptr;
};

class PropertySet : public core::NonCopyable {
 public:
  PropertySet() = default;
  virtual ~PropertySet() = default;

  vector<Property*> properties() {
    vector<Property*> properties;
    for (const auto& property : properties_)
      properties.push_back(property.get());
    return properties;
  }

  vector<const Property*> properties() const {
    vector<const Property*> properties;
    for (const auto& property : properties_)
      properties.push_back(property.get());
    return properties;
  }

  void resetToDefaultValues() {
    for (const auto& property : properties_)
      property->setValue(property->defaultValue());
  }

  void copyFrom(const PropertySet& src) {
    CHECK(typeid(*this) == typeid(src), "Incompatible property sets");
    CHECK(properties_.size() == src.properties_.size());

    if (sealed_) {
      throw core::Exception("Attempting to use 'copyFrom' on a sealed property set");
    }

    for (size_t i = 0; i < properties_.size(); ++i)
      properties_[i]->copyFrom(*src.properties_[i]);
  }

  void seal(bool sealed = true) {
    sealed_ = sealed;
  }

  bool sealed() const { return sealed_; }

  void onPropertyChange(const Property* property) {
    if (sealed_) {
      throw core::Exception("Attempting to set property '%s' on a sealed property set",
                            property->name());
    }
  }

  json toJson() const {
    json json_obj = json::object();
    for (const auto& property : properties_) {
      json_obj[property->name()] = property->toJson();
    }
    return json_obj;
  }

  void fromJson(const json& json_obj) {
    CHECK(json_obj.is_object());

    if (sealed_) {
      throw core::Exception("Attempting to use 'fromJson' on a sealed property set");
    }

    bool at_least_one_value = false;
    for (const auto& property : properties_) {
      auto json_it = json_obj.find(property->name());
      if (json_it != json_obj.end()) {
        property->fromJson(json_it.value());
        at_least_one_value = true;
      } else
        property->setValue(property->defaultValue());
    }

    // sanity check, if none of the fields match we have something
    // completely different than we expected
    CHECK(json_obj.empty() || properties_.empty() || at_least_one_value);
  }

 protected:
  template <class T>
  T registerProperty(const char* name,
                     T default_value,
                     T* value,
                     const char* description) {
    assert(name != nullptr);
    assert(value != nullptr);
    properties_.push_back(
        make_unique<TypedProperty<T>>(this, name, default_value, value, description));
    return default_value;
  }

  template <class V, class TAG>
  bool registerVariant(const char* name,
                       TAG default_case,
                       V* variant,
                       const char* description) {
    assert(name != nullptr);
    assert(variant != nullptr);
    variant->selectCase(default_case);
    properties_.push_back(
        make_unique<VariantProperty<V>>(this, name, default_case, variant, description));
    return true;
  }

 private:
  vector<unique_ptr<Property>> properties_;
  bool sealed_ = false;
};

template <class T>
void TypedProperty<T>::setValue(const string& str) {
  parent()->onPropertyChange(this);
  *value_ = core::fromString<T>(str);
}

template <class T>
void TypedProperty<T>::copyFrom(const Property& src) {
  parent()->onPropertyChange(this);
  *value_ = *dynamic_cast<const TypedProperty&>(src).value_;
}

template <class T>
void VariantProperty<T>::setValue(const string& str) {
  parent()->onPropertyChange(this);
  variant_->selectCase(core::fromString<TagType>(str));
}

template <class T>
void VariantProperty<T>::copyFrom(const Property& src) {
  parent()->onPropertyChange(this);
  variant_->copyFrom(*dynamic_cast<const VariantProperty&>(src).variant_);
}

// convenience macro for defining properties
#define PROPERTY(name, type, default_value, description) \
  type name { registerProperty<type>(#name, type(default_value), &name, (description)) }

// convenience macro for defining variants
#define VARIANT(name, type, default_case, description) \
  type name;                                           \
  bool name##_INIT { registerVariant<type>(#name, (default_case), &name, (description)) }

// convenience macro for defining variant cases
#define CASE(tag, name, type) \
  type name;                  \
  bool name##_INIT { registerCase((tag), &name) }

}  // namespace core