public override int ReadContentAsBinHex(byte[] buffer, int index, int count) { if (this.ReadState != System.Xml.ReadState.Interactive) { return(0); } if (this.state != State.InReadBinary) { if (base.CanReadBinaryContent && !this.checkCharacters) { this.readBinaryHelper = null; this.state = State.InReadBinary; return(base.ReadContentAsBinHex(buffer, index, count)); } this.readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset(this.readBinaryHelper, this); } else if (this.readBinaryHelper == null) { return(base.ReadContentAsBinHex(buffer, index, count)); } this.state = State.Interactive; int num = this.readBinaryHelper.ReadContentAsBinHex(buffer, index, count); this.state = State.InReadBinary; return(num); }
public override int ReadElementContentAsBase64(byte[] buffer, int index, int count) { // check arguments if (buffer == null) { throw new ArgumentNullException(nameof(buffer)); } if (count < 0) { throw new ArgumentOutOfRangeException(nameof(count)); } if (index < 0) { throw new ArgumentOutOfRangeException(nameof(index)); } if (buffer.Length - index < count) { throw new ArgumentOutOfRangeException(nameof(count)); } if (ReadState != ReadState.Interactive) { return(0); } if (_state != State.InReadBinary) { // forward ReadBase64Chunk calls into the base (wrapped) reader if possible, i.e. if it can read binary and we // should not check characters if (base.CanReadBinaryContent && (!_checkCharacters)) { _readBinaryHelper = null; _state = State.InReadBinary; return(base.ReadElementContentAsBase64(buffer, index, count)); } // the wrapped reader cannot read chunks or we are on an element where we should check characters or ignore whitespace else { _readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset(_readBinaryHelper, this); } } else { // forward calls into wrapped reader if (_readBinaryHelper == null) { return(base.ReadElementContentAsBase64(buffer, index, count)); } } // turn off InReadBinary state in order to have a normal Read() behavior when called from readBinaryHelper _state = State.Interactive; // call to the helper int readCount = _readBinaryHelper.ReadElementContentAsBase64(buffer, index, count); // turn on InReadBinary in again and return _state = State.InReadBinary; return(readCount); }
public override async Task <int> ReadContentAsBase64Async(byte[] buffer, int index, int count) { if (ReadState != ReadState.Interactive) { return(0); } // init ReadContentAsBinaryHelper when called first time if (validationState != ValidatingReaderState.OnReadBinaryContent) { readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset(readBinaryHelper, this); savedState = validationState; } // restore original state in order to have a normal Read() behavior when called from readBinaryHelper validationState = savedState; // call to the helper int readCount = await readBinaryHelper.ReadContentAsBase64Async(buffer, index, count).ConfigureAwait(false); // set OnReadBinaryContent state again and return savedState = validationState; validationState = ValidatingReaderState.OnReadBinaryContent; return(readCount); }
public override int ReadElementContentAsBinHex( byte[] buffer, int index, int count ) { if ( ReadState != ReadState.Interactive ) { return 0; } if ( state != State.InReadBinary ) { // forward ReadBinHexChunk calls into the base (wrapped) reader if possible, i.e. if it can read chunks and we // should not check characters if ( base.CanReadBinaryContent && ( !checkCharacters ) ) { readBinaryHelper = null; state = State.InReadBinary; return base.ReadElementContentAsBinHex( buffer, index, count ); } // the wrapped reader cannot read chunks or we are on an element where we should check characters or ignore white spaces else { readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset( readBinaryHelper, this ); } } else { // forward calls into wrapped reader if ( readBinaryHelper == null ) { return base.ReadElementContentAsBinHex( buffer, index, count ); } } // turn off InReadBinary state in order to have a normal Read() behavior when called from readBinaryHelper state = State.Interactive; // call to the helper int readCount = readBinaryHelper.ReadElementContentAsBinHex(buffer, index, count); // turn on InReadBinary in again and return state = State.InReadBinary; return readCount; }
public override async Task <int> ReadElementContentAsBinHexAsync(byte[] buffer, int index, int count) { if (ReadState != ReadState.Interactive) { return(0); } // init ReadContentAsBinaryHelper when called first time if (_validationState != ValidatingReaderState.OnReadBinaryContent) { _readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset(_readBinaryHelper, this); _savedState = _validationState; } // restore original state in order to have a normal Read() behavior when called from readBinaryHelper _validationState = _savedState; // call to the helper Debug.Assert(_readBinaryHelper != null); int readCount = await _readBinaryHelper.ReadElementContentAsBinHexAsync(buffer, index, count).ConfigureAwait(false); // set OnReadBinaryContent state again and return _savedState = _validationState; _validationState = ValidatingReaderState.OnReadBinaryContent; return(readCount); }
public override async Task <int> ReadElementContentAsBinHexAsync(byte[] buffer, int index, int count) { // check arguments if (buffer == null) { throw new ArgumentNullException("buffer"); } if (count < 0) { throw new ArgumentOutOfRangeException("count"); } if (index < 0) { throw new ArgumentOutOfRangeException("index"); } if (buffer.Length - index < count) { throw new ArgumentOutOfRangeException("count"); } if (ReadState != ReadState.Interactive) { return(0); } if (state != State.InReadBinary) { // forward ReadBinHexChunk calls into the base (wrapped) reader if possible, i.e. if it can read chunks and we // should not check characters if (base.CanReadBinaryContent && (!checkCharacters)) { readBinaryHelper = null; state = State.InReadBinary; return(await base.ReadElementContentAsBinHexAsync(buffer, index, count).ConfigureAwait(false)); } // the wrapped reader cannot read chunks or we are on an element where we should check characters or ignore white spaces else { readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset(readBinaryHelper, this); } } else { // forward calls into wrapped reader if (readBinaryHelper == null) { return(await base.ReadElementContentAsBinHexAsync(buffer, index, count).ConfigureAwait(false)); } } // turn off InReadBinary state in order to have a normal Read() behavior when called from readBinaryHelper state = State.Interactive; // call to the helper int readCount = await readBinaryHelper.ReadElementContentAsBinHexAsync(buffer, index, count).ConfigureAwait(false); // turn on InReadBinary in again and return state = State.InReadBinary; return(readCount); }
// Static methods internal static ReadContentAsBinaryHelper CreateOrReset( ReadContentAsBinaryHelper helper, XmlReader reader ) { if ( helper == null ) { return new ReadContentAsBinaryHelper( reader ); } else { helper.Reset(); return helper; } }
internal static ReadContentAsBinaryHelper CreateOrReset(ReadContentAsBinaryHelper helper, XmlReader reader) { if (helper == null) { return(new ReadContentAsBinaryHelper(reader)); } helper.Reset(); return(helper); }
public override Task <int> ReadElementContentAsBinHexAsync(byte[] buffer, int index, int count) { ArgumentNullException.ThrowIfNull(buffer); if (index < 0 || (uint)count > buffer.Length - index) { throw new ArgumentOutOfRangeException(index < 0 ? nameof(index) : nameof(count)); } if (ReadState != ReadState.Interactive) { return(Task.FromResult(0)); } return(Core(buffer, index, count)); async Task <int> Core(byte[] buffer, int index, int count) { if (_state != State.InReadBinary) { // forward ReadBinHexChunk calls into the base (wrapped) reader if possible, i.e. if it can read chunks and we // should not check characters if (base.CanReadBinaryContent && (!_checkCharacters)) { _readBinaryHelper = null; _state = State.InReadBinary; return(await base.ReadElementContentAsBinHexAsync(buffer, index, count).ConfigureAwait(false)); } // the wrapped reader cannot read chunks or we are on an element where we should check characters or ignore whitespace else { _readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset(_readBinaryHelper, this); } } else { // forward calls into wrapped reader if (_readBinaryHelper == null) { return(await base.ReadElementContentAsBinHexAsync(buffer, index, count).ConfigureAwait(false)); } } // turn off InReadBinary state in order to have a normal Read() behavior when called from readBinaryHelper _state = State.Interactive; // call to the helper int readCount = await _readBinaryHelper.ReadElementContentAsBinHexAsync(buffer, index, count).ConfigureAwait(false); // turn on InReadBinary in again and return _state = State.InReadBinary; return(readCount); } }
public override int ReadElementContentAsBinHex(byte[] buffer, int index, int count) { if (this.ReadState != System.Xml.ReadState.Interactive) { return(0); } if (this.parsingFunction != ParsingFunction.InReadBinaryContent) { this.readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset(this.readBinaryHelper, this.outerReader); } this.parsingFunction = ParsingFunction.Read; int num = this.readBinaryHelper.ReadElementContentAsBinHex(buffer, index, count); this.parsingFunction = ParsingFunction.InReadBinaryContent; return(num); }
public override int ReadElementContentAsBinHex(byte[] buffer, int index, int count) { if (this.readState != System.Xml.ReadState.Interactive) { return(0); } if (!this.bInReadBinary) { this.readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset(this.readBinaryHelper, this); } this.bInReadBinary = false; int num = this.readBinaryHelper.ReadElementContentAsBinHex(buffer, index, count); this.bInReadBinary = true; return(num); }
public override async Task <int> ReadContentAsBinHexAsync(byte[] buffer, int index, int count) { if (ReadState != ReadState.Interactive) { return(0); } if (_state != State.InReadBinary) { // forward ReadBinHexChunk calls into the base (wrapped) reader if possible, i.e. if it can read chunks and we // should not check characters if (base.CanReadBinaryContent && (!_checkCharacters)) { _readBinaryHelper = null; _state = State.InReadBinary; return(await base.ReadContentAsBinHexAsync(buffer, index, count).ConfigureAwait(false)); } // the wrapped reader cannot read chunks or we are on an element where we should check characters or ignore whitespace else { _readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset(_readBinaryHelper, this); } } else { // forward calls into wrapped reader if (_readBinaryHelper == null) { return(await base.ReadContentAsBinHexAsync(buffer, index, count).ConfigureAwait(false)); } } // turn off InReadBinary state in order to have a normal Read() behavior when called from readBinaryHelper _state = State.Interactive; // call to the helper int readCount = await _readBinaryHelper.ReadContentAsBinHexAsync(buffer, index, count).ConfigureAwait(false); // turn on InReadBinary in again and return _state = State.InReadBinary; return(readCount); }
public override int ReadElementContentAsBinHex(byte[] buffer, int index, int count) { if (buffer == null) { throw new ArgumentNullException("buffer"); } if (count < 0) { throw new ArgumentOutOfRangeException("count"); } if (index < 0) { throw new ArgumentOutOfRangeException("index"); } if ((buffer.Length - index) < count) { throw new ArgumentOutOfRangeException("count"); } if (this.ReadState != System.Xml.ReadState.Interactive) { return(0); } if (this.state != State.InReadBinary) { if (base.CanReadBinaryContent && !this.checkCharacters) { this.readBinaryHelper = null; this.state = State.InReadBinary; return(base.ReadElementContentAsBinHex(buffer, index, count)); } this.readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset(this.readBinaryHelper, this); } else if (this.readBinaryHelper == null) { return(base.ReadElementContentAsBinHex(buffer, index, count)); } this.state = State.Interactive; int num = this.readBinaryHelper.ReadElementContentAsBinHex(buffer, index, count); this.state = State.InReadBinary; return(num); }
public override int ReadElementContentAsBinHex(byte[] buffer, int index, int count) { if (ReadState != ReadState.Interactive) { return(0); } // init ReadChunkHelper when called first time if (parsingFunction != ParsingFunction.InReadBinaryContent) { readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset(readBinaryHelper, outerReader); } // set parsingFunction to Read state in order to have a normal Read() behavior when called from readBinaryHelper parsingFunction = ParsingFunction.Read; // call to the helper int readCount = readBinaryHelper.ReadElementContentAsBinHex(buffer, index, count); // setup parsingFunction parsingFunction = ParsingFunction.InReadBinaryContent; return(readCount); }
public override async Task <int> ReadContentAsBase64Async(byte[] buffer, int index, int count) { if (ReadState != ReadState.Interactive) { return(0); } // init ReadChunkHelper if called the first time if (_parsingFunction != ParsingFunction.InReadBinaryContent) { _readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset(_readBinaryHelper, _outerReader); } // set parsingFunction to Read state in order to have a normal Read() behavior when called from readBinaryHelper _parsingFunction = ParsingFunction.Read; // call to the helper int readCount = await _readBinaryHelper.ReadContentAsBase64Async(buffer, index, count).ConfigureAwait(false); // setup parsingFunction _parsingFunction = ParsingFunction.InReadBinaryContent; return(readCount); }
public override int ReadContentAsBinHex(byte[] buffer, int index, int count) { if (this.ReadState != System.Xml.ReadState.Interactive) { return 0; } if (this.state != State.InReadBinary) { if (base.CanReadBinaryContent && !this.checkCharacters) { this.readBinaryHelper = null; this.state = State.InReadBinary; return base.ReadContentAsBinHex(buffer, index, count); } this.readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset(this.readBinaryHelper, this); } else if (this.readBinaryHelper == null) { return base.ReadContentAsBinHex(buffer, index, count); } this.state = State.Interactive; int num = this.readBinaryHelper.ReadContentAsBinHex(buffer, index, count); this.state = State.InReadBinary; return num; }
public override int ReadElementContentAsBase64(byte[] buffer, int index, int count) { if (this.ReadState != System.Xml.ReadState.Interactive) { return 0; } if (this.state != State.InReadBinary) { this.readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset(this.readBinaryHelper, this); this.savedState = this.state; } this.state = this.savedState; int num = this.readBinaryHelper.ReadElementContentAsBase64(buffer, index, count); this.savedState = this.state; this.state = State.InReadBinary; return num; }
public override int ReadElementContentAsBinHex(byte[] buffer, int index, int count) { // check arguments if (buffer == null) { throw new ArgumentNullException("buffer"); } if (count < 0) { throw new ArgumentOutOfRangeException("count"); } if (index < 0) { throw new ArgumentOutOfRangeException("index"); } if (buffer.Length - index < count) { throw new ArgumentOutOfRangeException("count"); } if (ReadState != ReadState.Interactive) { return 0; } if (_state != State.InReadBinary) { // forward ReadBinHexChunk calls into the base (wrapped) reader if possible, i.e. if it can read chunks and we // should not check characters if (base.CanReadBinaryContent && (!_checkCharacters)) { _readBinaryHelper = null; _state = State.InReadBinary; return base.ReadElementContentAsBinHex(buffer, index, count); } // the wrapped reader cannot read chunks or we are on an element where we should check characters or ignore white spaces else { _readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset(_readBinaryHelper, this); } } else { // forward calls into wrapped reader if (_readBinaryHelper == null) { return base.ReadElementContentAsBinHex(buffer, index, count); } } // turn off InReadBinary state in order to have a normal Read() behavior when called from readBinaryHelper _state = State.Interactive; // call to the helper int readCount = _readBinaryHelper.ReadElementContentAsBinHex(buffer, index, count); // turn on InReadBinary in again and return _state = State.InReadBinary; return readCount; }
public override int ReadElementContentAsBinHex( byte[] buffer, int index, int count ) { if ( ReadState != ReadState.Interactive ) { return 0; } // init ReadChunkHelper when called first time if ( parsingFunction != ParsingFunction.InReadBinaryContent ) { readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset( readBinaryHelper, outerReader ); } // set parsingFunction to Read state in order to have a normal Read() behavior when called from readBinaryHelper parsingFunction = ParsingFunction.Read; // call to the helper int readCount = readBinaryHelper.ReadElementContentAsBinHex( buffer, index, count ); // setup parsingFunction parsingFunction = ParsingFunction.InReadBinaryContent; return readCount; }
public override int ReadElementContentAsBinHex(byte[] buffer, int index, int count) { if (this.ReadState != System.Xml.ReadState.Interactive) { return 0; } if (this.validationState != ValidatingReaderState.OnReadBinaryContent) { this.readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset(this.readBinaryHelper, this); this.savedState = this.validationState; } this.validationState = this.savedState; int num = this.readBinaryHelper.ReadElementContentAsBinHex(buffer, index, count); this.savedState = this.validationState; this.validationState = ValidatingReaderState.OnReadBinaryContent; return num; }
public override int ReadContentAsBinHex( byte[] buffer, int index, int count ) { if (ReadState != ReadState.Interactive) { return 0; } if ( state != State.InReadBinary ) { // forward ReadBinHexChunk calls into the base (wrapped) reader if possible, i.e. if it can read chunks and we // should not check characters if ( base.CanReadBinaryContent && ( !checkCharacters ) ) { readBinaryHelper = null; state = State.InReadBinary; return base.ReadContentAsBinHex( buffer, index, count ); } // the wrapped reader cannot read chunks or we are on an element where we should check characters or ignore white spaces else { readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset( readBinaryHelper, this ); } } else { // forward calls into wrapped reader if ( readBinaryHelper == null ) { return base.ReadContentAsBinHex( buffer, index, count ); } } // turn off InReadBinary state in order to have a normal Read() behavior when called from readBinaryHelper state = State.Interactive; // call to the helper int readCount = readBinaryHelper.ReadContentAsBinHex(buffer, index, count); // turn on InReadBinary in again and return state = State.InReadBinary; return readCount; }
public override int ReadElementContentAsBinHex(byte[] buffer, int index, int count) { if (buffer == null) { throw new ArgumentNullException("buffer"); } if (count < 0) { throw new ArgumentOutOfRangeException("count"); } if (index < 0) { throw new ArgumentOutOfRangeException("index"); } if ((buffer.Length - index) < count) { throw new ArgumentOutOfRangeException("count"); } if (this.ReadState != System.Xml.ReadState.Interactive) { return 0; } if (this.state != State.InReadBinary) { if (base.CanReadBinaryContent && !this.checkCharacters) { this.readBinaryHelper = null; this.state = State.InReadBinary; return base.ReadElementContentAsBinHex(buffer, index, count); } this.readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset(this.readBinaryHelper, this); } else if (this.readBinaryHelper == null) { return base.ReadElementContentAsBinHex(buffer, index, count); } this.state = State.Interactive; int num = this.readBinaryHelper.ReadElementContentAsBinHex(buffer, index, count); this.state = State.InReadBinary; return num; }
public override int ReadElementContentAsBinHex(byte[] buffer, int index, int count) { if (ReadState != ReadState.Interactive) { return 0; } // init ReadContentAsBinaryHelper when called first time if (validationState != ValidatingReaderState.OnReadBinaryContent) { readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset(readBinaryHelper, this); savedState = validationState; } // restore original state in order to have a normal Read() behavior when called from readBinaryHelper validationState = savedState; // call to the helper int readCount = readBinaryHelper.ReadElementContentAsBinHex(buffer, index, count); // set OnReadBinaryContent state again and return savedState = validationState; validationState = ValidatingReaderState.OnReadBinaryContent; return readCount; }
public override int ReadElementContentAsBinHex( byte[] buffer, int index, int count ) { if ( readState != ReadState.Interactive ) { return 0; } // init ReadContentAsBinaryHelper when called first time if ( !bInReadBinary ) { readBinaryHelper = ReadContentAsBinaryHelper.CreateOrReset( readBinaryHelper, this ); } // turn off bInReadBinary in order to have a normal Read() behavior when called from readBinaryHelper bInReadBinary = false; // call to the helper int readCount = readBinaryHelper.ReadElementContentAsBinHex( buffer, index, count ); // turn on bInReadBinary in again and return bInReadBinary = true; return readCount; }