public void BasicOperations()
{
using (var buf = new RingBuffer()) {
Assert.Equal(0, buf.BytesAvailable());
Assert.Equal(8191, buf.WriteBytesAvailable()); // implementation dependent.
using (var synth = new SynthUnit(buf)) {
var bytes = new byte [] { 0x90, 0x30, 0 }; // note on at 0x30, but with no velocity = no sound.
buf.Write(bytes, 0, bytes.Length);
var results = new short [1024];
Assert.Equal(3, buf.BytesAvailable());
synth.Init(44100);
synth.GetSamples(results, 0, results.Length);
Assert.All(results, r => Assert.Equal(0, r));
bytes = new byte [] { 0x90, 0x30, 100 }; // now give vel = 100
buf.Write(bytes, 0, bytes.Length);
synth.GetSamples(results, 0, results.Length);
Assert.Contains(results, r => r != 0);
// to see what's being generated, enable these lines.
//var str = string.Concat (results.Select (s => s.ToString ("X04")));
//Console.WriteLine (str);
}
}
}
public int Write(IReadOnlyTimeLocatedBuffer1D <T> source, int offset, int elements)
{
var written = _buffer.Write(source.Data, offset, elements);
Time = Time.Increment(written, Samplerate);
return(written);
}
// Data recieved handler
void _uart_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
int BytesToRead;
// Only accept char data
if (e.EventType == SerialData.Eof)
{
return;
}
// Get number of bytes to read
lock (_uart)
{
BytesToRead = _uart.BytesToRead;
}
// First read large chuncks
while (BytesToRead >= _readHelper.Length)
{
// Read large chunck of data to fifo
lock (_uart)
{
_uart.Read(_readHelper, 0, _readHelper.Length);
}
// Lock the input FIFO
lock (_inputFIFO)
{
_inputFIFO.Write(_readHelper);
}
// Check for new buffer length
BytesToRead = _uart.BytesToRead;
}
// Exit if no more bytes to read
if (BytesToRead <= 0)
{
return;
}
// Create buffer for remaing bytes to read
byte[] remainingData = new byte[BytesToRead];
// Read rest of the data from FIFO
lock (_uart)
{
_uart.Read(remainingData, 0, remainingData.Length);
}
// Lock the input FIFO
lock (_inputFIFO)
{
_inputFIFO.Write(remainingData);
}
}
public int Write(IReadOnlyTimeLocatedBufferFFT source, int offsetFrames, int frames)
{
var written = _buffer.Write(source.Data, offsetFrames * FrameSize, frames * FrameSize);
if (written % FrameSize != 0)
{
throw new InvalidOperationException();
}
Time = Time.Increment(written * 2, Samplerate);
return(written / FrameSize);
}
public void RingBufferClearTest()
{
int capacity = 5;
RingBuffer <string> target = new RingBuffer <string>(capacity);
target.Write("100");
Assert.IsTrue(target.HeadElement.Equals("100"));
target.Write("200");
Assert.IsTrue(target.HeadElement.Equals("200"));
target.Clear();
Assert.IsTrue(target.Count == 0);
Assert.IsTrue(target.HeadElement == null);
}
public void TestBufferReuse()
{
var ringBuffer = new RingBuffer(12); // 16 cap
var data = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
ringBuffer.Write(data);
ringBuffer.Read();
ringBuffer.Write(data);
var read = ringBuffer.Read();
Assert.AreEqual(10, read.Length);
Assert.AreEqual(1, read[0]);
Assert.AreEqual(10, read[9]);
}
public void WriteReadSingle()
{
Assert.AreEqual(32, RingBuffer.Capacity);
Assert.AreEqual(32, RingBuffer.WriteAvailable);
Assert.AreEqual(0, RingBuffer.ReadAvailable);
RingBuffer.Write(1);
Assert.AreEqual(32, RingBuffer.Capacity);
Assert.AreEqual(31, RingBuffer.WriteAvailable);
Assert.AreEqual(1, RingBuffer.ReadAvailable);
Assert.AreEqual(1, RingBuffer.Read());
}
public void TestCanRead()
{
var ringBuffer = new RingBuffer();
var buffer = new byte[] { 1, 2, 3, 4, 5 };
ringBuffer.Write(buffer);
Assert.AreEqual(true, ringBuffer.CanRead(4));
Assert.AreEqual(true, ringBuffer.CanRead(5));
Assert.AreEqual(false, ringBuffer.CanRead(6));
ringBuffer.Write(buffer);
Assert.AreEqual(true, ringBuffer.CanRead(9));
Assert.AreEqual(true, ringBuffer.CanRead(10));
Assert.AreEqual(false, ringBuffer.CanRead(11));
}
private void OnReceived(IAsyncResult ar)
{
try
{
int bytesRead = socket.EndReceive(ar);
if (bytesRead > 0)
{
if (enableMultiBytes)
{
queue.Write(buffer, 0, bytesRead);
Array.Clear(buffer, 0, bytesRead);
GetPacket();
}
else
{
byte[] data = new byte[bytesRead];
Buffer.BlockCopy(buffer, 0, data, 0, bytesRead);
Array.Clear(buffer, 0, bytesRead);
socket.BeginReceive(buffer, 0, buffersize, 0, new AsyncCallback(OnReceived), null);
Received?.Invoke(this, bytesRead, data);
}
}
else
{
Close();
}
}
catch (Exception e)
{
if (e is Win32Exception w && w.ErrorCode == 10054)
{
Disconnected?.Invoke(this);
}
public void Receive(List <AudioSenderPacket> audioPackets, RingBuffer ringBuffer)
{
audioPackets.Sort((x, y) => x.frameId.CompareTo(y.frameId));
float[] pcm = new float[KinectSpeaker.KH_SAMPLES_PER_FRAME * KinectSpeaker.KH_CHANNEL_COUNT];
int index = 0;
while (ringBuffer.FreeSamples >= pcm.Length)
{
if (index >= audioPackets.Count)
{
break;
}
var audioPacketData = audioPackets[index++];
if (audioPacketData.frameId <= lastAudioFrameId)
{
continue;
}
opusDecoder.Decode(audioPacketData.opusFrame, pcm, KinectSpeaker.KH_SAMPLES_PER_FRAME);
ringBuffer.Write(pcm);
lastAudioFrameId = audioPacketData.frameId;
}
}
public void LoadAll()
{
if (!File.Exists(SaveFile))
{
return;
}
using (var r = new BinaryReader(new FileStream(SaveFile, FileMode.Open)))
{
try
{
var count = r.ReadInt32();
var data = r.ReadBytes((int)r.BaseStream.Length);
var buff = new RingBuffer();
buff.Write(data);
FC.For(count, (i) =>
{
var replay = buff.Read <BattleReplay>();
replays.Add(replay);
});
}
catch (Exception)
{
replays.Clear();
}
finally
{
r.Close();
}
}
}
public void Listen()
{
ReadAsync(Stream, 0, x =>
{
RingBuffer.Write(x);
});
}
protected void ProcessRingBuffer(byte[] data)
{
try
{
if (_device == null)
{
return;
}
bool found = false;
byte[] buff;
bool dataAdded;
Process:
dataAdded = false;
if (!_ringBuffer.IsFull)
{
_ringBuffer.Write(data, 0, data.Length);
dataAdded = true;
}
if (DoParse != null)
{
found = false;
buff = DoParse(_device.GetType(), _ringBuffer);
while (buff != null)
{
found = true;
_device.UpdateData(buff);
buff = DoParse(_device.GetType(), _ringBuffer);
}
}
// incase no data package found
// Remove unidentified bytes from buffer to release spaces
if (!found && _ringBuffer.IsFull)
{
var byteToRelease = _ringBuffer.Capacity - 200;
if (byteToRelease < 0)
{
byteToRelease = _ringBuffer.Capacity - 100;
}
var unusedBytes = new byte[byteToRelease];
_ringBuffer.Read(unusedBytes, 0, byteToRelease);
}
if (!dataAdded)
{
goto Process;
}
}
catch (Exception ex)
{
LogService.Logger.Error("ProcessRingBuffer", ex);
}
}
public void TestReadWrite()
{
var ringBuffer = new RingBuffer();
var buffer = new byte[] { 1, 2, 4, 5 };
ringBuffer.Write(buffer, 1, 2);
var read = ringBuffer.Read();
Assert.AreEqual(2, read.Length);
Assert.AreEqual(2, read[0]);
Assert.AreEqual(4, read[1]);
ringBuffer = new RingBuffer();
buffer = new byte[] { 1, 2, 3, 4, 5 };
ringBuffer.Write(buffer, 2);
buffer = new byte[5];
var readCount = ringBuffer.Read(buffer, 2);
Assert.AreEqual(3, readCount);
Assert.AreEqual(0, buffer[0]);
Assert.AreEqual(0, buffer[1]);
Assert.AreEqual(3, buffer[2]);
Assert.AreEqual(4, buffer[3]);
Assert.AreEqual(5, buffer[4]);
}
private void SocketClient_BinaryInput(byte[] data,int offset,int lengt)
{
RingBuffer.Write(data,offset,lengt);
while (RingBuffer.Read(out byte[] pdata))
BinaryInput?.Invoke(pdata);
}
public void TestFullBuffer()
{
var ringBuffer = new RingBuffer(4); // 4 cap
var buffer = new byte[] { 1, 2, 3, 4, 5 };
var write = ringBuffer.Write(buffer);
Assert.AreEqual(4, write);
Assert.AreEqual(0, ringBuffer.WriteableCapacity);
Assert.AreEqual(4, ringBuffer.ReadableCapacity);
write = ringBuffer.Write(buffer);
Assert.AreEqual(0, write);
Assert.AreEqual(0, ringBuffer.WriteableCapacity);
Assert.AreEqual(4, ringBuffer.ReadableCapacity);
}
public override void Write(byte[] buffer, int offset, int count)
{
var ret = RingBuffer.Write(buffer, offset, count);
if (ret != count)
{
throw (new OverflowException());
}
}
public void TestCanWrite()
{
var ringBuffer = new RingBuffer(12); // 16 cap
Assert.AreEqual(true, ringBuffer.CanWrite(15));
Assert.AreEqual(true, ringBuffer.CanWrite(16));
Assert.AreEqual(false, ringBuffer.CanWrite(17));
ringBuffer.Write(new byte[] { 1, 2, 3, 4, 5 });
Assert.AreEqual(true, ringBuffer.CanWrite(10));
Assert.AreEqual(true, ringBuffer.CanWrite(11));
Assert.AreEqual(false, ringBuffer.CanWrite(12));
ringBuffer.Write(new byte[] { 1, 2, 3, 4, 5 }, 3);
Assert.AreEqual(true, ringBuffer.CanWrite(8));
Assert.AreEqual(true, ringBuffer.CanWrite(9));
Assert.AreEqual(false, ringBuffer.CanWrite(10));
}
long ServerRedi_newSendOrderRequest(Order o)
{
if (o.id == 0)
{
o.id = _idt.AssignId;
}
v("received order request: " + o.ToString());
_neworders.Write(o);
return((long)MessageTypes.OK);
}
public void FillBufferNoMoreItemsAreAdded()
{
//Arrange
const int capacity = 256;
RingBuffer<object> ringBuffer = new RingBuffer<object>(capacity, i => new RingBufferItem<object>(i));
Assert.AreEqual(256, ringBuffer.Capacity);
//act
for (int i = 0; i < capacity; i++)
{
var indexUsed = ringBuffer.Write(new object());
Assert.AreEqual(i, indexUsed, "The write index should match the loop index");
}
//Assert
var index = ringBuffer.Write(new object());
Assert.AreEqual(-1, index);
}
public long ServerRealTick_newSendOrderRequest(Order o)
{
if (o.id == 0)
{
o.id = _idt.AssignId;
}
_neworders.Write(o);
return((long)MessageTypes.OK);
}
private void Client_BinaryInput(byte[] data)
{
RingBuffer.Write(data);
byte[] pdata;
while (RingBuffer.Read(out pdata))
{
DataOn(pdata);
}
}
void ServerRealTick_newRegisterSymbols(string client, string symbols)
{
debug("Subscribe request: " + symbols);
if (!isConnected)
{
debug("not connected.");
return;
}
// save list of symbols to subscribe
_newsymlist = AllClientBasket.ToString();
// notify other thread to subscribe to them
_newsyms.Write(true);
}
public override void PushDown(byte[] bData, bool bPush)
{
lock (rbSendBuffer)
{
//rbSendBuffer.Write(bData, 0, bData.Length);
switch (TCPState)
{
case TCPSocketState.CloseWait:
case TCPSocketState.Established:
rbSendBuffer.Write(bData, 0, bData.Length);
if (bPush || rbSendBuffer.Count >= tcb.SND_WND)
{
Flush();
}
break;
case TCPSocketState.Listen:
rbSendBuffer.Write(bData, 0, bData.Length);
Connect();
break;
case TCPSocketState.SynReceived:
case TCPSocketState.SynSent:
rbSendBuffer.Write(bData, 0, bData.Length);
break;
case TCPSocketState.Closing:
case TCPSocketState.TimeWait:
case TCPSocketState.Closed:
case TCPSocketState.FinWait1:
case TCPSocketState.FinWait2:
case TCPSocketState.LastAck:
throw new InvalidOperationException("Trying to send data is not possible while no connection has been established");
}
}
}
protected override void OnInitialized()
{
if (RealtimeConnection is null || Configuration is null)
{
Updates = new RingBuffer <string>(capacity: 0);
return;
}
Updates = new RingBuffer <string>(Configuration.GetValue(key: "Updates-BufferSize", defaultValue: 10));
PrimeUpdates();
RealtimeConnection.Closed += async _ =>
{
ErrorMessage = Empty;
Connected = false;
if (Receive)
{
await RealtimeConnection.StartAsync();
}
};
RealtimeConnection.Reconnected += _ =>
{
ErrorMessage = Empty;
Connected = true;
return(CompletedTask);
};
RealtimeConnection.Reconnecting += _ =>
{
ErrorMessage = Empty;
Connected = false;
return(CompletedTask);
};
RealtimeConnection.On <string>
(
methodName: "statusUpdate"
, status =>
{
Updates.Write(status);
StateHasChanged();
}
);
}
/// <summary>
/// Writes the given bytes to the network stream.
/// </summary>
/// <param name="buffer">The buffer to write.</param>
/// <param name="offset">The offset in buffer where writing starts.</param>
/// <param name="count">The count of bytes to write.</param>
/// <param name="bPush">A bool indicating whether a push flag should be set for the bites written.</param>
public override void Write(byte[] buffer, int offset, int count, bool bPush)
{
lock (oPushSync)
{
iWriteCount += count;
iWriteCount %= rfBuffer.Length;
if (bPush)
{
Flush();
}
}
rfBuffer.Write(buffer, offset, count);
}
public void RingBufferWrite()
{
RingBuffer <int> ring = new RingBuffer <int>(3);
Assert.IsTrue(ring.Count == 0);
Assert.IsFalse(ring.IsFull);
Assert.IsTrue(ring.IsEmpty);
ring.Write(1);
Assert.IsTrue(ring.Count == 1);
Assert.IsFalse(ring.IsFull);
Assert.IsFalse(ring.IsEmpty);
ring.Write(2);
Assert.IsTrue(ring.Count == 2);
Assert.IsFalse(ring.IsFull);
Assert.IsFalse(ring.IsEmpty);
ring.Write(3);
Assert.IsTrue(ring.IsFull);
Assert.IsFalse(ring.IsEmpty);
ring.Write(4);
Assert.IsTrue(ring.Count == 3);
Assert.IsTrue(ring.IsFull);
Assert.IsFalse(ring.IsEmpty);
}
public void RingBufferReadTest()
{
RingBuffer <string> ring = new RingBuffer <string>(3);
ring.Write("q");
Assert.IsTrue(ring.Count == 1);
string s = ring.Read();
Assert.AreEqual(s, "q");
Assert.IsTrue(ring.IsEmpty);
ring.Write("aaa");
ring.Write("bbb");
ring.Write("ccc");
ring.Write("ddd");
string s2 = ring.Read();
Assert.AreEqual(s2, "bbb");
string s3 = ring.Read();
Assert.AreEqual(s3, "ccc");
Assert.IsTrue(ring.Count == 1);
}
void tl_newRegisterSymbols(string client, string symbols)
{
////test();
//string[] syms = tl.AllClientBasket.ToString().Split(',');
////m_Quotes.UnadviseAll(this);
//for (int i = 0; i < syms.Length; i++)
//{
// if (syms[i].Contains("."))
// {
// //we can reasonably assume this is an options request
// //m_Quotes.AdviseSymbol(this, syms[i], (int)enumQuoteServiceFlags.qsfOptions);
// }
// else if (syms[i].Contains("/"))
// {
// //we know (or can at least reasonably assume) this is forex
// //advise only level1 bid-ask quotes
// // m_Quotes.AdviseSymbol(this, syms[i], (int)enumQuoteServiceFlags.qsfLevelOne);
// //m_Quotes.AdviseSymbol(this, syms[i], (int)enumQuoteServiceFlags.qsfLevelTwo);
// }
// else
// {
// //probably equity, advise time and sales
// //m_Quotes.AdviseSymbol(this, syms[i], ((int)enumQuoteServiceFlags.qsfTimeAndSales));
// GetQuote(syms[i]);
// }
//}
//debug("Symbol Registered " + syms[syms.Length - 1]);
//
// get original basket
Basket org = BasketImpl.FromString(symquotes);
// if we had something before, check if something was removed
if (org.Count > 0)
{
Basket rem = BasketImpl.Subtract(org, tl.AllClientBasket);
foreach (Security s in rem)
{
removesym.Write(s.Symbol);
}
}
symquotes = tl.AllClientBasket.ToString();
if (VerboseDebugging)
{
debug("client subscribe request received: " + symquotes);
}
_symsq.Write(true);
}
public void TestOutOffset()
{
var ringBuffer = new RingBuffer(4); // 4 cap
var buffer = new byte[5];
ExceptionAssert.Throws <ArgumentOutOfRangeException>(() =>
{
ringBuffer.Read(buffer, 2, 10);
});
ExceptionAssert.Throws <ArgumentOutOfRangeException>(() =>
{
ringBuffer.Write(buffer, 2, 10);
});
}
long tl_newSendOrderRequest(Order o)
{
if (!m_bGrayBoxRunning)
{
debug("Graybox got disconnected");
return((long)MessageTypes.BROKERSERVER_NOT_FOUND);
}
if (o.id == 0)
{
o.id = _idt.AssignId;
}
_orderq.Write(o);
return((long)MessageTypes.OK);
}
public void TestByteRingBuffer()
{
var CurrentEncoding = Encoding.UTF8;
int BufferSize = 1024;
var Buffer = new RingBuffer<byte>(BufferSize);
// Initial check
Assert.AreEqual(BufferSize, Buffer.AvailableForWrite);
Assert.AreEqual(0, Buffer.AvailableForRead);
// Try peek
CollectionAssert.AreEqual(new byte[0], Buffer.PeekGet(16));
// Write
var DataToWrite = CurrentEncoding.GetBytes("Hello World");
Buffer.Write(DataToWrite);
Assert.AreEqual(BufferSize - DataToWrite.Length, Buffer.AvailableForWrite);
Assert.AreEqual(0 + DataToWrite.Length, Buffer.AvailableForRead);
}
public void ConcurrentReadWrite()
{
//Arrange
const int capacity = 128;
RingBuffer<object> ringBuffer = new RingBuffer<object>(capacity, i => new RingBufferItem<object>(i));
AutoResetEvent resetEvent = new AutoResetEvent(false);
Action writerAction = () =>
{
for (int i = 0; i < capacity; i++)
{
int writeIndex = ringBuffer.Write(new object());
Assert.AreEqual(i, writeIndex);
resetEvent.Set();
}
};
Action readerAction = () =>
{
for (int i = 0; i < capacity; i++)
{
int readIndex;
object read = ringBuffer.Read(out readIndex);
if (readIndex < 0)
{
resetEvent.WaitOne(100);
read = ringBuffer.Read(out readIndex);
}
Assert.AreEqual(i, readIndex, "readIndex does not equal loop index.");
Assert.IsNotNull(read, "read object in null");
}
};
Parallel.Invoke(writerAction, readerAction);
}
public void FillBufferThenReadHalfThenWriteHalf()
{
//Arrange
const int capacity = 256;
RingBuffer<object> ringBuffer = new RingBuffer<object>(capacity, i => new RingBufferItem<object>(i));
Assert.AreEqual(256, ringBuffer.Capacity);
//act
for (int i = 0; i < capacity; i++)
{
var indexUsed = ringBuffer.Write(new object());
Assert.AreEqual(i, indexUsed, "The write index should match the loop index");
}
//The buffer should be full, so no more writes are allowed
var index = ringBuffer.Write(new object());
Assert.AreEqual(-1, index);
for (int i = 0; i < capacity / 2; i++)
{
int readIndex;
var item = ringBuffer.Read(out readIndex);
Assert.IsNotNull(item, "Item should not be null");
Assert.AreEqual(i, readIndex, "The Read index should be same as the loop index");
}
//Write again from the beginning
for (int i = 0; i < capacity / 2; i++)
{
var indexUsed = ringBuffer.Write(new object());
Assert.AreEqual(i, indexUsed, "The write index should match the loop index");
}
//Assert
index = ringBuffer.Write(new object());
Assert.AreEqual(-1, index);
}
public void FillHalfTheBufferThenReadAll()
{
//Arrange
const int capacity = 256;
RingBuffer<object> ringBuffer = new RingBuffer<object>(capacity, index => new RingBufferItem<object>(index));
Assert.AreEqual(256, ringBuffer.Capacity);
//act
for (int j = 0; j < capacity / 2; j++)
{
var indexUsed = ringBuffer.Write(new object());
Assert.AreEqual(j, indexUsed, "The write index should match the loop index");
}
int i;
int readIndex = 0;
for (i = 0; i < capacity; i++)
{
var item = ringBuffer.Read(out readIndex);
if (readIndex == -1)
break;
Assert.IsNotNull(item);
Assert.AreEqual(i, readIndex, "The Read index should be same as the loop index");
}
//Assert
Assert.AreEqual(-1, readIndex);
Assert.AreEqual(capacity / 2, i);
}
