import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeException; //导入依赖的package包/类
private static Date toDate(String sourceValue) {
  try {
    return EdmDateTimeOffset.getInstance().valueOfString(
        sourceValue,
        true,
        null,
        null,
        null,
        null,
        Date.class);
  } catch (EdmPrimitiveTypeException dateTimeOffsetException) {
    try {
      return EdmDate.getInstance().valueOfString(
          sourceValue,
          true,
          null,
          null,
          null,
          null,
          Date.class);
    } catch (EdmPrimitiveTypeException e) {
      throw new IllegalStateException("Cannot convert to EdmDate: " + sourceValue, e);
    }
  }
}
 

import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeException; //导入依赖的package包/类
/**
 * Writes primitive property into json.
 * 
 * @param type
 *            the EDM type
 * @param property
 *            property instance
 * @param options
 *            options for the serializer
 * @param json
 *            json generator
 * @throws EdmPrimitiveTypeException
 *             if any error occurred
 * @throws IOException
 *             if any error occurred
 * @throws SerializerException
 *             if any error occurred
 */
private void writePrimitive(EdmPrimitiveType type, Property property,
        PrimitiveSerializerOptions options, JsonGenerator json)
        throws EdmPrimitiveTypeException, IOException, SerializerException {
    Boolean isNullable = options == null ? null : options.isNullable();
    Integer maxLength = options == null ? null : options.getMaxLength();
    Integer precision = options == null ? null : options.getPrecision();
    Integer scale = options == null ? null : options.getScale();
    Boolean isUnicode = options == null ? null : options.isUnicode();
    if (property.isPrimitive()) {
        writePrimitiveValue(property.getName(), type, property.asPrimitive(), isNullable,
                maxLength, precision, scale, isUnicode, json);
    } else if (property.isGeospatial()) {
        throw new SerializerException("Property type not yet supported!",
                SerializerException.MessageKeys.UNSUPPORTED_PROPERTY_TYPE, property.getName());
    } else if (property.isEnum()) {
        writePrimitiveValue(property.getName(), type, property.asEnum(), isNullable, maxLength,
                precision, scale, isUnicode, json);
    } else {
        throw new SerializerException("Inconsistent property type!",
                SerializerException.MessageKeys.INCONSISTENT_PROPERTY_TYPE, property.getName());
    }
}
 

import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeException; //导入依赖的package包/类
protected MultiLineString stringToMultiLineString(final String value, final Boolean isNullable,
    final Integer maxLength, final Integer precision, final Integer scale, final Boolean isUnicode)
        throws EdmPrimitiveTypeException {

  final Matcher matcher = getMatcher(PATTERN, value);

  final List<LineString> lineStrings = new ArrayList<LineString>();
  for (String coo : matcher.group(4).contains("),(")
      ? matcher.group(4).split("\\),\\(") : new String[] { matcher.group(4) }) {

    String lineString = coo;
    if (lineString.charAt(0) == '(') {
      lineString = lineString.substring(1);
    }
    if (lineString.endsWith(")")) {
      lineString = lineString.substring(0, lineString.length() - 1);
    }

    lineStrings.add(newLineString(null, lineString, isNullable, maxLength, precision, scale, isUnicode));
  }

  return new MultiLineString(this.dimension, SRID.valueOf(matcher.group(2)), lineStrings);
}
 

