ts2famix 2.0.0 → 2.0.3

package/src/lib/famix/model/famix/indexed_file_anchor.ts

@@ -0,0 +1,46 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { SourceAnchor } from "./source_anchor";
+
+export class IndexedFileAnchor extends SourceAnchor {
+
+  private _startPos!: number;
+  private _endPos!: number;
+  private _fileName!: string;
+
+  public getJSON(): string {
+    const json: FamixJSONExporter = new FamixJSONExporter("IndexedFileAnchor", this);
+    this.addPropertiesToExporter(json);
+    return json.getJSON();
+  }
+
+  public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+    super.addPropertiesToExporter(exporter);
+    exporter.addProperty("startPos", this.startPos);
+    exporter.addProperty("endPos", this.endPos);
+    exporter.addProperty("fileName", this.fileName);
+  }
+
+    get startPos(): number {
+        return this._startPos;
+    }
+
+    set startPos(startPos: number) {
+        this._startPos = startPos;
+    }
+
+    get endPos(): number {
+        return this._endPos;
+    }
+
+    set endPos(endPos: number) {
+        this._endPos = endPos;
+    }
+
+    get fileName(): string {
+        return this._fileName;
+    }
+
+    set fileName(fileName: string) {
+        this._fileName = fileName;
+    }
+}

package/src/lib/famix/model/famix/inheritance.ts

@@ -0,0 +1,40 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Class } from "./class";
+import { Entity } from "./entity";
+import { Interface } from "./interface";
+
+export class Inheritance extends Entity {
+
+    private _superclass!: Class | Interface;
+    private _subclass!: Class | Interface;
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("Inheritance", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("superclass", this.superclass);
+        exporter.addProperty("subclass", this.subclass);
+    }
+
+    get superclass() {
+        return this._superclass;
+    }
+
+    set superclass(superclass: Class | Interface) {
+        this._superclass = superclass;
+        superclass.addSubInheritance(this);
+    }
+
+    get subclass() {
+        return this._subclass;
+    }
+
+    set subclass(subclass: Class | Interface) {
+        this._subclass = subclass;
+        subclass.addSuperInheritance(this);
+    }
+}

package/src/lib/famix/model/famix/interface.ts

@@ -0,0 +1,75 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Type } from "./type";
+import { Method } from "./method";
+import { Property } from "./property";
+import { Inheritance } from "./inheritance";
+
+export class Interface extends Type {
+
+    private _properties: Set<Property> = new Set();
+
+    public addProperty(property: Property): void {
+        if (!this._properties.has(property)) {
+            this._properties.add(property);
+            property.parentEntity = this;
+        }
+    }
+
+    private _methods: Set<Method> = new Set();
+
+    public addMethod(method: Method): void {
+        if (!this._methods.has(method)) {
+            this._methods.add(method);
+            method.parentEntity = this;
+        }
+    }
+
+    private _superInheritances: Set<Inheritance> = new Set();
+
+    public addSuperInheritance(superInheritance: Inheritance): void {
+        if (!this._superInheritances.has(superInheritance)) {
+            this._superInheritances.add(superInheritance);
+            superInheritance.subclass = this;
+        }
+    }
+
+    private _subInheritances: Set<Inheritance> = new Set();
+
+    public addSubInheritance(subInheritance: Inheritance): void {
+        if (!this._subInheritances.has(subInheritance)) {
+            this._subInheritances.add(subInheritance);
+            subInheritance.superclass = this;
+        }
+    }
+
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("Interface", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("attributes", this.properties);
+        exporter.addProperty("methods", this.methods);
+        exporter.addProperty("superInheritances", this.superInheritances);
+        exporter.addProperty("subInheritances", this.subInheritances);
+    }
+
+    get properties() {
+        return this._properties;
+    }
+
+    get methods() {
+        return this._methods;
+    }
+
+    get superInheritances() {
+        return this._superInheritances;
+    }
+
+    get subInheritances() {
+        return this._subInheritances;
+    }
+}

package/src/lib/famix/model/famix/invocation.ts

