annotations.hpp

Go to the documentation of this file.

#pragma once

 
#include <meta>
 
#include <cstdint>
#include <string_view>
 
#include <wowlib/core/client_version.hpp>
#include <wowlib/formats/common/fourcc.hpp>
 
namespace wowlib::formats {
  namespace detail {
    struct ChunkSpec {
      std::uint32_t magic; 
      FourCCEndian endian; 
    };

    struct SinceSpec {
      ClientVersion v;
    };

    struct UntilSpec {
      ClientVersion v;
    };

    struct OptionalSpec {};

    struct HeaderSpec {};

    struct ContainerSpec {};

    struct RepeatsSpec {
      std::uint32_t max;
    };

    struct RepeatingSpec {};

    struct SequenceDataSpec {};

    struct GatedBySpec {
      std::uint32_t mask;
    };

    struct OffsetAfterSpec {
      const char* name;
 
      constexpr std::string_view view() const { return name; }
    };
 
    // --- validation specs (validate(), never the serializer) ------------------

    struct CountMatchesSpec {
      const char* name; 
      std::uint32_t scale; 
 
      constexpr std::string_view view() const { return name; }
    };

    struct CountMultipleOfSpec {
      std::uint32_t divisor;
    };

    struct CountExactlySpec {
      std::uint32_t count;
    };

    struct IndexesSpec {
      const char* name; 
 
      constexpr std::string_view view() const { return name; }
    };

    struct IndexesOptionalSpec {
      const char* name; 
 
      constexpr std::string_view view() const { return name; }
    };

    struct IndexesInRootSpec {
      const char* name; 
 
      constexpr std::string_view view() const { return name; }
    };

    struct ExpectedValueSpec {
      std::uint32_t value;
    };

    struct NonemptySpec {};
  }

  consteval detail::ChunkSpec chunk(const char(&cc)[5], FourCCEndian endian = FourCCEndian::Reversed) {
    return {fourcc(cc, endian), endian};
  }

  consteval detail::SinceSpec since(ClientVersion v) { return {v}; }

  consteval detail::UntilSpec until(ClientVersion v) { return {v}; }

  inline constexpr detail::OptionalSpec Optional{};

  inline constexpr detail::HeaderSpec Header{};

  inline constexpr detail::ContainerSpec Container{};

  consteval detail::RepeatsSpec repeats(std::uint32_t max) { return {max}; }

  inline constexpr detail::RepeatingSpec Repeating{};

  inline constexpr detail::SequenceDataSpec SequenceData{};

  consteval detail::GatedBySpec gatedBy(std::uint32_t mask) {
    return {mask};
  }

  consteval detail::OffsetAfterSpec offsetAfter(std::string_view name) {
    return {std::define_static_string(name)};
  }
 
  // --- validation annotations (validate() contracts, never the serializer) ----

  consteval detail::CountMatchesSpec countMatches(std::string_view name, std::uint32_t scale = 1) {
    return {std::define_static_string(name), scale};
  }

  consteval detail::CountMultipleOfSpec countMultipleOf(std::uint32_t divisor) {
    return {divisor};
  }

  consteval detail::CountExactlySpec countExactly(std::uint32_t count) {
    return {count};
  }

  consteval detail::IndexesSpec indexes(std::string_view name) {
    return {std::define_static_string(name)};
  }

  consteval detail::IndexesOptionalSpec indexesOptional(std::string_view name) {
    return {std::define_static_string(name)};
  }

  consteval detail::IndexesInRootSpec
  indexesInRoot(std::string_view name) {
    return {std::define_static_string(name)};
  }

  consteval detail::ExpectedValueSpec expectedValue(std::uint32_t value) {
    return {value};
  }

  inline constexpr detail::NonemptySpec Nonempty{};
}