@fncts/io 0.0.1

package/_mjs/internal/Hub.mjs

@@ -0,0 +1,723 @@
+import * as tsplus_module_1 from "@fncts/base/collection/immutable/Conc/constructors";
+import * as tsplus_module_2 from "@fncts/base/collection/immutable/Conc/api";
+import * as tsplus_module_3 from "@fncts/base/collection/immutable/Conc/api/empty";
+import * as tsplus_module_4 from "@fncts/base/data/exceptions";
+/**
+ * @tsplus type fncts.internal.Hub.Subscription
+ * @tsplus companion fncts.internal.Hub.SubscriptionOps
+ */
+
+export class SubscriptionInternal {}
+/**
+ * @tsplus type fncts.internal.Hub
+ * @tsplus companion fncts.internal.Hub
+ */
+
+export class Hub {}
+export class BoundedHubArb extends Hub {
+  constructor(requestedCapacity) {
+    super();
+    this.publisherIndex = 0;
+    this.subscriberCount = 0;
+    this.subscribersIndex = 0;
+    this.array = Array(requestedCapacity);
+    this.subscribers = Array(requestedCapacity);
+    this.capacity = requestedCapacity;
+  }
+
+  isEmpty() {
+    return this.publisherIndex === this.subscribersIndex;
+  }
+
+  isFull() {
+    return this.publisherIndex === this.subscribersIndex + this.capacity;
+  }
+
+  publish(a) {
+    if (this.isFull()) {
+      return false;
+    }
+
+    if (this.subscriberCount !== 0) {
+      const index = this.publisherIndex % this.capacity;
+      this.array[index] = a;
+      this.subscribers[index] = this.subscriberCount;
+      this.publisherIndex += 1;
+    }
+
+    return true;
+  }
+
+  publishAll(as) {
+    const asArray = tsplus_module_1.from(as);
+    const n = asArray.length;
+    const size = this.publisherIndex - this.subscribersIndex;
+    const available = this.capacity - size;
+    const forHub = Math.min(n, available);
+
+    if (forHub === 0) {
+      return asArray;
+    }
+
+    let iteratorIndex = 0;
+    const publishAllIndex = this.publisherIndex + forHub;
+
+    while (this.publisherIndex !== publishAllIndex) {
+      const a = tsplus_module_2.unsafeGet_(asArray, iteratorIndex++);
+      const index = this.publisherIndex % this.capacity;
+      this.array[index] = a;
+      this.publisherIndex += 1;
+    }
+
+    return tsplus_module_2.drop_(asArray, iteratorIndex - 1);
+  }
+
+  size() {
+    return this.publisherIndex - this.subscribersIndex;
+  }
+
+  slide() {
+    if (this.subscribersIndex !== this.publisherIndex) {
+      const index = this.subscribersIndex % this.capacity;
+      this.array[index] = null;
+      this.subscribers[index] = 0;
+      this.subscribersIndex += 1;
+    }
+  }
+
+  subscribe() {
+    this.subscriberCount += 1;
+    return new BoundedHubArbSubscription(this, this.publisherIndex, false);
+  }
+
+}
+
+class BoundedHubArbSubscription extends SubscriptionInternal {
+  constructor(self, subscriberIndex, unsubscribed) {
+    super();
+    this.self = self;
+    this.subscriberIndex = subscriberIndex;
+    this.unsubscribed = unsubscribed;
+  }
+
+  isEmpty() {
+    return this.unsubscribed || this.self.publisherIndex === this.subscriberIndex || this.self.publisherIndex === this.self.subscribersIndex;
+  }
+
+  poll(default_) {
+    if (this.unsubscribed) {
+      return default_;
+    }
+
+    this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
+
+    if (this.subscriberIndex !== this.self.publisherIndex) {
+      const index = this.subscriberIndex % this.self.capacity;
+      const a = this.self.array[index];
+      this.self.subscribers[index] -= 1;
+
+      if (this.self.subscribers[index] === 0) {
+        this.self.array[index] = null;
+        this.self.subscribersIndex += 1;
+      }
+
+      this.subscriberIndex += 1;
+      return a;
+    }
+
+    return default_;
+  }
+
+  pollUpTo(n) {
+    if (this.unsubscribed) {
+      return tsplus_module_3.empty();
+    }
+
+    this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
+    const size = this.self.publisherIndex - this.subscriberIndex;
+    const toPoll = Math.min(n, size);
+
+    if (toPoll <= 0) {
+      return tsplus_module_3.empty();
+    }
+
+    let builder = tsplus_module_3.empty();
+    const pollUpToIndex = this.subscriberIndex + toPoll;
+
+    while (this.subscriberIndex !== pollUpToIndex) {
+      const index = this.subscriberIndex % this.self.capacity;
+      const a = this.self.array[index];
+      builder = tsplus_module_2.append_(builder, a);
+      this.subscriberIndex += 1;
+    }
+
+    return builder;
+  }
+
+  size() {
+    if (this.unsubscribed) {
+      return 0;
+    }
+
+    return this.self.publisherIndex - Math.max(this.subscriberIndex, this.self.subscribersIndex);
+  }
+
+  unsubscribe() {
+    if (!this.unsubscribed) {
+      this.unsubscribed = true;
+      this.self.subscriberCount -= 1;
+      this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
+
+      while (this.subscriberIndex !== this.self.publisherIndex) {
+        const index = this.subscriberIndex % this.self.capacity;
+        this.self.subscribers[index] -= 1;
+
+        if (this.self.subscribers[index] === 0) {
+          this.self.array[index] = null;
+          this.self.subscribersIndex += 1;
+        }
+
+        this.subscriberIndex += 1;
+      }
+    }
+  }
+
+}
+
+export class BoundedHubPow2 extends Hub {
+  constructor(requestedCapacity) {
+    super();
+    this.publisherIndex = 0;
+    this.subscriberCount = 0;
+    this.subscribersIndex = 0;
+    this.array = Array(requestedCapacity);
+    this.mask = requestedCapacity - 1;
+    this.subscribers = Array(requestedCapacity);
+    this.capacity = requestedCapacity;
+  }
+
+  isEmpty() {
+    return this.publisherIndex === this.subscribersIndex;
+  }
+
+  isFull() {
+    return this.publisherIndex === this.subscribersIndex + this.capacity;
+  }
+
+  publish(a) {
+    if (this.isFull()) {
+      return false;
+    }
+
+    if (this.subscriberCount !== 0) {
+      const index = this.publisherIndex & this.mask;
+      this.array[index] = a;
+      this.subscribers[index] = this.subscriberCount;
+      this.publisherIndex += 1;
+    }
+
+    return true;
+  }
+
+  publishAll(as) {
+    const asArray = tsplus_module_1.from(as);
+    const n = asArray.length;
+    const size = this.publisherIndex - this.subscribersIndex;
+    const available = this.capacity - size;
+    const forHub = Math.min(n, available);
+
+    if (forHub === 0) {
+      return asArray;
+    }
+
+    let iteratorIndex = 0;
+    const publishAllIndex = this.publisherIndex + forHub;
+
+    while (this.publisherIndex !== publishAllIndex) {
+      const a = tsplus_module_2.unsafeGet_(asArray, iteratorIndex++);
+      const index = this.publisherIndex & this.mask;
+      this.array[index] = a;
+      this.publisherIndex += 1;
+    }
+
+    return tsplus_module_2.drop_(asArray, iteratorIndex - 1);
+  }
+
+  size() {
+    return this.publisherIndex - this.subscribersIndex;
+  }
+
+  slide() {
+    if (this.subscribersIndex !== this.publisherIndex) {
+      const index = this.subscribersIndex & this.mask;
+      this.array[index] = null;
+      this.subscribers[index] = 0;
+      this.subscribersIndex += 1;
+    }
+  }
+
+  subscribe() {
+    this.subscriberCount += 1;
+    return new BoundedHubPow2Subcription(this, this.publisherIndex, false);
+  }
+
+}
+
+class BoundedHubPow2Subcription extends SubscriptionInternal {
+  constructor(self, subscriberIndex, unsubscribed) {
+    super();
+    this.self = self;
+    this.subscriberIndex = subscriberIndex;
+    this.unsubscribed = unsubscribed;
+  }
+
+  isEmpty() {
+    return this.unsubscribed || this.self.publisherIndex === this.subscriberIndex || this.self.publisherIndex === this.self.subscribersIndex;
+  }
+
+  poll(default_) {
+    if (this.unsubscribed) {
+      return default_;
+    }
+
+    this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
+
+    if (this.subscriberIndex !== this.self.publisherIndex) {
+      const index = this.subscriberIndex & this.self.mask;
+      const a = this.self.array[index];
+      this.self.subscribers[index] -= 1;
+
+      if (this.self.subscribers[index] === 0) {
+        this.self.array[index] = null;
+        this.self.subscribersIndex += 1;
+      }
+
+      this.subscriberIndex += 1;
+      return a;
+    }
+
+    return default_;
+  }
+
+  pollUpTo(n) {
+    if (this.unsubscribed) {
+      return tsplus_module_3.empty();
+    }
+
+    this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
+    const size = this.self.publisherIndex - this.subscriberIndex;
+    const toPoll = Math.min(n, size);
+
+    if (toPoll <= 0) {
+      return tsplus_module_3.empty();
+    }
+
+    let builder = tsplus_module_3.empty();
+    const pollUpToIndex = this.subscriberIndex + toPoll;
+
+    while (this.subscriberIndex !== pollUpToIndex) {
+      const index = this.subscriberIndex & this.self.mask;
+      const a = this.self.array[index];
+      builder = tsplus_module_2.append_(builder, a);
+      this.subscriberIndex += 1;
+    }
+
+    return builder;
+  }
+
+  size() {
+    if (this.unsubscribed) {
+      return 0;
+    }
+
+    return this.self.publisherIndex - Math.max(this.subscriberIndex, this.self.subscribersIndex);
+  }
+
+  unsubscribe() {
+    if (!this.unsubscribed) {
+      this.unsubscribed = true;
+      this.self.subscriberCount -= 1;
+      this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
+
+      while (this.subscriberIndex < this.self.publisherIndex) {
+        const index = this.subscriberIndex & this.self.mask;
+        this.self.subscribers[index] -= 1;
+
+        if (this.self.subscribers[index] === 0) {
+          this.self.array[index] = null;
+          this.self.subscribersIndex += 1;
+        }
+
+        this.subscriberIndex += 1;
+      }
+    }
+  }
+
+}
+
+export class BoundedHubSingle extends Hub {
+  constructor() {
+    super();
+    this.publisherIndex = 0;
+    this.subscriberCount = 0;
+    this.subscribers = 0;
+    this.value = null;
+    this.capacity = 1;
+  }
+
+  isEmpty() {
+    return this.subscribers === 0;
+  }
+
+  isFull() {
+    return !this.isEmpty();
+  }
+
+  publish(a) {
+    if (this.isFull()) {
+      return false;
+    }
+
+    if (this.subscriberCount !== 0) {
+      this.value = a;
+      this.subscribers = this.subscriberCount;
+      this.publisherIndex += 1;
+    }
+
+    return true;
+  }
+
+  publishAll(as) {
+    const list = tsplus_module_1.from(as);
+
+    if (tsplus_module_2.isEmpty(list)) {
+      return tsplus_module_3.empty();
+    }
+
+    if (this.publish(tsplus_module_2.unsafeHead(list))) {
+      return tsplus_module_2.drop_(list, 1);
+    } else {
+      return list;
+    }
+  }
+
+  size() {
+    return this.isEmpty() ? 0 : 1;
+  }
+
+  slide() {
+    if (this.isFull()) {
+      this.subscribers = 0;
+      this.value = null;
+    }
+  }
+
+  subscribe() {
+    this.subscriberCount += 1;
+    return new BoundedHubSingleSubscription(this, this.publisherIndex, false);
+  }
+
+}
+
+class BoundedHubSingleSubscription extends SubscriptionInternal {
+  constructor(self, subscriberIndex, unsubscribed) {
+    super();
+    this.self = self;
+    this.subscriberIndex = subscriberIndex;
+    this.unsubscribed = unsubscribed;
+  }
+
+  isEmpty() {
+    return this.unsubscribed || this.self.subscribers === 0 || this.subscriberIndex === this.self.publisherIndex;
+  }
+
+  poll(default_) {
+    if (this.isEmpty()) {
+      return default_;
+    }
+
+    const a = this.self.value;
+    this.self.subscribers -= 1;
+
+    if (this.self.subscribers === 0) {
+      this.self.value = null;
+    }
+
+    this.subscriberIndex += 1;
+    return a;
+  }
+
+  pollUpTo(n) {
+    if (this.isEmpty() || n < 1) {
+      return tsplus_module_3.empty();
+    }
+
+    const a = this.self.value;
+    this.self.subscribers -= 1;
+
+    if (this.self.subscribers === 0) {
+      this.self.value = null;
+    }
+
+    this.subscriberIndex += 1;
+    return tsplus_module_1.single(a);
+  }
+
+  size() {
+    return this.isEmpty() ? 0 : 1;
+  }
+
+  unsubscribe() {
+    if (!this.unsubscribed) {
+      this.unsubscribed = true;
+      this.self.subscriberCount -= 1;
+
+      if (this.subscriberIndex !== this.self.publisherIndex) {
+        this.self.subscribers -= 1;
+
+        if (this.self.subscribers === 0) {
+          this.self.value = null;
+        }
+      }
+    }
+  }
+
+}
+
+class Node {
+  constructor(value, subscribers, next) {
+    this.value = value;
+    this.subscribers = subscribers;
+    this.next = next;
+  }
+
+}
+
+export class UnboundedHub extends Hub {
+  constructor() {
+    super();
+    this.publisherHead = new Node(null, 0, null);
+    this.publisherIndex = 0;
+    this.subscribersIndex = 0;
+    this.capacity = Number.MAX_SAFE_INTEGER;
+    this.publisherTail = this.publisherHead;
+  }
+
+  isEmpty() {
+    return this.publisherHead === this.publisherTail;
+  }
+
+  isFull() {
+    return false;
+  }
+
+  publish(a) {
+    const subscribers = this.publisherTail.subscribers;
+
+    if (subscribers !== 0) {
+      this.publisherTail.next = new Node(a, subscribers, null);
+      this.publisherTail = this.publisherTail.next;
+      this.publisherIndex += 1;
+    }
+
+    return true;
+  }
+
+  publishAll(as) {
+    for (const a of as) {
+      this.publish(a);
+    }
+
+    return tsplus_module_3.empty();
+  }
+
+  size() {
+    return this.publisherIndex - this.subscribersIndex;
+  }
+
+  slide() {
+    if (this.publisherHead !== this.publisherTail) {
+      this.publisherHead = this.publisherHead.next;
+      this.publisherHead.value = null;
+      this.subscribersIndex += 1;
+    }
+  }
+
+  subscribe() {
+    this.publisherTail.subscribers += 1;
+    return new UnboundedHubSubscription(this, this.publisherTail, this.publisherIndex, false);
+  }
+
+}
+
+class UnboundedHubSubscription extends SubscriptionInternal {
+  constructor(self, subscriberHead, subscriberIndex, unsubscribed) {
+    super();
+    this.self = self;
+    this.subscriberHead = subscriberHead;
+    this.subscriberIndex = subscriberIndex;
+    this.unsubscribed = unsubscribed;
+  }
+
+  isEmpty() {
+    if (this.unsubscribed) {
+      return true;
+    }
+
+    let empty = true;
+    let loop = true;
+
+    while (loop) {
+      if (this.subscriberHead === this.self.publisherTail) {
+        loop = false;
+      } else {
+        if (this.subscriberHead.next.value !== null) {
+          empty = false;
+          loop = false;
+        } else {
+          this.subscriberHead = this.subscriberHead.next;
+          this.subscriberIndex += 1;
+        }
+      }
+    }
+
+    return empty;
+  }
+
+  poll(def) {
+    if (this.unsubscribed) {
+      return def;
+    }
+
+    let loop = true;
+    let polled = def;
+
+    while (loop) {
+      if (this.subscriberHead === this.self.publisherTail) {
+        loop = false;
+      } else {
+        const a = this.subscriberHead.next.value;
+
+        if (a !== null) {
+          polled = a;
+          this.subscriberHead.subscribers -= 1;
+
+          if (this.subscriberHead.subscribers === 0) {
+            this.self.publisherHead = this.self.publisherHead.next;
+            this.self.publisherHead.value = null;
+            this.self.subscribersIndex += 1;
+          }
+
+          loop = false;
+        }
+
+        this.subscriberHead = this.subscriberHead.next;
+        this.subscriberIndex += 1;
+      }
+    }
+
+    return polled;
+  }
+
+  pollUpTo(n) {
+    let builder = tsplus_module_3.empty();
+    const default_ = null;
+    let i = 0;
+
+    while (i !== n) {
+      const a = this.poll(default_);
+
+      if (a === default_) {
+        i = n;
+      } else {
+        builder = tsplus_module_2.append_(builder, a);
+        i += 1;
+      }
+    }
+
+    return builder;
+  }
+
+  size() {
+    if (this.unsubscribed) {
+      return 0;
+    }
+
+    return this.self.publisherIndex - Math.max(this.subscriberIndex, this.self.subscribersIndex);
+  }
+
+  unsubscribe() {
+    if (!this.unsubscribed) {
+      this.unsubscribed = true;
+      this.self.publisherTail.subscribers -= 1;
+
+      while (this.subscriberHead !== this.self.publisherTail) {
+        if (this.subscriberHead.next.value !== null) {
+          this.subscriberHead.subscribers -= 1;
+
+          if (this.subscriberHead.subscribers === 0) {
+            this.self.publisherHead = this.self.publisherHead.next;
+            this.self.publisherHead.value = null;
+            this.self.subscribersIndex += 1;
+          }
+        }
+
+        this.subscriberHead = this.subscriberHead.next;
+      }
+    }
+  }
+
+}
+
+function ensureCapacity(capacity) {
+  if (capacity <= 0) {
+    throw new tsplus_module_4.InvalidCapacityError(`A Hub cannot have a capacity of ${capacity}`);
+  }
+}
+
+function nextPow2(n) {
+  const nextPow = Math.ceil(Math.log(n) / Math.log(2.0));
+  return Math.max(Math.pow(2, nextPow), 2);
+}
+/**
+ * @tsplus static fncts.internal.Hub makeBounded
+ */
+
+
+export function makeBounded(requestedCapacity) {
+  ensureCapacity(requestedCapacity);
+
+  if (requestedCapacity === 1) {
+    return new BoundedHubSingle();
+  } else if (nextPow2(requestedCapacity) === requestedCapacity) {
+    return new BoundedHubPow2(requestedCapacity);
+  } else {
+    return new BoundedHubArb(requestedCapacity);
+  }
+}
+/**
+ * @tsplus static fncts.internal.Hub makeUnbounded
+ */
+
+export function makeUnbounded() {
+  return new UnboundedHub();
+}
+/**
+ * Unsafely polls all values from a subscription.
+ *
+ * @tsplus getter fncts.internal.Hub.Subscription unsafePollAll
+ */
+
+export function unsafePollAll(subscription) {
+  return subscription.pollUpTo(Number.MAX_SAFE_INTEGER);
+}
+/**
+ * Unsafely polls the specified number of values from a subscription.
+ *
+ * @tsplus fluent fncts.internal.Hub.Subscription unsafePollN
+ */
+
+export function unsafePollN(subscription, max) {
+  return subscription.pollUpTo(max);
+}
+//# sourceMappingURL=Hub.mjs.map