WIP: flesh out Node interface, implement interface on classes

Author: jshcrowthe

src/database/core/snap/ChildrenNode.ts

@@ -5,7 +5,7 @@ import {
   MIN_NAME
 } from "../util/util";
 import { SortedMap } from "../util/SortedMap";
-import { NamedNode } from "./Node";
+import { Node, NamedNode } from "./Node";
 import { 
   validatePriorityNode, 
   priorityHashText,
@@ -30,7 +30,7 @@ let EMPTY_NODE;
  * @param {?Node} priorityNode The priority of this node (as a snapshot node).
  * @param {!IndexMap} indexMap
  */
-export class ChildrenNode {
+export class ChildrenNode implements Node {
   children_;
   priorityNode_;
   indexMap_;
@@ -491,7 +491,7 @@ export class MaxNode extends ChildrenNode {
 
 
   getImmediateChild(childName) {
-    ChildrenNode.EMPTY_NODE;
+    return ChildrenNode.EMPTY_NODE;
   };
 
 

src/database/core/snap/LeafNode.ts

@@ -8,14 +8,15 @@ import {
   validatePriorityNode
 } from "./snap";
 import { ChildrenNode } from "./ChildrenNode";
+import { Node } from "./Node";
 
 
 /**
  * LeafNode is a class for storing leaf nodes in a DataSnapshot.  It
  * implements Node and stores the value of the node (a string,
  * number, or boolean) accessible via getValue().
  */
-export class LeafNode {
+export class LeafNode implements Node {
   value_;
   priorityNode_;
   lazyHash_;
@@ -128,9 +129,7 @@ export class LeafNode {
       assert(front !== '.priority' || path.getLength() === 1,
           '.priority must be the last token in a path');
 
-      return this.updateImmediateChild(front,
-                                       ChildrenNode.EMPTY_NODE.updateChild(path.popFront(),
-                                                                           newChildNode));
+      return this.updateImmediateChild(front, ChildrenNode.EMPTY_NODE.updateChild(path.popFront(), newChildNode));
     }
   }
 

src/database/core/snap/MaxNode.ts

@@ -1,142 +1,142 @@
+import { Path } from "../util/path";
+import { Index } from "./indexes/Index";
+
 /**
  * Node is an interface defining the common functionality for nodes in
  * a DataSnapshot.
  *
  * @interface
  */
-export const Node = function() { };
-
-
-/**
- * Whether this node is a leaf node.
- * @return {boolean} Whether this is a leaf node.
- */
-Node.prototype.isLeafNode;
-
-
-/**
- * Gets the priority of the node.
- * @return {!Node} The priority of the node.
- */
-Node.prototype.getPriority;
+export interface Node {
+  /**
+   * Whether this node is a leaf node.
+   * @return {boolean} Whether this is a leaf node.
+   */
+  isLeafNode(): boolean;
 
 
-/**
- * Returns a duplicate node with the new priority.
- * @param {!Node} newPriorityNode New priority to set for the node.
- * @return {!Node} Node with new priority.
- */
-Node.prototype.updatePriority;
+  /**
+   * Gets the priority of the node.
+   * @return {!Node} The priority of the node.
+   */
+  getPriority(): Node;
 
 
-/**
- * Returns the specified immediate child, or null if it doesn't exist.
- * @param {string} childName The name of the child to retrieve.
- * @return {!Node} The retrieved child, or an empty node.
- */
-Node.prototype.getImmediateChild;
+  /**
+   * Returns a duplicate node with the new priority.
+   * @param {!Node} newPriorityNode New priority to set for the node.
+   * @return {!Node} Node with new priority.
+   */
+  updatePriority(newPriorityNode: Node): Node;
 
 
-/**
- * Returns a child by path, or null if it doesn't exist.
- * @param {!fb.core.util.Path} path The path of the child to retrieve.
- * @return {!Node} The retrieved child or an empty node.
- */
-Node.prototype.getChild;
+  /**
+   * Returns the specified immediate child, or null if it doesn't exist.
+   * @param {string} childName The name of the child to retrieve.
+   * @return {!Node} The retrieved child, or an empty node.
+   */
+  getImmediateChild(childName: string): Node;
 
 
-/**
- * Returns the name of the child immediately prior to the specified childNode, or null.
- * @param {!string} childName The name of the child to find the predecessor of.
- * @param {!Node} childNode The node to find the predecessor of.
- * @param {!fb.core.snap.Index} index The index to use to determine the predecessor
- * @return {?string} The name of the predecessor child, or null if childNode is the first child.
- */
-Node.prototype.getPredecessorChildName;
+  /**
+   * Returns a child by path, or null if it doesn't exist.
+   * @param {!Path} path The path of the child to retrieve.
+   * @return {!Node} The retrieved child or an empty node.
+   */
+  getChild(path: Path): Node;
 
-/**
- * Returns a duplicate node, with the specified immediate child updated.
- * Any value in the node will be removed.
- * @param {string} childName The name of the child to update.
- * @param {!Node} newChildNode The new child node
- * @return {!Node} The updated node.
- */
-Node.prototype.updateImmediateChild;
 
+  /**
+   * Returns the name of the child immediately prior to the specified childNode, or null.
+   * @param {!string} childName The name of the child to find the predecessor of.
+   * @param {!Node} childNode The node to find the predecessor of.
+   * @param {!Index} index The index to use to determine the predecessor
+   * @return {?string} The name of the predecessor child, or null if childNode is the first child.
+   */
+  getPredecessorChildName(childName: String, childNode: Node, index: Index): string;
 
-/**
- * Returns a duplicate node, with the specified child updated.  Any value will
- * be removed.
- * @param {!fb.core.util.Path} path The path of the child to update.
- * @param {!Node} newChildNode The new child node, which may be an empty node
- * @return {!Node} The updated node.
- */
-Node.prototype.updateChild;
+  /**
+   * Returns a duplicate node, with the specified immediate child updated.
+   * Any value in the node will be removed.
+   * @param {string} childName The name of the child to update.
+   * @param {!Node} newChildNode The new child node
+   * @return {!Node} The updated node.
+   */
+  updateImmediateChild(childName: string, newChildNode: Node): Node;
 
-/**
- * True if the immediate child specified exists
- * @param {!string} childName
- * @return {boolean}
- */
-Node.prototype.hasChild;
 
-/**
- * @return {boolean} True if this node has no value or children.
- */
-Node.prototype.isEmpty;
+  /**
+   * Returns a duplicate node, with the specified child updated.  Any value will
+   * be removed.
+   * @param {!Path} path The path of the child to update.
+   * @param {!Node} newChildNode The new child node, which may be an empty node
+   * @return {!Node} The updated node.
+   */
+  updateChild(path: Path, newChildNode: Node): Node;
 
+  /**
+   * True if the immediate child specified exists
+   * @param {!string} childName
+   * @return {boolean}
+   */
+  hasChild(childName: string): boolean;
 
-/**
- * @return {number} The number of children of this node.
- */
-Node.prototype.numChildren;
+  /**
+   * @return {boolean} True if this node has no value or children.
+   */
+  isEmpty(): boolean;
 
 
-/**
- * Calls action for each child.
- * @param {!fb.core.snap.Index} index
- * @param {function(string, !Node)} action Action to be called for
- * each child.  It's passed the child name and the child node.
- * @return {*} The first truthy value return by action, or the last falsey one
- */
-Node.prototype.forEachChild;
+  /**
+   * @return {number} The number of children of this node.
+   */
+  numChildren(): number;
 
 
-/**
- * @param {boolean=} opt_exportFormat True for export format (also wire protocol format).
- * @return {*} Value of this node as JSON.
- */
-Node.prototype.val;
+  /**
+   * Calls action for each child.
+   * @param {!Index} index
+   * @param {function(string, !Node)} action Action to be called for
+   * each child.  It's passed the child name and the child node.
+   * @return {*} The first truthy value return by action, or the last falsey one
+   */
+  forEachChild(index: Index, action: (string, node) => any): any;
 
+  /**
+   * @param {boolean=} opt_exportFormat True for export format (also wire protocol format).
+   * @return {*} Value of this node as JSON.
+   */
+  val(exportFormat?: boolean): Object;
 
-/**
- * @return {string} hash representing the node contents.
- */
-Node.prototype.hash;
+  /**
+   * @return {string} hash representing the node contents.
+   */
+  hash(): string;
 
-/**
- * @param {!Node} other Another node
- * @return {!number} -1 for less than, 0 for equal, 1 for greater than other
- */
-Node.prototype.compareTo;
+  /**
+   * @param {!Node} other Another node
+   * @return {!number} -1 for less than, 0 for equal, 1 for greater than other
+   */
+  compareTo(other: Node): number;
 
-/**
- * @param {!Node} other
- * @return {boolean} Whether or not this snapshot equals other
- */
-Node.prototype.equals;
+  /**
+   * @param {!Node} other
+   * @return {boolean} Whether or not this snapshot equals other
+   */
+  equals(other: Node): boolean;
 
-/**
- * @param {!fb.core.snap.Index} indexDefinition
- * @return {!Node} This node, with the specified index now available
- */
-Node.prototype.withIndex;
+  /**
+   * @param {!Index} indexDefinition
+   * @return {!Node} This node, with the specified index now available
+   */
+  withIndex(indexDefinition: Index): Node;
 
-/**
- * @param {!fb.core.snap.Index} indexDefinition
- * @return {boolean}
- */
-Node.prototype.isIndexed;
+  /**
+   * @param {!Index} indexDefinition
+   * @return {boolean}
+   */
+  isIndexed(indexDefinition: Index): boolean;
+}
 
 /**
  *
@@ -146,8 +146,7 @@ Node.prototype.isIndexed;
  * @struct
  */
 export class NamedNode {
-  name;
-  node;
+  constructor(public name: string, public node: Node) {}
 
   /**
    *
@@ -158,10 +157,5 @@ export class NamedNode {
   static Wrap(name: string, node: Node) {
     return new NamedNode(name, node);
   }
-  
-  constructor(name, node) {
-    this.name = name;
-    this.node = node;
-  }
 }