ts2famix 1.0.1

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

@@ -0,0 +1,15 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Variable } from "./variable";
+
+export class ImplicitVariable extends Variable {
+
+  public getJSON(): string {
+    const mse: FamixJSONExporter = new FamixJSONExporter("ImplicitVariable", this);
+    this.addPropertiesToExporter(mse);
+    return mse.getJSON();
+  }
+
+  public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+    super.addPropertiesToExporter(exporter);
+  }
+}

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

@@ -0,0 +1,53 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Association } from "./association";
+import { Module } from "./module";
+import { NamedEntity } from "./named_entity";
+
+export class ImportClause extends Association {
+
+  private importer: Module;
+
+  public getImporter(): Module {
+    return this.importer;
+  }
+
+  public setImporter(importer: Module): void {
+    this.importer = importer;
+    importer.addImportClause(this);
+  }
+
+  private importedEntity: NamedEntity;
+
+  public getImportedEntity(): NamedEntity {
+    return this.importedEntity;
+  }
+
+  public setImportedEntity(importedEntity: NamedEntity): void {
+    this.importedEntity = importedEntity;
+    importedEntity.addImport(this);
+  }
+
+  private moduleSpecifier: string;
+
+  public getModuleSpecifier(): string {
+    return this.moduleSpecifier;
+  }
+
+  public setModuleSpecifier(moduleSpecifier: string): void {
+    this.moduleSpecifier = moduleSpecifier;
+  }
+
+
+  public getJSON(): string {
+    const mse: FamixJSONExporter = new FamixJSONExporter("ImportClause", this);
+    this.addPropertiesToExporter(mse);
+    return mse.getJSON();
+  }
+
+  public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+    super.addPropertiesToExporter(exporter);
+    exporter.addProperty("importer", this.getImporter());
+    exporter.addProperty("importedEntity", this.getImportedEntity());
+    exporter.addProperty("moduleSpecifier", this.getModuleSpecifier());
+  }
+}

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

@@ -0,0 +1,42 @@
+export {Access} from "./access";
+export {Accessor} from "./accessor";
+export {Alias} from "./alias";
+export {Association} from "./association";
+export {BehavioralEntity} from "./behavioral_entity";
+export {CSourceLanguage} from "./c_source_language";
+export {Class} from "./class";
+export {Comment} from "./comment";
+export {ContainerEntity} from "./container_entity";
+export {CustomSourceLanguage} from "./custom_source_language";
+export {Decorator} from "./decorator";
+export {Entity} from "./entity";
+export {EnumValue} from "./enum_value";
+export {Enum} from "./enum";
+export {Property} from "./property";
+export {Function} from "./function";
+export {ImplicitVariable} from "./implicit_variable";
+export {ImportClause} from "./import_clause";
+export {IndexedFileAnchor} from "./indexed_file_anchor";
+export {Inheritance} from "./inheritance";
+export {Interface} from "./interface";
+export {Invocation} from "./invocation";
+export {Method} from "./method";
+export {Module} from "./module";
+export {NamedEntity} from "./named_entity";
+export {Namespace} from "./namespace";
+export {TypeParameter} from "./type_parameter";
+export {Parameter} from "./parameter";
+export {ParameterizableClass} from "./parameterizable_class";
+export {ParameterizableInterface} from "./parameterizable_interface";
+export {ParameterizedType} from "./parameterized_type";
+export {PrimitiveType} from "./primitive_type";
+export {Reference} from "./reference";
+export {ScopingEntity} from "./scoping_entity";
+export {ScriptEntity} from "./script_entity";
+export {SourceAnchor} from "./source_anchor";
+export {SourceLanguage} from "./source_language";
+export {SourcedEntity} from "./sourced_entity";
+export {StructuralEntity} from "./structural_entity";
+export {TextAnchor} from "./text_anchor";
+export {Type} from "./type";
+export {Variable} from "./variable";

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

@@ -0,0 +1,49 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { SourceAnchor } from "./source_anchor";
+
+export class IndexedFileAnchor extends SourceAnchor {
+
+  private startPos: number;
+
+  public getStartPos(): number {
+    return this.startPos;
+  }
+
+  public setStartPos(startPos: number): void {
+    this.startPos = startPos;
+  }
+
+  private endPos: number;
+
+  public getEndPos(): number {
+    return this.endPos;
+  }
+
+  public setEndPos(endPos: number): void {
+    this.endPos = endPos;
+  }
+
+  private fileName: string;
+
+  public getFileName(): string {
+    return this.fileName;
+  }
+
+  public setFileName(fileName: string): void {
+    this.fileName = fileName;
+  }
+
+
+  public getJSON(): string {
+    const mse: FamixJSONExporter = new FamixJSONExporter("IndexedFileAnchor", this);
+    this.addPropertiesToExporter(mse);
+    return mse.getJSON();
+  }
+
+  public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+    super.addPropertiesToExporter(exporter);
+    exporter.addProperty("startPos", this.getStartPos());
+    exporter.addProperty("endPos", this.getEndPos());
+    exporter.addProperty("fileName", this.getFileName());
+  }
+}

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

