environment.h

 
#pragma once
 
#include <algorithm>
#include <cstddef>
#include <initializer_list>
#include <ostream>
#include <span>
#include <unordered_map>
 
#include "smats/symbolic/variable.h"
#include "smats/symbolic/variables.h"
 
namespace smats {
template <class T>
class Environment {
 public:
  using key_type = Variable;
  using mapped_type = T;
  using map = std::unordered_map<key_type, T>;
  using value_type = map::value_type;
  using iterator = map::iterator;
  using const_iterator = map::const_iterator;
 
  Environment() = default;
 
  explicit Environment(std::initializer_list<value_type> init);
 
  explicit Environment(std::span<const value_type> init);
 
  explicit Environment(std::initializer_list<key_type> vars);
 
  explicit Environment(std::span<const key_type> vars);
 
  explicit Environment(map m);
 
  iterator begin() { return map_.begin(); }
  iterator end() { return map_.end(); }
  [[nodiscard]] const_iterator begin() const { return map_.cbegin(); }
  [[nodiscard]] const_iterator end() const { return map_.cend(); }
  [[nodiscard]] const_iterator cbegin() const { return map_.cbegin(); }
  [[nodiscard]] const_iterator cend() const { return map_.cend(); }
 
  void insert(const key_type& key, const T& elem);
  void insert_or_assign(const key_type& key, const T& elem);
 
  [[nodiscard]] bool empty() const { return map_.empty(); }
  [[nodiscard]] std::size_t size() const { return map_.size(); }
  [[nodiscard]] Variables domain() const;
 
  [[nodiscard]] bool contains(const key_type& key) const { return map_.contains(key); }
  iterator find(const key_type& key) { return map_.find(key); }
  [[nodiscard]] const_iterator find(const key_type& key) const { return map_.find(key); }
 
  [[nodiscard]] const T& at(const key_type& key) const;
 
  T& operator[](const key_type& key);
 
  const T& operator[](const key_type& key) const;
 
  bool operator==(const Environment<T>& other) const;
 
 private:
  map map_;  
};
 
template <class T>
std::ostream& operator<<(std::ostream& os, const Environment<T>& env);
 
using EnvironmentI = Environment<int>;
using EnvironmentL = Environment<long>;
using EnvironmentF = Environment<float>;
using EnvironmentD = Environment<double>;
 
extern template class Environment<int>;
extern template class Environment<long>;
extern template class Environment<float>;
extern template class Environment<double>;
 
}  // namespace smats