Class QueueSpy

packages/effect/test/Sink/constructors.test.ts:91–191

const createQueueSpy = <A>(queue: Queue.Queue<A>): Queue.Queue<A> => new QueueSpy(queue)

class QueueSpy<A> extends Effectable.Class<A> implements Queue.Queue<A> {
  readonly [Queue.DequeueTypeId] = internalQueue.dequeueVariance
  readonly [Queue.EnqueueTypeId] = internalQueue.enqueueVariance
  private isShutdownInternal = false
  readonly queue: Queue.BackingQueue<A>
  readonly shutdownFlag: MutableRef.MutableRef<boolean>
  readonly shutdownHook: Deferred.Deferred<void, never>
  readonly strategy: Queue.Strategy<A>
  readonly takers: MutableQueue.MutableQueue<Deferred.Deferred<A, never>>

  constructor(readonly backingQueue: Queue.Queue<A>) {
    super()
    this.queue = backingQueue.queue
    this.shutdownFlag = backingQueue.shutdownFlag
    this.shutdownHook = backingQueue.shutdownHook
    this.strategy = backingQueue.strategy
    this.takers = backingQueue.takers
  }

  commit() {
    return this.take
  }

  pipe() {
    return pipeArguments(this, arguments)
  }

  unsafeOffer(value: A): boolean {
    return Queue.unsafeOffer(this.backingQueue, value)
  }

  offer(a: A) {
    return Queue.offer(this.backingQueue, a)
  }

  offerAll(elements: Iterable<A>) {
    return Queue.offerAll(this.backingQueue, elements)
  }

  capacity(): number {
    return Queue.capacity(this.backingQueue)
  }

  get size(): Effect.Effect<number> {
    return Queue.size(this.backingQueue)
  }

  unsafeSize(): Option.Option<number> {
    return this.backingQueue.unsafeSize()
  }

  get awaitShutdown(): Effect.Effect<void> {
    return Queue.awaitShutdown(this.backingQueue)
  }

  isActive(): boolean {
    return !this.isShutdownInternal
  }