org.kevoree.modeling.ast.MModelClass Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of dsl Show documentation
The newest version!
package org.kevoree.modeling.ast;

import java.util.*;

public class MModelClass extends MModelClassifier {

    //public int globalIndex = 0;

    private Map attributes = new HashMap();
    private Map references = new HashMap();
    private Map parents = new HashMap();
    private Map operations = new HashMap();

    private Map inputs = new HashMap();
    private Map outputs = new HashMap();
    
    private MModelDependencies dependencies = null;

    public MModelClass(String name) {
        this.name = name;
    }

    public boolean isInferred() {
        return this.inference != null;
    }

    private String inference = null;
    private Long temporalResolution = null;
    private Boolean canHaveInstance = true;

    public Boolean getCanHaveInstance() {
        return canHaveInstance;
    }

    public void setCanHaveInstance(Boolean instance) {
        this.canHaveInstance = instance;
    }

    public Long getTemporalLimit() {
        return temporalLimit;
    }

    public void setTemporalLimit(Long temporalLimit) {
        this.temporalLimit = temporalLimit;
    }

    public Long getTemporalResolution() {
        return temporalResolution;
    }

    public void setTemporalResolution(Long temporalResolution) {
        this.temporalResolution = temporalResolution;
    }

    public String getInference() {
        return inference;
    }

    public void setInference(String inference) {
        this.inference = inference;
    }

    private Long temporalLimit = null;

    public void addAttribute(MModelAttribute att) {
        attributes.put(att.getName(), att);
    }

    public Collection getAttributes() {
        HashMap collected = new HashMap();
        HashMap passed = new HashMap();
        deep_collect_atts(collected, passed);
        for (String collectedKey : collected.keySet()) {
            if (!attributes.containsKey(collectedKey)) {
                attributes.put(collectedKey, collected.get(collectedKey).clone());
            }
        }
        return attributes.values();
    }

    private void deep_collect_atts(HashMap collector, HashMap passed) {
        if (passed.containsKey(this.getName())) {
            return;
        } else {
            for (String key : attributes.keySet()) {
                if (!collector.containsKey(key)) {
                    collector.put(key, attributes.get(key));
                }
            }
            passed.put(getName(), this);
            for (MModelClass parent : getParents()) {
                parent.deep_collect_atts(collector, passed);
            }
        }
    }

    public void addReference(MModelRelation ref) {
        references.put(ref.getName(), ref);
    }

    public void addDependency(MModelDependency el) {
        if (dependencies == null) {
            dependencies = new MModelDependencies("dependencies", null);
        }
        dependencies.dependencies.put(el.getName(), el);
    }

    public MModelDependencies dependencies() {
        return dependencies;
    }

    public MModelDependency[] getDependencies() {
        MModelDependency[] flat = dependencies.dependencies.values().toArray(new MModelDependency[dependencies.dependencies.size()]);
        Arrays.sort(flat, new Comparator() {
            @Override
            public int compare(MModelDependency o1, MModelDependency o2) {
                return o1.getIndex() - o2.getIndex();
            }
        });
        return flat;
    }

    public void addInput(MModelInput el) {
        inputs.put(el.getName(), el);
    }

    public Collection getInputs() {
        return inputs.values();
    }

    public void addOutput(MModelOutput el) {
        outputs.put(el.getName(), el);
    }

    public MModelOutput[] getOutputs() {
        MModelOutput[] flat = outputs.values().toArray(new MModelOutput[outputs.size()]);
        Arrays.sort(flat, new Comparator() {
            @Override
            public int compare(MModelOutput o1, MModelOutput o2) {
                return o1.getIndex() - o2.getIndex();
            }
        });
        return flat;
    }

    public boolean multipleOutput() {
        return this.getOutputs().length > 1;
    }

    public Collection getReferences() {
        HashMap collected = new HashMap();
        HashMap passed = new HashMap();
        deep_collect_refs(collected, passed);
        for (String collectedKey : collected.keySet()) {
            if (!references.containsKey(collectedKey)) {
                references.put(collectedKey, collected.get(collectedKey).clone());
            }
        }
        return references.values();
    }

    private void deep_collect_refs(HashMap collector, HashMap passed) {
        if (passed.containsKey(this.getName())) {
            return;
        } else {
            for (String key : references.keySet()) {
                if (!collector.containsKey(key)) {
                    collector.put(key, references.get(key));
                }
            }
            passed.put(getName(), this);
            for (MModelClass parent : getParents()) {
                parent.deep_collect_refs(collector, passed);
            }
        }
    }

    public void addParent(MModelClass cls) {
        parents.put(cls.getName(), cls);
    }

    public Collection getParents() {
        return parents.values();
    }

    public Collection getOperations() {
        HashMap collected = new HashMap();
        deep_collect_ops(collected, new HashMap());
        for (String collectedKey : collected.keySet()) {
            if (!operations.containsKey(collectedKey)) {
                operations.put(collectedKey, collected.get(collectedKey).clone());
            }
        }
        return operations.values();
    }

    private void deep_collect_ops(HashMap collector, HashMap passed) {
        if (!passed.containsKey(this.getName())) {
            for (String key : operations.keySet()) {
                if (!collector.containsKey(key)) {
                    collector.put(key, operations.get(key));
                }
            }
            passed.put(getName(), this);
            for (MModelClass parent : getParents()) {
                parent.deep_collect_ops(collector, passed);
            }
        }
    }

    public void addOperation(MModelOperation operation) {
        this.operations.put(operation.getName(), operation);
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("class ");
        sb.append(getPack() + "." + getName());
        sb.append(", parent:");
        sb.append(getParents());
        sb.append("{\n \tattributes{\n");
        for (MModelAttribute att : attributes.values()) {
            sb.append("\t\t" + att.getName());
            sb.append(":");
            sb.append(att.getType());
            sb.append("\n");
        }
        sb.append("\t}\n");
        sb.append("\treferences:{\n");
        for (MModelRelation att : references.values()) {
            sb.append("\t\t" + att.getName());
            sb.append(":");
            sb.append(att.getType().getName());
            if (att.getOpposite() != null) {
                sb.append(" opposite ");
                sb.append(att.getOpposite());
            }
            sb.append("\n");
        }
        sb.append("\t}\n\tfunctions:{\n");
        for (MModelOperation op : operations.values()) {
            sb.append("\t\t" + op.getName());
            sb.append("(");
            boolean isFirst = true;
            for (MModelOperationParam param : op.inputParams) {
                if (!isFirst) {
                    sb.append(", ");
                }
                sb.append(param.getName());
                sb.append(" : ");
                sb.append(param.getType());
                isFirst = false;
            }
            sb.append(")");
            if (op.getReturnType() != null) {
                sb.append(":");
                sb.append(op.getReturnType());
            }
            sb.append("\n");
        }
        sb.append("\t}\n}\n");
        return sb.toString();
    }

    public boolean containsDependencies() {
        return this.dependencies != null && this.dependencies.dependencies.size() > 0;
    }
}