list-toolkit 1.0.2 → 2.1.0

package/src/slist/ext.js

@@ -0,0 +1,331 @@
+'use strict';
+
+import {ExtListBase, PtrBase} from './nodes.js';
+import {pop, extract, splice} from './basics.js';
+import {addAliases, normalizeIterator} from '../meta-utils.js';
+
+export class Ptr extends PtrBase {
+  constructor(list, node, prev) {
+    super(list, node, prev, ExtSList);
+  }
+  clone() {
+    return new Ptr(this);
+  }
+}
+
+export class ExtSList extends ExtListBase {
+  get ptrRange() {
+    return this.head ? {from: this.makePtr(), to: this.head, list: this.head} : null;
+  }
+
+  makePtr(node) {
+    if (node && !this.isNodeLike(node)) throw new Error('"node" is not a compatible node');
+    return new Ptr(this, node);
+  }
+
+  makePtrFromPrev(prev) {
+    if (prev && !this.isNodeLike(prev)) throw new Error('"prev" is not a compatible node');
+    return new Ptr(this, null, prev || this.head);
+  }
+
+  // Ptr API
+
+  removeNodeAfter() {
+    return this.head ? this.removeNode(this.makePtr()) : null;
+  }
+
+  addAfter(value) {
+    const node = this.adoptValue(value);
+    if (this.head) {
+      splice(this, this.head, {prevFrom: node});
+    } else {
+      this.head = node;
+    }
+    return this.makePtr();
+  }
+
+  addNodeAfter(node) {
+    node = this.adoptNode(node);
+    if (this.head) {
+      splice(this, this.head, {prevFrom: node});
+    } else {
+      this.head = node;
+    }
+    return this.makePtr();
+  }
+
+  insertAfter(extList) {
+    if (!this.isCompatible(extList)) throw new Error('Incompatible lists');
+
+    const head = extList.head;
+    if (head) {
+      splice(this, this.head, {prevFrom: head, to: head});
+      extList.head = null;
+    }
+
+    return this.makePtr();
+  }
+
+  moveAfter(ptr) {
+    if (!this.isCompatiblePtr(ptr)) throw new Error('Incompatible pointer');
+    ptr.list = this;
+
+    if (!this.head) {
+      this.head = pop(this, ptr.prevNode).extracted.to;
+      return this;
+    }
+
+    if (this.head === ptr.prevNode) return this;
+
+    if (this.head === ptr.prevNode[this.nextName]) {
+      if (this.head === this.head[this.nextName]) return this;
+      this.head = this.head[this.nextName];
+    }
+
+    ptr.prevNode = splice(this, this.head, {prevFrom: pop(this, ptr.prevNode).extracted.to});
+
+    return ptr.clone();
+  }
+
+  // List API
+
+  clear(drop) {
+    if (drop) {
+      for (const current of this.getNodeIterator()) {
+        current[this.nextName] = current; // make stand-alone
+      }
+    }
+    this.head = null;
+    return this;
+  }
+
+  removeNode(ptr) {
+    if (!this.head) return null;
+    if (!this.isCompatiblePtr(ptr)) throw new Error('Incompatible pointer');
+    if (this.head === ptr.prevNode[this.nextName]) {
+      if (this.head === this.head[this.nextName]) {
+        this.head = null;
+        return ptr.prevNode[this.nextName];
+      }
+      this.head = this.head[this.nextName];
+    }
+    return pop(this, ptr.prevNode).extracted.to;
+  }
+
+  removeRange(ptrRange, drop) {
+    return this.extractRange(ptrRange).clear(drop);
+  }
+
+  extractRange(ptrRange = {}) {
+    ptrRange = this.normalizePtrRange(ptrRange.from ? ptrRange : {...ptrRange, from: this.makePtr()});
+    ptrRange.to ||= this.head;
+
+    const prevFrom = ptrRange.from.prevNode,
+      to = ptrRange.to,
+      extracted = this.make();
+    if (!this.head) return extracted;
+    if (this.head === prevFrom[this.nextName] || this.head === to) this.head = to[this.nextName];
+    if (this.head === prevFrom[this.nextName]) this.head = null;
+    extracted.head = extract(this, {prevFrom, to}).extracted.prevFrom[this.nextName];
+
+    return extracted;
+  }
+
+  extractBy(condition) {
+    const extracted = this.make();
+    if (this.isEmpty) return extracted;
+
+    const rest = this.make();
+    for (const current of this.getNodeIterator()) {
+      current[this.nextName] = current; // make stand-alone
+      if (condition(current)) {
+        extracted.addAfter(current);
+        extracted.next();
+      } else {
+        rest.addAfter(current);
+        rest.next();
+      }
+    }
+    extracted.next();
+    rest.next();
+
+    this.head = rest.head;
+
+    return extracted;
+  }
+
+  reverse() {
+    if (this.isOneOrEmpty) return this;
+
+    let prev = this.head,
+      current = prev[this.nextName];
+    do {
+      const next = current[this.nextName];
+      current[this.nextName] = prev;
+      prev = current;
+      current = next;
+    } while (current !== this.head);
+    this.head[this.nextName] = prev;
+
+    this.head = this.head[this.nextName];
+
+    return this;
+  }
+
+  sort(lessFn) {
+    if (this.isOneOrEmpty) return this;
+
+    const leftHead = {},
+      rightHead = {};
+    leftHead[this.nextName] = leftHead;
+    rightHead[this.nextName] = rightHead;
+
+    const left = this.make(leftHead),
+      right = this.make(rightHead);
+
+    // split into two sublists
+    let isLeft = true;
+    for (const current of this.getNodeIterator()) {
+      current[this.nextName] = current; // make stand-alone
+      if (isLeft) {
+        left.addNodeAfter(current);
+        left.next();
+      } else {
+        right.addNodeAfter(current);
+        right.next();
+      }
+      isLeft = !isLeft;
+    }
+    left.removeNodeAfter(); // remove the head node
+    right.removeNodeAfter(); // remove the head node
+    this.clear();
+    // the list is empty now
+
+    // sort sublists
+    left.next().sort(lessFn);
+    right.next().sort(lessFn);
+
+    // merge sublists
+    const leftIterator = left.getNodeIterator()[Symbol.iterator](),
+      rightIterator = right.getNodeIterator()[Symbol.iterator]();
+    let leftItem = leftIterator.next(),
+      rightItem = rightIterator.next();
+    while (!leftItem.done && !rightItem.done) {
+      let node;
+      if (lessFn(leftItem.value, rightItem.value)) {
+        node = leftItem.value;
+        leftItem = leftIterator.next();
+      } else {
+        node = rightItem.value;
+        rightItem = rightIterator.next();
+      }
+      node[this.nextName] = node; // make stand-alone
+      this.addNodeAfter(node);
+      this.next();
+    }
+    for (; !leftItem.done; this.next(), leftItem = leftIterator.next()) {
+      const node = leftItem.value;
+      node[this.nextName] = node; // make stand-alone
+      this.addNodeAfter(node);
+    }
+    for (; !rightItem.done; this.next(), rightItem = rightIterator.next()) {
+      const node = rightItem.value;
+      node[this.nextName] = node; // make stand-alone
+      this.addNodeAfter(node);
+    }
+
+    return this.next();
+  }
+
+  // iterators
+
+  [Symbol.iterator]() {
+    let current = this.head,
+      readyToStop = this.isEmpty;
+    return normalizeIterator({
+      next: () => {
+        if (readyToStop && current === this.head) return {done: true};
+        readyToStop = true;
+        const value = current;
+        current = current[this.nextName];
+        return {value};
+      }
+    });
+  }
+
+  getNodeIterator(range = {}) {
+    range = this.normalizeRange(range);
+    const {from, to} = range;
+    return {
+      [Symbol.iterator]: () => {
+        let readyToStop = this.isEmpty,
+          current = readyToStop ? null : from || this.head;
+        const stop = readyToStop ? null : to ? to[this.nextName] : this.head;
+        return normalizeIterator({
+          next: () => {
+            if (readyToStop && current === stop) return {done: true};
+            readyToStop = true;
+            const value = current;
+            current = current[this.nextName];
+            return {value};
+          }
+        });
+      }
+    };
+  }
+
+  getPtrIterator(range) {
+    if (!ptrRange.from) ptrRange = Object.assign({from: this.frontPtr}, ptrRange);
+    ptrRange = this.normalizePtrRange(ptrRange);
+    const {from: fromPtr, to} = ptrRange;
+    return {
+      [Symbol.iterator]: () => {
+        let current = fromPtr.clone(),
+          readyToStop = this.isEmpty;
+        const stop = to ? to[this.nextName] : this;
+        return normalizeIterator({
+          next: () => {
+            if (readyToStop && current.node === stop) return {done: true};
+            readyToStop = true;
+            const value = current.clone();
+            current = current.next();
+            return {value};
+          }
+        });
+      }
+    };
+  }
+
+  // meta helpers
+
+  clone() {
+    return new ExtSList(this);
+  }
+
+  make(head = null) {
+    return new ExtSList(head, this);
+  }
+
+  makeFrom(values) {
+    return ExtSList.from(values, this);
+  }
+
+  static from(values, options) {
+    const list = new ExtSList(null, options);
+    for (const value of values) {
+      list.addNodeAfter(value);
+      list.next();
+    }
+    return list.next();
+  }
+}
+
+ExtSList.Ptr = Ptr;
+
+addAliases(ExtSList.prototype, {
+  addAfter: 'add',
+  removeNodeAfter: 'removeAfter',
+  getNodeIterator: 'getIterator'
+});
+
+export default ExtSList;

