private EdmNavigationProperty.Builder parseEdmNavigationProperty( XMLEventReader2 reader, XMLEvent2 event) { List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); StartElement2 navPropStartElement = event.asStartElement(); String associationName = navPropStartElement.getAttributeByName("Name").getValue(); String relationshipName = navPropStartElement.getAttributeByName("Relationship").getValue(); String fromRoleName = navPropStartElement.getAttributeByName("FromRole").getValue(); String toRoleName = navPropStartElement.getAttributeByName("ToRole").getValue(); while (reader.hasNext()) { event = reader.nextEvent(); if (event.isStartElement()) { EdmAnnotation<?> anElement = getAnnotationElements(event, reader); if (anElement != null) { annotElements.add(anElement); } } if (isEndElement(event, navPropStartElement.getName())) { return EdmNavigationProperty.newBuilder(associationName) .setRelationshipName(relationshipName) .setFromToName(fromRoleName, toRoleName) .setAnnotations(getAnnotations(navPropStartElement)) .setAnnotationElements(annotElements); } } throw new UnsupportedOperationException(); }
private EdmFunctionImport.Builder parseEdmFunctionImport( XMLEventReader2 reader, String schemaNamespace, StartElement2 functionImportElement) { String name = functionImportElement.getAttributeByName("Name").getValue(); String entitySet = getAttributeValueIfExists(functionImportElement, "EntitySet"); Attribute2 returnTypeAttr = functionImportElement.getAttributeByName("ReturnType"); String returnType = returnTypeAttr != null ? returnTypeAttr.getValue() : null; List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); // strict parsing boolean isCollection = returnType != null && returnType.matches("^Collection\\(.*\\)$"); if (isCollection) { returnType = returnType.substring(11, returnType.length() - 1); } String httpMethod = getAttributeValueIfExists(functionImportElement, new QName2(NS_METADATA, "HttpMethod")); List<EdmFunctionParameter.Builder> parameters = new ArrayList<EdmFunctionParameter.Builder>(); while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); if (event.isStartElement()) { if (isElement( event, EDM2006_PARAMETER, EDM2007_PARAMETER, EDM2008_1_PARAMETER, EDM2008_9_PARAMETER, EDM2009_8_PARAMETER, EDM2009_11_PARAMETER)) { StartElement2 paramStartElement = event.asStartElement(); EdmFunctionParameter.Builder functionParameter = parseEdmFunctionParameter(reader, paramStartElement); parameters.add(functionParameter); } else { EdmAnnotation<?> anElement = getAnnotationElements(event, reader); if (anElement != null) { annotElements.add(anElement); } } } if (isEndElement(event, functionImportElement.getName())) { return EdmFunctionImport.newBuilder() .setName(name) .setEntitySetName(entitySet) .setReturnTypeName(returnType) .setIsCollection(isCollection) .setHttpMethod(httpMethod) .addParameters(parameters) .setAnnotations(getAnnotations(functionImportElement)) .setAnnotationElements(annotElements); } } throw new UnsupportedOperationException(); }
private EdmReferentialConstraint.Builder parseEdmConstraintElement( XMLEventReader2 tmpReader, StartElement2 constraintElement) { List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); List<String> principalPropertyRef = new ArrayList<String>(); List<String> dependentPropertyRef = new ArrayList<String>(); String principalRole = null; String dependentRole = null; while (tmpReader.hasNext()) { XMLEvent2 event = tmpReader.nextEvent(); if (event.isStartElement()) { if (isElement( event, EDM2006_PRINCIPAL, EDM2007_PRINCIPAL, EDM2008_1_PRINCIPAL, EDM2008_9_PRINCIPAL, EDM2009_8_PRINCIPAL, EDM2009_11_PRINCIPAL)) { StartElement2 principalElement = event.asStartElement(); principalPropertyRef = parsePropertyRef(tmpReader, principalElement); principalRole = principalElement.getAttributeByName("Role").getValue(); } else if (isElement( event, EDM2006_DEPENDENT, EDM2007_DEPENDENT, EDM2008_1_DEPENDENT, EDM2008_9_DEPENDENT, EDM2009_8_DEPENDENT, EDM2009_11_DEPENDENT)) { StartElement2 dependentElement = event.asStartElement(); dependentPropertyRef = parsePropertyRef(tmpReader, dependentElement); dependentRole = dependentElement.getAttributeByName("Role").getValue(); } else { EdmAnnotation<?> anElement = getAnnotationElements(event, tmpReader); if (anElement != null) { annotElements.add(anElement); } } } if (isEndElement(event, constraintElement.getName())) { return EdmReferentialConstraint.newBuilder() .setPrincipalRole(principalRole) .setDependentRole(dependentRole) .addDependentReferences(dependentPropertyRef) .addPrincipalReferences(principalPropertyRef) .setAnnotationElements(annotElements) .setAnnotations(getAnnotations(constraintElement)); } } throw new UnsupportedOperationException(); }
private EdmAssociation.Builder parseEdmAssociation( XMLEventReader2 reader, String schemaNamespace, String schemaAlias, StartElement2 associationElement) { String name = associationElement.getAttributeByName("Name").getValue(); List<EdmAssociationEnd.Builder> ends = new ArrayList<EdmAssociationEnd.Builder>(); List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); EdmReferentialConstraint.Builder referentialConstraint = null; while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); if (event.isStartElement()) { if (isElement( event, EDM2006_END, EDM2007_END, EDM2008_1_END, EDM2008_9_END, EDM2009_8_END, EDM2009_11_END)) { EdmAssociationEnd.Builder edmAssociationEnd = parseEdmAssociationEnd(reader, event); ends.add(edmAssociationEnd); } else if (isElement( event, EDM2006_REFCONSTRAINT, EDM2007_REFCONSTRAINT, EDM2008_1_REFCONSTRAINT, EDM2008_9_REFCONSTRAINT, EDM2009_8_REFCONSTRAINT, EDM2009_11_REFCONSTRAINT)) { StartElement2 constraintElement = event.asStartElement(); referentialConstraint = parseEdmConstraintElement(reader, constraintElement); } else { EdmAnnotation<?> anElement = getAnnotationElements(event, reader); if (anElement != null) { annotElements.add(anElement); } } } if (isEndElement(event, associationElement.getName())) { return EdmAssociation.newBuilder() .setNamespace(schemaNamespace) .setAlias(schemaAlias) .setName(name) .setEnds(ends.get(0), ends.get(1)) .setRefConstraint(referentialConstraint == null ? null : referentialConstraint) .setAnnotations(getAnnotations(associationElement)) .setAnnotationElements(annotElements); } } throw new UnsupportedOperationException(); }
private EdmAssociationEnd.Builder parseEdmAssociationEnd( XMLEventReader2 tmpReader, XMLEvent2 event) { List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); StartElement2 endStartElement = event.asStartElement(); String onDeleteAction = null; while (tmpReader.hasNext()) { XMLEvent2 event2 = tmpReader.nextEvent(); if (event2.isStartElement()) { if (isElement( event2, EDM2006_ONDELETE, EDM2007_ONDELETE, EDM2008_1_ONDELETE, EDM2008_9_ONDELETE, EDM2009_8_ONDELETE, EDM2009_11_ONDELETE)) { StartElement2 onDeleteStartElement = event2.asStartElement(); onDeleteAction = onDeleteStartElement.getAttributeByName("Action").getValue(); } else { EdmAnnotation<?> anElement = getAnnotationElements(event2, tmpReader); if (anElement != null) { annotElements.add(anElement); } } } if (isEndElement(event2, endStartElement.getName())) { return EdmAssociationEnd.newBuilder() .setRole(endStartElement.getAttributeByName("Role").getValue()) .setTypeName(endStartElement.getAttributeByName("Type").getValue()) .setMultiplicity( EdmMultiplicity.fromSymbolString( endStartElement.getAttributeByName("Multiplicity").getValue())) .setOnDeleteAction( onDeleteAction == null ? null : EdmOnDeleteAction.fromSymbolString(onDeleteAction)) .setAnnotations(getAnnotations(endStartElement)) .setAnnotationElements(annotElements); } } throw new UnsupportedOperationException(); }
private EdmAssociationSet.Builder parseEdmAssociationSet( XMLEventReader2 reader, String schemaNamespace, StartElement2 associationSetElement) { String name = associationSetElement.getAttributeByName("Name").getValue(); String associationName = associationSetElement.getAttributeByName("Association").getValue(); List<EdmAssociationSetEnd.Builder> ends = new ArrayList<EdmAssociationSetEnd.Builder>(); List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); if (event.isStartElement()) { if (isElement( event, EDM2006_END, EDM2007_END, EDM2008_1_END, EDM2008_9_END, EDM2009_8_END, EDM2009_11_END)) { StartElement2 endStartElement = event.asStartElement(); EdmAssociationSetEnd.Builder assocSetEnd = parseEdmAssociationSetEnd(reader, endStartElement); ends.add(assocSetEnd); } else { EdmAnnotation<?> anElement = getAnnotationElements(event, reader); if (anElement != null) { annotElements.add(anElement); } } } if (isEndElement(event, associationSetElement.getName())) { return EdmAssociationSet.newBuilder() .setName(name) .setAssociationName(associationName) .setEnds(ends.get(0), ends.get(1)) .setAnnotations(getAnnotations(associationSetElement)) .setAnnotationElements(annotElements); } } throw new UnsupportedOperationException(); }
private EdmAssociationSetEnd.Builder parseEdmAssociationSetEnd( XMLEventReader2 reader, StartElement2 endStartElement) { List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); String role = endStartElement.getAttributeByName("Role").getValue(); String entitySetName = endStartElement.getAttributeByName("EntitySet").getValue(); while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); if (event.isStartElement()) { EdmAnnotation<?> anElement = getAnnotationElements(event, reader); if (anElement != null) { annotElements.add(anElement); } } if (isEndElement(event, endStartElement.getName())) { return EdmAssociationSetEnd.newBuilder() .setRoleName(role) .setEntitySetName(entitySetName) .setAnnotations(getAnnotations(endStartElement)) .setAnnotationElements(annotElements); } } throw new UnsupportedOperationException(); }
private EdmFunctionParameter.Builder parseEdmFunctionParameter( XMLEventReader2 reader, StartElement2 paramStartElement) { List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); Attribute2 modeAttribute = paramStartElement.getAttributeByName("Mode"); String nullableS = getAttributeValueIfExists(paramStartElement, "Nullable"); String maxLength = getAttributeValueIfExists(paramStartElement, "MaxLength"); String precision = getAttributeValueIfExists(paramStartElement, "Precision"); String scale = getAttributeValueIfExists(paramStartElement, "Scale"); while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); if (event.isStartElement()) { EdmAnnotation<?> anElement = getAnnotationElements(event, reader); if (anElement != null) { annotElements.add(anElement); } } if (isEndElement(event, paramStartElement.getName())) { return EdmFunctionParameter.newBuilder() .setName(paramStartElement.getAttributeByName("Name").getValue()) .setType( EdmType.newDeferredBuilder( paramStartElement.getAttributeByName("Type").getValue(), dataServices)) .setMode(modeAttribute != null ? Mode.valueOf(modeAttribute.getValue()) : null) .setNullable(nullableS == null ? null : "true".equalsIgnoreCase(nullableS)) .setMaxLength( maxLength == null ? null : maxLength.equals("Max") ? Integer.MAX_VALUE : Integer.parseInt(maxLength)) .setPrecision(precision == null ? null : Integer.parseInt(precision)) .setScale(scale == null ? null : Integer.parseInt(scale)) .setAnnotations(getAnnotations(paramStartElement)) .setAnnotationElements(annotElements); } } throw new UnsupportedOperationException(); }
private EdmComplexType.Builder parseEdmComplexType( XMLEventReader2 reader, String schemaNamespace, StartElement2 complexTypeElement) { String name = complexTypeElement.getAttributeByName("Name").getValue(); String isAbstractS = getAttributeValueIfExists(complexTypeElement, "Abstract"); String baseType = getAttributeValueIfExists(complexTypeElement, "BaseType"); List<EdmProperty.Builder> edmProperties = new ArrayList<EdmProperty.Builder>(); List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); if (event.isStartElement()) { if (isElement( event, EDM2006_PROPERTY, EDM2007_PROPERTY, EDM2008_1_PROPERTY, EDM2008_9_PROPERTY, EDM2009_8_PROPERTY, EDM2009_11_PROPERTY)) { edmProperties.add(parseEdmProperty(reader, event)); } else { EdmAnnotation<?> anElement = getAnnotationElements(event, reader); if (anElement != null) { annotElements.add(anElement); } } } if (isEndElement(event, complexTypeElement.getName())) { EdmComplexType.Builder complexType = EdmComplexType.newBuilder() .setNamespace(schemaNamespace) .setName(name) .setBaseType(baseType) .addProperties(edmProperties) .setAnnotations(getAnnotations(complexTypeElement)) .setAnnotationElements(annotElements); if (isAbstractS != null) complexType.setIsAbstract("true".equals(isAbstractS)); return complexType; } } throw new UnsupportedOperationException(); }
private EdmEntitySet.Builder parseEdmEntitySet( XMLEventReader2 reader, String schemaNamespace, StartElement2 entitySetStartElement) { List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); String name = entitySetStartElement.getAttributeByName("Name").getValue(); String entityTypeName = getAttributeValueIfExists(entitySetStartElement, "EntityType"); while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); if (event.isStartElement()) { EdmAnnotation<?> anElement = getAnnotationElements(event, reader); if (anElement != null) { annotElements.add(anElement); } } if (isEndElement(event, entitySetStartElement.getName())) { return EdmEntitySet.newBuilder() .setName(name) .setEntityTypeName(entityTypeName) .setAnnotations(getAnnotations(entitySetStartElement)) .setAnnotationElements(annotElements); } } throw new UnsupportedOperationException(); }
private EdmEntityType.Builder parseEdmEntityType( XMLEventReader2 reader, String schemaNamespace, String schemaAlias, StartElement2 entityTypeElement) { String name = entityTypeElement.getAttributeByName("Name").getValue(); String hasStreamValue = getAttributeValueIfExists(entityTypeElement, new QName2(NS_METADATA, "HasStream")); Boolean hasStream = hasStreamValue == null ? null : hasStreamValue.equals("true"); String baseType = getAttributeValueIfExists(entityTypeElement, "BaseType"); String isAbstractS = getAttributeValueIfExists(entityTypeElement, "Abstract"); String openTypeValue = getAttributeValueIfExists(entityTypeElement, "OpenType"); Boolean openType = openTypeValue == null ? null : openTypeValue.equals("true"); List<String> keys = new ArrayList<String>(); List<EdmProperty.Builder> edmProperties = new ArrayList<EdmProperty.Builder>(); List<EdmNavigationProperty.Builder> edmNavigationProperties = new ArrayList<EdmNavigationProperty.Builder>(); List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); if (event.isStartElement()) { if (isElement( event, EDM2006_PROPERTYREF, EDM2007_PROPERTYREF, EDM2008_1_PROPERTYREF, EDM2008_9_PROPERTYREF, EDM2009_8_PROPERTYREF, EDM2009_11_PROPERTYREF)) { keys.add(event.asStartElement().getAttributeByName("Name").getValue()); } else if (isElement( event, EDM2006_PROPERTY, EDM2007_PROPERTY, EDM2008_1_PROPERTY, EDM2008_9_PROPERTY, EDM2009_8_PROPERTY, EDM2009_11_PROPERTY)) { edmProperties.add(parseEdmProperty(reader, event)); } else if (isElement( event, EDM2006_NAVIGATIONPROPERTY, EDM2007_NAVIGATIONPROPERTY, EDM2008_1_NAVIGATIONPROPERTY, EDM2008_9_NAVIGATIONPROPERTY, EDM2009_8_NAVIGATIONPROPERTY, EDM2009_11_NAVIGATIONPROPERTY)) { edmNavigationProperties.add(parseEdmNavigationProperty(reader, event)); } else { EdmAnnotation<?> anElement = getAnnotationElements(event, reader); if (anElement != null) { annotElements.add(anElement); } } } if (isEndElement(event, entityTypeElement.getName())) { return EdmEntityType.newBuilder() .setNamespace(schemaNamespace) .setAlias(schemaAlias) .setName(name) .setHasStream(hasStream) .setOpenType(openType) .addKeys(keys) .addProperties(edmProperties) .addNavigationProperties(edmNavigationProperties) .setBaseType(baseType) .setIsAbstract(isAbstractS == null ? null : "true".equals(isAbstractS)) .setAnnotations(getAnnotations(entityTypeElement)) .setAnnotationElements(annotElements); } } throw new UnsupportedOperationException(); }
private EdmEntityContainer.Builder parseEdmEntityContainer( XMLEventReader2 reader, String schemaNamespace, StartElement2 entityContainerElement) { String name = entityContainerElement.getAttributeByName("Name").getValue(); boolean isDefault = "true" .equals( getAttributeValueIfExists( entityContainerElement, new QName2(NS_METADATA, "IsDefaultEntityContainer"))); String lazyLoadingEnabledValue = getAttributeValueIfExists( entityContainerElement, new QName2(NS_EDMANNOTATION, "LazyLoadingEnabled")); Boolean lazyLoadingEnabled = lazyLoadingEnabledValue == null ? null : lazyLoadingEnabledValue.equals("true"); String extendz = getAttributeValueIfExists(entityContainerElement, new QName2("Extends")); List<EdmEntitySet.Builder> edmEntitySets = new ArrayList<EdmEntitySet.Builder>(); List<EdmAssociationSet.Builder> edmAssociationSets = new ArrayList<EdmAssociationSet.Builder>(); List<EdmFunctionImport.Builder> edmFunctionImports = new ArrayList<EdmFunctionImport.Builder>(); List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); if (event.isStartElement()) { if (isElement( event, EDM2006_ENTITYSET, EDM2007_ENTITYSET, EDM2008_1_ENTITYSET, EDM2008_9_ENTITYSET, EDM2009_8_ENTITYSET, EDM2009_11_ENTITYSET)) { EdmEntitySet.Builder entitySet = parseEdmEntitySet(reader, schemaNamespace, event.asStartElement()); edmEntitySets.add(entitySet); } else if (isElement( event, EDM2006_ASSOCIATIONSET, EDM2007_ASSOCIATIONSET, EDM2008_1_ASSOCIATIONSET, EDM2008_9_ASSOCIATIONSET, EDM2009_8_ASSOCIATIONSET, EDM2009_11_ASSOCIATIONSET)) { edmAssociationSets.add( parseEdmAssociationSet(reader, schemaNamespace, event.asStartElement())); } else if (isElement( event, EDM2006_FUNCTIONIMPORT, EDM2007_FUNCTIONIMPORT, EDM2008_1_FUNCTIONIMPORT, EDM2008_9_FUNCTIONIMPORT, EDM2009_8_FUNCTIONIMPORT, EDM2009_11_FUNCTIONIMPORT)) { edmFunctionImports.add( parseEdmFunctionImport(reader, schemaNamespace, event.asStartElement())); } else { EdmAnnotation<?> anElement = getAnnotationElements(event, reader); if (anElement != null) { annotElements.add(anElement); } } } if (isEndElement(event, entityContainerElement.getName())) { return EdmEntityContainer.newBuilder() .setName(name) .setIsDefault(isDefault) .setLazyLoadingEnabled(lazyLoadingEnabled) .setExtendz(extendz) .addEntitySets(edmEntitySets) .addAssociationSets(edmAssociationSets) .addFunctionImports(edmFunctionImports) .setAnnotations(getAnnotations(entityContainerElement)) .setAnnotationElements(annotElements); } } throw new UnsupportedOperationException(); }
private EdmSchema.Builder parseEdmSchema(XMLEventReader2 reader, StartElement2 schemaElement) { String schemaNamespace = schemaElement.getAttributeByName(new QName2("Namespace")).getValue(); String schemaAlias = getAttributeValueIfExists(schemaElement, new QName2("Alias")); final List<EdmEntityType.Builder> edmEntityTypes = new ArrayList<EdmEntityType.Builder>(); List<EdmComplexType.Builder> edmComplexTypes = new ArrayList<EdmComplexType.Builder>(); List<EdmAssociation.Builder> edmAssociations = new ArrayList<EdmAssociation.Builder>(); List<EdmEntityContainer.Builder> edmEntityContainers = new ArrayList<EdmEntityContainer.Builder>(); List<EdmAnnotation<?>> annotElements = new ArrayList<EdmAnnotation<?>>(); while (reader.hasNext()) { XMLEvent2 event = reader.nextEvent(); if (event.isStartElement()) { if (isElement( event, EDM2006_ENTITYTYPE, EDM2007_ENTITYTYPE, EDM2008_1_ENTITYTYPE, EDM2008_9_ENTITYTYPE, EDM2009_8_ENTITYTYPE, EDM2009_11_ENTITYTYPE)) { EdmEntityType.Builder edmEntityType = parseEdmEntityType(reader, schemaNamespace, schemaAlias, event.asStartElement()); edmEntityTypes.add(edmEntityType); } else if (isElement( event, EDM2006_ASSOCIATION, EDM2007_ASSOCIATION, EDM2008_1_ASSOCIATION, EDM2008_9_ASSOCIATION, EDM2009_8_ASSOCIATION, EDM2009_11_ASSOCIATION)) { EdmAssociation.Builder edmAssociation = parseEdmAssociation(reader, schemaNamespace, schemaAlias, event.asStartElement()); edmAssociations.add(edmAssociation); } else if (isElement( event, EDM2006_COMPLEXTYPE, EDM2007_COMPLEXTYPE, EDM2008_1_COMPLEXTYPE, EDM2008_9_COMPLEXTYPE, EDM2009_8_COMPLEXTYPE, EDM2009_11_COMPLEXTYPE)) { EdmComplexType.Builder edmComplexType = parseEdmComplexType(reader, schemaNamespace, event.asStartElement()); edmComplexTypes.add(edmComplexType); } else if (isElement( event, EDM2006_ENTITYCONTAINER, EDM2007_ENTITYCONTAINER, EDM2008_1_ENTITYCONTAINER, EDM2008_9_ENTITYCONTAINER, EDM2009_8_ENTITYCONTAINER, EDM2009_11_ENTITYCONTAINER)) { EdmEntityContainer.Builder edmEntityContainer = parseEdmEntityContainer(reader, schemaNamespace, event.asStartElement()); edmEntityContainers.add(edmEntityContainer); } else { EdmAnnotation<?> anElement = getAnnotationElements(event, reader); if (anElement != null) { annotElements.add(anElement); } } } if (isEndElement(event, schemaElement.getName())) { return EdmSchema.newBuilder() .setNamespace(schemaNamespace) .setAlias(schemaAlias) .addEntityTypes(edmEntityTypes) .addComplexTypes(edmComplexTypes) .addAssociations(edmAssociations) .addEntityContainers(edmEntityContainers) .setAnnotations(getAnnotations(schemaElement)) .setAnnotationElements(annotElements); } } throw new UnsupportedOperationException(); }