symbolic_variables.h

#pragma once
 
#include <cstddef>
#include <functional>
#include <initializer_list>
#include <ostream>
#include <set>
#include <string>
 
#include "dlinear/symbolic/symbolic_variable.h"
 
namespace dlinear::drake {
namespace symbolic {
 
class Variables {
 public:
  Variables(const Variables &) = default;
  Variables &operator=(const Variables &) = default;
  Variables(Variables &&) = default;
  Variables &operator=(Variables &&) = default;
 
  typedef typename std::set<Variable>::size_type size_type;
  typedef typename std::set<Variable>::iterator iterator;
  typedef typename std::set<Variable>::const_iterator const_iterator;
  typedef typename std::set<Variable>::reverse_iterator reverse_iterator;
  typedef typename std::set<Variable>::const_reverse_iterator
      const_reverse_iterator;
 
  Variables() = default;
 
  ~Variables() = default;
 
  Variables(std::initializer_list<Variable> init);
 
  size_t get_hash() const;
 
  size_type size() const { return vars_.size(); }
 
  bool empty() const { return vars_.empty(); }
 
  std::string to_string() const;
 
  iterator begin() { return vars_.begin(); }
  iterator end() { return vars_.end(); }
  const_iterator begin() const { return vars_.cbegin(); }
  const_iterator end() const { return vars_.cend(); }
  const_iterator cbegin() const { return vars_.cbegin(); }
  const_iterator cend() const { return vars_.cend(); }
  reverse_iterator rbegin() { return vars_.rbegin(); }
  reverse_iterator rend() { return vars_.rend(); }
  const_reverse_iterator rbegin() const { return vars_.crbegin(); }
  const_reverse_iterator rend() const { return vars_.crend(); }
  const_reverse_iterator crbegin() const { return vars_.crbegin(); }
  const_reverse_iterator crend() const { return vars_.crend(); }
 
  void insert(const Variable &var) { vars_.insert(var); }
  template<class InputIt>
  void insert(InputIt first, InputIt last) {
    vars_.insert(first, last);
  }
  void insert(const Variables &vars) { vars_.insert(vars.begin(), vars.end()); }
 
  size_type erase(const Variable &key) { return vars_.erase(key); }
 
  size_type erase(const Variables &vars);
 
  iterator find(const Variable &key) { return vars_.find(key); }
  const_iterator find(const Variable &key) const { return vars_.find(key); }
 
  bool include(const Variable &key) const { return find(key) != end(); }
 
  bool IsSubsetOf(const Variables &vars) const;
  bool IsSupersetOf(const Variables &vars) const;
  bool IsStrictSubsetOf(const Variables &vars) const;
  bool IsStrictSupersetOf(const Variables &vars) const;
 
  friend bool operator==(const Variables &vars1, const Variables &vars2);
 
  friend bool operator<(const Variables &vars1, const Variables &vars2);
 
  friend std::ostream &operator<<(std::ostream &, const Variables &vars);
 
  friend Variables intersect(const Variables &vars1, const Variables &vars2);
 
 private:
  /* Constructs from std::set<Variable>. */
  explicit Variables(std::set<Variable> vars);
 
  std::set<Variable> vars_;
};
 
// NOLINTNEXTLINE(runtime/references) per C++ standard signature.
Variables operator+=(Variables &vars1, const Variables &vars2);
// NOLINTNEXTLINE(runtime/references) per C++ standard signature.
Variables operator+=(Variables &vars, const Variable &var);
Variables operator+(Variables vars1, const Variables &vars2);
Variables operator+(Variables vars, const Variable &var);
Variables operator+(const Variable &var, Variables vars);
 
// NOLINTNEXTLINE(runtime/references) per C++ standard signature.
Variables operator-=(Variables &vars1, const Variables &vars2);
// NOLINTNEXTLINE(runtime/references) per C++ standard signature.
Variables operator-=(Variables &vars, const Variable &var);
Variables operator-(Variables vars1, const Variables &vars2);
Variables operator-(Variables vars, const Variable &var);
 
Variables intersect(const Variables &vars1, const Variables &vars2);
 
}  // namespace symbolic
 
template<>
struct hash_value<symbolic::Variables> {
  size_t operator()(const symbolic::Variables &vars) const {
    return vars.get_hash();
  }
};
 
} // namespace dlinear::drake