package/src/slist/nodes.js

@@ -0,0 +1,290 @@
+'use strict';
+
+import {isRangeLike, normalizeNode, normalizeRange, normalizePtrRange} from '../list-helpers.js';
+import {addAlias, copyDescriptors} from '../meta-utils.js';
+
+export const isNodeLike = ({nextName}, node) => node && node[nextName];
+export const isStandAlone = ({nextName}, node) => node && node[nextName] === node;
+export const isCompatible = (options1, options2) => options1.nextName === options2.nextName;
+
+export class Node {
+  constructor({nextName = 'next'} = {}) {
+    this.nextName = nextName;
+    this[nextName] = this;
+  }
+  get isStandAlone() {
+    return this[this.nextName] === this;
+  }
+}
+
+export class HeadNode extends Node {
+  constructor(options) {
+    super(options);
+    this.last = this;
+  }
+  isNodeLike(node) {
+    if (!node) return false;
+    const next = node[this.nextName];
+    return next && typeof next == 'object';
+  }
+  isCompatibleNames({nextName}) {
+    return this.nextName === nextName;
+  }
+  isCompatible(list) {
+    return list === this || (list instanceof HeadNode && this.nextName === list.nextName);
+  }
+  isCompatiblePtr(ptr) {
+    return ptr instanceof PtrBase && (ptr.list === this || (ptr.list instanceof HeadNode && this.nextName === ptr.list.nextName));
+  }
+  isCompatibleRange(range) {
+    return isRangeLike(this, range);
+  }
+
+  get isEmpty() {
+    return this[this.nextName] === this;
+  }
+
+  get isOne() {
+    return this[this.nextName] !== this && this[this.nextName][this.nextName] === this;
+  }
+
+  get isOneOrEmpty() {
+    return this[this.nextName][this.nextName] === this;
+  }
+
+  get head() {
+    return this;
+  }
+
+  get front() {
+    return this[this.nextName];
+  }
+
+  get back() {
+    return this.last;
+  }
+
+  get range() {
+    return this[this.nextName] === this ? null : {from: this[this.nextName], to: this.last, list: this};
+  }
+
+  getLength() {
+    let n = 0;
+    for (let p = this[this.nextName]; p !== this; ++n, p = p[this.nextName]);
+    return n;
+  }
+
+  adoptNode(nodeOrPtr) {
+    const isPtr = nodeOrPtr instanceof PtrBase;
+    if (isPtr && !this.isCompatiblePtr(nodeOrPtr)) throw new Error('Incompatible pointer');
+    const node = isPtr ? nodeOrPtr.node : nodeOrPtr;
+    if (node[this.nextName]) {
+      if (node[this.nextName] === node) return node;
+      throw new Error('node is already a part of a list, or there is a name clash');
+    }
+    node[this.nextName] = node;
+    if (isPtr) {
+      nodeOrPtr.list = this;
+      nodeOrPtr.prevNode = node;
+    }
+    return node;
+  }
+
+  normalizeNode(nodeOrPtr) {
+    const node = normalizeNode(this, nodeOrPtr, PtrBase);
+    if (nodeOrPtr instanceof PtrBase) nodeOrPtr.list = this;
+    return node;
+  }
+
+  normalizeRange(range) {
+    return normalizeRange(this, range, PtrBase);
+  }
+
+  normalizePtrRange(range) {
+    return normalizePtrRange(this, range, PtrBase);
+  }
+
+  syncLast() {
+    this.last = this;
+    while (this.last[this.nextName] !== this) this.last = this.last[this.nextName];
+    return this;
+  }
+}
+
+addAlias(HeadNode.prototype, 'adoptNode', 'adoptValue');
+
+export class ValueNode extends Node {
+  constructor(value, options) {
+    super(options);
+    this.value = value;
+  }
+}
+
+export class PtrBase {
+  constructor(list, node, prev, ListClass) {
+    if (list instanceof PtrBase) {
+      this.list = list.list;
+      this.node = list.node;
+      this.prevNode = list.prevNode;
+      return;
+    }
+    if (!(list instanceof ListClass)) throw new Error('"list" is not a compatible list');
+    if (node instanceof PtrBase) {
+      if (list !== node.list) throw new Error('Node specified by a pointer must belong to the same list');
+      this.list = list;
+      this.node = node.node;
+      this.prevNode = node.prevNode;
+    } else {
+      this.list = list;
+      this.node = node;
+      this.prevNode = prev;
+    }
+    // check nodes
+    if (this.node && !isNodeLike(this.list, this.node)) throw new Error('"node" is not a compatible node');
+    if (this.prevNode && !isNodeLike(this.list, this.prevNode)) throw new Error('"prev" is not a compatible node');
+    // initialize missing nodes
+    if (this.node) {
+      if (!this.prevNode) this.prevNode = this.node;
+    } else {
+      if (!this.prevNode) this.prevNode = this.list.head;
+      if (this.prevNode) this.node = this.prevNode[this.list.nextName];
+    }
+  }
+  get nextNode() {
+    return this.node[this.list.nextName];
+  }
+  isPrevNodeValid() {
+    if (!this.prevNode) this.prevNode = this.node;
+    if (this.prevNode[this.list.nextName] === this.node) return true;
+    this.prevNode = this.node;
+    if (this.prevNode[this.list.nextName] === this.node) return true;
+    this.prevNode = this.prevNode[this.list.nextName];
+    if (this.prevNode[this.list.nextName] === this.node) return true;
+    this.prevNode = this.list.head;
+    if (this.prevNode[this.list.nextName] === this.node) return true;
+    this.prevNode = this.node;
+    return false;
+  }
+  next() {
+    this.prevNode = this.node;
+    this.node = this.node[this.list.nextName];
+    return this;
+  }
+  prev() {
+    if (!this.isPrevNodeValid()) throw new Error('Cannot get previous node: "prevNode" is invalid');
+    this.node = this.prevNode;
+    return this;
+  }
+  syncPrev() {
+    if (this.isPrevNodeValid()) return this;
+    this.prevNode = this.node;
+    do {
+      const next = this.prevNode[this.list.nextName];
+      if (next === this.node) break;
+      this.prevNode = next;
+    } while (this.prevNode !== this.node);
+    return this;
+  }
+}
+
+export class ExtListBase {
+  constructor(head = null, {nextName = 'next'} = {}) {
+    if (head instanceof ExtListBase) {
+      this.nextName = head.nextName;
+      this.attach(head.head);
+      return;
+    }
+    if (head instanceof PtrBase) {
+      this.nextName = head.list.nextName;
+      this.attach(head.node);
+      return;
+    }
+    this.nextName = nextName;
+    this.attach(head);
+  }
+
+  isCompatible(list) {
+    return list === this || (list instanceof ExtListBase && this.nextName === list.nextName);
+  }
+
+  isCompatiblePtr(ptr) {
+    return ptr instanceof PtrBase && (ptr.list === this || (ptr.list instanceof ExtListBase && this.nextName === ptr.list.nextName));
+  }
+
+  get isEmpty() {
+    return !this.head;
+  }
+
+  get isOne() {
+    return this.head && this.head[this.nextName] === this.head;
+  }
+
+  get isOneOrEmpty() {
+    return !this.head || this.head[this.nextName] === this.head;
+  }
+
+  get front() {
+    return this.head;
+  }
+
+  get range() {
+    return this.head ? {from: this.head[this.nextName], to: this.head, list: this.head} : null;
+  }
+
+  getLength() {
+    if (!this.head) return 0;
+
+    let n = 0,
+      current = this.head;
+    do {
+      current = current[this.nextName];
+      ++n;
+    } while (current !== this.head);
+
+    return n;
+  }
+
+  getBack() {
+    if (!this.head) return null;
+    for (let current = this.head; ; ) {
+      const next = current[this.nextName];
+      if (next === this.head) return current;
+      current = next;
+    }
+    // unreachable
+  }
+
+  attach(head = null) {
+    const oldHead = this.head;
+    if (head instanceof PtrBase) {
+      if (!this.isCompatible(head.list)) throw new Error('Incompatible lists');
+      this.head = head.node;
+    } else {
+      if (head && !this.isNodeLike(head)) throw new Error('"head" is not a compatible node');
+      this.head = head;
+    }
+    return oldHead;
+  }
+
+  detach() {
+    const oldHead = this.head;
+    this.head = null;
+    return oldHead;
+  }
+
+  next() {
+    if (this.head) this.head = this.head[this.nextName];
+    return this;
+  }
+}
+
+copyDescriptors(ExtListBase.prototype, HeadNode.prototype, [
+  'isNodeLike',
+  'isCompatibleNames',
+  'isCompatibleRange',
+  'normalizeNode',
+  'normalizeRange',
+  'normalizePtrRange',
+  'adoptNode',
+  'adoptValue'
+]);

