nlptoolkit-annotatedtree 1.0.2 → 1.0.4

package/source/ParseNodeDrawable.ts

@@ -10,6 +10,14 @@ export class ParseNodeDrawable extends ParseNode{
     protected depth: number
     protected inOrderTraversalIndex: number
 
+    /**
+     * Constructs a ParseNodeDrawable from a single line. If the node is a leaf node, it only sets the data. Otherwise,
+     * splits the line w.r.t. spaces and parenthesis and calls itself recursively to generate its child parseNodes.
+     * @param parentOrLeftOrSymbol The parent node of this node.
+     * @param lineOrRightOrData The input line to create this parseNode.
+     * @param dataOrIsleaf True, if this node is a leaf node; false otherwise.
+     * @param depth Depth of the node.
+     */
     constructor(parentOrLeftOrSymbol?: any, lineOrRightOrData?: any, dataOrIsleaf?: any, depth?: number) {
         super();
         if (parentOrLeftOrSymbol == null || lineOrRightOrData != undefined){
@@ -66,10 +74,19 @@ export class ParseNodeDrawable extends ParseNode{
         }
     }
 
+    /**
+     * Accessor for layers attribute
+     * @return Layers attribute
+     */
     getLayerInfo(): LayerInfo{
         return this.layers
     }
 
+    /**
+     * Returns the data. Either the node is a leaf node, in which case English word layer is returned; or the node is
+     * a nonleaf node, in which case the node tag is returned.
+     * @return English word for leaf node, constituency tag for non-leaf node.
+     */
     getData(): Symbol{
         if (this.layers == null){
             return super.getData()
@@ -78,10 +95,17 @@ export class ParseNodeDrawable extends ParseNode{
         }
     }
 
+    /**
+     * Clears the layers hash map.
+     */
     clearLayers(){
         this.layers = new LayerInfo()
     }
 
+    /**
+     * Recursive method to clear a given layer.
+     * @param layerType Name of the layer to be cleared
+     */
     clearLayer(layerType: ViewLayerType){
         if (this.children.length == 0 && this.layerExists(layerType)){
             this.layers.removeLayer(layerType)
@@ -91,15 +115,27 @@ export class ParseNodeDrawable extends ParseNode{
         }
     }
 
+    /**
+     * Clears the node tag.
+     */
     clearData(){
         this.data = null
     }
 
+    /**
+     * Setter for the data attribute and also clears all layers.
+     * @param data New data field.
+     */
     setDataAndClearLayers(data: Symbol){
         super.setData(data)
         this.layers = null
     }
 
+    /**
+     * Mutator for the data field. If the layers is null, its sets the data field, otherwise it sets the English layer
+     * to the given value.
+     * @param data Data to be set.
+     */
     setData(data: Symbol) {
         if (this.layers == null){
             super.setData(data);
@@ -108,6 +144,11 @@ export class ParseNodeDrawable extends ParseNode{
         }
     }
 
+    /**
+     * Returns the layer value of the head child of this node.
+     * @param viewLayerType Layer name
+     * @return Layer value of the head child of this node.
+     */
     headWord(viewLayerType: ViewLayerType): string{
         if (this.children.length > 0){
             return (<ParseNodeDrawable> this.headChild()).headWord(viewLayerType);
@@ -116,6 +157,11 @@ export class ParseNodeDrawable extends ParseNode{
         }
     }
 
+    /**
+     * Returns the layer value of a given layer.
+     * @param viewLayer Layer name
+     * @return Value of the given layer
+     */
     getLayerData(viewLayer?: ViewLayerType): string{
         if (viewLayer == undefined){
             if (this.data != null){
@@ -130,16 +176,29 @@ export class ParseNodeDrawable extends ParseNode{
         }
     }
 
+    /**
+     * Accessor for the depth attribute
+     * @return Depth attribute
+     */
     getDepth(): number{
         return this.depth
     }
 
+    /**
+     * Replaces a given old child with the given new child.
+     * @param oldChild Old child to be replaced
+     * @param newChild New child which replaces old child
+     */
     replaceChild(oldChild: ParseNodeDrawable, newChild: ParseNodeDrawable){
         newChild.updateDepths(this.depth + 1);
         newChild.parent = this;
         this.children[this.children.indexOf(oldChild)] = newChild;
     }
 
+    /**
+     * Recursive method which updates the depth attribute
+     * @param depth Current depth to set.
+     */
     updateDepths(depth: number){
         this.depth = depth;
         for (let aChildren of this.children){
@@ -148,6 +207,10 @@ export class ParseNodeDrawable extends ParseNode{
         }
     }
 
+    /**
+     * Calculates the maximum depth of the subtree rooted from this node.
+     * @return The maximum depth of the subtree rooted from this node.
+     */
     maxDepth(): number{
         let depth = this.depth;
         for (let aChildren of this.children) {
@@ -158,6 +221,13 @@ export class ParseNodeDrawable extends ParseNode{
         return depth;
     }
 
+    /**
+     * Recursive method that checks if all nodes in the subtree rooted with this node has the annotation in the given
+     * layer.
+     * @param viewLayerType Layer name
+     * @return True if all nodes in the subtree rooted with this node has the annotation in the given layer, false
+     * otherwise.
+     */
     layerExists(viewLayerType: ViewLayerType): boolean{
         if (this.children.length == 0){
             if (this.getLayerData(viewLayerType) != null){
@@ -173,6 +243,11 @@ export class ParseNodeDrawable extends ParseNode{
         return false;
     }
 
+    /**
+     * Checks if the current node is a dummy node or not. A node is a dummy node if its data contains '*', or its
+     * data is '0' and its parent is '-NONE-'.
+     * @return True if the current node is a dummy node, false otherwise.
+     */
     isDummyNode(): boolean {
         let data = this.getLayerData(ViewLayerType.ENGLISH_WORD);
         let parentData = (<ParseNodeDrawable> this.parent).getLayerData(ViewLayerType.ENGLISH_WORD);
@@ -187,6 +262,12 @@ export class ParseNodeDrawable extends ParseNode{
         }
     }
 
+    /**
+     * Checks if all nodes in the subtree rooted with this node has annotation with the given layer.
+     * @param viewLayerType Layer name
+     * @return True if all nodes in the subtree rooted with this node has annotation with the given layer, false
+     * otherwise.
+     */
     layerAll(viewLayerType: ViewLayerType): boolean{
         if (this.children.length == 0){
             if (this.getLayerData(viewLayerType) == null && !this.isDummyNode()){
@@ -202,6 +283,11 @@ export class ParseNodeDrawable extends ParseNode{
         return true;
     }
 
+    /**
+     * Recursive method to convert the subtree rooted with this node to a string. All parenthesis types are converted to
+     * their regular forms.
+     * @return String version of the subtree rooted with this node.
+     */
     toTurkishSentence(): string{
         if (this.children.length == 0){
             if (this.getLayerData(ViewLayerType.TURKISH_WORD) != null && this.getLayerData(ViewLayerType.TURKISH_WORD) != "*NONE*"){
@@ -230,6 +316,12 @@ export class ParseNodeDrawable extends ParseNode{
         }
     }
 
+    /**
+     * Sets the NER layer according to the tag of the parent node and the word in the node. The word is searched in the
+     * gazetteer, if it exists, the NER info is replaced with the NER tag in the gazetter.
+     * @param gazetteer Gazetteer where we search the word
+     * @param word Word to be searched in the gazetteer
+     */
     checkGazetteer(gazetteer: Gazetteer, word: string){
         if (gazetteer.contains(word) && this.getParent().getData().getName() == "NNP"){
             this.getLayerInfo().setLayerData(ViewLayerType.NER, gazetteer.getName());
@@ -239,6 +331,12 @@ export class ParseNodeDrawable extends ParseNode{
         }
     }
 
+    /**
+     * Recursive method that sets the tag information of the given parse node with all descendants with respect to the
+     * morphological annotation of the current node with all descendants.
+     * @param parseNode Parse node whose tag information will be changed.
+     * @param surfaceForm If true, tag will be replaced with the surface form annotation.
+     */
     generateParseNode(parseNode: ParseNode, surfaceForm: boolean){
         if (this.numberOfChildren() == 0){
             if (surfaceForm){
@@ -256,6 +354,10 @@ export class ParseNodeDrawable extends ParseNode{
         }
     }
 
+    /**
+     * Recursive method to convert the subtree rooted with this node to a string.
+     * @return String version of the subtree rooted with this node.
+     */
     toString(): string{
         if (this.children.length < 2){
             if (this.children.length < 1){

package/source/ParseTreeDrawable.ts

@@ -15,54 +15,115 @@ export class ParseTreeDrawable extends ParseTree{
 
     private fileDescription: FileDescription
 
+    /**
+     * Another constructor for the ParseTreeDrawable. Sets the file description and reads the tree from the file
+     * description.
+     * @param fileDescription File description that contains the path, index and extension information.
+     */
+    constructor1(fileDescription: FileDescription){
+        this.fileDescription = fileDescription
+        this.readFromFile(fileDescription.getPath())
+    }
+
+    /**
+     * Another constructor for the ParseTreeDrawable. Sets the file description and reads the tree from the file
+     * description.
+     * @param path Path of the tree
+     */
+    constructor2(path: string){
+        this.readFromFile(path)
+    }
+
+    /**
+     * Another constructor for the ParseTreeDrawable. Sets the file description and reads the tree from the file
+     * description.
+     * @param path Path of the tree
+     * @param fileDescription File description that contains the path, index and extension information.
+     */
+    constructor3(path: string, fileDescription: FileDescription){
+        this.fileDescription = new FileDescription(path, fileDescription.getExtension(), fileDescription.getIndex())
+        this.readFromFile(this.fileDescription.getPath())
+    }
+
+    /**
+     * Constructor for the ParseTreeDrawable. Sets the file description and reads the tree from the file description.
+     * @param path Path of the tree
+     * @param rawFileName File name of the tree such as 0123.train.
+     */
+    constructor4(path: string, rawFileName: string){
+        this.fileDescription = new FileDescription(path, rawFileName)
+        this.readFromFile(this.fileDescription.getPath())
+    }
+
+    /**
+     * Another constructor for the ParseTreeDrawable. Sets the file description and reads the tree from the file
+     * description.
+     * @param path Path of the tree
+     * @param extension Extension of the file such as train, test or dev.
+     * @param index Index of the file such as 1235.
+     */
+    constructor5(path: string, extension: string, index: number){
+        this.fileDescription = new FileDescription(path, extension, index)
+        this.readFromFile(this.fileDescription.getPath())
+    }
+
     constructor(fileDescriptionOrPath?: any, fileDescriptionOrFileName?: any, index?: number) {
         super();
         if (fileDescriptionOrPath instanceof FileDescription){
-            this.fileDescription = fileDescriptionOrPath
-            this.readFromFile(fileDescriptionOrPath.getPath())
+            this.constructor1(fileDescriptionOrPath)
         } else {
             if (fileDescriptionOrFileName == undefined){
-                let path: string = fileDescriptionOrPath
-                this.readFromFile(path)
+                this.constructor2(fileDescriptionOrPath)
             } else {
                 if (fileDescriptionOrFileName instanceof FileDescription){
-                    let path: string = fileDescriptionOrPath
-                    let fileDescription: FileDescription = fileDescriptionOrFileName
-                    this.fileDescription = new FileDescription(path, fileDescription.getExtension(), fileDescription.getIndex())
-                    this.readFromFile(this.fileDescription.getPath())
+                    this.constructor3(fileDescriptionOrPath, fileDescriptionOrFileName)
                 } else {
                     if (index == undefined){
-                        let path: string = fileDescriptionOrPath
-                        let rawFileName: string = fileDescriptionOrFileName
-                        this.fileDescription = new FileDescription(path, rawFileName)
-                        this.readFromFile(this.fileDescription.getPath())
+                        this.constructor4(fileDescriptionOrPath, fileDescriptionOrFileName)
                     } else {
-                        let path: string = fileDescriptionOrPath
-                        let extension:  string = fileDescriptionOrFileName
-                        this.fileDescription = new FileDescription(path, extension, index)
-                        this.readFromFile(this.fileDescription.getPath())
+                        this.constructor5(fileDescriptionOrPath, fileDescriptionOrFileName, index)
                     }
                 }
             }
         }
     }
 
+    /**
+     * Mutator method for the fileDescription attribute.
+     * @param fileDescription New fileDescription value.
+     */
     setFileDescription(fileDescription: FileDescription){
         this.fileDescription = fileDescription
     }
 
+    /**
+     * Accessor method for the fileDescription attribute.
+     * @return FileDescription attribute.
+     */
     getFileDescription(){
         return this.fileDescription
     }
 
+    /**
+     * Reloads the tree from the input file.
+     */
     reload(){
         this.readFromFile(this.fileDescription.getPath());
     }
 
+    /**
+     * Mutator for the root attribute.
+     * @param newRootNode New root node.
+     */
     setRoot(newRootNode: ParseNode){
         this.root = newRootNode
     }
 
+    /**
+     * Reads the parse tree from the given file description with path replaced with the currentPath. It sets the root
+     * node which calls ParseNodeDrawable constructor recursively.
+     * @param currentPath Path of the tree
+     */
     readFromFile(currentPath: string) {
         let data = fs.readFileSync(currentPath, 'utf8')
         let line = data.split("\n")[0]
@@ -72,6 +133,12 @@ export class ParseTreeDrawable extends ParseTree{
         }
     }
 
+    /**
+     * Loads the next tree according to the index of the parse tree. For example, if the current
+     * tree fileName is 0123.train, after the call of nextTree(3), the method will load 0126.train. If the next tree
+     * does not exist, nothing will happen.
+     * @param count Number of trees to go forward
+     */
     nextTree(count: number){
         if (this.fileDescription.nextFileExists(count)){
             this.fileDescription.addToIndex(count);
@@ -79,6 +146,12 @@ export class ParseTreeDrawable extends ParseTree{
         }
     }
 
+    /**
+     * Loads the previous tree according to the index of the parse tree. For example, if the current
+     * tree fileName is 0123.train, after the call of previousTree(4), the method will load 0119.train. If the
+     * previous tree does not exist, nothing will happen.
+     * @param count Number of trees to go backward
+     */
     previousTree(count: number){
         if (this.fileDescription.previousFileExists(count)){
             this.fileDescription.addToIndex(-count);
@@ -86,22 +159,42 @@ export class ParseTreeDrawable extends ParseTree{
         }
     }
 
+    /**
+     * Calculates the maximum depth of the tree.
+     * @return The maximum depth of the tree.
+     */
     maxDepth(): number{
         return (<ParseNodeDrawable> this.root).maxDepth()
     }
 
+    /**
+     * Swaps the given child node of this node with the previous sibling of that given node. If the given node is the
+     * leftmost child, it swaps with the last node.
+     * @param node Node to be swapped.
+     */
     moveLeft(node: ParseNode){
         if (this.root != node){
             this.root.moveLeft(node);
         }
     }
 
+    /**
+     * Swaps the given child node of this node with the next sibling of that given node. If the given node is the
+     * rightmost child, it swaps with the first node.
+     * @param node Node to be swapped.
+     */
     moveRight(node: ParseNode){
         if (this.root != node){
             this.root.moveRight(node);
         }
     }
 
+    /**
+     * Divides the given node into multiple parse nodes if it contains more than one word. The parent node will be
+     * the same for the new nodes, original node is deleted from the children, the pos tags of the new parse nodes will
+     * be determined according to their morphological parses.
+     * @param parseNode Parse node to be divided
+     */
     divideIntoWords(parseNode: ParseNodeDrawable) {
         let layers = parseNode.getLayerInfo().divideIntoWords();
         parseNode.getParent().removeChild(parseNode);
@@ -120,6 +213,12 @@ export class ParseTreeDrawable extends ParseTree{
         }
     }
 
+    /**
+     * Moves the subtree rooted at fromNode as a child to the node toNode at position childIndex.
+     * @param fromNode Subtree root node to be moved.
+     * @param toNode Node to which a new subtree will be added.
+     * @param childIndex New child index of the toNode.
+     */
     moveNode(fromNode: ParseNode, toNode: ParseNode, childIndex?: number){
         if (this.root != fromNode){
             let parent = fromNode.getParent();
@@ -129,6 +228,11 @@ export class ParseTreeDrawable extends ParseTree{
         }
     }
 
+    /**
+     * Removed the first child of the parent node and adds the given child node as a child to that node.
+     * @param parent Parent node.
+     * @param child New child node to be added.
+     */
     combineWords(parent: ParseNodeDrawable, child: ParseNodeDrawable){
         while (parent.numberOfChildren() > 0){
             parent.removeChild(parent.firstChild());
@@ -137,20 +241,39 @@ export class ParseTreeDrawable extends ParseTree{
         (<ParseNodeDrawable> this.root).updateDepths(0);
     }
 
+    /**
+     * The method checks if all nodes in the tree has the annotation in the given layer.
+     * @param viewLayerType Layer name
+     * @return True if all nodes in the tree has the annotation in the given layer, false otherwise.
+     */
     layerExists(viewLayerType: ViewLayerType): boolean{
         return (<ParseNodeDrawable>(this.root)).layerExists(viewLayerType);
     }
 
+    /**
+     * Checks if all nodes in the tree has annotation with the given layer.
+     * @param viewLayerType Layer name
+     * @return True if all nodes in the tree has annotation with the given layer, false otherwise.
+     */
     layerAll(viewLayerType: ViewLayerType): boolean{
         return (<ParseNodeDrawable>(this.root)).layerAll(viewLayerType);
     }
 
+    /**
+     * Clears the given layer for all nodes in the tree
+     * @param layerType Layer name
+     */
     clearLayer(layerType: ViewLayerType){
         if (this.root != null){
             (<ParseNodeDrawable>this.root).clearLayer(layerType);
         }
     }
 
+    /**
+     * Returns the leaf node that comes one after the given parse node according to the inorder traversal.
+     * @param parseNode Input parse node.
+     * @return The leaf node that comes one after the given parse node according to the inorder traversal.
+     */
     nextLeafNode(parseNode: ParseNodeDrawable): ParseNodeDrawable {
         let nodeDrawableCollector = new NodeDrawableCollector(<ParseNodeDrawable>this.root, new IsTurkishLeafNode());
         let leafList = nodeDrawableCollector.collect();
@@ -162,6 +285,11 @@ export class ParseTreeDrawable extends ParseTree{
         return null;
     }
 
+    /**
+     * Returns the leaf node that comes one before the given parse node according to the inorder traversal.
+     * @param parseNode Input parse node.
+     * @return The leaf node that comes one before the given parse node according to the inorder traversal.
+     */
     previousLeafNode(parseNode: ParseNodeDrawable): ParseNodeDrawable {
         let nodeDrawableCollector = new NodeDrawableCollector(<ParseNodeDrawable>this.root, new IsTurkishLeafNode());
         let leafList = nodeDrawableCollector.collect();
@@ -173,6 +301,12 @@ export class ParseTreeDrawable extends ParseTree{
         return null;
     }
 
+    /**
+     * Constructs an AnnotatedSentence object from the Turkish tree. Collects all leaf nodes, then for each leaf node
+     * converts layer info of all words at that node to AnnotatedWords. Layers are converted to the counterparts in the
+     * AnnotatedWord.
+     * @return AnnotatedSentence counterpart of the Turkish tree
+     */
     generateAnnotatedSentence(language?: string): AnnotatedSentence{
         if (language == undefined){
             let sentence = new AnnotatedSentence();
@@ -198,6 +332,14 @@ export class ParseTreeDrawable extends ParseTree{
         }
     }
 
+    /**
+     * Recursive method that generates a new parse tree by replacing the tag information of the all parse nodes (with all
+     * its descendants) with respect to the morphological annotation of all parse nodes (with all its descendants)
+     * of the current parse tree.
+     * @param surfaceForm If true, tag will be replaced with the surface form annotation.
+     * @return A new parse tree by replacing the tag information of the all parse nodes with respect to the
+     * morphological annotation of all parse nodes of the current parse tree.
+     */
     generateParseTree(surfaceForm: boolean): ParseTree{
         let rootNode = <ParseNodeDrawable> this.root
         let result = new ParseTree(new ParseNode(rootNode.getData()))

package/source/Processor/Condition/IsDoubleNode.ts

@@ -3,6 +3,12 @@ import {ParseNodeDrawable} from "../../ParseNodeDrawable";
 
 export class IsDoubleNode implements NodeDrawableCondition{
 
+    /**
+     * Checks if the parse node is a double node, i.e., it has one child and his child has one or more children; its
+     * tag equals to its child tag.
+     * @param parseNode Parse node to check
+     * @return True if the tag of the parse node is equal to the tag of its child node, false otherwise.
+     */
     satisfies(parseNode: ParseNodeDrawable): boolean {
         return parseNode.numberOfChildren() == 1
             && parseNode.getChild(0).numberOfChildren() >= 1

package/source/Processor/Condition/IsDoubleNodeWithDifferentTags.ts

@@ -3,6 +3,12 @@ import {ParseNodeDrawable} from "../../ParseNodeDrawable";
 
 export class IsDoubleNodeWithDifferentTags implements NodeDrawableCondition{
 
+    /**
+     * Checks if the parse node is a double node, i.e., it has one child and his child has one or more children; and its
+     * tag is not equal to its child tag.
+     * @param parseNode Parse node to check
+     * @return True if the tag of the parse node is not equal to the tag of its child node, false otherwise.
+     */
     satisfies(parseNode: ParseNodeDrawable): boolean {
         return parseNode.numberOfChildren() == 1
             && parseNode.getChild(0).numberOfChildren() >= 1

package/source/Processor/Condition/IsEnglishLeafNode.ts

@@ -4,6 +4,11 @@ import {IsNullElement} from "./IsNullElement";
 
 export class IsEnglishLeafNode extends IsLeafNode{
 
+    /**
+     * Checks if the parse node is a leaf node and contains a valid English word in its data.
+     * @param parseNode Parse node to check.
+     * @return True if the parse node is a leaf node and contains a valid English word in its data; false otherwise.
+     */
     satisfies(parseNode: ParseNodeDrawable): boolean {
         if (super.satisfies(parseNode)) {
             return !new IsNullElement().satisfies(parseNode);

package/source/Processor/Condition/IsLeafNode.ts

@@ -3,6 +3,11 @@ import {ParseNodeDrawable} from "../../ParseNodeDrawable";
 
 export class IsLeafNode implements NodeDrawableCondition{
 
+    /**
+     * Checks if the parse node is a leaf node, i.e., it has no child.
+     * @param parseNode Parse node to check.
+     * @return True if the parse node is a leaf node, false otherwise.
+     */
     satisfies(parseNode: ParseNodeDrawable): boolean {
         return parseNode.numberOfChildren() == 0;
     }

package/source/Processor/Condition/IsNodeWithPredicate.ts

@@ -4,10 +4,21 @@ import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
 
 export class IsNodeWithPredicate extends IsNodeWithSynSetId{
 
+    /**
+     * Stores the synset id to check.
+     * @param id Synset id to check
+     */
     constructor(id: string) {
         super(id);
     }
 
+    /**
+     * Checks if at least one of the semantic ids of the parse node is equal to the given id and also the node is
+     * annotated as PREDICATE with semantic role.
+     * @param parseNode Parse node to check.
+     * @return True if at least one of the semantic ids of the parse node is equal to the given id and also the node is
+     * annotated as PREDICATE with semantic role, false otherwise.
+     */
     satisfies(parseNode: ParseNodeDrawable): boolean {
         let layerInfo = parseNode.getLayerInfo();
         return super.satisfies(parseNode)

package/source/Processor/Condition/IsNodeWithSymbol.ts

@@ -5,10 +5,19 @@ export class IsNodeWithSymbol implements NodeDrawableCondition{
 
     private symbol: string
 
+    /**
+     * Stores the symbol to check.
+     * @param symbol Symbol to check
+     */
     constructor(symbol: string) {
         this.symbol = symbol
     }
 
+    /**
+     * Checks if the tag of the parse node is equal to the given symbol.
+     * @param parseNode Parse node to check.
+     * @return True if the tag of the parse node is equal to the given symbol, false otherwise.
+     */
     satisfies(parseNode: ParseNodeDrawable): boolean {
         if (parseNode.numberOfChildren() > 0){
             return parseNode.getData().toString() == this.symbol;

package/source/Processor/Condition/IsNodeWithSynSetId.ts

@@ -5,11 +5,20 @@ export class IsNodeWithSynSetId extends IsLeafNode{
 
     private id: string
 
+    /**
+     * Stores the synset id to check.
+     * @param id Synset id to check
+     */
     constructor(id: string) {
         super();
         this.id = id
     }
 
+    /**
+     * Checks if at least one of the semantic ids of the parse node is equal to the given id.
+     * @param parseNode Parse node to check.
+     * @return True if at least one of the semantic ids of the parse node is equal to the given id, false otherwise.
+     */
     satisfies(parseNode: ParseNodeDrawable): boolean {
         if (super.satisfies(parseNode)){
             let layerInfo = parseNode.getLayerInfo();

package/source/Processor/Condition/IsNoneNode.ts

@@ -11,6 +11,11 @@ export class IsNoneNode extends IsLeafNode{
         this.secondLanguage = secondLanguage
     }
 
+    /**
+     * Checks if the data of the parse node is '*NONE*'.
+     * @param parseNode Parse node to check.
+     * @return True if the data of the parse node is '*NONE*', false otherwise.
+     */
     satisfies(parseNode: ParseNodeDrawable): boolean {
         if (super.satisfies(parseNode)){
             let data = parseNode.getLayerData(this.secondLanguage);

package/source/Processor/Condition/IsNullElement.ts

@@ -4,6 +4,12 @@ import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
 
 export class IsNullElement extends IsLeafNode{
 
+    /**
+     * Checks if the parse node is a leaf node and its data is '*' and its parent's data is '-NONE-'.
+     * @param parseNode Parse node to check.
+     * @return True if the parse node is a leaf node and its data is '*' and its parent's data is '-NONE-', false
+     * otherwise.
+     */
     satisfies(parseNode: ParseNodeDrawable): boolean {
         if (super.satisfies(parseNode)){
             let data = parseNode.getLayerData(ViewLayerType.ENGLISH_WORD);