env_base.h

Go to the documentation of this file.

#ifndef ENV_BASE_H
#define ENV_BASE_H
 
#include "bitrl/bitrl_consts.h"
#include "bitrl/bitrl_types.h"
 
#include <any>
#include <string>
#include <type_traits>
#include <unordered_map>
 
namespace bitrl
{
namespace envs
{
 
template <typename TimeStepType, typename SpaceType> class EnvBase : public SpaceType
{
  public:
    static_assert(std::is_default_constructible<TimeStepType>::value &&
                  "TimeStepType should be default constructible");
    static_assert(std::is_default_constructible<SpaceType>::value &&
                  "SpaceType should be default constructible");
 
    static const uint_t DEFAULT_ENV_SEED = 42;
 
    typedef TimeStepType time_step_type;
 
    typedef typename SpaceType::state_space state_space_type;
 
    typedef typename SpaceType::state_type state_type;
 
    typedef typename SpaceType::action_space action_space_type;
 
    typedef typename SpaceType::action_type action_type;
 
    virtual ~EnvBase() = default;
 
    virtual void make(const std::string &version,
                      const std::unordered_map<std::string, std::any> &make_options,
                      const std::unordered_map<std::string, std::any> &reset_options) = 0;
 
    virtual void close() = 0;
 
    virtual time_step_type reset() = 0;
 
    virtual time_step_type step(const action_type &action) = 0;
 
    const std::unordered_map<std::string, std::any> &make_options() const noexcept
    {
        return make_options_;
    }
 
    const std::unordered_map<std::string, std::any> &reset_options() const noexcept
    {
        return reset_options_;
    }
 
    template <typename T> T read_option(const std::string &op_name) const;
 
    std::string idx() const noexcept { return idx_; }
 
    bool is_created() const noexcept { return is_created_; }
 
    std::string env_name() const noexcept { return name_; }
 
    std::string version() const noexcept { return version_; }
 
  protected:
    explicit EnvBase(const std::string &idx = bitrl::consts::INVALID_STR,
                     const std::string &name = bitrl::consts::INVALID_STR);
 
    EnvBase(const EnvBase &);
 
    void set_version_(const std::string &version) noexcept { version_ = version; }
 
    void set_idx_(const std::string &idx) noexcept { idx_ = idx; }
 
    void set_make_options_(const std::unordered_map<std::string, std::any> &options) noexcept
    {
        make_options_ = options;
    }
 
    void set_reset_options_(const std::unordered_map<std::string, std::any> &options) noexcept
    {
        reset_options_ = options;
    }
 
    void invalidate_is_created_flag_() noexcept { is_created_ = false; }
 
    void make_created_() noexcept { is_created_ = true; }
 
    time_step_type &get_current_time_step_() noexcept { return current_state_; }
 
    const time_step_type &get_current_time_step_() const noexcept { return current_state_; }
 
  private:
    bool is_created_;        
    std::string idx_;        
    std::string version_;    
    const std::string name_; 
    std::unordered_map<std::string, std::any> make_options_;  
    std::unordered_map<std::string, std::any> reset_options_; 
    time_step_type current_state_;                            
};
 
template <typename TimeStepType, typename SpaceType>
EnvBase<TimeStepType, SpaceType>::EnvBase(const std::string &idx, const std::string &name)
    : SpaceType(), is_created_(false), idx_(idx), version_(), name_(name), current_state_()
{
}
 
template <typename TimeStepType, typename SpaceType>
EnvBase<TimeStepType, SpaceType>::EnvBase(const EnvBase<TimeStepType, SpaceType> &other)
    : SpaceType(), is_created_(other.is_created_), idx_(other.idx_), version_(other.version_),
      name_(other.name_), current_state_()
{
}
 
template <typename TimeStepType, typename SpaceType> void EnvBase<TimeStepType, SpaceType>::close()
{
    this->is_created_ = false;
}
 
template <typename TimeStepType, typename SpaceType>
template <typename T>
T EnvBase<TimeStepType, SpaceType>::read_option(const std::string &op_name) const
{
 
    auto op_itr = make_options_.find(op_name);
    if (op_itr != make_options_.end())
    {
        return std::any_cast<T>(op_itr->second);
    }
 
    throw std::logic_error("Option: " + op_name + " not found");
}
 
template <typename TimeStepType, typename SpaceType>
void EnvBase<TimeStepType, SpaceType>::make(
    const std::string &version, const std::unordered_map<std::string, std::any> &make_options,
    const std::unordered_map<std::string, std::any> &reset_options)
{
    version_ = version;
    make_options_ = make_options;
    reset_options_ = reset_options;
}
 
} // namespace envs
} // namespace bitrl
 
#endif // ENV_BASE_H