/// <summary>
/// Reads an EDI item from the stream.
/// </summary>
/// <returns>Indication if an item was read.</returns>
public override bool Read()
{
if (Item is ReaderErrorContext && !ContinueOnError)
{
return(false);
}
Item = null;
try
{
while ((!StreamReader.EndOfStream || InternalBuffer.Any()) && Item == null)
{
var segment = ReadSegment();
if (Separators == null)
{
throw new ReaderException("No valid separator set was found.", ReaderErrorCode.InvalidControlStructure);
}
if (string.IsNullOrEmpty(segment))
{
continue;
}
Item = Split(segment) ?? Process(segment);
}
}
catch (ReaderException ex)
{
Item = new ReaderErrorContext(ex, ex.ErrorCode);
}
catch (ParserMessageException ex)
{
Item = new ReaderErrorContext(ex, ReaderErrorCode.InvalidSpecOrAssembly, ex.MessageErrorContext);
}
catch (Exception ex)
{
Item = new ReaderErrorContext(ex, ReaderErrorCode.Unknown);
}
if (StreamReader.EndOfStream && CurrentSegments.Any())
{
Item = new ReaderErrorContext(new Exception("Improper end of file."), ReaderErrorCode.ImproperEndOfFile);
}
var readerErrorContext = Item as ReaderErrorContext;
if (readerErrorContext != null)
{
CurrentSegments.Clear();
if (readerErrorContext.MessageErrorContext == null)
{
Separators = null;
}
}
return(Item != null);
}
public virtual void Enqueue(TEntity item)
{
if (InternalBuffer == null || InternalBuffer.Count >= Settings.WorkerBatchSize)
{
_itemAvailableEvent.Reset();
_itemAvailableEvent.WaitOne();
}
InternalBuffer.TryAdd(item);
}
public override void Clear()
{
/* Don't bother re-creating the stream if it's already empty. */
if (InternalBuffer.Length != 0)
{
InternalBuffer.Close();
InternalBuffer = new MemoryStream();
}
}
protected virtual async Task <T> Enqueue(T item)
{
LoadItem(item);
if (InternalBuffer.Count >= BufferSize)
{
_semaphore.WaitOne();
}
InternalBuffer.TryAdd(item);
return(item);
}
void SwapBuffers()
{
//Put into temporary variable so we dont loose the reference when we repoint.
InternalBuffer temp = this.currentBuffer;
//This make our current buffers next pointer become our front buffer, this will cycle infinite.
this.currentBuffer = temp.GetNextBuffer();
//Always clear frontbuffer when it becomes active.
this.currentBuffer.Clear();
}
public void copyInto(InternalBuffer ano)
{
ano.last_pic_num = this.last_pic_num;
for (int i = 0; i < 4; i++)
{
ano.@base[i] = this.@base[i];
ano.data_offset[i] = this.data_offset[i];
ano.linesize[i] = this.linesize[i];
} // for i
ano.width = this.width;
ano.height = this.height;
ano.pix_fmt = this.pix_fmt;
}
public void copyInto(InternalBuffer ano)
{
ano.last_pic_num = this.last_pic_num;
for (int i = 0; i < 4; i++)
{
ano.@base[i] = this.@base[i];
ano.data_offset[i] = this.data_offset[i];
ano.linesize[i] = this.linesize[i];
} // for i
ano.width = this.width;
ano.height = this.height;
ano.pix_fmt = this.pix_fmt;
}
/// <summary>
/// Reads an item from the stream.
/// </summary>
/// <returns>Indication if an item was read.</returns>
public override bool Read()
{
if (Item is ReaderErrorContext && !ContinueOnError)
{
return(false);
}
Item = null;
try
{
while ((!StreamReader.EndOfStream || InternalBuffer.Any()) && Item == null)
{
var segment = ReadSegment();
if (string.IsNullOrEmpty(segment))
{
continue;
}
Item = Process(segment);
}
}
catch (ReaderException ex)
{
Item = new ReaderErrorContext(ex, ex.ErrorCode);
}
catch (ParserMessageException ex)
{
Item = new ReaderErrorContext(ex, ReaderErrorCode.InvalidSpecOrAssembly, ex.MessageErrorContext);
}
catch (Exception ex)
{
Item = new ReaderErrorContext(ex, ReaderErrorCode.Unknown);
}
if (StreamReader.EndOfStream && CurrentSegments.Any())
{
Item = Flush(null);
}
var readerErrorContext = Item as ReaderErrorContext;
if (readerErrorContext != null)
{
CurrentSegments.Clear();
}
return(Item != null);
}
private void CheckForSpace(ushort count)
{
if (IndexPosition + count < InternalBuffer.Length)
{
return;
}
int newSize = (int)Math.Ceiling(InternalBuffer.Length * _growFactor);
while (IndexPosition + count >= newSize)
{
newSize = (int)Math.Ceiling(newSize * _growFactor);
}
byte[] tmp = new byte[newSize];
InternalBuffer.CopyTo(tmp, 0);
InternalBuffer = tmp;
}
public ServerWebSocket(Stream innerStream,
string subProtocol,
int receiveBufferSize,
TimeSpan keepAliveInterval,
ArraySegment <byte> internalBuffer)
: base(innerStream, subProtocol, keepAliveInterval,
WebSocketBuffer.CreateServerBuffer(internalBuffer, receiveBufferSize))
{
_properties = InternalBuffer.CreateProperties(false);
_sessionHandle = CreateWebSocketHandle();
if (_sessionHandle == null || _sessionHandle.IsInvalid)
{
WebSocketValidate.ThrowPlatformNotSupportedException_WSPC();
}
StartKeepAliveTimer();
}
public float CalculateONPExpresion(string onpExpression)
{
int id = 0;
OutputOperationBuffer = new InternalBuffer<OutputOperation>();
InternalStack<string> stack = new InternalStack<string>();
List<string> tokenList = onpExpression.Trim().Split(' ').ToList();
string input = onpExpression.Trim();
OutputOperationBuffer.Push(new OutputOperation(id++, input, stack.ToReverseString(), string.Empty));
foreach (string token in tokenList)
{
if (!string.IsNullOrEmpty(input.Trim()))
input = input.Trim().Remove(0, 1);
if (token.IsOperator())
{
string secondToken = stack.Pop();
string firstToken = stack.Pop();
string result = Calculate(token, firstToken, secondToken);
OutputOperationBuffer.Push(new OutputOperation(id++, input, stack.ToReverseString(), string.Format("{0} {1} {2}", firstToken, token, secondToken)));
stack.Push(result);
OutputOperationBuffer.Push(new OutputOperation(id++, input, stack.ToReverseString(), string.Empty));
}
else
{
stack.Push(token);
OutputOperationBuffer.Push(new OutputOperation(id++, input, stack.ToReverseString(), string.Empty));
}
}
string resultToken = stack.Pop();
float resultValue = float.Parse(resultToken);
return resultValue;
}
/// <summary>
/// Reads from the stream until a non-escaped segment terminator was reached.
/// Breaks if no segment terminator was encountered after 5000 symbols were read.
/// This is to avoid loading large and corrupt files.
/// </summary>
/// <returns>
/// The segment.
/// </returns>
protected override string ReadSegment()
{
var line = "";
var postFix = "";
while ((!StreamReader.EndOfStream || InternalBuffer.Any()) && line.Length < MaxSegmentLength)
{
line = line + Read(1);
}
while (!string.IsNullOrEmpty(_postFix) && !StreamReader.EndOfStream && postFix.Length < _postFix.Length)
{
postFix = postFix + Read(1);
}
if (!string.IsNullOrEmpty(_postFix) && postFix != _postFix)
{
throw new Exception(string.Format("Postfix {0} is different than the expected {1}", postFix, _postFix));
}
return(line);
}
public PhonemeBuffer(float bufferLength, int numberOfBuffers)
{
this.phonemeBuffers = new List <InternalBuffer>(numberOfBuffers);
//Create buffers;
for (int i = 0; i < numberOfBuffers; i++)
{
InternalBuffer buffer = new InternalBuffer(bufferLength, 4);
phonemeBuffers.Add(buffer);
}
//First buffer added get lowest possible starttime. Then we work ourself up to 0 from there.
int timeScale = -numberOfBuffers;
//Create cyclic buffer pointers.
for (int i = 0; i < numberOfBuffers; i++)
{
InternalBuffer buffer = phonemeBuffers[i];
//loop back to first index when at the end.
buffer.SetNextBuffer(phonemeBuffers[i < numberOfBuffers - 1 ? i + 1 : 0]);
//The time at which this buffer will start.
float startTime = timeScale * bufferLength;
//All buffers are filled with silent phonemes.
buffer.SetDefaultValues(startTime, bufferLength, 4);
//Make sure all buffers have different default times stretching back.
timeScale += 1;
}
//Clear this index since its going to be our frontbuffer.
this.phonemeBuffers[0].Clear();
this.currentBuffer = this.phonemeBuffers[0];
//This buffer will eat all incoming phonemes even when it gets full.
this.completeBuffer = new InternalBuffer(bufferLength, 100);
}
// return value indicates sync vs async completion
// false: sync completion
// true: async completion or error
private unsafe bool ReadAsyncFast(HttpListenerAsyncEventArgs eventArgs)
{
eventArgs.StartOperationCommon(this, _inputStream.InternalHttpContext.RequestQueueBoundHandle);
eventArgs.StartOperationReceive();
bool completedAsynchronouslyOrWithError;
try
{
Debug.Assert(eventArgs.Buffer != null, "'BufferList' is not supported for read operations.");
if (eventArgs.Count == 0 || _inputStream.Closed)
{
eventArgs.FinishOperationSuccess(0, true);
return(false);
}
uint dataRead = 0;
int offset = eventArgs.Offset;
int remainingCount = eventArgs.Count;
if (_inputStream.BufferedDataChunksAvailable)
{
dataRead = _inputStream.GetChunks(eventArgs.Buffer, eventArgs.Offset, eventArgs.Count);
if (_inputStream.BufferedDataChunksAvailable && dataRead == eventArgs.Count)
{
eventArgs.FinishOperationSuccess(eventArgs.Count, true);
return(false);
}
}
Debug.Assert(!_inputStream.BufferedDataChunksAvailable, "'m_InputStream.BufferedDataChunksAvailable' MUST BE 'FALSE' at this point.");
Debug.Assert(dataRead <= eventArgs.Count, "'dataRead' MUST NOT be bigger than 'eventArgs.Count'.");
if (dataRead != 0)
{
offset += (int)dataRead;
remainingCount -= (int)dataRead;
//the http.sys team recommends that we limit the size to 128kb
if (remainingCount > HttpRequestStream.MaxReadSize)
{
remainingCount = HttpRequestStream.MaxReadSize;
}
eventArgs.SetBuffer(eventArgs.Buffer, offset, remainingCount);
}
else if (remainingCount > HttpRequestStream.MaxReadSize)
{
remainingCount = HttpRequestStream.MaxReadSize;
eventArgs.SetBuffer(eventArgs.Buffer, offset, remainingCount);
}
uint flags = 0;
uint bytesReturned = 0;
uint statusCode =
Interop.HttpApi.HttpReceiveRequestEntityBody(
_inputStream.InternalHttpContext.RequestQueueHandle,
_inputStream.InternalHttpContext.RequestId,
flags,
(byte *)_webSocket !.InternalBuffer.ToIntPtr(eventArgs.Offset),
(uint)eventArgs.Count,
out bytesReturned,
eventArgs.NativeOverlapped);
if (statusCode != Interop.HttpApi.ERROR_SUCCESS &&
statusCode != Interop.HttpApi.ERROR_IO_PENDING &&
statusCode != Interop.HttpApi.ERROR_HANDLE_EOF)
{
throw new HttpListenerException((int)statusCode);
}
else if (statusCode == Interop.HttpApi.ERROR_SUCCESS &&
HttpListener.SkipIOCPCallbackOnSuccess)
{
// IO operation completed synchronously. No IO completion port callback is used because
// it was disabled in SwitchToOpaqueMode()
eventArgs.FinishOperationSuccess((int)bytesReturned, true);
completedAsynchronouslyOrWithError = false;
}
else if (statusCode == Interop.HttpApi.ERROR_HANDLE_EOF)
{
eventArgs.FinishOperationSuccess(0, true);
completedAsynchronouslyOrWithError = false;
}
else
{
completedAsynchronouslyOrWithError = true;
}
}
catch (Exception e)
{
_readEventArgs !.FinishOperationFailure(e, true);
_outputStream.SetClosedFlag();
_outputStream.InternalHttpContext.Abort();
completedAsynchronouslyOrWithError = true;
}
return(completedAsynchronouslyOrWithError);
}
public async Task <T> ReadMessage <T>(int size, CancellationToken ct = default, UInt32?checksum = null) where T : IStreamable, new()
{
top:
if (BufferedData >= size)
{
//we have enough data buffered
if (checksum.HasValue)
{
var chk = BitConverter.ToUInt32(InternalBuffer.Span.Slice(0, size).SHA256d());
if (chk != checksum.Value)
{
//skip this payload because checksum failed
if (BufferedData > size)
{
InternalBuffer.Span.Slice(size, BufferedData - size).CopyTo(InternalBuffer.Span);
BufferedData -= size;
}
throw new Exception("Checksum failed");
}
}
var obj = new T();
obj.ReadFromPayload(InternalBuffer.Span);
if (BufferedData > size)
{
//copy extra data to start of the buffer
InternalBuffer.Span.Slice(size, BufferedData - size).CopyTo(InternalBuffer.Span);
}
BufferedData -= size;
return(obj);
}
else
{
//resize the buffer
if (size > InternalBuffer.Length)
{
if (size > MemoryPool <byte> .Shared.MaxBufferSize)
{
throw new Exception($"Buffer size is larger than the max size {MemoryPool<byte>.Shared.MaxBufferSize}");
}
var newowner = MemoryPool <byte> .Shared.Rent((int)(Math.Ceiling(size / (decimal)InternalBufferSize) * InternalBufferSize));
var newbuf = newowner.Memory;
if (BufferedData > 0)
{
InternalBuffer.Slice(0, BufferedData).CopyTo(newbuf);
}
MemoryOwner.Dispose();
MemoryOwner = newowner;
InternalBuffer = newbuf;
}
read_more:
try
{
var rlen = await Stream.ReadAsync(InternalBuffer.Slice(BufferedData), ct);
BufferedData += rlen;
if (rlen == 0)
{
return(default);
public override void Write(byte[] buffer, int offset, int count)
{
InternalBuffer.Write(buffer, offset, count);
}
public override int Read(byte[] buffer, int offset, int count)
{
return(InternalBuffer.Read(buffer, offset, count));
}
public override void SetLength(long value)
{
InternalBuffer.SetLength(value);
}
public override long Seek(long offset, SeekOrigin origin)
{
return(InternalBuffer.Seek(offset, origin));
}
/// <summary>
/// Reads from the stream until a non-escaped segment terminator was reached.
/// Breaks if no segment terminator was encountered after 5000 symbols were read.
/// This is to avoid loading large and corrupt files.
/// </summary>
/// <returns>
/// An EDI segment.
/// </returns>
protected override string ReadSegment()
{
var line = "";
while (!StreamReader.EndOfStream || InternalBuffer.Any())
{
line = line + Read(1);
if (line.Length > 2)
{
var last3 = line.Substring(line.Length - 3);
Separators separators;
string probed;
if (TryReadHeader(last3, out probed, out separators))
{
Separators = separators;
Trims = Trims.Except(new[] { Separators.Segment }).ToArray();
line = probed;
}
else
{
if (!string.IsNullOrEmpty(probed))
{
Buffer(probed.Skip(3));
}
}
}
// Segment terminator may never be reached
if (line.Length > MaxSegmentLength)
{
// Reset and continue or break
if (ContinueOnError)
{
line = "";
}
else
{
throw new ReaderException(
string.Format("No segment was found before the buffer reached the allowed maximum of {0}.", MaxSegmentLength),
ReaderErrorCode.InvalidInterchangeContent);
}
}
if (Separators == null)
{
continue;
}
if (!line.EndsWith(Separators.Segment.ToString(), StringComparison.Ordinal))
{
continue;
}
if (Separators.Escape.HasValue &&
line.EndsWith(string.Concat(Separators.Escape.Value, Separators.Segment),
StringComparison.Ordinal))
{
continue;
}
var index = line.LastIndexOf(Separators.Segment.ToString(), StringComparison.Ordinal);
if (index > 0)
{
line = line.Remove(index);
}
if (!string.IsNullOrEmpty(line))
{
break;
}
}
return(line.Trim(Trims));
}
public byte[] ToBytes()
{
return(InternalBuffer.ToArray());
}
public void SetNextBuffer(InternalBuffer nextBuffer)
{
this.Next = nextBuffer;
}
public override void Flush()
{
InternalBuffer.Flush();
}
public string ConvertToONP(string infix)
{
int id = 0;
OutputOperationBuffer = new InternalBuffer<OutputOperation>();
InternalStack<Operator> stack = new InternalStack<Operator>();
string output = string.Empty;
char[] infixArray = infix.Trim().ToArray();
string input = infix;
OutputOperationBuffer.Push(new OutputOperation(id++, input, stack.ToReverseString(), output));
foreach (char infixChar in infixArray)
{
if(!string.IsNullOrEmpty(input))
input = input.Remove(0, 1);
if (!infixChar.IsOperator())
{
AddToOutput(ref output, infixChar);
OutputOperationBuffer.Push(new OutputOperation(id++, input, stack.ToReverseString(), output));
}
else if (infixChar == Operators.OpenBracket)
{
AddToOutput(ref output);
Operator newOperator = new Operator(infixChar);
stack.Push(newOperator);
OutputOperationBuffer.Push(new OutputOperation(id++, input, stack.ToReverseString(), output));
}
else if (infixChar == Operators.CloseBracket)
{
AddToOutput(ref output);
Operator newOperator = new Operator(infixChar);
while (stack.Any() && stack.Peek().OperatorType != Operators.OpenBracket)
{
AddToOutput(ref output, stack.Pop());
OutputOperationBuffer.Push(new OutputOperation(id++, input, stack.ToReverseString(), output));
}
stack.Pop();
OutputOperationBuffer.Push(new OutputOperation(id++, input, stack.ToReverseString(), output));
}
else
{
AddToOutput(ref output);
Operator newOperator = new Operator(infixChar);
while (stack.Any() && stack.Peek().Priority >= newOperator.Priority)
{
AddToOutput(ref output, stack.Pop());
}
stack.Push(newOperator);
OutputOperationBuffer.Push(new OutputOperation(id++, input, stack.ToReverseString(), output));
}
}
while (stack.Any())
{
AddToOutput(ref output, stack.Pop());
}
return output;
}