variables.h

 
#pragma once
// IWYU pragma: no_include <string_view>
 
#include <initializer_list>
#include <ostream>
#include <set>
 
#include "smats/symbolic/variable.h"
#include "smats/util/concepts.h"
#include "smats/util/hash.hpp"
 
namespace smats {
 
class Variables {
 public:
  using size_type = std::set<Variable>::size_type;
  using iterator = std::set<Variable>::iterator;
  using const_iterator = std::set<Variable>::const_iterator;
  using reverse_iterator = std::set<Variable>::reverse_iterator;
  using const_reverse_iterator = std::set<Variable>::const_reverse_iterator;
 
  Variables() = default;
  Variables(std::initializer_list<Variable> init);
 
  [[nodiscard]] size_type size() const { return vars_.size(); }
  [[nodiscard]] bool empty() const { return vars_.empty(); }
  void hash(InvocableHashAlgorithm auto& hasher) const noexcept { hash_append(hasher, vars_); }
  iterator begin() { return vars_.begin(); }
  iterator end() { return vars_.end(); }
  [[nodiscard]] const_iterator begin() const { return vars_.cbegin(); }
  [[nodiscard]] const_iterator end() const { return vars_.cend(); }
  [[nodiscard]] const_iterator cbegin() const { return vars_.cbegin(); }
  [[nodiscard]] const_iterator cend() const { return vars_.cend(); }
  reverse_iterator rbegin() { return vars_.rbegin(); }
  reverse_iterator rend() { return vars_.rend(); }
  [[nodiscard]] const_reverse_iterator rbegin() const { return vars_.crbegin(); }
  [[nodiscard]] const_reverse_iterator rend() const { return vars_.crend(); }
  [[nodiscard]] const_reverse_iterator crbegin() const { return vars_.crbegin(); }
  [[nodiscard]] 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); }
  [[nodiscard]] const_iterator find(const Variable& key) const { return vars_.find(key); }
  [[nodiscard]] bool contains(const Variable& key) const { return find(key) != end(); }
 
  [[nodiscard]] bool is_subset_of(const Variables& vars) const;
  [[nodiscard]] bool is_superset_of(const Variables& vars) const;
  [[nodiscard]] bool is_strict_subset_of(const Variables& vars) const;
  [[nodiscard]] bool is_strict_superset_of(const Variables& vars) const;
 
  bool operator==(const Variables& vars) const;
  bool operator<(const Variables& vars) const;
 
  Variables& operator+=(const Variables& vars);
  Variables& operator+=(const Variable& var);
 
  Variables& operator-=(const Variables& vars);
  Variables& operator-=(const Variable& var);
 
  Variables operator+(const Variables& vars) const;
  Variables operator+(const Variable& var) const;
 
  Variables operator-(const Variables& vars) const;
  Variables operator-(const Variable& var) const;
 
  [[nodiscard]] Variables intersect(const Variables& vars) const;
 
 private:
  explicit Variables(std::set<Variable> vars);
 
  std::set<Variable> vars_;  
};
 
Variables operator+(const Variable& var, Variables vars);
 
std::ostream& operator<<(std::ostream&, const Variables& vars);
 
}  // namespace smats
 
namespace std {
template <>
struct hash<smats::Variables> : public smats::DefaultHash {};
}  // namespace std