com.github.loicoudot.java4cpp.model.ClassContent Maven / Gradle / Ivy

Go to download
package com.github.loicoudot.java4cpp.model;

import static com.github.loicoudot.java4cpp.Utils.newArrayList;
import static com.github.loicoudot.java4cpp.Utils.newHashSet;

import java.util.List;
import java.util.Set;

public class ClassContent {
    private ClassModel superclass;
    private final List interfaces = newArrayList();
    private final List nestedClass = newArrayList();
    private final List constructors = newArrayList();
    private final List staticFields = newArrayList();
    private final List methods = newArrayList();
    private final List enumKeys = newArrayList();

    public ClassModel getSuperclass() {
        return superclass;
    }

    public void setSuperclass(ClassModel superclass) {
        this.superclass = superclass;
    }

    public List getInterfaces() {
        return interfaces;
    }

    public void addInterface(ClassModel interfaceModel) {
        interfaces.add(interfaceModel);
    }

    public List getNestedClass() {
        return nestedClass;
    }

    public void addNestedClass(ClassModel nestedClassModel) {
        nestedClass.add(nestedClassModel);
    }

    public List getConstructors() {
        return constructors;
    }

    public void addConstructor(ConstructorModel constructorModel) {
        constructors.add(constructorModel);
    }

    public List getStaticFields() {
        return staticFields;
    }

    public void addField(FieldModel fieldModel) {
        staticFields.add(fieldModel);
    }

    public List getMethods() {
        return methods;
    }

    public void addMethod(MethodModel methodModel) {
        methods.add(methodModel);
    }

    public List getEnumKeys() {
        return enumKeys;
    }

    public void addEnumKey(String key) {
        enumKeys.add(key);
    }

    public Set getIncludes() {
        Set includes = newHashSet();
        for (ClassModel nested : getNestedClass()) {
            includes.addAll(nested.getContent().getIncludes());
        }
        for (ConstructorModel constructor : getConstructors()) {
            for (ClassModel parameter : constructor.getParameters()) {
                includes.addAll(parameter.getType().getIncludes());
            }
        }
        for (FieldModel field : getStaticFields()) {
            includes.addAll(field.getType().getType().getIncludes());
        }
        for (MethodModel method : getMethods()) {
            includes.addAll(method.getReturnType().getType().getIncludes());
            for (ClassModel parameter : method.getParameters()) {
                includes.addAll(parameter.getType().getIncludes());
            }
        }
        return includes;
    }

    public Set getDependencies() {
        Set dependencies = newHashSet();
        if (superclass != null) {
            dependencies.add(superclass);
        }
        for (ClassModel interfaze : getInterfaces()) {
            dependencies.add(interfaze);
        }
        for (ClassModel nested : getNestedClass()) {
            dependencies.addAll(nested.getContent().getDependencies());
        }
        for (ConstructorModel constructor : getConstructors()) {
            for (ClassModel parameter : constructor.getParameters()) {
                dependencies.addAll(parameter.getType().getDependencies());
            }
        }
        for (FieldModel field : getStaticFields()) {
            dependencies.addAll(field.getType().getType().getDependencies());
        }
        for (MethodModel method : getMethods()) {
            dependencies.addAll(method.getReturnType().getType().getDependencies());
            for (ClassModel parameter : method.getParameters()) {
                dependencies.addAll(parameter.getType().getDependencies());
            }
        }
        return dependencies;
    }
}