odata2-lib/odata-core/src/main/java/org/apache/olingo/odata2/core/edm/EdmImpl.java

/*******************************************************************************
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 ******************************************************************************/
package org.apache.olingo.odata2.core.edm;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.olingo.odata2.api.edm.Edm;
import org.apache.olingo.odata2.api.edm.EdmAssociation;
import org.apache.olingo.odata2.api.edm.EdmComplexType;
import org.apache.olingo.odata2.api.edm.EdmEntityContainer;
import org.apache.olingo.odata2.api.edm.EdmEntitySet;
import org.apache.olingo.odata2.api.edm.EdmEntityType;
import org.apache.olingo.odata2.api.edm.EdmException;
import org.apache.olingo.odata2.api.edm.EdmFunctionImport;
import org.apache.olingo.odata2.api.edm.EdmServiceMetadata;
import org.apache.olingo.odata2.api.edm.FullQualifiedName;
import org.apache.olingo.odata2.api.exception.ODataException;

/**
 *  
 */
public abstract class EdmImpl implements Edm {

  private Map<String, EdmEntityContainer> edmEntityContainers;
  private Map<FullQualifiedName, EdmEntityType> edmEntityTypes;
  private Map<FullQualifiedName, EdmComplexType> edmComplexTypes;
  private Map<FullQualifiedName, EdmAssociation> edmAssociations;
  private Map<String, String> aliasToNamespaceInfo;
  private List<EdmEntitySet> edmEntitySets;
  private List<EdmFunctionImport> edmFunctionImports;

  protected EdmServiceMetadata edmServiceMetadata;

  public EdmImpl(final EdmServiceMetadata edmServiceMetadata) {
    edmEntityContainers = new HashMap<String, EdmEntityContainer>();
    edmEntityTypes = new HashMap<FullQualifiedName, EdmEntityType>();
    edmComplexTypes = new HashMap<FullQualifiedName, EdmComplexType>();
    edmAssociations = new HashMap<FullQualifiedName, EdmAssociation>();
    this.edmServiceMetadata = edmServiceMetadata;
  }

  @Override
  public EdmEntityContainer getEntityContainer(final String name) throws EdmException {
    if (edmEntityContainers.containsKey(name)) {
      return edmEntityContainers.get(name);
    }

    EdmEntityContainer edmEntityContainer = null;

    try {
      edmEntityContainer = createEntityContainer(name);
      if (edmEntityContainer != null) {
        if (name == null && edmEntityContainers.containsKey(edmEntityContainer.getName())) {
          // ensure that the same default entity container is stored in the HashMap under null and its name
          edmEntityContainer = edmEntityContainers.get(edmEntityContainer.getName());
          edmEntityContainers.put(name, edmEntityContainer);
        } else if (edmEntityContainers.containsKey(null) && edmEntityContainers.get(null) != null
            && name.equals(edmEntityContainers.get(null).getName())) {
          // ensure that the same default entity container is stored in the HashMap under null and its name
          edmEntityContainer = edmEntityContainers.get(null);
          edmEntityContainers.put(name, edmEntityContainer);
        } else {
          edmEntityContainers.put(name, edmEntityContainer);
        }
      }
    } catch (EdmException e) {
      throw e;
    } catch (ODataException e) {
      throw new EdmException(EdmException.COMMON, e);
    }

    return edmEntityContainer;
  }

  @Override
  public EdmEntityType getEntityType(final String namespaceOrAlias, final String name) throws EdmException {
    String finalNamespace = getNamespaceForAlias(namespaceOrAlias);

    FullQualifiedName fqName = new FullQualifiedName(finalNamespace, name);
    if (edmEntityTypes.containsKey(fqName)) {
      return edmEntityTypes.get(fqName);
    }

    EdmEntityType edmEntityType = null;

    try {
      edmEntityType = createEntityType(fqName);
      if (edmEntityType != null) {
        edmEntityTypes.put(fqName, edmEntityType);
      }
    } catch (EdmException e) {
      throw e;
    } catch (ODataException e) {
      throw new EdmException(EdmException.COMMON, e);
    }

    return edmEntityType;
  }

