Changed size estimation api, added the ability to skip a number of by…

…tes in IO.

package.json

@@ -1,6 +1,6 @@
 {
     "name": "typed-binary",
-    "version": "2.0.0",
+    "version": "2.1.0",
     "description": "Describe binary structures with full TypeScript support. Encode and decode into pure JavaScript objects.",
     "main": "dist/cjs/index.js",
     "module": "dist/esm/index.js",

src/io/bufferReader.ts

@@ -50,4 +50,8 @@ export class BufferReader extends BufferIOBase implements ISerialInput {
 
     return contents;
   }
+
+  skipBytes(bytes: number): void {
+    this.byteOffset += bytes;
+  }
 }

src/io/bufferWriter.ts

@@ -46,4 +46,8 @@ export class BufferWriter extends BufferIOBase implements ISerialOutput {
     // Extra null character
     this.uint8View[this.byteOffset++] = 0;
   }
+
+  skipBytes(bytes: number): void {
+    this.byteOffset += bytes;
+  }
 }

src/io/index.ts

@@ -1,4 +1,5 @@
-export { ISerialInput, ISerialOutput } from './types';
+export { ISerialInput, ISerialOutput, IMeasurer } from './types';
 export { BufferWriter } from './bufferWriter';
 export { BufferReader } from './bufferReader';
-export { isBigEndian } from '../util';
+export { Measurer } from './measurer';
+export { isBigEndian } from '../util';

src/io/measurer.ts

@@ -0,0 +1,34 @@
+import { IMeasurer } from './types';
+
+class UnboundedMeasurer implements IMeasurer {
+  size = NaN;
+  unbounded: IMeasurer = this;
+  isUnbounded = true;
+
+  add(): IMeasurer {
+    return this;
+  }
+
+  fork(): IMeasurer {
+    return this;
+  }
+}
+
+const unboundedMeasurer = new UnboundedMeasurer();
+
+export class Measurer implements IMeasurer {
+  size = 0;
+  unbounded: IMeasurer = unboundedMeasurer;
+  isUnbounded = false;
+
+  add(bytes: number): IMeasurer {
+    this.size += bytes;
+    return this;
+  }
+
+  fork() {
+    const forked = new Measurer();
+    forked.size = this.size;
+    return forked;
+  }
+}

src/io/types.ts

@@ -5,6 +5,7 @@ export interface ISerialInput {
   readUint32(): number;
   readFloat32(): number;
   readString(): string;
+  skipBytes(bytes: number): void;
   readonly currentByteOffset: number;
 }
 
@@ -15,5 +16,15 @@ export interface ISerialOutput {
   writeUint32(value: number): void;
   writeFloat32(value: number): void;
   writeString(value: string): void;
+  skipBytes(bytes: number): void;
   readonly currentByteOffset: number;
 }
+
+export interface IMeasurer {
+  add(bytes: number): IMeasurer;
+  fork(): IMeasurer;
+  readonly unbounded: IMeasurer;
+
+  readonly size: number;
+  readonly isUnbounded: boolean;
+}

src/structure/array.ts

