public static string GetName()
{
Namer namer = new Namer();
namer.ShowDialog();
return(namer.GetName());
}
private string ConvertParameter(ParameterInfo info, CodeMemberMethod method)
{
var type = info.ParameterType;
if (type.IsRegMember(RegPairs, out var regPair))
{
CodeFieldReferenceExpression regRef;
if (!TryGetReferenceToFieldOfType(regPair.Registry, out regRef))
{
regRef = AddConstructorInitializedField(regPair.Registry);
}
var param = new CodeParameterDeclarationExpression(regPair.Key, Namer.GetName());
method.Parameters.Add(param);
// Declare localVar
var localVarDeclaration = new CodeVariableDeclarationStatement(regPair.Member, Namer.GetName());
method.Statements.Add(localVarDeclaration);
// Assign to localVar
var localVarAssignment = new CodeAssignStatement(
new CodeVariableReferenceExpression(localVarDeclaration.Name),
new CodeIndexerExpression(regRef, new CodeArgumentReferenceExpression(param.Name)));
method.Statements.Add(localVarAssignment);
return(localVarDeclaration.Name);
}
else
{
Console.WriteLine("ERROR IN PARAMETER CONVERSION");
return(null);
}
}
private CodeFieldReferenceExpression AddDirectlyInitializedField(Type type, string svcString)
{
var field = CodeDomEx.CreatePrivateField(Namer.GetName(), type);
field.InitExpression = new CodeSnippetExpression("SuperMemoAssistant.Services.Svc.SM." + svcString);
Klass.Members.Add(field);
return(CodeDomEx.CreateThisFieldRef(field.Name));
}
private CodeFieldReferenceExpression AddConstructorInitializedField(Type type)
{
// Add parameter arg
var param = CodeDomEx.CreateParam(Namer.GetName(), type);
Constructor.Parameters.Add(param);
// Add field
var field = CodeDomEx.CreatePrivateField(Namer.GetName(), type);
Klass.Members.Add(field);
var fieldRef = CodeDomEx.CreateThisFieldRef(field.Name);
// Assign to field from constructor
var paramRef = new CodeArgumentReferenceExpression(param.Name);
var assignment = new CodeAssignStatement(fieldRef, paramRef);
Constructor.Statements.Add(assignment);
return(CodeDomEx.CreateThisFieldRef(field.Name));
}
private CodeVariableReferenceExpression GetRegistryMemberFromRegistryField(CodeMemberMethod method, RegistryType regPair, CodeFieldReferenceExpression regRef)
{
// Add as the method's first parameter
var param = new CodeParameterDeclarationExpression(regPair.Key, Namer.GetName());
method.Parameters.Add(param);
// Create the local variable to store the reference to the registry member
var thisVarDeclaration = new CodeVariableDeclarationStatement(
regPair.Member,
Namer.GetName());
method.Statements.Add(thisVarDeclaration);
// eg. IElement thisIElement = Svc.SM.Registry.Element[thisId];
CodeAssignStatement thisVarAssignment = new CodeAssignStatement(
new CodeVariableReferenceExpression(thisVarDeclaration.Name),
new CodeIndexerExpression(regRef, new CodeArgumentReferenceExpression(param.Name)));
method.Statements.Add(thisVarAssignment);
return(new CodeVariableReferenceExpression(thisVarDeclaration.Name));
}
private void ConvertReturnedInvoke(CodeMemberMethod method, Type retType, CodeMethodInvokeExpression invoke)
{
if (retType.IsRegMember(RegPairs, out _))
{
var decl = new CodeVariableDeclarationStatement(new CodeTypeReference(retType), Namer.GetName());
var varRef = new CodeVariableReferenceExpression(decl.Name);
var assignment = new CodeAssignStatement(varRef, invoke);
var prop = new CodePropertyReferenceExpression(varRef, "Id");
method.Statements.Add(decl);
method.Statements.Add(assignment);
method.Statements.Add(new CodeMethodReturnStatement(prop));
method.ReturnType = new CodeTypeReference(typeof(int));
}
else if (retType.IsGenericType && retType.GetGenericTypeDefinition() == typeof(IEnumerable <>) && retType.GetGenericArguments()[0].IsRegMember(RegPairs, out _))
{
var decl = new CodeVariableDeclarationStatement(new CodeTypeReference(retType), Namer.GetName());
var varRef = new CodeVariableReferenceExpression(decl.Name);
var assignment = new CodeAssignStatement(varRef, invoke);
method.Statements.Add(decl);
method.Statements.Add(assignment);
method.Statements.Add(new CodeMethodReturnStatement(new CodeSnippetExpression(decl.Name + ".Select(x => x.Id)")));
method.ReturnType = new CodeTypeReference(typeof(IEnumerable <int>));
AddImportIfNotExists("System.Linq");
}
else
{
method.Statements.Add(
new CodeMethodReturnStatement(
invoke
));
}
}
private void ConvertMethod(MethodInfo info)
{
var method = CodeDomEx.CreateMethod(info.Name, info.ReturnType);
method.Comments.Add(new CodeCommentStatement(GetDocsFor(info)));
var targetMethodRef = new CodeMethodReferenceExpression(WrappedRef, info.Name);
var targetMethodArgs = new List <CodeExpression>();
var retType = info.ReturnType;
if (Wrapped.IsRegMember(RegPairs, out var regPair))
{
CodeFieldReferenceExpression regRef;
if (!TryGetReferenceToFieldOfType(regPair.Registry, out regRef))
{
regRef = AddConstructorInitializedField(regPair.Registry);
}
var localInstanceRef = GetRegistryMemberFromRegistryField(method, regPair, regRef);
targetMethodRef = new CodeMethodReferenceExpression(localInstanceRef, info.Name);
}
var parameters = info.GetParameters();
if (parameters != null)
{
foreach (var parameter in parameters)
{
if (parameter.IsOut)
{
var paramType = parameter.ParameterType;
var decl = new CodeVariableDeclarationStatement(new CodeTypeReference(paramType.GetElementType()), Namer.GetName());
method.Statements.Add(decl);
targetMethodArgs.Add(new CodeSnippetExpression("out " + decl.Name));
continue;
}
if (parameter.ParameterType.IsRegMember(RegPairs, out _))
{
string x = ConvertParameter(parameter, method);
targetMethodArgs.Add(new CodeVariableReferenceExpression(x));
}
else
{
string x = KeepParameter(parameter, method);
targetMethodArgs.Add(new CodeArgumentReferenceExpression(x));
}
}
}
var invoke = new CodeMethodInvokeExpression(targetMethodRef, targetMethodArgs.ToArray());
ConvertReturnedInvoke(method, retType, invoke);
Klass.Members.Add(method);
}
private string KeepParameter(ParameterInfo info, CodeMemberMethod method)
{
var param = new CodeParameterDeclarationExpression(new CodeTypeReference(info.ParameterType), Namer.GetName());
method.Parameters.Add(param);
return(param.Name);
}