/// <summary> /// Translates a <see cref="SingleComplexNode"/> into a corresponding <see cref="String"/>. /// </summary> /// <param name="node">The node to translate.</param> /// <returns>The translated String.</returns> public override String Visit(SingleComplexNode node) { ExceptionUtils.CheckArgumentNotNull(node, "node"); return(this.TranslatePropertyAccess(node.Source, node.Property.Name)); }
/// <summary> /// Translates a <see cref="SingleResourceCastNode"/> into a corresponding <see cref="String"/>. /// </summary> /// <param name="node">The node to translate.</param> /// <returns>The translated String.</returns> public override String Visit(SingleResourceCastNode node) { ExceptionUtils.CheckArgumentNotNull(node, "node"); return(this.TranslatePropertyAccess(node.Source, node.StructuredTypeReference.Definition.ToString())); }
/// <summary> /// Translates an <see cref="CollectionOpenPropertyAccessNode"/> into a corresponding <see cref="String"/>. /// </summary> /// <param name="node">The node to translate.</param> /// <returns>The translated String.</returns> public override String Visit(CollectionOpenPropertyAccessNode node) { ExceptionUtils.CheckArgumentNotNull(node, "node"); return(this.TranslatePropertyAccess(node.Source, node.Name)); }
/// <summary>Returns the format used by the message reader for reading the payload.</summary> /// <returns>The format used by the messageReader for reading the payload.</returns> /// <param name="messageReader">The <see cref="T:Microsoft.OData.ODataMessageReader" /> to get the read format from.</param> /// <remarks>This method must only be called once reading has started. /// This means that a read method has been called on the <paramref name="messageReader"/> or that a reader (for entries, resource sets, collections, etc.) has been created. /// If the method is called prior to that it will throw.</remarks> public static ODataFormat GetReadFormat(ODataMessageReader messageReader) { ExceptionUtils.CheckArgumentNotNull(messageReader, "messageReader"); return(messageReader.GetFormat()); }
/// <summary> /// Translates a <see cref="NonResourceRangeVariableReferenceNode"/> into a corresponding <see cref="String"/>. /// </summary> /// <param name="node">The node to translate.</param> /// <returns>The translated String.</returns> public override String Visit(NonResourceRangeVariableReferenceNode node) { ExceptionUtils.CheckArgumentNotNull(node, "node"); return(node.Name); }
internal static object CoerceNumericType(object primitiveValue, IEdmPrimitiveType targetEdmType) { // This is implemented to match TypePromotionUtils and MetadataUtilsCommon.CanConvertPrimitiveTypeTo() ExceptionUtils.CheckArgumentNotNull(primitiveValue, "primitiveValue"); ExceptionUtils.CheckArgumentNotNull(targetEdmType, "targetEdmType"); EdmPrimitiveTypeKind targetPrimitiveKind = targetEdmType.PrimitiveKind; if (primitiveValue is SByte) { switch (targetPrimitiveKind) { case EdmPrimitiveTypeKind.SByte: return(primitiveValue); case EdmPrimitiveTypeKind.Int16: return(Convert.ToInt16((SByte)primitiveValue)); case EdmPrimitiveTypeKind.Int32: return(Convert.ToInt32((SByte)primitiveValue)); case EdmPrimitiveTypeKind.Int64: return(Convert.ToInt64((SByte)primitiveValue)); case EdmPrimitiveTypeKind.Single: return(Convert.ToSingle((SByte)primitiveValue)); case EdmPrimitiveTypeKind.Double: return(Convert.ToDouble((SByte)primitiveValue)); case EdmPrimitiveTypeKind.Decimal: return(Convert.ToDecimal((SByte)primitiveValue)); } } if (primitiveValue is Byte) { switch (targetPrimitiveKind) { case EdmPrimitiveTypeKind.Byte: return(primitiveValue); case EdmPrimitiveTypeKind.Int16: return(Convert.ToInt16((Byte)primitiveValue)); case EdmPrimitiveTypeKind.Int32: return(Convert.ToInt32((Byte)primitiveValue)); case EdmPrimitiveTypeKind.Int64: return(Convert.ToInt64((Byte)primitiveValue)); case EdmPrimitiveTypeKind.Single: return(Convert.ToSingle((Byte)primitiveValue)); case EdmPrimitiveTypeKind.Double: return(Convert.ToDouble((Byte)primitiveValue)); case EdmPrimitiveTypeKind.Decimal: return(Convert.ToDecimal((Byte)primitiveValue)); } } if (primitiveValue is Int16) { switch (targetPrimitiveKind) { case EdmPrimitiveTypeKind.Int16: return(primitiveValue); case EdmPrimitiveTypeKind.Int32: return(Convert.ToInt32((Int16)primitiveValue)); case EdmPrimitiveTypeKind.Int64: return(Convert.ToInt64((Int16)primitiveValue)); case EdmPrimitiveTypeKind.Single: return(Convert.ToSingle((Int16)primitiveValue)); case EdmPrimitiveTypeKind.Double: return(Convert.ToDouble((Int16)primitiveValue)); case EdmPrimitiveTypeKind.Decimal: return(Convert.ToDecimal((Int16)primitiveValue)); } } if (primitiveValue is Int32) { switch (targetPrimitiveKind) { case EdmPrimitiveTypeKind.Int32: return(primitiveValue); case EdmPrimitiveTypeKind.Int64: return(Convert.ToInt64((Int32)primitiveValue)); case EdmPrimitiveTypeKind.Single: return(Convert.ToSingle((Int32)primitiveValue)); case EdmPrimitiveTypeKind.Double: return(Convert.ToDouble((Int32)primitiveValue)); case EdmPrimitiveTypeKind.Decimal: return(Convert.ToDecimal((Int32)primitiveValue)); } } if (primitiveValue is Int64) { switch (targetPrimitiveKind) { case EdmPrimitiveTypeKind.Int64: return(primitiveValue); case EdmPrimitiveTypeKind.Single: return(Convert.ToSingle((Int64)primitiveValue)); case EdmPrimitiveTypeKind.Double: return(Convert.ToDouble((Int64)primitiveValue)); case EdmPrimitiveTypeKind.Decimal: return(Convert.ToDecimal((Int64)primitiveValue)); } } if (primitiveValue is Single) { switch (targetPrimitiveKind) { case EdmPrimitiveTypeKind.Single: return(primitiveValue); case EdmPrimitiveTypeKind.Double: /*to string then to double, avoid losing precision like "(double)123.001f" which is 123.00099945068359, instead of 123.001d.*/ return(double.Parse(((Single)primitiveValue).ToString("R", CultureInfo.InvariantCulture), CultureInfo.InvariantCulture)); case EdmPrimitiveTypeKind.Decimal: return(Convert.ToDecimal((Single)primitiveValue)); } } if (primitiveValue is Double) { switch (targetPrimitiveKind) { case EdmPrimitiveTypeKind.Double: return(primitiveValue); case EdmPrimitiveTypeKind.Decimal: // TODO: extract these convertion steps to an individual function decimal doubleToDecimalR; // To keep the full presion of the current value, which if necessary is all 17 digits of precision supported by the Double type. if (decimal.TryParse(((Double)primitiveValue).ToString("R", CultureInfo.InvariantCulture), out doubleToDecimalR)) { return(doubleToDecimalR); } return(Convert.ToDecimal((Double)primitiveValue)); } } if (primitiveValue is Decimal) { switch (targetPrimitiveKind) { case EdmPrimitiveTypeKind.Decimal: return(primitiveValue); } } return(null); }
/// <summary> /// Converts the given payload value to the type defined in a type definition. /// </summary> /// <param name="value">The given payload value.</param> /// <param name="edmTypeReference">The expected type reference from model.</param> /// <returns>The converted value of the type.</returns> public virtual object ConvertFromPayloadValue(object value, IEdmTypeReference edmTypeReference) { IEdmPrimitiveTypeReference primitiveTypeReference = edmTypeReference as IEdmPrimitiveTypeReference; Debug.Assert(primitiveTypeReference != null, "primitiveTypeReference != null"); if (primitiveTypeReference.PrimitiveKind() == EdmPrimitiveTypeKind.PrimitiveType) { return(value); } try { Type targetType = EdmLibraryExtensions.GetPrimitiveClrType(primitiveTypeReference.PrimitiveDefinition(), false); string stringValue = value as string; if (stringValue != null) { return(ConvertStringValue(stringValue, targetType)); } else if (value is Int32) { return(ConvertInt32Value((int)value, targetType, primitiveTypeReference)); } else if (value is Decimal) { Decimal decimalValue = (Decimal)value; if (targetType == typeof(Int64)) { return(Convert.ToInt64(decimalValue)); } if (targetType == typeof(Double)) { return(Convert.ToDouble(decimalValue)); } if (targetType == typeof(Single)) { return(Convert.ToSingle(decimalValue)); } if (targetType != typeof(Decimal)) { throw new ODataException(ODataErrorStrings.ODataJsonReaderUtils_CannotConvertDecimal(primitiveTypeReference.FullName())); } } else if (value is Double) { return(ConvertDoubleValue((Double)value, targetType, primitiveTypeReference)); } else if (value is bool) { if (targetType != typeof(bool)) { throw new ODataException(ODataErrorStrings.ODataJsonReaderUtils_CannotConvertBoolean(primitiveTypeReference.FullName())); } } else if (value is DateTime) { if (targetType != typeof(DateTime)) { throw new ODataException(ODataErrorStrings.ODataJsonReaderUtils_CannotConvertDateTime(primitiveTypeReference.FullName())); } } else if (value is DateTimeOffset) { if (targetType != typeof(DateTimeOffset)) { throw new ODataException(ODataErrorStrings.ODataJsonReaderUtils_CannotConvertDateTimeOffset(primitiveTypeReference.FullName())); } } } catch (Exception e) { if (!ExceptionUtils.IsCatchableExceptionType(e)) { throw; } throw ReaderValidationUtils.GetPrimitiveTypeConversionException(primitiveTypeReference, e, value.ToString()); } // otherwise just return the value without doing any conversion return(value); }
/// <summary> /// Provide additional serialization information to the <see cref="ODataWriter"/> for <paramref name="nestedResourceInfo"/>. /// </summary> /// <param name="nestedResourceInfo">The instance to set the serialization info.</param> /// <param name="serializationInfo">The serialization info to set.</param> public static void SetSerializationInfo(this ODataNestedResourceInfo nestedResourceInfo, ODataNestedResourceInfoSerializationInfo serializationInfo) { ExceptionUtils.CheckArgumentNotNull(nestedResourceInfo, "resource"); nestedResourceInfo.SerializationInfo = serializationInfo; }
/// <summary> /// Provide additional serialization information to the <see cref="ODataWriter"/> for <paramref name="property"/>. /// </summary> /// <param name="property">The instance to set the serialization info.</param> /// <param name="serializationInfo">The serialization info to set.</param> public static void SetSerializationInfo(this ODataProperty property, ODataPropertySerializationInfo serializationInfo) { ExceptionUtils.CheckArgumentNotNull(property, "property"); property.SerializationInfo = serializationInfo; }
/// <summary> /// Provide additional serialization information to the <see cref="ODataDeltaWriter"/> for <paramref name="deltalink"/>. /// </summary> /// <param name="deltalink">The instance to set the serialization info.</param> /// <param name="serializationInfo">The serialization info to set.</param> public static void SetSerializationInfo(this ODataDeltaLinkBase deltalink, ODataDeltaSerializationInfo serializationInfo) { ExceptionUtils.CheckArgumentNotNull(deltalink, "deltalink"); deltalink.SerializationInfo = serializationInfo; }
/// <summary> /// Provide additional serialization information to the <see cref="ODataWriter"/> for <paramref name="resource"/>. /// </summary> /// <param name="resource">The instance to set the serialization info.</param> /// <param name="serializationInfo">The serialization info to set.</param> public static void SetSerializationInfo(this ODataResourceBase resource, ODataResourceSerializationInfo serializationInfo) { ExceptionUtils.CheckArgumentNotNull(resource, "resource"); resource.SerializationInfo = serializationInfo; }
/// <summary> /// Provide additional serialization information to the <see cref="ODataDeltaWriter"/> for <paramref name="deltaDeletedEntry"/>. /// </summary> /// <param name="deltaDeletedEntry">The instance to set the serialization info.</param> /// <param name="serializationInfo">The serialization info to set.</param> public static void SetSerializationInfo(this ODataDeltaDeletedEntry deltaDeletedEntry, ODataDeltaSerializationInfo serializationInfo) { ExceptionUtils.CheckArgumentNotNull(deltaDeletedEntry, "deltaDeletedEntry"); deltaDeletedEntry.SerializationInfo = serializationInfo; }
/// <summary> /// Converts a string to a primitive value. /// </summary> /// <param name="text">The string text to convert.</param> /// <param name="targetTypeReference">Type to convert the string to.</param> /// <returns>The value converted to the target type.</returns> /// <remarks>This method does not convert null value.</remarks> internal static object ConvertStringToPrimitive(string text, IEdmPrimitiveTypeReference targetTypeReference) { Debug.Assert(text != null, "text != null"); Debug.Assert(targetTypeReference != null, "targetTypeReference != null"); try { EdmPrimitiveTypeKind primitiveKind = targetTypeReference.PrimitiveKind(); switch (primitiveKind) { case EdmPrimitiveTypeKind.Binary: return(Convert.FromBase64String(text)); case EdmPrimitiveTypeKind.Boolean: return(ConvertXmlBooleanValue(text)); case EdmPrimitiveTypeKind.Byte: return(XmlConvert.ToByte(text)); case EdmPrimitiveTypeKind.DateTimeOffset: return(PlatformHelper.ConvertStringToDateTimeOffset(text)); case EdmPrimitiveTypeKind.Decimal: return(XmlConvert.ToDecimal(text)); case EdmPrimitiveTypeKind.Double: return(XmlConvert.ToDouble(text)); case EdmPrimitiveTypeKind.Guid: return(new Guid(text)); case EdmPrimitiveTypeKind.Int16: return(XmlConvert.ToInt16(text)); case EdmPrimitiveTypeKind.Int32: return(XmlConvert.ToInt32(text)); case EdmPrimitiveTypeKind.Int64: return(XmlConvert.ToInt64(text)); case EdmPrimitiveTypeKind.SByte: return(XmlConvert.ToSByte(text)); case EdmPrimitiveTypeKind.Single: return(XmlConvert.ToSingle(text)); case EdmPrimitiveTypeKind.String: case EdmPrimitiveTypeKind.PrimitiveType: return(text); case EdmPrimitiveTypeKind.Duration: return(EdmValueParser.ParseDuration(text)); case EdmPrimitiveTypeKind.Date: return(PlatformHelper.ConvertStringToDate(text)); case EdmPrimitiveTypeKind.TimeOfDay: return(PlatformHelper.ConvertStringToTimeOfDay(text)); case EdmPrimitiveTypeKind.Stream: case EdmPrimitiveTypeKind.None: case EdmPrimitiveTypeKind.Geography: case EdmPrimitiveTypeKind.GeographyCollection: case EdmPrimitiveTypeKind.GeographyPoint: case EdmPrimitiveTypeKind.GeographyLineString: case EdmPrimitiveTypeKind.GeographyPolygon: case EdmPrimitiveTypeKind.GeometryCollection: case EdmPrimitiveTypeKind.GeographyMultiPolygon: case EdmPrimitiveTypeKind.GeographyMultiLineString: case EdmPrimitiveTypeKind.GeographyMultiPoint: case EdmPrimitiveTypeKind.Geometry: case EdmPrimitiveTypeKind.GeometryPoint: case EdmPrimitiveTypeKind.GeometryLineString: case EdmPrimitiveTypeKind.GeometryPolygon: case EdmPrimitiveTypeKind.GeometryMultiPolygon: case EdmPrimitiveTypeKind.GeometryMultiLineString: case EdmPrimitiveTypeKind.GeometryMultiPoint: default: // Note that Astoria supports XElement and Binary as well, but they are serialized as string or byte[] // and the metadata will actually talk about string and byte[] as well. Astoria will perform the conversion if necessary. throw new ODataException(Strings.General_InternalError(InternalErrorCodes.ODataRawValueUtils_ConvertStringToPrimitive)); } } catch (Exception e) { if (!ExceptionUtils.IsCatchableExceptionType(e)) { throw; } throw ReaderValidationUtils.GetPrimitiveTypeConversionException(targetTypeReference, e, text); } }
/// <summary> /// Gets the <see cref="ODataPreferenceHeader"/> instance to get or set preferences on the "Preference-Applied" header of the <paramref name="responseMessage"/>. /// </summary> /// <param name="responseMessage">The response message to get or set the "Preference-Applied" header.</param> /// <returns>Returns the <see cref="ODataPreferenceHeader"/> instance to get or set preferences on the "Preference-Applied" header of the <paramref name="responseMessage"/>.</returns> public static ODataPreferenceHeader PreferenceAppliedHeader(this IODataResponseMessage responseMessage) { ExceptionUtils.CheckArgumentNotNull(responseMessage, "responseMessage"); return(new ODataPreferenceHeader(responseMessage)); }
/// <summary> /// Translates a <see cref="ParameterAliasNode"/> into a corresponding <see cref="String"/>. /// </summary> /// <param name="node">The node to translate.</param> /// <returns>The translated String.</returns> public override String Visit(ParameterAliasNode node) { ExceptionUtils.CheckArgumentNotNull(node, "node"); return(node.Alias); }
/// <summary> /// Provide additional serialization information to the <see cref="ODataCollectionWriter"/> for <paramref name="collectionStart"/>. /// </summary> /// <param name="collectionStart">The instance to set the serialization info.</param> /// <param name="serializationInfo">The serialization info to set.</param> public static void SetSerializationInfo(this ODataCollectionStart collectionStart, ODataCollectionStartSerializationInfo serializationInfo) { ExceptionUtils.CheckArgumentNotNull(collectionStart, "collectionStart"); collectionStart.SerializationInfo = serializationInfo; }
/// <summary> /// Translates a <see cref="NamedFunctionParameterNode"/> into a corresponding <see cref="String"/>. /// </summary> /// <param name="node">The node to translate.</param> /// <returns>The translated String of NamedFunctionParameterNode.</returns> public override string Visit(NamedFunctionParameterNode node) { ExceptionUtils.CheckArgumentNotNull(node, "node"); return(String.Concat(node.Name, ExpressionConstants.SymbolEqual, this.TranslateNode(node.Value))); }
/// <summary> /// Provide additional serialization information to the <see cref="ODataDeltaWriter"/> for <paramref name="deltaResourceSet"/>. /// </summary> /// <param name="deltaResourceSet">The instance to set the serialization info.</param> /// <param name="serializationInfo">The serialization info to set.</param> public static void SetSerializationInfo(this ODataDeltaResourceSet deltaResourceSet, ODataResourceSerializationInfo serializationInfo) { ExceptionUtils.CheckArgumentNotNull(deltaResourceSet, "deltaResourceSet"); deltaResourceSet.SerializationInfo = serializationInfo; }
/// <summary> /// Initializes a new instance of the <see cref="Microsoft.OData.ODataInnerError" /> class with a dictionary of property names and corresponding ODataValues. /// </summary> /// <param name="properties">Dictionary of string keys with ODataValue as value. Key string indicates the property name where as the value of the property is encapsulated in ODataValue.</param> public ODataInnerError(IDictionary <string, ODataValue> properties) { ExceptionUtils.CheckArgumentNotNull(properties, "properties"); Properties = new Dictionary <string, ODataValue>(properties); }
/// <summary> /// Translates a <see cref="ConvertNode"/> into a corresponding <see cref="String"/>. /// </summary> /// <param name="node">The node to translate.</param> /// <returns>The translated String.</returns> public override String Visit(ConvertNode node) { ExceptionUtils.CheckArgumentNotNull(node, "node"); return(this.TranslateNode(node.Source)); }
/// <summary> /// Returns enumeration of tasks to run to buffer the entire input stream. /// </summary> /// <returns>Enumeration of tasks to run to buffer the input stream.</returns> /// <remarks>This method relies on lazy eval of the enumerator, never enumerate through it synchronously.</remarks> private IEnumerable <Task> BufferInputStream() { while (this.inputStream != null) { Debug.Assert(this.currentBufferIndex >= -1 && this.currentBufferIndex < this.buffers.Count, "The currentBufferIndex is outside of the valid range."); DataBuffer currentBuffer = this.currentBufferIndex == -1 ? null : this.buffers[this.currentBufferIndex]; // Here we intentionally leave some memory unused (smaller than MinReadBufferSize) // in order to issue big enough read requests. This is a perf optimization. if (currentBuffer != null && currentBuffer.FreeBytes < DataBuffer.MinReadBufferSize) { currentBuffer = null; } if (currentBuffer == null) { currentBuffer = this.AddNewBuffer(); } #if PORTABLELIB yield return(inputStream.ReadAsync(currentBuffer.Buffer, currentBuffer.OffsetToWriteTo, currentBuffer.FreeBytes) .ContinueWith(t => { try { int bytesRead = t.Result; if (bytesRead == 0) { this.inputStream = null; } else { currentBuffer.MarkBytesAsWritten(bytesRead); } } catch (Exception exception) { if (!ExceptionUtils.IsCatchableExceptionType(exception)) { throw; } this.inputStream = null; throw; } })); #else yield return(Task.Factory.FromAsync( (asyncCallback, asyncState) => this.inputStream.BeginRead( currentBuffer.Buffer, currentBuffer.OffsetToWriteTo, currentBuffer.FreeBytes, asyncCallback, asyncState), (asyncResult) => { try { int bytesRead = this.inputStream.EndRead(asyncResult); if (bytesRead == 0) { this.inputStream = null; } else { currentBuffer.MarkBytesAsWritten(bytesRead); } } catch (Exception exception) { if (!ExceptionUtils.IsCatchableExceptionType(exception)) { throw; } this.inputStream = null; throw; } }, null)); #endif } }
/// <summary> /// Sets the custom instance annotations. /// </summary> /// <param name="value">The new value to set.</param> internal void SetInstanceAnnotations(ICollection <ODataInstanceAnnotation> value) { ExceptionUtils.CheckArgumentNotNull(value, "value"); this.instanceAnnotations = value; }