agent.hpp

Go to the documentation of this file.

 
 
#ifndef UAT_AGENT_HPP
#define UAT_AGENT_HPP
 
#include <uat/permit.hpp>
 
#include <span>
#include <variant>
 
#include <type_safe/reference.hpp>
 
namespace uat
{
 
struct trade_value_t
{
  value_t min_value;   
  value_t highest_bid; 
};
 
namespace permit_public_status
{
 
struct unavailable
{};
 
struct available
{
  value_t min_value; 
 
  std::span<const trade_value_t> trades;
};
 
struct owned
{};
 
} // namespace permit_public_status
 
using permit_public_status_t =
  std::variant<permit_public_status::unavailable, permit_public_status::available, permit_public_status::owned>;
 
using bid_fn = type_safe::function_ref<bool(region_view, uint_t, value_t)>;
 
using ask_fn = type_safe::function_ref<bool(region_view, uint_t, value_t)>;
 
using permit_public_status_fn = type_safe::function_ref<permit_public_status_t(region_view, uint_t)>;
 
template <region_compatible R> struct agent
{
  using region_type = R;
 
  virtual auto bid_phase([[maybe_unused]] uint_t time, [[maybe_unused]] bid_fn bid,
                         [[maybe_unused]] permit_public_status_fn status, [[maybe_unused]] int seed) -> void
  {}
 
  virtual auto ask_phase([[maybe_unused]] uint_t time, [[maybe_unused]] ask_fn ask,
                         [[maybe_unused]] permit_public_status_fn status, [[maybe_unused]] int seed) -> void
  {}
 
  virtual auto on_bought([[maybe_unused]] const R& region, [[maybe_unused]] uint_t time, [[maybe_unused]] value_t value) -> void
  {}
 
  virtual auto on_sold([[maybe_unused]] const R& region, [[maybe_unused]] uint_t time, [[maybe_unused]] value_t value) -> void {}
 
  virtual auto stop(uint_t time, int seed) -> bool = 0;
};
 
template <typename T>
concept agent_compatible = std::movable<T> && std::derived_from<T, agent<typename T::region_type>>;
 
class any_agent
{
  class agent_interface
  {
  public:
    virtual ~agent_interface() = default;
 
    virtual auto bid_phase(uint_t, bid_fn, permit_public_status_fn, int) -> void = 0;
    virtual auto ask_phase(uint_t, ask_fn, permit_public_status_fn, int) -> void = 0;
 
    virtual auto on_bought(region_view, uint_t, value_t) -> void = 0;
    virtual auto on_sold(region_view, uint_t, value_t) -> void = 0;
 
    virtual auto stop(uint_t, int) -> bool = 0;
  };
 
  template <agent_compatible Agent> class agent_model : public agent_interface
  {
  public:
    agent_model(Agent any_agent) : agent_(std::move(any_agent)) {}
    virtual ~agent_model() = default;
 
    auto bid_phase(uint_t t, bid_fn b, permit_public_status_fn i, int seed) -> void override
    {
      agent_.bid_phase(t, std::move(b), std::move(i), seed);
    }
 
    auto ask_phase(uint_t t, ask_fn a, permit_public_status_fn i, int seed) -> void override
    {
      agent_.ask_phase(t, std::move(a), std::move(i), seed);
    }
 
    auto on_bought(region_view s, uint_t t, value_t v) -> void override
    {
      agent_.on_bought(s.downcast<typename Agent::region_type>(), t, v);
    }
 
    auto on_sold(region_view s, uint_t t, value_t v) -> void override
    {
      agent_.on_sold(s.downcast<typename Agent::region_type>(), t, v);
    }
 
    auto stop(uint_t t, int seed) -> bool override { return agent_.stop(t, seed); }
 
  private:
    Agent agent_;
  };
 
public:
  template <agent_compatible Agent> any_agent(Agent a) : interface_(new agent_model<Agent>(std::move(a))) {}
 
  any_agent() = delete;
 
  any_agent(const any_agent&) = delete;
  any_agent(any_agent&&) noexcept = default;
 
  auto operator=(const any_agent&) -> any_agent& = delete;
  auto operator=(any_agent&&) noexcept -> any_agent& = default;
 
  auto bid_phase(uint_t, bid_fn, permit_public_status_fn, int) -> void;
  auto ask_phase(uint_t, ask_fn, permit_public_status_fn, int) -> void;
 
  auto on_bought(region_view, uint_t, value_t) -> void;
  auto on_sold(region_view, uint_t, value_t) -> void;
 
  auto stop(uint_t time, int seed) -> bool;
 
private:
  std::unique_ptr<agent_interface> interface_;
};
 
} // namespace uat
 
#endif // UAT_AGENT_HPP