void AddCreatorDocs(CodeTypeDeclaration type, CodeMemberMethod method, int w, int n)
{
var tp = Types.GetTypeParameter(n, w);
var idx = XmlDocs.GetIndex(tp);
var fold = type.GetMethods("Fold").First();
method.Comments.AddDocs(
XmlDocs.Param("value",
" A <typeparamref name=\"" + tp + "\" /> containing the value",
" to provide to the " + idx,
" " + XmlDocs.See(DefaultNamespace, type, fold),
" delegate."
),
XmlDocs.Summary(
" Creates a " + XmlDocs.See(DefaultNamespace, type) + " instance which",
" holds a <typeparamref name=\"" + tp + "\" /> value."
),
XmlDocs.Returns(
" A " + XmlDocs.See(DefaultNamespace, type) + " instance which holds a ",
" holds a <typeparamref name=\"" + tp + "\" /> value."
),
XmlDocs.Remarks(
" <para>",
" When",
" " + XmlDocs.See(DefaultNamespace, type, fold),
" is invoked,",
" the returned " + XmlDocs.See(DefaultNamespace, type) + " instance",
" will invoke the " + idx + " delegate",
" for conversions.",
" </para>"
),
XmlDocs.ArgumentNullException("value")
);
}
CodeTypeDeclaration CreateTupleType(int n)
{
var tuple = new CodeTypeDeclaration("Tuple")
{
TypeAttributes = TypeAttributes.Public,
IsPartial = true,
};
AddConditionalCompilationDirective(tuple, "!NET_4_0");
for (int i = 0; i < n; ++i)
{
tuple.TypeParameters.Add(Types.GetTypeParameter(n, i));
tuple.Members.Add(new CodeMemberField(Types.GetTypeParameter(n, i), Tuple.item(n, i)));
var p = new CodeMemberProperty()
{
Attributes = MemberAttributes.Public | MemberAttributes.Final,
Name = Tuple.Item(n, i),
HasGet = true,
HasSet = false,
Type = new CodeTypeReference(Types.GetTypeParameter(n, i)),
};
p.GetStatements.Add(
new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), Tuple.item(n, i))));
p.Comments.AddDocs(
XmlDocs.Summary(string.Format("The {0} tuple value.", XmlDocs.GetIndex(i))),
XmlDocs.Value("A <typeparamref name=\"" + Types.GetTypeParameter(n, i) + "\" /> which is the " +
XmlDocs.GetIndex(i) + " tuple value."),
XmlDocs.Remarks(string.Format("The {0} tuple value.", XmlDocs.GetIndex(i))));
tuple.Members.Add(p);
}
var c = new CodeConstructor()
{
Attributes = MemberAttributes.Public,
};
for (int i = 0; i < n; ++i)
{
c.Parameters.Add(new CodeParameterDeclarationExpression(Types.GetTypeParameter(n, i), Tuple.item(n, i)));
c.Statements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), Tuple.item(n, i)),
new CodeVariableReferenceExpression(Tuple.item(n, i))));
}
tuple.Members.Add(c);
c.Comments.AddDocs(
XmlDocs.Summary("Constructs and initializes a new " + XmlDocs.See(DefaultNamespace, tuple) + " instance."),
Enumerable.Range(0, n).Select(p => XmlDocs.Param(Tuple.item(n, p),
"A <typeparamref name=\"" + Types.GetTypeParameter(n, p) + "\"/> which is used to initialize the " +
XmlDocs.See(DefaultNamespace, tuple, tuple.Members.OfType <CodeMemberProperty>().First(v => v.Name == Tuple.Item(n, p))) +
" property.")),
XmlDocs.Remarks(
"<para>",
" Constructs and initializes a new " + XmlDocs.See(DefaultNamespace, tuple) + " instance.",
"</para>"));
tuple.Members.Add(CreateTupleEqualsMethod(n, tuple));
tuple.Members.Add(CreateTupleGetHashCodeMethod(n));
tuple.Members.Add(CreateTupleToStringMethod(n, tuple));
tuple.Comments.AddDocs(
XmlDocs.TypeParams(tuple.TypeParameters),
XmlDocs.Summary("A strongly-typed sequence of " + n + " variously typed values."),
XmlDocs.Remarks(
"<para>",
" A <c>Tuple</c> is an immutable, strongly typed sequence of variously",
" typed values with each value lacking an otherwise meaningful name aside",
" from its position.",
"</para>"));
return(tuple);
}
CodeMemberMethod CreateCreateMethod(int n)
{
var retType = new CodeTypeReference("Cadenza.Tuple", Types.GetTypeParameterReferences(n, false).ToArray());
var m = new CodeMemberMethod()
{
Attributes = MemberAttributes.Public | MemberAttributes.Static,
Name = "Create",
ReturnType = retType,
};
for (int i = 0; i < n; ++i)
{
m.TypeParameters.Add(Types.GetTypeParameter(n, i));
}
for (int i = 0; i < n; ++i)
{
m.Parameters.Add(
new CodeParameterDeclarationExpression(
new CodeTypeReference(Types.GetTypeParameter(n, i)), Tuple.item(n, i)));
}
m.Statements.Add(
new CodeMethodReturnStatement(
new CodeObjectCreateExpression(
new CodeTypeReference("Cadenza.Tuple", Types.GetTypeParameterReferences(n, false).ToArray()),
Enumerable.Range(0, n).Select(p => new CodeVariableReferenceExpression(Tuple.item(n, p))).ToArray())));
var tcref = "Cadenza.Tuple{" + Types.GetTypeParameterList(n) + "}";
m.Comments.AddDocs(
Enumerable.Range(0, n).Select(p => XmlDocs.TypeParam(Types.GetTypeParameter(n, p),
string.Format("The {0} <see cref=\"T:{1}\" /> value type.", XmlDocs.GetIndex(p), tcref))),
XmlDocs.Summary("Creates a <see cref=\"" + tcref + "\" />."),
Enumerable.Range(0, n).Select(p => XmlDocs.Param(Tuple.item(n, p),
string.Format("The {0} <see cref=\"T:{1}\" /> value.", XmlDocs.GetIndex(p), tcref))),
XmlDocs.Returns(
"A <see cref=\"T:" + tcref + "\" /> initialized with the parameter values."),
"<seealso cref=\"C:" + tcref + "(" +
string.Join(",", Enumerable.Range(0, n)
.Select(p => "`" + p.ToString()).ToArray()) + ")\" />");
return(m);
}
static IEnumerable GetTimingsParameters(int n)
{
return(Enumerable.Range(0, n).Select(p =>
XmlDocs.Param(Value(n, p), "The " + XmlDocs.GetIndex(Value(n, p)) + " <paramref name=\"self\"/> parameter value.")));
}
