@axpecter/lync 2.2.1 → 2.3.2

package/src/codec/composite/Shared.luau

@@ -1,29 +1,27 @@
 --!strict
 --!native
--- Shared helpers for composite codecs: delta flags, scratch pool, bool packing.
+-- Shared composite-codec helpers: delta flags, scratch pool, bool packing.
 
 local Base = require(script.Parent.Parent.Base)
+local Buf = require(script.Parent.Parent.Parent.util.Buffer)
+local Channel = require(script.Parent.Parent.Parent.internal.Channel)
+local Log = require(script.Parent.Parent.Parent.util.Log)
 local Types = require(script.Parent.Parent.Parent.Types)
 
 -- Constants --------------------------------------------------------------
 
 --[[
-    Delta encoding flag space, shared across deltaStruct/deltaArray/deltaMap:
-      0    UNCHANGED  : sender skipped this entry, decoder reuses cache
-      1    FULL       : full payload follows
-      2..  reserved   : per-segment / per-key delta encodings (future)
-
-    Struct's per-segment scheme uses [1..segCount] as "single dirty
-    segment index" then segCount + DELTA_FULL_OFFSET for full and
-    segCount + DELTA_MULTI_OFFSET for multi-dirty bitmap.
+    Delta flag base shared by deltaStruct's per-segment scheme:
+      0    UNCHANGED
+      1..segCount             single dirty segment k
+      segCount + FULL_OFFSET  FULL payload
+      segCount + MULTI_OFFSET MULTI: bitmap + dirty segs in order
+    deltaArray and deltaMap manage their own flag spaces.
 ]]
 local DELTA_UNCHANGED = 0
-local DELTA_FULL = 1
 local DELTA_FULL_OFFSET = 1
 local DELTA_MULTI_OFFSET = 2
 
-local INITIAL_SCRATCH = 1024
-
 -- State ------------------------------------------------------------------
 
 local _nextDeltaId = 0
@@ -35,29 +33,31 @@ local _scratchStack: { Types.ChannelState } = {}
 local alloc = Base.alloc
 local band = bit32.band
 local bor = bit32.bor
-local bxor = bit32.bxor
 local lshift = bit32.lshift
 local readu8 = buffer.readu8
-local readu32 = buffer.readu32
 local writeu8 = buffer.writeu8
+local bufCopy = buffer.copy
+local bufLen = buffer.len
+local rangeEqual = Buf.rangeEqual
+local snapshot = Buf.snapshot
 
-local function newScratch(): Types.ChannelState
-    return {
-        buff = buffer.create(INITIAL_SCRATCH),
-        cursor = 0,
-        size = INITIAL_SCRATCH,
-        refs = {},
-        refCount = 0,
-        lastId = -1,
-        countPos = -1,
-        itemCount = 0,
-        singleMode = false,
-        singlePos = 0,
-        deltas = {},
-        prevDump = nil,
-        prevDumpLen = 0,
-        currentPacket = nil,
-    }
+--[[
+    Reuse `existing` when it's already large enough, else snapshot via
+    Buf.snapshot. Avoids per-write buffer allocations on delta caches that
+    hover at a stable size.
+]]
+local function copyToBuf(existing: buffer?, src: buffer, srcOff: number, len: number): buffer
+    if existing and bufLen(existing) >= len then
+        bufCopy(existing, 0, src, srcOff, len)
+        return existing
+    end
+    return snapshot(src, len, srcOff)
+end
+
+-- Update a `{raw, len}` cache shape from scratch bytes; reuses raw via copyToBuf.
+local function refreshCache(cache: any, src: buffer, len: number): ()
+    cache.raw = copyToBuf(cache.raw, src, 0, len)
+    cache.len = len
 end
 
 -- Public -----------------------------------------------------------------
@@ -65,19 +65,39 @@ end
 local Shared = {}
 
 Shared.DELTA_UNCHANGED = DELTA_UNCHANGED
-Shared.DELTA_FULL = DELTA_FULL
 Shared.DELTA_FULL_OFFSET = DELTA_FULL_OFFSET
 Shared.DELTA_MULTI_OFFSET = DELTA_MULTI_OFFSET
+Shared.rangeEqual = rangeEqual
+Shared.snapshot = snapshot
+Shared.refreshCache = refreshCache
+Shared.copyToBuf = copyToBuf
+
+-- True when `c` itself is a delta codec OR contains one in its tree.
+function Shared.containsDelta(c: Types.InternalCodec<any>): boolean
+    return c._isDelta == true or c._hasDelta == true
+end
+
+-- Common bounds check for variable-length container codecs.
+function Shared.enforceMaxCount(len: number, maxCount: number?, label: string?): ()
+    if maxCount and len > maxCount then
+        Log.error(`{label or "count"} {len} exceeds max {maxCount}`)
+    end
+end
 
 function Shared.allocDeltaId(): number
     _nextDeltaId += 1
     return _nextDeltaId
 end
 
