import org.apache.olingo.odata2.api.edm.EdmException; //导入依赖的package包/类
private static String formatPropertyHeader(EdmProperty property) throws EdmException
{
   StringBuilder property_header = new StringBuilder();
   if (property.getType().getKind().equals(EdmTypeKind.COMPLEX))
   {
      EdmComplexType property_type = (EdmComplexType) property.getType();
      for (String complex_property_name: property_type.getPropertyNames())
      {
         property_header.append(property.getName())
               .append(":")
               .append(complex_property_name)
               .append(SEPARATOR);
      }
   }
   else
   {
      property_header.append(property.getName()).append(SEPARATOR);
   }
   return property_header.toString();
}
 

import org.apache.olingo.odata2.api.edm.EdmException; //导入依赖的package包/类
@Override
public Object visitLiteral(LiteralExpression literal, EdmLiteral edm_literal)
{
   try
   {
      // A literal is a Provider<?> (Functional Java)
      // Returns a Node<?> (Expression Tree)
      Object o = edm_literal.getType().valueOfString(
            edm_literal.getLiteral(),
            EdmLiteralKind.DEFAULT,
            null,
            edm_literal.getType().getDefaultType());
      return ExecutableExpressionTree.Node.createLeave(ConstantFactory.constantFactory(o));
   }
   catch (EdmException ex)
   {
      throw new RuntimeException(ex);
   }
}
 

import org.apache.olingo.odata2.api.edm.EdmException; //导入依赖的package包/类
public ODataEntry readEntry(String serviceUri, String contentType,
		String entitySetName, String keyValue, SystemQueryOptions options)
		throws IllegalStateException, IOException, EdmException,
		EntityProviderException {
	EdmEntityContainer entityContainer = readEdm()
			.getDefaultEntityContainer();
	logger.info("Entity container is => " + entityContainer.getName());
	String absolutUri = createUri(serviceUri, entitySetName, keyValue,
			options);

	InputStream content = executeGet(absolutUri, contentType);

	return EntityProvider.readEntry(contentType,
			entityContainer.getEntitySet(entitySetName), content,
			EntityProviderReadProperties.init().build());
}
 

import org.apache.olingo.odata2.api.edm.EdmException; //导入依赖的package包/类
@Override
public Object readData(final EdmEntitySet entitySet, final Map<String, Object> keys)
    throws ODataNotFoundException, EdmException, ODataApplicationException {

  DataStore<Object> store = getDataStore(entitySet);
  if (store != null) {
    Object keyInstance = store.createInstance();
    ANNOTATION_HELPER.setKeyFields(keyInstance, keys);

    Object result = store.read(keyInstance);
    if (result != null) {
      return result;
    }
  }

  throw new ODataNotFoundException(ODataNotFoundException.ENTITY);
}
 

import org.apache.olingo.odata2.api.edm.EdmException; //导入依赖的package包/类
@Override
public Object readRelatedData(final EdmEntitySet sourceEntitySet, final Object sourceData,
    final EdmEntitySet targetEntitySet,
    final Map<String, Object> targetKeys)
    throws ODataNotImplementedException, ODataNotFoundException, EdmException, ODataApplicationException {

  DataStore<?> sourceStore = dataStoreManager.getDataStore(sourceEntitySet.getName());
  DataStore<?> targetStore = dataStoreManager.getDataStore(targetEntitySet.getName());

  AnnotationHelper.AnnotatedNavInfo navInfo = ANNOTATION_HELPER.getCommonNavigationInfo(
      sourceStore.getDataTypeClass(), targetStore.getDataTypeClass());
  final Field sourceField;
  if(navInfo.isBiDirectional()) {
    sourceField = navInfo.getToField();
  } else {
    sourceField = navInfo.getFromField();
  }
  if (sourceField == null) {
    throw new AnnotationRuntimeException("Missing source field for related data (sourceStore='" + sourceStore
        + "', targetStore='" + targetStore + "').");
  }

  List<Object> resultData = readResultData(targetStore, sourceData, sourceField, navInfo);
  return extractResultData(targetStore, targetKeys, navInfo, resultData);
}
 

