private IEnumerable <RegisteredType> GetInitialBatch(
TypeDependencyKind kind)
{
return(_types.Values
.Where(t => t.Dependencies.All(d => d.Kind != kind))
.Distinct());
}
public TypeDependency(
ITypeReference typeReference,
TypeDependencyKind kind)
{
TypeReference = typeReference
?? throw new ArgumentNullException(nameof(typeReference));
Kind = kind;
}
private bool CompleteTypes(
TypeDependencyKind kind,
Func <RegisteredType, bool> action)
{
var processed = new HashSet <ITypeReference>();
var batch = new List <RegisteredType>(
GetInitialBatch(kind));
bool failed = false;
while (!failed && processed.Count < _types.Count && batch.Count > 0)
{
foreach (RegisteredType registeredType in batch)
{
if (!action(registeredType))
{
failed = true;
break;
}
foreach (ITypeReference reference in
registeredType.References)
{
processed.Add(reference);
}
}
if (!failed)
{
batch.Clear();
batch.AddRange(GetNextBatch(processed, kind));
}
}
if (!failed && processed.Count < _types.Count)
{
foreach (RegisteredType type in _types.Values.Distinct()
.Where(t => !processed.Contains(t.References[0])))
{
string name = type.Type.Name.HasValue
? type.Type.Name.Value
: type.References.ToString();
_errors.Add(SchemaErrorBuilder.New()
.SetMessage(string.Format(
TypeResources.TypeInitializer_CannotResolveDependency,
name,
string.Join(", ", type.Dependencies
.Where(t => t.Kind == kind)
.Select(t => t.TypeReference))))
.SetTypeSystemObject(type.Type)
.Build());
}
return(false);
}
return(_errors.Count == 0);
}
public CompleteConfiguration(
Action <ITypeCompletionContext, TDefinition> configure,
TDefinition owner,
ApplyConfigurationOn on,
ITypeReference?typeReference = null,
TypeDependencyKind kind = TypeDependencyKind.Default)
: base((c, d) => configure(c, (TDefinition)d), owner, on, typeReference, kind)
{
}
public void RegisterDependency(
ITypeReference reference,
TypeDependencyKind kind)
{
if (reference == null)
{
throw new ArgumentNullException(nameof(reference));
}
_typeDependencies.Add(new TypeDependency(reference, kind));
}
public IDependencyDescriptor DependsOn <TType>(bool mustBeNamed)
where TType : ITypeSystem
{
TypeDependencyKind kind = mustBeNamed
? TypeDependencyKind.Named
: TypeDependencyKind.Default;
_configuration.Dependencies.Add(
TypeDependency.FromSchemaType(
typeof(TType), kind));
return(this);
}
public void RegisterDependencyRange(
IEnumerable <ITypeReference> references,
TypeDependencyKind kind)
{
if (references == null)
{
throw new ArgumentNullException(nameof(references));
}
foreach (ITypeReference reference in references)
{
_typeDependencies.Add(new TypeDependency(reference, kind));
}
}
protected void DependsOn(
NameString typeName,
bool mustBeNamedOrCompleted)
{
typeName.EnsureNotEmpty(nameof(typeName));
TypeDependencyKind kind = mustBeNamedOrCompleted
? DependencyKind
: TypeDependencyKind.Default;
_configuration.AddDependency(
new TypeDependency(
TypeReference.Create(new NamedTypeNode(typeName), TypeContext.None),
kind));
}
public IDependencyDescriptor DependsOn(
NameString typeName,
bool mustBeNamed)
{
typeName.EnsureNotEmpty(nameof(typeName));
TypeDependencyKind kind = mustBeNamed
? TypeDependencyKind.Named
: TypeDependencyKind.Default;
_configuration.Dependencies.Add(
new TypeDependency(
new SyntaxTypeReference(
new NamedTypeNode(typeName), TypeContext.None),
kind));
return(this);
}
public static TypeDependency FromSchemaType(
IExtendedType type,
TypeDependencyKind kind = TypeDependencyKind.Default)
{
if (type is null)
{
throw new ArgumentNullException(nameof(type));
}
if (!type.IsSchemaType)
{
throw new ArgumentException(
TypeResources.TypeDependency_MustBeSchemaType,
nameof(type));
}
return(new TypeDependency(
Descriptors.TypeReference.Create(type),
kind));
}
public static TypeDependency FromSchemaType(
Type type,
TypeDependencyKind kind)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (BaseTypes.IsSchemaType(type))
{
TypeContext context = SchemaTypeReference.InferTypeContext(type);
var reference = new ClrTypeReference(type, context);
return(new TypeDependency(reference, kind));
}
throw new ArgumentException(
TypeResources.TypeDependency_MustBeSchemaType,
nameof(type));
}
protected void DependsOn(IExtendedType schemaType, bool mustBeNamedOrCompleted)
{
if (schemaType is null)
{
throw new ArgumentNullException(nameof(schemaType));
}
if (!schemaType.IsSchemaType)
{
throw new ArgumentException(
TypeResources.DependencyDescriptorBase_OnlyTsoIsAllowed,
nameof(schemaType));
}
TypeDependencyKind kind = mustBeNamedOrCompleted
? DependencyKind
: TypeDependencyKind.Default;
_configuration.AddDependency(
TypeDependency.FromSchemaType(schemaType, kind));
}
private IEnumerable <RegisteredType> GetNextBatch(
ISet <ITypeReference> processed,
TypeDependencyKind kind)
{
foreach (RegisteredType type in _typeRegistry.Types)
{
if (!processed.Contains(type.References[0]))
{
IEnumerable <ITypeReference> references =
type.Dependencies.Where(t => t.Kind == kind)
.Select(t => t.TypeReference);
if (TryNormalizeDependencies(references,
out IReadOnlyList <ITypeReference>?normalized) &&
processed.IsSupersetOf(normalized))
{
yield return(type);
}
}
}
}
protected void DependsOn(Type schemaType, bool mustBeNamedOrCompleted)
{
if (schemaType == null)
{
throw new ArgumentNullException(nameof(schemaType));
}
if (!typeof(ITypeSystemMember).IsAssignableFrom(schemaType))
{
throw new ArgumentException(
TypeResources.DependencyDescriptorBase_OnlyTsoIsAllowed,
nameof(schemaType));
}
TypeDependencyKind kind = mustBeNamedOrCompleted
? DependencyKind
: TypeDependencyKind.Default;
_configuration.Dependencies.Add(
TypeDependency.FromSchemaType(
schemaType, kind));
}
protected void DependsOn(Type schemaType, bool mustBeNamedOrCompleted)
{
if (schemaType == null)
{
throw new ArgumentNullException(nameof(schemaType));
}
if (!typeof(ITypeSystem).IsAssignableFrom(schemaType))
{
// TODO : resources
throw new ArgumentException(
"Only type system objects are allowed.");
}
TypeDependencyKind kind = mustBeNamedOrCompleted
? DependencyKind
: TypeDependencyKind.Default;
_configuration.Dependencies.Add(
TypeDependency.FromSchemaType(
schemaType, kind));
}
private bool ProcessTypes(
TypeDependencyKind kind,
Func <RegisteredType, bool> action)
{
var processed = new HashSet <ITypeReference>();
var batch = new List <RegisteredType>(GetInitialBatch(kind));
var failed = false;
while (!failed &&
processed.Count < _typeRegistry.Count &&
batch.Count > 0)
{
foreach (RegisteredType registeredType in batch)
{
if (!action(registeredType))
{
failed = true;
break;
}
foreach (ITypeReference reference in registeredType.References)
{
processed.Add(reference);
}
}
if (!failed)
{
batch.Clear();
batch.AddRange(GetNextBatch(processed, kind));
}
}
if (!failed && processed.Count < _typeRegistry.Count)
{
foreach (RegisteredType type in _typeRegistry.Types
.Where(t => !processed.Contains(t.References[0])))
{
string name = type.Type.Name.HasValue
? type.Type.Name.Value
: type.References[0].ToString() !;
ITypeReference[] references =
type.Dependencies.Where(t => t.Kind == kind)
.Select(t => t.TypeReference).ToArray();
IReadOnlyList <ITypeReference> needed =
TryNormalizeDependencies(references,
out IReadOnlyList <ITypeReference>?normalized)
? normalized.Except(processed).ToArray()
: references;
_errors.Add(SchemaErrorBuilder.New()
.SetMessage(
TypeInitializer_CannotResolveDependency,
name,
string.Join(", ", needed))
.SetTypeSystemObject(type.Type)
.Build());
}
return(false);
}
return(_errors.Count == 0);
}
