bases.h

Go to the documentation of this file.

#pragma once

#include <memory>
#include <random>

#include "sieve.h"
#include "facility.h"


namespace cauldron {
template<typename Value>
class Union;


template<typename Value>
class Filtered;


template<typename Value>
class Mapped;


template<typename Value>
class Strategy {
 public:
  virtual Value operator()() const = 0;

  virtual Union<Value> operator||(const Strategy<Value> &strategy) const {
    return Union<Value>{*this, strategy};
  }

  virtual Union<Value> operator||(const Union<Value> &strategy) const {
    return strategy || static_cast<const Strategy<Value> &>(*this);
  }

  virtual Filtered<Value> filter(const Requirement<Value> &requirement) const {
    Sieve<Value> sieve{requirement};
    return Filtered<Value>(*this, sieve);
  }

  virtual Mapped<Value> map(const Converter<Value> &converter) const {
    Facility<Value> facility{converter};
    return Mapped<Value>(*this, facility);
  }

  virtual std::unique_ptr<Strategy<Value>> clone() const = 0;
};


template<typename Value, class Derived>
class CloneHelper : public Strategy<Value> {
 public:
  std::unique_ptr<Strategy<Value>> clone() const override {
    return std::make_unique<Derived>(static_cast<const Derived &>(*this));
  }
};


template<class Value>
class Union : public CloneHelper<Value, Union<Value>> {
 public:
  explicit Union(const Strategy<Value> &strategy,
                 const Strategy<Value> &other_strategy) {
    strategies_.push_back(strategy.clone());
    strategies_.push_back(other_strategy.clone());
  }

  Union(const Union<Value> &strategy) {
    strategies_.reserve(strategy.strategies_.size());
    for (const auto &sub_strategy: strategy.strategies_) {
      strategies_.push_back(sub_strategy->clone());
    }
  }

  Value operator()() const override {
    static std::random_device random_device;
    size_t max_index = strategies_.size() - 1;
    std::uniform_int_distribution<size_t> distribution(0, max_index);
    size_t index = distribution(random_device);
    return (*strategies_[index])();
  }

  Union<Value> operator||(const Strategy<Value> &strategy) const override {
    Union<Value> result(*this);
    result.strategies_.push_back(strategy.clone());
    return result;
  }

  Union<Value> operator||(const Union<Value> &strategy) const override {
    Union<Value> result(*this);
    for (const auto &sub_strategy: strategy.strategies_) {
      result.strategies_.push_back(sub_strategy->clone());
    }
    return result;
  }

 private:
  std::vector<std::unique_ptr<Strategy<Value>>> strategies_;
};


template<typename Value>
class Filtered : public CloneHelper<Value, Filtered<Value>> {
 public:
  explicit Filtered(const Strategy<Value> &strategy,
                    const Sieve<Value> &sieve) :
      strategy_(strategy.clone()),
      sieve_(sieve) {};

  Filtered(const Filtered<Value> &strategy) :
      strategy_(strategy.strategy_->clone()),
      sieve_(strategy.sieve_) {}

  Filtered<Value> filter(
      const Requirement<Value> &requirement
  ) const override {
    auto sieve = sieve_.expand(requirement);
    return Filtered<Value>(*strategy_, sieve);
  }

  Value operator()() const override {
    std::function<Value()> producer([&]() -> Value {
      return (*strategy_)();
    });
    return sieve_.sift(producer);
  }

 protected:
  std::unique_ptr<Strategy<Value>> strategy_;
  Sieve<Value> sieve_;
};


template<typename Value>
class Mapped : public CloneHelper<Value, Mapped<Value>> {
 public:
  explicit Mapped(const Strategy<Value> &strategy,
                  const Facility<Value> &facility) :
      strategy_(strategy.clone()),
      facility_(facility) {};

  Mapped(const Mapped<Value> &strategy) :
      strategy_(strategy.strategy_->clone()),
      facility_(strategy.facility_) {}

  Mapped<Value> map(const Converter<Value> &converter) const override {
    auto facility = facility_.expand(converter);
    return Mapped(*strategy_, facility);
  }

  Value operator()() const override {
    Value product = (*strategy_)();
    return facility_.convert(product);
  }

 protected:
  std::unique_ptr<Strategy<Value>> strategy_;
  Facility<Value> facility_;
};
}