import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeException; //导入依赖的package包/类
private void update(final ContentType contentType) throws EdmPrimitiveTypeException {
  final ClientSingleton changes = getClient().getObjectFactory().newSingleton(
      new FullQualifiedName("Microsoft.Test.OData.Services.ODataWCFService.Company"));
  changes.getProperties().add(getClient().getObjectFactory().newPrimitiveProperty("Revenue",
      getClient().getObjectFactory().newPrimitiveValueBuilder().buildInt64(132520L)));

  final URI uri = client.newURIBuilder(testStaticServiceRootURL).appendSingletonSegment("Company").build();
  final ODataEntityUpdateRequest<ClientSingleton> req = getClient().getCUDRequestFactory().
      getSingletonUpdateRequest(uri, UpdateType.PATCH, changes);
  req.setFormat(contentType);

  final ODataEntityUpdateResponse<ClientSingleton> res = req.execute();
  assertEquals(204, res.getStatusCode());

  final ClientSingleton updated =
      getClient().getRetrieveRequestFactory().getSingletonRequest(uri).execute().getBody();
  assertNotNull(updated);
  assertEquals(132520, updated.getProperty("Revenue").getPrimitiveValue().toCastValue(Integer.class), 0);
}
 

import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeException; //导入依赖的package包/类
@Override
public void createEntity(DataRequest request, Entity entity, EntityResponse response)
        throws ODataApplicationException {
    EdmEntitySet edmEntitySet = request.getEntitySet();
    String baseURL = request.getODataRequest().getRawBaseUri();
    try {
        Entity created = createEntityInTable(edmEntitySet.getEntityType(), entity);
        entity.setId(new URI(ODataUtils.buildLocation(baseURL, created, edmEntitySet.getName(),
                                                      edmEntitySet.getEntityType())));
        response.writeCreatedEntity(edmEntitySet, created);
    } catch (ODataServiceFault | SerializerException | URISyntaxException | EdmPrimitiveTypeException e) {
        response.writeNotModified();
        String error = "Error occurred while creating entity. :" + e.getMessage();
        throw new ODataApplicationException(error, 500, Locale.ENGLISH);
    }
}
 

import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeException; //导入依赖的package包/类
static Object readPrimitiveValue(EdmProperty edmProperty, String value)
    throws ODataApplicationException {
  if (value == null) {
    return null;
  }
  try {
    if (value.startsWith("'") && value.endsWith("'")) {
      value = value.substring(1,value.length()-1);
    }
    EdmPrimitiveType edmPrimitiveType = (EdmPrimitiveType) edmProperty.getType();
    Class<?> javaClass = getJavaClassForPrimitiveType(edmProperty, edmPrimitiveType);
    return edmPrimitiveType.valueOfString(value, edmProperty.isNullable(),
        edmProperty.getMaxLength(), edmProperty.getPrecision(), edmProperty.getScale(),
        edmProperty.isUnicode(), javaClass);
  } catch (EdmPrimitiveTypeException e) {
    throw new ODataApplicationException("Invalid value: " + value + " for property: "
        + edmProperty.getName(), 500, Locale.getDefault());
  }
}
 

import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeException; //导入依赖的package包/类
/**
 * MUST NOT require <tt>odata.streaming=true</tt> in the <tt>Content-Type</tt> header (section 4.4).
 */
@Test
public void item6() throws EdmPrimitiveTypeException {
  final URI uri = edmClient.newURIBuilder().
      appendEntitySetSegment("Accounts").appendKeySegment(102).
      appendNavigationSegment("MyPaymentInstruments").appendKeySegment(102902).build();
  final ODataEntityRequest<ClientEntity> req = edmClient.getRetrieveRequestFactory().getEntityRequest(uri);

  // request format (via Accept header) does not contain odata.streaming=true
  assertEquals("application/json;odata.metadata=minimal", req.getAccept());

  final ODataRetrieveResponse<ClientEntity> res = req.execute();

  // response payload is understood
  final ClientEntity entity = res.getBody();
  assertNotNull(entity);
  assertEquals("Microsoft.Test.OData.Services.ODataWCFService.PaymentInstrument", entity.getTypeName().toString());
  assertEquals(102902, entity.getProperty("PaymentInstrumentID").getPrimitiveValue().toCastValue(Integer.class), 0);
  assertEquals("Edm.DateTimeOffset", entity.getProperty("CreatedDate").getPrimitiveValue().getTypeName());
}
 

