public Key(RoDefinitionType genericTypeDefinition, RoType[] genericTypeArguments)
{
Debug.Assert(genericTypeDefinition != null);
Debug.Assert(genericTypeArguments != null);
GenericTypeDefinition = genericTypeDefinition;
GenericTypeArguments = genericTypeArguments;
}
internal RoConstructedGenericType(RoDefinitionType genericTypeDefinition, RoType[] genericTypeArguments)
: base()
{
Debug.Assert(genericTypeDefinition != null);
Debug.Assert(genericTypeArguments != null);
_genericTypeDefinition = genericTypeDefinition;
_genericTypeArguments = genericTypeArguments;
}
public void Add(int hashCode, RoDefinitionType value)
{
int bucket = ComputeBucket(hashCode, _buckets.Length);
int newEntryIdx = _nextFreeEntry;
_entries[newEntryIdx]._value = value;
_entries[newEntryIdx]._hashCode = hashCode;
_entries[newEntryIdx]._next = _buckets[bucket];
_nextFreeEntry++;
// The line that atomically adds the new key/value pair. If the thread is killed before this line executes but after
// we've incremented _nextFreeEntry, this entry is harmlessly leaked until the next resize.
Volatile.Write(ref _buckets[bucket], newEntryIdx);
VerifyUnifierConsistency();
}
public bool TryGetValue(ReadOnlySpan <byte> ns, ReadOnlySpan <byte> name, int hashCode, [NotNullWhen(true)] out RoDefinitionType?value)
{
// Lock acquistion NOT required.
int bucket = ComputeBucket(hashCode, _buckets.Length);
int i = Volatile.Read(ref _buckets[bucket]);
while (i != -1)
{
if (hashCode == _entries[i]._hashCode)
{
RoDefinitionType actualValue = _entries[i]._value;
if (actualValue.IsTypeNameEqual(ns, name))
{
value = actualValue;
return(true);
}
}
i = _entries[i]._next;
}
value = default;
return(false);
}
internal RoDefinitionType GetTypeCore(ReadOnlySpan <byte> ns, ReadOnlySpan <byte> name, bool ignoreCase, out Exception e)
{
RoDefinitionType result = GetRoManifestModule().GetTypeCore(ns, name, ignoreCase, out e);
if (IsSingleModule || result != null)
{
return(result);
}
foreach (RoModule module in ComputeRoModules(getResourceModules: false))
{
if (module == ManifestModule)
{
continue;
}
result = module.GetTypeCore(ns, name, ignoreCase, out e);
if (result != null)
{
return(result);
}
}
return(null);
}
//
// Constructed Generic Types
//
internal RoConstructedGenericType GetUniqueConstructedGenericType(RoDefinitionType genericTypeDefinition, RoType[] genericTypeArguments)
{
return(_constructedGenericTypeDict.GetOrAdd(new RoConstructedGenericType.Key(genericTypeDefinition, genericTypeArguments), s_constructedGenericTypeFactory));
}
public RoDefinitionType GetOrAdd(ReadOnlySpan <byte> ns, ReadOnlySpan <byte> name, int hashCode, RoDefinitionType type)
{
if (_container.TryGetValue(ns, name, hashCode, out RoDefinitionType? prior))
{
return(prior);
}
Monitor.Enter(_lock);
try
{
if (_container.TryGetValue(ns, name, hashCode, out RoDefinitionType? winner))
{
return(winner);
}
if (!_container.HasCapacity)
{
_container.Resize(); // This overwrites the _container field.
}
_container.Add(hashCode, type);
return(type);
}
finally
{
Monitor.Exit(_lock);
}
}
public bool TryGet(ReadOnlySpan <byte> ns, ReadOnlySpan <byte> name, int hashCode, out RoDefinitionType type)
{
return(_container.TryGetValue(ns, name, hashCode, out type));
}
public static RoConstructedGenericType GetUniqueConstructedGenericType(this RoDefinitionType genericTypeDefinition, RoType[] genericTypeArguments) => genericTypeDefinition.GetRoModule().GetUniqueConstructedGenericType(genericTypeDefinition, genericTypeArguments);