import org.apache.olingo.odata2.api.edm.EdmException; //导入依赖的package包/类
@Override
public BinaryData readBinaryData(final EdmEntitySet entitySet, final Object mediaLinkEntryData)
    throws ODataNotImplementedException, ODataNotFoundException, EdmException, ODataApplicationException {

  Object data = ANNOTATION_HELPER.getValueForField(mediaLinkEntryData, EdmMediaResourceContent.class);
  Object mimeType = ANNOTATION_HELPER.getValueForField(mediaLinkEntryData, EdmMediaResourceMimeType.class);

  if (data == null && mimeType == null) {
    DataStore<Object> dataStore = getDataStore(entitySet);
    Object readEntry = dataStore.read(mediaLinkEntryData);
    if (readEntry != null) {
      data = ANNOTATION_HELPER.getValueForField(readEntry, EdmMediaResourceContent.class);
      mimeType = ANNOTATION_HELPER.getValueForField(readEntry, EdmMediaResourceMimeType.class);
    }
  }

  return new BinaryData((byte[]) data, String.valueOf(mimeType));
}
 

import org.apache.olingo.odata2.api.edm.EdmException; //导入依赖的package包/类
@Override
public void writeBinaryData(final EdmEntitySet entitySet, final Object mediaEntityInstance,
    final BinaryData binaryData)
    throws ODataNotImplementedException, ODataNotFoundException, EdmException, ODataApplicationException {

  try {
    DataStore<Object> dataStore = getDataStore(entitySet);
    Object readEntry = dataStore.read(mediaEntityInstance);
    if (readEntry == null) {
      throw new ODataNotFoundException(ODataNotFoundException.ENTITY);
    } else {
      ANNOTATION_HELPER.setValueForAnnotatedField(
          mediaEntityInstance, EdmMediaResourceContent.class, binaryData.getData());
      ANNOTATION_HELPER.setValueForAnnotatedField(
          mediaEntityInstance, EdmMediaResourceMimeType.class, binaryData.getMimeType());
    }
  } catch (AnnotationHelper.ODataAnnotationException e) {
    throw new AnnotationRuntimeException("Invalid media resource annotation at entity set '" + entitySet.getName()
        + "' with message '" + e.getMessage() + "'.", e);
  }
}
 

import org.apache.olingo.odata2.api.edm.EdmException; //导入依赖的package包/类
private List<EntityContainer> getEntityContainerHierachy() throws ODataException {
  if (entityContainerHierachy != null) {
    return entityContainerHierachy;
  }

  entityContainerHierachy = new ArrayList<EntityContainer>();
  Map<String, EntityContainer> name2Container = getEntityContainerMap();
  String currentName = getName();
  while (currentName != null) {
    EntityContainer currentContainer = name2Container.get(currentName);
    entityContainerHierachy.add(currentContainer);
    currentName = currentContainer.getExtendz();
  }

  if (entityContainerHierachy.isEmpty()) {
    throw new EdmException(EdmException.PROVIDERPROBLEM, "No container at all found.");
  }
  return entityContainerHierachy;
}
 

import org.apache.olingo.odata2.api.edm.EdmException; //导入依赖的package包/类
@Test
public void Test() {

  EdmEntitySet edmEntitySet = EasyMock.createMock(EdmEntitySet.class);
  try {
    EasyMock.expect(edmEntitySet.getName()).andReturn("SalesOrder");
    EasyMock.replay(edmEntitySet);
  } catch (EdmException e) {
    fail("Not Expected");
  }
  GetEntitySetUriInfo resultsView = EasyMock.createMock(GetEntitySetUriInfo.class);
  EasyMock.expect(resultsView.getTargetEntitySet()).andReturn(edmEntitySet);
  EasyMock.replay(resultsView);
  JPATombstoneCallBack tombStoneCallBack = new JPATombstoneCallBack("/sample/", resultsView, "1");

  TombstoneCallbackResult result = tombStoneCallBack.getTombstoneCallbackResult();
  assertEquals("/sample/SalesOrder?!deltatoken=1", result.getDeltaLink());
}
 

