/// <summary>
/// Builds the method.
/// </summary>
public void Build()
{
result = new CodeMemberMethod();
result.Name = "InitializeInitialStates";
result.Attributes = MemberAttributes.Private;
CodeThisReferenceExpression thisReference = new CodeThisReferenceExpression();
CodeFieldReferenceExpression stateField;
CodeFieldReferenceExpression initialStateField;
CodePropertyReferenceExpression initialStateProperty;
foreach (DictionaryEntry entry in stateInitialStates)
{
stateField = new CodeFieldReferenceExpression(
thisReference, "state" + entry.Key.ToString());
initialStateField = new CodeFieldReferenceExpression(
thisReference, "state" + entry.Value.ToString());
initialStateProperty = new CodePropertyReferenceExpression(
stateField, "InitialState");
result.Statements.Add(new CodeAssignStatement(
initialStateProperty, initialStateField));
}
}
public void TypeReferenceExpressionTest()
{
StringBuilder sb = new StringBuilder();
using (StringWriter sw = new StringWriter(sb)) {
CodeThisReferenceExpression thisRef = new CodeThisReferenceExpression();
CodeFieldReferenceExpression parentField = new CodeFieldReferenceExpression();
parentField.TargetObject = thisRef;
parentField.FieldName = "Parent";
CodeBinaryOperatorExpression expression = new CodeBinaryOperatorExpression(
parentField,
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null));
Assert.AreEqual("(Not (Me.Parent) Is Nothing)", Generate(expression, sw), "#1");
sw.Close();
}
sb = new StringBuilder();
using (StringWriter sw = new StringWriter(sb)) {
CodeThisReferenceExpression thisRef = new CodeThisReferenceExpression();
CodeFieldReferenceExpression parentField = new CodeFieldReferenceExpression();
parentField.TargetObject = thisRef;
parentField.FieldName = "Parent";
CodeBinaryOperatorExpression expression = new CodeBinaryOperatorExpression(
new CodePrimitiveExpression(null),
CodeBinaryOperatorType.IdentityInequality,
parentField);
Assert.AreEqual("(Not (Me.Parent) Is Nothing)", Generate(expression, sw), "#2");
sw.Close();
}
}
static void AddOutletProperty(CodeTypeReference outletAtt, CodeTypeDeclaration type, string name,
CodeTypeReference typeRef)
{
var fieldName = "__impl_" + name;
var field = new CodeMemberField(typeRef, fieldName);
var prop = new CodeMemberProperty()
{
Name = name,
Type = typeRef
};
AddAttribute(prop.CustomAttributes, outletAtt, name);
var setValue = new CodePropertySetValueReferenceExpression();
var thisRef = new CodeThisReferenceExpression();
var fieldRef = new CodeFieldReferenceExpression(thisRef, fieldName);
prop.SetStatements.Add(new CodeAssignStatement(fieldRef, setValue));
prop.GetStatements.Add(new CodeMethodReturnStatement(fieldRef));
prop.Attributes = field.Attributes = (prop.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Private;
type.Members.Add(prop);
type.Members.Add(field);
}
/// <summary>
/// Generates control fields
/// </summary>
/// <param name="source">The source.</param>
/// <param name="classType">Type of the class.</param>
/// <param name="method">The initialize method.</param>
/// <param name="generateField">if set to <c>true</c> [generate field].</param>
/// <returns></returns>
public override CodeExpression Generate(DependencyObject source, CodeTypeDeclaration classType, CodeMemberMethod method, bool generateField)
{
CodeExpression fieldReference = new CodeThisReferenceExpression();
CodeComHelper.GenerateBrushField(method, fieldReference, source, Control.BackgroundProperty);
CodeComHelper.GenerateBrushField(method, fieldReference, source, Control.BorderBrushProperty);
CodeComHelper.GenerateThicknessField(method, fieldReference, source, Control.BorderThicknessProperty);
CodeComHelper.GenerateThicknessField(method, fieldReference, source, Control.PaddingProperty);
CodeComHelper.GenerateBrushField(method, fieldReference, source, Control.ForegroundProperty);
CodeComHelper.GenerateField <bool>(method, fieldReference, source, UIRoot.IsTabNavigationEnabledProperty);
CodeComHelper.GenerateColorField(method, fieldReference, source, UIRoot.MessageBoxOverlayProperty);
CodeComHelper.GenerateTemplateStyleField(classType, method, fieldReference, source, FrameworkElement.StyleProperty);
Control control = source as Control;
if (!CodeComHelper.IsDefaultValue(source, Control.FontFamilyProperty) ||
!CodeComHelper.IsDefaultValue(source, Control.FontSizeProperty) ||
!CodeComHelper.IsDefaultValue(source, Control.FontStyleProperty) ||
!CodeComHelper.IsDefaultValue(source, Control.FontWeightProperty))
{
FontGenerator.Instance.AddFont(control.FontFamily, control.FontSize, control.FontStyle, control.FontWeight, method);
}
CodeComHelper.GenerateFontFamilyField(method, fieldReference, source, Control.FontFamilyProperty);
CodeComHelper.GenerateFieldDoubleToFloat(method, fieldReference, source, Control.FontSizeProperty);
CodeComHelper.GenerateFontStyleField(method, fieldReference, source, Control.FontStyleProperty, Control.FontWeightProperty);
return(fieldReference);
}
/// <summary>
/// Builds the method.
/// </summary>
public void Build()
{
result = new CodeMemberMethod();
result.Name = "InitializeActions";
result.Attributes = MemberAttributes.Private;
CodeThisReferenceExpression thisReference =
new CodeThisReferenceExpression();
CodeFieldReferenceExpression actionField;
CodeDelegateCreateExpression delegateCreate;
CodeTypeReference actionHandlerReference =
new CodeTypeReference(typeof(ActionHandler));
foreach (string name in actions)
{
actionField = new CodeFieldReferenceExpression(thisReference,
"action" + name);
delegateCreate = new CodeDelegateCreateExpression(
actionHandlerReference, thisReference, name);
result.Statements.Add(
new CodeAssignStatement(actionField, delegateCreate));
}
}
/// <summary>
/// Adds a property to the given type which raises PropertyChange Notifications when the property is set.
/// </summary>
/// <param name="type">The type to add property to.</param>
/// <param name="propertyType">Type of the property.</param>
/// <param name="propertyName">Name of the property.</param>
/// <returns>Added property.</returns>
protected CodeMemberProperty AddPropertyWithChangeNotification(CodeTypeDeclaration type, CodeTypeReference propertyType, string propertyName)
{
// Declare a private property to be the backing field
string backingFieldName = string.Format(CultureInfo.InvariantCulture, "backing{0}", propertyName);
type.AddField(propertyType, backingFieldName);
CodeMemberProperty propertyWithChangeNotifications = new CodeMemberProperty()
{
Name = propertyName,
Type = propertyType,
Attributes = MemberAttributes.Public
};
CodeThisReferenceExpression thisReference = new CodeThisReferenceExpression();
// this will hold the reference to the backing field
CodeFieldReferenceExpression backingFieldReference = new CodeFieldReferenceExpression(thisReference, backingFieldName);
// add a getter which returns the backing field
propertyWithChangeNotifications.GetStatements.Add(new CodeMethodReturnStatement(backingFieldReference));
// add a statement which sets the value of the backing field
CodeAssignStatement setStatement = new CodeAssignStatement(backingFieldReference, new CodeArgumentReferenceExpression("value"));
// This will call the RaisePropertyChanged method passing in the propertyName
CodeMethodInvokeExpression invokePropertyChangeNotifier = new CodeMethodInvokeExpression(thisReference, "RaisePropertyChanged", new CodeExpression[] { new CodePrimitiveExpression(propertyName) });
propertyWithChangeNotifications.SetStatements.Add(setStatement);
propertyWithChangeNotifications.SetStatements.Add(invokePropertyChangeNotifier);
type.Members.Add(propertyWithChangeNotifications);
return(propertyWithChangeNotifications);
}
public static void GenerateRepositoryGetAllObjectsMethod(IClassMap classMap, CodeTypeDeclaration classDecl)
{
CodeMemberMethod methodMember = new CodeMemberMethod();
methodMember.Name = GetRepositoryGetAllObjectsMethodName(classMap);
CodeTypeReference typeReference = new CodeTypeReference(classMap.GetName());
CodeTypeReference listTypeReference = new CodeTypeReference(typeof(IList));
methodMember.ReturnType = listTypeReference;
methodMember.Attributes = MemberAttributes.Public;
CodeThisReferenceExpression thisExp = new CodeThisReferenceExpression();
CodeFieldReferenceExpression contextVar = new CodeFieldReferenceExpression(thisExp, "context");
CodeTypeOfExpression typeOfExp = new CodeTypeOfExpression(typeReference);
CodeMethodInvokeExpression listInit = new CodeMethodInvokeExpression(contextVar, "GetObjects", new CodeExpression[] { typeOfExp });
CodeVariableDeclarationStatement listVarDecl = new CodeVariableDeclarationStatement(typeof(IList), "list", listInit);
CodeVariableReferenceExpression listVar = new CodeVariableReferenceExpression("list");
methodMember.Statements.Add(listVarDecl);
CodeMethodReturnStatement returnStmt = new CodeMethodReturnStatement(listVar);
methodMember.Statements.Add(returnStmt);
classDecl.Members.Add(methodMember);
}
private CodeMemberMethod GenerateDetachCore(IEnumerable <IReference> implementingReferences)
{
var detachCore = new CodeMemberMethod()
{
Name = "DetachCore",
Attributes = MemberAttributes.Family | MemberAttributes.Override
};
var thisRef = new CodeThisReferenceExpression();
foreach (var reference in implementingReferences)
{
if (reference.UpperBound == 1)
{
detachCore.Statements.Add(new CodeRemoveEventStatement(parentRef, reference.Name.ToPascalCase() + "Changed",
new CodeMethodReferenceExpression(thisRef, "PropagateValueChanges")));
}
else
{
detachCore.Statements.Add(new CodeRemoveEventStatement(new CodeMethodInvokeExpression(
new CodePropertyReferenceExpression(parentRef, reference.Name.ToPascalCase()), "AsNotifiable"), "CollectionChanged",
new CodeMethodReferenceExpression(thisRef, "PropagateCollectionChanges")));
}
}
return(detachCore);
}
public static void GenerateRepositoryDeleteObjectMethod(IClassMap classMap, CodeTypeDeclaration classDecl)
{
CodeMemberMethod methodMember = new CodeMemberMethod();
methodMember.Name = GetRepositoryDeleteObjectMethodName(classMap);
CodeTypeReference typeReference = new CodeTypeReference(classMap.GetName());
methodMember.Attributes = MemberAttributes.Public;
CodeParameterDeclarationExpression parameter = new CodeParameterDeclarationExpression(typeReference, MakeCamelCase(classMap.GetName()));
methodMember.Parameters.Add(parameter);
CodeArgumentReferenceExpression argExp = new CodeArgumentReferenceExpression(MakeCamelCase(classMap.GetName()));
CodeThisReferenceExpression thisExp = new CodeThisReferenceExpression();
CodeFieldReferenceExpression contextVar = new CodeFieldReferenceExpression(thisExp, "context");
CodeMethodInvokeExpression deleteCall = new CodeMethodInvokeExpression(contextVar, "DeleteObject", new CodeExpression[] { argExp });
methodMember.Statements.Add(deleteCall);
CodeMethodInvokeExpression commitCtx = new CodeMethodInvokeExpression(contextVar, "Commit", new CodeExpression[] {});
methodMember.Statements.Add(commitCtx);
classDecl.Members.Add(methodMember);
}
private CodeMemberMethod GenerateDetachCore(IEnumerable <IReference> implementingReferences, ITransformationContext context)
{
var detachCore = new CodeMemberMethod()
{
Name = "DetachCore",
Attributes = MemberAttributes.Family | MemberAttributes.Override
};
var thisRef = new CodeThisReferenceExpression();
var reference2Property = Rule <Reference2Property>();
foreach (var reference in implementingReferences)
{
var property = context.Trace.ResolveIn(reference2Property, reference);
if (reference.UpperBound == 1)
{
detachCore.Statements.Add(new CodeRemoveEventStatement(parentRef, property.Name + "Changed",
new CodeMethodReferenceExpression(thisRef, "PropagateValueChanges")));
}
else
{
detachCore.Statements.Add(new CodeRemoveEventStatement(new CodeMethodInvokeExpression(
new CodePropertyReferenceExpression(parentRef, property.Name), "AsNotifiable"), "CollectionChanged",
new CodeMethodReferenceExpression(thisRef, "PropagateCollectionChanges")));
}
}
return(detachCore);
}
private CodeMemberProperty PropertyMapToCodeMemberProperty(IPropertyMap propertyMap)
{
CodeMemberProperty propertyMember = new CodeMemberProperty();
propertyMember.Name = propertyMap.Name;
CodeTypeReference typeReference = new CodeTypeReference(propertyMap.DataType);
propertyMember.Type = typeReference;
propertyMember.Attributes = MemberAttributes.Public;
string fieldName = propertyMap.GetFieldName();
CodeThisReferenceExpression thisReferenceExpression = new CodeThisReferenceExpression();
CodeFieldReferenceExpression fieldReferenceExpression = new CodeFieldReferenceExpression(thisReferenceExpression, fieldName);
propertyMember.HasGet = true;
CodeMethodReturnStatement getMethodReturnStatement = new CodeMethodReturnStatement(fieldReferenceExpression);
propertyMember.GetStatements.Add(getMethodReturnStatement);
if (!propertyMap.IsReadOnly)
{
propertyMember.HasSet = true;
CodeVariableReferenceExpression valueReferenceExpression = new CodeVariableReferenceExpression("value");
CodeAssignStatement setMethodAssignStatement = new CodeAssignStatement(fieldReferenceExpression, valueReferenceExpression);
propertyMember.SetStatements.Add(setMethodAssignStatement);
}
return(propertyMember);
}
internal void UCodeAddReportProperty(string reportInstance, string reportName, string reportTitle,
string reportHeadline, string reportFilePath = "", string reportMemberName = "unifiedReport")
{
CodeMemberProperty uCodeProperty = new CodeMemberProperty();
uCodeProperty.Attributes = MemberAttributes.Public;
reportFilePath = string.IsNullOrEmpty(reportFilePath) ? Directory.GetParent(Directory.GetCurrentDirectory()).Parent.Parent.FullName : reportFilePath;
uCodeProperty.Name = reportInstance;
uCodeProperty.Type = new CodeTypeReference(Type.GetType("UnifiedFramework.UnifiedReports.UnifiedReports, UnifiedFramework"));
uCodeProperty.HasGet = true;
uCodeProperty.HasSet = false;
string localReportFilepath = "\"" + reportFilePath + "\"";
string localReportName = "\"" + reportName + "\"";
string localReportTitle = "\"" + reportTitle + "\"";
string localReportHeadLine = "\"" + reportHeadline + "\"";
var ucodeMethodOne = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(
Type.GetType("UnifiedFrameWork.Controller.DirectoryHandler,UnifiedFrameWork")), "DirectoryCreation", new CodePrimitiveExpression("UnifiedReport"));
CodeExpression uCodeOjectCreate = new CodeObjectCreateExpression(new CodeTypeReference("UnifiedReports"),
new CodePrimitiveExpression(Path.Combine(reportFilePath, reportName + ".html")), new CodePrimitiveExpression(true));
CodeExpression thisExpr = new CodeThisReferenceExpression();
uCodeProperty.GetStatements.Add(new CodeConditionStatement(new CodeSnippetExpression("unifiedReport==null"), new CodeStatement[] {
new CodeVariableDeclarationStatement(typeof(string), "reportFilePath", ucodeMethodOne),
new CodeExpressionStatement(new CodeSnippetExpression(reportMemberName + "= new UnifiedReports(Path.Combine(reportFilePath," + localReportName + "+" + "\".html\"), true)")),
new CodeExpressionStatement(new CodeSnippetExpression(reportMemberName + ".Config().DocumentTitle(" + localReportTitle + ").ReportName(" + localReportName + ").ReportHeadline(" + localReportHeadLine + ")"))
}));
uCodeProperty.GetStatements.Add(new CodeSnippetExpression("return " + reportMemberName));
//mpBriefcaseName.GetStatements.Add(new CodeSnippetExpression("return m_BriefcaseName"));
targetClass.Members.Add(uCodeProperty);
}
public static void AddOutletProperty(CodeTypeDeclaration type, string name, CodeTypeReference typeRef)
{
var fieldName = "__mt_" + name;
var field = new CodeMemberField(typeRef, fieldName);
var prop = new CodeMemberProperty()
{
Name = name,
Type = typeRef
};
prop.CustomAttributes.Add(
new CodeAttributeDeclaration("MonoTouch.Foundation.Connect",
new CodeAttributeArgument(new CodePrimitiveExpression(name))));
var setValue = new CodePropertySetValueReferenceExpression();
var thisRef = new CodeThisReferenceExpression();
var fieldRef = new CodeFieldReferenceExpression(thisRef, fieldName);
var setNativeRef = new CodeMethodReferenceExpression(thisRef, "SetNativeField");
var getNativeRef = new CodeMethodReferenceExpression(thisRef, "GetNativeField");
var namePrimitive = new CodePrimitiveExpression(name);
var invokeGetNative = new CodeMethodInvokeExpression(getNativeRef, namePrimitive);
prop.SetStatements.Add(new CodeAssignStatement(fieldRef, setValue));
prop.SetStatements.Add(new CodeMethodInvokeExpression(setNativeRef, namePrimitive, setValue));
prop.GetStatements.Add(new CodeAssignStatement(fieldRef, new CodeCastExpression(typeRef, invokeGetNative)));
prop.GetStatements.Add(new CodeMethodReturnStatement(fieldRef));
prop.Attributes = field.Attributes = (prop.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Private;
type.Members.Add(prop);
type.Members.Add(field);
}
private static CodeMemberProperty GenerateProperty(GenerationContext context, @class cls, property property)
{
String propertyType = context.ConvertType(property.type, true);
String propertyName = NamingHelper.GenerateDotNetName(String.Empty, property.name);
// Define various references
CodeTypeReference typeReference = new CodeTypeReference(propertyType);
CodeThisReferenceExpression thisReferenceExpression = new CodeThisReferenceExpression();
CodeTypeReferenceExpression typeReferenceExpression = new CodeTypeReferenceExpression("ObjectiveCRuntime");
// Define the property
CodeMemberProperty memberProperty = new CodeMemberProperty();
memberProperty.Attributes = MemberAttributes.Public;
memberProperty.Name = propertyName;
memberProperty.Type = typeReference;
// Generate getter
switch (property.access)
{
case "r":
case "rw":
{
String selector = NamingHelper.GenerateObjCName(property.name);
CodeMethodReferenceExpression methodReferenceExpression = new CodeMethodReferenceExpression(typeReferenceExpression, "SendMessage");
methodReferenceExpression.TypeArguments.Add(typeReference);
CodeMethodInvokeExpression invokeExpression = new CodeMethodInvokeExpression(methodReferenceExpression, thisReferenceExpression, new CodePrimitiveExpression(selector));
CodeMethodReturnStatement returnStatement = new CodeMethodReturnStatement(invokeExpression);
memberProperty.GetStatements.Add(returnStatement);
break;
}
default:
break;
}
// Generate setter
switch (property.access)
{
case "rw":
case "w":
{
String selector = "set" + propertyName + ":";
CodeMethodReferenceExpression methodReferenceExpression = new CodeMethodReferenceExpression(typeReferenceExpression, "SendMessage");
CodeMethodInvokeExpression invokeExpression = new CodeMethodInvokeExpression(methodReferenceExpression, thisReferenceExpression, new CodePrimitiveExpression(selector), new CodeVariableReferenceExpression("value"));
CodeExpressionStatement expressionStatement = new CodeExpressionStatement(invokeExpression);
memberProperty.SetStatements.Add(expressionStatement);
break;
}
default:
break;
}
return(memberProperty);
}
internal void AddGetStatements(CodeStatementCollection getStatements)
{
CodeThisReferenceExpression codeThisReferenceExpression = CodeDomHelper.This();
CodeExpression[] codeExpressionArray = new CodeExpression[] { CodeDomHelper.CreateFieldReference("WildCard", "DefaultWildCard") };
getStatements.Add(new CodeMethodReturnStatement(CodeDomHelper.CreateMethodCall(codeThisReferenceExpression, "GetWildCards", codeExpressionArray)));
}
private CodeExpression[] GetExpressionsC2J(GMethod method, string uName)
{
int offset = method.IsConstructor ? 3 : 2;
var expressions = new CodeExpression[method.Parameters.Count + offset];
if (method.IsStatic || method.IsConstructor)
{
expressions[0] = new CodeFieldReferenceExpression(ProxyTypeEx, "staticClass");
}
else
{
expressions[0] = new CodeThisReferenceExpression();
}
expressions[1] = new CodeFieldReferenceExpression(ProxyTypeEx, uName);
if (method.IsConstructor)
{
expressions[2] = new CodeThisReferenceExpression();
}
for (int i = 0; i < method.Parameters.Count; i++)
{
GType parameter = method.Parameters[i];
string paramName = method.ParameterNames[i];
CodeExpression invokeExpression = new CodeVariableReferenceExpression(paramName);
CodeMethodInvokeExpression conversionExpression = CreateConversionExpressionC2JParam(parameter,
invokeExpression);
expressions[i + offset] = conversionExpression;
}
return(expressions);
}
/// <summary>
/// Builds the method.
/// </summary>
public void Build()
{
result = new CodeMemberMethod();
result.Name = "InitializeRelationships";
result.Attributes = MemberAttributes.Private;
CodeThisReferenceExpression thisReference = new CodeThisReferenceExpression();
CodeFieldReferenceExpression substateField;
CodeFieldReferenceExpression superstateField;
CodePropertyReferenceExpression substatesProperty;
CodeMethodInvokeExpression addInvoke;
foreach (DictionaryEntry entry in stateRelationships)
{
substateField = new CodeFieldReferenceExpression(
thisReference, "state" + entry.Key.ToString());
superstateField = new CodeFieldReferenceExpression(
thisReference, "state" + entry.Value.ToString());
substatesProperty = new CodePropertyReferenceExpression(
superstateField, "Substates");
addInvoke = new CodeMethodInvokeExpression(substatesProperty,
"Add", new CodeExpression[] { substateField });
result.Statements.Add(addInvoke);
}
}
public TypescriptThisReferenceExpression(
CodeThisReferenceExpression codeExpression,
CodeGeneratorOptions options)
{
_codeExpression = codeExpression;
_options = options;
System.Diagnostics.Debug.WriteLine("TypescriptThisReferenceExpression Created");
}
/// <summary>
/// Generates control fields
/// </summary>
/// <param name="source">The source.</param>
/// <param name="classType">Type of the class.</param>
/// <param name="initMethod">The initialize method.</param>
/// <param name="generateField">if set to <c>true</c> [generate field].</param>
/// <returns></returns>
public override CodeExpression Generate(DependencyObject source, CodeTypeDeclaration classType, CodeMemberMethod initMethod, bool generateField)
{
CodeExpression fieldReference = new CodeThisReferenceExpression();
CodeComHelper.GenerateTemplateStyleField(classType, initMethod, fieldReference, source, FrameworkElement.StyleProperty);
return(fieldReference);
}
private CodeExpression GetEqualsExpression(CodeThisReferenceExpression codeThis, CodeVariableReferenceExpression codeThat, DiagnosticSpecification.Field field)
{
return(new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(object)), "Equals"),
new CodePropertyReferenceExpression(codeThis, field.FieldName.ToCamelCase()),
new CodePropertyReferenceExpression(codeThat, field.FieldName.ToCamelCase())
));
}
public static CodeFieldReferenceExpression fCreateFieldRef(string name)
{
var _this = new CodeThisReferenceExpression();
var _refStateProperty
= new CodeFieldReferenceExpression(_this, name);
return(_refStateProperty);
}
private static void GenerateHostResolveParameterValueLookup(string nameValue, CodeMemberField field, CodeStatementCollection statements, CodeVariableReferenceExpression valueAcquired, CodeTypeReference typeReference, CodeStatement setValueAcquired, string typeValue)
{
CodePropertyReferenceExpression callSite = new CodeThisReferenceExpression().Prop("Host");
CodeVariableDeclarationStatement declaration = new CodeVariableDeclarationStatement(typeof(string).Ref(), "parameterValue", callSite.Call("ResolveParameterValue", new CodeExpression[] { "Property".Prim(), "PropertyDirectiveProcessor".Prim(), nameValue.Prim() }));
CodeVariableReferenceExpression expression2 = declaration.Ref();
CodeVariableDeclarationStatement statement2 = new CodeVariableDeclarationStatement(typeof(TypeConverter).Ref(), "tc", typeof(TypeDescriptor).Expr().Call("GetConverter", new CodeExpression[] { new CodeTypeOfExpression(typeReference) }));
statements.Add(new CodeConditionStatement(valueAcquired.VEquals(false.Prim()), new CodeStatement[] { declaration, new CodeConditionStatement(typeof(string).Expr().Call("IsNullOrEmpty", new CodeExpression[] { expression2 }).VEquals(false.Prim()), new CodeStatement[] { statement2, new CodeConditionStatement(statement2.Ref().NotNull().And(statement2.Ref().Call("CanConvertFrom", new CodeExpression[] { new CodeTypeOfExpression(typeof(string).Ref()) })), new CodeStatement[] { field.Ref().Assign(new CodeCastExpression(typeReference, statement2.Ref().Call("ConvertFrom", new CodeExpression[] { expression2 }))), setValueAcquired }, new CodeStatement[] { GenerateReportTypeMismatch(nameValue, typeValue) }) }) }));
}
private bool HandleDynamic(CodeThisReferenceExpression obj, Context ctx)
{
if (string.IsNullOrEmpty(ThisReferenceKeyword))
{
return(false);
}
ctx.Writer.Write(ThisReferenceKeyword);
return(true);
}
internal virtual CodeExpression BuildInvokeAsync(string messageName, CodeArrayCreateExpression paramsArray, CodeExpression delegateField, CodeExpression userStateVar)
{
CodeThisReferenceExpression ethis = new CodeThisReferenceExpression();
CodeMethodInvokeExpression inv2 = new CodeMethodInvokeExpression(ethis, "InvokeAsync");
inv2.Parameters.Add(new CodePrimitiveExpression(messageName));
inv2.Parameters.Add(paramsArray);
inv2.Parameters.Add(delegateField);
inv2.Parameters.Add(userStateVar);
return(inv2);
}
/// <summary>
/// Builds the method.
/// </summary>
public void Build()
{
result = new CodeMemberMethod();
result.Name = "InitializeStates";
result.Attributes = MemberAttributes.Private;
CodeThisReferenceExpression thisReference = new CodeThisReferenceExpression();
CodeFieldReferenceExpression stateField;
CodeDelegateCreateExpression delegateCreate;
CodeVariableDeclarationStatement delegateVariable;
CodeObjectCreateExpression stateCreate;
CodeTypeReference enumReference = new CodeTypeReference("StateID");
foreach (string name in states)
{
delegateCreate =
new CodeDelegateCreateExpression(
new CodeTypeReference(typeof(EntryHandler)),
thisReference, "Entry" + name);
delegateVariable = new CodeVariableDeclarationStatement(
typeof(EntryHandler), "en" + name, delegateCreate);
result.Statements.Add(delegateVariable);
delegateCreate =
new CodeDelegateCreateExpression(
new CodeTypeReference(typeof(ExitHandler)),
thisReference, "Exit" + name);
delegateVariable = new CodeVariableDeclarationStatement(
typeof(ExitHandler), "ex" + name, delegateCreate);
result.Statements.Add(delegateVariable);
stateField = new CodeFieldReferenceExpression(thisReference,
"state" + name);
CodeFieldReferenceExpression enumFieldReference = new CodeFieldReferenceExpression(
new CodeTypeReferenceExpression("StateID"), name);
System.CodeDom.CodeCastExpression enumCast =
new CodeCastExpression(typeof(int), enumFieldReference);
CodeExpression[] parameters =
{
enumCast,
new CodeVariableReferenceExpression("en" + name),
new CodeVariableReferenceExpression("ex" + name)
};
stateCreate = new CodeObjectCreateExpression(typeof(State), parameters);
result.Statements.Add(new CodeAssignStatement(stateField, stateCreate));
}
}
/// <include file='doc\ComponentCodeDomSerializer.uex' path='docs/doc[@for="ComponentCodeDomSerializer.SerializeSupportInitialize"]/*' />
/// <devdoc>
/// This emits a method invoke to ISupportInitialize.
/// </devdoc>
private void SerializeSupportInitialize(IDesignerSerializationManager manager, CodeStatementCollection statements, object value, string methodName)
{
Debug.WriteLineIf(traceSerialization.TraceVerbose, "ComponentCodeDomSerializer::SerializeSupportInitialize");
Debug.Indent();
string name = manager.GetName(value);
if (name == null)
{
IReferenceService referenceService = (IReferenceService)manager.GetService(typeof(IReferenceService));
if (referenceService != null)
{
name = referenceService.GetName(value);
}
}
Debug.WriteLineIf(traceSerialization.TraceVerbose, name + "." + methodName);
// Assemble a cast to ISupportInitialize, and then invoke the method.
//
CodeExpression targetExpr = null;
IDesignerHost host = (IDesignerHost)manager.GetService(typeof(IDesignerHost));
if (host != null && host.RootComponent == value)
{
targetExpr = new CodeThisReferenceExpression();
}
else
{
targetExpr = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), name);
}
CodeTypeReference type = new CodeTypeReference(typeof(ISupportInitialize));
CodeCastExpression castExp = new CodeCastExpression(type, targetExpr);
CodeMethodReferenceExpression method = new CodeMethodReferenceExpression(castExp, methodName);
CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression();
methodInvoke.Method = method;
CodeExpressionStatement statement = new CodeExpressionStatement(methodInvoke);
if (methodName == "BeginInit")
{
statement.UserData["statement-ordering"] = "begin";
}
else
{
statement.UserData["statement-ordering"] = "end";
}
statements.Add(statement);
Debug.Unindent();
}
public void CreateRuleSet()
{
createRuleSet = new RuleSet("CreateRackRate");
// Define property and activity reference expressions through CodeDom functionality
CodeThisReferenceExpression thisRef = new CodeThisReferenceExpression();
CodeFieldReferenceExpression RoleNameRef = new CodeFieldReferenceExpression(thisRef, "RoleName");
CodeFieldReferenceExpression ValidityRef = new CodeFieldReferenceExpression(thisRef, "Validity");
CodeTypeReferenceExpression RoleEnumRef = new CodeTypeReferenceExpression(typeof(RoleType));
CodeFieldReferenceExpression OutputRef = new CodeFieldReferenceExpression(thisRef, "Output");
// IF RoleType != "SalesAdmin" AND ValidityLimit > 3
// THEN Output = "invalid"
Rule createRackRateRule = new Rule("CreatRackRateRule");
createRuleSet.Rules.Add(createRackRateRule);
// define first predicate: RoleType != "SalesAdmin"
CodeBinaryOperatorExpression ruleRoleName = new CodeBinaryOperatorExpression();
ruleRoleName.Left = RoleNameRef;
ruleRoleName.Operator = CodeBinaryOperatorType.IdentityInequality;
ruleRoleName.Right = new CodeFieldReferenceExpression(RoleEnumRef, "SalesAdmin");
// define second predicate: Validity > 3
CodeBinaryOperatorExpression ruleValidityTest = new CodeBinaryOperatorExpression();
ruleValidityTest.Left = ValidityRef;
ruleValidityTest.Operator = CodeBinaryOperatorType.ValueEquality;
ruleValidityTest.Right = new CodePrimitiveExpression("3");
// join the first two predicates into a single condition
CodeBinaryOperatorExpression ruleCondition = new CodeBinaryOperatorExpression();
ruleCondition.Left = ruleRoleName;
ruleCondition.Operator = CodeBinaryOperatorType.BooleanAnd;
ruleCondition.Right = ruleValidityTest;
createRackRateRule.Condition = new RuleExpressionCondition(ruleCondition);
// add the action: Output = invalid
CodeAssignStatement ruleSurchargeAction = new CodeAssignStatement(OutputRef, new CodePrimitiveExpression("invalid"));
createRackRateRule.ThenActions.Add(new RuleStatementAction(ruleSurchargeAction));
// Add the ruleset
RuleDefinitions ruleDef = new RuleDefinitions();
ruleDef.RuleSets.Add(createRuleSet);
// Set the RuleDefinitions on the workflow
//this.SetValue(RuleDefinitions.RuleDefinitionsProperty, ruleDef);
}
void VisitCodeExpression(CodeExpression expression)
{
if (expression != null)
{
WriteLine("VisitCodeExpression: " + expression.GetType().Name);
CodePrimitiveExpression primitiveExpression = expression as CodePrimitiveExpression;
CodeFieldReferenceExpression fieldReferenceExpression = expression as CodeFieldReferenceExpression;
CodeThisReferenceExpression thisReferenceExpression = expression as CodeThisReferenceExpression;
CodeObjectCreateExpression createExpression = expression as CodeObjectCreateExpression;
CodeBinaryOperatorExpression binaryExpression = expression as CodeBinaryOperatorExpression;
CodeMethodReferenceExpression methodReferenceExpression = expression as CodeMethodReferenceExpression;
CodeMethodInvokeExpression methodInvokeExpression = expression as CodeMethodInvokeExpression;
CodeVariableReferenceExpression variableReferenceExpression = expression as CodeVariableReferenceExpression;
if (primitiveExpression != null)
{
VisitCodePrimitiveExpression(primitiveExpression);
}
else if (fieldReferenceExpression != null)
{
VisitCodeFieldReferenceExpression(fieldReferenceExpression);
}
else if (thisReferenceExpression != null)
{
VisitCodeThisReferenceExpression(thisReferenceExpression);
}
else if (createExpression != null)
{
VisitObjectCreateExpression(createExpression);
}
else if (binaryExpression != null)
{
VisitCodeBinaryOperatorExpression(binaryExpression);
}
else if (methodReferenceExpression != null)
{
VisitCodeMethodReferenceExpression(methodReferenceExpression);
}
else if (methodInvokeExpression != null)
{
VisitCodeMethodInvokeExpression(methodInvokeExpression);
}
else if (variableReferenceExpression != null)
{
VisitCodeVariableReferenceExpression(variableReferenceExpression);
}
}
else
{
WriteLine("VisitCodeExpression: Null");
}
}
public static CodeFieldReferenceExpression CreateFieldReference(string typeName, string fieldName)
{
CodeExpression targetObject = null;
if (typeName == "this")
{
targetObject = new CodeThisReferenceExpression();
}
else if (typeName != null)
{
targetObject = new CodeTypeReferenceExpression(typeName);
}
return(new CodeFieldReferenceExpression(targetObject, fieldName));
}
private CodeMemberMethod CreateInitializeMethod(CodeNamespace cns, CodeDomObjectNode objectNode)
{
TypeConverterDictionary = new Dictionary <Type, string>();
PublicObjects = new Dictionary <string, CodeDomObjectNode>();
CodeMemberMethod initComponentMethod = new CodeConstructor();
initComponentMethod.Attributes = MemberAttributes.Public;
CodeThisReferenceExpression thisExpression = new CodeThisReferenceExpression();
AddMembers(initComponentMethod, thisExpression, objectNode);
return(initComponentMethod);
}
private void ValidateThisReferenceExpression(CodeThisReferenceExpression e)
{ // Do nothing
}
protected abstract void GenerateThisReferenceExpression(CodeThisReferenceExpression e);
private void GenerateThisReferenceExpression(CodeThisReferenceExpression e)
{
Output.Write("this");
}
public void VisitThisReference(CodeThisReferenceExpression t)
{
writer.Write("this");
}
public void Visit(CodeThisReferenceExpression o)
{
g.GenerateThisReferenceExpression(o);
}
protected override void GenerateThisReferenceExpression
(CodeThisReferenceExpression e)
{
Output.Write("this");
}