import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeException; //导入依赖的package包/类
protected String toString(final MultiLineString multiLineString, final Boolean isNullable, final Integer maxLength,
    final Integer precision, final Integer scale, final Boolean isUnicode) throws EdmPrimitiveTypeException {

  if (dimension != multiLineString.getDimension()) {
    throw new EdmPrimitiveTypeException("The value '" + multiLineString + "' is not valid.");
  }

  final StringBuilder result = toStringBuilder(multiLineString.getSrid()).
      append(reference.getSimpleName()).
      append('(');

  for (final Iterator<LineString> itor = multiLineString.iterator(); itor.hasNext();) {
    result.append('(').
    append(lineString(itor.next(), isNullable, maxLength, precision, scale, isUnicode)).
    append(')');
    if (itor.hasNext()) {
      result.append(',');
    }
  }

  return result.append(")'").toString();
}
 

import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeException; //导入依赖的package包/类
private void validateSet(final URI uri, final String cookie, final short... keys) throws EdmPrimitiveTypeException {
  final EdmEnabledODataClient client = getEdmEnabledClient();
  final ODataEntitySetRequest<ClientEntitySet> request = client.getRetrieveRequestFactory()
      .getEntitySetRequest(uri);
  request.addCustomHeader(HttpHeader.COOKIE, cookie);
  final ODataRetrieveResponse<ClientEntitySet> response = request.execute();

  assertEquals(HttpStatusCode.OK.getStatusCode(), response.getStatusCode());
  assertEquals(3, response.getBody().getEntities().size());

  for (final ClientEntity responseEntity : response.getBody().getEntities()) {
    short propertyInt16 = responseEntity.getProperty(PROPERTY_INT16)
        .getPrimitiveValue().toCastValue(Short.class);

    boolean found = false;
    for (int i = 0; i < keys.length && !found; i++) {
      if (propertyInt16 == keys[i]) {
        found = true;
      }
    }

    if (!found) {
      fail("Invalid key " + propertyInt16);
    }
  }
}
 

import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeException; //导入依赖的package包/类
@Override
protected <T> String internalValueToString(final T value,
    final Boolean isNullable, final Integer maxLength, final Integer precision,
    final Integer scale, final Boolean isUnicode) throws EdmPrimitiveTypeException {

  if (value instanceof Byte) {
    return value.toString();
  } else if (value instanceof Short || value instanceof Integer || value instanceof Long) {
    if (((Number) value).longValue() >= Byte.MIN_VALUE && ((Number) value).longValue() <= Byte.MAX_VALUE) {
      return value.toString();
    } else {
      throw new EdmPrimitiveTypeException("The value '" + value + "' is not valid.");
    }
  } else if (value instanceof BigInteger) {
    if (((BigInteger) value).bitLength() < Byte.SIZE) {
      return value.toString();
    } else {
      throw new EdmPrimitiveTypeException("The value '" + value + "' is not valid.");
    }
  } else {
    throw new EdmPrimitiveTypeException("The value type " + value.getClass() + " is not supported.");
  }
}
 

import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeException; //导入依赖的package包/类
@Override
public final <T> T valueOfString(final String value,
    final Boolean isNullable, final Integer maxLength, final Integer precision,
    final Integer scale, final Boolean isUnicode, final Class<T> returnType)
    throws EdmPrimitiveTypeException {
  if (value == null) {
    if (isNullable != null && !isNullable) {
      throw new EdmPrimitiveTypeException("The literal 'null' is not allowed.");
    }
    return null;
  }
  if (value.equals("null")) {
    return null;
  } else {
    throw new EdmPrimitiveTypeException("The literal '" + value + "' has illegal content.");
  }
}
 

