public static void GetCreateUnionValueExpression(object value, UnionSimpleTypeInfo unionDef, CodeExpressionCollection collection) { Debug.Assert(unionDef != null); //Use reflection to get real value and type from "value", which is an XsdSimpleValue object typedValue = value.GetType().InvokeMember("TypedValue", BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance, null, value, null, CultureInfo.InvariantCulture); CodeExpressionCollection dummy = new CodeExpressionCollection(); ClrSimpleTypeInfo matchingType = null; foreach (ClrSimpleTypeInfo type in unionDef.MemberTypes) { try { GetCreateValueExpression(typedValue, type, dummy); matchingType = type; break; } catch (Exception) { continue; } } Debug.Assert(matchingType != null); GetCreateValueExpression(typedValue, matchingType, collection); }
internal static CodeObjectCreateExpression CreateSetCreateExpression(Set <int> set) { string[] strArrays = new string[] { "System.Int32" }; CodeObjectCreateExpression createSet = new CodeObjectCreateExpression(CodeDomHelper.CreateGenericTypeReference("Set", strArrays), new CodeExpression[0]); CodeExpressionCollection parameters = createSet.Parameters; if (set.Count == 1) { foreach (int num in set) { parameters.Add(new CodePrimitiveExpression((object)num)); } } else if (set.Count > 1) { CodeArrayCreateExpression array = new CodeArrayCreateExpression() { CreateType = CodeDomHelper.CreateTypeReference("System.Int32") }; CodeExpressionCollection initializers = array.Initializers; foreach (int i in set) { initializers.Add(new CodePrimitiveExpression((object)i)); } parameters.Add(array); } return(createSet); }
protected virtual void OutputExpressionList (CodeExpressionCollection expressions, bool newlineBetweenItems) { writer.Indent += 1; bool first = true; foreach (CodeExpression expr in expressions) { if (!first) { if (newlineBetweenItems) { ContinueOnNewLine(","); } else { Output.Write(", "); } } else { first = false; } ((ICodeGenerator)this).GenerateCodeFromExpression (expr, writer.InnerWriter, Options); } writer.Indent -= 1; }
private void OutputExpressionList(CodeExpressionCollection expressions, bool newlineBetweenItems = false) { bool first = true; IEnumerator en = expressions.GetEnumerator(); Indent++; while (en.MoveNext()) { if (!first) { if (newlineBetweenItems) { ContinueOnNewLine(","); } else { output.Write(", "); } } else { first = false; } ((ICodeGenerator)this).GenerateCodeFromExpression((CodeExpression)en.Current, output.InnerWriter, options); } Indent--; }
internal void AddDeclaredParameters(CodeTypeDeclaration classDeclaration, IMethod method, CodeMemberMethod member, CodeExpressionCollection constructorParameters, bool addOptionalParameters) { if (method.Parameters == null) { return; } // Add all parameters to the method. foreach (var param in method.GetAllParametersSorted()) { if (!addOptionalParameters && !param.IsRequired) { continue; } // Generate a safe parameter name which was not yet used. // Also exclude method name as VB can not have parameterName the same as method name. string parameterName = GeneratorUtils.GetParameterName( param, method.Parameters.Keys.Without(param.Name).Concat(method.Name)); // Declare the parameter, and add it to the list of constructor parameters of the request class. member.Parameters.Add(DeclareInputParameter(classDeclaration, param, method)); constructorParameters.Add(new CodeVariableReferenceExpression(parameterName)); AddParameterComment(commentCreator, member, param, parameterName); } }
internal static CodeObjectCreateExpression CreateSetCreateExpression(Set <int> set) { CodeObjectCreateExpression createSet = new CodeObjectCreateExpression( CodeDomHelper.CreateGenericTypeReference("Set", new string[] { Constants.Int })); CodeExpressionCollection parameters = createSet.Parameters; if (set.Count == 1) { foreach (int i in set) { parameters.Add(new CodePrimitiveExpression(i)); } } else if (set.Count > 1) { CodeArrayCreateExpression array = new CodeArrayCreateExpression(); array.CreateType = CodeDomHelper.CreateTypeReference(Constants.Int); CodeExpressionCollection initializers = array.Initializers; foreach (int i in set) { initializers.Add(new CodePrimitiveExpression(i)); } parameters.Add(array); } return(createSet); }
static CodeExpression[] _ToArray(CodeExpressionCollection exprs) { var result = new CodeExpression[exprs.Count]; exprs.CopyTo(result, 0); return(result); }
protected virtual void OutputExpressionList(CodeExpressionCollection expressions, bool newLineBetweenItems) { ++Indent; IEnumerator enumerator = expressions.GetEnumerator(); if (enumerator.MoveNext()) { CodeExpression expression = (CodeExpression)enumerator.Current; GenerateExpression(expression); while (enumerator.MoveNext()) { expression = (CodeExpression)enumerator.Current; output.Write(','); if (newLineBetweenItems) { output.WriteLine(); } else { output.Write(' '); } GenerateExpression(expression); } } --Indent; }
protected virtual void OutputExpressionList(CodeExpressionCollection expressions, bool newlineBetweenItems) { bool first = true; Indent++; foreach (CodeExpression current in expressions) { if (first) { first = false; } else { if (newlineBetweenItems) { ContinueOnNewLine(","); } else { Output.Write(", "); } } ((ICodeGenerator)this).GenerateCodeFromExpression(current, _output.InnerWriter, _options); } Indent--; }
/// <summary> /// Appends initializers for an array. /// </summary> void AppendInitializers(CodeExpressionCollection initalizers) { codeBuilder.Append("("); codeBuilder.AppendLine(); codeBuilder.IncreaseIndent(); codeBuilder.AppendIndented("["); bool firstInitializer = true; foreach (CodeExpression expression in initalizers) { if (firstInitializer) { firstInitializer = false; } else { codeBuilder.Append(","); codeBuilder.AppendLine(); codeBuilder.AppendIndented(String.Empty); } AppendExpression(expression); } codeBuilder.Append("])"); codeBuilder.DecreaseIndent(); }
private void ValidateExpressionList(CodeExpressionCollection expressions) { foreach (CodeExpression current in expressions) { ValidateExpression(current); } }
private void ValidateConstructor(CodeConstructor e) { if (!(IsCurrentClass || IsCurrentStruct)) { return; } if (e.CustomAttributes.Count > 0) { ValidateAttributes(e.CustomAttributes); } ValidateParameters(e.Parameters); CodeExpressionCollection baseArgs = e.BaseConstructorArgs; CodeExpressionCollection thisArgs = e.ChainedConstructorArgs; if (baseArgs.Count > 0) { ValidateExpressionList(baseArgs); } if (thisArgs.Count > 0) { ValidateExpressionList(thisArgs); } ValidateStatements(e.Statements); }
public void AddRange() { CodeExpression exp1 = new CodeExpression(); CodeExpression exp2 = new CodeExpression(); CodeExpression exp3 = new CodeExpression(); CodeExpressionCollection coll1 = new CodeExpressionCollection(); coll1.Add(exp1); coll1.Add(exp2); CodeExpressionCollection coll2 = new CodeExpressionCollection(); coll2.Add(exp3); coll2.AddRange(coll1); Assert.AreEqual(3, coll2.Count, "#1"); Assert.AreEqual(1, coll2.IndexOf(exp1), "#2"); Assert.AreEqual(2, coll2.IndexOf(exp2), "#3"); Assert.AreEqual(0, coll2.IndexOf(exp3), "#4"); CodeExpressionCollection coll3 = new CodeExpressionCollection(); coll3.Add(exp3); coll3.AddRange(new CodeExpression[] { exp1, exp2 }); Assert.AreEqual(3, coll2.Count, "#5"); Assert.AreEqual(1, coll2.IndexOf(exp1), "#6"); Assert.AreEqual(2, coll2.IndexOf(exp2), "#7"); Assert.AreEqual(0, coll2.IndexOf(exp3), "#8"); }
public static void GetCreateValueExpression(object value, ClrSimpleTypeInfo typeDef, CodeExpressionCollection collection) { if (value == null) { collection.Add(new CodePrimitiveExpression(value)); return; } switch (typeDef.Variety) { case XmlSchemaDatatypeVariety.List: string str = ListSimpleTypeValidator.ToString(value); collection.Add(new CodePrimitiveExpression(str)); break; case XmlSchemaDatatypeVariety.Atomic: if (value is string) { collection.Add(new CodePrimitiveExpression(value)); } else { collection.Add(CreateTypedValueExpression(typeDef.InnerType.Datatype, value)); } break; case XmlSchemaDatatypeVariety.Union: GetCreateUnionValueExpression(value, typeDef as UnionSimpleTypeInfo, collection); break; default: break; } }
_ParamInfo[] _GetParamInfos(CodeExpressionCollection parms, CodeDomResolverScope scope = null) { var result = new _ParamInfo[parms.Count]; for (var i = 0; i < result.Length; i++) { CodeExpression e = parms[i]; _ParamInfo p = default(_ParamInfo); p.IsOptional = false; p.IsRetval = false; var de = e as CodeDirectionExpression; if (null != de) { switch (de.Direction) { case FieldDirection.In: break; case FieldDirection.Out: p.IsOut = true; break; case FieldDirection.Ref: p.IsIn = p.IsOut = true; break; } e = de.Expression; } p.ParameterType = _resolver.GetTypeOfExpression(e, _scope); result[i] = p; } return(result); }
private void SerializeResumeLayout(IDesignerSerializationManager manager, CodeStatementCollection statements, object control) { CodeExpressionCollection parameters = new CodeExpressionCollection(); parameters.Add(new CodePrimitiveExpression(false)); Type[] paramTypes = { typeof(bool) }; SerializeMethodInvocation(manager, statements, control, "ResumeLayout", parameters, paramTypes, StatementOrdering.Append); }
/// <summary>Converts a list of expressions to CodeDom expressions.</summary> void ConvertExpressions(CodeExpressionCollection args, ExpressionCollection expressions) { foreach (Expression e in expressions) { _expression = null; e.Accept(this); args.Add(_expression); } }
public void Constructor1_NullItem() { CodeExpression[] expressions = new CodeExpression[] { new CodeExpression(), null }; CodeExpressionCollection coll = new CodeExpressionCollection( expressions); }
public void Constructor0() { CodeExpressionCollection coll = new CodeExpressionCollection(); Assert.IsFalse(((IList)coll).IsFixedSize, "#1"); Assert.IsFalse(((IList)coll).IsReadOnly, "#2"); Assert.AreEqual(0, coll.Count, "#3"); Assert.IsFalse(((ICollection)coll).IsSynchronized, "#4"); }
public void AddRange_Self() { CodeExpressionCollection coll = new CodeExpressionCollection(); coll.Add(new CodeExpression()); Assert.AreEqual(1, coll.Count, "#1"); coll.AddRange(coll); Assert.AreEqual(2, coll.Count, "#2"); }
private void addParamToInvoker(EventType evt, ParameterType param, CodeExpressionCollection targetCollection) { //todo add param to the collection setParamName(evt, param); CodeVariableReferenceExpression _name = new CodeVariableReferenceExpression(param.name); targetCollection.Add(_name); }
private void ValidateExpressionList(CodeExpressionCollection expressions) { IEnumerator enumerator = expressions.GetEnumerator(); while (enumerator.MoveNext()) { this.ValidateExpression((CodeExpression)enumerator.Current); } }
private static void DumpExpressionList(CodeExpressionCollection coll) { _indent++; WriteLineIndent("Parameter count: " + coll.Count.ToString()); foreach (CodeExpression exp in coll) { DumpExpression(exp); } _indent--; }
public CodeExpressionCollection VisitArguments(IEnumerable <Expression> original) { CodeExpressionCollection list = new CodeExpressionCollection(); foreach (Expression e in original) { AddParam(list, e); } return(list); }
//public CodeExpressionCollection VisitExpressionList(System.Collections.ObjectModel.ReadOnlyCollection<Expression> original) public CodeExpressionCollection VisitExpressionList(IEnumerable <Expression> original) { CodeExpressionCollection list = new CodeExpressionCollection(); foreach (Expression e in original) { list.Add(_Visit(e)); } return(list); }
private void GenerateMethod(IDLInterface idlIntf, IDLMethod idlMethod , Udbus.Parsing.ICodeTypeDeclarationHolder contextDeclarationHolder , CodeTypeReference typerefDbusInterface , CodeTypeReference typerefDbusMarshal , CodeTypeDeclaration typeProxy) { // Straight-forward interface method. CodeMemberMethod methodInterface = new CodeMemberMethod(); CodeExpressionCollection interfaceCallArgs = new CodeExpressionCollection(); methodInterface.Name = idlMethod.Name; methodInterface.Attributes = MemberAttributes.Public; Udbus.Parsing.BuildContext context = new Udbus.Parsing.BuildContext(contextDeclarationHolder); #region Methods args foreach (IDLMethodArgument idlMethodArg in idlMethod.Arguments) { CodeCommentStatement commentMethod = new CodeCommentStatement(string.Format("{0} {1} \"{2}\"", idlMethodArg.Direction, idlMethodArg.Name, idlMethodArg.Type)); methodInterface.Comments.Add(commentMethod); // Parse the type string for the argument, creating required structs as we go, and returning a type for the argument. Udbus.Parsing.IDLArgumentTypeNameBuilderBase nameBuilder = new IDLMethodArgumentTypeNameBuilder(idlIntf, idlMethod); ParamCodeTypeFactory paramtypeHolder = new ParamCodeTypeFactory(CodeTypeFactory.Default, idlMethodArg.Direction == "out" ? FieldDirection.Out : FieldDirection.In); Udbus.Parsing.CodeBuilderHelper.BuildCodeParamType(paramtypeHolder, nameBuilder, idlMethodArg.Type, context); Udbus.Parsing.ICodeParamType paramtype = paramtypeHolder.paramtype; // Arguments. CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(paramtype.CodeType, idlMethodArg.Name); CodeVariableReferenceExpression varrefMethodArg = new CodeVariableReferenceExpression(idlMethodArg.Name); if (idlMethodArg.Direction == "out") { // Add to interface parameters. interfaceCallArgs.Add(new CodeDirectionExpression(FieldDirection.Out, varrefMethodArg)); // Add parameter to interface method. param.Direction = FieldDirection.Out; } else { interfaceCallArgs.Add(varrefMethodArg); } methodInterface.Parameters.Add(param); } // Ends loop over method arguments #endregion methodInterface.Statements.Add(this.DeclareTargetVariable(typerefDbusInterface, typerefDbusMarshal)); methodInterface.Statements.Add(new CodeMethodInvokeExpression(varrefTarget, idlMethod.Name, interfaceCallArgs.Cast <CodeExpression>().ToArray())); //methodInterface.Statements.Add(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(thisProxyFieldRef, idlMethod.Name) // , interfaceCallArgs.Cast<CodeExpression>().ToArray() //)); // Finish up. typeProxy.Members.Add(methodInterface); }
private void SerializeResumeLayout(IDesignerSerializationManager manager, CodeStatementCollection statements, object control) { CodeExpressionCollection codeExpressionCollection = new CodeExpressionCollection(); codeExpressionCollection.Add(new CodePrimitiveExpression(false)); Type[] paramTypes = new Type[] { typeof(bool) }; this.SerializeMethodInvocation(manager, statements, control, "ResumeLayout", codeExpressionCollection, paramTypes, ControlCodeDomSerializer.StatementOrdering.Append); }
public static void ReplaceType(this CodeExpressionCollection collection, string oldType, string newType) { if (collection == null) { return; } foreach (CodeExpression expression in collection) { expression.ReplaceType(oldType, newType); } }
static void WriteCodeExpressionCollection(CodeExpressionCollection collection, TextWriter w, CodeGeneratorOptions o) { for (int i = 0; i < collection.Count; i++) { if (i > 0) { w.Write(", "); } GenerateCodeFromExpression(collection[i], w, o); } }
internal static CodeExpression MaterializeSimpleTypeDef( ClrSimpleTypeInfo typeInfo, Dictionary <XmlSchemaObject, string> nameMappings, LinqToXsdSettings settings) { CodeObjectCreateExpression simpleTypeCreate = null; CodeExpressionCollection expressions = null; switch (typeInfo.Variety) { case XmlSchemaDatatypeVariety.Atomic: simpleTypeCreate = new CodeObjectCreateExpression( Constants.AtomicSimpleTypeValidator); expressions = simpleTypeCreate.Parameters; expressions.Add(CreateGetBuiltInSimpleType(typeInfo.TypeCode)); expressions.Add(CreateFacets(typeInfo)); break; case XmlSchemaDatatypeVariety.List: simpleTypeCreate = new CodeObjectCreateExpression( Constants.ListSimpleTypeValidator); expressions = simpleTypeCreate.Parameters; expressions.Add(CreateGetBuiltInSimpleType(typeInfo.TypeCode)); expressions.Add(CreateFacets(typeInfo)); ListSimpleTypeInfo listType = typeInfo as ListSimpleTypeInfo; ClrSimpleTypeInfo itemType = listType.ItemType; expressions.Add(CreateSimpleTypeDef( itemType, nameMappings, settings, true)); break; case XmlSchemaDatatypeVariety.Union: simpleTypeCreate = new CodeObjectCreateExpression( Constants.UnionSimpleTypeValidator); expressions = simpleTypeCreate.Parameters; expressions.Add(CreateGetBuiltInSimpleType(typeInfo.TypeCode)); expressions.Add(CreateFacets(typeInfo)); UnionSimpleTypeInfo unionType = typeInfo as UnionSimpleTypeInfo; CodeArrayCreateExpression memberTypeCreate = new CodeArrayCreateExpression(); memberTypeCreate.CreateType = new CodeTypeReference( Constants.SimpleTypeValidator); foreach (ClrSimpleTypeInfo st in unionType.MemberTypes) { memberTypeCreate.Initializers.Add(CreateSimpleTypeDef( st, nameMappings, settings, true)); } expressions.Add(memberTypeCreate); break; } return(simpleTypeCreate); }
protected virtual void OutputExpressionList(CodeExpressionCollection expressions) { OutputExpressionList(expressions, false); }
private void ValidateExpressionList(CodeExpressionCollection expressions) { foreach (CodeExpression current in expressions) { ValidateExpression(current); } }
private void OutputExpressionList(CodeExpressionCollection expressions) { OutputExpressionList(expressions, false /*newlineBetweenItems*/); }
protected virtual void OutputExpressionList(CodeExpressionCollection expressions, bool newlineBetweenItems) { bool first = true; Indent++; foreach (CodeExpression current in expressions) { if (first) { first = false; } else { if (newlineBetweenItems) ContinueOnNewLine(","); else Output.Write(", "); } ((ICodeGenerator)this).GenerateCodeFromExpression(current, _output.InnerWriter, _options); } Indent--; }
protected virtual void OutputExpressionList(CodeExpressionCollection expressions) { OutputExpressionList(expressions, newlineBetweenItems: false); }
private void OutputExpressionList(CodeExpressionCollection expressions, bool newlineBetweenItems) { bool first = true; IEnumerator en = expressions.GetEnumerator(); Indent++; while (en.MoveNext()) { if (first) { first = false; } else { if (newlineBetweenItems) ContinueOnNewLine(","); else Output.Write(", "); } ((ICodeGenerator)this).GenerateCodeFromExpression((CodeExpression)en.Current, output.InnerWriter, options); } Indent--; }
protected virtual void OutputExpressionList (CodeExpressionCollection expressions, bool newlineBetweenItems) { writer.Indent += 1; bool first = true; foreach(CodeExpression expr in expressions) { if(!first) { if(newlineBetweenItems) { ContinueOnNewLine(","); } else { Output.Write(", "); } } else { first = false; } ((ICodeGenerator)this).GenerateCodeFromExpression (expr, writer.InnerWriter, Options); } writer.Indent -= 1; }
public CodeExpressionCollection(CodeExpressionCollection value) {}
protected virtual void OutputExpressionList(CodeExpressionCollection expressions, bool newLineBetweenItems) { // CLEANUP: This method has been modified so it generates code better. ++Indent; if (expressions.Count > 0) { CodeExpression expression = expressions[0]; if (expression is CodeCastExpression) ((CodeCastExpression)expression).NeedsGrouping = false; else if (expression is CodeBinaryOperatorExpression) ((CodeBinaryOperatorExpression)expression).NeedsGrouping = false; GenerateExpression(expression); for (int i = 1; i < expressions.Count; i++) { expression = expressions[i]; if (expression is CodeCastExpression) ((CodeCastExpression)expression).NeedsGrouping = false; else if (expression is CodeBinaryOperatorExpression) ((CodeBinaryOperatorExpression)expression).NeedsGrouping = false; output.Write(','); if (newLineBetweenItems) output.WriteLine(); else output.Write(' '); GenerateExpression(expression); } } --Indent; }
public void AddRange(CodeExpressionCollection value) {}