ts2famix 1.0.1 → 1.0.4

package/dist/lib/famix/src/famix_repository.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FamixRepository = void 0;
+const famix_1 = require("./model/famix");
+/**
+ * This class is used to store all Famix elements
+ */
+class FamixRepository {
+    constructor() {
+        this.elements = new Set(); // All Famix elements
+        this.famixClasses = new Set(); // All Famix classes
+        this.famixInterfaces = new Set(); // All Famix interfaces
+        this.famixNamespaces = new Set(); // All Famix namespaces
+        this.famixMethods = new Set(); // All Famix methods
+        this.famixFunctions = new Set(); // All Famix functions
+        this.famixFiles = new Set(); // All Famix files
+        this.idCounter = 1; // Id counter
+    }
+    /**
+     * Gets a Famix entity by id
+     * @param id An id of a Famix entity
+     * @returns The Famix entity corresponding to the id or undefined if it doesn't exist
+     */
+    getFamixEntityById(id) {
+        const entity = Array.from(this.elements.values()).find(e => e.id === id);
+        return entity;
+    }
+    /**
+     * Gets a Famix entity by fully qualified name
+     * @param fullyQualifiedName A fully qualified name
+     * @returns The Famix entity corresponding to the fully qualified name or undefined if it doesn't exist
+     */
+    getFamixEntityByFullyQualifiedName(fullyQualifiedName) {
+        const allEntities = Array.from(this.elements.values()).filter(e => e instanceof famix_1.NamedEntity);
+        const entity = allEntities.find(e => e.getFullyQualifiedName() === fullyQualifiedName);
+        return entity;
+    }
+    // Only for tests
+    /**
+     * Gets all Famix entities
+     * @returns All Famix entities
+     */
+    _getAllEntities() {
+        return new Set(Array.from(this.elements.values()));
+    }
+    /**
+     * Gets all Famix entities of a given type
+     * @param theType A type of Famix entity
+     * @returns All Famix entities of the given type
+     */
+    _getAllEntitiesWithType(theType) {
+        return new Set(Array.from(this.elements.values()).filter(e => e.constructor.name === theType));
+    }
+    /**
+     * Gets a Famix class by name
+     * @param name A class name
+     * @returns The Famix class corresponding to the name or undefined if it doesn't exist
+     */
+    _getFamixClass(name) {
+        return Array.from(this.famixClasses.values()).find(ns => ns.getName() === name);
+    }
+    /**
+     * Gets a Famix interface by name
+     * @param name An interface name
+     * @returns The Famix interface corresponding to the name or undefined if it doesn't exist
+     */
+    _getFamixInterface(name) {
+        return Array.from(this.famixInterfaces.values()).find(ns => ns.getName() === name);
+    }
+    /**
+     * Gets a Famix method by name
+     * @param name A method name
+     * @returns The Famix method corresponding to the name or undefined if it doesn't exist
+     */
+    _getFamixMethod(name) {
+        return Array.from(this.famixMethods.values()).find(ns => ns.getName() === name);
+    }
+    /**
+     * Gets a Famix function by name
+     * @param name A function name
+     * @returns The Famix function corresponding to the name or undefined if it doesn't exist
+     */
+    _getFamixFunction(name) {
+        return Array.from(this.famixFunctions.values()).find(ns => ns.getName() === name);
+    }
+    /**
+     * Gets a Famix namespace by name
+     * @param name A namespace name
+     * @returns The Famix namespace corresponding to the name or undefined if it doesn't exist
+     */
+    _getFamixNamespace(name) {
+        return Array.from(this.famixNamespaces.values()).find(ns => ns.getName() === name);
+    }
+    /**
+     * Gets all Famix namespaces
+     * @returns All Famix namespaces
+     */
+    _getFamixNamespaces() {
+        return new Set(Array.from(this.famixNamespaces.values()));
+    }
+    /**
+     * Gets a Famix file by name
+     * @param name A file name
+     * @returns The Famix file corresponding to the name or undefined if it doesn't exist
+     */
+    _getFamixFile(name) {
+        return Array.from(this.famixFiles.values()).find(ns => ns.getName() === name);
+    }
+    /**
+     * Gets all Famix files
+     * @returns All Famix files
+     */
+    _getFamixFiles() {
+        return new Set(Array.from(this.famixFiles.values()));
+    }
+    /**
+     * Gets all method names as a set from a class
+     * @param className A class name
+     * @returns The set of class "className" method names
+     */
+    _methodNamesAsSetFromClass(className) {
+        const theClass = this._getFamixClass(className);
+        return new Set(Array.from(theClass.getMethods()).map(m => m.getName()));
+    }
+    /**
+     * Gets all method parents as a set from a class
+     * @param className A class name
+     * @returns The set of class "className" method parents
+     */
+    _methodParentsAsSetFromClass(className) {
+        const theClass = this._getFamixClass(className);
+        return new Set(Array.from(theClass.getMethods()).map(m => m.getParentEntity()));
+    }
+    /**
+     * Gets the map of Famix element ids and their Famix element from a JSON model
+     * @param model A JSON model
+     * @returns The map of Famix element ids and their Famix element from the JSON model
+     */
+    _initMapFromModel(model) {
+        const parsedModel = JSON.parse(model);
+        const idToElementMap = new Map();
+        parsedModel.forEach(element => {
+            idToElementMap.set(element.id, element);
+        });
+        return idToElementMap;
+    }
+    /**
+     * Adds a Famix element to the repository
+     * @param element A Famix element
+     */
+    addElement(element) {
+        if (element instanceof famix_1.Class) {
+            this.famixClasses.add(element);
+        }
+        else if (element instanceof famix_1.Interface) {
+            this.famixInterfaces.add(element);
+        }
+        else if (element instanceof famix_1.Namespace) {
+            this.famixNamespaces.add(element);
+        }
+        else if (element instanceof famix_1.Method) {
+            this.famixMethods.add(element);
+        }
+        else if (element instanceof famix_1.Function) {
+            this.famixFunctions.add(element);
+        }
+        else if (element instanceof famix_1.ScriptEntity || element instanceof famix_1.Module) {
+            this.famixFiles.add(element);
+        }
+        this.elements.add(element);
+        element.id = this.idCounter;
+        this.idCounter++;
+    }
+    /**
+     * Gets a JSON representation of the repository
+     * @returns A JSON representation of the repository
+     */
+    getJSON() {
+        let ret = "[";
+        for (const element of Array.from(this.elements.values())) {
+            ret = ret + element.getJSON() + ",";
+        }
+        ret = ret.substring(0, ret.length - 1);
+        return ret + "]";
+    }
+}
+exports.FamixRepository = FamixRepository;

