Namespace WoWLib

Classes

ClientVersion

A full client version tuple (major.minor.patch, build) plus the product flavor it came from. Determines which storage backend and archive chain a client uses, and — through format_lineage — which engine generation its files are laid out for. The versions namespace provides constants for the releases wowlib targets.

The version tuple alone does NOT identify an engine: the Classic
products reuse legacy version numbers on top of whatever retail branch
was current when they were built (Classic 3.4.x spans three retail
generations; 'wow_classic_titan' calls itself 3.80). The BUILD number
does — Blizzard's build counter is global across every product — so
every format decision keys on format_lineage, never on major/minor.

FamilyVector<T>

The version-agnostic view of a welded family's SEQUENCE member — a vector or fixed array whose elements are per-version welded classes — element-typed as the element's own family base. It is what lets base-typed code walk such a member without naming a version: Count and the indexer read through to the concrete version's native container LIVE (no copy; mutating an element view writes through), and the indexer's setter version-checks the assigned element — a wrong-version element throws InvalidCastException, the same contract as the family surface's single-member setters. Size-changing operations are deliberately absent: a fixed-array member has none at all, and growing a vector takes version-specific elements anyway — pattern-match to the concrete class and use its own member for Add/Clear. foreach is supported (the nested Enumerator is the standard allocation-free pattern).

FileDataId

A strongly-typed FileDataID — the numeric file identifier used by CASC-era clients (u32, matching the client's root manifest and DB2 references).

FileKey

A file request: by client-internal path, by FileDataID, or both. The generic file identity for version-independent tools — code that handles any client generation operates on FileKeys without caring which half is available (on pre-CASC clients the FileDataID is simply absent); the storage backend uses the half it needs and FileSystem.resolve fills gaps through the listfile. The stored path is always in canonical form.

FixedArrayOps<T>

The per-instantiation native operations a FixedArray<T> dispatches through; the extent is data here, not part of a type name.

FixedArray<T>

The fixed-size sibling of Vector<T> — a C++ std::array behind the same element protocols, minus every size-changing operation. The extent is the instantiation's, read via Count.

Global

SpanExtensions

VectorOps<T>

The per-instantiation native operations a Vector<T> dispatches through. Scalar/enum elements fill the span trio (Data/Push/Fill); welded and nested-container elements fill the live-view quartet (GetAt/View/HandleOf/SetAt + Add).

Vector<T>

A reference-semantic C++ std::vector, generic over the element. A scalar/enum element reads and writes through a zero-copy span over the C++ buffer (AsSpan() is the buffer-protocol view, valid until a size-changing operation or Dispose); a welded-class element hands out LIVE views, so v[i].Field = x writes through.

WelderContainerHandle

The one SafeHandle every generated container wrapper holds: release goes through the instantiation's stored destroy function (null = a non-owning view).

WelderContainers

The element-type → ops registry behind new Vector<T>() and the implicit T[] conversions. Generated module initializers register every bound instantiation before any user code runs; fixed arrays register per (element, extent) and resolve by the SOURCE ARRAY's length.

WelderNativeException

A C++ exception that crossed the native boundary.

WelderSpanExtensions

The zero-copy scalar-span surface. AsSpan() lives here as a CONSTRAINED extension (an instance method cannot constrain the class's own T; an extension can — the MemoryExtensions pattern), so it only exists for unmanaged (scalar/enum) elements: calling it on a container of record or nested-container elements is a compile error, not a runtime throw. For record elements use AsDataSpan() / AsSpan<TData>(); for nested containers, index in first.

Structs

ClientVersion.Data

A blittable value twin of the NATIVE layout (size 16): read or write whole record buffers through Vector<T>.AsSpan<Data>() / FixedArray<T>.AsSpan<Data>() — one interop crossing for the buffer, where the live-view indexer pays per element. Field offsets are the native ABI's, asserted in the shim.

FileDataId.Data

A blittable value twin of the NATIVE layout (size 4): read or write whole record buffers through Vector<T>.AsSpan<Data>() / FixedArray<T>.AsSpan<Data>() — one interop crossing for the buffer, where the live-view indexer pays per element. Field offsets are the native ABI's, asserted in the shim.

Enums

ClientFlavor

Which product line a client belongs to. Retail is the ordinary progression client, where the version number also tells you the engine generation. Every other flavor is a MODERN-engine client wearing a legacy version number: WoW Classic Era 1.15.9 is a Midnight-era client, Cataclysm Classic 4.4.2 a War Within-era one. Their file formats follow the build number, not the version tuple — see ClientVersion.format_lineage.

The enumerator also names the client's default TACT product code
('wow', 'wow_classic', 'wow_classic_era', 'wow_anniversary'); products
outside these four (PTR, beta, 'wow_classic_titan') pick the closest
flavor and pass their exact code to the filesystem explicitly.

Expansion

The expansion a client belongs to, in release order. The enumerable counterpart of a full ClientVersion: versioned format classes and factories are keyed on it (each enumerator maps to the last-minor-of-major release in the versions namespace).

Locale

Game client locale; enumerators use the client's own four-letter codes.

StorageKind

Which storage technology a client generation uses: Mpq for pre-WoD retail clients (StormLib), Casc for WoD+ and every Classic client (CascLib).