private static void ProvideClearIndentMethod(CodeTypeMemberCollection members, CodeMemberField currentIndent, CodeMemberProperty indentLengths)
{
CodeMemberMethod codeMemberMethod = CodeDomHelpers.CreateMethod(null, "ClearIndent", "Remove any indentation", (MemberAttributes)24578, indentLengths.Ref().CallS("Clear"), currentIndent.Ref().Assign(string.Empty.Prim()));
codeMemberMethod.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "Transform-time helpers"));
members.Add(codeMemberMethod);
}
private static IEnumerable <CodeTypeMember> SafeToEnumerable(CodeTypeMemberCollection collection)
{
foreach (CodeTypeMember codeTypeMember in collection)
{
yield return(codeTypeMember);
}
}
public static string GenerateCodeFromMembers(CodeTypeMemberCollection collection)
{
var type = new CodeTypeDeclaration("DUMMY");
type.Members.AddRange(collection);
var cp = new CSharpCodeProvider();
var sb = new StringBuilder();
var strWriter = new StringWriter(sb);
var ccu = new CodeCompileUnit();
var ns = new CodeNamespace();
ns.Types.Add(type);
ccu.Namespaces.Add(ns);
cp.GenerateCodeFromCompileUnit(ccu, strWriter, new CodeGeneratorOptions());
var adjusted = new[] { "" }.Concat(
sb.ToString()
.Split(new string[] { Environment.NewLine }, StringSplitOptions.None)
.Skip(14)
.Reverse()
.Skip(2)
.Reverse()).ToArray();
return(string.Join("\r\n", adjusted));
}
public override void apply(CodeTypeDeclaration mock, Type target)
{
CodeTypeMemberCollection mockMethods = mock.Members;
foreach (CodeTypeMember member in mockMethods)
{
if (member is CodeMemberMethod)
{
CodeMemberMethod method = (CodeMemberMethod)member;
CodeStatementCollection statements = method.Statements;
if (statements.Count > 0)
{
CodeStatement lastStatement = statements[statements.Count - 1];
if (lastStatement is CodeMethodReturnStatement)
{
statements.Remove(lastStatement);
}
}
CodeTypeReference typeToThrow = new CodeTypeReference(typeof(System.NotSupportedException));
CodeObjectCreateExpression createExpression = new CodeObjectCreateExpression(typeToThrow, new CodeExpression[] {});
CodeThrowExceptionStatement throwStatement = new CodeThrowExceptionStatement(createExpression);
statements.Add(throwStatement);
}
}
}
private static void ProvideClearIndentMethod(CodeTypeMemberCollection members, CodeMemberField currentIndent, CodeMemberProperty indentLengths)
{
CodeMemberMethod method = CodeDomHelpers.CreateMethod(null, "ClearIndent", "Remove any indentation", MemberAttributes.Public | MemberAttributes.Final, new CodeObject[] { indentLengths.Ref().CallS("Clear", new CodeExpression[0]), currentIndent.Ref().Assign(string.Empty.Prim()) });
method.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "Transform-time helpers"));
members.Add(method);
}
private CodeTypeMemberCollection GeneratePrivateMemberVars(List <XmlNode> fieldList)
{
CodeTypeMemberCollection members = new CodeTypeMemberCollection();
foreach (XmlNode fieldNode in fieldList)
{
try
{
if (fieldNode.Attributes["type"].InnerText == "Custom")
{
continue;
}
if (fieldNode.Attributes["type"].InnerText == "ArrayStart")
{
continue;
}
members.Add(GeneratePrivateMember(fieldNode));
}
catch (Exception ex)
{
throw new Exception(fieldNode.Attributes["type"].InnerText + " - GeneratePrivateMember on " + fieldNode.Attributes["name"].InnerText + " : " + ex.Message);
}
}
return(members);
}
/// <summary>
/// Adds [JsonIgnore] attribute if [XmlIgnore] found
/// </summary>
/// <param name="codedomElement">Class in which JsonIgnore to be added</param>
private void AddJsonIgnore(CodeTypeDeclaration codedomElement)
{
bool xmlIgnoreFound = false;
CodeTypeMemberCollection typeMembers = codedomElement.Members;
// Loop thru each member/property of the class
for (int memberCount = 0; memberCount < typeMembers.Count; memberCount++)
{
CodeMemberProperty typeProperty = typeMembers[memberCount] as CodeMemberProperty;
if (typeProperty != null)
{
foreach (CodeAttributeDeclaration xmlAttribute in typeProperty.CustomAttributes)
{
if (string.Equals(
xmlAttribute.AttributeType.BaseType.ToUpper(CultureInfo.InvariantCulture),
DataObjectConstants.XMLIGNORE.ToUpper(CultureInfo.InvariantCulture)))
{
xmlIgnoreFound = true;
}
} // Loop for each xml attribute
if (xmlIgnoreFound)
{
CodeAttributeDeclaration codeAttrDec = new CodeAttributeDeclaration(new CodeTypeReference("JsonIgnore"));
typeProperty.CustomAttributes.Add(codeAttrDec);
xmlIgnoreFound = false;
}
}
}
}
static CodeTypeMember[] _ToArray(CodeTypeMemberCollection refs)
{
var result = new CodeTypeMember[refs.Count];
refs.CopyTo(result, 0);
return(result);
}
public CodeTypeMemberCollection AddMethods(TableViewTableTypeBase baseobj)
{
CodeTypeMemberCollection ctmc = new CodeTypeMemberCollection();
ctmc.Add(BuildIsDirtyMethod(baseobj));
return(ctmc);
}
private static void ProvideWarningMethod(CodeTypeMemberCollection members, CodeMemberProperty Errors, CodeVariableReferenceExpression error)
{
CodeMemberMethod method = CodeDomHelpers.CreateMethod(null, "Warning", "Raise a warning", MemberAttributes.Public | MemberAttributes.Final, new CodeObject[] { new CodeVariableDeclarationStatement(typeof(CompilerError), "error", typeof(CompilerError).New()), error.Prop("ErrorText").Assign(new CodeVariableReferenceExpression("message")), error.Prop("IsWarning").Assign(true.Prim()), Errors.Ref().CallS("Add", new CodeExpression[] { error }) });
method.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(string)), "message"));
members.Add(method);
}
/// <summary>
/// Generates source code from given attributes.
/// </summary>
public static string GenerateFromAttribute(CodeDomProvider codeProvider, params CodeAttributeDeclaration[] attributes)
{
CodeTypeMemberCollection collection = new CodeTypeMemberCollection();
CodeMemberMethod temp = new CodeMemberMethod();
int start = 0;
if (attributes == null || attributes.Length == 0)
{
return(string.Empty);
}
temp.Name = " ";
temp.ReturnType = new CodeTypeReference(" ");
collection.Add(temp);
foreach (CodeAttributeDeclaration a in attributes)
{
temp.CustomAttributes.Add(a);
}
// get the code from function with attributes:
string code = GenerateFromMember(codeProvider, collection, false);
// and remove the last line with the function declaration:
for (int i = 0; i < attributes.Length; i++)
{
start = code.IndexOfAny(NewLineChars, start);
}
if (start != -1)
{
code = code.Substring(0, start);
}
return(code);
}
public void AddRange()
{
CodeTypeMember tm1 = new CodeTypeMember();
CodeTypeMember tm2 = new CodeTypeMember();
CodeTypeMember tm3 = new CodeTypeMember();
CodeTypeMemberCollection coll1 = new CodeTypeMemberCollection();
coll1.Add(tm1);
coll1.Add(tm2);
CodeTypeMemberCollection coll2 = new CodeTypeMemberCollection();
coll2.Add(tm3);
coll2.AddRange(coll1);
Assert.AreEqual(3, coll2.Count, "#1");
Assert.AreEqual(1, coll2.IndexOf(tm1), "#2");
Assert.AreEqual(2, coll2.IndexOf(tm2), "#3");
Assert.AreEqual(0, coll2.IndexOf(tm3), "#4");
CodeTypeMemberCollection coll3 = new CodeTypeMemberCollection();
coll3.Add(tm3);
coll3.AddRange(new CodeTypeMember[] { tm1, tm2 });
Assert.AreEqual(3, coll2.Count, "#5");
Assert.AreEqual(1, coll2.IndexOf(tm1), "#6");
Assert.AreEqual(2, coll2.IndexOf(tm2), "#7");
Assert.AreEqual(0, coll2.IndexOf(tm3), "#8");
}
/// <summary>
/// Replaces Item and Items property names to AnyIntuitObject and AnyIntuitObjects
/// </summary>
/// <param name="codedomElement">Class that has Item or Items property</param>
private void ReplaceItem(CodeTypeDeclaration codedomElement)
{
CodeTypeMemberCollection typeMembers = codedomElement.Members;
// Loop thru each member/property of the class
for (int memberCount = 0; memberCount < typeMembers.Count; memberCount++)
{
CodeMemberProperty typeProperty = typeMembers[memberCount] as CodeMemberProperty;
if (typeProperty != null)
{
if (string.Equals(
typeProperty.Name.ToUpper(CultureInfo.InvariantCulture),
DataObjectConstants.ITEM.ToUpper(CultureInfo.InvariantCulture)))
{
typeProperty.Name = DataObjectConstants.ANYINTUITOBJECT;
}
else if (string.Equals(
typeProperty.Name.ToUpper(CultureInfo.InvariantCulture),
DataObjectConstants.ITEMS.ToUpper(CultureInfo.InvariantCulture)))
{
typeProperty.Name = DataObjectConstants.ANYINTUITOBJECTS;
}
}
}
}
/// <summary>
/// Run all of the marshaling hueristiscs on the type and it's members
/// </summary>
/// <param name="ctd"></param>
/// <remarks></remarks>
public void Process(CodeTypeDeclaration ctd)
{
// First check and see if it is a delegate type, if so run the delegate hueristics
CodeTypeDelegate ctdDel = ctd as CodeTypeDelegate;
if (ctdDel != null && ctdDel.UserData.Contains(TransformConstants.DefinedType))
{
ProcessDelegate(ctdDel);
return;
}
// Now run the hueristics over the actual members of the type
if (ctd.UserData.Contains(TransformConstants.DefinedType))
{
NativeDefinedType nt = ctd.UserData[TransformConstants.DefinedType] as NativeDefinedType;
if (nt != null)
{
switch (nt.Kind)
{
case NativeSymbolKind.StructType:
ProcessStruct(ctd);
break;
case NativeSymbolKind.UnionType:
RunPluginUnionMembers(ctd);
break;
case NativeSymbolKind.EnumType:
RunPluginEnumMembers(ctd);
break;
}
}
}
// Now process the methods on the type. First step is to convert all of them into
// best PInvoke signature. Then create wrapper methods for them
CodeTypeMemberCollection col = new CodeTypeMemberCollection(ctd.Members);
List <CodeMemberMethod> list = new List <CodeMemberMethod>();
foreach (CodeTypeMember mem in col)
{
// Look at procedures
CodeMemberMethod codeProc = mem as CodeMemberMethod;
if (codeProc != null && codeProc.UserData.Contains(TransformConstants.Procedure))
{
list.Add(codeProc);
}
}
foreach (CodeMemberMethod codeProc in list)
{
ProcessParameters(codeProc);
ProcessReturnType(codeProc);
}
foreach (CodeMemberMethod codeProc in list)
{
ProcessWrapperMethods(ctd, codeProc);
}
}
/// <summary>
/// Iterates a CodeTypeMemberCollection and returns an array of indexes
/// to members that are marked with the IsAttribute custom attribute.
/// </summary>
/// <param name="typeMembers">A CodeTypeMemberCollection containing contract members.</param>
/// <returns>A integer array containing the indexes of attribute type members.</returns>
/// <remarks>
/// Special provisiong are made to handle AnyAttribute. If an AnyAttr data member is found,
/// the index will be moved to the end of the attribute list. This way attribute processing
/// can occur before an the next data member element is read.
/// </remarks>
internal static int[] GetListOfAttributes(CodeTypeMemberCollection typeMembers)
{
int[] tempList = new int[typeMembers.Count];
int index = 0;
int anyAttribIndex = -1;
// Add attribute members
for (int i = 0; i < typeMembers.Count; ++i)
{
if (GetCustomAttributeArgumentValue("IsAttribute", typeMembers[i].CustomAttributes) != null)
{
tempList[index++] = i;
}
else if (typeMembers[i].Name == "AnyAttr")
{
anyAttribIndex = i;
}
}
int[] sortOrder;
if (anyAttribIndex == -1)
{
sortOrder = new int[index];
Array.Copy(tempList, sortOrder, index);
}
else
{
sortOrder = new int[index + 1];
Array.Copy(tempList, sortOrder, index);
sortOrder[index] = anyAttribIndex;
}
return(sortOrder);
}
private static void ProvideWriteLineMethod1(CodeTypeMemberCollection members, CodeMemberField endsWithNewline, CodeMemberProperty GenerationEnvironment, CodeVariableReferenceExpression textToAppend)
{
CodeMemberMethod codeMemberMethod = CodeDomHelpers.CreateMethod(null, "WriteLine", "Write text directly into the generated output", (MemberAttributes)24578, CodeDomHelpers.Call("Write", textToAppend), GenerationEnvironment.Ref().CallS("AppendLine"), endsWithNewline.Ref().Assign(true.Prim()));
codeMemberMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(string)), textToAppend.VariableName));
members.Add(codeMemberMethod);
}
private void BuildMethod(CodeTypeMemberCollection members, MethodInfo method, object[] parameters)
{
CodeMemberMethod method2 = new CodeMemberMethod();
method2.Name = "Invoke" + method.Name;
this.mainMethod.Statements.Add(new CodeMethodInvokeExpression(null, method2.Name, new CodeExpression[0]));
method2.Attributes = MemberAttributes.Public | MemberAttributes.Static;
members.Add(method2);
CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression(this.BuildProxy(method2.Statements, method), method.Name, new CodeExpression[0]);
this.BuildParameters(method2.Statements, method, parameters, expression.Parameters);
if (method.ReturnType == typeof(void))
{
method2.Statements.Add(new CodeExpressionStatement(expression));
}
else
{
string uniqueVariableName = GetUniqueVariableName(method.Name + "Result", method2.Statements);
method2.Statements.Add(new CodeVariableDeclarationStatement(method.ReturnType.FullName, uniqueVariableName, expression));
this.BuildDumpInvoke(method2.Statements, "result", new CodeVariableReferenceExpression(uniqueVariableName));
}
ParameterInfo[] infoArray = method.GetParameters();
for (int i = 0; i < infoArray.Length; i++)
{
ParameterInfo info = infoArray[i];
if (info.IsOut || info.ParameterType.IsByRef)
{
this.BuildDumpInvoke(method2.Statements, info.Name, ((CodeDirectionExpression)expression.Parameters[i]).Expression);
}
}
}
private static void ProvideErrorMethod(CodeTypeMemberCollection members, CodeMemberProperty Errors, CodeVariableReferenceExpression error)
{
CodeMemberMethod codeMemberMethod = CodeDomHelpers.CreateMethod(null, "Error", "Raise an error", (MemberAttributes)24578, new CodeVariableDeclarationStatement(typeof(CompilerError), "error", typeof(CompilerError).New()), error.Prop("ErrorText").Assign(new CodeVariableReferenceExpression("message")), Errors.Ref().CallS("Add", error));
codeMemberMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(string)), "message"));
members.Add(codeMemberMethod);
}
public virtual CodeTypeDeclaration GenerateTypeDeclaration(string targetNamespace, string name, params string[] parents)
{
CodeTypeDeclaration type =
CreateTypeDeclaration.Called(name)
.AsPartial
.WithAttributes(TypeAttributes.Public)
.WithCustomAttributes(CodeGeneratorAttribute)
.Type;
CodeNamespace ns = LookupNamespace(targetNamespace);
if (parents.Length == 0)
{
ns.Types.Add(type);
}
else
{
CodeTypeMemberCollection members = GetMemberCollectionForTypeDeclaration(ns.Types, parents[0]);
for (int i = 1; i < parents.Length; i++)
{
members = GetMemberCollectionForTypeMember(members, parents[i]);
}
members.Add(type);
}
return(type);
}
public void GenerateRequestClassesTest()
{
var decorator = new CountingRequestDecorator();
var generator = new RequestClassGenerator(new IRequestDecorator[] { decorator });
var decl = new CodeTypeDeclaration();
// Create a test resource.
var resource = new MockResource();
resource.Methods.Add("MethodA", new MockMethod()
{
Name = "MethodA"
});
resource.Methods.Add("MethodB", new MockMethod()
{
Name = "MethodB"
});
// Run the generator
CodeTypeMemberCollection collection = generator.GenerateRequestClasses(decl, resource);
Assert.AreEqual(2, decorator.TimesCalled);
Assert.AreEqual(2, collection.Count);
Assert.IsInstanceOf <CodeTypeDeclaration>(collection[0]);
Assert.IsInstanceOf <CodeTypeDeclaration>(collection[1]);
CollectionAssert.AreEqual(
new[]
{
string.Format(RequestClassGenerator.RequestClassNamingScheme, "MethodA"),
string.Format(RequestClassGenerator.RequestClassNamingScheme, "MethodB"),
},
from CodeTypeMember m in collection select m.Name);
}
private void BuildMethod(CodeTypeMemberCollection members, MethodInfo method, object[] parameters)
{
CodeMemberMethod method1 = new CodeMemberMethod();
method1.Name = "Invoke" + method.Name;
mainMethod.Statements.Add(new CodeMethodInvokeExpression(null, method1.Name, new CodeExpression[0]));
method1.Attributes = MemberAttributes.Public | MemberAttributes.Static;
members.Add(method1);
CodeExpression expression1 = BuildProxy(method1.Statements, method);
CodeMethodInvokeExpression expression2 =
new CodeMethodInvokeExpression(expression1, method.Name, new CodeExpression[0]);
BuildParameters(method1.Statements, method, parameters, expression2.Parameters);
if (method.ReturnType == typeof(void))
{
method1.Statements.Add(new CodeExpressionStatement(expression2));
}
else
{
string text1 = GetUniqueVariableName(method.Name + "Result", method1.Statements);
method1.Statements.Add(
new CodeVariableDeclarationStatement(method.ReturnType.FullName, text1, expression2));
BuildDumpInvoke(method1.Statements, "result", new CodeVariableReferenceExpression(text1));
}
ParameterInfo[] infoArray1 = method.GetParameters();
for (int num1 = 0; num1 < infoArray1.Length; num1++)
{
ParameterInfo info1 = infoArray1[num1];
if (info1.IsOut || info1.ParameterType.IsByRef)
{
BuildDumpInvoke(method1.Statements, info1.Name,
((CodeDirectionExpression)expression2.Parameters[num1]).Expression);
}
}
}
static CodeTypeMemberCollection GetWMIMembers(CodeTypeDeclaration type)
{
CodeTypeMemberCollection members = new CodeTypeMemberCollection();
AppendWMIMembers(type, members);
return(members);
}
private static void ProvidePopIndentMethod(CodeTypeMemberCollection members, CodeMemberField currentIndent, CodeMemberProperty indentLengths)
{
CodeVariableReferenceExpression lhs = new CodeVariableReferenceExpression("indentLength");
CodeVariableReferenceExpression expression2 = new CodeVariableReferenceExpression("returnValue");
CodeMemberMethod method = CodeDomHelpers.CreateMethod(typeof(string), "PopIndent", "Remove the last indent that was added with PushIndent", MemberAttributes.Public | MemberAttributes.Final, new CodeObject[] { new CodeVariableDeclarationStatement(typeof(string), expression2.VariableName, string.Empty.Prim()), new CodeConditionStatement(indentLengths.Ref().Prop("Count").Gt(0.Prim()), new CodeStatement[] { new CodeVariableDeclarationStatement(typeof(int), lhs.VariableName, indentLengths.Ref().Index(new CodeExpression[] { indentLengths.Ref().Prop("Count").Subtract(1.Prim()) })), indentLengths.Ref().CallS("RemoveAt", new CodeExpression[] { indentLengths.Ref().Prop("Count").Subtract(1.Prim()) }), new CodeConditionStatement(lhs.Gt(0.Prim()), new CodeStatement[] { expression2.Assign(currentIndent.Ref().Call("Substring", new CodeExpression[] { currentIndent.Ref().Prop("Length").Subtract(lhs) })), currentIndent.Ref().Assign(currentIndent.Ref().Call("Remove", new CodeExpression[] { currentIndent.Ref().Prop("Length").Subtract(lhs) })) }) }), new CodeMethodReturnStatement(expression2) });
members.Add(method);
}
private static void ProvideWriteLineMethod2(CodeTypeMemberCollection members, CodeParameterDeclarationExpression argsParam)
{
CodeMemberMethod codeMemberMethod = CodeDomHelpers.CreateMethod(null, "WriteLine", "Write formatted text directly into the generated output", (MemberAttributes)24578, CodeDomHelpers.Call("WriteLine", CodeDomHelpers.Call(typeof(string), "Format", typeof(CultureInfo).Expr().Prop("CurrentCulture"), new CodeVariableReferenceExpression("format"), new CodeVariableReferenceExpression("args"))));
codeMemberMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(string)), "format"));
codeMemberMethod.Parameters.Add(argsParam);
members.Add(codeMemberMethod);
}
private static void ProvidePushIndentMethod(CodeTypeMemberCollection members, CodeMemberField currentIndent, CodeMemberProperty indentLengths)
{
CodeVariableReferenceExpression codeVariableReferenceExpression = new CodeVariableReferenceExpression("indent");
CodeMemberMethod codeMemberMethod = CodeDomHelpers.CreateMethod(null, "PushIndent", "Increase the indent", (MemberAttributes)24578, new CodeConditionStatement(codeVariableReferenceExpression.VEquals(CodeDomHelpers.nullEx), new CodeThrowExceptionStatement(typeof(ArgumentNullException).New("indent".Prim()))), currentIndent.Ref().Assign(currentIndent.Ref().Add(codeVariableReferenceExpression)), indentLengths.Ref().CallS("Add", codeVariableReferenceExpression.Prop("Length")));
codeMemberMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(string)), "indent"));
members.Add(codeMemberMethod);
}
private static void ProvidePushIndentMethod(CodeTypeMemberCollection members, CodeMemberField currentIndent, CodeMemberProperty indentLengths)
{
CodeVariableReferenceExpression lhs = new CodeVariableReferenceExpression("indent");
CodeMemberMethod method = CodeDomHelpers.CreateMethod(null, "PushIndent", "Increase the indent", MemberAttributes.Public | MemberAttributes.Final, new CodeObject[] { new CodeConditionStatement(lhs.VEquals(CodeDomHelpers.nullEx), new CodeStatement[] { new CodeThrowExceptionStatement(typeof(ArgumentNullException).New(new CodeExpression[] { "indent".Prim() })) }), currentIndent.Ref().Assign(currentIndent.Ref().Add(lhs)), indentLengths.Ref().CallS("Add", new CodeExpression[] { lhs.Prop("Length") }) });
method.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(string)), "indent"));
members.Add(method);
}
private void AddRegionMarkers(CodeTypeMemberCollection members, string description)
{
if (members.Count > 0)
{
members[0].StartDirectives.Insert(0, new CodeRegionDirective(CodeRegionMode.Start, description));
members[members.Count - 1].EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, null));
}
}
private static string GenerateSourceCodeOutput(string codeClassName, IList <CodeNamedElement> codeElements, CodeModelLanguages language)
{
CodeTypeMemberCollection code = new CodeTypeMemberCollection();
CodeTypeMember initConstructor = VariableHelper.GetInitConstructor(codeClassName, codeElements, language);
code.Add(initConstructor);
return(Environment.NewLine + CodeHelper.GenerateFromMember(language, code));
}
// private SendOrPostCallback xxxOperationCompleted;
internal static void AddCallbackDeclaration(CodeTypeMemberCollection members, string callbackMember)
{
CodeMemberField callback = new CodeMemberField();
callback.Type = new CodeTypeReference(typeof(SendOrPostCallback));
callback.Name = callbackMember;
members.Add(callback);
}
private static void ProvidePopIndentMethod(CodeTypeMemberCollection members, CodeMemberField currentIndent, CodeMemberProperty indentLengths)
{
CodeVariableReferenceExpression codeVariableReferenceExpression = new CodeVariableReferenceExpression("indentLength");
CodeVariableReferenceExpression codeVariableReferenceExpression2 = new CodeVariableReferenceExpression("returnValue");
CodeMemberMethod value = CodeDomHelpers.CreateMethod(typeof(string), "PopIndent", "Remove the last indent that was added with PushIndent", (MemberAttributes)24578, new CodeVariableDeclarationStatement(typeof(string), codeVariableReferenceExpression2.VariableName, string.Empty.Prim()), new CodeConditionStatement(indentLengths.Ref().Prop("Count").Gt(0.Prim()), new CodeVariableDeclarationStatement(typeof(int), codeVariableReferenceExpression.VariableName, indentLengths.Ref().Index(indentLengths.Ref().Prop("Count").Subtract(1.Prim()))), indentLengths.Ref().CallS("RemoveAt", indentLengths.Ref().Prop("Count").Subtract(1.Prim())), new CodeConditionStatement(codeVariableReferenceExpression.Gt(0.Prim()), codeVariableReferenceExpression2.Assign(currentIndent.Ref().Call("Substring", currentIndent.Ref().Prop("Length").Subtract(codeVariableReferenceExpression))), currentIndent.Ref().Assign(currentIndent.Ref().Call("Remove", currentIndent.Ref().Prop("Length").Subtract(codeVariableReferenceExpression))))), new CodeMethodReturnStatement(codeVariableReferenceExpression2));
members.Add(value);
}
public void AddRange(CodeTypeMemberCollection value) {}
public void PostMembersHook(Smoke* smoke, Smoke.Class* klass, CodeTypeDeclaration type)
{
if (Util.IsQObject(klass))
{
CodeMemberProperty emit = new CodeMemberProperty();
emit.Name = "Emit";
emit.Attributes = MemberAttributes.Family | MemberAttributes.New | MemberAttributes.Final;
emit.HasGet = true;
emit.HasSet = false;
string signalsIfaceName = "I" + type.Name + "Signals";
CodeTypeReference returnType = new CodeTypeReference(signalsIfaceName);
emit.Type = returnType;
emit.GetStatements.Add(new CodeMethodReturnStatement(new CodeCastExpression(
returnType,
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "Q_EMIT")
)));
type.Members.Add(emit);
string className = ByteArrayManager.GetString(klass->className);
int colon = className.LastIndexOf("::", StringComparison.Ordinal);
string prefix = (colon != -1) ? className.Substring(0, colon) : string.Empty;
IList typeCollection = this.Data.GetTypeCollection(prefix);
CodeTypeDeclaration ifaceDecl = new CodeTypeDeclaration(signalsIfaceName);
ifaceDecl.IsInterface = true;
if (className != "QObject")
{
string parentClassName = ByteArrayManager.GetString(smoke->classes[smoke->inheritanceList[klass->parents]].className);
colon = parentClassName.LastIndexOf("::", StringComparison.Ordinal);
prefix = (colon != -1) ? parentClassName.Substring(0, colon) : string.Empty;
if (colon != -1)
{
parentClassName = parentClassName.Substring(colon + 2);
}
string parentInterface = (prefix != string.Empty) ? prefix.Replace("::", ".") + "." : string.Empty;
parentInterface += "I" + parentClassName + "Signals";
ifaceDecl.BaseTypes.Add(new CodeTypeReference(parentInterface));
}
Dictionary<CodeSnippetTypeMember, CodeMemberMethod> signalEvents = new Dictionary<CodeSnippetTypeMember, CodeMemberMethod>();
IEnumerable<CodeMemberMethod> methods = type.Members.OfType<CodeMemberMethod>().ToList();
GetSignals(smoke, klass, delegate(string signature, string name, string typeName, IntPtr metaMethod)
{
CodeMemberMethod signal = new CodeMemberMethod();
signal.Attributes = MemberAttributes.Abstract;
// capitalize the first letter
StringBuilder builder = new StringBuilder(name);
builder[0] = char.ToUpper(builder[0]);
string signalName = builder.ToString();
if (type.Members.OfType<CodeTypeDeclaration>().Any(t => t.Name == signalName))
{
builder[0] = name[0];
}
signal.Name = builder.ToString();
bool isRef;
try
{
if (typeName == string.Empty)
signal.ReturnType = new CodeTypeReference(typeof(void));
else
signal.ReturnType = this.Translator.CppToCSharp(typeName, type, out isRef);
}
catch (NotSupportedException)
{
Debug.Print(" |--Won't wrap signal {0}::{1}", className, signature);
return;
}
CodeAttributeDeclaration attr = new CodeAttributeDeclaration("Q_SIGNAL",
new CodeAttributeArgument(new CodePrimitiveExpression(signature)));
signal.CustomAttributes.Add(attr);
int argNum = 1;
StringBuilder fullNameBuilder = new StringBuilder("Slot");
GetMetaMethodParameters(metaMethod, delegate(string paramType, string paramName)
{
if (paramName == string.Empty)
{
paramName = "arg" + argNum.ToString();
}
argNum++;
CodeParameterDeclarationExpression param;
try
{
short id = smoke->IDType(paramType);
CodeTypeReference paramTypeRef;
if (id > 0)
{
paramTypeRef = this.Translator.CppToCSharp(smoke->types + id, type, out isRef);
}
else
{
if (!paramType.Contains("::"))
{
id = smoke->IDType(className + "::" + paramType);
if (id > 0)
{
paramTypeRef = this.Translator.CppToCSharp(smoke->types + id, type, out isRef);
}
else
{
paramTypeRef = this.Translator.CppToCSharp(paramType, type, out isRef);
}
}
else
{
paramTypeRef = this.Translator.CppToCSharp(paramType, type, out isRef);
}
}
param = new CodeParameterDeclarationExpression(paramTypeRef, paramName);
}
catch (NotSupportedException)
{
Debug.Print(" |--Won't wrap signal {0}::{1}", className, signature);
return;
}
if (isRef)
{
param.Direction = FieldDirection.Ref;
}
signal.Parameters.Add(param);
if (argNum == 2)
{
fullNameBuilder.Append('<');
}
fullNameBuilder.Append(param.Type.BaseType);
fullNameBuilder.Append(',');
});
if (fullNameBuilder[fullNameBuilder.Length - 1] == ',')
{
fullNameBuilder[fullNameBuilder.Length - 1] = '>';
}
ifaceDecl.Members.Add(signal);
CodeSnippetTypeMember signalEvent = new CodeSnippetTypeMember();
signalEvent.Name = signal.Name;
DocumentSignalEvent(type, signal, methods, signalEvent, signature);
foreach (CodeMemberMethod method in from method in methods
where method.Name == signal.Name && method.ReturnType.BaseType == signal.ReturnType.BaseType
select method)
{
method.Name = "On" + method.Name;
}
CodeSnippetTypeMember existing = signalEvents.Keys.FirstOrDefault(m => m.Name == signal.Name);
if (existing != null)
{
CodeSnippetTypeMember signalEventToUse;
CodeMemberMethod signalToUse;
if (signal.Parameters.Count == 0)
{
signalEventToUse = existing;
signalToUse = signalEvents[existing];
}
else
{
signalEventToUse = signalEvent;
signalToUse = signal;
}
string suffix = GetSignalEventSuffix(signalToUse);
signalEventToUse.Text = signalEventToUse.Text.Replace(signalEventToUse.Name, signalEventToUse.Name += suffix);
}
else
{
if (signal.Parameters.Count > 0 && methods.Any(m => m.Name == signal.Name))
{
signalEvent.Name += GetSignalEventSuffix(signal);
}
}
signalEvent.Text += string.Format(@"
public event {0} {1}
{{
add
{{
QObject.Connect(this, Qt.SIGNAL(""{2}""), (QObject) value.Target, Qt.SLOT(value.Method.Name + ""{3}""));
}}
remove
{{
QObject.Disconnect(this, Qt.SIGNAL(""{2}""), (QObject) value.Target, Qt.SLOT(value.Method.Name + ""{3}""));
}}
}}", fullNameBuilder, signalEvent.Name, signature, signature.Substring(signature.IndexOf('(')));
signalEvents.Add(signalEvent, signal);
});
typeCollection.Add(ifaceDecl);
CodeTypeMemberCollection members = new CodeTypeMemberCollection();
foreach (KeyValuePair<CodeSnippetTypeMember, CodeMemberMethod> signalEvent in signalEvents)
{
members.Add(signalEvent.Key);
}
int index = 0;
CodeSnippetTypeMember lastEvent = type.Members.OfType<CodeSnippetTypeMember>().LastOrDefault(s => s.Text.Contains("EventHandler<QEventArgs<"));
if (lastEvent != null)
{
index = type.Members.IndexOf(lastEvent) + 1;
}
for (int i = members.Count - 1; i >= 0; i--)
{
type.Members.Insert(index, members[i]);
}
}
}
public CodeTypeMemberCollection(CodeTypeMemberCollection value) {}