package/dist/lib/famix/src/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+const Famix = __importStar(require("./model/famix"));
+const famix_base_element_1 = require("./famix_base_element");
+const famix_JSON_exporter_1 = require("./famix_JSON_exporter");
+const famix_repository_1 = require("./famix_repository");
+const model = { Famix };
+module.exports = { FamixBaseElement: famix_base_element_1.FamixBaseElement, FamixJSONExporter: famix_JSON_exporter_1.FamixJSONExporter, FamixRepository: famix_repository_1.FamixRepository, model };

package/dist/lib/famix/src/model/famix/access.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Access = void 0;
+const famix_JSON_exporter_1 = require("../../famix_JSON_exporter");
+const association_1 = require("./association");
+class Access extends association_1.Association {
+    getAccessor() {
+        return this.accessor;
+    }
+    setAccessor(accessor) {
+        this.accessor = accessor;
+        accessor.addAccess(this);
+    }
+    getVariable() {
+        return this.variable;
+    }
+    setVariable(variable) {
+        this.variable = variable;
+        variable.addIncomingAccess(this);
+    }
+    getIsWrite() {
+        return this.isWrite;
+    }
+    setIsWrite(isWrite) {
+        this.isWrite = isWrite;
+    }
+    getJSON() {
+        const mse = new famix_JSON_exporter_1.FamixJSONExporter("Access", this);
+        this.addPropertiesToExporter(mse);
+        return mse.getJSON();
+    }
+    addPropertiesToExporter(exporter) {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("accessor", this.getAccessor());
+        exporter.addProperty("variable", this.getVariable());
+        exporter.addProperty("isWrite", this.getIsWrite());
+    }
+}
+exports.Access = Access;

package/dist/lib/famix/src/model/famix/accessor.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Accessor = void 0;
+const famix_JSON_exporter_1 = require("../../famix_JSON_exporter");
+const method_1 = require("./method");
+class Accessor extends method_1.Method {
+    getJSON() {
+        const mse = new famix_JSON_exporter_1.FamixJSONExporter("Accessor", this);
+        this.addPropertiesToExporter(mse);
+        return mse.getJSON();
+    }
+    addPropertiesToExporter(exporter) {
+        super.addPropertiesToExporter(exporter);
+    }
+}
+exports.Accessor = Accessor;