import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeException; //导入依赖的package包/类
private void collection(final Valuable valuable, final XMLEventReader reader, final StartElement start,
    final EdmType edmType, final boolean isNullable, final Integer maxLength, final Integer precision,
    final Integer scale, final boolean isUnicode) throws XMLStreamException, EdmPrimitiveTypeException,
    DeserializerException {

  List<Object> values = new ArrayList<Object>();
  boolean foundEndProperty = false;
  while (reader.hasNext() && !foundEndProperty) {
    final XMLEvent event = reader.nextEvent();
    if (event.isStartElement()) {
      if (edmType instanceof EdmPrimitiveType) {
        values.add(primitive(reader, event.asStartElement(), edmType, isNullable,
            maxLength, precision, scale, isUnicode));
      } else if (edmType instanceof EdmComplexType) {
        values.add(complex(reader, event.asStartElement(), (EdmComplexType) edmType));
      }
      // do not add null or empty values
    }

    if (event.isEndElement() && start.getName().equals(event.asEndElement().getName())) {
      foundEndProperty = true;
    }
  }
  valuable.setValue(getValueType(edmType, true), values);
}
 

import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeException; //导入依赖的package包/类
@Test
public void timeOfDay() throws EdmPrimitiveTypeException {
  final Calendar expected = Calendar.getInstance();
  expected.clear();
  expected.set(2013, 0, 10, 21, 45, 17);

  final ClientValue value = client.getObjectFactory().newPrimitiveValueBuilder()
      .setType(EdmPrimitiveTypeKind.TimeOfDay).setValue(expected).build();
  assertEquals(EdmPrimitiveTypeKind.TimeOfDay, value.asPrimitive().getTypeKind());

  final Calendar actual = value.asPrimitive().toCastValue(Calendar.class);
  assertEquals(expected.get(Calendar.HOUR), actual.get(Calendar.HOUR));
  assertEquals(expected.get(Calendar.MINUTE), actual.get(Calendar.MINUTE));
  assertEquals(expected.get(Calendar.SECOND), actual.get(Calendar.SECOND));

  assertEquals("21:45:17", value.asPrimitive().toString());
}
 

import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeException; //导入依赖的package包/类
@Override
public String valueToString(final Object value, final Boolean isNullable, final Integer maxLength,
    final Integer precision, final Integer scale, final Boolean isUnicode) throws EdmPrimitiveTypeException {

  if (value == null) {
    if (isNullable != null && !isNullable) {
      throw new EdmPrimitiveTypeException("The value NULL is not allowed.");
    }
    return null;
  }
  if (value instanceof Byte || value instanceof Short || value instanceof Integer || value instanceof Long) {
    return constructEnumValue(((Number) value).longValue());
  } else {
    throw new EdmPrimitiveTypeException("The value type " + value.getClass() + " is not supported.");
  }
}
 

import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeException; //导入依赖的package包/类
@Override
protected <T> T internalValueOfString(final String value,
    final Boolean isNullable, final Integer maxLength, final Integer precision,
    final Integer scale, final Boolean isUnicode, final Class<T> returnType) throws EdmPrimitiveTypeException {

  if (isUnicode != null && !isUnicode && !PATTERN_ASCII.matcher(value).matches()
      || maxLength != null && maxLength < value.length()) {
    throw new EdmPrimitiveTypeException("The literal '" + value + "' does not match the facets' constraints.");
  }

  if (returnType.isAssignableFrom(String.class)) {
    return returnType.cast(value);
  } else {
    throw new EdmPrimitiveTypeException("The value type " + returnType + " is not supported.");
  }
}
 

import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeException; //导入依赖的package包/类
@Override
protected <T> T internalValueOfString(final String value,
    final Boolean isNullable, final Integer maxLength, final Integer precision,
    final Integer scale, final Boolean isUnicode, final Class<T> returnType) throws EdmPrimitiveTypeException {

  if (value == null || !isBase64(value.getBytes(UTF_8))) {
    throw new EdmPrimitiveTypeException("The literal '" + value + "' has illegal content.");
  }
  if (!validateMaxLength(value, maxLength)) {
    throw new EdmPrimitiveTypeException("The literal '" + value + "' does not match the facets' constraints.");
  }

  final byte[] result = Base64.decodeBase64(value.getBytes(UTF_8));

  if (returnType.isAssignableFrom(byte[].class)) {
    return returnType.cast(result);
  } else if (returnType.isAssignableFrom(Byte[].class)) {
    final Byte[] byteArray = new Byte[result.length];
    for (int i = 0; i < result.length; i++) {
      byteArray[i] = result[i];
    }
    return returnType.cast(byteArray);
  } else {
    throw new EdmPrimitiveTypeException("The value type " + returnType + " is not supported.");
  }
}
 