@@ -0,0 +1,42 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Association } from "./association";
+import { Class } from "./class";
+import { Interface } from "./interface";
+
+export class Inheritance extends Association {
+
+  private superclass: Class | Interface;
+
+  public getSuperclass(): Class  | Interface {
+    return this.superclass;
+  }
+
+  public setSuperclass(superclass: Class | Interface): void {
+    this.superclass = superclass;
+    superclass.addSubInheritance(this);
+  }
+
+  private subclass: Class | Interface;
+
+  public getSubclass(): Class | Interface {
+    return this.subclass;
+  }
+
+  public setSubclass(subclass: Class | Interface): void {
+    this.subclass = subclass;
+    subclass.addSuperInheritance(this);
+  }
+
+
+  public getJSON(): string {
+    const mse: FamixJSONExporter = new FamixJSONExporter("Inheritance", this);
+    this.addPropertiesToExporter(mse);
+    return mse.getJSON();
+  }
+
+  public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+    super.addPropertiesToExporter(exporter);
+    exporter.addProperty("superclass", this.getSuperclass());
+    exporter.addProperty("subclass", this.getSubclass());
+  }
+}

package/src/lib/famix/src/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 getProperties(): Set<Property> {
+    return this.properties;
+  }
+
+  public addProperty(property: Property): void {
+    if (!this.properties.has(property)) {
+      this.properties.add(property);
+      property.setParentEntity(this);
+    }
+  }
+
+  private methods: Set<Method> = new Set();
+
+  public getMethods(): Set<Method> {
+    return this.methods;
+  }
+
+  public addMethod(method: Method): void {
+    if (!this.methods.has(method)) {
+      this.methods.add(method);
+      method.setParentEntity(this);
+    }
+  }
+
+  private superInheritances: Set<Inheritance> = new Set();
+
+  public getSuperInheritances(): Set<Inheritance> {
+    return this.superInheritances;
+  }
+
+  public addSuperInheritance(superInheritance: Inheritance): void {
+    if (!this.superInheritances.has(superInheritance)) {
+      this.superInheritances.add(superInheritance);
+      superInheritance.setSubclass(this);
+    }
+  }
+
+  private subInheritances: Set<Inheritance> = new Set();
+
+  public getSubInheritances(): Set<Inheritance> {
+    return this.subInheritances;
+  }
+
+  public addSubInheritance(subInheritance: Inheritance): void {
+    if (!this.subInheritances.has(subInheritance)) {
+      this.subInheritances.add(subInheritance);
+      subInheritance.setSuperclass(this);
+    }
+  }
+
+
+  public getJSON(): string {
+    const mse: FamixJSONExporter = new FamixJSONExporter("Interface", this);
+    this.addPropertiesToExporter(mse);
+    return mse.getJSON();
+  }
+
+  public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+    super.addPropertiesToExporter(exporter);
+    exporter.addProperty("properties", this.getProperties());
+    exporter.addProperty("methods", this.getMethods());
+    exporter.addProperty("superInheritances", this.getSuperInheritances());
+    exporter.addProperty("subInheritances", this.getSubInheritances());  
+  }
+}

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

