symbolic_environment.h

#pragma once
 
#include <initializer_list>
#include <ostream>
#include <string>
#include <unordered_map>
 
#include "dlinear/libs/libgmp.h"
#include "dlinear/symbolic/symbolic_variable.h"
#include "dlinear/symbolic/symbolic_variables.h"
 
namespace dlinear::drake::symbolic {
class Environment {
 public:
  Environment(const Environment &) = default;
  Environment &operator=(const Environment &) = default;
  Environment(Environment &&) = default;
  Environment &operator=(Environment &&) = default;
 
  typedef Variable key_type;
  typedef mpq_class mapped_type;
  typedef typename std::unordered_map<key_type, mapped_type> map;
  typedef typename std::unordered_map<key_type, double> double_map;
  typedef typename map::value_type value_type;
  typedef typename map::iterator iterator;
  typedef typename map::const_iterator const_iterator;
 
  Environment() = default;
 
  ~Environment() = default;
 
  Environment(std::initializer_list<value_type> init);
 
  Environment(std::initializer_list<key_type> vars);
 
  explicit Environment(map m);
  explicit Environment(const double_map &m);
 
  iterator begin() { return map_.begin(); }
  iterator end() { return map_.end(); }
  const_iterator begin() const { return map_.cbegin(); }
  const_iterator end() const { return map_.cend(); }
  const_iterator cbegin() const { return map_.cbegin(); }
  const_iterator cend() const { return map_.cend(); }
 
  std::pair<Environment::iterator, bool> insert(const key_type &key, const mapped_type &elem);
  bool empty() const { return map_.empty(); }
  size_t size() const { return map_.size(); }
 
  iterator find(const key_type &key) { return map_.find(key); }
  const_iterator find(const key_type &key) const { return map_.find(key); }
 
  const mapped_type &at(const key_type &key) const;
 
  std::size_t erase(const key_type &key);
  void erase(const iterator &pos);
 
  Variables domain() const;
 
  std::string to_string() const;
 
  mapped_type &operator[](const key_type &key);
 
  const mapped_type &operator[](const key_type &key) const;
 
  bool contains(const key_type &key) const;
 
  friend std::ostream &operator<<(std::ostream &os, const Environment &env);
 
 private:
  map map_;
};
}  // namespace dlinear::drake::symbolic