public CodeStatementCollection GenerateInvocationCode(Activity activity, Dictionary <string, string> variables)
{
var invocationCodeCollection = new CodeStatementCollection();
//invocationCodeCollection.AddRange(DefaultActivityBuilder.LogActivity(activity));
var groupActivity = (GroupActivity)activity;
if (groupActivity.GroupType == GroupType.INPUTLOOP)
{
invocationCodeCollection.Add(this.GenerateForLoop(groupActivity));
}
else if (groupActivity.GroupType == GroupType.REPEAT)
{
invocationCodeCollection.Add(this.GenerateForRepeat(groupActivity, true));
}
else if (groupActivity.GroupType == GroupType.WHILE)
{
invocationCodeCollection.Add(this.GenerateForRepeat(groupActivity, false));
}
else if (groupActivity.GroupType == GroupType.CRITICALSECTION)
{
invocationCodeCollection.AddRange(this.GenerateForCriticalSection(groupActivity));
}
else
{
invocationCodeCollection.AddRange(this.GenerateCoreGroupMethod(groupActivity));
}
return(invocationCodeCollection);
}
private void EmitPropertyGetter(CodeMemberProperty memberProperty, List <CodeStatement> additionalGetStatements)
{
CodeStatementCollection statements = memberProperty.GetStatements;
// we need to insert user-specified code before other/existing code, including
// the return statement
if (additionalGetStatements != null && additionalGetStatements.Count > 0)
{
try
{
CodeStatementCollection getStatements = new CodeStatementCollection();
getStatements.AddRange(additionalGetStatements.ToArray());
if (statements != null && statements.Count > 0)
{
getStatements.AddRange(statements);
}
statements.Clear();
statements.AddRange(getStatements);
}
catch (ArgumentNullException e)
{
Generator.AddError(Strings.InvalidGetStatementSuppliedForProperty(Item.Name),
ModelBuilderErrorCode.InvalidGetStatementSuppliedForProperty,
EdmSchemaErrorSeverity.Error,
e);
}
}
MemberAttributes access = memberProperty.Attributes & MemberAttributes.AccessMask;
AddGetterSetterFixUp(Generator.FixUps, PropertyFQName, GetGetterAccessibility(Item), access, true);
EmitPropertyGetterBody(statements);
}
public override List <CodeMemberMethod> GenerateMethods(Activity activity, Dictionary <string, string> variables)
{
var activityMethod = base.GenerateMethods(activity, variables);
var jdbcQueryActivity = (JdbcQueryActivity)activity;
var invocationCodeCollection = new CodeStatementCollection();
// Add the input bindings
if (jdbcQueryActivity.InputBindings != null)
{
foreach (var element in jdbcQueryActivity.InputBindings)
{
//var firstOrDefault = (XElement)jdbcQueryActivity.InputBindings.FirstOrDefault();
//var inputNodes = firstOrDefault.Nodes();
if (((XElement)element).Name.LocalName == "inputSet" || ((XElement)element).Name.LocalName == "jdbcQueryActivityInput")
{
invocationCodeCollection.AddRange(this.xslBuilder.Build(((XElement)element).Nodes()));
}
else
{
invocationCodeCollection.AddRange(this.xslBuilder.Build(new List <XNode> {
element
}));
}
}
}
// Add the invocation itself
var activityServiceReference = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), VariableHelper.ToVariableName(this.ServiceToInvoke));
var parameters = GenerateParameters(jdbcQueryActivity);
var returnType = this.GetReturnType(activity);
if (!returnType.Equals(CSharpTypeConstant.SystemVoid))
{
var codeInvocation = new CodeMethodReturnStatement(new CodeMethodInvokeExpression(activityServiceReference, DataAccessServiceBuilder.ExecuteSqlQueryMethodName, parameters));
invocationCodeCollection.Add(codeInvocation);
}
else
{
var codeInvocation = new CodeMethodInvokeExpression(activityServiceReference, DataAccessServiceBuilder.ExecuteSqlQueryMethodName, parameters);
invocationCodeCollection.Add(codeInvocation);
}
activityMethod[0].Statements.AddRange(invocationCodeCollection);
return(activityMethod);
}
protected CodeStatementCollection GetAssignStatementForVariableLengthField(MessageSerializedPropertyInfo variableLengthFieldPropertyInfo, MessageSerializedClassInfo classInfo)
{
CalculatedFieldInfo messageLengthCalculatedFieldInfo = classInfo.GetCalculatedLengthInfo();
if (messageLengthCalculatedFieldInfo == null)
{
throw new Exception($"Class {classInfo.ClassType.FullName}, property {variableLengthFieldPropertyInfo.PropertyInfo.Name} is a variable length non-blob field but there isn't a related calculated length field");
}
CodeVariableReferenceExpression currentArrayIndexExpression = new CodeVariableReferenceExpression("currentArrayIndex");
IEnumerable <int> blobLengthIndexes = messageLengthCalculatedFieldInfo.GetAssociatedBlobLengthFieldIndexes(classInfo.Properties);
var getVaryingLengthFieldLengthArguments = new List <CodeExpression>();
// (int)typedObject.LengthFieldName
getVaryingLengthFieldLengthArguments.Add(
new CodeCastExpression(
typeof(int),
new CodePropertyReferenceExpression(
new CodeVariableReferenceExpression(TypedObjectFieldName),
messageLengthCalculatedFieldInfo.CalculatorResultPropertyInfo.PropertyInfo.Name)));
foreach (int blobLengthIndex in blobLengthIndexes)
{
// (int)typedObject.BlobLengthFieldName
getVaryingLengthFieldLengthArguments.Add(
new CodeCastExpression(
typeof(int),
new CodePropertyReferenceExpression(
new CodeVariableReferenceExpression(TypedObjectFieldName),
classInfo.Properties[blobLengthIndex].PropertyInfo.Name)));
}
// _calculatorLength.GetVaryingLengthFieldLength((int)typedObject.LengthFieldName, (int)typedObject.BlobLength1, (int)typedObject.BlobLength2)
CodeMethodInvokeExpression variableLengthFieldLengthExpression = new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression(GetCalculatorMemberVariableName(messageLengthCalculatedFieldInfo)),
"GetVaryingLengthFieldLength",
getVaryingLengthFieldLengthArguments.ToArray());
CodeStatementCollection codeStatementCollection = new CodeStatementCollection();
if (variableLengthFieldPropertyInfo.IsList)
{
codeStatementCollection.AddRange(AssignListDataFromByteArrayStatement(classInfo, variableLengthFieldPropertyInfo, currentArrayIndexExpression, variableLengthFieldLengthExpression));
}
else
{
codeStatementCollection.AddRange(GetAssignFromByteArrayStatement(classInfo, variableLengthFieldPropertyInfo, currentArrayIndexExpression, variableLengthFieldLengthExpression));
}
return(codeStatementCollection);
}
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 void AddRange()
{
CodeStatement cs1 = new CodeStatement();
CodeStatement cs2 = new CodeStatement();
CodeStatement cs3 = new CodeStatement();
CodeStatementCollection coll1 = new CodeStatementCollection();
coll1.Add(cs1);
coll1.Add(cs2);
CodeStatementCollection coll2 = new CodeStatementCollection();
coll2.Add(cs3);
coll2.AddRange(coll1);
Assert.AreEqual(3, coll2.Count, "#1");
Assert.AreEqual(1, coll2.IndexOf(cs1), "#2");
Assert.AreEqual(2, coll2.IndexOf(cs2), "#3");
Assert.AreEqual(0, coll2.IndexOf(cs3), "#4");
CodeStatementCollection coll3 = new CodeStatementCollection();
coll3.Add(cs3);
coll3.AddRange(new CodeStatement[] { cs1, cs2 });
Assert.AreEqual(3, coll2.Count, "#5");
Assert.AreEqual(1, coll2.IndexOf(cs1), "#6");
Assert.AreEqual(2, coll2.IndexOf(cs2), "#7");
Assert.AreEqual(0, coll2.IndexOf(cs3), "#8");
}
public CodeStatementCollection GenerateInvocationCode(Activity activity, Dictionary <string, string> variables)
{
var errorActivity = (GenerateErrorActivity)activity;
var invocationCodeCollection = new CodeStatementCollection();
// add log
invocationCodeCollection.AddRange(AbstractActivityBuilder.LogActivity(errorActivity));
//add the input
invocationCodeCollection.AddRange(this.xslBuilder.Build(activity.InputBindings));
// Add the exception Call
invocationCodeCollection.Add(this.GenerateExceptionStatement(errorActivity));
return(invocationCodeCollection);
}
public virtual List <CodeMemberMethod> GenerateMethods(Activity activity, Dictionary <string, string> variables)
{
var activityMethod = new CodeMemberMethod
{
Attributes = MemberAttributes.Private | MemberAttributes.Final,
Name = VariableHelper.ToClassName(activity.Name) + "Call"
};
var dependantVariables = new XpathUtils().GetVariableNames(activity.InputBindings);
foreach (var variable in dependantVariables)
{
if (variables.ContainsKey(variable))
{
activityMethod.Parameters.Add(new CodeParameterDeclarationExpression(variables[variable], VariableHelper.ToVariableName(variable)));
}
}
activityMethod.ReturnType = new CodeTypeReference(this.GetReturnType(activity));
var invocationLogCodeCollection = new CodeStatementCollection();
invocationLogCodeCollection.AddRange(LogActivity(activity));
activityMethod.Statements.AddRange(invocationLogCodeCollection);
return(new List <CodeMemberMethod> {
activityMethod
});
}
public override List <CodeMemberMethod> GenerateMethods(Activity activity, Dictionary <string, string> variables)
{
var activityMethod = base.GenerateMethods(activity, variables);
var mapperActivity = (MapperActivity)activity;
var invocationCodeCollection = new CodeStatementCollection();
// Add the invocation
// TODO : need to put it in the parser to get the real ReturnType !!
string variableReturnType;
CodeVariableReferenceExpression parameter;
if (mapperActivity.XsdReference != null)
{
variableReturnType = this.GetReturnType(mapperActivity.XsdReference);
parameter = new CodeVariableReferenceExpression(variableReturnType);
}
else
{
// TODO : make a utils method in the parser to simplify this
variableReturnType = this.xsdParser.Parse(mapperActivity.ObjectXNodes, this.TargetNamespace(activity))[0].Type;
parameter = new CodeVariableReferenceExpression(mapperActivity.Parameters[0].Name);
}
var packageName = this.RemoveFinalType(variableReturnType);
// Add the mapping
invocationCodeCollection.AddRange(this.xslBuilder.Build(packageName, mapperActivity.InputBindings));
activityMethod[0].Statements.AddRange(invocationCodeCollection);
var code = new CodeMethodReturnStatement(parameter);
activityMethod[0].Statements.Add(code);
return(activityMethod);
}
public override List <CodeMemberMethod> GenerateMethods(Activity activity, Dictionary <string, string> variables)
{
var activityMethod = base.GenerateMethods(activity, variables);
var rdvPublishActivity = (RdvPublishActivity)activity;
var invocationCodeCollection = new CodeStatementCollection();
// Add the mapping
invocationCodeCollection.AddRange(this.xslBuilder.Build(rdvPublishActivity.InputBindings));
invocationCodeCollection.Add(new CodeSnippetStatement("string subject = \"" + rdvPublishActivity.Subject + "\";"));
// Add the invocation itself
var activityServiceReference = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), this.GetServiceFieldName(activity));
var initParameters = new List <string>
{
"subject"
};
var parameters = GenerateParameters(initParameters, rdvPublishActivity);
var codeInvocation = new CodeMethodInvokeExpression(activityServiceReference, "Send", parameters);
invocationCodeCollection.Add(codeInvocation);
activityMethod[0].Statements.AddRange(invocationCodeCollection);
return(activityMethod);
}
private CodeStatementCollection GenerateElementImpl(XmlReader reader, CodeExpression writerExpression)
{
CodeStatementCollection statements = new CodeStatementCollection();
statements.Add(new CodeMethodInvokeExpression(
writerExpression,
"WriteStartElement",
new CodePrimitiveExpression(reader.Prefix),
new CodePrimitiveExpression(reader.LocalName),
new CodePrimitiveExpression(reader.NamespaceURI)));
// Add code for attributes.
for (bool go = reader.MoveToFirstAttribute(); go; go = reader.MoveToNextAttribute())
{
statements.Add(new CodeMethodInvokeExpression(
writerExpression,
"WriteAttributeString",
new CodePrimitiveExpression(reader.Prefix),
new CodePrimitiveExpression(reader.LocalName),
new CodePrimitiveExpression(reader.NamespaceURI),
BuildValueExpression(reader.Value)));
}
if (reader.HasAttributes)
{
reader.MoveToElement();
}
if (reader.IsEmptyElement)
{
statements.AddRange(GenerateEndElementImpl(reader, writerExpression));
}
return(statements);
}
public override List <CodeMemberMethod> GenerateMethods(Activity activity, Dictionary <string, string> variables)
{
var activityMethod = base.GenerateMethods(activity, variables);
var sharedVariableActivity = (SharedVariableActivity)activity;
var invocationCodeCollection = new CodeStatementCollection();
// Add the input bindings
invocationCodeCollection.AddRange(this.xslBuilder.Build(sharedVariableActivity.InputBindings));
invocationCodeCollection.Add(new CodeSnippetStatement("var configName = \"" + sharedVariableActivity.VariableConfig + "\";"));
// Add the invocation itself
// TODO : need to put it in the parser to get the real ReturnType !!
//var variableName = VariableHelper.ToVariableName(sharedVariableActivity.Name);
var activityServiceReference = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), VariableHelper.ToVariableName(SharedVariableServiceBuilder.SharedVariableServiceName));
var parameters = GenerateParameters(new List <string> {
"configName"
}, sharedVariableActivity);
var codeInvocation = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(activityServiceReference, SharedVariableServiceBuilder.SetMethodName), parameters);
invocationCodeCollection.Add(codeInvocation);
activityMethod[0].Statements.AddRange(invocationCodeCollection);
return(activityMethod);
}
private CodeIterationStatement GenerateForRepeat(GroupActivity groupActivity, bool isRepeat)
{
var coreGroupMethodStatement = new CodeStatementCollection();
// get the core loop code
coreGroupMethodStatement.AddRange(this.GenerateCoreGroupMethod(groupActivity));
var coreOfTheLoop = new CodeStatement[coreGroupMethodStatement.Count];
coreGroupMethodStatement.CopyTo(coreOfTheLoop, 0);
string outCondition;
if (isRepeat)
{
outCondition = "!(" + this.xpathBuilder.Build(groupActivity.RepeatCondition) + ")";
}
else
{
outCondition = this.xpathBuilder.Build(groupActivity.RepeatCondition);
}
var whileLoop = new CodeIterationStatement(
new CodeSnippetStatement(string.Empty),
new CodeSnippetExpression(outCondition),
new CodeSnippetStatement(string.Empty),
coreOfTheLoop);
return(whileLoop);
}
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
var iterationElementSlotDeclaration = new CodeVariableDeclarationStatement("var", groupActivity.IterationElementSlot, new CodeVariableReferenceExpression(this.xpathBuilder.Build(groupActivity.Over) + "[" + groupActivity.IndexSlot + "]"));
coreGroupMethodStatement.Add(iterationElementSlotDeclaration);
// Get the core loop code
coreGroupMethodStatement.AddRange(this.GenerateCoreGroupMethod(groupActivity));
var coreOfTheLoop = new CodeStatement[coreGroupMethodStatement.Count];
coreGroupMethodStatement.CopyTo(coreOfTheLoop, 0);
// put it then in the loop
var forLoop = new CodeIterationStatement(
new CodeVariableDeclarationStatement(typeof(int), groupActivity.IndexSlot, new CodePrimitiveExpression(0)),
new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(groupActivity.IndexSlot), CodeBinaryOperatorType.LessThan, new CodeVariableReferenceExpression(this.xpathBuilder.Build(groupActivity.Over) + ".Length")),
new CodeAssignStatement(new CodeVariableReferenceExpression(groupActivity.IndexSlot), new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(groupActivity.IndexSlot), CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))),
coreOfTheLoop);
return(forLoop);
}
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());
}
/// <summary>
/// 生成条件语句
/// </summary>
/// <param name="savePar"></param>
/// <param name="CondiIndex"></param>
/// <param name="parameters"></param>
/// <param name="tryCodeStatementCollection"></param>
/// <param name="paramterQuery"></param>
/// <param name="sqls"></param>
/// <param name="sQLsCount"></param>
/// <param name="stringBuilderBlueprint"></param>
/// <param name="cONDITION_TYPE"></param>
/// <param name="customName"></param>
private void CreateCondition(
Dictionary <string, string> savePar
, int CondiIndex
, Dictionary <int, List <Dictionary <PARAMETER, string> > > parameters
, CodeStatementCollection tryCodeStatementCollection
, IParamterQuery paramterQuery
, List <SqlFormat> sqls
, int sQLsCount
, StringBuilderBlueprint stringBuilderBlueprint
, CONDITION_TYPE cONDITION_TYPE
, string customName = "")
{
if (!savePar.ContainsKey($"{CondiIndex}Par{customName}"))
{
StringBuilderBlueprint stringBuilderBlueprintTmp = new StringBuilderBlueprint($"par{CondiIndex}{customName}");
tryCodeStatementCollection.Add(stringBuilderBlueprintTmp.Create());
for (int parametersChildCount = 0; parametersChildCount < parameters[CondiIndex].Count; parametersChildCount++)
{
tryCodeStatementCollection.AddRange(paramterQuery.Create(
stringBuilderBlueprintTmp
, parameters[CondiIndex][parametersChildCount]
, cONDITION_TYPE));
}
savePar.Add($"{CondiIndex}Par{customName}", stringBuilderBlueprintTmp.Field);
}
if (sqls[sQLsCount].CondiIndex != -1)
{
tryCodeStatementCollection.Add(stringBuilderBlueprint.AppendField($"par{CondiIndex}{customName}"));
}
}
public override List <CodeMemberMethod> GenerateMethods(Activity activity, Dictionary <string, string> variables)
{
var activityMethod = base.GenerateMethods(activity, variables);
var javaActivity = (JavaActivity)activity;
var invocationCodeCollection = new CodeStatementCollection();
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);
var javaClassReference = new CodeVariableReferenceExpression {
VariableName = javaClassVariableName
};
//add input to java class
invocationCodeCollection.AddRange(this.GenerateInputCallOnJavaClass(javaActivity, javaClassReference));
// add call to 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));
activityMethod[0].Statements.AddRange(invocationCodeCollection);
return(activityMethod);
}
public void AddInitStatements(CodeStatementCollection statements)
{
if (_init == null)
{
_init = new CodeStatementCollection();
}
_init.AddRange(statements);
}
public void AddRange_Self()
{
CodeStatementCollection coll = new CodeStatementCollection();
coll.Add(new CodeStatement());
Assert.AreEqual(1, coll.Count, "#1");
coll.AddRange(coll);
Assert.AreEqual(2, coll.Count, "#2");
}
static CodeStatementCollection GenTestCases(CodeTypeDeclarationCollection types)
{
CodeStatementCollection statements = new CodeStatementCollection();
foreach (CodeTypeDeclaration typeDef in types)
{
statements.AddRange(TestCreateInstance(typeDef, typeDef.Name.ToLower()));
}
return(statements);
}
public override List <CodeMemberMethod> GenerateMethods(Activity activity, Dictionary <string, string> variables)
{
var activityMethod = base.GenerateMethods(activity, variables);
var callProcessActivity = (CallProcessActivity)activity;
var invocationCodeCollection = new CodeStatementCollection();
// Add the mapping
if (IsTheProcessInputRequiresAnImport(callProcessActivity))
{
invocationCodeCollection.AddRange(
this.xslBuilder.Build(
TargetAppNameSpaceService.myAppName() + "." + callProcessActivity.TibcoProcessToCall.InputAndOutputNameSpace,
callProcessActivity.InputBindings));
}
else
{
invocationCodeCollection.AddRange(
this.xslBuilder.Build(callProcessActivity.InputBindings));
}
// Add the invocation
var processToCallReference = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), VariableHelper.ToVariableName(callProcessActivity.TibcoProcessToCall.ProcessName));
var parameters = GenerateParameters(callProcessActivity);
var methodInvocation = new CodeMethodInvokeExpression(processToCallReference, GetCalledProcess(activity).StartActivity.Name, parameters);
if (this.GetReturnType(activity) == CSharpTypeConstant.SystemVoid)
{
invocationCodeCollection.Add(methodInvocation);
}
else
{
var code = new CodeMethodReturnStatement(methodInvocation);
invocationCodeCollection.Add(code);
}
activityMethod[0].Statements.AddRange(invocationCodeCollection);
return(activityMethod);
}
private CodeStatementCollection GenerateForCriticalSection(GroupActivity groupActivity)
{
// TODO ADD the myLock object as a field in the process
var invocationCodeCollection = new CodeStatementCollection();
invocationCodeCollection.Add(
new CodeSnippetStatement("lock (" + VariableHelper.ToVariableName(groupActivity.Name) + "Lock){"));
invocationCodeCollection.AddRange(this.GenerateCoreGroupMethod(groupActivity));
invocationCodeCollection.Add(new CodeSnippetStatement("}"));
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 GenerateConstructorCodeStatement(Activity groupActivity)
{
var statements = new CodeStatementCollection();
foreach (var activity in ((GroupActivity)groupActivity).Activities)
{
var activityBuilder = activityBuilderFactory.Get(activity.Type);
statements.AddRange(activityBuilder.GenerateConstructorCodeStatement(activity));
}
return(statements);
}
/// <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 void SerializeContentProperty(IDesignerSerializationManager manager, object component,
PropertyDescriptor descriptor, CodeStatementCollection statements)
{
CodePropertyReferenceExpression propRef = new CodePropertyReferenceExpression();
propRef.PropertyName = descriptor.Name;
object value = descriptor.GetValue(component);
ExpressionContext expressionCtx = manager.Context[typeof(ExpressionContext)] as ExpressionContext;
if (expressionCtx != null && expressionCtx.PresetValue == component)
{
propRef.TargetObject = expressionCtx.Expression;
}
else
{
manager.Context.Push(new CodeStatementCollection());
propRef.TargetObject = TryGetCachedExpression(manager, component, propRef, value);
manager.Context.Pop();
}
CodeDomSerializer serializer = manager.GetSerializer(value.GetType(), typeof(CodeDomSerializer)) as CodeDomSerializer;
if (propRef.TargetObject != null && serializer != null)
{
// request full serialization (presetvalue == instance)
//
manager.Context.Push(new ExpressionContext(propRef, propRef.GetType(), component, value));
object serialized = serializer.Serialize(manager, value);
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));
}
}
}
public override List <CodeMemberMethod> GenerateMethods(Activity activity, Dictionary <string, string> variables)
{
var activityMethod = base.GenerateMethods(activity, variables);
var write2LogActivity = (WriteToLogActivity)activity;
var invocationCodeCollection = new CodeStatementCollection();
//add the input
invocationCodeCollection.AddRange(this.xslBuilder.Build(write2LogActivity.InputBindings));
//Add the logger call
invocationCodeCollection.Add(this.GenerateLoggerCodeInvocation(write2LogActivity));
activityMethod[0].Statements.AddRange(invocationCodeCollection);
return(activityMethod);
}
public override List <CodeMemberMethod> GenerateMethods(Activity activity, Dictionary <string, string> variables)
{
var activityMethods = base.GenerateMethods(activity, variables);
var invocationCodeCollection = new CodeStatementCollection();
// Add the mapping
invocationCodeCollection.AddRange(this.xslBuilder.Build(activity.InputBindings));
// Add the invocation new Timer (timerValue)
var code = new CodeSnippetStatement("new Timer(" + activity.Parameters[0].Name + ");");
invocationCodeCollection.Add(code);
activityMethods[0].Statements.AddRange(invocationCodeCollection);
return(activityMethods);
}
private CodeStatementCollection GenerateCoreGroupMethod(GroupActivity groupActivity)
{
var invocationCodeCollection = new CodeStatementCollection();
try
{
invocationCodeCollection.AddRange(this.coreProcessBuilder.GenerateMainCodeStatement(groupActivity.Transitions, "start", null, this.activityNameToServiceNameDictionnary));
}
catch (Exception e)
{
invocationCodeCollection.Add(new CodeSnippetStatement("// TODO : Unable to Generate code for this Group"));
Log.Error("################ Unable to Generate code for this Group :" + groupActivity.Name, e);
}
return(invocationCodeCollection);
}
public CodeStatementCollection GenerateMainMethodBody(TibcoBWProcess tibcoBwProcessToGenerate, Dictionary <string, CodeStatementCollection> activityNameToServiceNameDictionnary)
{
var statements = new CodeStatementCollection();
if (tibcoBwProcessToGenerate.Transitions != null)
{
if (tibcoBwProcessToGenerate.StarterActivity != null)
{
//foreach (var parameter in tibcoBwProcessToGenerate.StarterActivity.Parameters)
//{
//statements.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(parameter.Type), parameter.Name));
//}
}
statements.AddRange(this.coreProcessBuilder.GenerateMainCodeStatement(tibcoBwProcessToGenerate.Transitions, tibcoBwProcessToGenerate.StartingPoint, null, activityNameToServiceNameDictionnary));
}
return(statements);
}
