@hla4ts/session 0.1.0 → 0.1.1

package/src/sequence-number.ts

@@ -1,200 +1,200 @@
-/**
- * Sequence Number Management
- *
- * Handles sequence numbers with wrap-around behavior as defined in the
- * IEEE 1516-2025 Federate Protocol specification.
- *
- * Sequence numbers are 32-bit unsigned integers that wrap around from
- * MAX_VALUE (2^31 - 1) back to 0. The value 0x80000000 is reserved as
- * "no sequence number" and is never used as a valid sequence number.
- */
-
-/**
- * Invalid/no sequence number marker.
- * Binary: 10000000 00000000 00000000 00000000
- * This is stored as a 32-bit signed integer (-2147483648 = Integer.MIN_VALUE)
- * but transmitted as unsigned (2147483648).
- */
-export const NO_SEQUENCE_NUMBER = 0x80000000 >>> 0; // Force unsigned
-
-/**
- * Initial sequence number for new sessions
- */
-export const INITIAL_SEQUENCE_NUMBER = 0;
-
-/**
- * Maximum valid sequence number (2^31 - 1)
- */
-export const MAX_SEQUENCE_NUMBER = 0x7fffffff;
-
-/**
- * Check if a value is a valid sequence number
- */
-export function isValidSequenceNumber(value: number): boolean {
-  // Valid sequence numbers are 0 to MAX_SEQUENCE_NUMBER (0x7FFFFFFF)
-  // Invalid is 0x80000000 and above (as unsigned)
-  return value >= 0 && value <= MAX_SEQUENCE_NUMBER;
-}
-
-/**
- * Get the next sequence number with wrap-around
- */
-export function nextSequenceNumber(current: number): number {
-  const next = current + 1;
-  // Wrap around if we exceed max or hit the invalid marker
-  return next > MAX_SEQUENCE_NUMBER ? INITIAL_SEQUENCE_NUMBER : next;
-}
-
-/**
- * Add two sequence numbers with wrap-around
- */
-export function addSequenceNumbers(a: number, b: number): number {
-  const sum = a + b;
-  // Mask to keep in valid range (clear high bit)
-  return sum & MAX_SEQUENCE_NUMBER;
-}
-
-/**
- * Check if a candidate sequence number is within an interval [oldest, newest]
- * Handles wrap-around correctly.
- */
-export function isInInterval(
-  candidate: number,
-  oldest: number,
-  newest: number
-): boolean {
-  if (!isValidSequenceNumber(oldest) || !isValidSequenceNumber(candidate) || !isValidSequenceNumber(newest)) {
-    throw new Error("All sequence numbers must be valid");
-  }
-
-  if (oldest <= newest) {
-    // Normal case: no wrap-around in interval
-    return oldest <= candidate && candidate <= newest;
-  } else {
-    // Wrap-around case: interval spans from oldest to MAX, then 0 to newest
-    return candidate >= oldest || candidate <= newest;
-  }
-}
-
-/**
- * Mutable sequence number class for tracking and incrementing
- */
-export class SequenceNumber {
-  private _value: number;
-
-  constructor(initialValue: number = INITIAL_SEQUENCE_NUMBER) {
-    this._value = initialValue;
-  }
-
-  /**
-   * Get the current value
-   */
-  get value(): number {
-    return this._value;
-  }
-
-  /**
-   * Set a new value
-   */
-  set(newValue: number): void {
-    this._value = newValue;
-  }
-
-  /**
-   * Increment and return the new value
-   */
-  increment(): number {
-    this._value = nextSequenceNumber(this._value);
-    return this._value;
-  }
-
-  /**
-   * Get current value and then increment
-   */
-  getAndIncrement(): number {
-    const current = this._value;
-    this._value = nextSequenceNumber(this._value);
-    return current;
-  }
-
-  /**
-   * Check if the current value is valid
-   */
-  isValid(): boolean {
-    return isValidSequenceNumber(this._value);
-  }
-
-  /**
-   * Create a copy
-   */
-  clone(): SequenceNumber {
-    return new SequenceNumber(this._value);
-  }
-
-  toString(): string {
-    return String(this._value);
-  }
-}
-
-/**
- * Thread-safe (atomic-like) sequence number for concurrent access.
- * In JavaScript/TypeScript this provides a clean interface for
- * atomic get/set operations.
- */
-export class AtomicSequenceNumber {
-  private _value: number;
-
-  constructor(initialValue: number = NO_SEQUENCE_NUMBER) {
-    this._value = initialValue;
-  }
-
-  /**
-   * Get the current value
-   */
-  get(): number {
-    return this._value;
-  }
-
-  /**
-   * Set a new value
-   */
-  set(newValue: number): void {
-    this._value = newValue;
-  }
-
-  /**
-   * Compare and set: only set if current value equals expected
-   * Returns true if the value was set
-   */
-  compareAndSet(expected: number, newValue: number): boolean {
-    if (this._value === expected) {
-      this._value = newValue;
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * Get current value and then set new value
-   */
-  getAndSet(newValue: number): number {
-    const current = this._value;
-    this._value = newValue;
-    return current;
-  }
-
-  /**
-   * Increment and return the new value
-   */
-  incrementAndGet(): number {
-    this._value = nextSequenceNumber(this._value);
-    return this._value;
-  }
-
-  /**
-   * Check if the current value is valid
-   */
-  isValid(): boolean {
-    return isValidSequenceNumber(this._value);
-  }
-}
+/**
+ * Sequence Number Management
+ *
+ * Handles sequence numbers with wrap-around behavior as defined in the
+ * IEEE 1516-2025 Federate Protocol specification.
+ *
+ * Sequence numbers are 32-bit unsigned integers that wrap around from
+ * MAX_VALUE (2^31 - 1) back to 0. The value 0x80000000 is reserved as
+ * "no sequence number" and is never used as a valid sequence number.
+ */
+
+/**
+ * Invalid/no sequence number marker.
+ * Binary: 10000000 00000000 00000000 00000000
+ * This is stored as a 32-bit signed integer (-2147483648 = Integer.MIN_VALUE)
+ * but transmitted as unsigned (2147483648).
+ */
+export const NO_SEQUENCE_NUMBER = 0x80000000 >>> 0; // Force unsigned
+
+/**
+ * Initial sequence number for new sessions
+ */
+export const INITIAL_SEQUENCE_NUMBER = 0;
+
+/**
+ * Maximum valid sequence number (2^31 - 1)
+ */
+export const MAX_SEQUENCE_NUMBER = 0x7fffffff;
+
+/**
+ * Check if a value is a valid sequence number
+ */
+export function isValidSequenceNumber(value: number): boolean {
+  // Valid sequence numbers are 0 to MAX_SEQUENCE_NUMBER (0x7FFFFFFF)
+  // Invalid is 0x80000000 and above (as unsigned)
+  return value >= 0 && value <= MAX_SEQUENCE_NUMBER;
+}
+
+/**
+ * Get the next sequence number with wrap-around
+ */
+export function nextSequenceNumber(current: number): number {
+  const next = current + 1;
+  // Wrap around if we exceed max or hit the invalid marker
+  return next > MAX_SEQUENCE_NUMBER ? INITIAL_SEQUENCE_NUMBER : next;
+}
+
+/**
+ * Add two sequence numbers with wrap-around
+ */
+export function addSequenceNumbers(a: number, b: number): number {
+  const sum = a + b;
+  // Mask to keep in valid range (clear high bit)
+  return sum & MAX_SEQUENCE_NUMBER;
+}
+
+/**
+ * Check if a candidate sequence number is within an interval [oldest, newest]
+ * Handles wrap-around correctly.
+ */
+export function isInInterval(
+  candidate: number,
+  oldest: number,
+  newest: number
+): boolean {
+  if (!isValidSequenceNumber(oldest) || !isValidSequenceNumber(candidate) || !isValidSequenceNumber(newest)) {
+    throw new Error("All sequence numbers must be valid");
+  }
+
+  if (oldest <= newest) {
+    // Normal case: no wrap-around in interval
+    return oldest <= candidate && candidate <= newest;
+  } else {
+    // Wrap-around case: interval spans from oldest to MAX, then 0 to newest
+    return candidate >= oldest || candidate <= newest;
+  }
+}
+
+/**
+ * Mutable sequence number class for tracking and incrementing
+ */
+export class SequenceNumber {
+  private _value: number;
+
+  constructor(initialValue: number = INITIAL_SEQUENCE_NUMBER) {
+    this._value = initialValue;
+  }
+
+  /**
+   * Get the current value
+   */
+  get value(): number {
+    return this._value;
+  }
+
+  /**
+   * Set a new value
+   */
+  set(newValue: number): void {
+    this._value = newValue;
+  }
+
+  /**
+   * Increment and return the new value
+   */
+  increment(): number {
+    this._value = nextSequenceNumber(this._value);
+    return this._value;
+  }
+
+  /**
+   * Get current value and then increment
+   */
+  getAndIncrement(): number {
+    const current = this._value;
+    this._value = nextSequenceNumber(this._value);
+    return current;
+  }
+
+  /**
+   * Check if the current value is valid
+   */
+  isValid(): boolean {
+    return isValidSequenceNumber(this._value);
+  }
+
+  /**
+   * Create a copy
+   */
+  clone(): SequenceNumber {
+    return new SequenceNumber(this._value);
+  }
+
+  toString(): string {
+    return String(this._value);
+  }
+}
+
+/**
+ * Thread-safe (atomic-like) sequence number for concurrent access.
+ * In JavaScript/TypeScript this provides a clean interface for
+ * atomic get/set operations.
+ */
+export class AtomicSequenceNumber {
+  private _value: number;
+
+  constructor(initialValue: number = NO_SEQUENCE_NUMBER) {
+    this._value = initialValue;
+  }
+
+  /**
+   * Get the current value
+   */
+  get(): number {
+    return this._value;
+  }
+
+  /**
+   * Set a new value
+   */
+  set(newValue: number): void {
+    this._value = newValue;
+  }
+
+  /**
+   * Compare and set: only set if current value equals expected
+   * Returns true if the value was set
+   */
+  compareAndSet(expected: number, newValue: number): boolean {
+    if (this._value === expected) {
+      this._value = newValue;
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Get current value and then set new value
+   */
+  getAndSet(newValue: number): number {
+    const current = this._value;
+    this._value = newValue;
+    return current;
+  }
+
+  /**
+   * Increment and return the new value
+   */
+  incrementAndGet(): number {
+    this._value = nextSequenceNumber(this._value);
+    return this._value;
+  }
+
+  /**
+   * Check if the current value is valid
+   */
+  isValid(): boolean {
+    return isValidSequenceNumber(this._value);
+  }
+}