public void UpdateType(RegisteredType registeredType) { foreach (ITypeReference typeReference in registeredType.References) { _registered[typeReference] = registeredType; } }
public void Register(NameString typeName, RegisteredType registeredType) { if (registeredType is null) { throw new ArgumentNullException(nameof(registeredType)); } typeName.EnsureNotEmpty(nameof(typeName)); if (registeredType.IsExtension) { return; } if (!registeredType.IsNamedType && !registeredType.IsDirectiveType) { return; } if (TryGetTypeRef(typeName, out ITypeReference? typeRef) && TryGetType(typeRef, out RegisteredType? type) && !ReferenceEquals(type, registeredType)) { throw TypeInitializer_DuplicateTypeName(registeredType.Type, type.Type); } _nameRefs[typeName] = registeredType.References[0]; }
public void Register(RegisteredType registeredType) { if (registeredType is null) { throw new ArgumentNullException(nameof(registeredType)); } bool addToTypes = !_typeRegister.ContainsValue(registeredType); foreach (ITypeReference typeReference in registeredType.References) { if (_typeRegister.TryGetValue(typeReference, out RegisteredType? current) && !ReferenceEquals(current, registeredType)) { if (current.IsInferred && !registeredType.IsInferred) { _typeRegister[typeReference] = registeredType; if (!_typeRegister.ContainsValue(current)) { _types.Remove(current); } } } else { _typeRegister[typeReference] = registeredType; } } if (addToTypes) { _types.Add(registeredType); } }
public void Register(TypeSystemObjectBase typeSystemObject, bool isInferred = false) { RegisteredType registeredType = InitializeType(typeSystemObject, isInferred); if (registeredType.References.Count > 0) { foreach (ITypeReference typeReference in registeredType.References) { _registered[typeReference] = registeredType; _unresolved.Remove(typeReference); } if (typeSystemObject is IHasClrType hasClrType && hasClrType.ClrType != typeof(object)) { var clrRef = new ClrTypeReference( hasClrType.ClrType, SchemaTypeReference.InferTypeContext(typeSystemObject)); _unresolved.Remove(clrRef); if (!_clrTypeReferences.ContainsKey(clrRef)) { _clrTypeReferences.Add(clrRef, registeredType.References[0]); } } } }
public void Register(TypeSystemObjectBase typeSystemObject, bool isInferred = false) { RegisteredType registeredType = InitializeType(typeSystemObject, isInferred); if (registeredType.References.Count > 0) { foreach (ITypeReference typeReference in registeredType.References) { _registered[typeReference] = registeredType; _unresolved.Remove(typeReference); } if (typeSystemObject is IHasClrType hasClrType && hasClrType.ClrType != typeof(object)) { var clrRef = new ClrTypeReference( hasClrType.ClrType, SchemaTypeReference.InferTypeContext(typeSystemObject)); _unresolved.Remove(clrRef); bool autoBind = true; if (typeSystemObject is ScalarType scalar && scalar.Bind == BindingBehavior.Explicit) { autoBind = false; } if (autoBind && !_clrTypeReferences.ContainsKey(clrRef)) { _clrTypeReferences.Add(clrRef, registeredType.References[0]); } } } }
private void ResolveReferences(RegisteredType registeredType) { foreach (ITypeReference typeReference in registeredType.References) { _registered[typeReference] = registeredType; MarkResolved(typeReference); } }
private void ResolveReferences(RegisteredType registeredType) { _typeRegistry.Register(registeredType); foreach (ITypeReference typeReference in registeredType.References) { MarkResolved(typeReference); } }
private RegisteredType InitializeType( TypeSystemObjectBase typeSystemObject, string?scope, bool isInferred) { try { var discoveryContext = new TypeDiscoveryContext( typeSystemObject, scope, _serviceFactory.Services, _descriptorContext, _interceptor); typeSystemObject.Initialize(discoveryContext); var references = new List <ITypeReference>(); if (!isInferred) { references.Add(TypeReference.Create( typeSystemObject, scope: scope)); } if (!BaseTypes.IsNonGenericBaseType(typeSystemObject.GetType())) { references.Add(TypeReference.Create( typeSystemObject.GetType(), SchemaTypeReference.InferTypeContext(typeSystemObject), scope: scope)); } if (typeSystemObject is IHasTypeIdentity hasTypeIdentity && hasTypeIdentity.TypeIdentity is { }) { var reference = TypeReference.Create( hasTypeIdentity.TypeIdentity, SchemaTypeReference.InferTypeContext(typeSystemObject), scope: scope); if (!references.Contains(reference)) { references.Add(reference); } } var registeredType = new RegisteredType( references, typeSystemObject, discoveryContext, CollectDependencies(discoveryContext), isInferred); return(registeredType); }
private RegisteredType InitializeType( TypeSystemObjectBase typeSystemObject, bool isInferred) { try { var initializationContext = new InitializationContext( typeSystemObject, _serviceFactory.Services, _descriptorContext, _contextData, _interceptor); typeSystemObject.Initialize(initializationContext); var references = new List <ITypeReference>(); if (!isInferred) { references.Add(new SchemaTypeReference(typeSystemObject)); } if (!BaseTypes.IsNonGenericBaseType(typeSystemObject.GetType())) { references.Add(new ClrTypeReference( typeSystemObject.GetType(), SchemaTypeReference.InferTypeContext(typeSystemObject))); } if (typeSystemObject is IHasTypeIdentity hasTypeIdentity && hasTypeIdentity.TypeIdentity is { }) { var reference = new ClrTypeReference( hasTypeIdentity.TypeIdentity, SchemaTypeReference.InferTypeContext(typeSystemObject)); if (!references.Contains(reference)) { references.Add(reference); } } var registeredType = new RegisteredType( references, typeSystemObject, initializationContext, initializationContext.TypeDependencies, isInferred); return(registeredType); }
public bool TryGetType( ITypeReference typeReference, out RegisteredType registeredType) { ITypeReference typeRef = typeReference; if (typeRef is IClrTypeReference clrTypeRef && _clrTypeReferences.TryGetValue(clrTypeRef, out ITypeReference t)) { typeRef = t; } return(_registered.TryGetValue(typeRef, out registeredType)); }
private bool TryNormalizeDependencies( RegisteredType registeredType, IEnumerable <ITypeReference> dependencies, out IReadOnlyList <ITypeReference> normalized) { var n = new List <ITypeReference>(); foreach (ITypeReference reference in dependencies) { if (!TryNormalizeReference(reference, out ITypeReference nr)) { normalized = null; return(false); } _depsLup[reference] = nr; n.Add(nr); } normalized = n; return(true); }
private void MergeTypeExtension( IEnumerable <RegisteredType> extensions, RegisteredType registeredType, INamedType namedType) { foreach (RegisteredType extension in extensions) { if (extension.Type is INamedTypeExtensionMerger m) { if (m.Kind != namedType.Kind) { throw new SchemaException(SchemaErrorBuilder.New() .SetMessage(string.Format( CultureInfo.InvariantCulture, TypeInitializer_Merge_KindDoesNotMatch, namedType.Name)) .SetTypeSystemObject((ITypeSystemObject)namedType) .Build()); } TypeDiscoveryContext initContext = extension.DiscoveryContext; foreach (FieldReference reference in initContext.Resolvers.Keys) { _resolvers[reference] = initContext.Resolvers[reference].WithSourceType(registeredType.RuntimeType); } // merge TypeCompletionContext context = extension.CompletionContext; context.Status = TypeStatus.Named; m.Merge(context, namedType); // update dependencies context = registeredType.CompletionContext; registeredType.AddDependencies(extension.Dependencies); _typeRegistry.Register(registeredType); CopyAlternateNames(extension.CompletionContext, context); } } }
private void MergeTypeExtensions() { var extensions = _types.Values .Where(t => t.Type is INamedTypeExtensionMerger) .Distinct() .ToList(); if (extensions.Count > 0) { var types = _types.Values .Where(t => t.Type is INamedType) .Distinct() .ToList(); foreach (RegisteredType extension in extensions) { RegisteredType type = types.FirstOrDefault(t => t.Type.Name.Equals(extension.Type.Name)); if (type != null && extension.Type is INamedTypeExtensionMerger m && type.Type is INamedType n) { // merge CompletionContext context = _cmpCtx[extension]; context.Status = TypeStatus.Named; MergeTypeExtension(context, m, n); // update dependencies context = _cmpCtx[type]; type = type.AddDependencies(extension.Dependencies); type.Update(_types); _cmpCtx[type] = context; CopyAlternateNames(_cmpCtx[extension], context); } } } }
public bool TryGetRegisteredType( ITypeReference reference, out RegisteredType registeredType) { if (reference == null) { throw new ArgumentNullException(nameof(reference)); } if (_types.TryGetValue(reference, out registeredType)) { return(true); } if (TryNormalizeReference(reference, out ITypeReference nr) && _types.TryGetValue(nr, out registeredType)) { return(true); } registeredType = null; return(false); }
public void Register( TypeSystemObjectBase typeSystemObject, string?scope, bool isInferred = false) { RegisteredType registeredType = InitializeType( typeSystemObject, scope, isInferred); if (registeredType.References.Count > 0) { ResolveReferences(registeredType); if (typeSystemObject is IHasRuntimeType hasClrType && hasClrType.RuntimeType != typeof(object)) { var clrRef = TypeReference.Create( hasClrType.RuntimeType, SchemaTypeReference.InferTypeContext(typeSystemObject), scope: scope); var explicitBind = typeSystemObject is ScalarType scalar && scalar.Bind == BindingBehavior.Explicit; if (!explicitBind) { MarkResolved(clrRef); if (!_clrTypeReferences.ContainsKey(clrRef)) { _clrTypeReferences.Add(clrRef, registeredType.References[0]); } } } } }
public void Register( TypeSystemObjectBase typeSystemObject, string?scope, bool isInferred = false) { if (typeSystemObject is null) { throw new ArgumentNullException(nameof(typeSystemObject)); } RegisteredType registeredType = InitializeType(typeSystemObject, scope, isInferred); if (registeredType.References.Count > 0) { ResolveReferences(registeredType); if (typeSystemObject is IHasRuntimeType hasRuntimeType && hasRuntimeType.RuntimeType != typeof(object)) { ExtendedTypeReference runtimeTypeRef = _context.TypeInspector.GetTypeRef( hasRuntimeType.RuntimeType, SchemaTypeReference.InferTypeContext(typeSystemObject), scope: scope); var explicitBind = typeSystemObject is ScalarType scalar && scalar.Bind == BindingBehavior.Explicit; if (!explicitBind) { MarkResolved(runtimeTypeRef); _typeRegistry.TryRegister(runtimeTypeRef, registeredType.References[0]); } } } }
private RegisteredType InitializeType( TypeSystemObjectBase typeSystemObject, string?scope, bool isInferred) { try { var discoveryContext = new TypeDiscoveryContext( typeSystemObject, _typeRegistry, _typeLookup, _context, _interceptor, scope); typeSystemObject.Initialize(discoveryContext); var references = new List <ITypeReference>(); if (!isInferred) { references.Add(TypeReference.Create(typeSystemObject, scope)); } if (!ExtendedType.Tools.IsNonGenericBaseType(typeSystemObject.GetType())) { references.Add(_context.TypeInspector.GetTypeRef( typeSystemObject.GetType(), SchemaTypeReference.InferTypeContext(typeSystemObject), scope)); } if (typeSystemObject is IHasTypeIdentity hasTypeIdentity && hasTypeIdentity.TypeIdentity is not null) { ExtendedTypeReference reference = _context.TypeInspector.GetTypeRef( hasTypeIdentity.TypeIdentity, SchemaTypeReference.InferTypeContext(typeSystemObject), scope); if (!references.Contains(reference)) { references.Add(reference); } } var registeredType = new RegisteredType( typeSystemObject, references, CollectDependencies(discoveryContext), discoveryContext, isInferred); return(registeredType); } catch (Exception ex) { throw new SchemaException( SchemaErrorBuilder.New() .SetMessage(ex.Message) .SetException(ex) .SetTypeSystemObject(typeSystemObject) .Build()); } }