Пример #1
0
 private static void CopyAlternateNames(
     TypeCompletionContext source,
     TypeCompletionContext destination)
 {
     foreach (NameString name in source.AlternateTypeNames)
     {
         destination.AlternateTypeNames.Add(name);
     }
 }
Пример #2
0
        public void SetCompletionContext(TypeCompletionContext completionContext)
        {
            if (_completionContext is not null)
            {
                throw new InvalidOperationException(
                          TypeResources.RegisteredType_CompletionContext_Already_Set);
            }

            _completionContext = completionContext;
        }
Пример #3
0
        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);
                }
            }
        }
Пример #4
0
        private void CompleteTypes()
        {
            bool CompleteType(RegisteredType registeredType)
            {
                if (!registeredType.IsExtension)
                {
                    TypeCompletionContext context = registeredType.CompletionContext;
                    context.Status      = TypeStatus.Named;
                    context.IsQueryType = _isQueryType.Invoke(registeredType.Type);
                    registeredType.Type.CompleteType(context);
                }
                return(true);
            }

            ProcessTypes(TypeDependencyKind.Completed, CompleteType);
            EnsureNoErrors();

            if (_interceptor.TriggerAggregations)
            {
                _interceptor.OnTypesCompleted(
                    _typeRegistry.Types.Select(t => t.CompletionContext).ToList());
            }
        }