oracle_internal.tcc

Go to the documentation of this file.

 
#if !defined(ULTRA_ORACLE_H)
#  error "Don't include this file directly, include the specific .h instead"
#endif
 
#if !defined(ULTRA_ORACLE_INTERNAL_TCC)
#define      ULTRA_ORACLE_INTERNAL_TCC
 
namespace internal
{
 
// ***********************************************************************
// *  reg_oracle_storage                                                 *
// ***********************************************************************
 
// The general template.
template<class P, bool S> class reg_oracle_storage;
 
// ********* First specialization (individual stored inside) *********
template<>
class reg_oracle_storage<gp::individual, true>
{
public:
  explicit reg_oracle_storage(const gp::individual &ind) : ind_(ind)
  {
    Ensures(is_valid());
  }

  reg_oracle_storage(std::istream &in, const symbol_set &ss)
  {
    if (!ind_.load(in, ss))
      throw exception::data_format("Cannot load individual");
 
    int_.reset();
 
    Ensures(is_valid());
  }

  template<class ...Args> [[nodiscard]] value_t run(Args && ...args) const
  {
    if (int_) [[likely]]
      int_->rebind(ind_);
    else
      int_.emplace(ind_);
 
    return int_->run(std::forward<Args>(args)...);
  }

  [[nodiscard]] bool is_valid() const
  {
    return ind_.is_valid();
  }

  bool save(std::ostream &out) const { return ind_.save(out); }
 
private:
  gp::individual ind_;
 
  // Lazily initialised interpreter cache.
  //
  // This member is mutable to allow lazy construction and rebinding in
  // `run()`, even though execution does not conceptually modify the logical
  // state of the object.
  //
  // The interpreter is never accessed outside `run()`.
  mutable std::optional<src::interpreter> int_ {};
};
 
// ********* Second specialization (individual not stored) *********
template<>
class reg_oracle_storage<gp::individual, false>
{
public:
  explicit reg_oracle_storage(const gp::individual &ind) : int_(ind)
  { Ensures(is_valid()); }
 
  template<class ...Args> [[nodiscard]] value_t run(Args && ...args) const
  {
    return int_.run(std::forward<Args>(args)...);
  }
 
  [[nodiscard]] bool is_valid() const { return true; }
 
  // Serialization
  bool save(std::ostream &out) const
  {
    return int_.program().save(out);
  }
 
private:
  mutable src::interpreter int_;
};
 
// ********* Third specialization (teams) *********
template<gp::Team T, bool S>
class reg_oracle_storage<T, S>
{
public:
  explicit reg_oracle_storage(const T &t)
  {
    team_.reserve(t.size());
    for (const auto &ind : t)
      team_.emplace_back(ind);
 
    Ensures(is_valid());
  }
 
  reg_oracle_storage(std::istream &in, const symbol_set &ss)
  {
    std::size_t n;
    if (!(in >> n) || !n)
      throw exception::data_format("Unknown/wrong number of programs");
 
    team_.reserve(n);
    for (std::size_t j(0); j < n; ++j)
      team_.emplace_back(in, ss);
 
    Ensures(is_valid());
  }
 
  [[nodiscard]] bool is_valid() const
  {
    return true;
  }
 
  // Serialization.
  bool save(std::ostream &o) const
  {
    return (o << team_.size() << '\n')
           && std::ranges::all_of(
                team_,
                [&o](const auto &ind) { return ind.save(o); });
  }
 
public:
  std::vector<reg_oracle_storage<typename T::value_type, S>> team_ {};
};
 
}  // namespace internal
 
#endif  // include guard