pedestrian_types.hpp

#pragma once
 
#include <cstdint>
#include <functional>
 
#include "vipra/geometry/f3d.hpp"
#include "vipra/types/size.hpp"
 
#include "vipra/vipra_behaviors/util/class_types.hpp"
 
namespace VIPRA::Behaviors {

using typeUID = uint64_t;

class Ptype {
  DEFAULT_CONSTRUCTIBLE(Ptype)
  COPYABLE(Ptype)
  MOVEABLE(Ptype)
 
 public:
  typeUID fullType = 0;
 
  explicit constexpr Ptype(typeUID tid) noexcept : fullType(tid) {}

  [[nodiscard]] inline constexpr auto type_count() const -> VIPRA::size
  {
    VIPRA::size count = 0;
    typeUID     check = 1;
    while ( (check & fullType) != 0U ) {
      check = check << 1U;
      ++count;
    }
 
    return count;
  }

  void for_each_type(std::function<void(typeUID)> const& func) const
  {
    typeUID type = fullType;
    typeUID check = 1;
    while ( check <= type ) {
      if ( (type & check) != 0U ) {
        func(check);
      }
      check = check << 1U;
    }
  }

  [[nodiscard]] inline constexpr auto is_type(typeUID type) const noexcept -> bool
  {
    return ((type & fullType) != 0U) && ((~type & fullType) == 0);
  }

  [[nodiscard]] inline constexpr auto has_type(typeUID type) const noexcept -> bool
  {
    return (type & fullType) != 0U;
  }

  inline constexpr auto operator+(typeUID type) const noexcept -> Ptype
  {
    return Ptype{fullType | type};
  }

  inline constexpr auto operator+=(typeUID type) noexcept -> Ptype&
  {
    fullType = (fullType | type);
    return *this;
  }

  inline constexpr auto operator+(Ptype type) const noexcept -> Ptype
  {
    return Ptype{fullType | type.fullType};
  }

  inline constexpr auto operator+=(Ptype type) noexcept -> Ptype&
  {
    fullType = (fullType | type.fullType);
    return *this;
  }

  inline constexpr auto operator-(typeUID type) const noexcept -> Ptype
  {
    return Ptype{fullType & ~type};
  }

  inline constexpr auto operator-=(typeUID type) noexcept -> Ptype&
  {
    fullType = (fullType & ~type);
    return *this;
  }

  inline constexpr auto operator-(Ptype type) const noexcept -> Ptype
  {
    return Ptype{fullType & ~type.fullType};
  }

  inline constexpr auto operator-=(Ptype type) noexcept -> Ptype&
  {
    fullType = (fullType & ~type.fullType);
    return *this;
  }

  inline constexpr auto operator==(Ptype type) const noexcept -> bool
  {
    return fullType == type.fullType;
  }

  inline constexpr auto operator!=(Ptype type) const noexcept -> bool
  {
    return fullType != type.fullType;
  }
};
}  // namespace VIPRA::Behaviors