package/src/slist/ptr.js

@@ -0,0 +1,77 @@
+'use strict';
+
+import {HeadNode, PtrBase} from './nodes.js';
+import {pop, splice} from './basics.js';
+
+export class Ptr extends PtrBase {
+  constructor(list, node, prev) {
+    super(list, node, prev, HeadNode);
+  }
+
+  get isHead() {
+    return this.node === this.list;
+  }
+  clone() {
+    return new Ptr(this);
+  }
+  removeCurrent() {
+    if (!this.isPrevNodeValid()) throw new Error('Current node cannot be removed: "prevNode" is invalid');
+    if (this.node === this.list || this.node === this.prevNode) return null;
+    if (this.list.last === this.node) this.list.last = this.prevNode;
+    const node = pop(this.list, this.prevNode).extracted.to;
+    this.node = this.prevNode[this.list.nextName];
+    return node;
+  }
+  addBefore(value) {
+    if (!this.isPrevNodeValid()) throw new Error('Cannot be added before: "prevNode" is invalid');
+    const node = this.list.adoptValue(value),
+      prev = splice(this.list, this.prevNode, {prevFrom: node});
+    this.prevNode = node;
+    if (this.list.last === this.list) this.list.last = node;
+    return this.list.makePtr(prev);
+  }
+  addNodeBefore(node) {
+    if (!this.isPrevNodeValid()) throw new Error('Cannot be added before: "prevNode" is invalid');
+    node = this.list.adoptNode(node);
+    const prev = splice(this.list, this.prevNode, {prevFrom: node});
+    this.prevNode = node;
+    if (this.list.last === this.list) this.list.last = node;
+    return this.list.makePtr(prev);
+  }
+  addAfter(value) {
+    const node = this.list.adoptValue(value),
+      prev = splice(this.list, this.node, {prevFrom: node});
+    return this.list.makePtr(prev);
+  }
+  addNodeAfter(node) {
+    node = this.list.adoptNode(node);
+    const prev = splice(this.list, this.node, {prevFrom: node});
+    return this.list.makePtr(prev);
+  }
+  insertBefore(list) {
+    if (!this.isPrevNodeValid()) throw new Error('Cannot be inserted before: "prevNode" is invalid');
+    if (!this.list.isCompatible(list)) throw new Error('Incompatible lists');
+    if (list.isEmpty) return this;
+
+    const prev = splice(this.list, this.prevNode, {prevFrom: list, to: list.last});
+    if (this.list.last === this.list) this.list.last = list.last;
+    this.prevNode = list.last;
+
+    list.last = list;
+
+    return this.list.makePtr(prev);
+  }
+  insertAfter(list) {
+    if (!this.list.isCompatible(list)) throw new Error('Incompatible lists');
+    if (list.isEmpty) return this;
+
+    const prev = splice(this.list, this.prevNode[this.list.nextName], {prevFrom: list, to: list.last});
+    if (this.list.last === this.prevNode) this.list.last = list.last;
+
+    list.last = list;
+
+    return this.list.makePtr(prev);
+  }
+}
+
+export default Ptr;