#pragma warning disable CA1063, CA1816 // Implement IDisposable Correctly
/// <inheritdoc />
public void Dispose()
#pragma warning restore CA1063, CA1816 // Implement IDisposable Correctly
{
Debug.Assert(!Cache.Contains(this), "!Cache.Contains(this)");
this.Clear();
Cache.Enqueue(this);
}
public async Task <bool> CheckMonthStatsAsync(IStockModel stock, CancellationToken token = default(CancellationToken))
{
if (stock.MonthStatsExpired)
{
lock (stock)
{
if (!_monthStatsQueue.Contains(stock))
{
_monthStatsQueue.Enqueue(stock);
}
}
while (stock.MonthStatsExpired && !token.IsCancellationRequested)
{
await Task.Delay(100, token);
}
if (token.IsCancellationRequested)
{
return(false);
}
}
return(true);
}
/// <summary>
/// 设置值
/// </summary>
/// <param name="key">key值</param>
/// <param name="value">需要写入的value</param>
/// <returns>成功状态</returns>
public bool SetValue(T key, U value)
{
if (keyValues.TryGetValue(key, out var oldValue))
{
keyValues.TryUpdate(key, value, oldValue);
if (!keyUpdateQueue.Contains(key))
{
keyUpdateQueue.Enqueue(key);
}
return(true);
}
else
{
var result = dBHelper.CommandSQL($"SELECT TOP 1 [{valueName}] FROM {tableName} WHERE {condition} {keyName}='{key}'");
if (result.EffectNum > 0)
{
var val = (U)result.Collection[0][valueName];
keyValues.AddOrUpdate(key, value, (k, v) => value);
if (!keyUpdateQueue.Contains(key) && !val.Equals(value))
{
keyUpdateQueue.Enqueue(key);
}
return(true);
}
}
return(false);
}
private void SetState(ConcurrentQueue <Patron> queueToBar)
{
if (currentState == State.DrinkingBeer)
{
currentState = State.LeavingPub;
return;
}
if (currentState == State.FindChair)
{
currentState = State.DrinkingBeer;
return;
}
if (HasBeer() && chairUsed == null)
{
currentState = State.FindChair;
return;
}
if (!HasBeer() && !queueToBar.Contains(this))
{
currentState = State.GoingToBar;
return;
}
if (!HasBeer() && queueToBar.Contains(this))
{
currentState = State.AwaitingBeer;
return;
}
}
/// <summary>
///
/// </summary>
/// <param name="filenameList"></param>
public static void PlayAsync(IEnumerable <string> filenameList)
{
var path = Application.StartupPath + "\\Config\\Wave\\";
UnmanagedCode.Assert();
try
{
foreach (var fileName in filenameList)
{
var filefullname = path + fileName;
if (!_fileNames.Contains(filefullname))
{
if (!File.Exists(filefullname))
{
continue;
}
_fileNames.Enqueue(filefullname);
}
sndPlaySound(filefullname,
(int)(SoundFlags.SND_FILENAME | SoundFlags.SND_NODEFAULT | SoundFlags.SND_ASYNC));
// PlaySound(path + fileName, IntPtr.Zero, (int)(SoundFlags.SND_FILENAME | SoundFlags.SND_NODEFAULT | SoundFlags.SND_ASYNC));
}
}
finally
{
CodeAccessPermission.RevertAssert();
}
}
public static void ConcurrentQueue()
{
ConcurrentQueue <string> myQueue = new ConcurrentQueue <string>();
//Add items to the concurrent queue
myQueue.Enqueue("Abhy");
myQueue.Enqueue("Sangs");
myQueue.Enqueue("Unni");
//Check if the queue contains an item
var isContaining = myQueue.Contains <string>("Abhy");
isContaining = myQueue.Contains <string>("Sangs");
isContaining = myQueue.Contains <string>("Unni");
string item = string.Empty;
//Peek for next item on concurrent queue
var isPeekSuccess = myQueue.TryPeek(out item);
//Remove items from the concurrent queue
var isDequeueSuccess = myQueue.TryDequeue(out item);
isDequeueSuccess = myQueue.TryDequeue(out item);
isDequeueSuccess = myQueue.TryDequeue(out item);
isDequeueSuccess = myQueue.TryDequeue(out item);
var isNextItemAvailable = myQueue.TryPeek(out item);
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
Debug.Assert(!Cache.Contains(this), "!Cache.Contains(this)");
this.Clear();
Cache.Enqueue(this);
}
}
public static void AddProvider(IDiacriticProvider provider)
{
if (Providers.Contains(provider))
{
throw new Exception("Provider already added");
}
Providers.Enqueue(provider);
BuildIndex();
}
/// <summary>
/// Add one item into this set.
/// </summary>
/// <param name="item">The item to add</param>
public void Add(T item)
{
lock (_syncLock)
{
if (!_queue.Contains(item))
{
_queue.Enqueue(item);
}
}
}
private void DeactivateNode(IRiakNode node)
{
lock (node)
{
if (!_offlineNodes.Contains(node))
{
_loadBalancer.RemoveNode(node);
_offlineNodes.Enqueue(node);
}
}
}
/// <summary>
/// Update pool with new ID
/// </summary>
/// <param name="id">ID</param>
internal static void UpdateSharedIdPool(long id)
{
if (SharedIdPool.Contains(id))
{
return;
}
SharedIdPool.Enqueue(id);
if (SharedIdPool.Count > 30)
{
SharedIdPool.TryDequeue(out _);
}
}
public static void ReturnTextureRGB24(Texture2D tex)
{
if (tex == null)
{
return;
}
if (_circlePool.Contains(tex))
{
UnityEngine.Debug.LogError($"ReturnTextureRGB24 was already returned!!!");
return;
}
_gridPool.Enqueue(tex);
}
/// <summary>
/// Handle an event message from the websocket
/// </summary>
/// NOITE: CHANGE TO USE STRING INSTEAD OF JToken
private void HandleEvent(JToken doc)
{
if (doc.IsNullOrEmpty())
{
return;
}
var data = doc["data"];
if (data.IsNullOrEmpty())
{
return;
}
if (data.Type != JTokenType.Object)
{
return;
}
// Ignore messages I have send
if (!data["id"].IsNullOrEmpty() && Guid.TryParse((string)data["id"], out var guid))
{
if (_myLatestMessages.Contains(guid))
{
return;
}
}
_parser.Process(doc["event"]?.Value <string>(), data);
}
internal void QueueAccount(Account a)
{
if (a != null && !accountQueue.Contains(a))
{
accountQueue.Enqueue(a);
}
}
internal void QueueTransaction(Transaction t)
{
if (t != null && !transactionQueue.Contains(t))
{
transactionQueue.Enqueue(t);
}
}
private void InitExchanges( )
{
foreach (var exchange in Exchanges.Values)
{
exchange.ClearObservers( );
Observers[exchange.Id] = new CryptoExchangeObserver(exchange);
exchange.Changed += (e, coin) =>
{
if (!pendingUpdates.Contains(e.Id))
{
pendingUpdates.Enqueue(e.Id);
}
};
var observer = Observers[exchange.Id];
observer.Next += (e, coin) => Logger.Debug($"{e.Name,-10} {e[coin.Symbol]}");
exchange.Subscribe(observer);
CompareTable.AddExchange(exchange);
try
{
Task.Run(() => exchange.StartMonitor(cts.Token), cts.Token);
}
catch (Exception e)
{
Logger.Error(e);
throw;
}
}
}
public Task CheckRulesForProperty(string propertyName)
{
if (OverrideResult == null)
{
if (TransferredResults)
{
var oldResults = Results.Where(x => x.Key < 0 && x.Value.TriggerProperties.Contains(propertyName)).ToList();
oldResults.ForEach(r => Results.Remove(r.Key));
if (!Results.Where(x => x.Key < 0).Any())
{
TransferredResults = false;
}
}
foreach (var index in Rules.Values.Where(r => r.TriggerProperties.Contains(propertyName)).Select(r => r.UniqueIndex))
{
if (!ruleQueue.Contains(index))
{
// System.Diagnostics.Debug.WriteLine($"Enqueue {propertyName}");
ruleQueue.Enqueue(index);
}
}
CheckRulesQueue();
return(WaitForRules);
}
else
{
return(Task.CompletedTask);
}
}
public bool Contains(TElement element)
{
lock (_lock)
{
return(_internalQueue.Contains(element));
}
}
/// ************************************************************************************************
/// <summary>
/// Gets ID for the station name in German
/// If there is no ID in local cache, put the station name in the request ID queue to avoid program freezing.
/// </summary>
/// <param name="stationName">Name of the desired station in German</param>
/// <returns>Station ID, if station name exists, "" otherwise</returns>
public static string GetIdForStation(string stationName)
{
if (string.IsNullOrEmpty(stationName))
{
return("");
}
if (localIdСache.ContainsKey(stationName))
{
return(localIdСache[stationName]);
}
else
{
if (!stationIdRequestQueue.Contains(stationName))
{
stationIdRequestQueue.Enqueue(stationName);
if (!stationIdRequestBackgroundWorker.IsBusy)
{
stationIdRequestBackgroundWorker.RunWorkerAsync();
}
}
return("");
}
}
private void SetLightLevel(World world, ConcurrentQueue <BlockCoordinates> lightBfsQueue, BlockCoordinates coordinates, int currentLightLevel, Block block, int lightLevel)
{
if (currentLightLevel > 0)
{
if (currentLightLevel >= lightLevel)
{
return;
}
world.SetBlockLight(coordinates, (byte)Math.Max(currentLightLevel, lightLevel - 1));
//UpdateNeighbors(world, coordinates);
return;
}
if ((!block.Solid || block.Transparent) && currentLightLevel + 2 <= lightLevel)
{
world.SetBlockLight(coordinates, (byte)(lightLevel - 1));
//UpdateNeighbors(world, coordinates);
if (!lightBfsQueue.Contains(coordinates))
{
lightBfsQueue.Enqueue(coordinates);
}
}
}
public bool Contains(T value)
{
lock (_lockObject)
{
return(_innerQueue.Contains(value));
}
}
/// <summary>
/// Analyze payload of IoTHub message, adding timestamp and related sequence numbers into temporary
/// </summary>
/// <param name="arg"></param>
/// <returns></returns>
private static async Task Client_ProcessEventAsync(ProcessEventArgs arg)
{
var body = arg.Data.Body.ToArray();
var content = Encoding.UTF8.GetString(body);
dynamic json = JsonConvert.DeserializeObject(content);
int valueChangesCount = 0;
foreach (dynamic entry in json)
{
var sequence = (int)entry.SequenceNumber;
var timestamp = ((DateTime)entry.Value.SourceTimestamp).ToString(_dateTimeFormat);
_missingSequences.AddOrUpdate(
timestamp,
(ts) =>
{
return(new List <int>(500)
{
sequence
});
},
(ts, list) =>
{
list.Add(sequence);
return(list);
});
valueChangesCount++;
if (!_observedTimestamps.Contains(timestamp))
{
_observedTimestamps.Enqueue(timestamp);
}
}
}
public static bool Notify_WalkabilityChanged(RegionDirtyer __instance, IntVec3 c)
{
List <Region> regionsToDirty = new List <Region>();
//regionsToDirty.Clear();
for (int i = 0; i < 9; i++)
{
IntVec3 c2 = c + GenAdj.AdjacentCellsAndInside[i];
if (c2.InBounds(map(__instance)))
{
Region regionAt_NoRebuild_InvalidAllowed = map(__instance).regionGrid.GetRegionAt_NoRebuild_InvalidAllowed(c2);
if (regionAt_NoRebuild_InvalidAllowed != null && regionAt_NoRebuild_InvalidAllowed.valid)
{
map(__instance).temperatureCache.TryCacheRegionTempInfo(c, regionAt_NoRebuild_InvalidAllowed);
regionsToDirty.Add(regionAt_NoRebuild_InvalidAllowed);
}
}
}
for (int j = 0; j < regionsToDirty.Count; j++)
{
SetRegionDirty(__instance, regionsToDirty[j]);
}
//regionsToDirty.Clear();
ConcurrentQueue <IntVec3> dirtyCells = get_DirtyCells(__instance);
if (c.Walkable(map(__instance)) && !dirtyCells.Contains(c))
{
dirtyCells.Enqueue(c);
}
return(false);
}
public void Write(IEnumerable <IrcWriteContext> context)
{
foreach (var ctx in context)
{
switch (ctx.MessageOrigin)
{
case MessageOrigin.Channel:
_botRuntime.SendMessage(ctx.Message);
break;
case MessageOrigin.Query:
_botRuntime.SendQueryMessage(ctx.Message, ctx.User);
break;
case MessageOrigin.Notice:
if (!_queue.Contains(ctx.Message))
{
_botRuntime.SendMessage(ctx.Message);
}
_queue.Enqueue(ctx.Message);
while (_queue.Count > QueueDepth)
{
string temp;
_queue.TryDequeue(out temp);
}
break;
case MessageOrigin.Quartz:
_botRuntime.SendMessage(ctx.Message);
break;
}
}
}
private void ClientUpdateWorker()
{
while (IsAvailable)
{
var currentTimeMillis = TimeManager.CurrentTimeMillis;
foreach (var networkManager in _networkManagers)
{
if (!(networkManager?.IsAvailable ?? false))
{
if (!_destroyNetworks.Contains(networkManager))
{
_destroyNetworks.Enqueue(networkManager);
}
continue;
}
if (!networkManager.Connected ||
currentTimeMillis - networkManager.LastPacketMillis > Timeout)
{
networkManager.Disconnect();
_destroyNetworks.Enqueue(networkManager);
continue;
}
networkManager.Update();
}
}
}
private void StartCountDown(GameGroup gg)
{
while (!CountDownQueue.Contains(gg))
{
CountDownQueue.Enqueue(gg);
}
}
protected virtual void QueueOnPropertyChangedEvent(String propertyName)
{
if (!eventQueue.Contains(propertyName))
{
eventQueue.Enqueue(propertyName);
}
}
private void Parse(string html, string url)
{
string strRef = @"(href|HREF)[]*=[]*[""'][^""'#>]+[""']";
MatchCollection matches = new Regex(strRef).Matches(html);
foreach (Match match in matches)
{
strRef = match.Value.Substring(match.Value.IndexOf('=') + 1)
.Trim('"', '\"', '#', '>');
string fixedStr = Fix(strRef, url);
if (!Regex.IsMatch(strRef, @"(.html/?)$"))
{
continue;
}
string site = Regex.Match(url, @"^https?://(?<site>[^/:]+(:\d*)?/?)").Groups["site"].Value;
if (!fixedStr.Contains(site) || fixedStr == url || fixedStr == site)
{
continue;
}
if (!urlqueue.Contains(fixedStr))
{
urlqueue.Enqueue(fixedStr);
}
}
}
public void AddReceiver(IPEndPoint receiverEndPoint)
{
if (!_endPoints.Contains(receiverEndPoint))
{
_endPoints.Enqueue(receiverEndPoint);
}
}
public void enqueue(CallbackQueueInterface.ICallbackInfo info)
{
if (info.Callback == null)
{
return;
}
if (!_queue.Contains(info))
{
_queue.Enqueue(info);
}
else
{
Console.WriteLine("ADDING A DUPLICATE CALLBACKINFO TO THE QUEUE");
}
}
