public void SingleEntry()
{
var d = new DictionarySlim <ulong, int>();
d.GetOrAddValueRef(7)++;
d.GetOrAddValueRef(7) += 3;
Assert.Equal(4, d.GetOrAddValueRef(7));
}
public void TryGetValue_Missing()
{
var d = new DictionarySlim <char, int>();
d.GetOrAddValueRef('a') = 9;
d.GetOrAddValueRef('b') = 11;
d.Remove('b');
Assert.Equal(false, d.TryGetValue('z', out int value));
Assert.Equal(default, value);
public void ContainKey()
{
var d = new DictionarySlim <ulong, int>();
d.GetOrAddValueRef(7) = 9;
d.GetOrAddValueRef(10) = 10;
Assert.True(d.ContainsKey(7));
Assert.True(d.ContainsKey(10));
Assert.False(d.ContainsKey(1));
}
public void TryGetValue_Present()
{
var d = new DictionarySlim <char, int>();
d.GetOrAddValueRef('a') = 9;
d.GetOrAddValueRef('b') = 11;
Assert.Equal(true, d.TryGetValue('a', out int value));
Assert.Equal(9, value);
Assert.Equal(true, d.TryGetValue('b', out value));
Assert.Equal(11, value);
}
internal static List <MethodInfo> GetAfterDeserializeMethods(Type type)
{
lock (_deserializeCacheLock)
{
ref var methods = ref _deserializeCache.GetOrAddValueRef(type);
if (methods == null)
{
var start = Enumerable.Empty <MethodInfo>();
while (type != null)
{
var newMethods = type.GetMethods(
BindingFlags.Instance
| BindingFlags.Static
| BindingFlags.Public
| BindingFlags.NonPublic
| BindingFlags.DeclaredOnly)
.Where(x => x.CustomAttributes.Any(a => a.AttributeType == typeof(AfterDeserialization)) &&
(
x.GetParameters().Length <= 1 && !x.IsStatic ||
x.GetParameters().Length <= 2 && x.GetParameters().Length >= 1 && x.IsStatic
));
start = start.Concat(newMethods);
type = type.BaseType !;
}
methods = start.Reverse().ToList();
}
return(methods);
}
internal static List <FieldInfo> GetOrderedFields(Type type, ImmutableSettings settings)
{
var mustUseReflectionToSetReadonly = FieldInfoModifier.MustUseReflectionToSetReadonly(settings);
lock (_cacheLock)
{
ref var fields = ref _orderedCache.GetOrAddValueRef(new OrderedTypeCacheKey {
Type = type, Flattened = settings.FlattenClassHierarchy
});
if (fields == null)
{
var unorderedFields = settings.FlattenClassHierarchy ? GetFlattenedFields(type) : GetFields(type);
if (mustUseReflectionToSetReadonly)
{
fields = unorderedFields.OrderBy(x => IsPrimitive(x.FieldType) ? 0 : 1)
.ThenBy(x => x.IsInitOnly ? 0 : 1)
.ThenBy(x => x.FieldType == typeof(string) ? 0 : 1)
.ThenBy(x => x.Name).ToList();
}
else
{
fields = unorderedFields.OrderBy(x => IsPrimitive(x.FieldType) ? 0 : 1)
.ThenBy(x => x.FieldType == typeof(string) ? 0 : 1)
.ThenBy(x => x.Name).ToList();
}
}
return(fields);
}
public void LoadDictionarySlim()
{
_dictSlim = new DictionarySlim <int, int>();
for (int i = 0; i < Size; i++)
{
_dictSlim.GetOrAddValueRef(i * 7) = -i;
}
}
public void LoadDictionarySlim()
{
for (int i = 0; i < _keys.Length; i++)
{
var k = _keys[i];
_refDict.GetOrAddValueRef(k) += k.HashCode;
}
}
private static void Check(DictionarySlim <long, int> dict, ref long rollingKey, byte nb, long mask)
{
if (nb == 255)
{
return;
}
rollingKey = ((rollingKey & mask) << 2) | nb;
dict.GetOrAddValueRef(rollingKey)++;
}
// [Fact] // Test too slow
public void ResizeToCapacity()
{
var d = new DictionarySlim <uint, byte>();
Assert.Throws <InvalidOperationException>(() =>
{
for (uint i = 0; i < uint.MaxValue; i++)
{
d.GetOrAddValueRef(i) = (byte)1;
}
});
}
static void AssignBots(IEnumerable <Assignment> assignments, DictionarySlim <int, Bot> bots, Logger logger)
{
foreach (var assignment in assignments)
{
ref var bot = ref bots.GetOrAddValueRef(assignment.BotNumber);
if (bot is null)
{
bot = new Bot(assignment.BotNumber);
}
bot.Set(assignment.Value);
logger.AssignValue(bot.Number, assignment.Value);
}
public DictionarySlim <string, string> DictSlim_GetOrAddValueRef()
{
var map = new DictionarySlim <string, string>();
for (var i = 0; i < Count; ++i)
{
var a = i.ToString();
var v = a + Seed;
map.GetOrAddValueRef(v + a) = v;
}
return(map);
}
public static IEnumerable <IGrouping <TKey, TSource> > GroupByRef <TSource, TKey>(this IEnumerable <TSource> source, Func <TSource, TKey> keySelector) where TKey : IEquatable <TKey>
{
var dict = new DictionarySlim <TKey, Grouping <TKey, TSource> >();
foreach (var t in source)
{
var k = keySelector(t);
ref var g = ref dict.GetOrAddValueRef(k);
if (g == null)
{
g = new Grouping <TKey, TSource>(k);
}
g.Add(t);
}
public void Precompile(Type type)
{
if (type.IsGenericTypeDefinition)
{
throw new ArgumentException("Cannot compile for a generic type definition", nameof(type));
}
lock (VirtualReadMethods)
{
ref var readMethod = ref VirtualReadMethods.GetOrAddValueRef(type);
if (readMethod == null)
{
readMethod = DynamicCode <TStream, Binary <TStream, TSettingGen> > .GenerateReadMethod <ReadObject>(type, Settings, true, false);
}
}
public bool TryAdd(TKey key, TValue value)
{
if (value.StorageIndex != 0)
{
ThrowStorageIndexNonZero();
}
EnterWriteLock();
try
{
var h = GCHandle.Alloc(value, GCHandleType.Weak);
ref var hr = ref _inner.GetOrAddValueRef(key);
var added = true;
if (hr.IsAllocated)
{
h.Free();
added = false;
}
else
{
hr = h;
var idx = _counter++; // we are inside lock, do not need: Interlocked.Increment(ref _counter);
if (idx >= _index.Length)
{
if (_freeSlots.Count == 0)
{
GrowIndexArray();
}
else
{
idx = _freeSlots.Pop();
if (AdditionalCorrectnessChecks.Enabled)
{
if (_index[idx].IsAllocated)
{
ThrowHelper.FailFast("Free slot is allocated");
}
}
}
}
value.StorageIndex = idx;
_index[idx] = h;
}
return(added);
}
public void CompareSCGAndFastDictionaryWithInts()
{
var dictionary = new Dictionary <long, long>();
var dictionarySlim = new DictionarySlim <long, long>();
var fastDictionary = new FastDictionary <long, long>();
var concurrentDictionary = new ConcurrentDictionary <long, long>();
var length = 10000;
for (int i = 0; i < length; i++)
{
dictionary.Add(i, i);
ref var x = ref dictionarySlim.GetOrAddValueRef(i);
x = i;
fastDictionary.Add(i, i);
concurrentDictionary[i] = i;
}
private void FindAndResolveLabels(Match match) //when a label is found, substitutes all instances of this label with the equivalent 8085 memory address
{
if (labels.ContainsKey(match.Groups["label"].Value))
{
errors_list.Add(new AssembleError($"Label {match.Groups["label"].Value} was previously defined", line_number));
}
else
{
labels.GetOrAddValueRef(match.Groups["label"].Value) = counter;
if (to_be_resolved.TryGetValue(match.Groups["label"].Value, out IReadOnlyCollection <KeyValuePair <ushort, int> > address_line))
{
byte[] address_bytes = BitConverter.GetBytes(counter);
foreach (KeyValuePair <ushort, int> item in address_line)
{
temp_memory[item.Key] = address_bytes[0];
temp_memory[item.Key + 1] = address_bytes[1];
}
to_be_resolved.Remove(match.Groups["label"].Value);
}
}
}
public void Write <T>(T value, Stream outputStream)
{
_lastRefType = null;
_stream.WriteTo(outputStream);
WriteObjectEntry(value);
_stream.Flush();
if (Settings.SerializationMode == Mode.Graph)
{
_savedObjectLookup.Clear();
if (_internedObjects.Count > 0)
{
foreach (var o in _internedObjects)
{
_savedObjectLookup.GetOrAddValueRef(o) = _savedObjectLookup.Count;
}
}
}
_savedTypeLookup.Clear();
}
public void Setup()
{
dictionary = new Dictionary <string, bool>(data.Length);
foreach (var item in data)
{
dictionary.Add(item, true);
}
dictionarySlim = new DictionarySlim <string, bool>(data.Length);
foreach (var item in data)
{
dictionarySlim.GetOrAddValueRef(item) = true;
}
hashset = new HashSet <string>();
foreach (var item in data)
{
hashset.Add(item);
}
array[8] = 444;
}
static void Main(string[] args)
{
var counts = new DictionarySlim <string, int>();
var buffer = new char[BufferSize];
var offset = 0;
while (true)
{
// Read from stdin in chars
var bytesRead = Console.In.Read(buffer, offset, BufferSize - offset);
if (bytesRead == 0)
{
break;
}
// Determine last delimiter position
var bufferLength = offset + bytesRead;
var lastDelimiterIndex = -1;
for (var k = bufferLength - 1; k >= 0; --k)
{
if (buffer[k] <= ' ')
{
lastDelimiterIndex = k;
break;
}
}
var count = lastDelimiterIndex >= 0 ? lastDelimiterIndex : bufferLength;
var i = 0;
while (true)
{
// Skip whitespaces before each word
for (; i < count; ++i)
{
var c = buffer[i];
if (c > ' ')
{
break;
}
}
// Find word boundary and make it lowercase at the same time.
var start = i;
for (; i < count; ++i)
{
var c = buffer[i];
if (c <= ' ')
{
break;
}
// Set 6th bit to make char lowercase
buffer[i] = (char)(buffer[i] | 0x20);
}
if (i <= start)
{
break;
}
// Collect word statistics
var word = new String(buffer, start, i - start);
ref var curCount = ref counts.GetOrAddValueRef(word);
curCount++;
}
// Copy remaining part to the beginning of the buffer.
if (lastDelimiterIndex >= 0)
{
offset = (offset + bytesRead - 1) - lastDelimiterIndex;
Array.Copy(buffer, lastDelimiterIndex + 1, buffer, 0, offset);
}
else
{
offset = 0;
}
}