package/dist/lib/famix/src/model/famix/alias.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Alias = void 0;
+const famix_JSON_exporter_1 = require("../../famix_JSON_exporter");
+const named_entity_1 = require("./named_entity");
+class Alias extends named_entity_1.NamedEntity {
+    getParentEntity() {
+        return this.parentEntity;
+    }
+    setParentEntity(parentEntity) {
+        this.parentEntity = parentEntity;
+        parentEntity.addAlias(this);
+    }
+    getAliasedEntity() {
+        return this.aliasedEntity;
+    }
+    setAliasedEntity(aliasedEntity) {
+        this.aliasedEntity = aliasedEntity;
+        aliasedEntity.addTypeAlias(this);
+    }
+    getJSON() {
+        const mse = new famix_JSON_exporter_1.FamixJSONExporter("Alias", this);
+        this.addPropertiesToExporter(mse);
+        return mse.getJSON();
+    }
+    addPropertiesToExporter(exporter) {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("parentEntity", this.getParentEntity());
+        exporter.addProperty("aliasedEntity", this.getAliasedEntity());
+    }
+}
+exports.Alias = Alias;

package/dist/lib/famix/src/model/famix/association.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Association = void 0;
+const famix_JSON_exporter_1 = require("../../famix_JSON_exporter");
+const sourced_entity_1 = require("./sourced_entity");
+class Association extends sourced_entity_1.SourcedEntity {
+    getNext() {
+        return this.next;
+    }
+    setNext(next) {
+        if (this.next === undefined) {
+            this.next = next;
+            next.setPrevious(this);
+        }
+    }
+    getPrevious() {
+        return this.previous;
+    }
+    setPrevious(previous) {
+        if (this.previous === undefined) {
+            this.previous = previous;
+            previous.setNext(this);
+        }
+    }
+    getJSON() {
+        const mse = new famix_JSON_exporter_1.FamixJSONExporter("Association", this);
+        this.addPropertiesToExporter(mse);
+        return mse.getJSON();
+    }
+    addPropertiesToExporter(exporter) {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("next", this.getNext());
+        exporter.addProperty("previous", this.getPrevious());
+    }
+}
+exports.Association = Association;

package/dist/lib/famix/src/model/famix/behavioral_entity.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BehavioralEntity = void 0;
+const famix_JSON_exporter_1 = require("../../famix_JSON_exporter");
+const container_entity_1 = require("./container_entity");
+class BehavioralEntity extends container_entity_1.ContainerEntity {
+    constructor() {
+        super(...arguments);
+        this.parameters = new Set();
+        this.incomingInvocations = new Set();
+        this.typeParameters = new Set();
+    }
+    getIsGeneric() {
+        return this.isGeneric;
+    }
+    setIsGeneric(isGeneric) {
+        this.isGeneric = isGeneric;
+    }
+    getSignature() {
+        return this.signature;
+    }
+    setSignature(signature) {
+        this.signature = signature;
+    }
+    getParameters() {
+        return this.parameters;
+    }
+    addParameter(parameter) {
+        if (!this.parameters.has(parameter)) {
+            this.parameters.add(parameter);
+            parameter.setParentEntity(this);
+        }
+    }
+    getNumberOfParameters() {
+        return this.numberOfParameters;
+    }
+    setNumberOfParameters(numberOfParameters) {
+        this.numberOfParameters = numberOfParameters;
+    }
+    getIncomingInvocations() {
+        return this.incomingInvocations;
+    }
+    addIncomingInvocation(incomingInvocation) {
+        if (!this.incomingInvocations.has(incomingInvocation)) {
+            this.incomingInvocations.add(incomingInvocation);
+            incomingInvocation.addCandidate(this);
+        }
+    }
+    getDeclaredType() {
+        return this.declaredType;
+    }
+    setDeclaredType(declaredType) {
+        this.declaredType = declaredType;
+        declaredType.addBehavioralEntityWithDeclaredType(this);
+    }
+    getTypeParameters() {
+        return this.typeParameters;
+    }
+    addTypeParameter(typeParameter) {
+        if (!this.typeParameters.has(typeParameter)) {
+            this.typeParameters.add(typeParameter);
+            typeParameter.setParentGeneric(this);
+        }
+    }
+    getJSON() {
+        const mse = new famix_JSON_exporter_1.FamixJSONExporter("BehavioralEntity", this);
+        this.addPropertiesToExporter(mse);
+        return mse.getJSON();
+    }
+    addPropertiesToExporter(exporter) {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("isGeneric", this.getIsGeneric());
+        exporter.addProperty("signature", this.getSignature());
+        exporter.addProperty("parameters", this.getParameters());
+        exporter.addProperty("numberOfParameters", this.getNumberOfParameters());
+        exporter.addProperty("incomingInvocations", this.getIncomingInvocations());
+        exporter.addProperty("declaredType", this.getDeclaredType());
+        exporter.addProperty("typeParameters", this.getTypeParameters());
+    }
+}
+exports.BehavioralEntity = BehavioralEntity;