@@ -0,0 +1,65 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { NamedEntity } from "./named_entity";
+import { BehavioralEntity } from "./behavioral_entity";
+import { ContainerEntity } from "./container_entity";
+import { Entity } from "./entity";
+
+export class Invocation extends Entity {
+
+  private _candidates: Set<BehavioralEntity> = new Set();
+
+  public addCandidate(candidate: BehavioralEntity): void {  
+    if (!this._candidates.has(candidate)) {
+      this._candidates.add(candidate);
+      candidate.addIncomingInvocation(this);
+    }
+  }
+
+  private _receiver!: NamedEntity;
+  private _sender!: ContainerEntity;
+  private _signature!: string;
+
+  public getJSON(): string {
+    const json: FamixJSONExporter = new FamixJSONExporter("Invocation", this);
+    this.addPropertiesToExporter(json);
+    return json.getJSON();
+  }
+
+  public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+    super.addPropertiesToExporter(exporter);
+    exporter.addProperty("candidates", this.candidates);
+    exporter.addProperty("receiver", this.receiver);
+    exporter.addProperty("sender", this.sender);
+    exporter.addProperty("signature", this.signature);
+  }
+
+    get candidates() {
+        return this._candidates;
+    }
+
+    get receiver() {
+        return this._receiver;
+    }
+
+    set receiver(receiver: NamedEntity) {
+        this._receiver = receiver;
+        receiver.addReceivedInvocation(this);
+    }
+
+    get sender() {
+        return this._sender;
+    }
+
+    set sender(sender: ContainerEntity) {
+        this._sender = sender;
+        sender.addOutgoingInvocation(this);
+    }
+
+    get signature() {
+        return this._signature;
+    }
+
+    set signature(signature: string) {
+        this._signature = signature;
+    }
+}

package/src/lib/famix/model/famix/method.ts

@@ -0,0 +1,89 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { BehavioralEntity } from "./behavioral_entity";
+import { Class } from "./class";
+import { Interface } from "./interface";
+
+export class Method extends BehavioralEntity {
+
+  private _parentEntity!: Class | Interface;
+  private _kind!: string;
+  private _isAbstract!: boolean;
+  private _isClassSide!: boolean;
+  private _isPrivate!: boolean;
+  private _isPublic!: boolean;
+  private _isProtected!: boolean;
+
+  public getJSON(): string {
+    const json: FamixJSONExporter = new FamixJSONExporter("Method", this);
+    this.addPropertiesToExporter(json);
+    return json.getJSON();
+  }
+
+  public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+    super.addPropertiesToExporter(exporter);
+    exporter.addProperty("parentType", this.parentEntity);
+    exporter.addProperty("kind", this.kind);
+    exporter.addProperty("isAbstract", this.isAbstract);
+    exporter.addProperty("isClassSide", this.isClassSide);
+    exporter.addProperty("isPrivate", this.isPrivate);
+    exporter.addProperty("isPublic", this.isPublic);
+    exporter.addProperty("isProtected", this.isProtected);
+  }
+
+    get parentEntity() {
+        return this._parentEntity;
+    }
+
+    set parentEntity(parentEntity: Class | Interface) {
+        this._parentEntity = parentEntity;
+        parentEntity.addMethod(this);
+    }
+
+    get kind() {
+        return this._kind;
+    }
+
+    set kind(kind: string) {
+        this._kind = kind;
+    }
+
+    get isAbstract() {
+        return this._isAbstract;
+    }
+
+    set isAbstract(isAbstract: boolean) {
+        this._isAbstract = isAbstract;
+    }
+
+    get isClassSide() {
+        return this._isClassSide;
+    }
+
+    set isClassSide(isClassSide: boolean) {
+        this._isClassSide = isClassSide;
+    }
+
+    get isPrivate() {
+        return this._isPrivate;
+    }
+
+    set isPrivate(isPrivate: boolean) {
+        this._isPrivate = isPrivate;
+    }
+
+    get isPublic() {
+        return this._isPublic;
+    }
+
+    set isPublic(isPublic: boolean) {
+        this._isPublic = isPublic;
+    }
+
+    get isProtected() {
+        return this._isProtected;
+    }
+
+    set isProtected(isProtected: boolean) {
+        this._isProtected = isProtected;
+    }
+}

package/src/lib/famix/model/famix/module.ts

@@ -0,0 +1,71 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { ImportClause } from "./import_clause";
+import { ScopingEntity } from "./scoping_entity";
+import { ScriptEntity } from "./script_entity";
+
+export class Module extends ScriptEntity {
+
+    public get isAmbient() {
+        return this._isAmbient;
+    }
+
+    public set isAmbient(value: boolean) {
+        this._isAmbient = value;
+    }
+
+    private _isAmbient: boolean = false;
+
+    public get isNamespace() {
+        return this._isNamespace;
+    }
+
+    public set isNamespace(value: boolean) {
+        this._isNamespace = value;
+    }
+    private _isNamespace: boolean = false;
+
+    public get isModule() {
+        return this._isModule;
+    }
+
+    public set isModule(value: boolean) {
+        this._isModule = value;
+    }
+
+    private _isModule: boolean = true;
+
+    private _parentScope!: ScopingEntity;
+    // incomingImports are in NamedEntity
+    private _outgoingImports: Set<ImportClause> = new Set();
+
+    addOutgoingImport(importClause: ImportClause) {
+        if (!this._outgoingImports.has(importClause)) {
+            this._outgoingImports.add(importClause);
+            importClause.importingEntity = this;  // opposite
+        }
+    }
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("Module", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("outgoingImports", this.outgoingImports);
+    }
+
+    get parentScope() {
+        return this._parentScope;
+    }
+
+    set parentScope(parentScope: ScopingEntity) {
+        this._parentScope = parentScope;
+        parentScope.addModule(this);
+    }
+
+    get outgoingImports() {
+        return this._outgoingImports;
+    }
+}

