permit.hpp

Go to the documentation of this file.

 
 
#ifndef UAT_PERMIT_HPP
#define UAT_PERMIT_HPP
 
#include <uat/type.hpp>
 
#include <memory>
 
#include <boost/functional/hash.hpp>
 
namespace uat
{
 
class region_view
{
public:
  template <region_compatible R> region_view(const R& a) : region_(std::addressof(a)) {}
 
  region_view() noexcept = delete;
 
  region_view(const region_view&) = default;
  region_view(region_view&&) noexcept = default;
 
  auto operator=(const region_view&) -> region_view& = default;
  auto operator=(region_view&&) noexcept -> region_view& = default;
 
  template <region_compatible R> auto downcast() const -> const R& { return *reinterpret_cast<const R*>(region_); }
 
private:
  const void* region_;
};
 
template <region_compatible Region> struct permit
{
  permit() noexcept = delete;
  permit(Region s, uint_t time) noexcept : location(std::move(s)), time(time) {}
 
  auto operator==(const permit& other) const -> bool { return location == other.location && time == other.time; }
  auto operator!=(const permit& other) const -> bool { return location != other.location || time != other.time; }
 
  Region location; 
  uint_t time;     
};
 
template <std::size_t I, typename R> decltype(auto) get(permit<R>& ts)
{
  if constexpr (I == 0)
    return ts.location;
  else
    return ts.time;
}
 
template <std::size_t I, typename R> decltype(auto) get(const permit<R>& ts)
{
  if constexpr (I == 0)
    return ts.location;
  else
    return ts.time;
}
 
} // namespace uat
 
namespace std
{
 
template <typename Region> struct hash<uat::permit<Region>>
{
  auto operator()(const uat::permit<Region>& p) const noexcept -> size_t
  {
    size_t seed = 0;
    boost::hash_combine(seed, std::hash<Region>{}(p.location));
    boost::hash_combine(seed, std::hash<std::size_t>{}(p.time));
    return seed;
  }
};
 
template <typename R> struct tuple_size<uat::permit<R>> : public integral_constant<size_t, 2>
{};
 
template <typename R> struct tuple_element<0, uat::permit<R>>
{
  using type = R&;
};
 
template <typename R> struct tuple_element<0, const uat::permit<R>>
{
  using type = const R&;
};
 
template <typename R> struct tuple_element<1, uat::permit<R>>
{
  using type = uat::uint_t;
};
 
template <typename R> struct tuple_element<1, const uat::permit<R>>
{
  using type = uat::uint_t;
};
 
} // namespace std
 
#endif // UAT_PERMIT_HPP