public void From_InputObjectOfIntType()
{
// arrange
// act
ExtendedType extendedType = ExtendedType.FromType(
typeof(InputObjectType <IntType>),
_cache);
// assert
Assert.True(extendedType.IsSchemaType);
Assert.True(extendedType.IsGeneric);
Assert.True(extendedType.IsNamedType);
Assert.True(extendedType.IsNullable);
IExtendedType argument = extendedType.TypeArguments[0];
Assert.True(argument.IsSchemaType);
Assert.False(argument.IsGeneric);
Assert.True(extendedType.IsNamedType);
Assert.True(argument.IsNullable);
}
public ExtendedType GetOrCreateType(object member, Func <ExtendedType> create)
{
lock (_sync)
{
if (!_typeMemberLookup.TryGetValue(member, out ExtendedType? extendedType))
{
ExtendedType type = create();
if (_types.TryGetValue(type.Id, out extendedType))
{
_typeMemberLookup[member] = extendedType;
}
else
{
extendedType = type;
_types[extendedType.Id] = extendedType;
_typeMemberLookup[member] = extendedType;
}
}
return(extendedType);
}
}
public void From_SystemType_List()
{
// arrange
// act
IExtendedType list = ExtendedType.FromType(
typeof(NativeType <List <byte?> >),
_cache);
list = ExtendedType.Tools.ChangeNullability(
list, new bool?[] { false }, _cache);
ExtendedType nullableList = ExtendedType.FromType(
typeof(List <byte?>),
_cache);
// assert
Assert.True(list.IsList);
Assert.True(list.IsArrayOrList);
Assert.False(list.IsNullable);
Assert.True(nullableList.IsList);
Assert.True(nullableList.IsArrayOrList);
Assert.True(nullableList.IsNullable);
}
private static ExtendedType ChangeNullability(
ExtendedTypeId id,
ExtendedType type,
ReadOnlySpan <bool?> nullable,
ref int position,
TypeCache cache)
{
if (cache.TryGetType(id, out ExtendedType? cached))
{
return(cached);
}
var pos = position++;
var changeNullability =
nullable.Length > pos &&
nullable[pos].HasValue &&
nullable[pos] !.Value != type.IsNullable;
IReadOnlyList <ExtendedType>?typeArguments = type.TypeArguments;
if (type.TypeArguments.Count > 0 && nullable.Length > position)
{
var args = new ExtendedType[type.TypeArguments.Count];
for (var j = 0; j < type.TypeArguments.Count; j++)
{
ExtendedType typeArgument = type.TypeArguments[j];
ExtendedTypeId typeArgumentId =
Tools.CreateId(typeArgument, nullable.Slice(position));
args[j] = nullable.Length > position
? ChangeNullability(
typeArgumentId,
typeArgument,
nullable,
ref position,
cache)
: type.TypeArguments[j];
}
typeArguments = args;
}
if (changeNullability || !ReferenceEquals(typeArguments, type.TypeArguments))
{
ExtendedType?elementType = type.IsArrayOrList
? type.ElementType
: null;
if (elementType is not null &&
!ReferenceEquals(typeArguments, type.TypeArguments))
{
for (var e = 0; e < type.TypeArguments.Count; e++)
{
if (ReferenceEquals(elementType, type.TypeArguments[e]))
{
elementType = typeArguments[e];
}
}
}
var rewritten = new ExtendedType(
type.Type,
type.Kind,
typeArguments: typeArguments,
source: type.Source,
definition: type.Definition,
elementType: elementType,
isList: type.IsList,
isNamedType: type.IsNamedType,
isNullable: nullable[pos] ?? type.IsNullable);
return(cache.TryAdd(rewritten)
? rewritten
: cache.GetType(rewritten.Id));
}
return((ExtendedType)type);
}