@@ -1,5 +1,10 @@
-import type { ISerialInput, ISerialOutput } from '../io';
-import { i32 } from './baseTypes';
+import {
+  type ISerialInput,
+  type ISerialOutput,
+  type IMeasurer,
+  Measurer,
+} from '../io';
+import { u32 } from './baseTypes';
 import {
   IRefResolver,
   ISchema,
@@ -43,19 +48,23 @@ export class ArraySchema<T> extends Schema<T[]> {
     return array;
   }
 
-  sizeOf(values: T[] | typeof MaxValue): number {
+  measure(
+    values: T[] | typeof MaxValue,
+    measurer: IMeasurer = new Measurer(),
+  ): IMeasurer {
     if (values === MaxValue) {
       // arrays cannot be bound
-      return NaN;
+      return measurer.unbounded;
     }
 
     // Length encoding
-    let size = i32.sizeOf();
+    u32.measure(values.length, measurer);
+
     // Values encoding
-    size += values
-      .map((v) => this.elementType.sizeOf(v))
-      .reduce((a, b) => a + b, 0);
+    for (const value of values) {
+      this.elementType.measure(value, measurer);
+    }
 
-    return size;
+    return measurer;
   }
 }

src/structure/baseTypes.ts

@@ -1,4 +1,4 @@
-import { ISerialInput, ISerialOutput } from '../io';
+import { ISerialInput, ISerialOutput, IMeasurer, Measurer } from '../io';
 import { Schema, MaxValue } from './types';
 
 ////
@@ -18,8 +18,11 @@ export class BoolSchema extends Schema<boolean> {
     output.writeBool(value);
   }
 
-  sizeOf(): number {
-    return 1;
+  measure(
+    _: boolean | MaxValue,
+    measurer: IMeasurer = new Measurer(),
+  ): IMeasurer {
+    return measurer.add(1);
   }
 }
 
@@ -42,12 +45,15 @@ export class StringSchema extends Schema<string> {
     output.writeString(value);
   }
 
-  sizeOf<T extends string>(value: T | typeof MaxValue): number {
+  measure(
+    value: string | typeof MaxValue,
+    measurer: IMeasurer = new Measurer(),
+  ): IMeasurer {
     if (value === MaxValue) {
       // A string cannot be bound
-      return NaN;
+      return measurer.unbounded;
     }
-    return value.length + 1;
+    return measurer.add(value.length + 1);
   }
 }
 
@@ -70,8 +76,11 @@ export class ByteSchema extends Schema<number> {
     output.writeByte(value);
   }
 
-  sizeOf(): number {
-    return 1;
+  measure(
+    _: number | MaxValue,
+    measurer: IMeasurer = new Measurer(),
+  ): IMeasurer {
+    return measurer.add(1);
   }
 }
 
@@ -94,8 +103,11 @@ export class Int32Schema extends Schema<number> {
     output.writeInt32(value);
   }
 
-  sizeOf(): number {
-    return 4;
+  measure(
+    _: number | MaxValue,
+    measurer: IMeasurer = new Measurer(),
+  ): IMeasurer {
+    return measurer.add(4);
   }
 }
 
@@ -118,8 +130,11 @@ export class Uint32Schema extends Schema<number> {
     output.writeUint32(value);
   }
 
-  sizeOf(): number {
-    return 4;
+  measure(
+    _: number | MaxValue,
+    measurer: IMeasurer = new Measurer(),
+  ): IMeasurer {
+    return measurer.add(4);
   }
 }
 
@@ -142,8 +157,11 @@ export class Float32Schema extends Schema<number> {
     output.writeFloat32(value);
   }
 
-  sizeOf(): number {
-    return 4;
+  measure(
+    _: number | MaxValue,
+    measurer: IMeasurer = new Measurer(),
+  ): IMeasurer {
+    return measurer.add(4);
   }
 }
 

src/structure/chars.ts

@@ -1,35 +1,39 @@
-import type { ISerialInput, ISerialOutput } from '../io';
+import type { IMeasurer, ISerialInput, ISerialOutput } from '../io';
 import { TypedBinaryError } from '../error';
 import { Schema } from './types';
 
 export class CharsSchema extends Schema<string> {
-    constructor(public readonly length: number) {
-        super();
-    }
+  constructor(public readonly length: number) {
+    super();
+  }
 
-    resolve(): void { /* Nothing to resolve */ }
+  resolve(): void {
+    /* Nothing to resolve */
+  }
 
-    write(output: ISerialOutput, value: string): void {
-        if (value.length !== this.length) {
-            throw new TypedBinaryError(`Expected char-string of length ${this.length}, got ${value.length}`);
-        }
-
-        for (let i = 0; i < value.length; ++i) {
-            output.writeByte(value.charCodeAt(i));
-        }
+  write(output: ISerialOutput, value: string): void {
+    if (value.length !== this.length) {
+      throw new TypedBinaryError(
+        `Expected char-string of length ${this.length}, got ${value.length}`,
+      );
     }
 
-    read(input: ISerialInput): string {
-        let content = '';
-
-        for (let i = 0; i < this.length; ++i) {
-            content += String.fromCharCode(input.readByte());
-        }
-
-        return content;
+    for (let i = 0; i < value.length; ++i) {
+      output.writeByte(value.charCodeAt(i));
     }
+  }
+
+  read(input: ISerialInput): string {
+    let content = '';
 
-    sizeOf(): number {
-        return this.length;
+    for (let i = 0; i < this.length; ++i) {
+      content += String.fromCharCode(input.readByte());
     }
+
+    return content;
+  }
+
+  measure(_: string, measurer: IMeasurer): IMeasurer {
+    return measurer.add(this.length);
+  }
 }

src/structure/index.ts

@@ -9,6 +9,8 @@ export {
   Ref,
   IRefResolver,
   Schema,
+  ISchema,
+  IStableSchema,
   ISchemaWithProperties,
   Keyed,
   KeyedSchema,

src/structure/keyed.ts

@@ -1,6 +1,6 @@
 import { Parsed } from '..';
 import { TypedBinaryError } from '../error';
-import { ISerialInput, ISerialOutput } from '../io';
+import { IMeasurer, ISerialInput, ISerialOutput, Measurer } from '../io';
 import {
   IRefResolver,
   ISchema,
@@ -36,9 +36,9 @@ class RefSchema<K extends string> implements IStableSchema<Ref<K>> {
     );
   }
 
-  sizeOf(): number {
+  measure(): IMeasurer {
     throw new TypedBinaryError(
-      `Tried to estimate size of a reference directly. Resolve it instead.`,
+      `Tried to measure size of a reference directly. Resolve it instead.`,
     );
   }
 }
@@ -107,7 +107,10 @@ export class KeyedSchema<K extends string, S extends IStableSchema<unknown>>
     this.innerType.write(output, value);
   }
 
-  sizeOf(value: Parsed<S> | typeof MaxValue): number {
-    return this.innerType.sizeOf(value);
+  measure(
+    value: Parsed<S> | typeof MaxValue,
+    measurer: IMeasurer = new Measurer(),
+  ): IMeasurer {
+    return this.innerType.measure(value, measurer);
   }
 }