org.odata4j.edm.EdmSchema Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of odata4j-core
The newest version!
package org.odata4j.edm;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

import org.odata4j.core.ImmutableList;

/**
 * A CSDL Schema element.
 *
 * The Schema element is the root element of a conceptual model definition. It contains definitions
 * for the objects, functions, and containers that make up a conceptual model.
 *
 * @see [msdn] Schema Element (CSDL)
 */
public class EdmSchema extends EdmItem {

  private final String namespace;
  private final String alias;
  private final ImmutableList entityTypes;
  private final ImmutableList complexTypes;
  private final ImmutableList associations;
  private final ImmutableList entityContainers;

  private EdmSchema(String namespace, String alias, ImmutableList entityTypes,
      ImmutableList complexTypes, ImmutableList associations,
      ImmutableList entityContainers,
      EdmDocumentation doc, ImmutableList> annots) {
    super(doc, annots);
    this.namespace = namespace;
    this.alias = alias;
    this.entityTypes = entityTypes;
    this.complexTypes = complexTypes;
    this.associations = associations;
    this.entityContainers = entityContainers;
  }

  public String getNamespace() {
    return namespace;
  }

  public String getAlias() {
    return alias;
  }

  public List getEntityTypes() {
    return entityTypes;
  }

  public List getComplexTypes() {
    return complexTypes;
  }

  public List getAssociations() {
    return associations;
  }

  public List getEntityContainers() {
    return entityContainers;
  }

  public EdmEntityContainer findEntityContainer(String name) {
    for (EdmEntityContainer ec : entityContainers) {
      if (ec.getName().equals(name)) {
        return ec;
      }
    }
    return null;
  }

  public static Builder newBuilder() {
    return new Builder();
  }

  static Builder newBuilder(EdmSchema schema, BuilderContext context) {
    return context.newBuilder(schema, new Builder());
  }

  /** Mutable builder for {@link EdmSchema} objects. */
  public static class Builder extends EdmItem.Builder {

    private String namespace;
    private String alias;
    private final List entityTypes = new ArrayList();
    private final List complexTypes = new ArrayList();
    private final List associations = new ArrayList();
    private final List entityContainers = new ArrayList();

    @Override
    Builder newBuilder(EdmSchema schema, BuilderContext context) {
      List entityContainers = new ArrayList();
      for (EdmEntityContainer entityContainer : schema.entityContainers)
        entityContainers.add(EdmEntityContainer.newBuilder(entityContainer, context));

      List complexTypes = new ArrayList();
      for (EdmComplexType complexType : schema.complexTypes)
        complexTypes.add(EdmComplexType.newBuilder(complexType, context));

      List entityTypes = new ArrayList();
      for (EdmEntityType entityType : schema.entityTypes)
        entityTypes.add(EdmEntityType.newBuilder(entityType, context));

      List associations = new ArrayList();
      for (EdmAssociation association : schema.associations)
        associations.add(EdmAssociation.newBuilder(association, context));

      return new Builder()
          .setNamespace(schema.namespace)
          .setAlias(schema.alias)
          .addEntityTypes(entityTypes)
          .addComplexTypes(complexTypes)
          .addAssociations(associations)
          .addEntityContainers(entityContainers);

    }

    public EdmSchema build() {
      List entityContainers = new ArrayList(this.entityContainers.size());
      for (EdmEntityContainer.Builder entityContainer : this.entityContainers)
        entityContainers.add(entityContainer.build());

      List complexTypes = new ArrayList(this.complexTypes.size());
      for (EdmComplexType.Builder complexType : this.complexTypes)
        complexTypes.add(complexType.build());

      List entityTypes = new ArrayList(this.entityTypes.size());
      for (EdmEntityType.Builder entityType : this.entityTypes)
        entityTypes.add(entityType.build());

      List associations = new ArrayList(this.associations.size());
      for (EdmAssociation.Builder association : this.associations)
        associations.add(association.build());

      return new EdmSchema(namespace, alias,
          ImmutableList.copyOf(entityTypes),
          ImmutableList.copyOf(complexTypes),
          ImmutableList.copyOf(associations),
          ImmutableList.copyOf(entityContainers),
          getDocumentation(),
          ImmutableList.copyOf(getAnnotations()));
    }

    public Builder setNamespace(String namespace) {
      this.namespace = namespace;
      return this;
    }

    public Builder setAlias(String alias) {
      this.alias = alias;
      return this;
    }

    public Builder addEntityTypes(Collection entityTypes) {
      this.entityTypes.addAll(entityTypes);
      return this;
    }

    public Builder addEntityTypes(EdmEntityType.Builder... entityTypes) {
      this.entityTypes.addAll(Arrays.asList(entityTypes));
      return this;
    }

    public Builder addComplexTypes(Collection complexTypes) {
      this.complexTypes.addAll(complexTypes);
      return this;
    }

    public Builder addAssociations(Collection associations) {
      this.associations.addAll(associations);
      return this;
    }

    public Builder addEntityContainers(EdmEntityContainer.Builder... entityContainers) {
      this.entityContainers.addAll(Arrays.asList(entityContainers));
      return this;
    }

    public Builder addEntityContainers(Collection entityContainers) {
      this.entityContainers.addAll(entityContainers);
      return this;
    }

    public Iterable getComplexTypes() {
      return complexTypes;
    }

    public List getEntityTypes() {
      return entityTypes;
    }

    public List getAssociations() {
      return associations;
    }

    public List getEntityContainers() {
      return entityContainers;
    }

    public String getNamespace() {
      return namespace;
    }

    public EdmEntityContainer.Builder findEntityContainer(String name) {
      // TODO share or remove
      for (EdmEntityContainer.Builder ec : entityContainers) {
        if (ec.getName().equals(name)) {
          return ec;
        }
      }
      return null;
    }
  }

}