import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeException; //导入依赖的package包/类
private List<Point> readGeoPointValues(final String name, final Geospatial.Dimension dimension,
    final int minimalSize, final boolean closed, JsonNode node)
    throws DeserializerException, EdmPrimitiveTypeException {
  if (node.isArray()) {
    List<Point> points = new ArrayList<Point>();
    for (final JsonNode element : node) {
      points.add(readGeoPointValue(name, dimension, element));
    }
    if (points.size() >= minimalSize
        && (!closed || points.get(points.size() - 1).equals(points.get(0)))) {
        return points;
    }
  }
  throw new DeserializerException("Invalid point values '" + node + "' in property: " + name,
      DeserializerException.MessageKeys.INVALID_VALUE_FOR_PROPERTY, name);
}
 

import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeException; //导入依赖的package包/类
@Override
public final <T> T valueOfString(final String value, final Boolean isNullable, final Integer maxLength,
                                 final Integer precision, final Integer scale, final Boolean isUnicode,
                                 final Class<T> returnType) throws EdmPrimitiveTypeException {
    if (value == null) {
        if (isNullable != null && !isNullable) {
            throw new EdmPrimitiveTypeException("The literal 'null' is not allowed.");
        }
        return null;
    }
    if (value.equals("null")) {
        return null;
    } else {
        throw new EdmPrimitiveTypeException("The literal '" + value + "' has illegal content.");
    }
}
 

import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeException; //导入依赖的package包/类
private void writePrimitive(final EdmPrimitiveType type, final Property property,
    final Boolean isNullable, final Integer maxLength, final Integer precision, final Integer scale,
    final Boolean isUnicode, final JsonGenerator json)
    throws EdmPrimitiveTypeException, IOException, SerializerException {
  if (property.isPrimitive()) {
    writePrimitiveValue(property.getName(), type, property.asPrimitive(),
        isNullable, maxLength, precision, scale, isUnicode, json);
  } else if (property.isGeospatial()) {
    throw new SerializerException("Property type not yet supported!",
        SerializerException.MessageKeys.UNSUPPORTED_PROPERTY_TYPE, property.getName());
  } else if (property.isEnum()) {
    writePrimitiveValue(property.getName(), type, property.asEnum(),
        isNullable, maxLength, precision, scale, isUnicode, json);
  } else {
    throw new SerializerException("Inconsistent property type!",
        SerializerException.MessageKeys.INCONSISTENT_PROPERTY_TYPE, property.getName());
  }
}
 

import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeException; //导入依赖的package包/类
@Override
protected <T> String internalValueToString(final T value,
    final Boolean isNullable, final Integer maxLength, final Integer precision,
    final Integer scale, final Boolean isUnicode) throws EdmPrimitiveTypeException {
  if (value instanceof Byte || value instanceof Short) {
    return value.toString();
  } else if (value instanceof Integer || value instanceof Long) {
    if (((Number) value).longValue() >= Short.MIN_VALUE
        && ((Number) value).longValue() <= Short.MAX_VALUE) {
      return value.toString();
    } else {
      throw new EdmPrimitiveTypeException("The value '" + value + "' is not valid.");
    }
  } else if (value instanceof BigInteger) {
    if (((BigInteger) value).bitLength() < Short.SIZE) {
      return value.toString();
    } else {
      throw new EdmPrimitiveTypeException("The value '" + value + "' is not valid.");
    }
  } else {
    throw new EdmPrimitiveTypeException("The value type " + value.getClass() + " is not supported.");
  }
}