All files / src/abap/types method_definitions.ts

94.44% Statements 34/36
91.67% Branches 22/24
100% Functions 5/5
94.44% Lines 34/36

Press n or j to go to the next uncovered block, b, p or k for the previous block.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 741x   1x 1x 1x         1x 787x       787x 787x 787x       642x 387x         21x       21x           142x 142x 52x 52x         787x 787x 142x     645x 645x       645x 645x 36x 36x     645x 645x 10x 10x     645x 645x 191x 190x        
import {MethodDefinition} from "./method_definition";
import {StructureNode} from "../nodes";
import * as Structures from "../3_structures/structures";
import {MethodDef} from "../2_statements/statements";
import {Visibility} from "../4_file_information/visibility";
import {CurrentScope} from "../5_syntax/_current_scope";
import {IMethodDefinitions} from "./_method_definitions";
import {IMethodDefinition} from "./_method_definition";
 
export class MethodDefinitions implements IMethodDefinitions {
  private readonly all: {[index: string]: IMethodDefinition} = {};
  private readonly filename: string;
 
  public constructor(node: StructureNode, filename: string, scope: CurrentScope) {
    this.all = {};
    this.filename = filename;
    this.parse(node, scope);
  }
 
  public* getAll(): Generator<IMethodDefinition, void, undefined> {
    for (const a in this.all) {
      yield this.all[a];
    }
  }
 
  public getByName(name: string | undefined): IMethodDefinition | undefined {
    Iif (name === undefined) {
      return undefined;
    }
 
    return this.all[name.toUpperCase()];
  }
 
///////////////////////
 
  private parseInterface(node: StructureNode, scope: CurrentScope) {
    const defs = node.findAllStatements(MethodDef);
    for (const def of defs) {
      const m = new MethodDefinition(def, Visibility.Public, this.filename, scope);
      this.all[m.getName().toUpperCase()] = m;
    }
  }
 
  private parse(node: StructureNode, scope: CurrentScope) {
    const idef = node.findDirectStructure(Structures.Interface);
    if (idef) {
      return this.parseInterface(node, scope);
    }
 
    const cdef = node.findDirectStructure(Structures.ClassDefinition);
    Iif (!cdef) {
      throw new Error("MethodDefinitions, expected ClassDefinition as part of input node");
    }
 
    const pri = cdef.findDirectStructure(Structures.PrivateSection);
    for (const def of pri?.findAllStatements(MethodDef) || []) {
      const m = new MethodDefinition(def, Visibility.Private, this.filename, scope);
      this.all[m.getName().toUpperCase()] = m;
    }
 
    const pro = node.findDirectStructure(Structures.ProtectedSection);
    for (const def of pro?.findAllStatements(MethodDef) || []) {
      const m = new MethodDefinition(def, Visibility.Protected, this.filename, scope);
      this.all[m.getName().toUpperCase()] = m;
    }
 
    const pub = node.findDirectStructure(Structures.PublicSection);
    for (const def of pub?.findAllStatements(MethodDef) || []) {
      const m = new MethodDefinition(def, Visibility.Public, this.filename, scope);
      this.all[m.getName().toUpperCase()] = m;
    }
  }
 
}