protected virtual bool ReceiveElement(T message)
{
if (IsActive)
{
if (TotalDemand > 0L)
{
OnNext(message);
}
else if (BufferSize == 0)
{
Log.Debug("Dropping element because there is no downstream demand: [{0}]", message);
}
else if (!Buffer.IsFull)
{
Buffer.Enqueue(message);
}
else
{
switch (OverflowStrategy)
{
case OverflowStrategy.DropHead:
Log.Debug("Dropping the head element because buffer is full and overflowStrategy is: [DropHead]");
Buffer.DropHead();
Buffer.Enqueue(message);
break;
case OverflowStrategy.DropTail:
Log.Debug("Dropping the tail element because buffer is full and overflowStrategy is: [DropTail]");
Buffer.DropTail();
Buffer.Enqueue(message);
break;
case OverflowStrategy.DropBuffer:
Log.Debug("Dropping all the buffered elements because buffer is full and overflowStrategy is: [DropBuffer]");
Buffer.Clear();
Buffer.Enqueue(message);
break;
case OverflowStrategy.DropNew:
// do not enqueue new element if the buffer is full
Log.Debug("Dropping the new element because buffer is full and overflowStrategy is: [DropNew]");
break;
case OverflowStrategy.Fail:
Log.Error("Failing because buffer is full and overflowStrategy is: [Fail]");
OnErrorThenStop(new BufferOverflowException($"Buffer overflow, max capacity was ({BufferSize})"));
break;
case OverflowStrategy.Backpressure:
// there is a precondition check in Source.actorRefSource factory method
Log.Debug("Backpressuring because buffer is full and overflowStrategy is: [Backpressure]");
break;
}
}
return(true);
}
return(false);
}
/**
* <summary>Serializes the object stream entries into the stream body.</summary>
*/
private void Flush(
IOutputStream stream
)
{
// 1. Body.
int dataByteOffset;
{
// Serializing the entries into the stream buffer...
IBuffer indexBuffer = new bytes.Buffer();
IBuffer dataBuffer = new bytes.Buffer();
IndirectObjects indirectObjects = File.IndirectObjects;
int objectIndex = -1;
File context = File;
foreach (KeyValuePair <int, ObjectEntry> entry in Entries)
{
int objectNumber = entry.Key;
// Update the xref entry!
XRefEntry xrefEntry = indirectObjects[objectNumber].XrefEntry;
xrefEntry.Offset = ++objectIndex;
/*
* NOTE: The entry offset MUST be updated only after its serialization, in order not to
* interfere with its possible data-object retrieval from the old serialization.
*/
int entryValueOffset = (int)dataBuffer.Length;
// Index.
indexBuffer
.Append(objectNumber.ToString()).Append(Chunk.Space) // Object number.
.Append(entryValueOffset.ToString()).Append(Chunk.Space); // Byte offset (relative to the first one).
// Data.
entry.Value.DataObject.WriteTo(dataBuffer, context);
entry.Value.offset = entryValueOffset;
}
// Get the stream buffer!
IBuffer body = Body;
// Delete the old entries!
body.Clear();
// Add the new entries!
body.Append(indexBuffer);
dataByteOffset = (int)body.Length;
body.Append(dataBuffer);
}
// 2. Header.
{
PdfDictionary header = Header;
header[PdfName.N] = PdfInteger.Get(Entries.Count);
header[PdfName.First] = PdfInteger.Get(dataByteOffset);
}
}
/// <summary>
/// Clears bytes from the stream.
/// </summary>
/// <param name="count">The number of bytes (from the current position) to clear.</param>
/// <remarks>
/// <para>Logically equivalent to writing <c>count</c> null/zero bytes to the stream, some
/// implementations determine that some (or all) of the range indicated is not actually
/// stored. There is no direct, automatic, correspondence to clearing bytes and them
/// not being represented as an 'extent' - for example, the implementation of the underlying
/// stream may not permit fine-grained extent storage.</para>
/// <para>It is always safe to call this method to 'zero-out' a section of a stream, regardless of
/// the underlying stream implementation.</para>
/// </remarks>
public override void Clear(int count)
{
if (!CanWrite)
{
throw new IOException("Attempt to erase bytes in a read-only stream");
}
_buffer.Clear(_position, count);
_position += count;
}
private void BufferElement(Offer <TOut> offer)
{
if (!_buffer.IsFull)
{
EnqueueAndSuccess(offer);
}
else
{
switch (_stage._overflowStrategy)
{
case OverflowStrategy.DropHead:
_buffer.DropHead();
EnqueueAndSuccess(offer);
break;
case OverflowStrategy.DropTail:
_buffer.DropTail();
EnqueueAndSuccess(offer);
break;
case OverflowStrategy.DropBuffer:
_buffer.Clear();
EnqueueAndSuccess(offer);
break;
case OverflowStrategy.DropNew:
offer.CompletionSource.SetResult(QueueOfferResult.Dropped.Instance);
break;
case OverflowStrategy.Fail:
var bufferOverflowException =
new BufferOverflowException($"Buffer overflow (max capacity was: {_stage._maxBuffer})!");
offer.CompletionSource.SetResult(new QueueOfferResult.Failure(bufferOverflowException));
_completion.SetException(bufferOverflowException);
FailStage(bufferOverflowException);
break;
case OverflowStrategy.Backpressure:
if (_pendingOffer != null)
{
offer.CompletionSource.SetException(
new IllegalStateException(
"You have to wait for previous offer to be resolved to send another request."));
}
else
{
_pendingOffer = offer;
}
break;
}
}
}
public void Return(IBuffer buffer)
{
if (!buffers.ContainsKey(buffer))
{
return;
}
buffer.Clear();
lock (locker)
{
buffers[buffer] = true;
currentCount++;
Monitor.PulseAll(locker);
}
logger.Debug($"{nameof(BufferPool)}. Buffer returned. Free buffers {currentCount}");
}
private bool TryStoreBufferedValues()
{
if (dataBuffer.IsEmpty())
{
return(true);
}
var packages = dataBuffer.GetValues();
try {
logger.Info("Отправка данных из буфера в ИТС. Данных для сохранения: " + packages.Length);
if (itsConnector.TryWritePackages(packages))
{
logger.Info("Очистка буфера.");
dataBuffer.Clear();
}
return(true);
}
catch (Exception ex) {
logger.Error("Ошибка при сохранении беферизированных данных.");
return(false);
}
}
private void reset()
{
EngineCurrentKeyPress.Reset();
EnginePatternWriter.Clear();
EngineBuffer.Clear();
}
/// <summary> /// TBD /// </summary> public void Clear() => _q.Clear();
/**
* <summary>Gets the stream body.</summary>
* <param name="decode">Defines whether the body has to be decoded.</param>
*/
public IBuffer GetBody(
bool decode
)
{
if (!bodyResolved)
{
/*
* NOTE: In case of stream data from external file, a copy to the local buffer has to be done.
*/
FileSpecification dataFile = DataFile;
if (dataFile != null)
{
Updateable = false;
body.Clear();
body.Write(dataFile.GetInputStream());
body.Dirty = false;
Updateable = true;
}
bodyResolved = true;
}
if (decode)
{
PdfDataObject filter = Filter;
if (filter != null) // Stream encoded.
{
header.Updateable = false;
PdfDataObject parameters = Parameters;
if (filter is PdfName) // Single filter.
{
body.Decode(
bytes.filters.Filter.Get((PdfName)filter),
(PdfDictionary)parameters
);
}
else // Multiple filters.
{
IEnumerator <PdfDirectObject> filterIterator = ((PdfArray)filter).GetEnumerator();
IEnumerator <PdfDirectObject> parametersIterator = (parameters != null ? ((PdfArray)parameters).GetEnumerator() : null);
while (filterIterator.MoveNext())
{
PdfDictionary filterParameters;
if (parametersIterator == null)
{
filterParameters = null;
}
else
{
parametersIterator.MoveNext();
filterParameters = (PdfDictionary)Resolve(parametersIterator.Current);
}
body.Decode(bytes.filters.Filter.Get((PdfName)Resolve(filterIterator.Current)), filterParameters);
}
}
// The stream is free from encodings.
Filter = null;
Parameters = null;
header.Updateable = true;
}
}
return(body);
}
public void Clear() => buffer.Clear();
public IBuffer GetBuffer()
{
buffer.Clear();
return(buffer);
}
public void Clear()
{
buffer.Clear();
}
private void ReadLine(IBuffer buffer, char maskChar)
{
int startPosition = Console.CursorLeft;
int position = 0;
int length = 0;
ConsoleKeyInfo keyInfo;
while ((keyInfo = Console.ReadKey(true)).Key != ConsoleKey.Enter)
{
switch (keyInfo.Key)
{
case ConsoleKey.Backspace:
if (position > 0)
{
buffer.DeleteChar(--position);
Write(startPosition + --length, ' ');
}
break;
case ConsoleKey.Escape:
case ConsoleKey.PageUp:
case ConsoleKey.UpArrow:
buffer.Clear();
for (; length >= 0; length--)
{
Write(startPosition + length, ' ');
}
position = length = 0;
break;
case ConsoleKey.PageDown:
case ConsoleKey.DownArrow:
break;
case ConsoleKey.LeftArrow:
position = Math.Max(position - 1, 0);
break;
case ConsoleKey.RightArrow:
position = Math.Min(position + 1, length);
break;
case ConsoleKey.Delete:
if (position < length)
{
buffer.DeleteChar(position);
Write(startPosition + --length, ' ');
}
break;
case ConsoleKey.Home:
position = 0;
break;
case ConsoleKey.End:
position = length;
break;
default:
buffer.InsertChar(position, keyInfo.KeyChar);
position++;
Write(startPosition + length, maskChar);
length++;
break;
}
Console.CursorLeft = position + startPosition;
}
Console.WriteLine();
}
