/// <summary>
/// Clears state.
/// </summary>
public void Clear()
{
EnsureInitialized();
m_CurrentMenu = default(MenuStackItem);
m_MenuStack.Clear();
foreach (var button in m_ActiveButtons)
{
button.transform.SetParent(m_ElementPool, false);
m_InactiveButtons.PushBack(button);
}
foreach (var text in m_ActiveTexts)
{
text.transform.SetParent(m_ElementPool, false);
m_InactiveTexts.PushBack(text);
}
foreach (var divider in m_ActiveDividers)
{
divider.transform.SetParent(m_ElementPool, false);
m_InactiveDividers.PushBack(divider);
}
m_ActiveButtons.Clear();
m_ActiveTexts.Clear();
m_ActiveDividers.Clear();
m_Header.Init(new DMHeaderInfo()
{
Label = string.Empty
}, false);
}
// xmodem format is
// <SOH>
// Block
// 255-Block
// 128 bytes of data
// Check Digit (sum of data bytes & 0xff)
// If block is valid, reply with <ACK>
// otherwise reply with <NAK>
// finally, if the block is <next block number> append data.
// If block is <last block number>, re-write previous block
private void ProcessBuffer()
{
Display.PrintClear("Receiving block " + CurrentBlock, false);
byte b = dataBuffer.Read();
byte checksum = 0;
int blockNo;
int blockCheck;
if (b != SOH)
{
return;
}
// Check the block number and the check-block
// if they don't match, dump and NAK
blockNo = dataBuffer.Read();
blockCheck = dataBuffer.Read();
if (blockNo != (255 - blockCheck) && blockNo != (127 - blockCheck))
{
Display.PrintClear("Invalid block number: " + blockNo.ToString() + "," + blockCheck.ToString(), true);
dataBuffer.Clear();
SendNAK();
return;
}
// if the received block number is the NEXT block
// advance the write pointer. Otherwise, we're getting
// the previous block again, so re-write the last block
if (blockNo == ((CurrentBlock + 1) % 256) || blockNo == ((CurrentBlock + 1) % 128))
{
CurrentBlock += 1;
FilePosition += DATA_LENGTH;
}
stream.Seek(FilePosition, SeekOrigin.Begin);
// get the block data
for (int i = 0; i < DATA_LENGTH; i++)
{
b = dataBuffer.Read();
stream.WriteByte(b);
checksum += b;
}
// get the checksum and send either an <ACK> or <NAK>
// depending on whether it matches
b = dataBuffer.Read();
if (b == checksum)
{
SendACK();
}
else
{
Display.PrintAtStart("\nInvalid Checksum. Expected " + checksum + " got " + b.ToString(), true);
dataBuffer.Clear();
SendByte(NAK);
}
}
public string DumpToString()
{
lock (bufferLock)
{
var dumpBuilder = new StringBuilder();
foreach (var msg in ringBuffer)
{
dumpBuilder.AppendLine(msg);
}
ringBuffer.Clear();
return(dumpBuilder.ToString());
}
}
/// <summary>
/// Sends Hayes Escape Sequence +++
/// </summary>
/// <param name="PauseBefore">Pause before sending the escape sequence</param>
/// <param name="PauseAfter">Pause after sending the escape sequence</param>
/// <param name="Timeout">Timeout in mSec to wait for response</param>
/// <returns>Response type, or ERROR if timed out</returns>
public ResponseCodes EscapeSequence(int PauseBefore, int PauseAfter, int Timeout)
{
// Check if disposed
if (_disposed)
{
throw new GM862Exception(GM862Exception.DISPOSED);
}
// Wait before we send first + sign
Thread.Sleep(PauseBefore);
// Set GM862 in COMMAND state
State = States.COMMAND;
// Send escape sequence
_uartSendString("+++");
// Clear input FIFO
lock (_inputFIFO)
_inputFIFO.Clear();
// Clear buffered line data
lock (_bufferedlinedata)
_bufferedlinedata = "";
// Wait after we send last + sign
Thread.Sleep(PauseAfter);
// Now wait for response
string ResponseBody;
return(WaitForResponse(out ResponseBody, Timeout));
}
private void sendData()
{
bool error = false;
if (rdText.Checked == true)
{
for (int i = 0; i < 128; i++)
{
package[i] = (byte)((i + this.counter) % 128);
}
timer1.Start();
timer2.Start();
rxbuffer.Clear();
txbuffer.Clear();
}
else
{
try
{
byte[] data = HexStringToByteArray(txtSend.Text);
ComPort.Write(data, 0, data.Length);
txtSend.Clear();
}
catch (FormatException) { error = true; }
catch (ArgumentException) { error = true; }
if (error)
{
MessageBox.Show(this, "Not properly formatted hex string: " + txtSend.Text + "\n" + "example: E1 FF 1B", "Format Error", MessageBoxButtons.OK, MessageBoxIcon.Stop);
}
}
}
public void Clear()
{
m_Locked = false;
m_Nodes.Clear();
m_Edges.Clear();
m_Meta.Clear();
}
static public void ExpandingRingBufferTest()
{
RingBuffer <int> buffer = new RingBuffer <int>();
buffer.PushBack(5);
buffer.PushBack(16);
buffer.PushBack(17);
Assert.Greater(buffer.Capacity, 0);
Assert.AreEqual(5, buffer.PopFront());
Assert.AreEqual(17, buffer.PopBack());
buffer.Clear();
Assert.AreEqual(0, buffer.Count);
buffer.PushBack(5);
buffer.PushBack(6);
buffer.PushBack(7);
buffer.PushBack(8);
buffer.PushBack(9);
buffer.SetCapacity(16);
}
public void ClearAsExpected()
{
RingBuffer <int> _buffer = new RingBuffer <int>(iterations);
populateBuffer(iterations, _buffer);
_buffer.Clear();
Assert.AreEqual(0, _buffer.Count);
}
public void ClearTest_notempty()
{
RingBuffer<int> rb = new RingBuffer<int>(4);
rb.Add(7);
Assert.IsFalse(rb.IsEmpty);
rb.Clear();
Assert.IsTrue(rb.IsEmpty);
}
void ResetHandler()
{
_startSignal = false;
if (audioBuffer != null)
{
audioBuffer.Clear();
}
count = 0;
}
public void Open()
{
if (buffer == null || buffer.Capacity != totalWidth)
{
buffer = new RingBuffer <Pose>(totalWidth);
}
buffer.Clear();
OnOpen();
}
public void Clear()
{
var target = new RingBuffer <int>(3)
{
-100, 300, -200, 400
};
target.Clear();
Assert.AreEqual(0, target.Count);
}
public void WhenRingBufferHasBeenClearedIsEmptyFlagShouldBeSetToTrue()
{
var buffer = new RingBuffer <int>(2);
buffer.Enqueue(2);
buffer.Enqueue(1);
buffer.Clear();
Assert.Equal(buffer.IsEmpty, true);
}
public void AssertThat_Clear_ClearsAllData()
{
var b = new RingBuffer <int>(4)
{
1, 2, 3, 4, 5
};
Assert.AreEqual(4, b.Count);
b.Clear();
Assert.AreEqual(0, b.Count);
}
public void WhenClearedSetIsEmptyFlagToTrue()
{
RingBuffer <int> buffer = new RingBuffer <int>(3);
buffer.Enqueue(7);
buffer.Enqueue(8);
buffer.Enqueue(9);
buffer.Clear();
Assert.AreEqual(true, buffer.IsEmpty);
}
/// <summary>
/// Stops the performance tracker and clears all recorded timings.
/// </summary>
public void Stop()
{
VerifyNotDisposed();
m_FirstTick = true;
m_FrameStopwatch.Stop();
m_RenderStopwatch.Stop();
UnhookCameras();
m_FrameTimeBuffer.Clear();
m_RenderTimeBuffer.Clear();
}
protected virtual void FixedUpdate()
{
if (interactionHand.isTracked && interactionHand.primaryHoveredObject != null)
{
Vector3 tipPos = interactionHand.leapHand.GetIndex().TipPosition.ToVector3();
_indexPosBuffer.Add(tipPos);
}
else
{
_indexPosBuffer.Clear();
}
}
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);
}
private void OnApplicationPause(bool pause)
{
if (pause)
{
_startSignal = false;
if (audioBuffer != null)
{
audioBuffer.Clear();
}
count = 0;
}
else
{
Debug.Log("Application resumed.");
}
}
public override void Flush()
{
if (m_ReadBuffer != null && m_ReadBuffer.Length > 0)
{
m_ReadBuffer.Clear();
}
if (m_WriteBuffer != null && m_WriteBuffer.Length > 0)
{
using (NetworkConnection im = new NetworkConnection(FullName, m_Credentials))
{
byte[] tmp = new byte[m_WriteBuffer.Length];
base.Write(tmp, 0, tmp.Length);
tmp = null;
}
m_WriteBuffer.Clear();
}
}
private void SendDataLoop()
{
byte[] tmpBuf = new byte[64 * 1024];
int tmpBufSize = 0;
int dataLen = 0;
int hasSendDataLen = 0;
while (m_TcpSocket.Connected)
{
if (m_SendBuffer.DataCount == 0 && hasSendDataLen == tmpBufSize)
{
Thread.Sleep(10);
continue;
}
else if (hasSendDataLen < tmpBufSize)
{
}
else
{
lock (m_SendBuffer)
{
tmpBufSize = m_SendBuffer.DataCount;
m_SendBuffer.ReadBuffer(tmpBuf, 0, m_SendBuffer.DataCount);
m_SendBuffer.Clear(m_SendBuffer.DataCount);
}
}
if (m_TcpSocket.Poll(10 * 1000, SelectMode.SelectWrite))
{
dataLen = m_TcpSocket.Send(tmpBuf, hasSendDataLen, tmpBufSize, SocketFlags.None);
hasSendDataLen += dataLen;
if (hasSendDataLen == tmpBufSize)
{
Array.Clear(tmpBuf, 0, tmpBufSize);
tmpBufSize = 0;
hasSendDataLen = 0;
}
}
}
Debug.Log("SendDataLoop Exit...");
CloseConnection();
}
public void BeginTrackingStroke()
{
if (_isBufferingStroke)
{
Debug.LogError("[StrokeProcessor] Stroke in progress; cannot begin new stroke. Call EndStroke() to finalize the current stroke first.");
return;
}
_isBufferingStroke = true;
_strokeBuffer.Clear();
_actualizedStrokeIdxBuffer.Clear();
for (int i = 0; i < _strokeFilters.Count; i++)
{
_strokeFilters[i].Reset();
}
for (int i = 0; i < _strokeBufferRenderers.Count; i++)
{
_strokeBufferRenderers[i].InitializeRenderer();
}
}
public void Reset()
{
if (workSocket != null)
{
workSocket.Close();
}
workSocket = null;
state = EConnectorState.Initial;
isReceiving = false;
isSending = false;
if (sendCache != null)
{
sendCache.Clear();
}
if (receiveCache != null)
{
receiveCache.Clear();
}
}
public void OnDrawRuntimeGizmos(RuntimeGizmoDrawer drawer)
{
if (!this.enabled || !this.gameObject.activeInHierarchy || !drawDebug)
{
return;
}
drawer.color = LeapColor.purple;
var poseRadius = 0.004f;
if (!Application.isPlaying)
{
_debugPoseBuffer.Clear();
_debugPoseBuffer.Add(GetTipPose());
_debugActivatedBuffer.Clear();
_debugActivatedBuffer.Add(false);
}
for (int i = 0; i < _debugPoseBuffer.Count; i++)
{
var pose = _debugPoseBuffer.Get(i);
var isActive = _debugActivatedBuffer.Get(i);
var a = pose.position + pose.rotation * Vector3.right * radius;
var b = pose.position - pose.rotation * Vector3.right * radius;
var multiplier = 1f;
if (isActive)
{
multiplier = 2.5f;
}
if (isActive || drawDebugIdlePaths || !Application.isPlaying)
{
drawer.DrawPose(new Pose(a, pose.rotation), poseRadius * multiplier);
drawer.DrawPose(new Pose(b, pose.rotation), poseRadius * multiplier);
}
}
}
public void GetEnumeratorTest()
{
RingBuffer <string> ring = new RingBuffer <string>(3);
ring.Write("aaa");
ring.Write("bbb");
ring.Write("ccc");
ring.Write("ddd");
IEnumerator <string> en = ring.GetEnumerator();
int conta = 0;
while (en.MoveNext())
{
if (conta == 0)
{
Assert.AreEqual(en.Current, "bbb");
}
if (conta == 1)
{
Assert.AreEqual(en.Current, "ccc");
}
if (conta == 2)
{
Assert.AreEqual(en.Current, "ddd");
}
++conta;
}
ring.Clear();
Assert.IsTrue(ring.Count == 0);
IEnumerator <string> en2 = ring.GetEnumerator();
Assert.IsFalse(en.MoveNext());
}
public virtual void Clear()
{
_buffer.Clear();
}
public void ClearAsExpected() {
RingBuffer<int> _buffer = new RingBuffer<int>(iterations);
populateBuffer(iterations, _buffer);
_buffer.Clear();
Assert.AreEqual(0, _buffer.Count);
}
/// <summary>
/// Clears all elements.
/// </summary>
public DMInfo Clear()
{
Elements.Clear();
return(this);
}
public void Clear()
{
samples.Clear();
}
/// <summary>
/// Clears all values from this table.
/// </summary>
public void Clear()
{
m_Values.Clear();
m_Optimized = true;
}
public void Open()
{
_poseBuffer.Clear();
OnOpen();
}
public void Open()
{
_buffer.Clear();
OnOpen();
}