internal virtual AsyncCompletionResult WriteBase64TextAsync(AsyncEventArgs<XmlNodeWriterWriteBase64TextArgs> state) { // We do not guard this invocation. The caller of the NodeWriter should ensure that that // they override the FastAsync guard clause for the XmlDictionaryWriter and that the // nodeWriter has an implemenation for WriteBase64TextAsync. throw Fx.AssertAndThrow("WriteBase64TextAsync not implemented."); }
AsyncCompletionResult InternalWriteBase64TextAsync(AsyncEventArgs<XmlWriteBase64AsyncArguments> writerState) { GetBufferAsyncEventArgs bufferState = this.getBufferState; GetBufferArgs bufferArgs = this.getBufferArgs; XmlWriteBase64AsyncArguments writerArgs = writerState.Arguments; if (bufferState == null) { // Need to initialize the cached getBufferState // used to call GetBufferAsync() multiple times. bufferState = new GetBufferAsyncEventArgs(); bufferArgs = new GetBufferArgs(); this.getBufferState = bufferState; this.getBufferArgs = bufferArgs; } Base64Encoding encoding = XmlConverter.Base64Encoding; while (writerArgs.Count >= 3) { int byteCount = Math.Min(bufferLength / 4 * 3, writerArgs.Count - writerArgs.Count % 3); int charCount = byteCount / 3 * 4; bufferArgs.Count = charCount; bufferState.Set(onGetBufferComplete, bufferArgs, this); if (writer.GetBufferAsync(bufferState) == AsyncCompletionResult.Completed) { GetBufferEventResult getbufferResult = bufferState.Result; bufferState.Complete(true); writer.Advance(encoding.GetChars( writerArgs.Buffer, writerArgs.Offset, byteCount, getbufferResult.Buffer, getbufferResult.Offset)); writerArgs.Offset += byteCount; writerArgs.Count -= byteCount; } else { return AsyncCompletionResult.Queued; } } if (writerArgs.Count > 0) { bufferArgs.Count = 4; bufferState.Set(onGetBufferComplete, bufferArgs, this); if (writer.GetBufferAsync(bufferState) == AsyncCompletionResult.Completed) { GetBufferEventResult getbufferResult = bufferState.Result; bufferState.Complete(true); writer.Advance(encoding.GetChars( writerArgs.Buffer, writerArgs.Offset, writerArgs.Count, getbufferResult.Buffer, getbufferResult.Offset)); } else { return AsyncCompletionResult.Queued; } } return AsyncCompletionResult.Completed; }
internal AsyncCompletionResult StartAsync(AsyncEventArgs<XmlNodeWriterWriteBase64TextArgs> xmlNodeWriterState) { Fx.Assert(xmlNodeWriterState != null, "xmlNodeWriterState cannot be null."); Fx.Assert(this.nodeState == null, "nodeState is not null."); this.nodeState = xmlNodeWriterState; XmlNodeWriterWriteBase64TextArgs nodeWriterArgs = xmlNodeWriterState.Arguments; if (nodeWriterArgs.TrailCount > 0) { this.writerArgs.Buffer = nodeWriterArgs.TrailBuffer; this.writerArgs.Offset = 0; this.writerArgs.Count = nodeWriterArgs.TrailCount; this.writerState.Set(onTrailByteComplete, this.writerArgs, this); if (this.InternalWriteBase64TextAsync(this.writerState) != AsyncCompletionResult.Completed) { return AsyncCompletionResult.Queued; } this.writerState.Complete(true); } if (this.WriteBufferAsync() == AsyncCompletionResult.Completed) { this.nodeState = null; return AsyncCompletionResult.Completed; } return AsyncCompletionResult.Queued; }
public InternalWriteBase64TextAsyncWriter(XmlUTF8NodeWriter writer) { this.writer = writer; this.writerState = new AsyncEventArgs<XmlWriteBase64AsyncArguments>(); this.writerArgs = new XmlWriteBase64AsyncArguments(); }
internal override AsyncCompletionResult WriteBase64TextAsync(AsyncEventArgs<XmlNodeWriterWriteBase64TextArgs> xmlNodeWriterState) { if (internalWriteBase64TextAsyncWriter == null) { internalWriteBase64TextAsyncWriter = new InternalWriteBase64TextAsyncWriter(this); } return this.internalWriteBase64TextAsyncWriter.StartAsync(xmlNodeWriterState); }
AsyncCompletionResult WriteAsync() { if (this.writerAsyncState == null) { this.writerAsyncArgs = new XmlWriteBase64AsyncArguments(); this.writerAsyncState = new AsyncEventArgs<XmlWriteBase64AsyncArguments>(); } if (onWriteComplete == null) { onWriteComplete = new AsyncEventArgsCallback(OnWriteComplete); } this.writerAsyncArgs.Buffer = this.block; this.writerAsyncArgs.Offset = 0; this.writerAsyncArgs.Count = this.bytesRead; this.writerAsyncState.Set(onWriteComplete, this.writerAsyncArgs, this); if (this.writer.WriteBase64Async(this.writerAsyncState) == AsyncCompletionResult.Completed) { this.HandleWriteComplete(); this.writerAsyncState.Complete(true); return AsyncCompletionResult.Completed; } return AsyncCompletionResult.Queued; }
internal virtual AsyncCompletionResult WriteBase64Async(AsyncEventArgs<XmlWriteBase64AsyncArguments> state) { throw FxTrace.Exception.AsError(new NotSupportedException()); }
void Clear() { this.inputState = null; this.buffer = null; this.offset = 0; this.count = 0; this.actualByteCount = 0; this.totalByteCount = 0; }
bool HandleWriteBase64Text(bool isAsyncCallback) { Fx.Assert(this.count > 0 && this.actualByteCount >= 3, "HandleWriteBase64Text cannot be invoked with less than 3 bytes."); if (!writer.isXmlnsAttribute) { if (!isAsyncCallback) { if (this.nodeWriterAsyncState == null) { this.nodeWriterAsyncState = new AsyncEventArgs<XmlNodeWriterWriteBase64TextArgs>(); this.nodeWriterArgs = new XmlNodeWriterWriteBase64TextArgs(); } if (onWriteComplete == null) { onWriteComplete = new AsyncEventArgsCallback(OnWriteComplete); } this.writer.StartContent(); this.nodeWriterArgs.TrailBuffer = this.writer.trailBytes; this.nodeWriterArgs.TrailCount = this.writer.trailByteCount; this.nodeWriterArgs.Buffer = this.buffer; this.nodeWriterArgs.Offset = this.offset; this.nodeWriterArgs.Count = this.actualByteCount - this.writer.trailByteCount; this.nodeWriterAsyncState.Set(onWriteComplete, this.nodeWriterArgs, this); if (this.writer.writer.WriteBase64TextAsync(this.nodeWriterAsyncState) != AsyncCompletionResult.Completed) { return false; } this.nodeWriterAsyncState.Complete(true); } this.writer.EndContent(); } this.writer.trailByteCount = (this.totalByteCount - this.actualByteCount); if (this.writer.trailByteCount > 0) { int trailOffset = offset + count - this.writer.trailByteCount; for (int i = 0; i < this.writer.trailByteCount; i++) this.writer.trailBytes[i] = this.buffer[trailOffset++]; } return true; }
public void SetArguments(AsyncEventArgs<XmlWriteBase64AsyncArguments> inputState) { Fx.Assert(inputState != null, "InputState cannot be null."); this.inputState = inputState; this.buffer = inputState.Arguments.Buffer; this.offset = inputState.Arguments.Offset; this.count = inputState.Arguments.Count; }
internal override AsyncCompletionResult WriteBase64Async(AsyncEventArgs<XmlWriteBase64AsyncArguments> state) { if (this.nodeWriterAsyncHelper == null) { this.nodeWriterAsyncHelper = new XmlBaseWriterNodeWriterAsyncHelper(this); } this.nodeWriterAsyncHelper.SetArguments(state); if (this.nodeWriterAsyncHelper.StartAsync() == AsyncCompletionResult.Completed) { return AsyncCompletionResult.Completed; } return AsyncCompletionResult.Queued; }