@@ -0,0 +1,68 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { NamedEntity } from "./named_entity";
+import { Association } from "./association";
+import { BehavioralEntity } from "./behavioral_entity";
+import { ContainerEntity } from "./container_entity";
+
+export class Invocation extends Association {
+
+  private candidates: Set<BehavioralEntity> = new Set();
+
+  public getCandidates(): Set<BehavioralEntity> {
+    return this.candidates;
+  }
+
+  public addCandidate(candidate: BehavioralEntity): void {  
+    if (!this.candidates.has(candidate)) {
+      this.candidates.add(candidate);
+      candidate.addIncomingInvocation(this);
+    }
+  }
+
+  private receiver: NamedEntity;
+
+  public getReceiver(): NamedEntity {
+    return this.receiver;
+  }
+
+  public setReceiver(receiver: NamedEntity): void {
+    this.receiver = receiver;
+    receiver.addReceivedInvocation(this);
+  }
+
+  private sender: ContainerEntity;
+
+  public getSender(): ContainerEntity {
+    return this.sender;
+  }
+
+  public setSender(sender: ContainerEntity): void {
+    this.sender = sender;
+    sender.addOutgoingInvocation(this);
+  }
+
+  private signature: string;
+
+  public getSignature(): string {
+    return this.signature;
+  }
+
+  public setSignature(signature: string): void {
+    this.signature = signature;
+  }
+
+
+  public getJSON(): string {
+    const mse: FamixJSONExporter = new FamixJSONExporter("Invocation", this);
+    this.addPropertiesToExporter(mse);
+    return mse.getJSON();
+  }
+
+  public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+    super.addPropertiesToExporter(exporter);
+    exporter.addProperty("candidates", this.getCandidates());
+    exporter.addProperty("receiver", this.getReceiver());
+    exporter.addProperty("sender", this.getSender());
+    exporter.addProperty("signature", this.getSignature());
+  }
+}

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

@@ -0,0 +1,96 @@
+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;
+
+  public getParentEntity(): Class | Interface {
+    return this.parentEntity;
+  }
+
+  public setParentEntity(parentEntity: Class | Interface): void {
+    this.parentEntity = parentEntity;
+    parentEntity.addMethod(this);
+  }
+
+  private kind: string;
+
+  public getKind(): string {
+    return this.kind;
+  }
+
+  public setKind(kind: string): void {
+    this.kind = kind;
+  }
+
+  private isAbstract: boolean;
+
+  public getIsAbstract(): boolean {
+    return this.isAbstract;
+  }
+
+  public setIsAbstract(isAbstract: boolean): void {
+    this.isAbstract = isAbstract;
+  }
+
+  private isClassSide: boolean;
+
+  public getIsClassSide(): boolean {
+    return this.isClassSide;
+  }
+
+  public setIsClassSide(isClassSide: boolean): void {
+    this.isClassSide = isClassSide;
+  }
+
+  private isPrivate: boolean;
+
+  public getIsPrivate(): boolean {
+    return this.isPrivate;
+  }
+
+  public setIsPrivate(isPrivate: boolean): void {
+    this.isPrivate = isPrivate;
+  }
+
+  private isPublic: boolean;
+
+  public getIsPublic(): boolean {
+    return this.isPublic;
+  }
+
+  public setIsPublic(isPublic: boolean): void {
+    this.isPublic = isPublic;
+  }
+
+  private isProtected: boolean;
+
+  public getIsProtected(): boolean {
+    return this.isProtected;
+  }
+
+  public setIsProtected(isProtected: boolean): void {
+    this.isProtected = isProtected;
+  }
+
+  
+  public getJSON(): string {
+    const mse: FamixJSONExporter = new FamixJSONExporter("Method", this);
+    this.addPropertiesToExporter(mse);
+    return mse.getJSON();
+  }
+
+  public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+    super.addPropertiesToExporter(exporter);
+    exporter.addProperty("parentEntity", this.getParentEntity());
+    exporter.addProperty("kind", this.getKind());
+    exporter.addProperty("isAbstract", this.getIsAbstract());
+    exporter.addProperty("isClassSide", this.getIsClassSide());
+    exporter.addProperty("isPrivate", this.getIsPrivate());
+    exporter.addProperty("isPublic", this.getIsPublic());
+    exporter.addProperty("isProtected", this.getIsProtected());
+  }
+}

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

@@ -0,0 +1,31 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { ScriptEntity } from "./script_entity";
+import { ImportClause } from "./import_clause";
+
+export class Module extends ScriptEntity {
+
+  private importClauses: Set<ImportClause> = new Set();
+
+  public getImportClauses(): Set<ImportClause> {
+    return this.importClauses;
+  }
+
+  public addImportClause(importClause: ImportClause): void {
+    if (!this.importClauses.has(importClause)) {
+      this.importClauses.add(importClause);
+      importClause.setImporter(this);
+    }
+  }
+
+
+  public getJSON(): string {
+    const mse: FamixJSONExporter = new FamixJSONExporter("Module", this);
+    this.addPropertiesToExporter(mse);
+    return mse.getJSON();
+  }
+
+  public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+    super.addPropertiesToExporter(exporter);
+    exporter.addProperty("importClauses", this.getImportClauses());
+  }
+}

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

