nlptoolkit-annotatedtree 1.0.2 → 1.0.4

package/source/Processor/Condition/IsNumber.ts

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

package/source/Processor/Condition/IsPredicateVerbNode.ts

@@ -4,10 +4,21 @@ import {ParseNodeDrawable} from "../../ParseNodeDrawable";
 
 export class IsPredicateVerbNode extends IsVerbNode{
 
+    /**
+     * Stores the wordnet for checking the pos tag of the synset.
+     * @param wordNet Wordnet used for checking the pos tag of the synset.
+     */
     constructor(wordNet: WordNet) {
         super(wordNet);
     }
 
+    /**
+     * Checks if the node is a leaf node and at least one of the semantic ids of the parse node belong to a verb synset,
+     * and the semantic role of the node is PREDICATE.
+     * @param parseNode Parse node to check.
+     * @return True if the node is a leaf node and at least one of the semantic ids of the parse node belong to a verb
+     *          synset and the semantic role of the node is PREDICATE, false otherwise.
+     */
     satisfies(parseNode: ParseNodeDrawable): boolean {
         let layerInfo = parseNode.getLayerInfo();
         return super.satisfies(parseNode)

package/source/Processor/Condition/IsProperNoun.ts

@@ -3,6 +3,11 @@ import {ParseNodeDrawable} from "../../ParseNodeDrawable";
 
 export class IsProperNoun extends IsLeafNode{
 
+    /**
+     * Checks if the node is a leaf node and its parent has the tag NNP or NNPS.
+     * @param parseNode Parse node to check.
+     * @return True if the node is a leaf node and its parent has the tag NNP or NNPS, false otherwise.
+     */
     satisfies(parseNode: ParseNodeDrawable): boolean {
         if (super.satisfies(parseNode)){
             let parentData = parseNode.getParent().getData().getName();

package/source/Processor/Condition/IsPunctuationNode.ts

@@ -5,6 +5,11 @@ import {Word} from "nlptoolkit-dictionary/dist/Dictionary/Word";
 
 export class IsPunctuationNode extends IsLeafNode{
 
+    /**
+     * Checks if the node is a leaf node and contains punctuation as the data.
+     * @param parseNode Parse node to check.
+     * @return True if the node is a leaf node and contains punctuation as the data, false otherwise.
+     */
     satisfies(parseNode: ParseNodeDrawable): boolean {
         if (super.satisfies(parseNode)){
             let data = parseNode.getLayerData(ViewLayerType.ENGLISH_WORD);

package/source/Processor/Condition/IsTransferable.ts

@@ -13,6 +13,11 @@ export class IsTransferable extends IsLeafNode{
         this.secondLanguage = secondLanguage
     }
 
+    /**
+     * Checks if the node is a leaf node and is not a None or Null node.
+     * @param parseNode Parse node to check.
+     * @return True if the node is a leaf node and is not a None or Null node, false otherwise.
+     */
     satisfies(parseNode: ParseNodeDrawable): boolean {
         if (super.satisfies(parseNode)) {
             if (new IsNoneNode(this.secondLanguage).satisfies(parseNode)){

package/source/Processor/Condition/IsTurkishLeafNode.ts

@@ -4,6 +4,11 @@ import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
 
 export class IsTurkishLeafNode extends IsLeafNode{
 
+    /**
+     * Checks if the parse node is a leaf node and contains a valid Turkish word in its data.
+     * @param parseNode Parse node to check.
+     * @return True if the parse node is a leaf node and contains a valid Turkish word in its data; false otherwise.
+     */
     satisfies(parseNode: ParseNodeDrawable): boolean {
         if (super.satisfies(parseNode)){
             let data = parseNode.getLayerInfo().getLayerData(ViewLayerType.TURKISH_WORD);

package/source/Processor/Condition/IsVPNode.ts

@@ -3,6 +3,11 @@ import {ParseNodeDrawable} from "../../ParseNodeDrawable";
 
 export class IsVPNode implements NodeDrawableCondition{
 
+    /**
+     * Checks if the node is not a leaf node and its tag is VP.
+     * @param parseNode Parse node to check.
+     * @return True if the node is not a leaf node and its tag is VP, false otherwise.
+     */
     satisfies(parseNode: ParseNodeDrawable): boolean {
         return parseNode.numberOfChildren() > 0 && parseNode.getData().isVP();
     }

package/source/Processor/Condition/IsVerbNode.ts

@@ -8,11 +8,21 @@ export class IsVerbNode extends IsLeafNode{
 
     private wordNet: WordNet
 
+    /**
+     * Stores the wordnet for checking the pos tag of the synset.
+     * @param wordNet Wordnet used for checking the pos tag of the synset.
+     */
     constructor(wordNet: WordNet) {
         super();
         this.wordNet = wordNet
     }
 
+    /**
+     * Checks if the node is a leaf node and at least one of the semantic ids of the parse node belong to a verb synset.
+     * @param parseNode Parse node to check.
+     * @return True if the node is a leaf node and at least one of the semantic ids of the parse node belong to a verb
+     * synset, false otherwise.
+     */
     satisfies(parseNode: ParseNodeDrawable): boolean {
         let layerInfo = parseNode.getLayerInfo();
         if (super.satisfies(parseNode) && layerInfo != null && layerInfo.getLayerData(ViewLayerType.SEMANTICS) != null){

package/source/Processor/LayerExist/ContainsLayerInformation.ts

@@ -7,10 +7,19 @@ export class ContainsLayerInformation implements LeafListCondition{
 
     private readonly viewLayerType: ViewLayerType
 
+    /**
+     * Constructor for ContainsLayerInformation class. Sets the viewLayerType attribute.
+     * @param viewLayerType Layer for which check is done.
+     */
     constructor(viewLayerType: ViewLayerType) {
         this.viewLayerType = viewLayerType
     }
 
+    /**
+     * Checks if all leaf nodes in the leafList contains the given layer information.
+     * @param leafList Array list storing the leaf nodes.
+     * @return True if all leaf nodes in the leafList contains the given layer information, false otherwise.
+     */
     satisfies(leafList: Array<ParseNodeDrawable>): boolean {
         for (let parseNode of leafList){
             if (!parseNode.getLayerData(ViewLayerType.ENGLISH_WORD).includes("*")){

package/source/Processor/LayerExist/NotContainsLayerInformation.ts

@@ -7,10 +7,19 @@ export class NotContainsLayerInformation implements LeafListCondition{
 
     private readonly viewLayerType: ViewLayerType
 
+    /**
+     * Constructor for NotContainsLayerInformation class. Sets the viewLayerType attribute.
+     * @param viewLayerType Layer for which check is done.
+     */
     constructor(viewLayerType: ViewLayerType) {
         this.viewLayerType = viewLayerType
     }
 
+    /**
+     * Checks if none of the leaf nodes in the leafList contains the given layer information.
+     * @param leafList Array list storing the leaf nodes.
+     * @return True if none of the leaf nodes in the leafList contains the given layer information, false otherwise.
+     */
     satisfies(leafList: Array<ParseNodeDrawable>): boolean {
         for (let parseNode of leafList){
             if (!parseNode.getLayerData(ViewLayerType.ENGLISH_WORD).includes("*")) {

package/source/Processor/LayerExist/SemiContainsLayerInformation.ts

@@ -7,10 +7,20 @@ export class SemiContainsLayerInformation implements LeafListCondition{
 
     private readonly viewLayerType: ViewLayerType
 
+    /**
+     * Constructor for SemiContainsLayerInformation class. Sets the viewLayerType attribute.
+     * @param viewLayerType Layer for which check is done.
+     */
     constructor(viewLayerType: ViewLayerType) {
         this.viewLayerType = viewLayerType
     }
 
+    /**
+     * Checks if some (but not all) of the leaf nodes in the leafList contains the given layer information.
+     * @param leafList Array list storing the leaf nodes.
+     * @return True if some (but not all) of the leaf nodes in the leafList contains the given layer information, false
+     * otherwise.
+     */
     satisfies(leafList: Array<ParseNodeDrawable>): boolean {
         let notDone = 0, done = 0;
         for (let parseNode of leafList){

package/source/Processor/LeafConverter/LeafToEnglish.ts

@@ -3,6 +3,9 @@ import {LeafToLanguageConverter} from "./LeafToLanguageConverter";
 
 export class LeafToEnglish extends LeafToLanguageConverter{
 
+    /**
+     * Constructor for LeafToEnglish. Sets viewLayerType to ENGLISH.
+     */
     constructor() {
         super()
         this.viewLayerType = ViewLayerType.ENGLISH_WORD;

package/source/Processor/LeafConverter/LeafToLanguageConverter.ts

@@ -6,6 +6,13 @@ export class LeafToLanguageConverter implements LeafToStringConverter{
 
     protected viewLayerType: ViewLayerType
 
+    /**
+     * Converts the data in the leaf node to string, except shortcuts to parentheses are converted to its normal forms,
+     * '*', '0', '-NONE-' are converted to empty string.
+     * @param leafNode Node to be converted to string.
+     * @return String form of the data, except shortcuts to parentheses are converted to its normal forms,
+     * '*', '0', '-NONE-' are converted to empty string.
+     */
     leafConverter(leafNode: ParseNodeDrawable): string {
         let layerData = leafNode.getLayerData(this.viewLayerType);
         let parentLayerData = (<ParseNodeDrawable>leafNode.getParent()).getLayerData(this.viewLayerType);

package/source/Processor/LeafConverter/LeafToPersian.ts

@@ -3,6 +3,9 @@ import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
 
 export class LeafToPersian extends LeafToLanguageConverter{
 
+    /**
+     * Constructor for LeafToPersian. Sets viewLayerType to PERSIAN.
+     */
     constructor() {
         super();
         this.viewLayerType = ViewLayerType.PERSIAN_WORD

package/source/Processor/LeafConverter/LeafToRootFormConverter.ts

@@ -3,6 +3,13 @@ import {ParseNodeDrawable} from "../../ParseNodeDrawable";
 
 export class LeafToRootFormConverter implements LeafToStringConverter{
 
+    /**
+     * Converts the data in the leaf node to string. If there are multiple words in the leaf node, they are concatenated
+     * with space.
+     * @param parseNodeDrawable Node to be converted to string.
+     * @return String form of the data. If there are multiple words in the leaf node, they are concatenated
+     * with space.
+     */
     leafConverter(parseNodeDrawable: ParseNodeDrawable): string {
         let layerInfo = parseNodeDrawable.getLayerInfo();
         let rootWords = " ";

package/source/Processor/LeafConverter/LeafToTurkish.ts

@@ -3,6 +3,9 @@ import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
 
 export class LeafToTurkish extends LeafToLanguageConverter{
 
+    /**
+     * Constructor for LeafToPersian. Sets viewLayerType to TURKISH.
+     */
     constructor() {
         super();
         this.viewLayerType = ViewLayerType.TURKISH_WORD

package/source/Processor/NodeDrawableCollector.ts

@@ -6,11 +6,23 @@ export class NodeDrawableCollector {
     private condition: NodeDrawableCondition
     private rootNode: ParseNodeDrawable
 
+    /**
+     * Constructor for the NodeDrawableCollector class. NodeDrawableCollector's main aim is to collect a set of
+     * ParseNode's from a subtree rooted at rootNode, where the ParseNode's satisfy a given NodeCondition, which is
+     * implemented by other interface class.
+     * @param rootNode Root node of the subtree
+     * @param condition The condition interface for which all nodes in the subtree rooted at rootNode will be checked
+     */
     constructor(rootNode: ParseNodeDrawable, condition: NodeDrawableCondition) {
         this.rootNode = rootNode
         this.condition = condition
     }
 
+    /**
+     * Private recursive method to check all descendants of the parseNode, if they ever satisfy the given node condition
+     * @param parseNode Root node of the subtree
+     * @param collected The {@link ArrayList} where the collected ParseNode's will be stored.
+     */
     private collectNodes(parseNode: ParseNodeDrawable, collected: Array<ParseNodeDrawable>){
         if (this.condition == null || this.condition.satisfies(parseNode)){
             collected.push(parseNode);
@@ -20,6 +32,10 @@ export class NodeDrawableCollector {
         }
     }
 
+    /**
+     * Collects and returns all ParseNodes satisfying the node condition.
+     * @return All ParseNodes satisfying the node condition.
+     */
     collect(): Array<ParseNodeDrawable>{
         let result = new Array<ParseNodeDrawable>();
         this.collectNodes(this.rootNode, result);

package/source/Processor/TreeToStringConverter.ts

@@ -7,11 +7,22 @@ export class TreeToStringConverter {
     private converter: LeafToStringConverter
     private parseTree: ParseTreeDrawable
 
+    /**
+     * Constructor of the TreeToStringConverter class. Sets the attributes.
+     * @param parseTree Parse tree to be converted.
+     * @param converter Node to string converter interface.
+     */
     constructor(parseTree: ParseTreeDrawable, converter: LeafToStringConverter) {
         this.converter = converter
         this.parseTree = parseTree
     }
 
+    /**
+     * Converts recursively a parse node to a string. If it is a leaf node, calls the converter's leafConverter method,
+     * otherwise concatenates the converted strings of its children.
+     * @param parseNode Parse node to convert to string.
+     * @return String form of the parse node and all of its descendants.
+     */
     private convertToString(parseNode: ParseNodeDrawable): string{
         if (parseNode.isLeaf()){
             return this.converter.leafConverter(parseNode);
@@ -24,6 +35,10 @@ export class TreeToStringConverter {
         }
     }
 
+    /**
+     * Calls the convertToString method with root of the tree to convert the parse tree to string.
+     * @return String form of the parse tree.
+     */
     convert(){
         return this.convertToString(<ParseNodeDrawable> this.parseTree.getRoot());
     }

package/source/TreeBankDrawable.ts

@@ -6,6 +6,13 @@ import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
 
 export class TreeBankDrawable extends TreeBank{
 
+    /**
+     * A constructor of {@link TreeBankDrawable} class which reads all {@link ParseTreeDrawable} files with the file
+     * name satisfying the given pattern inside the given folder. For each file inside that folder, the constructor
+     * creates a ParseTreeDrawable and puts in inside the list parseTrees.
+     * @param folder Folder where all parseTrees reside.
+     * @param pattern File pattern such as "." ".train" ".test".
+     */
     constructor(folder?: string, pattern?: string) {
         super();
         let files = fs.readdirSync(folder);
@@ -24,14 +31,27 @@ export class TreeBankDrawable extends TreeBank{
         }
     }
 
+    /**
+     * Accessor for the parseTrees attribute
+     * @return ParseTrees attribute
+     */
     getParseTrees(): Array<ParseTree>{
         return this.parseTrees
     }
 
+    /**
+     * Accessor for a specific tree with the given position in the array.
+     * @param index Index of the parseTree.
+     * @return Tree that is in the position index
+     */
     get(index: number): ParseTreeDrawable{
         return <ParseTreeDrawable> this.parseTrees[index];
     }
 
+    /**
+     * Clears the given layer for all nodes in all trees
+     * @param layerType Layer name
+     */
     clearLayer(layerType: ViewLayerType){
         for (let tree of this.parseTrees){
             let parseTree = <ParseTreeDrawable> tree;