package/dist/lib/famix/src/model/famix/c_source_language.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSourceLanguage = void 0;
+const famix_JSON_exporter_1 = require("../../famix_JSON_exporter");
+const source_language_1 = require("./source_language");
+class CSourceLanguage extends source_language_1.SourceLanguage {
+    getJSON() {
+        const mse = new famix_JSON_exporter_1.FamixJSONExporter("CSourceLanguage", this);
+        this.addPropertiesToExporter(mse);
+        return mse.getJSON();
+    }
+    addPropertiesToExporter(exporter) {
+        super.addPropertiesToExporter(exporter);
+    }
+}
+exports.CSourceLanguage = CSourceLanguage;

package/dist/lib/famix/src/model/famix/class.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Class = void 0;
+const famix_JSON_exporter_1 = require("../../famix_JSON_exporter");
+const type_1 = require("./type");
+class Class extends type_1.Type {
+    constructor() {
+        super(...arguments);
+        this.properties = new Set();
+        this.methods = new Set();
+        this.superInheritances = new Set();
+        this.subInheritances = new Set();
+    }
+    getIsAbstract() {
+        return this.isAbstract;
+    }
+    setIsAbstract(isAbstract) {
+        this.isAbstract = isAbstract;
+    }
+    getProperties() {
+        return this.properties;
+    }
+    addProperty(property) {
+        if (!this.properties.has(property)) {
+            this.properties.add(property);
+            property.setParentEntity(this);
+        }
+    }
+    getMethods() {
+        return this.methods;
+    }
+    addMethod(method) {
+        if (!this.methods.has(method)) {
+            this.methods.add(method);
+            method.setParentEntity(this);
+        }
+    }
+    getSuperInheritances() {
+        return this.superInheritances;
+    }
+    addSuperInheritance(superInheritance) {
+        if (!this.superInheritances.has(superInheritance)) {
+            this.superInheritances.add(superInheritance);
+            superInheritance.setSubclass(this);
+        }
+    }
+    getSubInheritances() {
+        return this.subInheritances;
+    }
+    addSubInheritance(subInheritance) {
+        if (!this.subInheritances.has(subInheritance)) {
+            this.subInheritances.add(subInheritance);
+            subInheritance.setSuperclass(this);
+        }
+    }
+    getJSON() {
+        const mse = new famix_JSON_exporter_1.FamixJSONExporter("Class", this);
+        this.addPropertiesToExporter(mse);
+        return mse.getJSON();
+    }
+    addPropertiesToExporter(exporter) {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("isAbstract", this.getIsAbstract());
+        exporter.addProperty("properties", this.getProperties());
+        exporter.addProperty("methods", this.getMethods());
+        exporter.addProperty("superInheritances", this.getSuperInheritances());
+        exporter.addProperty("subInheritances", this.getSubInheritances());
+    }
+}
+exports.Class = Class;

package/dist/lib/famix/src/model/famix/comment.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Comment = void 0;
+const famix_JSON_exporter_1 = require("../../famix_JSON_exporter");
+const sourced_entity_1 = require("./sourced_entity");
+class Comment extends sourced_entity_1.SourcedEntity {
+    getIsJSDoc() {
+        return this.isJSDoc;
+    }
+    setIsJSDoc(isJSDoc) {
+        this.isJSDoc = isJSDoc;
+    }
+    getContainer() {
+        return this.container;
+    }
+    setContainer(container) {
+        this.container = container;
+        container.addComment(this);
+    }
+    getContent() {
+        return this.content;
+    }
+    setContent(content) {
+        this.content = content;
+    }
+    getJSON() {
+        const mse = new famix_JSON_exporter_1.FamixJSONExporter("Comment", this);
+        this.addPropertiesToExporter(mse);
+        return mse.getJSON();
+    }
+    addPropertiesToExporter(exporter) {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("isJSDoc", this.getIsJSDoc());
+        exporter.addProperty("container", this.getContainer());
+        exporter.addProperty("content", this.getContent());
+    }
+}
+exports.Comment = Comment;

