Hash

Implements the Adler hash algorithm. More...

Classes
class	SystemEx.Hash.AdlerHash
class	SystemEx.Hash.BernsteinHash
class	SystemEx.Hash.FletcherHash
class	SystemEx.Hash.Fnv1aHash
class	SystemEx.Hash.GrøstlHash
class	SystemEx.Hash.Hashable
class	SystemEx.Hash.HashAlgorithmAttribute
struct	SystemEx.Hash.Hash32
struct	SystemEx.Hash.Hash64
	Represents a 64‑bit hash value produced by a SystemEx hashing algorithm. More...
interface	SystemEx.Hash.IHash
	Interface for SystemEx hashing algorithms. More...
class	SystemEx.Hash.RamakrishnaHash
class	SystemEx.Hash.WeinbergHash

Detailed Description

Implements the Adler hash algorithm.

Implements the Weinberg hash algorithm.

Implements the Ramakrishna hash algorithm.

Represents a 32‑bit hash value produced by a SystemEx hashing algorithm.

Declares which hashing algorithm a Hashable type should use.

Base class for objects that can be hashed using the SystemEx hashing subsystem.

Implements the Grøstl-256 and Grøstl-512 hashing functions as part of the SystemEx low-level cryptographic subsystem. This class provides a fully self-contained, allocation-free, deterministic hash engine based on the original Grøstl specification (SHA-3 finalist).

Implements the FNV-1a hash algorithm.

Implements the Fletcher hash algorithm.

Simple non‑cryptographic hash function based on the Bernstein family of hash algorithms.

The Adler hash algorithm is a checksum algorithm which was invented by Mark Adler in 1995. It is a modification of the Fletcher checksum, which was invented by John G. Fletcher in 1982.

This implementation provides both 32‑bit and 64‑bit variants and supports seeding, allowing deterministic or randomized hash streams depending on the caller.

Characteristics:

• Very fast
• Deterministic
• Suitable for hash tables, indexing, lightweight hashing
• Not intended for cryptographic use

The algorithm uses a classic multiply‑and‑xor mixing step: hash = (hash * M) ^ byte where M is a constant chosen for diffusion.

The implementation is designed for systems programming scenarios where predictable behavior, portability, and runtime independence are required. All operations are performed using fixed-size buffers, explicit state transformations, and constant-time primitives where applicable.

GroestlHash exposes two public hashing interfaces:

• Compute — Produces a 32-bit hash derived from the full Grøstl-256 digest.
• ComputeLong — Produces a 64-bit hash derived from the full Grøstl-512 digest.

Both variants support endian-aware extraction and optional seed mixing, enabling integration into heterogeneous environments, custom keying schemes, and internal hashing pipelines.

This class is intended for:

• Deterministic hashing inside low-level frameworks
• Internal key generation and seeding mechanisms
• Data integrity checks and non-cryptographic fingerprinting
• Embedded or isolated verification modules

A Hashable instance provides its binary representation through ToBytes and selects a hashing algorithm via HashAlgorithmAttribute applied on the concrete type.

The class supports both 32‑bit and 64‑bit hashing.
A per‑instance random seed is generated once and stored, ensuring stable hashing for the lifetime of the object while preventing predictable hash streams.

The attribute binds a concrete hasher implementation (IHash) to a class or struct and specifies the byte‑order (Endian) used when interpreting the binary representation returned by Hashable.ToBytes.

The SystemEx hashing subsystem reads this attribute at runtime to instantiate the correct hasher and compute 32‑bit or 64‑bit hashes.

The struct is immutable and stores the raw 32‑bit result exactly as returned by the underlying hasher. No normalization or reinterpretation is performed.