public AttributionSpec(ClrClassName AttributeName, params AttributeParameterSpec[] parameters)
{
this.AttributeName = AttributeName;
this.Parameters
= parameters.Any(p => p.ParameterPosition == null)
? parameters.ToReadOnlyList()
: parameters.OrderBy(x => x.ParameterPosition.Value).ToReadOnlyList();
}
public static ConstructorInvocationSpec SpecifyConstructorInvocation
(
this ClrClassName declaringType,
IEnumerable <NamedValue> paramValues
) => new ConstructorInvocationSpec
(
declaringType.CreateReference(),
map(paramValues, SpecifyArgumentValue).ToArray()
);
public static MethodSpec SpecifyCustomMethod(this ClrClassName type, ClrCustomMemberIdentifier kind)
{
return(new MethodSpec
(
type,
kind?.ToString() ?? string.Empty,
ReturnType: null,
CustomMemberKind: kind
));
}
public static IEnumerable <ConstructorSpec> SpecifyStandardConstructors(this ClrClassName typeName, IReadOnlyList <PropertySpec> properties)
{
yield return(new DefaultConstructorSpec(typeName));
if (properties.Count != 0)
{
yield return(new ItemArrayConstructorSpec(typeName, properties));
yield return(new PropertyConstructorSpec(typeName, properties));
}
}
/// <summary>
/// Defines a field
/// </summary>
/// <param name="DeclaringType">The type that declares the field</param>
/// <param name="FieldName">The name of the field</param>
/// <param name="FieldType">The field's type</param>
/// <param name="AccessLevel">The fields visibility</param>
/// <param name="IsStatic">Specifies whether the field is static</param>
/// <param name="IsReadOnly">Specifies whether the field is readonly</param>
/// <param name="Initializer">Specifies the value with which the field is initialized</param>
/// <returns></returns>
public static FieldSpec SpecifyField(this ClrClassName DeclaringType, ClrFieldName FieldName,
ClrTypeReference FieldType, ClrAccessKind?AccessLevel = null, bool IsStatic = true,
bool IsReadOnly = true, ConstructorInvocationSpec Initializer = null)
=> new FieldSpec
(
DeclaringTypeName: DeclaringType,
Name: FieldName,
FieldType: FieldType,
AccessLevel: AccessLevel ?? ClrAccessKind.Public,
IsStatic: true,
IsReadOnly: true,
Initializer: Initializer != null ? new FieldInitializerSpec(Initializer) : null
);
public ItemArrayConstructorSpec(ClrClassName DeclaringTypeName,
IReadOnlyList <PropertySpec> InitializedMembers,
ClrAccessKind?AccessLevel = null)
: base
(
DeclaringTypeName,
AccessLevel,
MethodParameters: roitems(new MethodParameterSpec("items",
ClrCollectionClosure.Array(new ClrClassName("object"))))
)
{
this.InitializedMembers = InitializedMembers;
}
public PropertyConstructorSpec(ClrClassName DeclaringTypeName,
IReadOnlyList <PropertySpec> InitializedMembers, ClrAccessKind?AccessLevel = null)
: base
(
DeclaringTypeName,
AccessLevel,
MethodParameters:
mapi(InitializedMembers, (i, p)
=> new MethodParameterSpec(new ClrMethodParameterName(p.Name.SimpleName), p.PropertyType, i)
).ToArray()
)
{
this.InitializedMembers = InitializedMembers;
}
public ClassSpec
(
ClrClassName Name,
CodeDocumentationSpec Documentation = null,
ClrAccessKind?AccessLevel = null,
IEnumerable <AttributionSpec> Attributions = null,
IEnumerable <TypeParameter> TypeParameters = null,
IEnumerable <ClrTypeClosure> BaseTypes = null,
IEnumerable <ClrInterfaceName> ImplicitRealizations = null,
IClrElementName DeclaringType = null,
bool IsStatic = false,
IEnumerable <IClrMemberSpec> Members = null,
bool IsPartial = false,
bool IsSealed = false,
IEnumerable <IClrTypeSpec> DeclaredTypes = null,
bool IsAbstract = false
)
: base
(
Name,
Documentation,
AccessLevel ?? ClrAccessKind.Public,
Attributions ?? array <AttributionSpec>(),
TypeParameters ?? array <TypeParameter>(),
BaseTypes ?? array <ClrTypeClosure>(),
ImplicitRealizations ?? array <ClrInterfaceName>(),
DeclaringType,
IsStatic,
Members ?? array <IClrMemberSpec>(),
IsPartial: IsPartial
)
{
this.IsSealed = IsSealed;
this.DeclaredTypes = rolist(DeclaredTypes);
this.IsAbstract = IsAbstract;
}
public static AttributionSpec Specify(ClrClassName attribName, params AttributeParameterSpec[] parameters) => new AttributionSpec(attribName, parameters);
public static ClrTypeClosure SpecifyTypeClosure(this ClrClassName typeName, params TypeArgument[] args) => new ClrTypeClosure(typeName, args);
/// <summary>
/// Defines a <see cref="FieldSpec"/>
/// </summary>
/// <typeparam name="T">The field's type</typeparam>
/// <param name="declaringType">The type that declares the field</param>
/// <param name="name">The name of the field</param>
/// <param name="init">The field initializer</param>
/// <returns></returns>
public static FieldSpec SpecifyField <T>(this ClrClassName declaringType, string name, ConstructorInvocationSpec init)
=> new FieldSpec(DeclaringTypeName: declaringType, Name: new ClrFieldName(name),
FieldType: ClrType.Get <T>().GetReference(), AccessLevel: ClrAccessKind.Public,
IsStatic: true, IsReadOnly: true, Initializer: new FieldInitializerSpec(init));
public DefaultConstructorSpec(ClrClassName DeclaringTypeName,
ClrAccessKind?AccessLevel = null)
: base(DeclaringTypeName, AccessLevel)
{
}