import org.apache.olingo.odata2.api.edm.EdmException; //导入依赖的package包/类
private void writeProperties(final EntityInfoAggregator entityInfo, final Map<String, Object> data,
    final EdmEntityType type, boolean containsMetadata) throws EdmException, EntityProviderException, IOException {
  // if the payload contains metadata we must not omit the first comm as it separates the _metadata object form the
  // properties
  boolean omitComma = !containsMetadata;

  List<String> propertyNames = type.getPropertyNames();
  for (final String propertyName : propertyNames) {
    if (properties.isDataBasedPropertySerialization() && ((Map<?,?>)data).containsKey(propertyName)) {
      omitComma = appendPropertyNameValue(entityInfo, data, omitComma, propertyName);
    } else if (!properties.isDataBasedPropertySerialization() && entityInfo.getSelectedPropertyNames()
        .contains(propertyName)) {
      omitComma = appendPropertyNameValue(entityInfo, data, omitComma, propertyName);
    }
  }
}
 

import org.apache.olingo.odata2.api.edm.EdmException; //导入依赖的package包/类
private void createSelectTree(final ExpandSelectTreeNodeImpl root) throws EdmException {
  for (SelectItem item : initialSelect) {
    ExpandSelectTreeNodeImpl actualNode = root;

    for (NavigationPropertySegment navSegement : item.getNavigationPropertySegments()) {
      actualNode = addSelectNode(actualNode, navSegement.getNavigationProperty().getName());
    }

    if (item.getProperty() != null) {
      actualNode.addProperty(item.getProperty());
    } else if (item.isStar()) {
      actualNode.setAllExplicitly();
    } else {
      // The actual node is a navigation property and has no property or star so it is explicitly selected
      actualNode.setExplicitlySelected();
    }
  }
}
 

import org.apache.olingo.odata2.api.edm.EdmException; //导入依赖的package包/类
private EdmProperty getEdmProperty() {
  EdmProperty edmTyped = EasyMock.createMock(EdmProperty.class);

  JPAEdmMappingImpl edmMapping = EasyMock.createMock(JPAEdmMappingImpl.class);
  EasyMock.expect(edmMapping.getInternalName()).andStubReturn("Field1");
  EasyMock.expect(((JPAEdmMappingImpl) edmMapping).isVirtualAccess()).andStubReturn(false);
  EasyMock.replay(edmMapping);

  EdmType edmType = EasyMock.createMock(EdmType.class);

  try {
    EasyMock.expect(edmType.getKind()).andStubReturn(EdmTypeKind.SIMPLE);
    EasyMock.expect(edmType.getName()).andStubReturn("identifier");
    EasyMock.expect(edmTyped.getName()).andStubReturn("SalesOrderHeader");
    EasyMock.expect(edmTyped.getMapping()).andStubReturn(edmMapping);

    EasyMock.expect(edmTyped.getType()).andStubReturn(edmType);
    EasyMock.expect(edmTyped.getMapping()).andStubReturn(edmMapping);

  } catch (EdmException e) {
    fail(ODataJPATestConstants.EXCEPTION_MSG_PART_1 + e.getMessage() + ODataJPATestConstants.EXCEPTION_MSG_PART_2);
  }
  EasyMock.replay(edmType);
  EasyMock.replay(edmTyped);
  return edmTyped;
}
 

