public CodeStatementCollection GenerateCodeInvocation( AssignActivity assignActivity) { var invocationCodeCollection = new CodeStatementCollection(); invocationCodeCollection.AddRange(DefaultActivityBuilder.LogActivity(assignActivity)); invocationCodeCollection.AddRange(this.xslBuilder.Build(assignActivity.InputBindings)); var variableToAssignReference = new CodeFieldReferenceExpression ( new CodeThisReferenceExpression (), VariableHelper.ToVariableName(assignActivity.VariableName)); var codeInvocation = new CodeAssignStatement (variableToAssignReference, new CodeVariableReferenceExpression(VariableHelper.ToVariableName(assignActivity.VariableName))); invocationCodeCollection.Add(codeInvocation); return invocationCodeCollection; }
public void Constructor1_Deny_Unrestricted () { CodeStatementCollection coll = new CodeStatementCollection (array); coll.CopyTo (array, 0); Assert.AreEqual (1, coll.Add (cs), "Add"); Assert.AreSame (cs, coll[0], "this[int]"); coll.AddRange (array); coll.AddRange (coll); Assert.IsTrue (coll.Contains (cs), "Contains"); Assert.AreEqual (0, coll.IndexOf (cs), "IndexOf"); coll.Insert (0, cs); coll.Remove (cs); }
public CodeStatementCollection GenerateCodeInvocation(WriteToLogActivity activity) { var invocationCodeCollection = new CodeStatementCollection(); // add log invocationCodeCollection.AddRange(DefaultActivityBuilder.LogActivity(activity)); //add the input invocationCodeCollection.AddRange(this.xslBuilder.Build(activity.InputBindings)); //Add the logger call invocationCodeCollection.Add(this.GenerateLoggerCodeInvocation(activity)); return invocationCodeCollection; }
public CodeStatementCollection GenerateCodeInvocation(GenerateErrorActivity activity) { var invocationCodeCollection = new CodeStatementCollection(); // add log invocationCodeCollection.AddRange(DefaultActivityBuilder.LogActivity(activity)); //add the input invocationCodeCollection.AddRange(this.xslBuilder.Build(activity.InputBindings)); // Add the exception Call invocationCodeCollection.Add(this.GenerateExceptionStatement(activity)); return invocationCodeCollection; }
private CodeStatementCollection GenerateCoreGroupMethod(GroupActivity groupActivity) { var invocationCodeCollection = new CodeStatementCollection(); invocationCodeCollection.AddRange(this.coreProcessBuilder.GenerateStartCodeStatement(groupActivity.Transitions, "start", null, this.activityNameToServiceNameDictionnary)); return invocationCodeCollection; }
public CodeStatementCollection DefaultInvocationMethod(Activity activity) { var invocationCodeCollection = new CodeStatementCollection(); invocationCodeCollection.AddRange(DefaultActivityBuilder.LogActivity(activity)); return invocationCodeCollection; }
public PreshaderSrc(AsmListing listing, CodeStatementCollection statementCollection) { statements = new List<CodeStatement>(); object[] paramsArray = new object[1]; StringBuilder sb = new StringBuilder(); foreach (AsmCommand cmd in listing.Commands) { MethodInfo method; if (!methodList.TryGetValue(cmd.Target, out method)) { if (cmd.Target == "preshader") continue; throw new CompileException(string.Format("Error decoding PreShader: Unexpected command '{0}'", cmd.Target)); } string[] args = new string[cmd.OpCount]; for (int i = 0; i < cmd.OpCount; i++) { cmd.GetOp(i).ToString(sb); args[i] = sb.ToString(); sb.Length = 0; } paramsArray[0] = args; method.Invoke(this, paramsArray); } statementCollection.AddRange(this.statements.ToArray()); }
public CodeStatementCollection DefaultInvocationMethod(Activity activity) { var activityServiceReference = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), VariableHelper.ToVariableName(activity.Name)); var methodInvocation = new CodeMethodInvokeExpression(activityServiceReference, "Execute", new CodeExpression[] { }); var invocationCodeCollection = new CodeStatementCollection(); invocationCodeCollection.AddRange(LogActivity(activity)); invocationCodeCollection.Add(methodInvocation); return invocationCodeCollection; }
public CodeStatementCollection GenerateCodeInvocation( MapperActivity mapperActivity) { var invocationCodeCollection = new CodeStatementCollection(); // Add the Log invocationCodeCollection.AddRange(DefaultActivityBuilder.LogActivity(mapperActivity)); // Add the mapping invocationCodeCollection.AddRange(this.xslBuilder.Build(mapperActivity.InputBindings)); // Add the invocation var variableReturnType = mapperActivity.XsdReference.Split(':')[1]; var variableName = VariableHelper.ToVariableName(mapperActivity.Name); var parameter = new CodeVariableReferenceExpression(mapperActivity.Parameters[0].Name); var code = new CodeVariableDeclarationStatement (variableReturnType, variableName, parameter); invocationCodeCollection.Add(code); return invocationCodeCollection; }
/// <summary> /// Serializes properties of a certain component. /// </summary> /// <param name="componentHolder">The parent expression that holds the instance.</param> /// <param name="instance">The component to take away the values from.</param> /// <returns>A collection of code statements initiating the properties of the given object to their values.</returns> public CodeStatementCollection SerializeProperties(CodeExpression componentHolder, object instance) { CodeStatementCollection statements = new CodeStatementCollection(); // Iterate through properties and add property + value to statements. foreach (PropertyDescriptor property in GetMustSerializeProperties(instance)) { statements.AddRange(SerializeProperty(componentHolder, instance, property)); } return statements; }
public CodeStatementCollection GenerateCodeInvocation(CallProcessActivity callProcessActivity) { var invocationCodeCollection = new CodeStatementCollection(); // Add the Log invocationCodeCollection.AddRange(DefaultActivityBuilder.LogActivity(callProcessActivity)); // Add the mapping invocationCodeCollection.AddRange(this.xslBuilder.Build(callProcessActivity.InputBindings)); // Add the invocation var processToCallReference = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), VariableHelper.ToVariableName(callProcessActivity.TibcoProcessToCall.ProcessName)); var parameters = DefaultActivityBuilder.GenerateParameters(callProcessActivity); // TODO : WARNING not sure the start method ProcessName is indeed START var methodInvocation = new CodeMethodInvokeExpression(processToCallReference, "Start", parameters); var code = new CodeVariableDeclarationStatement("var", VariableHelper.ToVariableName(callProcessActivity.Name), methodInvocation); invocationCodeCollection.Add(code); return invocationCodeCollection; }
public CodeSwitchStatement(CodeExpression target, CodeSwitchOption[] options, params CodeStatement[] defaultStatements) { _target = target; _options = new CodeSwitchOptionCollection(OptionsChanged, options); foreach (CodeSwitchOption option in options) { option.SetTarget(_target); } _defaultStatements = base.FalseStatements; _defaultStatements.AddRange(defaultStatements); Refresh(); }
/// <summary> /// Serializes a specific property to code. /// </summary> /// <param name="instanceHolder">The parent expression that holds the instance.</param> /// <param name="instance">The instance to take away the values from.</param> /// <param name="property">The property to serialize.</param> /// <returns>A collection of code statements initiating the given property of the given object to its value.</returns> public CodeStatementCollection SerializeProperty(CodeExpression instanceHolder, object instance, PropertyDescriptor property) { CodeStatementCollection statements = new CodeStatementCollection(); var propertyExpression = new CodePropertyReferenceExpression( instanceHolder, property.Name); object propertyValue = property.GetValue(instance); if (property.PropertyType.HasInterface(typeof(ICollection))) { // If collection, create property.Add(...) statements. statements.AddRange(CreateCollectionInitialization(propertyExpression, instance, property)); } else if (CodeDomTypeFormatter.IsFormattableWithAssignment(property.PropertyType)) { // else, create normal property = value statement. statements.Add(CreatePropertyAssignmentExpression(propertyExpression, instance, property)); } if (!CodeDomTypeFormatter.IsFormattableWithAssignment(property.PropertyType)) { // serialize child properties. if (property.PropertyType.IsValueType) { // value types uses a temp var.to access properties. statements.AddRange(CreateValueTypeInitialization(propertyExpression, instance, property)); } else { // access properties directly. statements.AddRange(SerializeProperties(propertyExpression, propertyValue)); } } return statements; }
private CodeStatementCollection InvocationMethod(Activity activity) { var invocationCodeCollection = new CodeStatementCollection(); invocationCodeCollection.AddRange(DefaultActivityBuilder.LogActivity(activity)); var groupActivity = (GroupActivity)activity; if (groupActivity.GroupType == GroupType.simpleGroup) { invocationCodeCollection.AddRange(this.GenerateCoreGroupMethod(groupActivity)); } else { var forLoop = this.GenerateForLoop(groupActivity); invocationCodeCollection.Add(forLoop); } return invocationCodeCollection; }
private CodeIterationStatement GenerateForLoop(GroupActivity groupActivity) { var coreGroupMethodStatement = new CodeStatementCollection(); // put the current element in the declare variable // TODO convert the $Variable in variable like in Xpath CodeVariableDeclarationStatement iterationElementSlotDeclaration = new CodeVariableDeclarationStatement("var", groupActivity.IterationElementSlot, new CodeVariableReferenceExpression(groupActivity.Over + "[" + groupActivity.IndexSlot + "]")); coreGroupMethodStatement.Add(iterationElementSlotDeclaration); // get the core loop code coreGroupMethodStatement.AddRange(this.GenerateCoreGroupMethod(groupActivity)); var array = new CodeStatement[coreGroupMethodStatement.Count]; coreGroupMethodStatement.CopyTo(array, 0); // put it then in the loop CodeIterationStatement forLoop = new CodeIterationStatement(new CodeVariableDeclarationStatement(typeof(int), groupActivity.IndexSlot, new CodePrimitiveExpression(0)), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(groupActivity.IndexSlot), CodeBinaryOperatorType.LessThan, new CodeVariableReferenceExpression(groupActivity.Over + ".Lenght")), new CodeAssignStatement(new CodeVariableReferenceExpression(groupActivity.IndexSlot), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(groupActivity.IndexSlot), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))), array); return forLoop; }
public CodeStatementCollection GenerateCodeInvocation(JavaActivity javaActivity) { var invocationCodeCollection = new CodeStatementCollection(); invocationCodeCollection.AddRange(DefaultActivityBuilder.LogActivity(javaActivity)); invocationCodeCollection.AddRange(this.xslBuilder.Build(javaActivity.InputBindings)); var variableReturnType = new CodeTypeReference(javaActivity.PackageName + "." + javaActivity.FileName); var creation = new CodeObjectCreateExpression (variableReturnType, new CodeExpression[0]); string javaClassVariableName = VariableHelper.ToVariableName(javaActivity.FileName); var codeInvocation = new CodeVariableDeclarationStatement(variableReturnType, javaClassVariableName, creation); invocationCodeCollection.Add(codeInvocation); CodeVariableReferenceExpression javaClassReference = new CodeVariableReferenceExpression(); javaClassReference.VariableName = javaClassVariableName; //add input to java class invocationCodeCollection.AddRange(this.GenerateInputCallOnJavaClass(javaActivity, javaClassReference)); // add call ti invoke methode invocationCodeCollection.Add(this.GenerateInvokeCallOnJavaClass(javaClassReference)); // instanciate the result class var activityReturnType = new CodeTypeReference(javaActivity.PackageName + "." + VariableHelper.ToClassName(javaActivity.Name)); var creationActivityReturn = new CodeObjectCreateExpression (activityReturnType, new CodeExpression[0]); string activityClassVariableName = VariableHelper.ToVariableName(javaActivity.Name); var codeActivityInvocation = new CodeVariableDeclarationStatement(activityReturnType, activityClassVariableName, creationActivityReturn); invocationCodeCollection.Add(codeActivityInvocation); // retrieve the output CodeVariableReferenceExpression activityClassReference = new CodeVariableReferenceExpression(); activityClassReference.VariableName = activityClassVariableName; invocationCodeCollection.AddRange(this.GenerateOutputCallOnJavaClass(javaActivity, javaClassReference, activityClassReference)); return invocationCodeCollection; }
private CodeStatement[] BuildIsParentStartElementStatements(string defaultNamespace, string fieldName, CodeNamespace codeNs, CodeTypeDeclaration codeType) { CodeStatementCollection statements = new CodeStatementCollection(); bool addReadEndElement = fieldName == null ? true : false; bool addRead = fieldName == null ? true : false; // New up the local DataContract object if (fieldName == null) { fieldName = codeType.Name + "Field"; statements.Add(CodeAssignNewObjectToVariableStatement(fieldName, codeType.Name)); } // If the type is an enum build switch statement if (codeType.IsEnum) { statements.AddRange(BuildReaderEnumSwitchStatement(codeType.Name + "Field", codeType, "reader.ReadString()")); } else { // Build sort order list of attribute member indexes int[] sortOrder = CodeGenUtils.GetListOfAttributes(codeType.Members); // For attributes build parsing code // Attributes must be parsed before Reading elements (they are parsed first) foreach (int index in sortOrder) { CodeMemberField memberField = (CodeMemberField)codeType.Members[index]; // Create IsAttribute parameters CodeVariableReferenceExpression readerParam = new CodeVariableReferenceExpression("reader"); CodeVariableReferenceExpression nameParam = new CodeVariableReferenceExpression("\"" + memberField.Name + "\""); if (memberField.Name == "AnyAttr") statements.Add(BuildReadAnyAttributeStatement(fieldName, memberField)); else { statements.Add( new CodeConditionStatement( new CodeMethodInvokeExpression( null, "IsAttribute", new CodeExpression[] { readerParam, nameParam } ), memberField.Type.ArrayElementType == null ? BuildIsAttributeStatements(MemberType.Attribute, fieldName, memberField, codeNs) : BuildIsAttributeArrayStatements(MemberType.Attribute, fieldName, memberField, codeNs) ) ); } } // Add Read to the IsParentStartElement conditional statements // reader.Read([FieldName]); // Since this method is recursive provisions restrict it to the first time through only. if (addRead) { statements.Add( new CodeMethodInvokeExpression( new CodeVariableReferenceExpression("reader"), "Read", new CodeExpression[] { } ) ); } // Build sort order list of field member indexes sortOrder = CodeGenUtils.GetListOfMembers(codeType.Members); // For each field member build processing code foreach (int index in sortOrder) { CodeMemberField memberField = (CodeMemberField)codeType.Members[index]; // If this a an Any element write the parsing calls here and forgo normal child processing if (memberField.Type.BaseType == "XmlElement" && memberField.Name == "Any") { statements.Add(BuildReadAnyElementStatement(fieldName, memberField)); } // Else if this is an Any element write the parsing calls here to forgo normal child // processing. Create special reader else if (!CodeGenUtils.IsNativeClrType(memberField.Type.BaseType)) { statements.AddRange(BuildIsChildStartElementStatements(MemberType.Attribute, defaultNamespace, fieldName, memberField, codeNs)); } else { string nillable = CodeGenUtils.GetCustomAttributeArgumentValue("IsNillable", memberField.CustomAttributes); bool isNillable = nillable == null || nillable == "false" ? false : true; // Check to see if the element is required (i.e. minOccurs > 0) string required = CodeGenUtils.GetCustomAttributeArgumentValue("IsRequired", memberField.CustomAttributes); bool isRequired = required == null || required == "true" ? true : false; // Build ReadStartObject if statement CodeVariableReferenceExpression readerParam = new CodeVariableReferenceExpression("reader"); CodeVariableReferenceExpression nameParam = new CodeVariableReferenceExpression("\"" + memberField.Name + "\""); CodePrimitiveExpression nillableParam = new CodePrimitiveExpression(isNillable); CodePrimitiveExpression requiredParam = new CodePrimitiveExpression(isRequired); CodeConditionStatement condition = new CodeConditionStatement(new CodeMethodInvokeExpression(null, "IsChildStartElement", new CodeExpression[] { readerParam, nameParam, nillableParam, requiredParam }), // True condition code. Build read statements based on contract member type BuildIsChildStartElementStatements(MemberType.Attribute, defaultNamespace, fieldName, memberField, codeNs) ); statements.Add(condition); } } } if (addReadEndElement) { // Build ReadEndElement statement statements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("reader"), "ReadEndElement", new CodeExpression[] { })); } // Build a CodeStatement array object to return CodeStatement[] codeStatements = new CodeStatement[statements.Count]; for (int i = 0; i < statements.Count; ++i) codeStatements[i] = statements[i]; return codeStatements; }
private CodeMemberMethod BuildNativeReadObjectMethod(string type, string typeName) { // Create ReadObject method CodeMemberMethod codeMemberMethod = new CodeMemberMethod(); codeMemberMethod.Attributes = MemberAttributes.Public | MemberAttributes.Override; codeMemberMethod.ReturnType = new CodeTypeReference(typeof(object)); codeMemberMethod.Name = "ReadObject"; codeMemberMethod.Parameters.Add(new CodeParameterDeclarationExpression("XmlReader", "reader")); // Create temporary variable CodeVariableDeclarationStatement varDecl = new CodeVariableDeclarationStatement(type, typeName); if (varDecl.Type.ArrayElementType == null) { if (type == "System.String") varDecl.InitExpression = new CodePrimitiveExpression(null); } else varDecl.InitExpression = new CodeArrayCreateExpression(type, new CodeExpression[] { }); codeMemberMethod.Statements.Add(varDecl); // Create temporary member field used to generate read string code CodeMemberField memberField = new CodeMemberField(type, typeName); // Create conditional read statement CodeStatementCollection readStatements = new CodeStatementCollection(); if (memberField.Type.ArrayElementType != null && CodeGenUtils.IsNativeClrType(memberField.Type.ArrayElementType.BaseType)) { readStatements.AddRange(BuildReadStringArrayStatements(MemberType.Field, null, memberField)); } // Else if this is a native type else if (Type.GetType(memberField.Type.BaseType) != null) { readStatements.Add(BuildReadStringStatement(MemberType.Field, null, memberField)); } else throw new ArgumentException("Invalid native field type for schema item: " + memberField.Name); // Add ReadEndElement to condition statements readStatements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("reader"), "ReadEndElement", new CodeExpression[] { })); // Add native type return statement readStatements.Add(new CodeMethodReturnStatement(new CodeArgumentReferenceExpression(typeName))); // Convert statement collection to array CodeStatement[] readStatementArray = new CodeStatement[readStatements.Count]; readStatements.CopyTo(readStatementArray, 0); // Build IsParentStartElement if statement CodeVariableReferenceExpression readerParam = new CodeVariableReferenceExpression("reader"); CodePrimitiveExpression nillableParam = new CodePrimitiveExpression(false); CodePrimitiveExpression requiredParam = new CodePrimitiveExpression(true); CodeConditionStatement condition = new CodeConditionStatement(new CodeMethodInvokeExpression(null, "IsParentStartElement", new CodeExpression[] { readerParam, nillableParam, requiredParam }), readStatementArray); // Add condition codeMemberMethod.Statements.Add(condition); // Add null return statement codeMemberMethod.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null))); return codeMemberMethod; }
private CodeStatement[] BuildWriteChildElementStatements(string classRefName, CodeMemberField memberField) { CodeTypeReferenceExpression readerRef = new CodeTypeReferenceExpression("writer"); CodeStatementCollection statements = new CodeStatementCollection(); // If the messages uses Mtom encoding and this is a byte array special mtom processing applies if (m_encodingType == MessageEncodingType.Mtom && memberField.Type.ArrayElementType != null && memberField.Type.ArrayElementType.BaseType == "System.Byte") { // Increment the cid identifier ++m_cid; // BodyParts.Add(CreateNewBodyPart(ClassName.FieldName, "<cid@body>")); statements.Add( new CodeMethodInvokeExpression( new CodeVariableReferenceExpression("BodyParts"), "Add", new CodeExpression[] { new CodeMethodInvokeExpression( null, "CreateNewBodyPart", new CodeExpression[] { new CodeFieldReferenceExpression( new CodeVariableReferenceExpression(classRefName), memberField.Name ), new CodePrimitiveExpression("<" + m_cid.ToString() + "@body>") } ) } ) ); // writer.WriteStartElement("xop", "Include", "http://www.w3.org/2004/08/xop/include"); statements.Add( new CodeMethodInvokeExpression( new CodeVariableReferenceExpression("writer"), "WriteStartElement", new CodeExpression[] { new CodePrimitiveExpression("xop"), new CodePrimitiveExpression("Include"), new CodePrimitiveExpression("http://www.w3.org/2004/08/xop/include") } ) ); // writer.WriteAttributeString(null, "href", null, "0@body"); statements.Add( new CodeMethodInvokeExpression( new CodeVariableReferenceExpression("writer"), "WriteAttributeString", new CodeExpression[] { new CodePrimitiveExpression(null), new CodePrimitiveExpression("href"), new CodePrimitiveExpression(null), new CodePrimitiveExpression("cid:" + m_cid.ToString() + "@body") } ) ); // writer.WriteEndElement(); statements.Add( new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("writer"), "WriteEndElement") ); } // If this is an any element create special reader else if (memberField.Type.BaseType == "XmlElement" && memberField.Name == "Any") { statements.Add(BuildWriteAnyElementStatement(classRefName, memberField)); } // Else if this is a native array else if (memberField.Type.ArrayElementType != null && CodeGenUtils.IsNativeClrType(memberField.Type.ArrayElementType.BaseType)) { statements.AddRange(BuildWriteArrayStatements(classRefName, memberField)); } else statements.Add(BuildWriteStringStatement(classRefName, memberField)); // If this is not an attribute add WriteEndElement statement if (CodeGenUtils.GetCustomAttributeArgumentValue("IsAttribute", memberField.CustomAttributes) == null) { CodeMethodInvokeExpression writeEndElementExp = new CodeMethodInvokeExpression( readerRef, "WriteEndElement", new CodeExpression[] { }); statements.Add(writeEndElementExp); } // Build a CodeStatement array object to return CodeStatement[] codeStatements = new CodeStatement[statements.Count]; for (int i = 0; i < statements.Count; ++i) codeStatements[i] = statements[i]; return codeStatements; }
private CodeStatement[] BuildWriteParentElementStatements(string defaultNamespace, string fieldName, CodeNamespace codeNs, CodeTypeDeclaration codeType) { CodeStatementCollection statements = new CodeStatementCollection(); bool writeWriteEnd = fieldName == null ? true : false; // New up the local DataContract object fieldName = (fieldName == null) ? codeType.Name + "Field" : fieldName; // Build member write statements based on member type statements.AddRange(BuildWriteParentElementStatement(defaultNamespace, fieldName, codeNs, codeType)); // If this is not a recursive call if (writeWriteEnd) { // Build WriteEndElement statement statements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("writer"), "WriteEndElement", new CodeExpression[] { })); } // Build a CodeStatement array object to return CodeStatement[] codeStatements = new CodeStatement[statements.Count]; for (int i = 0; i < statements.Count; ++i) codeStatements[i] = statements[i]; return codeStatements; }
private CodeStatementCollection BuildWriteParentElementStatement(string defaultNamespace, string fieldName, CodeNamespace codeNs, CodeTypeDeclaration codeType) { CodeStatementCollection statements = new CodeStatementCollection(); // If the code type is an enum build reader. if (codeType.IsEnum) { statements.AddRange(BuildWriterEnumSwitchStatement(codeType)); } else { // Sort member list. int[] sortOrder = CodeGenUtils.SortMemberTypes(codeType.Members); CodeMemberField codeField; // Build write statement for each member of the contract foreach (int index in sortOrder) { codeField = (CodeMemberField)codeType.Members[index]; // If this is an attribute build WriteAttribute element if (CodeGenUtils.GetCustomAttributeArgumentValue("IsAttribute", codeField.CustomAttributes) == "True") { statements.Add(BuildWriteAttributeExpression(defaultNamespace, fieldName, codeField)); } // Else if this is an anyAttibute element create special reader else if (codeField.Type.BaseType != null && codeField.Name == "AnyAttr") { statements.Add(BuildWriteAnyAttributeStatement(fieldName, codeField)); } // If this is a native schema type create WriteChildElement conditional statement else if ((codeField.Type.ArrayElementType != null && CodeGenUtils.IsNativeClrType(codeField.Type.ArrayElementType.BaseType)) || Type.GetType(codeField.Type.BaseType) != null) { statements.Add(BuildWriteChildElementCondition(defaultNamespace, fieldName, codeField)); } // If this is an any element create special reader else if (codeField.Type.BaseType != null && codeField.Name == "Any") { statements.Add(BuildWriteAnyElementStatement(fieldName, codeField)); } // Else Create new serializer and call it else { // New up a DataContractSerialiser for this type CodeVariableDeclarationStatement classDeclaration = new CodeVariableDeclarationStatement(codeField.Type.BaseType + "DataContractSerializer", codeField.Name + "DCS"); // Find the namespace of the member type which is required if there are nested namespaces in the data contract string ns = CodeGenUtils.GetNamespaceFromType(m_codeNamespaces, codeField.Type.BaseType); // use the default namespace if the field type was not found if(string.IsNullOrEmpty(ns)) { ns = defaultNamespace; } classDeclaration.InitExpression = new CodeObjectCreateExpression( codeField.Type.BaseType + "DataContractSerializer", new CodeExpression[] { new CodePrimitiveExpression(codeField.Name), new CodePrimitiveExpression(defaultNamespace), new CodePrimitiveExpression(ns) }); statements.Add(classDeclaration); // If this is not an array process the element if (codeField.Type.ArrayElementType == null) { // Build codeField[DCS].WriteObject(reader, [ClassName.FieldName); expression CodeFieldReferenceExpression fieldRef = new CodeFieldReferenceExpression( new CodeTypeReferenceExpression(fieldName), codeField.Name); CodeExpression writeExpression = new CodeMethodInvokeExpression( new CodeTypeReferenceExpression(codeField.Name + "DCS"), "WriteObject", new CodeExpression[] { new CodeTypeReferenceExpression("writer"), fieldRef }); // Add processing expression statements.Add(writeExpression); } // Else process an array of elements else { statements.AddRange(BuildElementArrayWriteStatements(fieldName, codeField, defaultNamespace, codeNs)); } } } } return statements; }
private void SerializeContentProperty (IDesignerSerializationManager manager, object instance, PropertyDescriptor descriptor, CodeStatementCollection statements) { CodePropertyReferenceExpression propRef = new CodePropertyReferenceExpression (); propRef.PropertyName = descriptor.Name; object propertyValue = descriptor.GetValue (instance); ExpressionContext expressionCtx = manager.Context[typeof (ExpressionContext)] as ExpressionContext; if (expressionCtx != null && expressionCtx.PresetValue == instance) propRef.TargetObject = expressionCtx.Expression; else propRef.TargetObject = base.SerializeToExpression (manager, instance); CodeDomSerializer serializer = manager.GetSerializer (propertyValue.GetType (), typeof (CodeDomSerializer)) as CodeDomSerializer; if (propRef.TargetObject != null && serializer != null) { manager.Context.Push (new ExpressionContext (propRef, propRef.GetType (), null, propertyValue)); object serialized = serializer.Serialize (manager, propertyValue); manager.Context.Pop (); CodeStatementCollection serializedStatements = serialized as CodeStatementCollection; if (serializedStatements != null) statements.AddRange (serializedStatements); CodeStatement serializedStatement = serialized as CodeStatement; if (serializedStatement != null) statements.Add (serializedStatement); CodeExpression serializedExpr = serialized as CodeExpression; if (serializedExpr != null) statements.Add (new CodeAssignStatement (propRef, serializedExpr)); } }
private CodeMemberMethod BuildNativeWriteObjectMethod(string type, string typeName, CodeNamespace codeNs) { // Create WriteObject method CodeMemberMethod codeMemberMethod = new CodeMemberMethod(); codeMemberMethod.Attributes = MemberAttributes.Public | MemberAttributes.Override; codeMemberMethod.ReturnType = new CodeTypeReference(typeof(void)); codeMemberMethod.Name = "WriteObject"; codeMemberMethod.Parameters.Add(new CodeParameterDeclarationExpression("XmlWriter", "writer")); codeMemberMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "graph")); // Add type declaration CodeVariableDeclarationStatement declaration = new CodeVariableDeclarationStatement(type, typeName); declaration.InitExpression = new CodeCastExpression(type, new CodeVariableReferenceExpression("graph")); codeMemberMethod.Statements.Add(declaration); // Create temporary member field used to generate write string code CodeMemberField memberField = new CodeMemberField(type, typeName); // Create conditional write statement CodeStatementCollection writeStatements = new CodeStatementCollection(); if (memberField.Type.ArrayElementType != null && CodeGenUtils.IsNativeClrType(memberField.Type.ArrayElementType.BaseType)) { writeStatements.AddRange(BuildWriteArrayStatements(null, memberField)); } // Else if this is a native type else if (Type.GetType(memberField.Type.BaseType) != null) { writeStatements.Add(BuildWriteStringStatement(null, memberField)); } else throw new ArgumentException("Invalid native field type for schema item: " + memberField.Name); // Add WriteEndElement statement writeStatements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("writer"), "WriteEndElement", new CodeExpression[] { })); // Convert statement collection to array CodeStatement[] writeStatementArray = new CodeStatement[writeStatements.Count]; writeStatements.CopyTo(writeStatementArray, 0); // Build WriteParentElement condition paramters CodeVariableReferenceExpression writerParam = new CodeVariableReferenceExpression("writer"); CodePrimitiveExpression nillableParam = new CodePrimitiveExpression(false); CodePrimitiveExpression requiredParam = new CodePrimitiveExpression(true); CodeVariableReferenceExpression objectParam = new CodeVariableReferenceExpression("graph"); // Build WriteParentElement condition statement CodeConditionStatement condition = new CodeConditionStatement(new CodeMethodInvokeExpression(null, "WriteParentElement", new CodeExpression[] { writerParam, nillableParam, requiredParam, objectParam }), // True condition code. Build read statements based on contract member type writeStatementArray ); // Add condition codeMemberMethod.Statements.Add(condition); return codeMemberMethod; }
private CodeStatement[] BuildIsAttributeStatements(MemberType memberType, string classRefName, CodeMemberField memberField, CodeNamespace codeNs) { CodeStatementCollection statements = new CodeStatementCollection(); // If this is a native schema type create IsAttribute conditional statement if ((memberField.Type.ArrayElementType != null && Type.GetType(memberField.Type.ArrayElementType.BaseType) != null) || Type.GetType(memberField.Type.BaseType) != null) { statements.Add(BuildReadStringStatement(MemberType.Attribute, classRefName, memberField)); } // Else if this is an enum type build switch else { // Attempt to get the enum type // Note: 2-16-09 - Changed code to get memberField.Type.BaseType instead of memberField.Name - Should // be going after the enum type not the complex field CodeTypeDeclaration enumType = CodeGenUtils.GetCodeType(memberField.Type.BaseType, codeNs); if (enumType == null || enumType.IsEnum == false) throw new XmlException(); statements.AddRange(BuildReaderEnumSwitchStatement(classRefName + "." + memberField.Name, enumType, "reader.Value")); } // Build a CodeStatement array object to return CodeStatement[] codeStatements = new CodeStatement[statements.Count]; for (int i = 0; i < statements.Count; ++i) codeStatements[i] = statements[i]; return codeStatements; }
private CodeStatement[] BuildIsChildStartElementStatements(MemberType memberType, string defaultNamespace, string classRefName, CodeMemberField memberField, CodeNamespace codeNs) { CodeStatementCollection statements = new CodeStatementCollection(); bool addReadEndElement = true; // Add Read to the IsChildStartElement conditional statements // reader.Read(); CodeMethodInvokeExpression ReadExpression = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression("reader"), "Read", new CodeExpression[] { } ); statements.Add(ReadExpression); // If the messages uses Mtom encoding and this is a byte array special mtom processing applies if (m_encodingType == MessageEncodingType.Mtom && memberField.Type.ArrayElementType != null && memberField.Type.ArrayElementType.BaseType == "System.Byte") { // Build statements that retreive the Mtom message info statements.AddRange(BuildMtomReadStringStatements(memberType, classRefName, memberField)); } else { // Else if this is a native schema array type create string array reader if (memberField.Type.ArrayElementType != null && CodeGenUtils.IsNativeClrType(memberField.Type.ArrayElementType.BaseType)) { statements.AddRange(BuildReadStringArrayStatements(MemberType.Field, classRefName, memberField)); } // Else if this is a native type else if (Type.GetType(memberField.Type.BaseType) != null) { statements.Add(BuildReadStringStatement(MemberType.Field, classRefName, memberField)); } // Else if this is an enum type build switch else { // If this is an enum or nested object don't write ReadEndElement addReadEndElement = false; // Attempt to get the enum type CodeTypeDeclaration enumType = CodeGenUtils.GetCodeType(memberField.Name, codeNs); if (enumType != null && enumType.IsEnum == true) { statements.AddRange(BuildReaderEnumSwitchStatement(enumType.Name + "Field", enumType, "reader.Value")); } else { // Clear the ReadExpression from the statements collection if we get here statements.Clear(); // New up a DataContractSerialiser for this type CodeVariableDeclarationStatement classDeclaration = new CodeVariableDeclarationStatement(memberField.Type.BaseType + "DataContractSerializer", memberField.Name + "DCS"); // Find the namespace of the member type which is required if there are nested namespaces in the data contract string ns = CodeGenUtils.GetNamespaceFromType(m_codeNamespaces, memberField.Type.BaseType); // Use the default namespace if the member type's could not be found if(string.IsNullOrEmpty(ns)) { ns = defaultNamespace; } classDeclaration.InitExpression = new CodeObjectCreateExpression( memberField.Type.BaseType + "DataContractSerializer", new CodeExpression[] { new CodePrimitiveExpression(memberField.Name), new CodePrimitiveExpression(defaultNamespace), new CodePrimitiveExpression(ns) }); statements.Add(classDeclaration); // Add data contract serializer used to process this type if (memberField.Type.ArrayElementType == null) { // Build [ClassName].[FieldName] = codeField[DCS].ReadObject(reader); expression CodeFieldReferenceExpression fieldRef = new CodeFieldReferenceExpression( new CodeTypeReferenceExpression(classRefName), memberField.Name); CodeCastExpression readExpression = new CodeCastExpression(memberField.Type.BaseType, new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(memberField.Name + "DCS"), "ReadObject", new CodeExpression[] { new CodeTypeReferenceExpression("reader") })); CodeAssignStatement convertStatement = new CodeAssignStatement(fieldRef, readExpression); // Add processing expression statements.Add(convertStatement); } //Else if the base type is an array build array processor else { statements.AddRange(BuildElementArrayReadStatements(classRefName, memberField, defaultNamespace, codeNs)); } } } } // Build ReadEndElement statement if (addReadEndElement) { statements.Add(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("reader"), "ReadEndElement", new CodeExpression[] { })); } // Build a CodeStatement array object to return CodeStatement[] codeStatements = new CodeStatement[statements.Count]; for (int i = 0; i < statements.Count; ++i) codeStatements[i] = statements[i]; return codeStatements; }
private CodeStatement[] BuildWriteArrayStatements(string classRefName, CodeMemberField memberField) { CodeStatementCollection statements = new CodeStatementCollection(); string tempListName = memberField.Name + "_List"; // Add create tempList statement: string tempListName; CodeVariableDeclarationStatement declaration = new CodeVariableDeclarationStatement(typeof(string), tempListName); declaration.InitExpression = new CodePrimitiveExpression(""); statements.Add(declaration); if (memberField.Type.ArrayElementType.BaseType == "System.Byte") { statements.Add( new CodeConditionStatement( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "_CompressByteArrays" ), BuildWriteArrayStatementsBase64(tempListName, classRefName, memberField), BuildWriteArrayStatementsNormal(tempListName, classRefName, memberField) ) ); } else { statements.AddRange(BuildWriteArrayStatementsNormal(tempListName, classRefName, memberField)); } // Build a CodeStatement array object to return CodeStatement[] codeStatements = new CodeStatement[statements.Count]; for (int i = 0; i < statements.Count; ++i) codeStatements[i] = statements[i]; return codeStatements; }
protected override void AddPageTypeCtorStatements (CodeStatementCollection statements) { base.AddPageTypeCtorStatements (statements); CodeTypeReference uriType = new CodeTypeReference (typeof(Uri)); CodeVariableDeclarationStatement procVar = new CodeVariableDeclarationStatement { Name = "proc", Type = new CodeTypeReference(typeof(IXQueryProcessor)), InitExpression = new CodeIndexerExpression { TargetObject = new CodePropertyReferenceExpression { PropertyName = "XQuery", TargetObject = new CodeTypeReferenceExpression(typeof(Processors)) }, Indices = { new CodePrimitiveExpression(parser.ProcessorName) } } }; CodeVariableDeclarationStatement sourceVar = new CodeVariableDeclarationStatement { Name = "source", Type = new CodeTypeReference(typeof(Stream)), InitExpression = new CodePrimitiveExpression(null) }; CodeVariableDeclarationStatement virtualPathVar = new CodeVariableDeclarationStatement { Name = "virtualPath", Type = new CodeTypeReference(typeof(String)), InitExpression = new CodePrimitiveExpression(this.parser.AppRelativeVirtualPath) }; CodeVariableDeclarationStatement sourceUriVar = new CodeVariableDeclarationStatement { Name = "sourceUri", Type = uriType, InitExpression = new CodeObjectCreateExpression { CreateType = uriType, Parameters = { new CodeMethodInvokeExpression { Method = new CodeMethodReferenceExpression { MethodName = "MapPath", TargetObject = new CodeTypeReferenceExpression(typeof(HostingEnvironment)) }, Parameters = { new CodeVariableReferenceExpression(virtualPathVar.Name) } }, new CodePropertyReferenceExpression { PropertyName = "Absolute", TargetObject = new CodeTypeReferenceExpression(typeof(UriKind)) } } } }; CodeTryCatchFinallyStatement trySt = new CodeTryCatchFinallyStatement (); trySt.TryStatements.Add (new CodeAssignStatement { Left = new CodeVariableReferenceExpression(sourceVar.Name), Right = new CodeCastExpression { TargetType = new CodeTypeReference(typeof(Stream)), Expression = new CodeMethodInvokeExpression { Method = new CodeMethodReferenceExpression { MethodName = "OpenRead", TargetObject = new CodeTypeReferenceExpression(typeof(File)) }, Parameters = { new CodePropertyReferenceExpression { PropertyName = "LocalPath", TargetObject = new CodeVariableReferenceExpression(sourceUriVar.Name) } } } } }); CodeVariableDeclarationStatement optionsVar = new CodeVariableDeclarationStatement { Name = "options", Type = new CodeTypeReference(typeof(XQueryCompileOptions)), }; optionsVar.InitExpression = new CodeObjectCreateExpression (optionsVar.Type); trySt.TryStatements.Add (optionsVar); trySt.TryStatements.Add (new CodeAssignStatement { Left = new CodePropertyReferenceExpression { PropertyName = "BaseUri", TargetObject = new CodeVariableReferenceExpression(optionsVar.Name) }, Right = new CodeVariableReferenceExpression(sourceUriVar.Name) }); trySt.TryStatements.Add (new CodeAssignStatement { Left = new CodeFieldReferenceExpression { FieldName = executableField.Name, TargetObject = PageTypeReferenceExpression }, Right = new CodeMethodInvokeExpression { Method = new CodeMethodReferenceExpression { MethodName = "Compile", TargetObject = new CodeVariableReferenceExpression(procVar.Name) }, Parameters = { new CodeVariableReferenceExpression(sourceVar.Name), new CodeVariableReferenceExpression(optionsVar.Name) } } }); CodeConditionStatement disposeIf = new CodeConditionStatement { Condition = new CodeBinaryOperatorExpression { Left = new CodeVariableReferenceExpression(sourceVar.Name), Operator = CodeBinaryOperatorType.IdentityInequality, Right = new CodePrimitiveExpression(null) } }; disposeIf.TrueStatements.Add (new CodeMethodInvokeExpression ( new CodeMethodReferenceExpression { MethodName = "Dispose", TargetObject = new CodeVariableReferenceExpression(sourceVar.Name) } )); trySt.FinallyStatements.Add (disposeIf); statements.AddRange (new CodeStatement[] { procVar, sourceVar, virtualPathVar, sourceUriVar, trySt }); }
private CodeStatement[] BuildReadStringArrayStatements(MemberType memberType, string classRefName, CodeMemberField memberField) { CodeStatementCollection statements = new CodeStatementCollection(); string tempListName = memberField.Name + "_List"; // Build: string[] tempArray = reader.ReadString().Split(); CodeVariableDeclarationStatement declaration = new CodeVariableDeclarationStatement(typeof(string[]), tempListName); CodeExpression expression = new CodeMethodInvokeExpression( new CodeTypeReferenceExpression("reader"), "ReadString"); expression = new CodeMethodInvokeExpression( expression, "Split"); declaration.InitExpression = expression; statements.Add(declaration); if (memberField.Type.ArrayElementType.BaseType == "System.Byte") { statements.Add( new CodeConditionStatement( new CodeBinaryOperatorExpression( new CodeFieldReferenceExpression( new CodeThisReferenceExpression(), "_CompressByteArrays" ), CodeBinaryOperatorType.BooleanOr, new CodeBinaryOperatorExpression( new CodeBinaryOperatorExpression( new CodeFieldReferenceExpression( new CodeVariableReferenceExpression(tempListName), "Length"), CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(1) ), CodeBinaryOperatorType.BooleanAnd, new CodeBinaryOperatorExpression( new CodeFieldReferenceExpression( new CodeArrayIndexerExpression( new CodeVariableReferenceExpression(tempListName), new CodePrimitiveExpression(0) ), "Length" ), CodeBinaryOperatorType.GreaterThan, new CodePrimitiveExpression(2) ) ) ), BuildBase64ArrayStatement(tempListName, classRefName, memberField), BuildReadStringArrayStatementsNormal(tempListName, classRefName, memberField) ) ); } else { statements.AddRange(BuildReadStringArrayStatementsNormal(tempListName, classRefName, memberField)); } // Build a CodeStatement array object to return CodeStatement[] codeStatements = new CodeStatement[statements.Count]; for (int i = 0; i < statements.Count; ++i) codeStatements[i] = statements[i]; return codeStatements; }
public override void AddStatements( CodeStatementCollection collection ) { collection.AddRange( this._statements ); }
static CodeStatementCollection BuildAttributeGet(AttributeMetadata attribute, CodeTypeReference targetType) { var statements = new CodeStatementCollection(); if (((attribute.AttributeType.GetValueOrDefault()) == AttributeTypeCode.PartyList) && (targetType.TypeArguments.Count > 0)) { statements.AddRange(BuildEntityCollectionAttributeGet(attribute.LogicalName, targetType)); return statements; } statements.Add(Return(ThisMethodInvoke("GetAttributeValue", targetType, new CodeExpression[] {StringLiteral(attribute.LogicalName)}))); return statements; }