convert.hpp

Go to the documentation of this file.

#pragma once

 
#include <array>
#include <cstddef>
 
#include <wowlib/core/client_version.hpp>
#include <wowlib/core/error.hpp>
#include <wowlib/formats/common/version_range.hpp>
 
namespace wowlib::formats {
  template <ClientVersion V>
  struct VersionTag {};

  template <template <ClientVersion> class E>
  inline constexpr auto SupportedVersions = nullptr;

  template <template <ClientVersion> class E>
  inline constexpr auto VersionPivots = nullptr;
 
  namespace detail {
    template <std::size_t N>
    consteval std::size_t indexOf(const std::array<ClientVersion, N>& versions, ClientVersion v) {
      for (std::size_t i = 0; i < N; ++i)
        if (versions[i] == v) return i;
      return N; // not found
    }
 
    template <template <ClientVersion> class E, ClientVersion From, ClientVersion To> concept HasConvertStep = requires(
      const E<From>& src) {
        { convert_step(src, VersionTag<To>{}) } -> std::same_as<Result<E<To>>>;
      };

    template <template <ClientVersion> class E>
    consteval ClientVersion
    nextCanonical(ClientVersion from, ClientVersion to) {
      const auto& versions = SupportedVersions<E>;
      const auto& pivots = VersionPivots<E>;
      std::size_t i = indexOf(versions, from);
      const std::size_t j = indexOf(versions, to);
      const ClientVersion fromCanonical = canonicalVersion(from, pivots, versions);
      while (i != j) {
        i = i < j ? i + 1 : i - 1;
        const ClientVersion c = canonicalVersion(versions[i], pivots, versions);
        if (c != fromCanonical) return c;
      }
      return fromCanonical;
    }
  }

  template <template <ClientVersion> class E, ClientVersion From, ClientVersion To>
  consteval bool hasConvertPath() {
    constexpr auto& versions = SupportedVersions<E>;
    constexpr auto& pivots = VersionPivots<E>;
    static_assert(detail::indexOf(versions, From) < versions.size(), "From is not a supported version of this format");
    static_assert(detail::indexOf(versions, To) < versions.size(), "To is not a supported version of this format");
    constexpr ClientVersion fromC = canonicalVersion(From, pivots, versions);
    constexpr ClientVersion toC = canonicalVersion(To, pivots, versions);
    if constexpr (fromC == toC) return true;
    else {
      constexpr ClientVersion next = detail::nextCanonical<E>(fromC, toC);
      if constexpr (detail::HasConvertStep<E, fromC, next>) return hasConvertPath<E, next, To>();
      else return false;
    }
  }

  template <ClientVersion To, template <ClientVersion> class E, ClientVersion From> requires(!std::is_same_v<
    decltype(SupportedVersions<E>), const std::nullptr_t>)
  auto convert(const E<From>& src) -> Result<E<canonicalVersion(To, VersionPivots<E>, SupportedVersions<E>)>> {
    constexpr auto& versions = SupportedVersions<E>;
    constexpr auto& pivots = VersionPivots<E>;
    static_assert(detail::indexOf(versions, To) < versions.size(), "To is not a supported version of this format");
    static_assert(From == canonicalVersion(From, pivots, versions),
                  "convert() takes a canonical instantiation — construct entities " "through the public aliases");
    constexpr ClientVersion toC = canonicalVersion(To, pivots, versions);
 
    if constexpr (From == toC) return src;
    else {
      constexpr ClientVersion next = detail::nextCanonical<E>(From, toC);
      static_assert(detail::HasConvertStep<E, From, next>,
                    "no convert_step overload for this canonical version pair — declare "
                    "Result<E<next>> convert_step(const E<From>&, version_tag<next>)") ;
      auto stepped = convert_step(src, VersionTag<next>{});
      if (!stepped) return std::unexpected{stepped.error()};
      return convert<To>(*stepped);
    }
  }
}