Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright 2013 SAP AG Licensed 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 com.sap.core.odata.core.edm.parser;
 
 import java.util.List;
 import java.util.Map;
 
 
 
 public class EdmParser {
 
   private Map<StringStringaliasNamespaceMap = new HashMap<StringString>();
   private Map<StringStringnamespaceMap;
   private String currentNamespace;
   private final String DEFAULT_NAMESPACE = "";
 
   public DataServices readMetadata(final XMLStreamReader readerfinal boolean validate)
       throws EntityProviderException {
     try {
       initialize();
       DataServices dataServices = new DataServices();
       List<Schemaschemas = new ArrayList<Schema>();
 
       while (reader.hasNext()
           && !(reader.isEndElement() && ..equals(reader.getNamespaceURI()) && ..equals(reader.getLocalName()))) {
         reader.next();
         if (reader.isStartElement()) {
           extractNamespaces(reader);
           if (..equals(reader.getLocalName())) {
             schemas.add(readSchema(reader));
           } else if (..equals(reader
               .getLocalName())) {
             dataServices.setDataServiceVersion(reader.getAttributeValue(."DataServiceVersion"));
           }
         }
       }
       if (validate) {
         validate();
       }
       dataServices.setSchemas(schemas);
       reader.close();
      return dataServices;
    } catch (XMLStreamException e) {
    }
  }
    Schema schema = new Schema();
    List<ComplexTypecomplexTypes = new ArrayList<ComplexType>();
    List<EntityTypeentityTypes = new ArrayList<EntityType>();
    List<Associationassociations = new ArrayList<Association>();
    List<EntityContainerentityContainers = new ArrayList<EntityContainer>();
    List<AnnotationElementannotationElements = new ArrayList<AnnotationElement>();
     = schema.getNamespace();
    while (reader.hasNext() && !(reader.isEndElement() && ..equals(reader.getNamespaceURI()) && ..equals(reader.getLocalName()))) {
      reader.next();
      if (reader.isStartElement()) {
        extractNamespaces(reader);
         = reader.getLocalName();
          entityTypes.add(readEntityType(reader));
          complexTypes.add(readComplexType(reader));
          associations.add(readAssociation(reader));
          entityContainers.add(readEntityContainer(reader));
        } else {
          annotationElements.add(readAnnotationElement(reader));
        }
      }
    }
    if (schema.getAlias() != null) {
      .put(schema.getAlias(), schema.getNamespace());
    }
    schema.setEntityTypes(entityTypes).setComplexTypes(complexTypes).setAssociations(associations).setEntityContainers(entityContainers).setAnnotationElements(annotationElements);
    return schema;
  }
    EntityContainer container = new EntityContainer();
    List<EntitySetentitySets = new ArrayList<EntitySet>();
    List<AssociationSetassociationSets = new ArrayList<AssociationSet>();
    List<FunctionImportfunctionImports = new ArrayList<FunctionImport>();
    List<AnnotationElementannotationElements = new ArrayList<AnnotationElement>();
    container.setName(reader.getAttributeValue(null.));
    if (reader.getAttributeValue(."IsDefaultEntityContainer") != null) {
      container.setDefaultEntityContainer("true".equalsIgnoreCase(reader.getAttributeValue(."IsDefaultEntityContainer")));
    }
    while (reader.hasNext() && !(reader.isEndElement() && ..equals(reader.getNamespaceURI()) && ..equals(reader.getLocalName()))) {
      reader.next();
      if (reader.isStartElement()) {
        extractNamespaces(reader);
         = reader.getLocalName();
          entitySets.add(readEntitySet(reader));
          associationSets.add(readAssociationSet(reader));
          functionImports.add(readFunctionImport(reader));
        } else {
          annotationElements.add(readAnnotationElement(reader));
        }
      }
    }
    container.setEntitySets(entitySets).setAssociationSets(associationSets).setFunctionImports(functionImports).setAnnotationElements(annotationElements);
    .put(new FullQualifiedName(container.getName()), container);
    return container;
  }
    FunctionImport function = new FunctionImport();
    List<FunctionImportParameterfunctionParameters = new ArrayList<FunctionImportParameter>();
    List<AnnotationElementannotationElements = new ArrayList<AnnotationElement>();
    function.setName(reader.getAttributeValue(null.));
    ReturnType returnType = new ReturnType();
    String returnTypeString = reader.getAttributeValue(null.);
    if (returnTypeString != null) {
      if (returnTypeString.startsWith("Collection") || returnTypeString.startsWith("collection")) {
        returnType.setMultiplicity(.);
        returnTypeString = returnTypeString.substring(returnTypeString.indexOf("(") + 1, returnTypeString.length() - 1);
        if (function.getEntitySet() == null) {
          //				throw new EntityProviderException(EntityProviderException.MISSING_ATTRIBUTE.addContent("EntitySet");
        }
      }
      FullQualifiedName fqName = extractFQName(returnTypeString);
      returnType.setTypeName(fqName);
      function.setReturnType(returnType);
    }
    while (reader.hasNext() && !(reader.isEndElement() && ..equals(reader.getNamespaceURI()) && ..equals(reader.getLocalName()))) {
      reader.next();
      if (reader.isStartElement()) {
        extractNamespaces(reader);
         = reader.getLocalName();
          functionParameters.add(readFunctionImportParameter(reader));
        } else {
          annotationElements.add(readAnnotationElement(reader));
        }
      }
    }
    function.setParameters(functionParameters).setAnnotationElements(annotationElements);
    return function;
  }
    FunctionImportParameter functionParameter = new FunctionImportParameter();
    List<AnnotationElementannotationElements = new ArrayList<AnnotationElement>();
    functionParameter.setName(reader.getAttributeValue(null.));
    String type = reader.getAttributeValue(null.);
    if (type == null) {
    }
    functionParameter.setType(EdmSimpleTypeKind.valueOf(extractFQName(type).getName()));
    functionParameter.setFacets(readFacets(reader));
    functionParameter.setAnnotationAttributes(readAnnotationAttribute(reader));
    while (reader.hasNext() && !(reader.isEndElement() && ..equals(reader.getNamespaceURI()) && ..equals(reader.getLocalName()))) {
      reader.next();
      if (reader.isStartElement()) {
        extractNamespaces(reader);
        annotationElements.add(readAnnotationElement(reader));
      }
    }
    functionParameter.setAnnotationElements(annotationElements);
    return functionParameter;
  }
    AssociationSet associationSet = new AssociationSet();
    List<AnnotationElementannotationElements = new ArrayList<AnnotationElement>();
    associationSet.setName(reader.getAttributeValue(null.));
    String association = reader.getAttributeValue(null.);
    if (association != null) {
      associationSet.setAssociation(extractFQName(association));
    } else {
    }
    associationSet.setAnnotationAttributes(readAnnotationAttribute(reader));
    while (reader.hasNext() && !(reader.isEndElement() && ..equals(reader.getNamespaceURI()) && ..equals(reader.getLocalName()))) {
      reader.next();
      if (reader.isStartElement()) {
        extractNamespaces(reader);
         = reader.getLocalName();
          AssociationSetEnd associationSetEnd = new AssociationSetEnd();
          associationSetEnd.setEntitySet(reader.getAttributeValue(null.));
          associationSetEnd.setRole(reader.getAttributeValue(null.));
          ends.add(associationSetEnd);
        } else {
          annotationElements.add(readAnnotationElement(reader));
        }
      }
    }
    if (ends.size() != 2) {
      throw new EntityProviderException(..addContent("Count of AssociationSet ends should be 2"));
    } else {
      associationSet.setEnd1(ends.get(0)).setEnd2(ends.get(1));
    }
    associationSet.setAnnotationElements(annotationElements);
    return associationSet;
  }
    EntitySet entitySet = new EntitySet();
    List<AnnotationElementannotationElements = new ArrayList<AnnotationElement>();
    entitySet.setName(reader.getAttributeValue(null.));
    String entityType = reader.getAttributeValue(null.);
    if (entityType != null) {
      FullQualifiedName fqName = extractFQName(entityType);
      entitySet.setEntityType(fqName);
    } else {
    }
    while (reader.hasNext() && !(reader.isEndElement() && ..equals(reader.getNamespaceURI()) && ..equals(reader.getLocalName()))) {
      reader.next();
      if (reader.isStartElement()) {
        extractNamespaces(reader);
        annotationElements.add(readAnnotationElement(reader));
      }
    }
    entitySet.setAnnotationElements(annotationElements);
    return entitySet;
  }
    Association association = new Association();
    association.setName(reader.getAttributeValue(null.));
    List<AssociationEndassociationEnds = new ArrayList<AssociationEnd>();
    List<AnnotationElementannotationElements = new ArrayList<AnnotationElement>();
    while (reader.hasNext() && !(reader.isEndElement() && ..equals(reader.getNamespaceURI()) && ..equals(reader.getLocalName()))) {
      reader.next();
      if (reader.isStartElement()) {
        extractNamespaces(reader);
         = reader.getLocalName();
          associationEnds.add(readAssociationEnd(reader));
          association.setReferentialConstraint(readReferentialConstraint(reader));
        } else {
          annotationElements.add(readAnnotationElement(reader));
        }
      }
    }
    if (associationEnds.size() < 2 && associationEnds.size() > 2) {
      throw new EntityProviderException(..addContent("Count of association ends should be 2"));
    }
    association.setEnd1(associationEnds.get(0)).setEnd2(associationEnds.get(1)).setAnnotationElements(annotationElements);
    .put(new FullQualifiedName(association.getName()), association);
    return association;
  }
    ReferentialConstraint refConstraint = new ReferentialConstraint();
    List<AnnotationElementannotationElements = new ArrayList<AnnotationElement>();
    refConstraint.setAnnotationAttributes(readAnnotationAttribute(reader));
      reader.next();
      if (reader.isStartElement()) {
        extractNamespaces(reader);
         = reader.getLocalName();
          refConstraint.setPrincipal(readReferentialConstraintRole(reader));
          refConstraint.setDependent(readReferentialConstraintRole(reader));
        } else {
          annotationElements.add(readAnnotationElement(reader));
        }
      }
    }
    refConstraint.setAnnotationElements(annotationElements);
    return refConstraint;
  }
    List<PropertyRefpropertyRefs = new ArrayList<PropertyRef>();
    List<AnnotationElementannotationElements = new ArrayList<AnnotationElement>();
    while (reader.hasNext() && !(reader.isEndElement() && ..equals(reader.getNamespaceURI())
      reader.next();
      if (reader.isStartElement()) {
        extractNamespaces(reader);
         = reader.getLocalName();
          propertyRefs.add(readPropertyRef(reader));
        } else {
          annotationElements.add(readAnnotationElement(reader));
        }
      }
    }
    rcRole.setPropertyRefs(propertyRefs).setAnnotationElements(annotationElements);
    return rcRole;
  }
    ComplexType complexType = new ComplexType();
    List<Propertyproperties = new ArrayList<Property>();
    List<AnnotationElementannotationElements = new ArrayList<AnnotationElement>();
    complexType.setName(reader.getAttributeValue(null.));
    while (reader.hasNext() && !(reader.isEndElement() && ..equals(reader.getNamespaceURI()) && ..equals(reader.getLocalName()))) {
      reader.next();
      if (reader.isStartElement()) {
        extractNamespaces(reader);
         = reader.getLocalName();
          properties.add(readProperty(reader));
        } else {
          annotationElements.add(readAnnotationElement(reader));
        }
      }
    }
    complexType.setProperties(properties).setAnnotationElements(annotationElements);
    return complexType;
  }
    EntityType entityType = new EntityType();
    List<Propertyproperties = new ArrayList<Property>();
    List<NavigationPropertynavProperties = new ArrayList<NavigationProperty>();
    List<AnnotationElementannotationElements = new ArrayList<AnnotationElement>();
    Key key = null;
    entityType.setName(reader.getAttributeValue(null.));
    if (hasStream != null) {
      entityType.setHasStream("true".equalsIgnoreCase(hasStream));
    }
    if (reader.getAttributeValue(null.) != null) {
    }
    String baseType = reader.getAttributeValue(null.);
    if (baseType != null) {
      entityType.setBaseType(extractFQName(baseType));
    }
    while (reader.hasNext() && !(reader.isEndElement() && ..equals(reader.getNamespaceURI()) && ..equals(reader.getLocalName()))) {
      reader.next();
      if (reader.isStartElement()) {
         = reader.getLocalName();
          key = readEntityTypeKey(reader);
          properties.add(readProperty(reader));
          navProperties.add(readNavigationProperty(reader));
        } else {
          annotationElements.add(readAnnotationElement(reader));
        }
        extractNamespaces(reader);
      }
    }
    if (entityType.getName() != null) {
      FullQualifiedName fqName = new FullQualifiedName(entityType.getName());
      .put(fqNameentityType);
    }
    entityType.setKey(key).setProperties(properties).setNavigationProperties(navProperties).setAnnotationElements(annotationElements);
    return entityType;
  }
    List<PropertyRefkeys = new ArrayList<PropertyRef>();
    List<AnnotationElementannotationElements = new ArrayList<AnnotationElement>();
    List<AnnotationAttributeannotationAttributes = readAnnotationAttribute(reader);
    while (reader.hasNext() && !(reader.isEndElement() && ..equals(reader.getNamespaceURI()) && ..equals(reader.getLocalName()))) {
      reader.next();
      if (reader.isStartElement()) {
        extractNamespaces(reader);
         = reader.getLocalName();
          keys.add(readPropertyRef(reader));
        } else {
          annotationElements.add(readAnnotationElement(reader));
        }
      }
    }
    return new Key().setKeys(keys).setAnnotationElements(annotationElements).setAnnotationAttributes(annotationAttributes);
  }
    PropertyRef propertyRef = new PropertyRef();
    propertyRef.setName(reader.getAttributeValue(null.));
    List<AnnotationElementannotationElements = new ArrayList<AnnotationElement>();
    while (reader.hasNext() && !(reader.isEndElement() && ..equals(reader.getNamespaceURI()) && ..equals(reader.getLocalName()))) {
      reader.next();
      if (reader.isStartElement()) {
        extractNamespaces(reader);
        annotationElements.add(readAnnotationElement(reader));
      }
    }
    return propertyRef.setAnnotationElements(annotationElements);
  }
    NavigationProperty navProperty = new NavigationProperty();
    List<AnnotationElementannotationElements = new ArrayList<AnnotationElement>();
    navProperty.setName(reader.getAttributeValue(null.));
    if (relationship != null) {
      FullQualifiedName fqName = extractFQName(relationship);
      navProperty.setRelationship(fqName);
    } else {
    }
    while (reader.hasNext() && !(reader.isEndElement() && ..equals(reader.getNamespaceURI()) && ..equals(reader.getLocalName()))) {
      reader.next();
      if (reader.isStartElement()) {
        extractNamespaces(reader);
        annotationElements.add(readAnnotationElement(reader));
      }
    }
    navProperty.setAnnotationElements(annotationElements);
    .add(navProperty);
    return navProperty;
  }
    Property property;
    List<AnnotationElementannotationElements = new ArrayList<AnnotationElement>();
    String type = reader.getAttributeValue(null.);
    if (type == null) {
    }
    FullQualifiedName fqName = extractFQName(type);
    if ("Edm".equals(fqName.getNamespace())) {
      property = readSimpleProperty(readerfqName);
    } else {
      property = readComplexProperty(readerfqName);
    }
    property.setFacets(readFacets(reader));
    while (reader.hasNext() && !(reader.isEndElement() && ..equals(reader.getNamespaceURI()) && ..equals(reader.getLocalName()))) {
      reader.next();
      if (reader.isStartElement()) {
        extractNamespaces(reader);
        annotationElements.add(readAnnotationElement(reader));
      }
    }
    property.setAnnotationElements(annotationElements);
    return property;
  }
  private Property readComplexProperty(final XMLStreamReader readerfinal FullQualifiedName fqNamethrows XMLStreamException {
    ComplexProperty property = new ComplexProperty();
    property.setName(reader.getAttributeValue(null.));
    property.setType(fqName);
    return property;
  }
  private Property readSimpleProperty(final XMLStreamReader readerfinal FullQualifiedName fqNamethrows XMLStreamException {
    SimpleProperty property = new SimpleProperty();
    property.setName(reader.getAttributeValue(null.));
    property.setType(EdmSimpleTypeKind.valueOf(fqName.getName()));
    return property;
  }
  private Facets readFacets(final XMLStreamReader readerthrows XMLStreamException {
    String isFixedLength = reader.getAttributeValue(null.);
    if (isNullable != null || maxLength != null || precision != null || scale != null || isFixedLength != null || isUnicode != null
        || concurrencyMode != null || defaultValue != null || collation != null) {
      Facets facets = new Facets();
      if (isNullable != null) {
        facets.setNullable("true".equalsIgnoreCase(isNullable));
      }
      if (maxLength != null) {
          facets.setMaxLength(.);
        } else {
          facets.setMaxLength(Integer.parseInt(maxLength));
        }
      }
      if (precision != null) {
        facets.setPrecision(Integer.parseInt(precision));
      }
      if (scale != null) {
        facets.setScale(Integer.parseInt(scale));
      }
      if (isFixedLength != null) {
        facets.setFixedLength("true".equalsIgnoreCase(isFixedLength));
      }
      if (isUnicode != null) {
        facets.setUnicode("true".equalsIgnoreCase(isUnicode));
      }
      for (int i = 0; i < EdmConcurrencyMode.values().lengthi++) {
        if (EdmConcurrencyMode.values()[i].name().equalsIgnoreCase(concurrencyMode)) {
          facets.setConcurrencyMode(EdmConcurrencyMode.values()[i]);
        }
      }
      facets.setDefaultValue(defaultValue);
      facets.setCollation(collation);
      return facets;
    } else {
      return null;
    }
  }
    if (targetPath != null || sourcePath != null || nsUri != null || nsPrefix != null || keepInContent != null || contentKind != null) {
      CustomizableFeedMappings feedMapping = new CustomizableFeedMappings();
      if (keepInContent != null) {
        feedMapping.setFcKeepInContent("true".equals(keepInContent));
      }
      for (int i = 0; i < EdmContentKind.values().lengthi++) {
        if (EdmContentKind.values()[i].name().equalsIgnoreCase(contentKind)) {
          feedMapping.setFcContentKind(EdmContentKind.values()[i]);
        }
      }
      feedMapping.setFcTargetPath(targetPath).setFcSourcePath(sourcePath).setFcNsUri(nsUri).setFcNsPrefix(nsPrefix);
      return feedMapping;
    } else {
      return null;
    }
  }
    AssociationEnd associationEnd = new AssociationEnd();
    List<AnnotationElementannotationElements = new ArrayList<AnnotationElement>();
    associationEnd.setRole(reader.getAttributeValue(null.));
    String type = reader.getAttributeValue(null.);
    if (type == null) {
    }
    associationEnd.setType(extractFQName(type));
    associationEnd.setAnnotationAttributes(readAnnotationAttribute(reader));
    while (reader.hasNext() && !(reader.isEndElement() && ..equals(reader.getNamespaceURI()) && ..equals(reader.getLocalName()))) {
      reader.next();
      if (reader.isStartElement()) {
        extractNamespaces(reader);
         = reader.getLocalName();
          OnDelete onDelete = new OnDelete();
          for (int i = 0; i < EdmAction.values().lengthi++) {
            if (EdmAction.values()[i].name().equalsIgnoreCase(reader.getAttributeValue(null.))) {
              onDelete.setAction(EdmAction.values()[i]);
            }
          }
          associationEnd.setOnDelete(onDelete);
        } else {
          annotationElements.add(readAnnotationElement(reader));
        }
      }
    }
    associationEnd.setAnnotationElements(annotationElements);
    return associationEnd;
  }
    AnnotationElement aElement = new AnnotationElement();
    List<AnnotationElementannotationElements = new ArrayList<AnnotationElement>();
    List<AnnotationAttributeannotationAttributes = new ArrayList<AnnotationAttribute>();
    aElement.setName(reader.getLocalName());
    String elementNamespace = reader.getNamespaceURI();
    if (!..equals(elementNamespace)) {
      aElement.setPrefix(reader.getPrefix());
      aElement.setNamespace(elementNamespace);
    }
    for (int i = 0; i < reader.getAttributeCount(); i++) {
      AnnotationAttribute annotationAttribute = new AnnotationAttribute();
      annotationAttribute.setText(reader.getAttributeValue(i));
      annotationAttribute.setName(reader.getAttributeLocalName(i));
      annotationAttribute.setPrefix(reader.getAttributePrefix(i));
      String namespace = reader.getAttributeNamespace(i);
      if (!.equals(namespace)) {
        annotationAttribute.setNamespace(namespace);
      }
      annotationAttributes.add(annotationAttribute);
    }
    aElement.setAttributes(annotationAttributes);
    while (reader.hasNext() && !(reader.isEndElement() && aElement.getName() != null && aElement.getName().equals(reader.getLocalName()))) {
      reader.next();
      if (reader.isStartElement()) {
        annotationElements.add(readAnnotationElement(reader));
      } else if (reader.isCharacters()) {
        aElement.setText(reader.getText());
      }
    }
    if (!annotationElements.isEmpty()) {
      aElement.setChildElements(annotationElements);
    }
    return aElement;
  }
    List<AnnotationAttributeannotationAttributes = new ArrayList<AnnotationAttribute>();
    for (int i = 0; i < reader.getAttributeCount(); i++) {
        annotationAttributes.add(new AnnotationAttribute().setName(reader.getAttributeLocalName(i)).
            setPrefix(reader.getAttributePrefix(i)).setNamespace(reader.getAttributeNamespace(i)).setText(reader.getAttributeValue(i)));
      }
    }
    if (annotationAttributes.isEmpty()) {
      return null;
    }
    return annotationAttributes;
  }
    }
  }
  private void extractNamespaces(final XMLStreamReader readerthrows EntityProviderException {
    int namespaceCount = reader.getNamespaceCount();
    for (int i = 0; i < namespaceCounti++) {
      String namespacePrefix = reader.getNamespacePrefix(i);
      String namespaceUri = reader.getNamespaceURI(i);
      if (namespacePrefix == null || .equals(namespacePrefix)) {
        namespacePrefix = .;
      }
      .put(namespacePrefixnamespaceUri);
    }
  }
  private FullQualifiedName extractFQName(final String name)
      throws EntityProviderException {
    // Looking for the last dot
    String[] names = name.split("\\" + . + "(?=[^\\" + . + "]+$)");
    if (names.length != 2) {
      throw new EntityProviderException(..addContent("Invalid type"));
    } else {
      return new FullQualifiedName(names[0], names[1]);
    }
  }
    String namespace = .get(aliasName.getNamespace());
    FullQualifiedName fqName = new FullQualifiedName(namespacealiasName.getName());
    if (!.containsKey(fqName)) {
      throw new EntityProviderException(..addContent("Invalid Type"));
    }
    return fqName;
  }
  private void validateEntityTypes() throws EntityProviderException {
    for (Map.Entry<FullQualifiedNameEntityTypeentityTypes : .entrySet()) {
      if (entityTypes.getValue() != null && entityTypes.getKey() != null) {
        EntityType entityType = entityTypes.getValue();
        if (entityType.getBaseType() != null) {
          FullQualifiedName baseTypeFQName = entityType.getBaseType();
          EntityType baseEntityType;
          if (!.containsKey(baseTypeFQName)) {
            FullQualifiedName fqName = validateEntityTypeWithAlias(baseTypeFQName);
            baseEntityType = .get(fqName);
          } else {
            baseEntityType = .get(baseTypeFQName);
          }
          if (baseEntityType.getKey() == null) {
            throw new EntityProviderException(..addContent("Missing key for EntityType " + baseEntityType.getName()));