package/dist/lib/famix/src/model/famix/container_entity.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerEntity = void 0;
+const famix_JSON_exporter_1 = require("../../famix_JSON_exporter");
+const named_entity_1 = require("./named_entity");
+class ContainerEntity extends named_entity_1.NamedEntity {
+    constructor() {
+        super(...arguments);
+        this.childrenContainerEntities = new Set();
+        this.outgoingReferences = new Set();
+        this.outgoingInvocations = new Set();
+        this.accesses = new Set();
+        this.childrenTypes = new Set();
+        this.childrenFunctions = new Set();
+        this.variables = new Set();
+    }
+    getParentContainerEntity() {
+        return this.parentContainerEntity;
+    }
+    setParentContainerEntity(parentContainerEntity) {
+        this.parentContainerEntity = parentContainerEntity;
+        parentContainerEntity.addChildContainerEntity(this);
+    }
+    getChildrenContainerEntities() {
+        return this.childrenContainerEntities;
+    }
+    addChildContainerEntity(childContainerEntity) {
+        if (!this.childrenContainerEntities.has(childContainerEntity)) {
+            this.childrenContainerEntities.add(childContainerEntity);
+            childContainerEntity.setParentContainerEntity(this);
+        }
+    }
+    getCyclomaticComplexity() {
+        return this.cyclomaticComplexity;
+    }
+    setCyclomaticComplexity(cyclomaticComplexity) {
+        this.cyclomaticComplexity = cyclomaticComplexity;
+    }
+    getNumberOfStatements() {
+        return this.numberOfStatements;
+    }
+    setNumberOfStatements(numberOfStatements) {
+        this.numberOfStatements = numberOfStatements;
+    }
+    getOutgoingReferences() {
+        return this.outgoingReferences;
+    }
+    addOutgoingReference(outgoingReference) {
+        if (!this.outgoingReferences.has(outgoingReference)) {
+            this.outgoingReferences.add(outgoingReference);
+            outgoingReference.setSource(this);
+        }
+    }
+    getNumberOfLinesOfCode() {
+        return this.numberOfLinesOfCode;
+    }
+    setNumberOfLinesOfCode(numberOfLinesOfCode) {
+        this.numberOfLinesOfCode = numberOfLinesOfCode;
+    }
+    getOutgoingInvocations() {
+        return this.outgoingInvocations;
+    }
+    addOutgoingInvocation(outgoingInvocation) {
+        if (!this.outgoingInvocations.has(outgoingInvocation)) {
+            this.outgoingInvocations.add(outgoingInvocation);
+            outgoingInvocation.setSender(this);
+        }
+    }
+    getAccesses() {
+        return this.accesses;
+    }
+    addAccess(access) {
+        if (!this.accesses.has(access)) {
+            this.accesses.add(access);
+            access.setAccessor(this);
+        }
+    }
+    getTypes() {
+        return this.childrenTypes;
+    }
+    addType(childType) {
+        if (!this.childrenTypes.has(childType)) {
+            this.childrenTypes.add(childType);
+            childType.setParentContainerEntity(this);
+        }
+    }
+    getFunctions() {
+        return this.childrenFunctions;
+    }
+    addFunction(childFunction) {
+        if (!this.childrenFunctions.has(childFunction)) {
+            this.childrenFunctions.add(childFunction);
+            childFunction.setParentContainerEntity(this);
+        }
+    }
+    getVariables() {
+        return this.variables;
+    }
+    addVariable(variable) {
+        if (!this.variables.has(variable)) {
+            this.variables.add(variable);
+            variable.setParentContainerEntity(this);
+        }
+    }
+    getJSON() {
+        const mse = new famix_JSON_exporter_1.FamixJSONExporter("ContainerEntity", this);
+        this.addPropertiesToExporter(mse);
+        return mse.getJSON();
+    }
+    addPropertiesToExporter(exporter) {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("parentContainerEntity", this.getParentContainerEntity());
+        exporter.addProperty("childrenContainerEntities", this.getChildrenContainerEntities());
+        exporter.addProperty("cyclomaticComplexity", this.getCyclomaticComplexity());
+        exporter.addProperty("numberOfStatements", this.getNumberOfStatements());
+        exporter.addProperty("outgoingReferences", this.getOutgoingReferences());
+        exporter.addProperty("numberOfLinesOfCode", this.getNumberOfLinesOfCode());
+        exporter.addProperty("outgoingInvocations", this.getOutgoingInvocations());
+        exporter.addProperty("accesses", this.getAccesses());
+        exporter.addProperty("types", this.getTypes());
+        exporter.addProperty("functions", this.getFunctions());
+        exporter.addProperty("variables", this.getVariables());
+    }
+}
+exports.ContainerEntity = ContainerEntity;