package/src/lib/famix/model/famix/named_entity.ts

@@ -0,0 +1,95 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { SourcedEntity } from "./sourced_entity";
+import { Invocation } from "./invocation";
+import { ImportClause } from "./import_clause";
+import { Alias } from "./alias";
+import { Decorator } from "./decorator";
+
+export class NamedEntity extends SourcedEntity {
+
+    private _fullyQualifiedName!: string;
+    private _receivedInvocations: Set<Invocation> = new Set();
+
+    public addReceivedInvocation(receivedInvocation: Invocation): void {
+        if (!this._receivedInvocations.has(receivedInvocation)) {
+            this._receivedInvocations.add(receivedInvocation);
+            receivedInvocation.receiver = this;
+        }
+    }
+
+    private _incomingImports: Set<ImportClause> = new Set();
+
+    public addIncomingImport(anImport: ImportClause): void {
+        if (!this._incomingImports.has(anImport)) {
+            this._incomingImports.add(anImport);
+            anImport.importedEntity = this;  // opposite
+        }
+    }
+
+    private _name!: string;
+    private _aliases: Set<Alias> = new Set();
+
+    public addAlias(alias: Alias): void {
+        if (!this._aliases.has(alias)) {
+            this._aliases.add(alias);
+            alias.parentEntity = this;
+        }
+    }
+
+    private _decorators: Set<Decorator> = new Set();
+
+    public addDecorator(decorator: Decorator): void {
+        if (!this._decorators.has(decorator)) {
+            this._decorators.add(decorator);
+            decorator.decoratedEntity = this;
+        }
+    }
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("NamedEntity", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        // exporter.addProperty("fullyQualifiedName", this.getFullyQualifiedName());
+        // exporter.addProperty("incomingInvocations", this.getReceivedInvocations());
+        exporter.addProperty("incomingImports", this.incomingImports);
+        exporter.addProperty("name", this.name);
+        // exporter.addProperty("aliases", this.getAliases());  /* since these generate Unknown property messages */
+        exporter.addProperty("decorators", this.decorators);
+    }
+
+    get fullyQualifiedName() {
+        return this._fullyQualifiedName;
+    }
+
+    set fullyQualifiedName(fullyQualifiedName: string) {
+        this._fullyQualifiedName = fullyQualifiedName;
+    }
+
+    get receivedInvocations() {
+        return this._receivedInvocations;
+    }
+
+    get incomingImports() {
+        return this._incomingImports;
+    }
+
+    get name() {
+        return this._name;
+    }
+
+    set name(name: string) {
+        this._name = name;
+    }
+
+    get aliases() {
+        return this._aliases;
+    }
+
+    get decorators() {
+        return this._decorators;
+    }
+}

package/src/lib/famix/{src/model → model}/famix/parameter.ts

