gymnasium_vector_env_base.h

Go to the documentation of this file.

 
#ifndef GYMNASIUM_VECTOR_ENV_BASE_H
#define GYMNASIUM_VECTOR_ENV_BASE_H
 
#include "../../network/rest_rl_env_client.h"
#include "bitrl/bitrl_config.h"
#include "bitrl/bitrl_types.h"
#include "bitrl/envs/env_types.h"
#include "bitrl/envs/gymnasium/gymnasium_env_base.h"
#include "bitrl/extern/nlohmann/json/json.hpp"
 
#ifdef BITRL_DEBUG
#include <cassert>
#endif
 
#include <stdexcept>
 
namespace bitrl
{
namespace envs
{
namespace gymnasium
{
 
template <typename VectorTimeStepType, typename SpaceType>
class GymnasiumVecEnvBase : public GymnasiumEnvBase<VectorTimeStepType, SpaceType>
{
 
  public:
    typedef GymnasiumEnvBase<VectorTimeStepType, SpaceType>::base_type base_type;
 
    typedef typename base_type::time_step_type time_step_type;
 
    typedef typename base_type::state_space_type state_space_type;
 
    typedef typename base_type::action_space_type action_space_type;
 
    typedef typename base_type::action_type action_type;
 
    typedef typename base_type::state_type state_type;
 
    virtual void make(const std::string &version,
                      const std::unordered_map<std::string, std::any> &options,
                      const std::unordered_map<std::string, std::any> &reset_options) = 0;
 
    uint_t get_n_envs() const noexcept { return n_envs_; }
 
    void reset_if_any_done(bool flag) noexcept { reset_if_any_done_ = flag; }
 
    bool get_reset_if_any_done() const noexcept { return reset_if_any_done_; }
 
  protected:
    GymnasiumVecEnvBase(network::RESTRLEnvClient &api_server, const std::string &name);
 
    GymnasiumVecEnvBase(const GymnasiumVecEnvBase &other);
 
  private:
    uint_t n_envs_{0};
 
    bool reset_if_any_done_{false};
};
 
template <typename VectorTimeStepType, typename SpaceType>
GymnasiumVecEnvBase<VectorTimeStepType, SpaceType>::GymnasiumVecEnvBase(
    network::RESTRLEnvClient &api_server, const std::string &name)
    : GymnasiumEnvBase<VectorTimeStepType, SpaceType>(api_server, name)
{
}
 
template <typename VectorTimeStepType, typename SpaceType>
GymnasiumVecEnvBase<VectorTimeStepType, SpaceType>::GymnasiumVecEnvBase(
    const GymnasiumVecEnvBase<VectorTimeStepType, SpaceType> &other)
    : GymnasiumEnvBase<VectorTimeStepType, SpaceType>(other), n_envs_(other.n_envs_),
      reset_if_any_done_(other.reset_if_any_done_)
{
}
 
template <typename VectorTimeStepType, typename SpaceType>
void GymnasiumVecEnvBase<VectorTimeStepType, SpaceType>::make(
    const std::string &version, const std::unordered_map<std::string, std::any> &options,
    const std::unordered_map<std::string, std::any> &reset_options)
{
 
    auto reset_if_any_done_itr = options.find("reset_if_any_done");
 
    if (reset_if_any_done_itr != options.end())
    {
        reset_if_any_done_ = std::any_cast<bool>(reset_if_any_done_itr->second);
    }
 
    auto n_envs_itr = options.find("num_envs");
 
    if (n_envs_itr != options.end())
    {
        n_envs_ = std::any_cast<uint_t>(n_envs_itr->second);
        return;
    }
 
    throw std::logic_error("num_envs variable is not provided");
}
 
} // namespace gymnasium
} // namespace envs
} // namespace bitrl
 
#endif // GYMNASIUMENVBASE_H