+-- 8 bools per byte.
+function Shared.boolBytes(n: number): number
+    return (n + 7) // 8
+end
+
 --[[
-    Acquire a scratch ChannelState. Stack-based so re-entrant codec
-    serialization (a codec writing into scratch that triggers another
-    codec's scratch acquire) works without aliasing.
+    Stack-based scratch ChannelState pool. Re-entrant codec serialization
+    (a codec writing into scratch that triggers another codec's scratch
+    acquire) works without aliasing.
 ]]
 function Shared.acquireScratch(): Types.ChannelState
     _scratchDepth += 1
@@ -87,7 +107,7 @@ function Shared.acquireScratch(): Types.ChannelState
         ch.refCount = 0
         return ch
     end
-    ch = newScratch()
+    ch = Channel.create()
     _scratchStack[_scratchDepth] = ch
     return ch
 end
@@ -96,35 +116,29 @@ function Shared.releaseScratch(): ()
     _scratchDepth -= 1
 end
 
-function Shared.rangeEqual(a: buffer, offA: number, b: buffer, offB: number, len: number): boolean
-    local aligned = band(len, -4)
-    local i = 0
-    while i < aligned do
-        if bxor(readu32(a, offA + i), readu32(b, offB + i)) ~= 0 then
-            return false
-        end
-        i += 4
-    end
-    while i < len do
-        if readu8(a, offA + i) ~= readu8(b, offB + i) then
-            return false
+--[[
+    Reset module-private state. Called by Sandbox in tests so that a thrown
+    codec.write (which skips releaseScratch and leaves depth inflated) can't
+    leak into the next test's scratch acquisition. Also resets the deltaId
+    counter so test ordering doesn't bleed.
+]]
+function Shared.reset(): ()
+    _scratchDepth = 0
+    _nextDeltaId = 0
+    for i = 1, #_scratchStack do
+        local ch = _scratchStack[i]
+        ch.cursor = 0
+        ch.refCount = 0
+        if ch.refCount > 0 then
+            table.clear(ch.refs)
         end
-        i += 1
-    end
-    return true
-end
-
-function Shared.snapshot(src: buffer, len: number): buffer
-    local out = buffer.create(len)
-    if len > 0 then
-        buffer.copy(out, 0, src, 0, len)
+        table.clear(ch.deltas)
     end
-    return out
 end
 
 --[[
-    Split a struct schema into (dataKeys, dataCodecs, boolKeys), all
-    sorted alphabetically for deterministic wire layout.
+    Split a struct schema into (dataKeys, dataCodecs, boolKeys), each sorted
+    alphabetically for deterministic wire layout.
 ]]
 function Shared.extractFields(
     schema: { [string]: Types.InternalCodec<any> }
@@ -140,9 +154,7 @@ function Shared.extractFields(
         end
     end
 
-    if #dataKeys == 0 and #boolKeys == 0 then
-        error("[Lync] Lync.struct: requires at least one field")
-    end
+    Log.assert(#dataKeys > 0 or #boolKeys > 0, "requires at least one field")
 
     table.sort(dataKeys)
     table.sort(boolKeys)
@@ -174,9 +186,9 @@ function Shared.packBools(
     if cursor + byteCount > ch.size then
         alloc(ch, byteCount)
     end
-    local b = ch.buff
 
     local idx = 1
+    local b = ch.buff
     for byteIdx = 0, byteCount - 1 do
         local packed = 0
         local remaining = boolCount - idx + 1
@@ -193,6 +205,39 @@ function Shared.packBools(
     ch.cursor = cursor + byteCount
 end
 
+--[[
+    Integer-indexed bool-array pack. Split from packBools to skip the
+    per-bit string-key getter on the bool-array hot path.
+]]
+function Shared.packBoolArray(ch: Types.ChannelState, value: { boolean }, count: number): ()
+    if count == 0 then
+        return
+    end
+
+    local byteCount = (count + 7) // 8
+    local cursor = ch.cursor
+    if cursor + byteCount > ch.size then
+        alloc(ch, byteCount)
+    end
+
+    local idx = 1
+    local b = ch.buff
+    for byteIdx = 0, byteCount - 1 do
+        local packed = 0
+        local remaining = count - idx + 1
+        local limit = if remaining >= 8 then 8 else remaining
+        for bit = 0, limit - 1 do
+            if value[idx] then
+                packed = bor(packed, lshift(1, bit))
+            end
+            idx += 1
+        end
+        writeu8(b, cursor + byteIdx, packed)
+    end
+
+    ch.cursor = cursor + byteCount
+end
+
 function Shared.unpackBools(
     src: buffer,
     pos: number,
@@ -218,4 +263,29 @@ function Shared.unpackBools(
     return byteCount
 end
 
+-- Fills `result[1..count]` in place.
+function Shared.unpackBoolArray(
+    src: buffer,
+    pos: number,
+    count: number,
+    result: { boolean }
+): number
+    if count == 0 then
+        return 0
+    end
+
+    local byteCount = (count + 7) // 8
+    local idx = 1
+    for byteIdx = 0, byteCount - 1 do
+        local byte = readu8(src, pos + byteIdx)
+        local remaining = count - idx + 1
+        local limit = if remaining >= 8 then 8 else remaining
+        for bit = 0, limit - 1 do
+            result[idx] = band(byte, lshift(1, bit)) ~= 0
+            idx += 1
+        end
+    end
+    return byteCount
+end
+
 return table.freeze(Shared)