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); }