variable.h

 
#pragma once
// IWYU pragma: no_include <string_view>
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <ostream>
#include <string>
#include <utility>
 
#include "smats/util/concepts.h"
#include "smats/util/hash.hpp"
 
namespace smats {
 
class Variable {
 public:
  using Id = std::size_t;
 
  enum class Type : std::uint8_t {
    CONTINUOUS,  
    INTEGER,     
    BINARY,      
    BOOLEAN,     
  };
 
  Variable() : id_{0}, name_{nullptr} {};
  explicit Variable(const std::string& name, Type type = Type::CONTINUOUS);
  Variable(const Variable&) = default;
  Variable(Variable&& other) noexcept : id_(other.id_), name_(std::move(other.name_)) { other.id_ = 0; }
  Variable& operator=(const Variable&) = default;
  Variable& operator=(Variable&& other) noexcept {
    id_ = other.id_;
    name_ = std::move(other.name_);
    other.id_ = 0;
    return *this;
  }
 
  [[nodiscard]] bool is_dummy() const { return id_ == 0; }
  [[nodiscard]] Id id() const { return id_; }
  [[nodiscard]] Type type() const { return static_cast<Type>(Id{id_} >> (7 * 8)); }
  [[nodiscard]] const std::string& name() const;
 
  [[nodiscard]] inline bool equal_to(const Variable& o) const noexcept { return id_ == o.id_; }
  [[nodiscard]] inline bool less(const Variable& o) const noexcept { return id_ < o.id_; }
  inline void hash(InvocableHashAlgorithm auto& hasher) const noexcept { hash_append(hasher, id_); }
 
 private:
  static Id get_next_id(Variable::Type type);
 
  Id id_;  
  std::shared_ptr<const std::string> name_;  
};
 
std::ostream& operator<<(std::ostream& os, const Variable& var);
 
std::ostream& operator<<(std::ostream& os, Variable::Type type);
 
}  // namespace smats
 
namespace std {
template <>
struct less<smats::Variable> {
  bool operator()(const smats::Variable& lhs, const smats::Variable& rhs) const { return lhs.less(rhs); }
};
 
template <>
struct equal_to<smats::Variable> {
  bool operator()(const smats::Variable& lhs, const smats::Variable& rhs) const { return lhs.equal_to(rhs); }
};
 
template <>
struct hash<smats::Variable> : public smats::DefaultHash {};
 
}  // namespace std