public void EqualityComparer()
{
var dict = new ThreadSafeDictionary <string, int>(StringComparer.InvariantCultureIgnoreCase);
dict.Add("Weißbier", 93);
Assert.AreEqual(dict["WEISSBIER"], 93);
dict["weissbier"] = 777;
Assert.AreEqual(dict["Weißbier"], 777);
dict.Add(new KeyValuePair <string, int>("Δίος", 21));
Assert.AreEqual(2, dict.Count);
Assert.IsTrue(dict.ContainsKey("ΔΊΟΣ"));
Assert.IsTrue(dict.Contains(new KeyValuePair <string, int>("δίος", 21)));
Assert.IsFalse(dict.Contains(new KeyValuePair <string, int>("δίος", 3)));
Assert.IsTrue(dict.Keys.Contains("δίος"));
Assert.IsFalse(dict.Keys.Contains("δίοςδίος"));
Assert.IsTrue(dict.Values.Contains(770, new RoundedEquality()));
Assert.IsFalse(dict.Values.Contains(770));
int result;
Assert.IsTrue(dict.TryGetValue("ΔΊΟΣ", out result) && result == 21);
Assert.IsFalse(dict.TryGetValue("Eggplant", out result));
Assert.IsFalse(dict.Remove("aubergine"));
Assert.IsTrue(dict.Remove("Δίος"));
Assert.IsFalse(dict.Remove(new KeyValuePair <string, int>("WEISSBIER", 93)));
Assert.IsTrue(dict.Remove(new KeyValuePair <string, int>("WEISSBIER", 777)));
Assert.IsFalse(dict.ContainsKey("WEISSBIER"));
Assert.IsFalse(dict.Remove(new KeyValuePair <string, int>("WEISSBIER", 777)));
Assert.AreEqual(dict.Count, 0);
dict.Add("Palmer", 1111);
Assert.IsFalse(dict.Remove("Palmer", 1110, out result));
Assert.AreEqual(dict.Count, 1);
Assert.IsTrue(dict.Remove("Palmer", 1110, new RoundedEquality(), out result));
Assert.AreEqual(result, 1111);
Assert.AreEqual(dict.Count, 0);
}
public Player GetPlayer(NebulaConnection conn)
{
if (connectedPlayers.TryGetValue(conn, out Player player))
{
return(player);
}
return(null);
}
public MultiplayerSessionReservation ReservePlayerContext(
NitroxConnection connection,
PlayerSettings playerSettings,
AuthenticationContext authenticationContext,
string correlationId)
{
// TODO: ServerPassword in NitroxClient
if (!string.IsNullOrEmpty(serverConfig.ServerPassword) && (!authenticationContext.ServerPassword.HasValue || authenticationContext.ServerPassword.Value != serverConfig.ServerPassword))
{
MultiplayerSessionReservationState rejectedState = MultiplayerSessionReservationState.REJECTED | MultiplayerSessionReservationState.AUTHENTICATION_FAILED;
return(new MultiplayerSessionReservation(correlationId, rejectedState));
}
if (reservedPlayerNames.Count >= serverConfig.MaxConnections)
{
MultiplayerSessionReservationState rejectedState = MultiplayerSessionReservationState.REJECTED | MultiplayerSessionReservationState.SERVER_PLAYER_CAPACITY_REACHED;
return(new MultiplayerSessionReservation(correlationId, rejectedState));
}
string playerName = authenticationContext.Username;
Player player;
allPlayersByName.TryGetValue(playerName, out player);
if ((player?.IsPermaDeath == true) && serverConfig.IsHardcore)
{
MultiplayerSessionReservationState rejectedState = MultiplayerSessionReservationState.REJECTED | MultiplayerSessionReservationState.HARDCORE_PLAYER_DEAD;
return(new MultiplayerSessionReservation(correlationId, rejectedState));
}
if (reservedPlayerNames.Contains(playerName))
{
MultiplayerSessionReservationState rejectedState = MultiplayerSessionReservationState.REJECTED | MultiplayerSessionReservationState.UNIQUE_PLAYER_NAME_CONSTRAINT_VIOLATED;
return(new MultiplayerSessionReservation(correlationId, rejectedState));
}
ConnectionAssets assetPackage;
assetsByConnection.TryGetValue(connection, out assetPackage);
if (assetPackage == null)
{
assetPackage = new ConnectionAssets();
assetsByConnection.Add(connection, assetPackage);
reservedPlayerNames.Add(playerName);
}
bool hasSeenPlayerBefore = player != null;
ushort playerId = hasSeenPlayerBefore ? player.Id : ++currentPlayerId;
PlayerContext playerContext = new PlayerContext(playerName, playerId, !hasSeenPlayerBefore, playerSettings);
string reservationKey = Guid.NewGuid().ToString();
reservations.Add(reservationKey, playerContext);
assetPackage.ReservationKey = reservationKey;
return(new MultiplayerSessionReservation(correlationId, playerId, reservationKey));
}
//public static long GetComponentCount = 0;
public T Get <T>() where T : IComponent
{
//GetComponentCount++;
IComponent component;
if (components.TryGetValue(typeof(T), out component))
{
return((T)component);
}
return(default(T));
}
private ValidatableElement GetElementOrNew(System.Type entityType)
{
ValidatableElement element;
if (!validators.TryGetValue(entityType, out element))
{
IClassValidator cv = GetClassValidator(entityType);
element = new ValidatableElement(entityType, cv);
AddValidatableElement(element);
}
return(element);
}
public bool RemoveChild(TKey key)
{
IMonohierarchy <T, TKey> child;
if (DictChildren.TryGetValue(key, out child))
{
if (!DictChildren.Remove(key))
{
return(false);
}
OnChildRemoved(child);
return(true);
}
return(false);
}
public void UpdateVehicle(VehicleMovementData vehicleMovement)
{
if (vehiclesById.TryGetValue(vehicleMovement.Id, out VehicleModel vehicleModel))
{
vehicleModel.Position = vehicleMovement.Position;
vehicleModel.Rotation = vehicleMovement.Rotation;
}
}
private static Delegate GetCachedDelegate(object delegateKey)
{
Delegate result;
return
(cachedDelegates.TryGetValue(delegateKey, out result) ? result : null);
}
internal IRequestResponseCorrelationWrapper TryGetWrapper(Guid correlationId)
{
IRequestResponseCorrelationWrapper wrapper;
_requestWrappers.TryGetValue(correlationId, out wrapper);
return(wrapper);
}
public Optional <VehicleModel> GetVehicleModel(NitroxId id)
{
VehicleModel vehicleModel;
vehiclesById.TryGetValue(id, out vehicleModel);
return(Optional.OfNullable(vehicleModel));
}
public void Unsubscribe(Observable <T> observable)
{
//lock (SyncObject)
//{
if (observable == null)
{
return;
}
try
{
Unsubscriber <T> target = null;
if (m_DictObservables.TryGetValue(observable, out target))
{
m_DictObservables.Remove(observable);
if (target != null)
{
target.Dispose();
}
}
if (m_DictObservables.Count == 0)
{
MessageQueue.Quit();
MessageQueue.Clear();
}
}
catch (Exception e)
{
e.LogError();
}
//}
}
static bool MonitorUpdateDurationInternal(IEnumerator tickable, string threadInfo)
{
TaskInfo info;
bool result;
if (taskInfos.TryGetValue(tickable.ToString(), out info) == false)
{
info = new TaskInfo(tickable);
info.AddUpdateDuration(_stopwatch.Elapsed.TotalMilliseconds);
info.AddThreadInfo(threadInfo);
taskInfos.Add(tickable.ToString(), info);
}
else
{
info.AddUpdateDuration(_stopwatch.Elapsed.TotalMilliseconds);
info.AddThreadInfo(threadInfo);
}
_stopwatch.Reset();
_stopwatch.Start();
result = tickable.MoveNext();
_stopwatch.Stop();
return(result);
}
public static bool MonitorUpdateDuration(IEnumerator tickable, string runnerName)
{
var key = tickable.ToString().FastConcat(runnerName);
#if ENABLE_PIX_EVENTS
PixWrapper.PIXBeginEventEx(0x11000000, key);
#endif
_stopwatch.Start();
var result = tickable.MoveNext();
_stopwatch.Stop();
#if ENABLE_PIX_EVENTS
PixWrapper.PIXEndEventEx();
#endif
lock (LOCK_OBJECT)
{
TaskInfo info;
if (taskInfos.TryGetValue(key, out info) == false)
{
info = new TaskInfo(tickable);
info.AddThreadInfo(runnerName.FastConcat(": "));
taskInfos.Add(key, ref info);
}
else
{
info.AddUpdateDuration(_stopwatch.Elapsed.TotalMilliseconds);
taskInfos.Update(key, ref info);
}
}
_stopwatch.Reset();
return(result);
}
private bool GetGlyphIndex(char c, out GlyphInfo gli)
{
GlyphInfo info;
if (CharMap.TryGetValue(c, out info))
{
if (info.ListID > 0 && info.Width > 0)
{
gli = info;
return(true);
}
else
{
gli = GlyphInfo.Empty;
return(false);
}
}
else if (OnDemand)
{
lock (SyncObject) {
uint glyphindex = Font.GetCharIndex(c);
info = CompileCharacter(Font, glyphindex, c);
CharMap.Add(c, info);
gli = info;
}
return(true);
}
gli = GlyphInfo.Empty;
return(false);
}
public ICache GetSecondLevelCacheRegion(string regionName)
{
ICache result;
allCacheRegions.TryGetValue(regionName, out result);
return(result);
}
public static XmlAttributeOverrides Create(Type objectType)
{
XmlAttributeOverrides xOver = null;
if (!table.TryGetValue(objectType, out xOver))
{
// Create XmlAttributeOverrides object.
xOver = new XmlAttributeOverrides();
/* Create an XmlTypeAttribute and change the name of the XML type. */
XmlTypeAttribute xType = new XmlTypeAttribute();
xType.TypeName = objectType.Name;
// Set the XmlTypeAttribute to the XmlType property.
XmlAttributes attrs = new XmlAttributes();
attrs.XmlType = xType;
/* Add the XmlAttributes to the XmlAttributeOverrides,
* specifying the member to override. */
xOver.Add(objectType, attrs);
table.MergeSafe(objectType, xOver);
}
return(xOver);
}
ThreadSafeStack <T> ReturnValidPool(ThreadSafeDictionary <int, ThreadSafeStack <T> > pools, int pool)
{
if (pools.TryGetValue(pool, out var localPool) == false)
{
pools[pool] = localPool = new ThreadSafeStack <T>();
}
return(localPool);
}
public bool TryGetValue(string key, out TextureImage image)
{
if (String.IsNullOrEmpty(key))
{
image = null;
return(false);
}
return(m_Images.TryGetValue(key, out image));
}
public IEntity EntityByID(int id)
{
Entity entity;
if (entities.TryGetValue(id, out entity))
{
return(entity);
}
return(null);
}
public SerializeMode this[string name]
{
get {
SerializeMode n = SerializeMode.None;
if (Rules.TryGetValue(name, out n))
{
return(n);
}
return(SerializeMode.None);
}
}
public static bool MonitorUpdateDuration <T
#if ENABLE_PLATFORM_PROFILER
, PP
#endif
>(T sveltoTask, string runnerName
#if ENABLE_PLATFORM_PROFILER
, PP profiler
#endif
)
where T : ISveltoTask
#if ENABLE_PLATFORM_PROFILER
where PP : IPlatformProfiler
#endif
{
var key = sveltoTask.ToString().FastConcat(runnerName);
bool result;
#if ENABLE_PLATFORM_PROFILER
using (profiler.Sample(sveltoTask.ToString()))
#endif
{
_stopwatch.Start();
#if ENABLE_PIX_EVENTS
PixWrapper.PIXBeginEventEx(0x11000000, key);
#endif
result = sveltoTask.MoveNext();
#if ENABLE_PIX_EVENTS
PixWrapper.PIXEndEventEx();
#endif
_stopwatch.Stop();
}
lock (LOCK_OBJECT)
{
if (taskInfos.TryGetValue(key, out var info) == false)
{
info = new TaskInfo(sveltoTask.ToString());
info.AddThreadInfo(runnerName.FastConcat(": "));
taskInfos.Add(key, ref info);
}
else
{
info.AddUpdateDuration(_stopwatch.Elapsed.TotalMilliseconds);
taskInfos.Update(key, ref info);
}
}
_stopwatch.Reset();
return(result);
}
private int ThreadSafeDictionaryReadTest(int count)
{
int j = 0, value;
for (int i = 0; i < count; i++)
{
if (tsd.TryGetValue(i % FillCount, out value))
{
j += value;
}
}
return(j);
}
object IDictionary.this[object key]
{
get
{
switch (key)
{
case null:
// key could be null
throw new ArgumentNullException(nameof(key));
case TKey keyAsTKey when _wrapped.TryGetValue(keyAsTKey, out var result):
return(result);
default:
return(null);
}
}
set
{
switch (key)
{
case null:
// key could be null
// ConcurrentDictionary hates null
throw new ArgumentNullException(nameof(key));
case TKey keyAsTKey when value is TValue valueAsTValue:
this[keyAsTKey] = valueAsTValue;
break;
default:
break;
}
throw new ArgumentException(string.Empty, nameof(value));
}
}
public static bool MonitorUpdateDuration <T, PP>(ref T sveltoTask, string runnerName, PP profiler)
where T : ISveltoTask where PP : IPlatformProfiler
{
var samplerName = sveltoTask.name;
var key = samplerName.FastConcat(runnerName);
bool result;
using (profiler.Sample(samplerName))
{
_stopwatch.Start();
#if ENABLE_PIX_EVENTS
PixWrapper.PIXBeginEventEx(0x11000000, key);
#endif
result = sveltoTask.MoveNext();
#if ENABLE_PIX_EVENTS
PixWrapper.PIXEndEventEx();
#endif
_stopwatch.Stop();
}
lock (LOCK_OBJECT)
{
if (taskInfos.TryGetValue(key, out var info) == false)
{
info = new TaskInfo(samplerName);
#warning Todo for seb: avoid allocation here please
info.AddThreadInfo(runnerName);
taskInfos.Add(key, ref info);
}
else
{
info.AddUpdateDuration(_stopwatch.Elapsed.TotalMilliseconds);
taskInfos.Update(key, ref info);
}
}
_stopwatch.Reset();
return(result);
}
public bool TryResolveType(string name, out TypeConverterTuple ttc)
{
if (TypeConverters.TryGetValue(name, out ttc))
{
return(true);
}
else
{
Type t = Type.GetType(name, false, false);
if (t == null)
{
return(false);
}
else
{
TypeConverter tc = TypeDescriptor.GetConverter(t);
TypeConverterTuple nttc = new TypeConverterTuple(t, tc);
TypeConverters.Add(name, nttc);
ttc = nttc;
return(true);
}
}
}
/// <summary>
/// Gets a dynamically created Comparison delegate that compare instances based on a compound property expression
/// </summary>
/// <param name="type">The type.</param>
/// <param name="properties">List of property names representing the property or fields to get. E.g. prop0.prop1.prop2 is represented as a list with items "prop0", "prop1" and "prop2".</param>
/// <param name="ascending">true to search in ascending order, false to sort in descending order</param>
/// <returns>
/// A Comparison delegate for the given property.
/// </returns>
/// <exception cref="System.ArgumentNullException">if properties is null.</exception>
/// <exception cref="System.ArgumentException">If any of the strings in properties is not recognized as a public property or field.</exception>
public static Comparison GetPropertyComparison(Type type, List <String> properties, bool ascending)
{
if (properties == null)
{
throw new ArgumentNullException("properties");
}
Comparison comparison;
if (cache.TryGetValue(properties, out comparison) == false)
{
comparison = CreatePropertyComparison(type, properties, true);
cache[new List <String>(properties)] = comparison;
}
if (ascending)
{
return(comparison);
}
else
{
return((Comparison) delegate(object x, object y) { return -comparison(x, y); });
}
}
/// <summary>
/// Create or reuse a XmlSerializer with a specific override!
/// The .NET Factory method "CreateSerializer" do not support caching with a custom override!
/// This method is optimized for speed and is threadsafe.
/// </summary>
/// <param name="factory"></param>
/// <param name="type"></param>
/// <param name="overrides"></param>
/// <returns></returns>
public static XmlSerializer GetSerializer(this XmlSerializerFactory factory, Type type, XmlAttributeOverrides overrides)
{
XmlSerializer result = null;
string key = type.AssemblyQualifiedName;
if (overrides != null)
{
key += overrides.GetHashCode();
if (!serializerTable.TryGetValue(key, out result))
{
result = factory.CreateSerializer(type, overrides);
serializerTable.MergeSafe(key, result);
}
}
else
{
result = factory.CreateSerializer(type);
}
return(result);
}
private object ConstructObjectInternal(Type type)
{
Func <PoorMansIoC, object> factory;
if (_factoryDelegates.TryGetValue(type, out factory))
{
var instance = factory(this);
RegisterInstance(instance);
return(instance);
}
else
{
var concreteType = ExtractConcreteTypeFor(type);
var args = concreteType.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
.Single()
.GetParameters()
.Select(p => Resolve(p.ParameterType))
.ToArray();
var instance = Activator.CreateInstance(concreteType, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, args, null);
RegisterInstance(instance);
return(instance);
}
}
private void InitFont(float scaleFactor)
{
try {
System.Diagnostics.Stopwatch sw = System.Diagnostics.Stopwatch.StartNew();
ScaleFactor = scaleFactor;
YOffsetScaled = YOffset * scaleFactor;
// Reset everything
Clear();
Font = new Face(FontManager.Library, FilePath);
// Go on
float size = Size.Scale(ScaleFactor);
Fixed26Dot6 sz = new Fixed26Dot6(size / 64);
Font.SetCharSize(sz, sz, 72, 72);
int pixelSize = (size * 1.3334).Ceil();
Font.SetPixelSizes((uint)pixelSize, (uint)pixelSize);
GlyphCount = Font.GlyphCount;
int glyphCount = GlyphCount;
Monospace = Font.FaceFlags.HasFlag(FaceFlags.FixedWidth);
string tmpName = Font.GetPostscriptName();
if (!String.IsNullOrEmpty(tmpName))
{
Name = tmpName;
}
// We support 4 different glyph loading strategies:
//
// (1) All: all glyphs loaded at once on start
// (2) Filtered: all filtered glyphs loaded at once on start
// (3) OnDemand: no glyphs loaded at start, all glyphs on demand
if (OnDemand)
{
// Startegy (3)
GlyphCount = 0;
}
else if (Filter > GlyphFilterFlags.OnDemand)
{
// Startegy (2)
// If we have a Filter set, let's count the number of valid glyphs
// to minimize graphics memory.
uint glyphindex;
uint cc = Font.GetFirstChar(out glyphindex);
int count = 0;
while (glyphindex > 0)
{
char c = (char)cc;
if (Filter.IsValid(c))
{
count++;
}
cc = Font.GetNextChar(cc, out glyphindex);
}
GlyphCount = count;
}
else
{
// Strategy (1), loading the entire font
}
m_Textures = new int[Math.Max(32, GlyphCount)];
CharMap = new ThreadSafeDictionary <char, GlyphInfo>(Math.Max(31, GlyphCount));
if (!OnDemand)
{
// Strategy (1) + (2): Load all or filtered glyphs
m_ListBase = GL.GenLists(GlyphCount);
GL.GenTextures(GlyphCount, m_Textures);
uint glyphindex;
uint cc = Font.GetFirstChar(out glyphindex);
while (glyphindex > 0)
{
char c = (char)cc;
if (!CharMap.ContainsKey(c) && Filter.IsValid(c))
{
try {
CharMap.Add(c, CompileCharacter(Font, glyphindex, c));
} catch (Exception ex) {
ex.LogWarning();
}
}
cc = Font.GetNextChar(cc, out glyphindex);
}
CharMap.TryGetValue(SpecialCharacters.Ellipsis, out m_EllipsisGlyphIndex);
}
else
{
try {
GetGlyphIndex(SpecialCharacters.Ellipsis, out m_EllipsisGlyphIndex);
} catch (Exception ex) {
ex.LogError();
}
}
//if (Height <= 1)
//Height = pixelSize.NextPowerOf2();
//Height = pixelSize * 1.33335f;
Height = pixelSize;
float fscale = Height / Font.Height * 1.33334f;
//float fscale = Height / Font.Height * 0.776f;
Ascender = Font.Ascender * fscale;
Descender = Font.Descender * fscale;
//HalfHeight = Height / 2;
Height = (Ascender).Ceil();
HalfHeight = (int)(Height / 2);
//LineHeight = Height * 1.42f * LineSpacing;
LineHeight = (int)((Height * 1.42f * LineSpacing) + 0.5f);
//TextBoxHeight = ((Height * 2f) + (ScaleFactor * 2f)).Ceil();
//TextBoxHeight = (int)(Height * 1.85f + 0.5f);
TextBoxHeight = (int)(Height * 1.85f + 2);
CaptionHeight = (int)(Height * 1.55 + 2);
YOffsetScaled = (YOffset * ScaleFactor) - HalfHeight;
if (OnDemand)
{
Count.LogInformation("Font {0} ({1}), {2}/{3} glyphs pre-loaded in {4} ms, more glyphs are loaded on demand.", Name, Size, Count, glyphCount, sw.ElapsedMilliseconds);
}
else
{
Count.LogInformation("Font {0} ({1}), {2}/{3} glyphs loaded in {4} ms.", Name, Size, Count, glyphCount, sw.ElapsedMilliseconds);
}
} catch (Exception ex) {
ex.LogError();
} finally {
if (!OnDemand && Font != null)
{
Font.Dispose();
Font = null;
}
}
}
/// <summary>
/// Returns the specified queue if it already exists but does not create one if it does not.
/// </summary>
/// <returns>True if the queue exists; false otherwise.</returns>
/// <remarks>
/// Senders should use this so that we don't fill up in-memory queues with messages for which there are no handlers.
/// Receivers should use GetOrCreateMessageQueue.
/// </remarks>
public bool TryGetExistingMessageQueue(string path, out AsyncBlockingCollection <NimbusMessage> queue)
{
return(_messageQueues.TryGetValue(path, out queue));
}