import org.apache.olingo.odata2.api.edm.EdmException; //导入依赖的package包/类
private Map<String, Object> parseLinkUri(final EdmEntitySet targetEntitySet, final String uriString)
    throws EdmException {
  ODataContext context = getContext();
  final int timingHandle = context.startRuntimeMeasurement("UriParser", "getKeyPredicatesFromEntityLink");

  List<KeyPredicate> key = null;
  try {
    key = UriParser.getKeyPredicatesFromEntityLink(targetEntitySet, uriString,
        context.getPathInfo().getServiceRoot());
  } catch (ODataException e) {
    // We don't understand the link target. This could also be seen as an error.
  }

  context.stopRuntimeMeasurement(timingHandle);

  return key == null ? null : mapKey(key);
}
 

import org.apache.olingo.odata2.api.edm.EdmException; //导入依赖的package包/类
public EdmEntityContainerImplProv(final EdmImplProv edm, final EntityContainerInfo entityContainerInfo)
    throws EdmException {
  this.edm = edm;
  this.entityContainerInfo = entityContainerInfo;
  edmEntitySets = new HashMap<String, EdmEntitySet>();
  edmAssociationSets = new HashMap<String, EdmAssociationSet>();
  edmFunctionImports = new HashMap<String, EdmFunctionImport>();
  isDefaultContainer = entityContainerInfo.isDefaultEntityContainer();

  if (entityContainerInfo.getExtendz() != null) {
    edmExtendedEntityContainer = edm.getEntityContainer(entityContainerInfo.getExtendz());
    if (edmExtendedEntityContainer == null) {
      throw new EdmException(EdmException.COMMON);
    }
  }
}
 

import org.apache.olingo.odata2.api.edm.EdmException; //导入依赖的package包/类
private EdmEntityType getLocalEdmEntityType() {
  EdmEntityType objEdmEntityType = EasyMock.createMock(EdmEntityType.class);
  try {
    EasyMock.expect(objEdmEntityType.getName()).andStubReturn("SalesOderHeaders");
    EasyMock.expect(objEdmEntityType.getNamespace()).andStubReturn("SalesOderHeaders");
    EasyMock.expect(objEdmEntityType.hasStream()).andStubReturn(false);
    EasyMock.expect(objEdmEntityType.hasStream()).andStubReturn(false);
    ArrayList<String> propertyNames = new ArrayList<String>();
    propertyNames.add("ID");
    EasyMock.expect(objEdmEntityType.getProperty("ID")).andStubReturn(getEdmPropertyForSelect());
    EasyMock.expect(objEdmEntityType.getPropertyNames()).andStubReturn(propertyNames);
    EasyMock.expect(objEdmEntityType.getNavigationPropertyNames()).andStubReturn(new ArrayList<String>());
    EasyMock.expect(objEdmEntityType.getKeyPropertyNames()).andStubReturn(propertyNames);
    EasyMock.expect(objEdmEntityType.getKeyProperties()).andStubReturn(getKeyProperties());
  } catch (EdmException e) {
    fail(ODataJPATestConstants.EXCEPTION_MSG_PART_1 + e.getMessage() + ODataJPATestConstants.EXCEPTION_MSG_PART_2);
  }
  EasyMock.replay(objEdmEntityType);
  return objEdmEntityType;
}
 

import org.apache.olingo.odata2.api.edm.EdmException; //导入依赖的package包/类
private static String getPropertyName(final CommonExpression whereExpression) throws EdmException,
    ODataJPARuntimeException {
  EdmTyped edmProperty = ((PropertyExpression) whereExpression).getEdmProperty();
  EdmMapping mapping;
  if (edmProperty instanceof EdmNavigationProperty) {
    EdmNavigationProperty edmNavigationProperty = (EdmNavigationProperty) edmProperty;
    mapping = edmNavigationProperty.getMapping();
  } else if(edmProperty instanceof EdmProperty) {
    EdmProperty property = (EdmProperty) edmProperty;
    mapping = property.getMapping();
  } else {
    throw ODataJPARuntimeException.throwException(ODataJPARuntimeException.GENERAL, null);
  }

  return mapping != null ? mapping.getInternalName() : edmProperty.getName();
}
 