@@ -4,17 +4,7 @@ import { BehavioralEntity } from "./behavioral_entity";
 
 export class Parameter extends StructuralEntity {
 
-  private parentEntity: BehavioralEntity;
-
-  public getParentEntity(): BehavioralEntity {
-    return this.parentEntity;
-  }
-
-  public setParentEntity(parentEntity: BehavioralEntity): void {
-    this.parentEntity = parentEntity;
-    parentEntity.addParameter(this);
-  }
-
+  private _parentEntity!: BehavioralEntity;
 
   public getJSON(): string {
     const json: FamixJSONExporter = new FamixJSONExporter("Parameter", this);
@@ -24,6 +14,15 @@ export class Parameter extends StructuralEntity {
 
   public addPropertiesToExporter(exporter: FamixJSONExporter): void {
     super.addPropertiesToExporter(exporter);
-    exporter.addProperty("parentBehaviouralEntity", this.getParentEntity());
+    exporter.addProperty("parentBehaviouralEntity", this.parentEntity);
   }
+
+    get parentEntity() {
+        return this._parentEntity;
+    }
+
+    set parentEntity(parentEntity: BehavioralEntity) {
+        this._parentEntity = parentEntity;
+        parentEntity.addParameter(this);
+    }
 }

package/src/lib/famix/model/famix/parameter_concretisation.ts

@@ -0,0 +1,51 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Concretisation } from "./concretisation";
+import { Entity } from "./entity";
+import { ParameterType } from "./parameter_type";
+import { PrimitiveType } from "./primitive_type";
+
+export class ParameterConcretisation extends Entity {
+
+    private _genericParameter!: ParameterType;
+    private _concreteParameter!: PrimitiveType;
+    private _concretisations: Set<Concretisation> = new Set();
+
+    public addConcretisation(concretisation: Concretisation): void {
+      if (!this._concretisations.has(concretisation)) {
+        this._concretisations.add(concretisation);
+      }
+    }
+  
+    public getJSON(): string {
+      const json: FamixJSONExporter = new FamixJSONExporter("ParameterConcretisation", this);
+      this.addPropertiesToExporter(json);
+      return json.getJSON();
+    }
+  
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+      super.addPropertiesToExporter(exporter);
+      exporter.addProperty("genericEntity", this.genericParameter);
+      exporter.addProperty("concreteEntity", this.concreteParameter);
+      exporter.addProperty("concretisations", this.concretisations);
+    }
+
+    get genericParameter() {
+        return this._genericParameter;
+    }
+
+    set genericParameter(genericEntity: ParameterType) {
+        this._genericParameter = genericEntity;
+    }
+
+    get concreteParameter() {
+        return this._concreteParameter;
+    }
+
+    set concreteParameter(concreteParameter: PrimitiveType) {
+        this._concreteParameter = concreteParameter;
+    }
+
+    get concretisations() {
+        return this._concretisations;
+    }
+}

package/src/lib/famix/model/famix/parameter_type.ts

@@ -0,0 +1,58 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Type } from "./type";
+import { ParametricClass } from "./parametric_class";
+import { ParametricInterface } from "./parametric_interface";
+import { Method } from "./method";
+import { Function as FamixFunction } from "./function";
+import { Accessor } from "./accessor";
+import { ParametricMethod } from "./parametric_method";
+import { ParametricFunction } from "./parametric_function";
+import { ArrowFunction } from "./arrow_function";
+import { ParametricArrowFunction } from "./parametric_arrow_function";
+
+export class ParameterType extends Type {
+
+    private _parentGeneric!: ParametricClass | ParametricInterface | Method | ParametricMethod | Accessor | FamixFunction | ParametricFunction | ArrowFunction | ParametricArrowFunction;
+    private _baseType!: Type;
+    private _arguments: Set<Type> = new Set();
+
+    public addArgument(argument: Type): void {
+        if (!this._arguments.has(argument)) {
+            this._arguments.add(argument);
+        }
+    }
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("ParameterType", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("parentGeneric", this.parentGeneric);
+        exporter.addProperty("baseType", this.baseType);
+        exporter.addProperty("arguments", this.arguments);
+    }
+
+    get parentGeneric() {
+        return this._parentGeneric;
+    }
+
+    set parentGeneric(parentGeneric: ParametricClass | ParametricInterface | Method | ParametricMethod | Accessor | FamixFunction | ParametricFunction | ArrowFunction | ParametricArrowFunction) {
+        this._parentGeneric = parentGeneric;
+        parentGeneric.addGenericParameter(this);
+    }
+
+    get baseType() {
+        return this._baseType;
+    }
+
+    set baseType(baseType: Type) {
+        this._baseType = baseType;
+    }
+
+    get arguments() {
+        return this._arguments;
+    }
+}

package/src/lib/famix/model/famix/parametric_arrow_function.ts

@@ -0,0 +1,32 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { ArrowFunction } from "./arrow_function";
+import { Class } from "./class";
+import { Interface } from "./interface";
+import { PrimitiveType } from "./primitive_type";
+
+export class ParametricArrowFunction extends ArrowFunction {
+
+    private _concreteParameters: Set<PrimitiveType | Class | Interface> = new Set();
+
+    public addConcreteParameter(concreteParameter: PrimitiveType | Class | Interface): void {
+        if (!this._concreteParameters.has(concreteParameter)) {
+            this._concreteParameters.add(concreteParameter);
+        }
+    }
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("ParametricArrowFunction", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("genericParameters", this.genericParameters);
+        exporter.addProperty("concreteParameters", this.concreteParameters);
+    }
+
+    get concreteParameters() {
+        return this._concreteParameters;
+    }
+}