@@ -0,0 +1,98 @@
+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;
+
+  public getFullyQualifiedName(): string {
+    return this.fullyQualifiedName;
+  }
+
+  public setFullyQualifiedName(fullyQualifiedName: string): void {
+    this.fullyQualifiedName = fullyQualifiedName;
+  }
+
+  private receivedInvocations: Set<Invocation> = new Set();
+
+  public getReceivedInvocations(): Set<Invocation> {
+    return this.receivedInvocations;
+  }
+
+  public addReceivedInvocation(receivedInvocation: Invocation): void {
+    if (!this.receivedInvocations.has(receivedInvocation)) {
+      this.receivedInvocations.add(receivedInvocation);
+      receivedInvocation.setReceiver(this);
+    }
+  }
+
+  private imports: Set<ImportClause> = new Set();
+
+  public getImports(): Set<ImportClause> {
+    return this.imports;
+  }
+
+  public addImport(anImport: ImportClause): void {
+    if (!this.imports.has(anImport)) {
+      this.imports.add(anImport);
+      anImport.setImportedEntity(this);
+    }
+  }
+
+  private name: string;
+
+  public getName(): string {
+    return this.name;
+  }
+
+  public setName(name: string): void {
+    this.name = name;
+  }
+
+  private aliases: Set<Alias> = new Set();
+
+  public getAliases(): Set<Alias> {
+    return this.aliases;
+  }
+
+  public addAlias(alias: Alias): void {
+    if (!this.aliases.has(alias)) {
+      this.aliases.add(alias);
+      alias.setParentEntity(this);
+    }
+  }
+
+  private decorators: Set<Decorator> = new Set();
+
+  public getDecorators(): Set<Decorator> {
+    return this.decorators;
+  }
+
+  public addDecorator(decorator: Decorator): void {
+    if (!this.decorators.has(decorator)) {
+      this.decorators.add(decorator);
+      decorator.setDecoratedEntity(this);
+    }
+  }
+
+
+  public getJSON(): string {
+    const mse: FamixJSONExporter = new FamixJSONExporter("NamedEntity", this);
+    this.addPropertiesToExporter(mse);
+    return mse.getJSON();
+  }
+
+  public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+    super.addPropertiesToExporter(exporter);
+    exporter.addProperty("fullyQualifiedName", this.getFullyQualifiedName());
+    exporter.addProperty("receivedInvocations", this.getReceivedInvocations());
+    exporter.addProperty("imports", this.getImports());
+    exporter.addProperty("name", this.getName());
+    exporter.addProperty("aliases", this.getAliases());
+    exporter.addProperty("decorators", this.getDecorators());
+  }
+}

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

@@ -0,0 +1,28 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { ScopingEntity } from "./scoping_entity";
+
+export class Namespace extends ScopingEntity {
+
+  private parentScope: ScopingEntity;
+
+  public getParentScope(): ScopingEntity {
+    return this.parentScope;
+  }
+
+  public setParentScope(parentScope: ScopingEntity): void {
+    this.parentScope = parentScope;
+    parentScope.addNamespace(this);
+  }
+
+
+  public getJSON(): string {
+    const mse: FamixJSONExporter = new FamixJSONExporter("Namespace", this);
+    this.addPropertiesToExporter(mse);
+    return mse.getJSON();
+  }
+
+  public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+    super.addPropertiesToExporter(exporter);
+    exporter.addProperty("parentScope", this.getParentScope());
+  }
+}

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

@@ -0,0 +1,29 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { StructuralEntity } from "./structural_entity";
+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);
+  }
+
+
+  public getJSON(): string {
+    const mse: FamixJSONExporter = new FamixJSONExporter("Parameter", this);
+    this.addPropertiesToExporter(mse);
+    return mse.getJSON();
+  }
+
+  public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+    super.addPropertiesToExporter(exporter);
+    exporter.addProperty("parentEntity", this.getParentEntity());
+  }
+}

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

@@ -0,0 +1,31 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Class } from "./class";
+import { TypeParameter } from "./type_parameter";
+
+export class ParameterizableClass extends Class {
+
+  private typeParameters: Set<TypeParameter> = new Set();
+
+  public getTypeParameters(): Set<TypeParameter> {
+    return this.typeParameters;
+  }
+
+  public addTypeParameter(typeParameter: TypeParameter): void {
+    if (!this.typeParameters.has(typeParameter)) {
+      this.typeParameters.add(typeParameter);
+      typeParameter.setParentGeneric(this);
+    }
+  }
+
+
+  public getJSON(): string {
+    const mse: FamixJSONExporter = new FamixJSONExporter("ParameterizableClass", this);
+    this.addPropertiesToExporter(mse);
+    return mse.getJSON();
+  }
+
+  public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+    super.addPropertiesToExporter(exporter);
+    exporter.addProperty("typeParameters", this.getTypeParameters());
+  }
+}