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) {}