import org.apache.olingo.odata2.api.edm.EdmException; //导入依赖的package包/类
@Override
public ODataResponse writeFunctionImport(final EdmFunctionImport functionImport, final Object data,
    final EntityProviderWriteProperties properties) throws EntityProviderException {
  try {
    final EdmType type = functionImport.getReturnType().getType();
    final boolean isCollection = functionImport.getReturnType().getMultiplicity() == EdmMultiplicity.MANY;

    if (type.getKind() == EdmTypeKind.ENTITY) {
      @SuppressWarnings("unchecked")
      Map<String, Object> map = (Map<String, Object>) data;
      return writeEntry(functionImport.getEntitySet(), map, properties);
    }

    final EntityPropertyInfo info = EntityInfoAggregator.create(functionImport);
    if (isCollection) {
      return writeCollection(info, (List<?>) data);
    } else {
      return writeSingleTypedElement(info, data);
    }
  } catch (EdmException e) {
    throw new EntityProviderProducerException(e.getMessageReference(), e);
  }
}
 

import org.apache.olingo.odata2.api.edm.EdmException; //导入依赖的package包/类
@Override
public List<String> getKeyPropertyNames() throws EdmException {
  if (edmKeyPropertyNames == null) {
    if (edmBaseType != null) {
      return ((EdmEntityType) edmBaseType).getKeyPropertyNames();
    }

    edmKeyPropertyNames = new ArrayList<String>();

    if (entityType.getKey() != null) {
      for (final PropertyRef keyProperty : entityType.getKey().getKeys()) {
        edmKeyPropertyNames.add(keyProperty.getName());
      }
    } else {
      // Entity Type does not define a key
      throw new EdmException(EdmException.COMMON);
    }
  }

  return edmKeyPropertyNames;
}
 

import org.apache.olingo.odata2.api.edm.EdmException; //导入依赖的package包/类
public List<?> readData(final EdmEntitySet entitySet) throws ODataNotImplementedException, ODataNotFoundException,
    EdmException {
  if (ENTITYSET_1_1.equals(entitySet.getName())) {
    return Arrays.asList(dataContainer.getEmployees().toArray());
  } else if (ENTITYSET_1_2.equals(entitySet.getName())) {
    return Arrays.asList(dataContainer.getTeams().toArray());
  } else if (ENTITYSET_1_3.equals(entitySet.getName())) {
    return Arrays.asList(dataContainer.getRooms().toArray());
  } else if (ENTITYSET_1_4.equals(entitySet.getName())) {
    return Arrays.asList(dataContainer.getManagers().toArray());
  } else if (ENTITYSET_1_5.equals(entitySet.getName())) {
    return Arrays.asList(dataContainer.getBuildings().toArray());
  } else if (ENTITYSET_2_1.equals(entitySet.getName())) {
    return Arrays.asList(dataContainer.getPhotos().toArray());
  } else {
    throw new ODataNotImplementedException();
  }
}
 

import org.apache.olingo.odata2.api.edm.EdmException; //导入依赖的package包/类
private void normalizeInlineEntries(final Map<String, Object> oDataEntryProperties) throws ODataJPARuntimeException {
  List<ODataEntry> entries = null;
  try {
    for (String navigationPropertyName : oDataEntityType.getNavigationPropertyNames()) {
      Object inline = oDataEntryProperties.get(navigationPropertyName);
      if (inline instanceof ODataFeed) {
        entries = ((ODataFeed) inline).getEntries();
      } else if (inline instanceof ODataEntry) {
        entries = new ArrayList<ODataEntry>();
        entries.add((ODataEntry) inline);
      }
      if (entries != null) {
        oDataEntryProperties.put(navigationPropertyName, entries);
        entries = null;
      }
    }
  } catch (EdmException e) {
    throw ODataJPARuntimeException
        .throwException(ODataJPARuntimeException.GENERAL
            .addContent(e.getMessage()), e);
  }
}