/// <summary> /// Reads the headers of a part. /// </summary> /// <returns>true if the start of a changeset part was detected; otherwise false.</returns> internal bool ProcessPartHeader() { DebugUtils.CheckNoExternalCallers(); Debug.Assert(this.batchEncoding != null, "Batch encoding should have been established on first call to SkipToBoundary."); bool isChangeSetPart; ODataBatchOperationHeaders headers = this.ReadPartHeaders(out isChangeSetPart); if (isChangeSetPart) { // determine the changeset boundary and the changeset encoding from the content type header this.DetermineChangesetBoundaryAndEncoding(headers[ODataConstants.ContentTypeHeader]); if (this.changesetEncoding == null) { // NOTE: No changeset encoding was specified in the changeset's content type header. // Determine the changeset encoding from the first bytes in the changeset. // NOTE: We do not have to skip over the potential preamble of the encoding // because the batch reader will skip over everything (incl. the preamble) // until it finds the first changeset (or batch) boundary this.changesetEncoding = this.DetectEncoding(); } // Verify that we only allow single byte encodings and UTF-8 for now. ReaderValidationUtils.ValidateEncodingSupportedInBatch(this.changesetEncoding); } return(isChangeSetPart); }
private void EnsureBatchEncoding() { if (this.batchEncoding == null) { this.batchEncoding = this.DetectEncoding(); } ReaderValidationUtils.ValidateEncodingSupportedInBatch(this.batchEncoding); }
/// <summary> /// Reads the next <see cref="ODataItem"/> from the message payload. /// </summary> /// <returns>true if more items were read; otherwise false.</returns> private bool ReadImplementation() { bool result; switch (this.State) { case ODataReaderState.Start: result = this.ReadAtStartImplementation(); break; case ODataReaderState.FeedStart: result = this.ReadAtFeedStartImplementation(); break; case ODataReaderState.FeedEnd: result = this.ReadAtFeedEndImplementation(); break; case ODataReaderState.EntryStart: this.IncreaseEntryDepth(); result = this.ReadAtEntryStartImplementation(); break; case ODataReaderState.EntryEnd: this.DecreaseEntryDepth(); result = this.ReadAtEntryEndImplementation(); break; case ODataReaderState.NavigationLinkStart: result = this.ReadAtNavigationLinkStartImplementation(); break; case ODataReaderState.NavigationLinkEnd: result = this.ReadAtNavigationLinkEndImplementation(); break; case ODataReaderState.EntityReferenceLink: result = this.ReadAtEntityReferenceLink(); break; case ODataReaderState.Exception: // fall through case ODataReaderState.Completed: throw new ODataException(Strings.ODataReaderCore_NoReadCallsAllowed(this.State)); default: Debug.Assert(false, "Unsupported reader state " + this.State + " detected."); throw new ODataException(Strings.General_InternalError(InternalErrorCodes.ODataReaderCore_ReadImplementation)); } if ((this.State == ODataReaderState.EntryStart || this.State == ODataReaderState.EntryEnd) && this.Item != null) { ReaderValidationUtils.ValidateEntry(this.CurrentEntry); } return(result); }
private bool ReadImplementation() { bool flag; switch (this.State) { case ODataReaderState.Start: flag = this.ReadAtStartImplementation(); break; case ODataReaderState.FeedStart: flag = this.ReadAtFeedStartImplementation(); break; case ODataReaderState.FeedEnd: flag = this.ReadAtFeedEndImplementation(); break; case ODataReaderState.EntryStart: this.IncreaseEntryDepth(); flag = this.ReadAtEntryStartImplementation(); break; case ODataReaderState.EntryEnd: this.DecreaseEntryDepth(); flag = this.ReadAtEntryEndImplementation(); break; case ODataReaderState.NavigationLinkStart: flag = this.ReadAtNavigationLinkStartImplementation(); break; case ODataReaderState.NavigationLinkEnd: flag = this.ReadAtNavigationLinkEndImplementation(); break; case ODataReaderState.EntityReferenceLink: flag = this.ReadAtEntityReferenceLink(); break; case ODataReaderState.Exception: case ODataReaderState.Completed: throw new ODataException(Microsoft.Data.OData.Strings.ODataReaderCore_NoReadCallsAllowed(this.State)); default: throw new ODataException(Microsoft.Data.OData.Strings.General_InternalError(InternalErrorCodes.ODataReaderCore_ReadImplementation)); } if (((this.State == ODataReaderState.EntryStart) || (this.State == ODataReaderState.EntryEnd)) && (this.Item != null)) { ReaderValidationUtils.ValidateEntry(this.CurrentEntry); } return(flag); }
/// <summary> /// Ensure that a batch encoding exists; if not, detect it from the first couple of bytes of the stream. /// </summary> private void EnsureBatchEncoding() { // If no batch encoding is specified we detect it from the first bytes in the buffer. if (this.batchEncoding == null) { // NOTE: The batch encoding will only ever be null on the first call to this method which // happens before the batch reader skips to the first boundary. this.batchEncoding = this.DetectEncoding(); } // Verify that we only allow single byte encodings and UTF-8 for now. ReaderValidationUtils.ValidateEncodingSupportedInBatch(this.batchEncoding); }
public ODataMessageReader(IODataResponseMessage responseMessage, ODataMessageReaderSettings settings, IEdmModel model) { this.readerPayloadKind = ODataPayloadKind.Unsupported; ExceptionUtils.CheckArgumentNotNull <IODataResponseMessage>(responseMessage, "responseMessage"); this.settings = (settings == null) ? new ODataMessageReaderSettings() : new ODataMessageReaderSettings(settings); ReaderValidationUtils.ValidateMessageReaderSettings(this.settings, true); this.readingResponse = true; this.message = new ODataResponseMessage(responseMessage, false, this.settings.DisableMessageStreamDisposal, this.settings.MessageQuotas.MaxReceivedMessageSize); this.urlResolver = responseMessage as IODataUrlResolver; this.version = ODataUtilsInternal.GetDataServiceVersion(this.message, this.settings.MaxProtocolVersion); this.model = model ?? EdmCoreModel.Instance; ODataVersionChecker.CheckVersionSupported(this.version, this.settings); }
internal bool ProcessPartHeader() { bool flag; ODataBatchOperationHeaders headers = this.ReadPartHeaders(out flag); if (flag) { this.DetermineChangesetBoundaryAndEncoding(headers["Content-Type"]); if (this.changesetEncoding == null) { this.changesetEncoding = this.DetectEncoding(); } ReaderValidationUtils.ValidateEncodingSupportedInBatch(this.changesetEncoding); } return(flag); }
/// <summary> /// If an entity type name is found in the payload this method is called to apply it to the current scope. /// This method should be called even if the type name was not found in which case a null should be passed in. /// The method validates that some type will be available as the current entity type after it returns (if we are parsing using metadata). /// </summary> /// <param name="entityTypeNameFromPayload">The entity type name found in the payload or null if no type was specified in the payload.</param> protected void ApplyEntityTypeNameFromPayload(string entityTypeNameFromPayload) { Debug.Assert( this.scopes.Count > 0 && this.scopes.Peek().Item is ODataEntry, "Entity type can be applied only when in entry scope."); SerializationTypeNameAnnotation serializationTypeNameAnnotation; EdmTypeKind targetTypeKind; IEdmEntityTypeReference targetEntityTypeReference = (IEdmEntityTypeReference)ReaderValidationUtils.ResolvePayloadTypeNameAndComputeTargetType( EdmTypeKind.Entity, /*defaultPrimitivePayloadType*/ null, this.CurrentEntityType.ToTypeReference(), entityTypeNameFromPayload, this.inputContext.Model, this.inputContext.MessageReaderSettings, this.inputContext.Version, () => EdmTypeKind.Entity, out targetTypeKind, out serializationTypeNameAnnotation); IEdmEntityType targetEntityType = null; ODataEntry entry = this.CurrentEntry; if (targetEntityTypeReference != null) { targetEntityType = targetEntityTypeReference.EntityDefinition(); entry.TypeName = targetEntityType.ODataFullName(); if (serializationTypeNameAnnotation != null) { entry.SetAnnotation(serializationTypeNameAnnotation); } } else if (entityTypeNameFromPayload != null) { entry.TypeName = entityTypeNameFromPayload; } // Set the current entity type since the type from payload might be more derived than // the expected one. this.CurrentEntityType = targetEntityType; }
protected void ApplyEntityTypeNameFromPayload(string entityTypeNameFromPayload) { SerializationTypeNameAnnotation annotation; EdmTypeKind kind; IEdmEntityTypeReference reference = (IEdmEntityTypeReference)ReaderValidationUtils.ResolvePayloadTypeNameAndComputeTargetType(EdmTypeKind.Entity, null, this.CurrentEntityType.ToTypeReference(), entityTypeNameFromPayload, this.inputContext.Model, this.inputContext.MessageReaderSettings, this.inputContext.Version, () => EdmTypeKind.Entity, out kind, out annotation); IEdmEntityType type = null; ODataEntry currentEntry = this.CurrentEntry; if (reference != null) { type = reference.EntityDefinition(); currentEntry.TypeName = type.ODataFullName(); if (annotation != null) { currentEntry.SetAnnotation <SerializationTypeNameAnnotation>(annotation); } } else if (entityTypeNameFromPayload != null) { currentEntry.TypeName = entityTypeNameFromPayload; } this.CurrentEntityType = type; }
/// <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) { DebugUtils.CheckNoExternalCallers(); 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.DateTime: return(PlatformHelper.ConvertStringToDateTime(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: return(text); case EdmPrimitiveTypeKind.Time: return(XmlConvert.ToTimeSpan(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.AtomValueUtils_ConvertStringToPrimitive)); } } catch (Exception e) { if (!ExceptionUtils.IsCatchableExceptionType(e)) { throw; } throw ReaderValidationUtils.GetPrimitiveTypeConversionException(targetTypeReference, e); } }
internal static object ConvertStringToPrimitive(string text, IEdmPrimitiveTypeReference targetTypeReference) { object obj2; try { switch (targetTypeReference.PrimitiveKind()) { case EdmPrimitiveTypeKind.Binary: return(Convert.FromBase64String(text)); case EdmPrimitiveTypeKind.Boolean: return(XmlConvert.ToBoolean(text)); case EdmPrimitiveTypeKind.Byte: return(XmlConvert.ToByte(text)); case EdmPrimitiveTypeKind.DateTime: return(Microsoft.Data.OData.PlatformHelper.ConvertStringToDateTime(text)); case EdmPrimitiveTypeKind.DateTimeOffset: return(XmlConvert.ToDateTimeOffset(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: return(text); case EdmPrimitiveTypeKind.Time: return(XmlConvert.ToTimeSpan(text)); } throw new ODataException(Microsoft.Data.OData.Strings.General_InternalError(InternalErrorCodes.AtomValueUtils_ConvertStringToPrimitive)); } catch (Exception exception) { if (!ExceptionUtils.IsCatchableExceptionType(exception)) { throw; } throw ReaderValidationUtils.GetPrimitiveTypeConversionException(targetTypeReference, exception); } return(obj2); }
protected override Task <bool> ReadAsynchronously() { Task <bool> result; switch (this.State) { case ODataReaderState.Start: result = this.ReadAtStartImplementationAsync(); break; case ODataReaderState.FeedStart: result = this.ReadAtFeedStartImplementationAsync(); break; case ODataReaderState.FeedEnd: result = this.ReadAtFeedEndImplementationAsync(); break; case ODataReaderState.EntryStart: result = TaskUtils.GetTaskForSynchronousOperation(() => this.IncreaseEntryDepth()) .FollowOnSuccessWithTask(t => this.ReadAtEntryStartImplementationAsync()); break; case ODataReaderState.EntryEnd: result = TaskUtils.GetTaskForSynchronousOperation(() => this.DecreaseEntryDepth()) .FollowOnSuccessWithTask(t => this.ReadAtEntryEndImplementationAsync()); break; case ODataReaderState.NavigationLinkStart: result = this.ReadAtNavigationLinkStartImplementationAsync(); break; case ODataReaderState.NavigationLinkEnd: result = this.ReadAtNavigationLinkEndImplementationAsync(); break; case ODataReaderState.EntityReferenceLink: result = this.ReadAtEntityReferenceLinkAsync(); break; case ODataReaderState.Exception: // fall through case ODataReaderState.Completed: result = TaskUtils.GetFaultedTask <bool>(new ODataException(Strings.ODataReaderCore_NoReadCallsAllowed(this.State))); break; default: Debug.Assert(false, "Unsupported reader state " + this.State + " detected."); result = TaskUtils.GetFaultedTask <bool>(new ODataException(Strings.General_InternalError(InternalErrorCodes.ODataReaderCoreAsync_ReadAsynchronously))); break; } return(result.FollowOnSuccessWith(t => { if ((this.State == ODataReaderState.EntryStart || this.State == ODataReaderState.EntryEnd) && this.Item != null) { ReaderValidationUtils.ValidateEntry(this.CurrentEntry); } return t.Result; })); }