  private String getNamespaceForAlias(final String namespaceOrAlias) throws EdmException {
    if (aliasToNamespaceInfo == null) {
      try {
        aliasToNamespaceInfo = createAliasToNamespaceInfo();
        if (aliasToNamespaceInfo == null) {
          aliasToNamespaceInfo = new HashMap<String, String>();
        }
      } catch (EdmException e) {
        throw e;
      } catch (ODataException e) {
        throw new EdmException(EdmException.COMMON, e);
      }
    }
    String namespace = aliasToNamespaceInfo.get(namespaceOrAlias);
    // If not contained in info it must be a namespace
    if (namespace == null) {
      namespace = namespaceOrAlias;
    }
    return namespace;
  }

  @Override
  public EdmComplexType getComplexType(final String namespaceOrAlias, final String name) throws EdmException {
    String finalNamespace = getNamespaceForAlias(namespaceOrAlias);
    FullQualifiedName fqName = new FullQualifiedName(finalNamespace, name);
    if (edmComplexTypes.containsKey(fqName)) {
      return edmComplexTypes.get(fqName);
    }

    EdmComplexType edmComplexType = null;

    try {
      edmComplexType = createComplexType(fqName);
      if (edmComplexType != null) {
        edmComplexTypes.put(fqName, edmComplexType);
      }
    } catch (EdmException e) {
      throw e;
    } catch (ODataException e) {
      throw new EdmException(EdmException.COMMON, e);
    }

    return edmComplexType;
  }

  @Override
  public EdmAssociation getAssociation(final String namespaceOrAlias, final String name) throws EdmException {
    String finalNamespace = getNamespaceForAlias(namespaceOrAlias);
    FullQualifiedName fqName = new FullQualifiedName(finalNamespace, name);
    if (edmAssociations.containsKey(fqName)) {
      return edmAssociations.get(fqName);
    }

    EdmAssociation edmAssociation = null;

    try {
      edmAssociation = createAssociation(fqName);
      if (edmAssociation != null) {
        edmAssociations.put(fqName, edmAssociation);
      }
    } catch (EdmException e) {
      throw e;
    } catch (ODataException e) {
      throw new EdmException(EdmException.COMMON, e);
    }

    return edmAssociation;
  }

  @Override
  public EdmServiceMetadata getServiceMetadata() {
    return edmServiceMetadata;
  }

  @Override
  public EdmEntityContainer getDefaultEntityContainer() throws EdmException {
    return getEntityContainer(null);
  }

  @Override
  public List<EdmEntitySet> getEntitySets() throws EdmException {
    try {
      if (edmEntitySets == null) {
        edmEntitySets = createEntitySets();
      }
    } catch (EdmException e) {
      throw e;
    } catch (ODataException e) {
      throw new EdmException(EdmException.COMMON, e);
    }
    return edmEntitySets;
  }

  @Override
  public List<EdmFunctionImport> getFunctionImports() throws EdmException {
    try {
      if (edmFunctionImports == null) {
        edmFunctionImports = createFunctionImports();
      }
    } catch (EdmException e) {
      throw e;
    } catch (ODataException e) {
      throw new EdmException(EdmException.COMMON, e);
    }
    return edmFunctionImports;
  }

  protected abstract EdmEntityContainer createEntityContainer(String name) throws ODataException;

  protected abstract EdmEntityType createEntityType(FullQualifiedName fqName) throws ODataException;

  protected abstract EdmComplexType createComplexType(FullQualifiedName fqName) throws ODataException;

  protected abstract EdmAssociation createAssociation(FullQualifiedName fqName) throws ODataException;

  protected abstract List<EdmEntitySet> createEntitySets() throws ODataException;

  protected abstract List<EdmFunctionImport> createFunctionImports() throws ODataException;

  protected abstract Map<String, String> createAliasToNamespaceInfo() throws ODataException;
}