void ICollection.CopyTo(Array array, int index)
{
if (array is T[] arrayAs)
{
_InternalQueue.CopyTo(arrayAs, index);
}
else
{
throw new ArgumentNullException(nameof(array));
}
}
public static void Test7_Exceptions()
{
ConcurrentQueue<int> queue = null;
Assert.Throws<ArgumentNullException>(
() => queue = new ConcurrentQueue<int>((IEnumerable<int>)null));
// "Test7_Exceptions: The constructor didn't throw ANE when null collection passed");
queue = new ConcurrentQueue<int>();
//CopyTo
Assert.Throws<ArgumentNullException>( () => queue.CopyTo(null, 0));
// "Test7_Exceptions: CopyTo didn't throw ANE when null array passed");
Assert.Throws<ArgumentOutOfRangeException>( () => queue.CopyTo(new int[1], -1));
// "Test7_Exceptions: CopyTo didn't throw AORE when negative array index passed");
}
public static void Test7_Exceptions()
{
ConcurrentQueue <int> queue = null;
Assert.Throws <ArgumentNullException>(
() => queue = new ConcurrentQueue <int>((IEnumerable <int>)null));
// "Test7_Exceptions: The constructor didn't throw ANE when null collection passed");
queue = new ConcurrentQueue <int>();
//CopyTo
Assert.Throws <ArgumentNullException>(() => queue.CopyTo(null, 0));
// "Test7_Exceptions: CopyTo didn't throw ANE when null array passed");
Assert.Throws <ArgumentOutOfRangeException>(() => queue.CopyTo(new int[1], -1));
// "Test7_Exceptions: CopyTo didn't throw AORE when negative array index passed");
}
public void CopyTo_AllItemsCopiedAtCorrectLocation(int count, bool viaInterface)
{
var q = new ConcurrentQueue <int>(Enumerable.Range(0, count));
var c = (ICollection)q;
int[] arr = new int[count];
if (viaInterface)
{
c.CopyTo(arr, 0);
}
else
{
q.CopyTo(arr, 0);
}
//Assert.AreEqual(q, arr);
if (!q.SequenceEqual(arr))
{
Assert.Fail("The copy was unsuccessful");
}
if (count > 1)
{
int toRemove = count / 2;
int remaining = count - toRemove;
for (int i = 0; i < toRemove; i++)
{
int item;
Assert.IsTrue(q.TryDequeue(out item));
Assert.AreEqual(i, item);
}
if (viaInterface)
{
c.CopyTo(arr, 1);
}
else
{
q.CopyTo(arr, 1);
}
Assert.AreEqual(0, arr[0]);
for (int i = 0; i < remaining; i++)
{
Assert.AreEqual(arr[1 + i], i + toRemove);
}
}
}
public int Save(Server S, string s = "")
{
string Identifier = AlphaNum.Replace(s.Trim().ToLower(), "");
if (Identifier == string.Empty)
{
Identifier = S.Id.ToString();
}
SongData[] Data;
if (CurrentSong != null)
{
Data = new SongData[SongQueue.Count + 1];
Data[0] = CurrentSong.Song;
SongQueue.CopyTo(Data, 1);
}
else
{
Data = Songs;
}
using (BinaryWriter Writer = new BinaryWriter(File.Open(Bot.MainDir + "data.playlist." + Identifier + ".txt", FileMode.Create)))
{
Writer.Write(Data.Length);
for (int i = 0; i < Data.Length; i++)
{
Writer.Write(Data[i].Query);
Writer.Write(Data[i].Local);
}
}
return(Data.Length);
}
public void Synchronize()
{
var newFrontResourcesBuffer = new Action[_backResourceLoadBuffer.Count];
_backResourceLoadBuffer.CopyTo(newFrontResourcesBuffer, 0);
_backResourceLoadBuffer = new ConcurrentQueue <Action>();
KeyValuePair <IRenderTarget, RenderPipeline[]>[] newFrontDrawCallBatchBuffer;
lock (_backBufferLock)
{
newFrontDrawCallBatchBuffer =
_backPipelineRunsBuffer.ToArray()
.Select(kvp => new KeyValuePair <IRenderTarget, RenderPipeline[]>(kvp.Key, kvp.Value.ToArray()))
.ToArray();
_backPipelineRunsBuffer = new Dictionary <IRenderTarget, List <RenderPipeline> >();
}
lock (_swapLock)
{
_frontResourceLoadBuffer = newFrontResourcesBuffer;
_frontPipelineRunsBuffer = newFrontDrawCallBatchBuffer;
// Swap all buffers in all enqueued GLDrawCallBuffers
foreach (var pipeline in _frontPipelineRunsBuffer.SelectMany(kvp => kvp.Value))
{
pipeline.SwapDrawCallBuffers();
}
OnSyncronize?.Invoke(this, EventArgs.Empty);
Monitor.Pulse(_swapLock);
}
}
private void SaveLogs()
{
if (_saveLogsFailCount > LOG_FAIL_COUNT)
{
throw new Exception($"Logger failed to save logs {LOG_FAIL_COUNT} times");
}
if (!_loggerIsBusy)
{
_saveLogsFailCount = 0;
var count = _logs.Count;
if (count > 0)
{
_loggerIsBusy = true;
var logsToSave = new string[count];
_logs.CopyTo(logsToSave, 0);
_logs.Clear();
File.AppendAllLines(Environment.ExpandEnvironmentVariables(@"%USERPROFILE%\Desktop\log.txt"), logsToSave);
_loggerIsBusy = false;
}
}
else
{
_saveLogsFailCount++;
}
}
public static ConcurrentQueue <T> CloneConcurrentQueue <T>(this ConcurrentQueue <T> queue)
{
var messages = new T[queue.Count];
queue.CopyTo(messages, 0);
return(new ConcurrentQueue <T>(messages));
}
/// <summary>
/// 从特定的 <see cref="T:System.Array"/> 索引处开始，将 <see cref="T:System.Collections.ICollection"/> 的元素复制到一个 <see cref="T:System.Array"/> 中。
/// </summary>
/// <param name="array">作为从 <see cref="T:System.Collections.ICollection"/> 复制的元素的目标位置的一维 <see cref="T:System.Array"/>。<see cref="T:System.Array"/> 必须具有从零开始的索引。</param>
/// <param name="index"><paramref name="array"/> 中从零开始的索引，将在此处开始复制。</param>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="array"/> 为 null。</exception>
///
/// <exception cref="T:System.ArgumentOutOfRangeException">
/// <paramref name="index"/> 小于零。</exception>
///
/// <exception cref="T:System.ArgumentException">
/// <paramref name="array"/> 是多维的。- 或 -源 <see cref="T:System.Collections.ICollection"/> 中的元素数目大于从 <paramref name="index"/> 到目标 <paramref name="array"/> 末尾之间的可用空间。</exception>
///
/// <exception cref="T:System.ArgumentException">源 <see cref="T:System.Collections.ICollection"/> 的类型无法自动转换为目标 <paramref name="array"/> 的类型。</exception>
void ICollection.CopyTo(Array array, int index)
{
if (!(array is T[]))
{
throw new ArgumentException("传入数据不是指定的类型，应传入T[]。");
}
_Q.CopyTo((T[])array, index);
}
public void ToArrayTest()
{
int[] array = queue.ToArray();
string s = string.Empty;
foreach (int i in array)
{
s += i;
}
Assert.AreEqual("0123456789", s, "#1 : " + s);
queue.CopyTo(array, 0);
s = string.Empty;
foreach (int i in array)
{
s += i;
}
Assert.AreEqual("0123456789", s, "#2 : " + s);
}
public void ConcurrentQueue_FunctionsAsNormalQueue_ForSingleThreadedAccess(params int[] numbersToAdd)
{
// Because we're not doing anything interesting with the queue itself, it seems reasonable to just wrap all of the basic queue API tests into one test
// Enqueue
foreach (var number in numbersToAdd)
{
_concurrentQueue.Enqueue(number);
}
// Peek
var head = _concurrentQueue.Peek();
Assert.AreEqual(numbersToAdd.First(), head);
// GetEnumerator<T>
var index = 0;
var genericEnumerator = _concurrentQueue.GetEnumerator();
while (index < numbersToAdd.Length && genericEnumerator.MoveNext())
{
Assert.AreEqual(numbersToAdd[index++], genericEnumerator.Current);
}
Assert.AreEqual(numbersToAdd.Length, index);
// GetEnumerator
index = 0;
var nongenericEnumerator = ((IEnumerable)_concurrentQueue).GetEnumerator();
while (index < numbersToAdd.Length && nongenericEnumerator.MoveNext())
{
Assert.AreEqual(numbersToAdd[index++], nongenericEnumerator.Current);
}
Assert.AreEqual(numbersToAdd.Length, index);
// Count
Assert.AreEqual(_concurrentQueue.Count, numbersToAdd.Length);
// CopyTo
var destinationArray = new int[numbersToAdd.Length];
_concurrentQueue.CopyTo(destinationArray, 0);
Assert.True(numbersToAdd.SequenceEqual(destinationArray));
// Contains
Assert.True(numbersToAdd.All(_concurrentQueue.Contains));
// Dequeue
head = _concurrentQueue.Dequeue();
Assert.AreEqual(numbersToAdd.First(), head);
Assert.True(_concurrentQueue.SequenceEqual(numbersToAdd.Skip(1)));
// Clear
_concurrentQueue.Clear();
Assert.AreEqual(0, _concurrentQueue.Count);
Assert.False(numbersToAdd.Any(_concurrentQueue.Contains));
}
public T[] ToArray()
{
T[] result = null;
lock (syncObject)
{
result = new T[queue.Count];
queue.CopyTo(result, 0);
}
return(result);
}
public void Commit()
{
backupMessageArray = new object[messageQueue.Count];
messageQueue.CopyTo(backupMessageArray, 0);
while (messageQueue.Count > 0)
{
object result;
if (messageQueue.TryDequeue(out result))
{
dispatcher.DispatchMessage(result);
}
}
committed = true;
}
public void ToArrayTest()
{
var array = _queue.ToArray();
var s = string.Empty;
var builder = new StringBuilder();
builder.Append(s);
foreach (var i in array)
{
builder.Append(i);
}
s = builder.ToString();
Assert.AreEqual("0123456789", s, "#1 : " + s);
_queue.CopyTo(array, 0);
s = string.Empty;
builder = new StringBuilder();
builder.Append(s);
foreach (var i in array)
{
builder.Append(i);
}
s = builder.ToString();
Assert.AreEqual("0123456789", s, "#2 : " + s);
}
private void LoadStorage()
{
string storage_path = Config.STORAGE_PATH;
string storage_name = Config.STORAGE_NAME;
string path_comb = Path.Combine(storage_name, storage_path);
using (Stream stream = File.Open(path_comb, FileMode.Create))
{
var formater = new BinaryFormatter();
TransactionProtocol[] transact_array = new TransactionProtocol[transactions.Count];
transactions.CopyTo(transact_array, 0);
var list_transact = transact_array.OfType <TransactionProtocol>().ToList();
formater.Serialize(stream, list_transact);
}
}
private static void ExerciseFullApi(ConcurrentQueue <int> concurrentQueue, int[] numbersToAdd)
{
dynamic _;
// Enqueue
foreach (var number in numbersToAdd)
{
concurrentQueue.Enqueue(number);
}
// Peek
try
{
_ = concurrentQueue.Peek();
}
catch (InvalidOperationException)
{
}
var index = 0;
var genericEnumerator = concurrentQueue.GetEnumerator();
while (index < numbersToAdd.Length && genericEnumerator.MoveNext())
{
_ = genericEnumerator.Current;
}
index = 0;
var nongenericEnumerator = ((IEnumerable)concurrentQueue).GetEnumerator();
while (index < numbersToAdd.Length && nongenericEnumerator.MoveNext())
{
_ = nongenericEnumerator.Current;
}
_ = concurrentQueue.Count;
var destinationArray = new int[500];
concurrentQueue.CopyTo(destinationArray, 0);
_ = concurrentQueue.Contains(numbersToAdd.First());
_ = concurrentQueue.DequeueOrDefault();
concurrentQueue.Clear();
}
public void Commit()
{
lock (sync)
{
backupMessageArray = new object[messageQueue.Count];
messageQueue.CopyTo(backupMessageArray, 0);
while (messageQueue.Count > 0)
{
object result;
if (messageQueue.TryDequeue(out result))
{
var @event = result;
var @eventType = @event.GetType();
var method = publishMethod.MakeGenericMethod(@eventType);
method.Invoke(this.eventAggregator, new object[] { @event });
}
}
committed = true;
}
}
/**
* return all sequence numbers whose last feedback time is larger than k*RTT
*
* @param RTT - the current round trip time
* @param doFeedback - true if the k parameter should be increased and the time should
* be reset (using {@link ReceiverLossListEntry#feedback()} )
* @return
*/
public List <long> getFilteredSequenceNumbers(long RTT, bool doFeedback)
{
List <long> result = new List <long>();
ReceiverLossListEntry[] sorted = new ReceiverLossListEntry[backingList.Count];
backingList.CopyTo(sorted, 0);
Array.Sort(sorted);
foreach (ReceiverLossListEntry e in sorted)
{
if ((Util.getCurrentTime() - e.getLastFeedbackTime()) > e.getK() * RTT)
{
result.Add(e.GetSequenceNumber());
if (doFeedback)
{
e.Feedback();
}
}
}
return(result);
}
private void RegisterContinuation(CompletesContinuation continuationCompletes)
{
if (HasException.Get())
{
var currentContinuations = new CompletesContinuation[Continuations.Count];
Continuations.CopyTo(currentContinuations, 0);
var continuationsCount = Continuations.Count;
for (var i = 0; i < continuationsCount; i++)
{
Continuations.TryDequeue(out _);
}
Continuations.Enqueue(continuationCompletes);
foreach (var currentContinuation in currentContinuations)
{
Continuations.Enqueue(currentContinuation);
}
}
else
{
Continuations.Enqueue(continuationCompletes);
}
}
public void WriteLogs()
{
int length;
Log[] logs;
lock (_queue)
{
length = _queue.Count;
logs = new Log[length];
_queue.CopyTo(logs, 0);
}
_writer.WriteLogs(logs);
lock (_queue)
{
for (var i = 0; i < length; i++)
{
_queue.TryDequeue(out _);
}
}
}
// Instantiates the queue w/ the enumerator ctor and validates the resulting copyto & toarray.
public static void Test5_CtorAndCopyToAndToArray(int count)
{
int[] arr = new int[count];
for (int i = 0; i < count; i++)
{
arr[i] = i;
}
ConcurrentQueue <int> s = new ConcurrentQueue <int>(arr);
// try toarray.
int[] sa1 = s.ToArray();
Assert.Equal(arr.Length, sa1.Length);
for (int i = 0; i < sa1.Length; i++)
{
Assert.Equal(arr[i], sa1[i]);
}
int[] sa2 = new int[count];
s.CopyTo(sa2, 0);
Assert.Equal(arr.Length, sa2.Length);
for (int i = 0; i < sa2.Length; i++)
{
Assert.Equal(arr[i], sa2[i]);
}
object[] sa3 = new object[count]; // test array variance.
((System.Collections.ICollection)s).CopyTo(sa3, 0);
Assert.Equal(arr.Length, sa3.Length);
for (int i = 0; i < sa3.Length; i++)
{
Assert.Equal(arr[i], (int)sa3[i]);
}
}
public void CopyTo(T[] array, int arrayIndex)
{
_dataQueue.CopyTo(array, arrayIndex);
}
public void CopyTo(T[] array, int index)
{
_queue.CopyTo(array, index);
}
// Instantiates the queue w/ the enumerator ctor and validates the resulting copyto & toarray.
public static void Test5_CtorAndCopyToAndToArray(int count)
{
int[] arr = new int[count];
for (int i = 0; i < count; i++) arr[i] = i;
ConcurrentQueue<int> s = new ConcurrentQueue<int>(arr);
// try toarray.
int[] sa1 = s.ToArray();
Assert.Equal(arr.Length, sa1.Length);
for (int i = 0; i < sa1.Length; i++)
{
Assert.Equal(arr[i], sa1[i]);
}
int[] sa2 = new int[count];
s.CopyTo(sa2, 0);
Assert.Equal(arr.Length, sa2.Length);
for (int i = 0; i < sa2.Length; i++)
{
Assert.Equal(arr[i], sa2[i]);
}
object[] sa3 = new object[count]; // test array variance.
((System.Collections.ICollection)s).CopyTo(sa3, 0);
Assert.Equal(arr.Length, sa3.Length);
for (int i = 0; i < sa3.Length; i++)
{
Assert.Equal(arr[i], (int)sa3[i]);
}
}
// Instantiates the queue w/ the enumerator ctor and validates the resulting copyto & toarray.
private static bool RunConcurrentQueueTest5_CtorAndCopyToAndToArray(int count)
{
TestHarness.TestLog("* RunConcurrentQueueTest5_CtorAndCopyToAndToArray()");
int[] arr = new int[count];
for (int i = 0; i < count; i++)
{
arr[i] = i;
}
ConcurrentQueue <int> s = new ConcurrentQueue <int>(arr);
// try toarray.
int[] sa1 = s.ToArray();
if (sa1.Length != arr.Length)
{
TestHarness.TestLog(" > ToArray resulting array is diff length: got {0}, wanted {1}",
sa1.Length, arr.Length);
return(false);
}
for (int i = 0; i < sa1.Length; i++)
{
if (sa1[i] != arr[i])
{
TestHarness.TestLog(" > ToArray returned an array w/ diff contents: got {0}, wanted {1}",
sa1[i], arr[i]);
return(false);
}
}
int[] sa2 = new int[count];
s.CopyTo(sa2, 0);
if (sa2.Length != arr.Length)
{
TestHarness.TestLog(" > CopyTo(int[]) resulting array is diff length: got {0}, wanted {1}",
sa2.Length, arr.Length);
return(false);
}
for (int i = 0; i < sa2.Length; i++)
{
if (sa2[i] != arr[i])
{
TestHarness.TestLog(" > CopyTo(int[]) returned an array w/ diff contents: got {0}, wanted {1}",
sa2[i], arr[i]);
return(false);
}
}
object[] sa3 = new object[count]; // test array variance.
((System.Collections.ICollection)s).CopyTo(sa3, 0);
if (sa3.Length != arr.Length)
{
TestHarness.TestLog(" > CopyTo(object[]) resulting array is diff length: got {0}, wanted {1}",
sa3.Length, arr.Length);
return(false);
}
for (int i = 0; i < sa3.Length; i++)
{
if ((int)sa3[i] != arr[i])
{
TestHarness.TestLog(" > CopyTo(object[]) returned an array w/ diff contents: got {0}, wanted {1}",
sa3[i], arr[i]);
return(false);
}
}
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="array"></param>
/// <param name="arrayIndex"></param>
public void CopyTo(T[] array, int arrayIndex)
{
_cacheStruct.CopyTo(array, arrayIndex);
}
// Instantiates the queue w/ the enumerator ctor and validates the resulting copyto & toarray.
private static bool RunConcurrentQueueTest5_CtorAndCopyToAndToArray(int count)
{
TestHarness.TestLog("* RunConcurrentQueueTest5_CtorAndCopyToAndToArray()");
int[] arr = new int[count];
for (int i = 0; i < count; i++) arr[i] = i;
ConcurrentQueue<int> s = new ConcurrentQueue<int>(arr);
// try toarray.
int[] sa1 = s.ToArray();
if (sa1.Length != arr.Length)
{
TestHarness.TestLog(" > ToArray resulting array is diff length: got {0}, wanted {1}",
sa1.Length, arr.Length);
return false;
}
for (int i = 0; i < sa1.Length; i++)
{
if (sa1[i] != arr[i])
{
TestHarness.TestLog(" > ToArray returned an array w/ diff contents: got {0}, wanted {1}",
sa1[i], arr[i]);
return false;
}
}
int[] sa2 = new int[count];
s.CopyTo(sa2, 0);
if (sa2.Length != arr.Length)
{
TestHarness.TestLog(" > CopyTo(int[]) resulting array is diff length: got {0}, wanted {1}",
sa2.Length, arr.Length);
return false;
}
for (int i = 0; i < sa2.Length; i++)
{
if (sa2[i] != arr[i])
{
TestHarness.TestLog(" > CopyTo(int[]) returned an array w/ diff contents: got {0}, wanted {1}",
sa2[i], arr[i]);
return false;
}
}
object[] sa3 = new object[count]; // test array variance.
((System.Collections.ICollection)s).CopyTo(sa3, 0);
if (sa3.Length != arr.Length)
{
TestHarness.TestLog(" > CopyTo(object[]) resulting array is diff length: got {0}, wanted {1}",
sa3.Length, arr.Length);
return false;
}
for (int i = 0; i < sa3.Length; i++)
{
if ((int)sa3[i] != arr[i])
{
TestHarness.TestLog(" > CopyTo(object[]) returned an array w/ diff contents: got {0}, wanted {1}",
sa3[i], arr[i]);
return false;
}
}
return true;
}
public void CopyTo(ILayer[] array, int arrayIndex)
{
_layers.CopyTo(array, arrayIndex);
}
public static void CopyTo <T>(ConcurrentQueue <T> concurrentQueue, T[] array, int index)
{
ConcurrentCollectionHelper.Interleave();
concurrentQueue.CopyTo(array, index);
}
/// <summary>
/// Retrieves a copy of the Error stack
/// </summary>
/// <returns>All errors thrown by functions using the message or flowcontrol system</returns>
public static PsfExceptionRecord[] GetErrors()
{
PsfExceptionRecord[] temp = new PsfExceptionRecord[ErrorRecords.Count];
ErrorRecords.CopyTo(temp, 0);
return(temp);
}
/// <summary>
/// Retrieves a copy of the message log
/// </summary>
/// <returns>All messages logged this session.</returns>
public static LogEntry[] GetLog()
{
LogEntry[] temp = new LogEntry[LogEntries.Count];
LogEntries.CopyTo(temp, 0);
return(temp);
}
/// <summary>
/// Copy semantics for fast array initialization and processing.
/// </summary>
/// <param name="array">Copy queue elements to array.</param>
/// <param name="index">Copy queue elements to which index position.</param>
public void CopyTo(Array array, int index)
{
_queue.CopyTo((TP[])array, index);
}
public void CopyTo_AllItemsCopiedAtCorrectLocation(int count, bool viaInterface)
{
var q = new ConcurrentQueue<int>(Enumerable.Range(0, count));
var c = (ICollection)q;
int[] arr = new int[count];
if (viaInterface)
{
c.CopyTo(arr, 0);
}
else
{
q.CopyTo(arr, 0);
}
Assert.Equal(q, arr);
if (count > 1)
{
int toRemove = count / 2;
int remaining = count - toRemove;
for (int i = 0; i < toRemove; i++)
{
int item;
Assert.True(q.TryDequeue(out item));
Assert.Equal(i, item);
}
if (viaInterface)
{
c.CopyTo(arr, 1);
}
else
{
q.CopyTo(arr, 1);
}
Assert.Equal(0, arr[0]);
for (int i = 0; i < remaining; i++)
{
Assert.Equal(arr[1 + i], i + toRemove);
}
}
}
/// <summary>
/// 获取改变的字段属性
/// </summary>
/// <returns></returns>
internal string[] GetChangePropertys()
{
string[] columns = new string[_changePropertys.Count];
_changePropertys.CopyTo(columns, 0);
return(columns);
}
public void CopyTo_Empty_Success()
{
var q = new ConcurrentQueue<int>();
q.CopyTo(Array.Empty<int>(), 0);
}
