public TypescriptPropertySetValueReferenceExpression(
CodePropertySetValueReferenceExpression codeExpression,
CodeGeneratorOptions options)
{
_codeExpression = codeExpression;
_options = options;
System.Diagnostics.Debug.WriteLine("TypescriptPropertySetValueReferenceExpression Created");
}
protected override void GeneratePropertySetValueReferenceExpression(CodePropertySetValueReferenceExpression e)
{
Output.Write("[CodePropertySetValueReferenceExpression: {0}]", e.ToString());
}
public void GenerateProperties(CodeTypeDeclaration ctd, ClassInfo ci)
{
CodeMemberProperty prop;
foreach (FieldInfo fi in classInfo.LocalFields)
{
if (fi.References != null)
continue;
if (fi.IsNullable)
{
if (options.NullableRepresentation == PrimitiveRepresentation.RawWithIsNull)
{
ctd.Members.Add(_IsNull(fi));
if (!ci.ReadOnly)
{
ctd.Members.Add(_SetNull(fi));
}
}
}
else
{
if (options.NotNullRepresentation == PrimitiveRepresentation.RawWithIsNull)
{
if (!ci.ReadOnly)
{
// if it's read-only, not-null means not-null and there's no
// exception
ctd.Members.Add(_IsNull(fi));
}
}
}
}
int primaryKeyComponentNumber = 0;
foreach (FieldInfo fi in classInfo.LocalFields)
{
PrimitiveRepresentation actualNullableRepresentation = options.NullableRepresentation;
PrimitiveRepresentation actualNotNullRepresentation = options.NotNullRepresentation;
if (fi.GetNullableFieldHandler().GetSqlType() == null)
{
if (actualNotNullRepresentation == PrimitiveRepresentation.SqlType)
actualNotNullRepresentation = PrimitiveRepresentation.Raw;
if (actualNullableRepresentation == PrimitiveRepresentation.SqlType)
actualNullableRepresentation = PrimitiveRepresentation.Raw;
}
CodeTypeReference returnType;
//if (fi.Name == ci.PrimaryKeyFieldName)
//{
// returnType = GetReturnType(PrimitiveRepresentation.Raw, fi.DataType);
//}
//else
if (fi.References != null)
{
returnType = new CodeTypeReference(fi.References);
}
else if (fi.IsNullable)
{
returnType = GetReturnType(actualNullableRepresentation, fi);
}
else
{
returnType = GetReturnType(actualNotNullRepresentation, fi);
}
prop = new CodeMemberProperty();
prop.Name = fi.Name;
prop.Attributes = MemberAttributes.Final | MemberAttributes.Public;
prop.Type = returnType;
//prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(null, "_FieldNames")));
if (fi.Description != null)
{
prop.Comments.Add(new CodeCommentStatement("<summary>", true));
prop.Comments.Add(new CodeCommentStatement(fi.Description, true));
prop.Comments.Add(new CodeCommentStatement("</summary>", true));
}
ctd.Members.Add(prop);
if (fi.Size != -1)
{
CodeAttributeDeclaration cad = new CodeAttributeDeclaration("Sooda.SoodaFieldSizeAttribute");
cad.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(fi.Size)));
prop.CustomAttributes.Add(cad);
}
if (fi.IsPrimaryKey)
{
CodeExpression getPrimaryKeyValue = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "GetPrimaryKeyValue");
if (classInfo.GetPrimaryKeyFields().Length > 1)
{
getPrimaryKeyValue = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(SoodaTuple)), "GetValue", getPrimaryKeyValue, new CodePrimitiveExpression(primaryKeyComponentNumber));
}
if (fi.References != null)
{
prop.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeMethodInvokeExpression(
LoaderClass(fi.ReferencedClass),
"GetRef",
GetTransaction(),
new CodeCastExpression(
GetReturnType(actualNotNullRepresentation, fi),
getPrimaryKeyValue
))));
}
else
{
prop.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeCastExpression(
prop.Type,
getPrimaryKeyValue
)));
}
if (!classInfo.ReadOnly && !fi.ReadOnly)
{
if (classInfo.GetPrimaryKeyFields().Length == 1)
{
prop.SetStatements.Add(
new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(), "SetPrimaryKeyValue",
new CodePropertySetValueReferenceExpression())));
}
else
{
CodeExpression plainValue = new CodePropertySetValueReferenceExpression();
if (fi.References != null)
plainValue = new CodeMethodInvokeExpression(plainValue, "GetPrimaryKeyValue");
prop.SetStatements.Add(
new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(), "SetPrimaryKeySubValue",
plainValue,
new CodePrimitiveExpression(primaryKeyComponentNumber),
new CodePrimitiveExpression(classInfo.GetPrimaryKeyFields().Length))));
}
}
primaryKeyComponentNumber++;
continue;
}
if (options.NullPropagation && (fi.References != null || fi.IsNullable) && actualNullableRepresentation != PrimitiveRepresentation.Raw)
{
CodeExpression retVal = new CodePrimitiveExpression(null);
if (fi.References == null && actualNullableRepresentation == PrimitiveRepresentation.SqlType)
{
retVal = new CodePropertyReferenceExpression(
new CodeTypeReferenceExpression(fi.GetNullableFieldHandler().GetSqlType()), "Null");
}
prop.GetStatements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeThisReferenceExpression(),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null)),
new CodeStatement[]
{
new CodeMethodReturnStatement(retVal)
},
new CodeStatement[]
{
}));
}
if (fi.References != null)
{
// reference field getter
//
CodeExpression pk = new CodeVariableReferenceExpression("pk");
Type pkType;
CodeExpression isFieldNotNull;
CodeExpression getRef;
if (fi.ParentClass.GetDataSource().EnableDynamicFields)
{
pkType = typeof(object);
isFieldNotNull = new CodeBinaryOperatorExpression(
pk,
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null));
getRef = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(SoodaObject)),
"GetRefHelper",
GetTransaction(),
Factory(fi.References),
pk);
}
else
{
pkType = fi.GetNullableFieldHandler().GetSqlType();
isFieldNotNull = new CodeBinaryOperatorExpression(
new CodePropertyReferenceExpression(pk, "IsNull"),
CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression(false));
getRef = new CodeMethodInvokeExpression(
LoaderClass(fi.ReferencedClass),
"GetRef",
GetTransaction(),
new CodePropertyReferenceExpression(pk, "Value"));
}
prop.GetStatements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
RefCacheExpression(ci, fi),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null)),
new CodeStatement[]
{
new CodeVariableDeclarationStatement(pkType, "pk", GetFieldValueForRead(fi)),
new CodeConditionStatement(
isFieldNotNull,
new CodeStatement[]
{
new CodeAssignStatement(
RefCacheExpression(ci, fi),
getRef)
})
}
));
prop.GetStatements.Add(
new CodeMethodReturnStatement(
new CodeCastExpression(returnType,
RefCacheExpression(ci, fi))));
// reference field setter
if (!classInfo.ReadOnly && !fi.ReadOnly)
{
prop.SetStatements.Add(
new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Sooda.ObjectMapper.SoodaObjectImpl)), "SetRefFieldValue",
// parameters
new CodeThisReferenceExpression(),
new CodePrimitiveExpression(fi.Table.OrdinalInClass),
new CodePrimitiveExpression(fi.Name),
new CodePrimitiveExpression(fi.ClassUnifiedOrdinal),
new CodePropertySetValueReferenceExpression(),
RefCacheArray(),
new CodePrimitiveExpression(GetFieldRefCacheIndex(ci, fi)),
Factory(returnType.BaseType)
)));
}
}
else
{
// plain field getter
CodeExpression fieldValue = GetFieldValueForRead(fi);
if (fi.ParentClass.GetDataSource().EnableDynamicFields)
{
switch (fi.IsNullable ? actualNullableRepresentation : actualNotNullRepresentation)
{
case PrimitiveRepresentation.Boxed:
break;
case PrimitiveRepresentation.SqlType:
case PrimitiveRepresentation.RawWithIsNull:
case PrimitiveRepresentation.Raw:
fieldValue = new CodeCastExpression(new CodeTypeReference(fi.GetNullableFieldHandler().GetFieldType()), fieldValue);
break;
case PrimitiveRepresentation.Nullable:
fieldValue = new CodeCastExpression(new CodeTypeReference(fi.GetNullableFieldHandler().GetNullableType()), fieldValue);
break;
default:
throw new NotImplementedException("Unknown PrimitiveRepresentation");
}
}
prop.GetStatements.Add(new CodeMethodReturnStatement(fieldValue));
if (!classInfo.ReadOnly && !fi.ReadOnly)
{
// plain field setter
CodeExpression beforeDelegate = new CodePrimitiveExpression(null);
CodeExpression afterDelegate = new CodePrimitiveExpression(null);
if (classInfo.Triggers)
{
beforeDelegate = new CodeDelegateCreateExpression(new CodeTypeReference(typeof(SoodaFieldUpdateDelegate)),
new CodeThisReferenceExpression(), "BeforeFieldUpdate_" + fi.Name);
afterDelegate = new CodeDelegateCreateExpression(new CodeTypeReference(typeof(SoodaFieldUpdateDelegate)),
new CodeThisReferenceExpression(), "AfterFieldUpdate_" + fi.Name);
}
prop.SetStatements.Add(
new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Sooda.ObjectMapper.SoodaObjectImpl)), "SetPlainFieldValue",
// parameters
new CodeThisReferenceExpression(),
new CodePrimitiveExpression(fi.Table.OrdinalInClass),
new CodePrimitiveExpression(fi.Name),
new CodePrimitiveExpression(fi.ClassUnifiedOrdinal),
Box(new CodePropertySetValueReferenceExpression()),
beforeDelegate,
afterDelegate
)));
}
}
}
if (classInfo.Collections1toN != null)
{
foreach (CollectionOnetoManyInfo coli in classInfo.Collections1toN)
{
prop = new CodeMemberProperty();
prop.Name = coli.Name;
prop.Attributes = MemberAttributes.Final | MemberAttributes.Public;
prop.Type = GetCollectionPropertyType(coli.ClassName);
prop.GetStatements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeFieldReferenceExpression(This, "_collectionCache_" + coli.Name),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null)), new CodeStatement[]
{
new CodeAssignStatement(
new CodeFieldReferenceExpression(This, "_collectionCache_" + coli.Name),
new CodeObjectCreateExpression(GetCollectionWrapperType(coli.ClassName),
new CodeObjectCreateExpression(new CodeTypeReference(typeof(Sooda.ObjectMapper.SoodaObjectOneToManyCollection)),
new CodeExpression[] {
new CodeMethodInvokeExpression(This, "GetTransaction"),
new CodeTypeOfExpression(new CodeTypeReference(coli.ClassName)),
new CodeThisReferenceExpression(),
new CodePrimitiveExpression(coli.ForeignFieldName),
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(coli.ClassName + "_Factory"), "TheClassInfo"),
new CodeFieldReferenceExpression(null, "_collectionWhere_" + coli.Name),
new CodePrimitiveExpression(coli.Cache)
}))),
}, new CodeStatement[] { }));
prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(This, "_collectionCache_" + coli.Name)));
ctd.Members.Add(prop);
#if DOTNET35
CodeExpression whereExpression = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Sooda.QL.Soql)),
"FieldEquals",
new CodePrimitiveExpression(coli.ForeignFieldName),
This);
if (!string.IsNullOrEmpty(coli.Where))
{
whereExpression = new CodeObjectCreateExpression(
typeof(Sooda.QL.SoqlBooleanAndExpression),
whereExpression,
new CodePropertyReferenceExpression(new CodeFieldReferenceExpression(null, "_collectionWhere_" + coli.Name), "WhereExpression"));
}
prop = GetCollectionLinqQuery(coli, whereExpression);
ctd.Members.Add(prop);
#endif
}
}
if (classInfo.CollectionsNtoN != null)
{
foreach (CollectionManyToManyInfo coli in classInfo.CollectionsNtoN)
{
RelationInfo relationInfo = coli.GetRelationInfo();
// FieldInfo masterField = relationInfo.Table.Fields[1 - coli.MasterField];
string relationTargetClass = relationInfo.Table.Fields[coli.MasterField].References;
prop = new CodeMemberProperty();
prop.Name = coli.Name;
prop.Attributes = MemberAttributes.Final | MemberAttributes.Public;
prop.Type = GetCollectionPropertyType(relationTargetClass);
prop.GetStatements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeFieldReferenceExpression(This, "_collectionCache_" + coli.Name),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null)), new CodeStatement[] {
new CodeAssignStatement(
new CodeFieldReferenceExpression(This, "_collectionCache_" + coli.Name),
new CodeObjectCreateExpression(GetCollectionWrapperType(relationTargetClass),
new CodeObjectCreateExpression(new CodeTypeReference(typeof(Sooda.ObjectMapper.SoodaObjectManyToManyCollection)),
new CodeExpression[] {
new CodeMethodInvokeExpression(This, "GetTransaction"),
new CodePrimitiveExpression(coli.MasterField),
new CodeMethodInvokeExpression(This, "GetPrimaryKeyValue"),
new CodeTypeOfExpression(relationInfo.Name + "_RelationTable"),
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(relationInfo.Name + "_RelationTable"), "theRelationInfo")
}))
),
}
, new CodeStatement[] { }));
prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(This, "_collectionCache_" + coli.Name)));
ctd.Members.Add(prop);
#if DOTNET35
CodeExpression whereExpression = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Sooda.QL.Soql)),
"CollectionFor",
new CodeMethodInvokeExpression(
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(classInfo.Name + "_Factory"), "TheClassInfo"),
"FindCollectionManyToMany",
new CodePrimitiveExpression(coli.Name)),
This);
prop = GetCollectionLinqQuery(coli, whereExpression);
ctd.Members.Add(prop);
#endif
}
}
}
protected override void GeneratePropertySetValueReferenceExpression(CodePropertySetValueReferenceExpression e)
{
base.Output.Write("value");
}
/// <summary>
/// Generate a navigation property
/// </summary>
/// <param name="target">the other end</param>
/// <param name="referenceProperty">True to emit Reference navigation property</param>
/// <returns>the generated property</returns>
private CodeMemberProperty EmitNavigationProperty(RelationshipEndMember target)
{
CodeTypeReference typeRef = GetReturnType(target);
// raise the PropertyGenerated event
PropertyGeneratedEventArgs eventArgs = new PropertyGeneratedEventArgs(Item,
null, // no backing field
typeRef);
this.Generator.RaisePropertyGeneratedEvent(eventArgs);
// [System.ComponentModel.Browsable(false)]
// public TargetType TargetName
// public EntityReference<TargetType> TargetName
// or
// public EntityCollection<targetType> TargetNames
CodeMemberProperty property = new CodeMemberProperty();
// Only reference navigation properties are currently currently supported with XML serialization
// and thus we should use the XmlIgnore and SoapIgnore attributes on other property types.
AttributeEmitter.AddIgnoreAttributes(property);
AttributeEmitter.AddBrowsableAttribute(property);
AttributeEmitter.AddGeneratedCodeAttribute(property);
CommentEmitter.EmitSummaryComments(Item, property.Comments);
property.Name = Item.Name;
if (eventArgs.ReturnType != null && !eventArgs.ReturnType.Equals(typeRef))
{
property.Type = eventArgs.ReturnType;
}
else
{
property.Type = typeRef;
}
property.Attributes = MemberAttributes.Final;
CodeExpression getMethod = EmitGetMethod(target);
CodeExpression getReturnExpression;
if (target.RelationshipMultiplicity != RelationshipMultiplicity.Many)
{
property.Attributes |= AccessibilityFromGettersAndSetters(Item);
// insert user-supplied Set code here, before the assignment
//
List<CodeStatement> additionalSetStatements = eventArgs.AdditionalSetStatements;
if (additionalSetStatements != null && additionalSetStatements.Count > 0)
{
try
{
property.SetStatements.AddRange(additionalSetStatements.ToArray());
}
catch (ArgumentNullException e)
{
Generator.AddError(Strings.InvalidSetStatementSuppliedForProperty(Item.Name),
ModelBuilderErrorCode.InvalidSetStatementSuppliedForProperty,
EdmSchemaErrorSeverity.Error,
e);
}
}
CodeExpression valueRef = new CodePropertySetValueReferenceExpression();
if (typeRef != eventArgs.ReturnType)
{
// we need to cast to the actual type
valueRef = new CodeCastExpression(typeRef, valueRef);
}
CodeExpression valueProperty = getMethod;
// get
// return ((IEntityWithRelationships)this).RelationshipManager.GetRelatedReference<TTargetEntity>("CSpaceQualifiedRelationshipName", "TargetRoleName").Value;
getReturnExpression = valueProperty;
// set
// ((IEntityWithRelationships)this).RelationshipManager.GetRelatedReference<TTargetEntity>("CSpaceQualifiedRelationshipName", "TargetRoleName").Value = value;
property.SetStatements.Add(
new CodeAssignStatement(valueProperty, valueRef));
// setup the accessibility of the navigation property setter and getter
MemberAttributes propertyAccessibility = property.Attributes & MemberAttributes.AccessMask;
PropertyEmitter.AddGetterSetterFixUp(Generator.FixUps, GetFullyQualifiedPropertyName(property.Name),
PropertyEmitter.GetGetterAccessibility(Item), propertyAccessibility, true);
PropertyEmitter.AddGetterSetterFixUp(Generator.FixUps, GetFullyQualifiedPropertyName(property.Name),
PropertyEmitter.GetSetterAccessibility(Item), propertyAccessibility, false);
List<CodeStatement> additionalAfterSetStatements = eventArgs.AdditionalAfterSetStatements;
if (additionalAfterSetStatements != null && additionalAfterSetStatements.Count > 0)
{
try
{
property.SetStatements.AddRange(additionalAfterSetStatements.ToArray());
}
catch (ArgumentNullException e)
{
Generator.AddError(Strings.InvalidSetStatementSuppliedForProperty(Item.Name),
ModelBuilderErrorCode.InvalidSetStatementSuppliedForProperty,
EdmSchemaErrorSeverity.Error,
e);
}
}
}
else
{
property.Attributes |= PropertyEmitter.GetGetterAccessibility(Item);
// get
// return ((IEntityWithRelationships)this).RelationshipManager.GetRelatedCollection<TTargetEntity>("CSpaceQualifiedRelationshipName", "TargetRoleName");
getReturnExpression = getMethod;
// set
// if (value != null) ==> Only for non-binding scenario
// {
// this =
// this.OnPropertyChanged("")
// }
CodeExpression valueRef = new CodePropertySetValueReferenceExpression();
CodeStatementCollection csc = null;
if (this.Generator.UseDataServiceCollection == true)
{
csc = property.SetStatements;
}
else
{
CodeConditionStatement ccs = new CodeConditionStatement(EmitExpressionDoesNotEqualNull(valueRef));
property.SetStatements.Add(ccs);
csc = ccs.TrueStatements;
}
csc.Add(new CodeAssignStatement(getMethod, valueRef));
if (eventArgs.AdditionalAfterSetStatements != null)
{
try
{
foreach (CodeStatement s in eventArgs.AdditionalAfterSetStatements)
{
csc.Add(s);
}
}
catch (ArgumentNullException e)
{
Generator.AddError(Strings.InvalidSetStatementSuppliedForProperty(Item.Name),
ModelBuilderErrorCode.InvalidSetStatementSuppliedForProperty,
EdmSchemaErrorSeverity.Error,
e);
}
}
}
// if additional Get statements were specified by the event subscriber, insert them now
//
List<CodeStatement> additionalGetStatements = eventArgs.AdditionalGetStatements;
if (additionalGetStatements != null && additionalGetStatements.Count > 0)
{
try
{
property.GetStatements.AddRange(additionalGetStatements.ToArray());
}
catch (ArgumentNullException ex)
{
Generator.AddError(Strings.InvalidGetStatementSuppliedForProperty(Item.Name),
ModelBuilderErrorCode.InvalidGetStatementSuppliedForProperty,
EdmSchemaErrorSeverity.Error,
ex);
}
}
property.GetStatements.Add(new CodeMethodReturnStatement(getReturnExpression));
return property;
}
public void Visit (CodePropertySetValueReferenceExpression o)
{
g.GeneratePropertySetValueReferenceExpression (o);
}
private void GeneratePropertySetValueReferenceExpression(CodePropertySetValueReferenceExpression e) {
Output.Write("value");
}
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);
}
private static void EmitBasicClassMembers(Type callerType, CodeTypeDeclaration resourceClass, string nameSpace, string baseName,
string resourcesNamespace, bool internalClass, bool useStatic, bool supportsTryCatch, string logicalName, bool generateCTor)
{
//logicalName added by Ðonny
// Full class name generation
string fullClassName;
if (resourcesNamespace != null)
{
if (resourcesNamespace.Length > 0)
fullClassName = resourcesNamespace + '.' + baseName;
else
fullClassName = baseName;
}
else if ((nameSpace != null) && (nameSpace.Length > 0))
fullClassName = nameSpace + '.' + baseName;
else
fullClassName = baseName;
// Generation of class comments
string callerTypeName = callerType != null ? callerType.Name : "NULL";
CodeCommentStatement classCommentStatement = new CodeCommentStatement(string.Format(ClassComments1Format, callerTypeName));
resourceClass.Comments.Add(classCommentStatement);
classCommentStatement = new CodeCommentStatement(string.Format(ClassComments2Format, callerTypeName));
resourceClass.Comments.Add(classCommentStatement);
classCommentStatement = new CodeCommentStatement(string.Format(ClassCommentsCopyright, DateTime.Today.Year));
resourceClass.Comments.Add(classCommentStatement);
// Generation of the SuppressMessage attribute
CodeAttributeDeclaration suppressAttributeDeclaration = new CodeAttributeDeclaration(new CodeTypeReference(typeof(SuppressMessageAttribute)));
suppressAttributeDeclaration.AttributeType.Options = CodeTypeReferenceOptions.GlobalReference;
suppressAttributeDeclaration.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression("Microsoft.Performance")));
suppressAttributeDeclaration.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression("CA1811:AvoidUncalledPrivateCode")));
// Generation of the constructor
if (generateCTor) {
CodeConstructor codeConstructor = new CodeConstructor();
codeConstructor.CustomAttributes.Add(suppressAttributeDeclaration);
codeConstructor.Attributes = MemberAttributes.Private;
resourceClass.Members.Add(codeConstructor);
}
// Generation of the _resourceManager field
CodeTypeReference resourceManagerTypeReference = new CodeTypeReference(typeof(ResourceManager), CodeTypeReferenceOptions.GlobalReference);
CodeMemberField resourceManagerMemberField = new CodeMemberField(resourceManagerTypeReference, ResMgrFieldName);
resourceManagerMemberField.Attributes = MemberAttributes.Private;
if (useStatic)
resourceManagerMemberField.Attributes |= MemberAttributes.Static;
resourceClass.Members.Add(resourceManagerMemberField);
// Generation of the _internalSyncObject field
CodeTypeReference objectTypeReference = new CodeTypeReference(typeof(object), CodeTypeReferenceOptions.GlobalReference);
CodeMemberField internalSyncObjectMemberField = new CodeMemberField(objectTypeReference, InternalSyncObjectFieldName);
internalSyncObjectMemberField.Attributes = MemberAttributes.Private;
if (useStatic)
internalSyncObjectMemberField.Attributes |= MemberAttributes.Static;
resourceClass.Members.Add(internalSyncObjectMemberField);
// Generation of the _resourceCulture field
CodeTypeReference cultureInfoTypeReference = new CodeTypeReference(typeof(CultureInfo), CodeTypeReferenceOptions.GlobalReference);
CodeMemberField cultureInfoMemberField = new CodeMemberField(cultureInfoTypeReference, CultureInfoFieldName);
cultureInfoMemberField.Attributes = MemberAttributes.Private;
if (useStatic)
cultureInfoMemberField.Attributes |= MemberAttributes.Static;
resourceClass.Members.Add(cultureInfoMemberField);
// Generation of the InternalSyncObject property
CodeMemberProperty internalSyncObjectProperty = new CodeMemberProperty();
resourceClass.Members.Add(internalSyncObjectProperty);
internalSyncObjectProperty.Name = InternalSyncObjectPropertyName;
internalSyncObjectProperty.HasGet = true;
internalSyncObjectProperty.HasSet = false;
internalSyncObjectProperty.Type = objectTypeReference;
/*if (internalClass)
internalSyncObjectProperty.Attributes = MemberAttributes.Assembly;
else*///Ð
internalSyncObjectProperty.Attributes = MemberAttributes.Public;
if (useStatic)
internalSyncObjectProperty.Attributes |= MemberAttributes.Static;
CodeTypeReference interlockedCodeTypeReference = new CodeTypeReference(typeof(Interlocked), CodeTypeReferenceOptions.GlobalReference);
CodeMethodReferenceExpression referenceEqualsMethodReference = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(object)),
"ReferenceEquals");
CodeFieldReferenceExpression internalSyncObjectFieldReference = new CodeFieldReferenceExpression(null, InternalSyncObjectFieldName);
CodeMethodInvokeExpression referenceEqualInvokeExpression = new CodeMethodInvokeExpression(referenceEqualsMethodReference,
new CodeExpression[] { internalSyncObjectFieldReference, new CodePrimitiveExpression(null) });
CodeObjectCreateExpression objectCreateExpression = new CodeObjectCreateExpression(objectTypeReference, new CodeExpression[] {});
CodeMethodReferenceExpression compareExchangeMethodReference = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(interlockedCodeTypeReference),
"CompareExchange");
CodeMethodInvokeExpression compareExchangeMethodInvokeExpression = new CodeMethodInvokeExpression(compareExchangeMethodReference,
new CodeDirectionExpression(FieldDirection.Ref, internalSyncObjectFieldReference), objectCreateExpression,
new CodePrimitiveExpression(null));
internalSyncObjectProperty.GetStatements.Add(new CodeConditionStatement(referenceEqualInvokeExpression,
new CodeExpressionStatement(compareExchangeMethodInvokeExpression)));
internalSyncObjectProperty.GetStatements.Add(new CodeMethodReturnStatement(internalSyncObjectFieldReference));
AddComments(internalSyncObjectProperty, InternalSyncObjectPropertyComment);
// Generation of the ResourceManager property
CodeMemberProperty resourceManagerProperty = new CodeMemberProperty();
resourceClass.Members.Add(resourceManagerProperty);
resourceManagerProperty.Name = ResMgrPropertyName;
resourceManagerProperty.HasGet = true;
resourceManagerProperty.HasSet = false;
resourceManagerProperty.Type = resourceManagerTypeReference;
/*if (internalClass)
resourceManagerProperty.Attributes = MemberAttributes.Assembly;
else*///Ð
resourceManagerProperty.Attributes = MemberAttributes.Public;
if (useStatic)
resourceManagerProperty.Attributes |= MemberAttributes.Static;
CodeTypeReference eitorBrowsableTypeReference = new CodeTypeReference(typeof(EditorBrowsableState));
eitorBrowsableTypeReference.Options = CodeTypeReferenceOptions.GlobalReference;
CodeAttributeArgument codeAttributeArgument = new CodeAttributeArgument(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(eitorBrowsableTypeReference), "Advanced"));
CodeAttributeDeclaration codeAttributeDeclaration = new CodeAttributeDeclaration("System.ComponentModel.EditorBrowsableAttribute", new CodeAttributeArgument[] { codeAttributeArgument });
codeAttributeDeclaration.AttributeType.Options = CodeTypeReferenceOptions.GlobalReference;
resourceManagerProperty.CustomAttributes.Add(codeAttributeDeclaration);
CodeFieldReferenceExpression resourceManagerFieldReference = new CodeFieldReferenceExpression(null, ResMgrFieldName);
CodeMethodInvokeExpression referenceEqualsMethodInvokeExpression = new CodeMethodInvokeExpression(referenceEqualsMethodReference,
resourceManagerFieldReference, new CodePrimitiveExpression(null));
CodeTypeReference monitorCodeTypeReference = new CodeTypeReference(typeof(Monitor), CodeTypeReferenceOptions.GlobalReference);
CodeMethodReferenceExpression monitorEnterMethodReference = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(monitorCodeTypeReference),
"Enter");
CodePropertyReferenceExpression internalSyncObjectPropertyReference = new CodePropertyReferenceExpression(null, InternalSyncObjectPropertyName);
CodeMethodInvokeExpression monitorEnterMethodInvokeExpression = new CodeMethodInvokeExpression(monitorEnterMethodReference,
internalSyncObjectPropertyReference);
CodePropertyReferenceExpression assemblyPropertyReference = new CodePropertyReferenceExpression(new CodeTypeOfExpression(new CodeTypeReference(resourceClass.Name)),
"Assembly");
CodeObjectCreateExpression resourceManagerCreateExpression = new CodeObjectCreateExpression(resourceManagerTypeReference,
new CodePrimitiveExpression(logicalName), assemblyPropertyReference); //logicalName changed by Ðonny
CodeMethodReferenceExpression interlockedExchangeMethodReference = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(interlockedCodeTypeReference),
"Exchange");
CodeMethodInvokeExpression interlockedExchangeMethodInvokeExpression = new CodeMethodInvokeExpression(interlockedExchangeMethodReference,
new CodeDirectionExpression(FieldDirection.Ref, resourceManagerFieldReference), resourceManagerCreateExpression);
CodeMethodReferenceExpression monitorExitMethodReference = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(monitorCodeTypeReference),
"Exit");
CodeMethodInvokeExpression monitorExitMethodInvokeExpression = new CodeMethodInvokeExpression(monitorExitMethodReference,
internalSyncObjectPropertyReference);
CodeTryCatchFinallyStatement tryFinallyStatement = new CodeTryCatchFinallyStatement();
tryFinallyStatement.TryStatements.Add(new CodeConditionStatement(referenceEqualsMethodInvokeExpression,
new CodeExpressionStatement(interlockedExchangeMethodInvokeExpression)));
tryFinallyStatement.FinallyStatements.Add(monitorExitMethodInvokeExpression);
resourceManagerProperty.GetStatements.Add(new CodeConditionStatement(referenceEqualsMethodInvokeExpression,
new CodeExpressionStatement(monitorEnterMethodInvokeExpression), tryFinallyStatement));
resourceManagerProperty.GetStatements.Add(new CodeMethodReturnStatement(resourceManagerFieldReference));
AddComments(resourceManagerProperty, ResMgrPropertyComment);
// Generation of the Culture property
CodeMemberProperty cultureProperty = new CodeMemberProperty();
resourceClass.Members.Add(cultureProperty);
cultureProperty.Name = CultureInfoPropertyName;
cultureProperty.HasGet = true;
cultureProperty.HasSet = true;
cultureProperty.Type = cultureInfoTypeReference;
/*if (internalClass)
cultureProperty.Attributes = MemberAttributes.Assembly;
else*///Ð
cultureProperty.Attributes = MemberAttributes.Public;
if (useStatic)
cultureProperty.Attributes |= MemberAttributes.Static;
cultureProperty.CustomAttributes.Add(codeAttributeDeclaration);
CodeFieldReferenceExpression resourceCultureFieldReference = new CodeFieldReferenceExpression(null, CultureInfoFieldName);
cultureProperty.GetStatements.Add(new CodeMethodReturnStatement(resourceCultureFieldReference));
CodePropertySetValueReferenceExpression codePropertySetValueReferenceExpression = new CodePropertySetValueReferenceExpression();
cultureProperty.SetStatements.Add(new CodeAssignStatement(resourceCultureFieldReference, codePropertySetValueReferenceExpression));
AddComments(cultureProperty, CulturePropertyComment1, CulturePropertyComment2);
}
public void Generate(CodePropertySetValueReferenceExpression expression)
{
Write("value");
}
protected override void GeneratePropertySetValueReferenceExpression(System.CodeDom.CodePropertySetValueReferenceExpression e)
{
throw new Exception("The method or operation is not implemented.");
}
private void Write(CodePropertySetValueReferenceExpression e){
this.writer.Write("value");
}
private void CreateDocTypes(IEnumerable<DocType> docTypes, CodeNamespace ns)
{
foreach (var docType in docTypes)
{
string genName = docType.TypeName;
CodeCompileUnit currUnit = new CodeCompileUnit();
currUnit.Namespaces.Add(ns);
//create class
CodeTypeDeclaration currClass = new CodeTypeDeclaration(genName);
//create the custom attribute
CodeAttributeDeclarationCollection classAttributes = new CodeAttributeDeclarationCollection(
new CodeAttributeDeclaration[] {
new CodeAttributeDeclaration("UmbracoInfo",
new CodeAttributeArgument(new CodePrimitiveExpression(docType.Alias))
),
new CodeAttributeDeclaration("DocType")
});
if (!Args.IsInterface)
{
classAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(DataContractAttribute))));
}
//add the address to the class
currClass.CustomAttributes.AddRange(classAttributes);
currClass.IsClass = true;
//add the summary decoration
currClass.Comments.AddRange(GenerateSummary(docType.Description));
//set up the type
currClass.TypeAttributes = TypeAttributes.Public;
if (docType.ParentId > 0)
{
string typeName = docTypes.Single(d => d.Id == docType.ParentId).TypeName;
if (!Args.IsInterface)
{
currClass.BaseTypes.Add(new CodeTypeReference(typeName)); //docType inheritance
}
else
{
currClass.BaseTypes.Add(new CodeTypeReference("I" + typeName)); //docType inheritance of interface type
}
}
else
{
if (!Args.IsInterface)
{
currClass.BaseTypes.Add(new CodeTypeReference("DocTypeBase")); //base class
}
else
{
currClass.BaseTypes.Add(new CodeTypeReference("IDocTypeBase")); //base interface
}
}
if (!Args.IsInterface)
{
currClass.IsPartial = true;
}
else
{
currClass.IsInterface = true;
currClass.Name = "I" + currClass.Name;
}
currClass.Members.AddRange(GenerateConstructors());
#region Doc Type Properties
foreach (var docTypeProperty in docType.Properties)
{
CodeMemberField valueField = new CodeMemberField();
valueField.Attributes = MemberAttributes.Private;
valueField.Name = "_" + docTypeProperty.TypeName;
valueField.Type = new CodeTypeReference(docTypeProperty.DatabaseType);
currClass.Members.Add(valueField);
//store the umbraco data in an attribute.
CodeMemberProperty p = new CodeMemberProperty();
p.CustomAttributes.AddRange(GenerateDocTypePropertyAttributes(docTypeProperty));
p.Name = docTypeProperty.TypeName;
p.Type = new CodeTypeReference(docTypeProperty.DatabaseType);
p.Attributes = MemberAttributes.Public;
p.HasGet = true;
p.HasSet = false;
p.GetStatements.Add(new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(), valueField.Name))
);
#region Set statement
//have a conditional statment so we can use the INotifyChanging and INotifyChanged events
CodeExpression left = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), valueField.Name);
CodeExpression right = new CodePropertySetValueReferenceExpression();
CodeExpression cond = GenerateInequalityConditionalStatement(left, right);
//Build the statements to execute when we are changing the property value
//The order is:
// - RaisePropertyChanging event
// - Assign the property
// - RaisePropertyChanged event
var trues = new CodeStatement[] {
new CodeExpressionStatement(new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
"RaisePropertyChanging"
)
),
new CodeAssignStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(), valueField.Name),
new CodePropertySetValueReferenceExpression()
),
new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
"RaisePropertyChanged",
new CodePrimitiveExpression(docTypeProperty.TypeName)
)
)
};
CodeConditionStatement condition = new CodeConditionStatement(cond, trues);
//enforce the validation from umbraco. It's there for a reason ;)
if (!string.IsNullOrEmpty(docTypeProperty.RegularExpression))
{
p.SetStatements.Add(new CodeExpressionStatement(new CodeMethodInvokeExpression(
null,
"ValidateProperty",
new CodePrimitiveExpression(docTypeProperty.RegularExpression),
new CodePropertySetValueReferenceExpression())
)
);
}
p.SetStatements.Add(condition);
#endregion
//comment the property with the description from umbraco
p.Comments.AddRange(GenerateSummary(docTypeProperty.Description));
currClass.Members.Add(p);
CodeMemberProperty retypedProperty = CreateCustomProperty(docTypeProperty, valueField.Name);
if (retypedProperty != null)
{
currClass.Members.Add(retypedProperty);
}
}
#endregion
#region Child Associations
foreach (var child in docType.Associations)
{
var realDocType = docTypes.SingleOrDefault(dt => dt.Id == child.AllowedId);
//put a check that a docType is actually returned
//This will cater for the bug of when you don't select to generate a
//docType but it is a child of the current
if (realDocType != null)
{
string name = realDocType.TypeName;
if (this.PluralizeCollections)
{
name = PluraliseName(realDocType.TypeName);
}
var t = new CodeTypeReference("AssociationTree");
t.TypeArguments.Add(realDocType.TypeName);
CodeMemberProperty p = new CodeMemberProperty();
p.Name = name;
p.Type = t;
p.Attributes = MemberAttributes.Public | MemberAttributes.Final;
p.HasGet = true;
p.HasSet = true;
if (!Args.IsInterface)
{
CodeMemberField childMember = new CodeMemberField();
childMember.Attributes = MemberAttributes.Private;
childMember.Name = "_" + name;
childMember.Type = t;
currClass.Members.Add(childMember);
CodeExpression left = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), childMember.Name);
CodeExpression right = new CodePrimitiveExpression(null);
CodeExpression cond = GenerateEqualityConditionalStatement(left, right);
var trues = new CodeConditionStatement(cond, new CodeAssignStatement(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), childMember.Name),
new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeThisReferenceExpression(),
"ChildrenOfType",
new CodeTypeReference[] {
new CodeTypeReference(realDocType.TypeName)
})
)
)
);
p.GetStatements.Add(trues);
p.GetStatements.Add(new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(), childMember.Name))
);
p.SetStatements.Add(
new CodeAssignStatement(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(), childMember.Name),
new CodePropertySetValueReferenceExpression()
)
);
}
currClass.Members.Add(p);
}
}
#endregion
ns.Types.Add(currClass);
}
}
private CodeMemberProperty CreateProperty(CodeTypeReference type, string propertyName, string fieldName, bool isValueType)
{
CodeMemberProperty property = new CodeMemberProperty {
Type = type,
Name = propertyName,
Attributes = MemberAttributes.Final
};
if (this.GenerateInternalTypes)
{
property.Attributes |= MemberAttributes.Assembly;
}
else
{
property.Attributes |= MemberAttributes.Public;
}
CodeMethodReturnStatement statement = new CodeMethodReturnStatement {
Expression = new CodeFieldReferenceExpression(this.ThisReference, fieldName)
};
property.GetStatements.Add(statement);
CodeAssignStatement statement2 = new CodeAssignStatement {
Left = new CodeFieldReferenceExpression(this.ThisReference, fieldName),
Right = new CodePropertySetValueReferenceExpression()
};
if (this.EnableDataBinding && this.SupportsDeclareEvents)
{
CodeConditionStatement statement3 = new CodeConditionStatement();
CodeExpression targetObject = new CodeFieldReferenceExpression(this.ThisReference, fieldName);
CodeExpression right = new CodePropertySetValueReferenceExpression();
if (!isValueType)
{
targetObject = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(Globals.TypeOfObject), "ReferenceEquals", new CodeExpression[] { targetObject, right });
}
else
{
targetObject = new CodeMethodInvokeExpression(targetObject, "Equals", new CodeExpression[] { right });
}
right = new CodePrimitiveExpression(true);
statement3.Condition = new CodeBinaryOperatorExpression(targetObject, CodeBinaryOperatorType.IdentityInequality, right);
statement3.TrueStatements.Add(statement2);
statement3.TrueStatements.Add(new CodeMethodInvokeExpression(this.ThisReference, this.RaisePropertyChangedEventMethod.Name, new CodeExpression[] { new CodePrimitiveExpression(propertyName) }));
property.SetStatements.Add(statement3);
return property;
}
property.SetStatements.Add(statement2);
return property;
}
CodeMemberProperty CreateProperty(CodeTypeReference type, string propertyName, string fieldName, bool isValueType, bool raisePropertyChanged)
{
CodeMemberProperty property = new CodeMemberProperty();
property.Type = type;
property.Name = propertyName;
property.Attributes = MemberAttributes.Final;
if (GenerateInternalTypes)
property.Attributes |= MemberAttributes.Assembly;
else
property.Attributes |= MemberAttributes.Public;
CodeMethodReturnStatement propertyGet = new CodeMethodReturnStatement();
propertyGet.Expression = new CodeFieldReferenceExpression(ThisReference, fieldName);
property.GetStatements.Add(propertyGet);
CodeAssignStatement propertySet = new CodeAssignStatement();
propertySet.Left = new CodeFieldReferenceExpression(ThisReference, fieldName);
propertySet.Right = new CodePropertySetValueReferenceExpression();
if (raisePropertyChanged)
{
CodeConditionStatement ifStatement = new CodeConditionStatement();
CodeExpression left = new CodeFieldReferenceExpression(ThisReference, fieldName);
CodeExpression right = new CodePropertySetValueReferenceExpression();
if (!isValueType)
{
left = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(Globals.TypeOfObject),
"ReferenceEquals", new CodeExpression[] { left, right });
}
else
{
left = new CodeMethodInvokeExpression(left, "Equals", new CodeExpression[] { right });
}
right = new CodePrimitiveExpression(true);
ifStatement.Condition = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.IdentityInequality, right);
ifStatement.TrueStatements.Add(propertySet);
ifStatement.TrueStatements.Add(new CodeMethodInvokeExpression(ThisReference, RaisePropertyChangedEventMethod.Name, new CodePrimitiveExpression(propertyName)));
property.SetStatements.Add(ifStatement);
}
else
property.SetStatements.Add(propertySet);
return property;
}
private void ValidatePropertySetValueReferenceExpression(CodePropertySetValueReferenceExpression e) { // Do nothing
}
private void CreateConstantSetters(IShaderDom shader, Action<CodeTypeMember, string> add, string name, CodeExpression assignmentField, CodeExpression assignmentArrayField)
{
/*
* Something like:
public void SetInvTargetSize(ref Microsoft.Xna.Framework.Vector2 value)
{
this.vreg.SetVector2(130, ref value);
}
public Microsoft.Xna.Framework.Vector2 InvTargetSize
{
set
{
this.SetInvTargetSize(ref value);
}
}*/
Register reg;
Type dataType;
bool hasSetMethod;
int stride;
if (!ExtractRegType(name, out reg, out dataType, out hasSetMethod, out stride))
return;
Type arrayOrSingleType = dataType;
//right...
//create the method of the given type.
//public void SetInvTargetSize(ref Microsoft.Xna.Framework.Vector2 value)
CodeStatementCollection methodStatements = new CodeStatementCollection();
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(dataType, "value");
List<CodeParameterDeclarationExpression> additionalParams = new List<CodeParameterDeclarationExpression>();
if (reg.ArraySize == -1)
param.Direction = FieldDirection.Ref;
else
{
arrayOrSingleType = dataType.MakeArrayType();
param.Type = new CodeTypeReference(arrayOrSingleType);
//add array params, readIndex, writeIndex, count
additionalParams.Add(new CodeParameterDeclarationExpression(typeof(uint), "readIndex"));
additionalParams.Add(new CodeParameterDeclarationExpression(typeof(uint), "writeIndex"));
additionalParams.Add(new CodeParameterDeclarationExpression(typeof(uint), "count"));
}
CodeExpression valueRef = new CodeArgumentReferenceExpression(param.Name);
//when there isn't a set method, there is just a set property
if (!hasSetMethod)
valueRef = new CodePropertySetValueReferenceExpression();
//create the guts
//depends on what constants use it...
//eg:
//this.vreg.SetVector2(130, ref value);
Register sreg;
if (dataType == typeof(bool))
{
//special case for booleans, assign the array directly.
//looks like:
//
// if (preg_bool[index] != value)
// {
// preg_bool[index] = value;
// preg_bool_changed = true;
// }
foreach (KeyValuePair<AsmListing, CodeExpression> listing in listingRegisters)
{
RegisterSet registers = listing.Key.RegisterSet;
CodeExpression registersRef = listing.Value;
if (registers.TryGetRegister(name, out sreg))
{
if (listing.Key == asm.PixelShader)
{
CodeExpression arrayIndex = new CodeArrayIndexerExpression(shader.PixelShaderBooleanRegistersRef, new CodePrimitiveExpression(sreg.Index));
CodeStatement assign = new CodeAssignStatement(arrayIndex, new CodePropertySetValueReferenceExpression());
CodeStatement change = new CodeAssignStatement(shader.PixelShaderBooleanRegistersChangedRef, new CodePrimitiveExpression(true));
CodeStatement condition = new CodeConditionStatement(
new CodeBinaryOperatorExpression(arrayIndex, CodeBinaryOperatorType.IdentityInequality, new CodePropertySetValueReferenceExpression()),
new CodeStatement[]{assign, change});
methodStatements.Add(condition);
}
if (listing.Key == asm.VertexShader)
{
CodeExpression arrayIndex = new CodeArrayIndexerExpression(shader.VertexShaderBooleanRegistersRef, new CodePrimitiveExpression(sreg.Index));
CodeStatement assign = new CodeAssignStatement(arrayIndex, new CodePropertySetValueReferenceExpression());
CodeStatement change = new CodeAssignStatement(shader.VertexShaderBooleanRegistersChangedRef, new CodePrimitiveExpression(true));
CodeStatement condition = new CodeConditionStatement(
new CodeBinaryOperatorExpression(arrayIndex, CodeBinaryOperatorType.IdentityInequality, new CodePropertySetValueReferenceExpression()),
new CodeStatement[] { assign, change });
methodStatements.Add(condition);
}
}
}
}
else
{
//some array set methods require temporary values, but should only be created once.
bool tempValuesCreated = false;
foreach (KeyValuePair<AsmListing, CodeExpression> listing in listingRegisters)
{
RegisterSet registers = listing.Key.RegisterSet;
CodeExpression registersRef = listing.Value;
if (registers.TryGetRegister(name, out sreg))
{
//Assign the register array data
AssignRegister(dataType, sreg, reg, listing.Value, valueRef, methodStatements, ref tempValuesCreated);
//set changed
CodeExpression changeValue = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), (registersRef as CodeFieldReferenceExpression).FieldName + "_change");
methodStatements.Add(new CodeAssignStatement(changeValue, new CodePrimitiveExpression(true)));
}
}
}
string upperName = Common.ToUpper(name);
//there is always a setable property
CodeMemberProperty property = new CodeMemberProperty();
property.Name = upperName;
property.Type = param.Type;
property.Attributes = MemberAttributes.Final | MemberAttributes.Public;
property.HasSet = true;
property.HasGet = false;
//there isn't always a set method
CodeMemberMethod method = null;
CodeStatement assignAttribute = null;
if (hasSetMethod || reg.ArraySize != -1)
{
//create the method to set the value
string methodName = "Set" + upperName;
method = new CodeMemberMethod();
method.Name = methodName;
method.Attributes = MemberAttributes.Final | MemberAttributes.Public;
method.Parameters.Add(param);
method.Parameters.AddRange(additionalParams.ToArray());
method.Statements.AddRange(methodStatements);
//create a property that calls the Set method
//is not an array
CodeMethodInvokeExpression invokeSetter =
new CodeMethodInvokeExpression(
shader.Instance, method.Name,
new CodeDirectionExpression(reg.ArraySize == -1 ? FieldDirection.Ref : FieldDirection.In, new CodePropertySetValueReferenceExpression()));
if (reg.ArraySize != -1)
{
//add method ops (readIndex, writeIndex, count)
invokeSetter.Parameters.Add(new CodePrimitiveExpression(0));
invokeSetter.Parameters.Add(new CodePrimitiveExpression(0));
invokeSetter.Parameters.Add(new CodeCastExpression(typeof(uint), new CodePropertyReferenceExpression(valueRef, "Length")));
}
property.SetStatements.Add(invokeSetter);
//call the method as well for attribute assign
CodeMethodInvokeExpression assignSetter =
new CodeMethodInvokeExpression(
shader.Instance, method.Name,
new CodeDirectionExpression(param.Direction, shader.AttributeAssignValue));
if (reg.ArraySize != -1)
{
//add method ops (readIndex, writeIndex, count)
assignSetter.Parameters.Add(new CodePrimitiveExpression(0));
assignSetter.Parameters.Add(new CodePrimitiveExpression(0));
assignSetter.Parameters.Add(new CodeCastExpression(typeof(uint), new CodePropertyReferenceExpression(valueRef, "Length")));
}
assignAttribute = shader.ETS(assignSetter);
}
else
{
//create a property to directly set the value
property.SetStatements.AddRange(methodStatements);
//attribute assign sets the property
assignAttribute = new CodeAssignStatement(
new CodePropertyReferenceExpression(shader.Instance, property.Name),
shader.AttributeAssignValue);
}
if (reg.ArraySize > 0)
{
if (method != null)
add(method, string.Format("Set the shader array value '{0} {1}[{2}]'", reg.Type, reg.Name, reg.ArraySize));
add(property, string.Format("Set and copy the array data for the shader value '{0} {1}[{2}]'", reg.Type, reg.Name, reg.ArraySize));
}
else
{
if (method != null)
add(method, string.Format("Set the shader value '{0} {1}'", reg.Type, reg.Name));
add(property, string.Format("Assign the shader value '{0} {1}'", reg.Type, reg.Name));
}
//create the attribute assignment value statement.
List<CodeStatement> assignList;
if (!attributeAssignment.TryGetValue(arrayOrSingleType, out assignList))
{
assignList = new List<CodeStatement>();
attributeAssignment.Add(arrayOrSingleType, assignList);
}
//create the statement...
CodeExpression assignIdsMatch =
new CodeBinaryOperatorExpression(shader.AttributeAssignId, CodeBinaryOperatorType.IdentityEquality, assignmentField);
CodeConditionStatement performAssign =
new CodeConditionStatement(assignIdsMatch,
assignAttribute, //call the assignment code
new CodeMethodReturnStatement(new CodePrimitiveExpression(true))); //return true, set correctly.
assignList.Add(performAssign);
}
private void ReplaceSetValue(ref CodeObject target, CodeObject parent, int indent)
{
CodeVariableReferenceExpression variableRefExpr = target as CodeVariableReferenceExpression;
if (variableRefExpr != null && StringUtils.CaseInsensitiveEquals(variableRefExpr.VariableName, _name))
{
target = new CodePropertySetValueReferenceExpression();
}
}
/// <summary>
/// Generates the "SetInstanceVariable" statement.
/// </summary>
/// <returns>The "SetInstanceVariable" statement.</returns>
/// <param name="thisRef">This reference.</param>
/// <param name="typeRef">Type reference.</param>
/// <param name="nameRef">Name reference.</param>
/// <param name="valueRef">Value reference</param>
protected override CodeExpression GenerateSetInstanceVariableStatement(CodeThisReferenceExpression thisRef, CodeTypeReference typeRef, CodePrimitiveExpression nameRef, CodePropertySetValueReferenceExpression valueRef)
{
throw new NotImplementedException();
}
static void ProcessType(Type type, CodeTypeDeclaration ctd)
{
foreach (FieldInfo field in type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.NonPublic)) {
ctd.AddField(ConvertType(field.FieldType), field.Name).Attributes = 0;
}
foreach (FieldInfo field in type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.NonPublic)) {
EasyProperty p = ctd.AddProperty(ConvertType(field.FieldType), GetPropertyName(field.Name));
p.Getter.Return(Easy.Var(field.Name));
CodeExpression ex;
if (field.FieldType.IsValueType)
ex = new CodePropertySetValueReferenceExpression();
else
ex = GetDefaultValue("value", field);
p.Setter.Assign(Easy.Var(field.Name), ex);
if (typeof(INode).IsAssignableFrom(field.FieldType)) {
if (typeof(INullable).IsAssignableFrom(field.FieldType)) {
p.SetStatements.Add(new CodeSnippetStatement("\t\t\t\tif (!" +field.Name+".IsNull) "+field.Name+".Parent = this;"));
} else {
p.SetStatements.Add(new CodeSnippetStatement("\t\t\t\t"+field.Name+".Parent = this;"));
}
}
}
foreach (ConstructorInfo ctor in type.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)) {
CodeConstructor c = new CodeConstructor();
if (type.IsAbstract)
c.Attributes = MemberAttributes.Family;
else
c.Attributes = MemberAttributes.Public;
ctd.Members.Add(c);
ConstructorInfo baseCtor = GetBaseCtor(type);
foreach(ParameterInfo param in ctor.GetParameters()) {
c.Parameters.Add(new CodeParameterDeclarationExpression(ConvertType(param.ParameterType),
param.Name));
if (baseCtor != null && Array.Exists(baseCtor.GetParameters(), delegate(ParameterInfo p) { return param.Name == p.Name; }))
continue;
c.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(GetPropertyName(param.Name)),
new CodeVariableReferenceExpression(param.Name)));
}
if (baseCtor != null) {
foreach(ParameterInfo param in baseCtor.GetParameters()) {
c.BaseConstructorArgs.Add(new CodeVariableReferenceExpression(param.Name));
}
}
// initialize fields that were not initialized by parameter
foreach (FieldInfo field in type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.NonPublic)) {
if (field.FieldType.IsValueType && field.FieldType != typeof(Location))
continue;
if (Array.Exists(ctor.GetParameters(), delegate(ParameterInfo p) { return field.Name == p.Name; }))
continue;
c.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(field.Name),
GetDefaultValue(null, field)));
}
}
}
/// <summary>
/// Generates code for the specified property set value reference expression.
/// </summary>
/// <remarks>Not supported.</remarks>
protected override void GeneratePropertySetValueReferenceExpression(CodePropertySetValueReferenceExpression e)
{
throw new Exception("The method or operation is not implemented.");
}
protected abstract void GeneratePropertySetValueReferenceExpression (CodePropertySetValueReferenceExpression e);
internal CodeMemberProperty CreatePropertyDeclaration(CodeMemberField field, string name, string typeName)
{
CodeMemberProperty property;
property = new CodeMemberProperty {
Type = new CodeTypeReference(typeName),
Name = name,
Attributes = (property.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public
};
CodeMethodReturnStatement statement = new CodeMethodReturnStatement {
Expression = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), field.Name)
};
property.GetStatements.Add(statement);
CodeAssignStatement statement2 = new CodeAssignStatement();
CodeExpression expression = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), field.Name);
CodeExpression expression2 = new CodePropertySetValueReferenceExpression();
statement2.Left = expression;
statement2.Right = expression2;
if (this.EnableDataBinding)
{
property.SetStatements.Add(statement2);
property.SetStatements.Add(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), RaisePropertyChangedEventMethod.Name, new CodeExpression[] { new CodePrimitiveExpression(name) }));
return property;
}
property.SetStatements.Add(statement2);
return property;
}
protected override void GeneratePropertySetValueReferenceExpression (CodePropertySetValueReferenceExpression e)
{
}
private CodeExpression GetPropertySetRValue(ComAliasEnum alias, System.Type propertyType)
{
CodeExpression expression = new CodePropertySetValueReferenceExpression();
if (alias == ComAliasEnum.None)
{
return expression;
}
string wFToComConverter = ComAliasConverter.GetWFToComConverter(alias);
string wFToComParamConverter = ComAliasConverter.GetWFToComParamConverter(alias, propertyType);
CodeExpression[] parameters = new CodeExpression[] { expression };
CodeMethodInvokeExpression expression2 = new CodeMethodInvokeExpression(null, wFToComConverter, parameters);
if (wFToComParamConverter.Length == 0)
{
return expression2;
}
return new CodeCastExpression(wFToComParamConverter, expression2);
}
/// <summary>
/// 构造一个命名空间
/// </summary>
/// <returns>code</returns>
static CodeNamespace CreateMimsyNamespace()
{
// 定义命名空间
CodeNamespace mimsyNamespace = new CodeNamespace("Mimsy");
// 添加引用
mimsyNamespace.Imports.AddRange(new[]
{
new CodeNamespaceImport("System"),
new CodeNamespaceImport("System.Text"),
new CodeNamespaceImport("System.Collections")
});
// 定义类
CodeTypeDeclaration jubjubClass = new CodeTypeDeclaration("Jubjub")
{
TypeAttributes = TypeAttributes.Public // NotPublic = internal, the internal type isn't visible to the dynamic binder
};
// 定义成员字段
CodeMemberField wabeCountFld = new CodeMemberField(typeof(int), "_wabeCount")
{
Attributes = MemberAttributes.Private
};
jubjubClass.Members.Add(wabeCountFld); // 附加字段到类
mimsyNamespace.Types.Add(jubjubClass); // 附加类到命名空间
// 定义实例构造函数
CodeConstructor jubjubCtor = new CodeConstructor
{
Attributes = MemberAttributes.Public
};
// 定义参数
var para = new CodeParameterDeclarationExpression(typeof(int), "wabeCount");
jubjubCtor.Parameters.Add(para); // 附加参数到构造函数
// 添加 ArrayList 字段
var typerefArrayList = new CodeTypeReference("ArrayList");
CodeMemberField updatesFld = new CodeMemberField(typerefArrayList, "_updates");
jubjubClass.Members.Add(updatesFld);
// 引用 _updates 字段
var refUpdatesFld = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_updates");
// 实例化 ArrayList
var newArrayList = new CodeObjectCreateExpression(typerefArrayList);
// 赋值
var assignUpdates = new CodeAssignStatement(refUpdatesFld, newArrayList);
jubjubCtor.Statements.Add(assignUpdates); // 附加赋值语句到构造函数
// 引用 _wabeCount 字段
var refWabeCountFld = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_wabeCount");
// 定义引用属性(用于赋值时进行判断)
var refWabeCountProp = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "WabeCount");
// 定义引用参数
var refWabeCountArg = new CodeArgumentReferenceExpression("wabeCount");
// 定义赋值语句
var assignWabeCount = new CodeAssignStatement(refWabeCountProp, refWabeCountArg);
jubjubCtor.Statements.Add(assignWabeCount); // 附加赋值语句到构造函数
jubjubClass.Members.Add(jubjubCtor); // 附加构造函数到类
// 定义成员属性
CodeMemberProperty wabeCountProp = new CodeMemberProperty()
{
Attributes = MemberAttributes.Public | MemberAttributes.Final, // Final == Nonvirtual
Type = new CodeTypeReference(typeof(int)),
Name = "WabeCount"
};
// 为属性添加 get 语句
wabeCountProp.GetStatements.Add(new CodeMethodReturnStatement(refWabeCountFld));
// 为属性添加 set 语句
var suppliedPropertyValue = new CodePropertySetValueReferenceExpression(); // value
var zero = new CodePrimitiveExpression(0);
var suppliedPropValIsLessThanZero = new CodeBinaryOperatorExpression(suppliedPropertyValue, CodeBinaryOperatorType.LessThan, zero);
// if/else 语句进行赋值判断, CodeDOM 不支持三元运算表达式 (value < 0) ? 0 : value;
var testSuppliedPropValAndAssign = new CodeConditionStatement(suppliedPropValIsLessThanZero,
new CodeStatement[]
{
new CodeAssignStatement(refWabeCountFld,zero)
},
new CodeStatement[]
{
new CodeAssignStatement(refWabeCountFld,suppliedPropertyValue)
});
wabeCountProp.SetStatements.Add(testSuppliedPropValAndAssign);
wabeCountProp.SetStatements.Add(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(refUpdatesFld, "Add"), refWabeCountFld));
jubjubClass.Members.Add(wabeCountProp); // 附加属性到类
// 定义一个方法
CodeMemberMethod methGetWabeCountHistory = new CodeMemberMethod
{
Attributes = MemberAttributes.Public | MemberAttributes.Final,
Name = "GetWabeCountHistory",
ReturnType = new CodeTypeReference(typeof(string))
};
jubjubClass.Members.Add(methGetWabeCountHistory); // 附加方法到类
// 定义本地变量并实例化
methGetWabeCountHistory.Statements.Add(new CodeVariableDeclarationStatement("StringBuilder", "result"));
var refResultVar = new CodeVariableReferenceExpression("result");
methGetWabeCountHistory.Statements.Add(new CodeAssignStatement(refResultVar, new CodeObjectCreateExpression("StringBuilder")));
// 定义本地变量 ndx
methGetWabeCountHistory.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "ndx"));
// 引用本地变量 ndx
var refNdxVar = new CodeVariableReferenceExpression("ndx");
#region 创建 for 语句
// 赋值语句 ndx = 0
var initNdxVar = new CodeAssignStatement(refNdxVar, new CodePrimitiveExpression(0));
// 条件语句 ndx < this._updates.Count
var testNdxWithUpdatesCount = new CodeBinaryOperatorExpression(refNdxVar, CodeBinaryOperatorType.LessThan,
new CodePropertyReferenceExpression(refUpdatesFld, "Count"));
// 自增语句
var incrementNdxVar = new CodeAssignStatement(refNdxVar,
new CodeBinaryOperatorExpression(refNdxVar, CodeBinaryOperatorType.Add,
new CodePrimitiveExpression(1)));
// 比较 if(ndx == 0)
var compareNdxWithZero = new CodeBinaryOperatorExpression(refNdxVar, CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression(0));
// 方法调用 result.AppendFormat("{0}", this._updates[ndx])
var methAppendFormatInvoke = new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(refResultVar, "AppendFormat"),
new CodePrimitiveExpression("{0}"),
new CodeArrayIndexerExpression(refUpdatesFld, refNdxVar)
)
);
// 方法调用 result.AppendFormat(", {0}", this._updates[ndx])
var methAppendFormtInvokeWithCommas = new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(refResultVar, "AppendFormat"),
new CodePrimitiveExpression(", {0}"),
new CodeArrayIndexerExpression(refUpdatesFld, refNdxVar)
)
);
methGetWabeCountHistory.Statements.Add(
new CodeIterationStatement(initNdxVar, testNdxWithUpdatesCount, incrementNdxVar,
new CodeConditionStatement(compareNdxWithZero,
new CodeStatement[] { methAppendFormatInvoke },
new CodeStatement[] { methAppendFormtInvokeWithCommas })));
#endregion
// 定义返回值
methGetWabeCountHistory.Statements.Add(
new CodeMethodReturnStatement(
new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(refResultVar, "ToString"))));
return mimsyNamespace;
}
public bool ValidateCodePropertySetValueReferenceExpression (CodePropertySetValueReferenceExpression exp) {
return true;
}
private static void GenerateProperties(Type t, CodeTypeDeclaration codeType)
{
foreach (PropertyInfo property in t.GetProperties())
{
if (OmittedProperties.ContainsKey(t.FullName) && OmittedProperties[t.FullName].Contains(property.Name))
{
continue;
}
if (property.CustomAttributes.Any(x => x.AttributeType.FullName.Contains("Obsolete")))
{
continue;
}
string propertyType = GetPropertyType(property.PropertyType);
bool isGenericCollection = property.PropertyType.IsGenericType &&
(property.PropertyType.GetGenericTypeDefinition() == typeof(IList<>) || property.PropertyType.GetGenericTypeDefinition() == typeof(IEnumerable<>) ||
property.PropertyType.GetGenericTypeDefinition() == typeof(IReadOnlyList<>));
CodeFieldReferenceExpression wrappedObject = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), OmObject);
CodePropertyReferenceExpression wrappedObjectProperty = new CodePropertyReferenceExpression(wrappedObject, property.Name);
CodeFieldReferenceExpression fieldReference = null;
if (isGenericCollection || OMtoPSClassMappings.ContainsKey(property.PropertyType.FullName))
{
// Add a backing field for the property with the same name but using camel case.
string fieldName = string.Format("{0}{1}", property.Name.ToLower()[0], property.Name.Substring(1, property.Name.Length - 1));
CodeMemberField backingField = new CodeMemberField();
backingField.Attributes = MemberAttributes.Private;
backingField.Name = fieldName;
backingField.Type = new CodeTypeReference(propertyType);
codeType.Members.Add(backingField);
fieldReference = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), fieldName);
}
CodeMemberProperty codeProperty = new CodeMemberProperty();
codeProperty.Attributes = MemberAttributes.Public | MemberAttributes.Final;
codeProperty.Name = property.Name;
codeProperty.Type = new CodeTypeReference(propertyType);
// For properties with a backing field, the field will not be initialized in the constructor in order to avoid
// hitting a run time access constraint from the OM. Instead, the field is initialized on the first access of
// the property.
if (isGenericCollection)
{
// Collections are not kept in sync with the wrapped OM object. Cmdlets will need to sync them before sending
// a request to the server.
Type argType = property.PropertyType.GetGenericArguments()[0];
string wrapperArgType = argType.FullName.StartsWith("System") ? argType.FullName : OMtoPSClassMappings[argType.FullName];
string wrapperListType = string.Format("List<{0}>", wrapperArgType);
if (property.GetMethod != null && property.GetMethod.IsPublic)
{
codeProperty.HasGet = true;
// Build a list of wrapper objects
const string listVariableName = "list";
CodeVariableDeclarationStatement listDeclaration = new CodeVariableDeclarationStatement(wrapperListType, listVariableName);
CodeVariableReferenceExpression listReference = new CodeVariableReferenceExpression(listVariableName);
CodeAssignStatement initializeList = new CodeAssignStatement(listReference, new CodeObjectCreateExpression(wrapperListType));
// CodeDom doesn't support foreach loops very well, so instead explicitly get the enumerator and loop on MoveNext() calls
const string enumeratorVariableName = "enumerator";
CodeVariableDeclarationStatement enumeratorDeclaration = new CodeVariableDeclarationStatement(string.Format("IEnumerator<{0}>", argType.FullName), enumeratorVariableName);
CodeVariableReferenceExpression enumeratorReference = new CodeVariableReferenceExpression(enumeratorVariableName);
CodeAssignStatement initializeEnumerator = new CodeAssignStatement(enumeratorReference, new CodeMethodInvokeExpression(wrappedObjectProperty, "GetEnumerator"));
CodeIterationStatement loopStatement = new CodeIterationStatement();
loopStatement.TestExpression = new CodeMethodInvokeExpression(enumeratorReference, "MoveNext");
loopStatement.IncrementStatement = new CodeSnippetStatement(string.Empty);
loopStatement.InitStatement = new CodeSnippetStatement(string.Empty);
CodePropertyReferenceExpression enumeratorCurrent = new CodePropertyReferenceExpression(enumeratorReference, "Current");
// Fill the list by individually wrapping each item in the loop
if (wrapperArgType.Contains("System"))
{
CodeMethodInvokeExpression addToList = new CodeMethodInvokeExpression(listReference, "Add", enumeratorCurrent);
loopStatement.Statements.Add(addToList);
}
else
{
CodeObjectCreateExpression createListItem = new CodeObjectCreateExpression(wrapperArgType, enumeratorCurrent);
CodeMethodInvokeExpression addToList = new CodeMethodInvokeExpression(listReference, "Add", createListItem);
loopStatement.Statements.Add(addToList);
}
// Initialize the backing field with the built list on first access of the property
CodeAssignStatement assignStatement;
if (property.PropertyType.GetGenericTypeDefinition() == typeof(IReadOnlyList<>))
{
CodeMethodInvokeExpression asReadOnlyList = new CodeMethodInvokeExpression(listReference, "AsReadOnly");
assignStatement = new CodeAssignStatement(fieldReference, asReadOnlyList);
}
else
{
assignStatement = new CodeAssignStatement(fieldReference, listReference);
}
CodePrimitiveExpression nullExpression = new CodePrimitiveExpression(null);
CodeBinaryOperatorExpression fieldNullCheck = new CodeBinaryOperatorExpression(fieldReference, CodeBinaryOperatorType.IdentityEquality, nullExpression);
CodeBinaryOperatorExpression wrappedPropertyNullCheck = new CodeBinaryOperatorExpression(wrappedObjectProperty, CodeBinaryOperatorType.IdentityInequality, nullExpression);
CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(fieldNullCheck, CodeBinaryOperatorType.BooleanAnd, wrappedPropertyNullCheck);
CodeConditionStatement ifBlock = new CodeConditionStatement(condition, listDeclaration, initializeList, enumeratorDeclaration, initializeEnumerator, loopStatement, assignStatement);
codeProperty.GetStatements.Add(ifBlock);
codeProperty.GetStatements.Add(new CodeMethodReturnStatement(fieldReference));
}
if (property.SetMethod != null && property.SetMethod.IsPublic)
{
// Call the "set" on the OM object to ensure that constraints are enforced.
codeProperty.HasSet = true;
CodePropertySetValueReferenceExpression valueReference = new CodePropertySetValueReferenceExpression();
CodeBinaryOperatorExpression nullCheck = new CodeBinaryOperatorExpression(valueReference, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null));
CodeAssignStatement nullAssignment = new CodeAssignStatement(wrappedObjectProperty, new CodePrimitiveExpression(null));
CodeAssignStatement nonNullAssignment = new CodeAssignStatement(wrappedObjectProperty, new CodeObjectCreateExpression(string.Format("List<{0}>", argType.FullName)));
CodeConditionStatement ifBlock = new CodeConditionStatement(nullCheck, new CodeStatement[] { nullAssignment }, new CodeStatement[] { nonNullAssignment });
codeProperty.SetStatements.Add(ifBlock);
codeProperty.SetStatements.Add(new CodeAssignStatement(fieldReference, valueReference));
}
}
else if (OMtoPSClassMappings.ContainsKey(property.PropertyType.FullName))
{
if (property.GetMethod != null && property.GetMethod.IsPublic)
{
codeProperty.HasGet = true;
CodeObjectCreateExpression createFieldObject = new CodeObjectCreateExpression(OMtoPSClassMappings[property.PropertyType.FullName], wrappedObjectProperty);
CodeAssignStatement assignStatement = new CodeAssignStatement(fieldReference, createFieldObject);
CodePrimitiveExpression nullExpression = new CodePrimitiveExpression(null);
CodeBinaryOperatorExpression fieldNullCheck = new CodeBinaryOperatorExpression(fieldReference, CodeBinaryOperatorType.IdentityEquality, nullExpression);
CodeBinaryOperatorExpression wrappedPropertyNullCheck = new CodeBinaryOperatorExpression(wrappedObjectProperty, CodeBinaryOperatorType.IdentityInequality, nullExpression);
CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(fieldNullCheck, CodeBinaryOperatorType.BooleanAnd, wrappedPropertyNullCheck);
CodeConditionStatement ifBlock = new CodeConditionStatement(condition, assignStatement);
codeProperty.GetStatements.Add(ifBlock);
codeProperty.GetStatements.Add(new CodeMethodReturnStatement(fieldReference));
}
if (property.SetMethod != null && property.SetMethod.IsPublic)
{
codeProperty.HasSet = true;
CodePropertySetValueReferenceExpression valueReference = new CodePropertySetValueReferenceExpression();
CodeBinaryOperatorExpression nullCheck = new CodeBinaryOperatorExpression(valueReference, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null));
CodeAssignStatement nullAssignment = new CodeAssignStatement(wrappedObjectProperty, new CodePrimitiveExpression(null));
CodePropertyReferenceExpression valueProperty = new CodePropertyReferenceExpression(valueReference, OmObject);
CodeAssignStatement nonNullAssignment = new CodeAssignStatement(wrappedObjectProperty, valueProperty);
CodeConditionStatement ifBlock = new CodeConditionStatement(nullCheck, new CodeStatement[] { nullAssignment }, new CodeStatement[] { nonNullAssignment });
codeProperty.SetStatements.Add(ifBlock);
codeProperty.SetStatements.Add(new CodeAssignStatement(fieldReference, valueReference));
}
}
else
{
// By default, just pass through to the wrapped OM object's property.
if (property.GetMethod != null && property.GetMethod.IsPublic)
{
codeProperty.HasGet = true;
codeProperty.GetStatements.Add(new CodeMethodReturnStatement(wrappedObjectProperty));
}
if (property.SetMethod != null && property.SetMethod.IsPublic)
{
codeProperty.HasSet = true;
codeProperty.SetStatements.Add(new CodeAssignStatement(wrappedObjectProperty, new CodePropertySetValueReferenceExpression()));
}
}
codeType.Members.Add(codeProperty);
}
}
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);
}
internal CodeMemberProperty CreatePropertyDeclaration(CodeMemberField field, string name, string typeName) {
CodeMemberProperty prop = new CodeMemberProperty();
prop.Type = new CodeTypeReference(typeName);
prop.Name = name;
prop.Attributes = (prop.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
//add get
CodeMethodReturnStatement ret = new CodeMethodReturnStatement();
ret.Expression = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), field.Name);
prop.GetStatements.Add(ret);
CodeAssignStatement propertySet = new CodeAssignStatement();
CodeExpression left = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), field.Name);
CodeExpression right = new CodePropertySetValueReferenceExpression();
propertySet.Left = left;
propertySet.Right = right;
if (EnableDataBinding)
{
prop.SetStatements.Add(propertySet);
prop.SetStatements.Add(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), RaisePropertyChangedEventMethod.Name, new CodePrimitiveExpression(name)));
}
else
prop.SetStatements.Add(propertySet);
return prop;
}
private static void EmitBasicClassMembers(CodeTypeDeclaration srClass, string nameSpace, string baseName, string resourcesNamespace, bool internalClass, bool useStatic, bool supportsTryCatch)
{
string str;
if (resourcesNamespace != null)
{
if (resourcesNamespace.Length > 0)
{
str = resourcesNamespace + '.' + baseName;
}
else
{
str = baseName;
}
}
else if ((nameSpace != null) && (nameSpace.Length > 0))
{
str = nameSpace + '.' + baseName;
}
else
{
str = baseName;
}
CodeAttributeDeclaration declaration = new CodeAttributeDeclaration(new CodeTypeReference(typeof(SuppressMessageAttribute))) {
AttributeType = { Options = CodeTypeReferenceOptions.GlobalReference }
};
declaration.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression("Microsoft.Performance")));
declaration.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression("CA1811:AvoidUncalledPrivateCode")));
CodeConstructor constructor = new CodeConstructor();
constructor.CustomAttributes.Add(declaration);
if (useStatic || internalClass)
{
constructor.Attributes = MemberAttributes.FamilyAndAssembly;
}
else
{
constructor.Attributes = MemberAttributes.Public;
}
srClass.Members.Add(constructor);
CodeTypeReference type = new CodeTypeReference(typeof(ResourceManager), CodeTypeReferenceOptions.GlobalReference);
CodeMemberField field = new CodeMemberField(type, "resourceMan") {
Attributes = MemberAttributes.Private
};
if (useStatic)
{
field.Attributes |= MemberAttributes.Static;
}
srClass.Members.Add(field);
CodeTypeReference reference2 = new CodeTypeReference(typeof(CultureInfo), CodeTypeReferenceOptions.GlobalReference);
field = new CodeMemberField(reference2, "resourceCulture") {
Attributes = MemberAttributes.Private
};
if (useStatic)
{
field.Attributes |= MemberAttributes.Static;
}
srClass.Members.Add(field);
CodeMemberProperty property = new CodeMemberProperty();
srClass.Members.Add(property);
property.Name = "ResourceManager";
property.HasGet = true;
property.HasSet = false;
property.Type = type;
if (internalClass)
{
property.Attributes = MemberAttributes.Assembly;
}
else
{
property.Attributes = MemberAttributes.Public;
}
if (useStatic)
{
property.Attributes |= MemberAttributes.Static;
}
CodeTypeReference reference3 = new CodeTypeReference(typeof(EditorBrowsableState)) {
Options = CodeTypeReferenceOptions.GlobalReference
};
CodeAttributeArgument argument = new CodeAttributeArgument(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(reference3), "Advanced"));
CodeAttributeDeclaration declaration2 = new CodeAttributeDeclaration("System.ComponentModel.EditorBrowsableAttribute", new CodeAttributeArgument[] { argument }) {
AttributeType = { Options = CodeTypeReferenceOptions.GlobalReference }
};
property.CustomAttributes.Add(declaration2);
CodeMemberProperty property2 = new CodeMemberProperty();
srClass.Members.Add(property2);
property2.Name = "Culture";
property2.HasGet = true;
property2.HasSet = true;
property2.Type = reference2;
if (internalClass)
{
property2.Attributes = MemberAttributes.Assembly;
}
else
{
property2.Attributes = MemberAttributes.Public;
}
if (useStatic)
{
property2.Attributes |= MemberAttributes.Static;
}
property2.CustomAttributes.Add(declaration2);
CodeFieldReferenceExpression left = new CodeFieldReferenceExpression(null, "resourceMan");
CodeMethodReferenceExpression method = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(object)), "ReferenceEquals");
CodeMethodInvokeExpression condition = new CodeMethodInvokeExpression(method, new CodeExpression[] { left, new CodePrimitiveExpression(null) });
CodePropertyReferenceExpression expression4 = new CodePropertyReferenceExpression(new CodeTypeOfExpression(new CodeTypeReference(srClass.Name)), "Assembly");
CodeObjectCreateExpression initExpression = new CodeObjectCreateExpression(type, new CodeExpression[] { new CodePrimitiveExpression(str), expression4 });
CodeStatement[] trueStatements = new CodeStatement[] { new CodeVariableDeclarationStatement(type, "temp", initExpression), new CodeAssignStatement(left, new CodeVariableReferenceExpression("temp")) };
property.GetStatements.Add(new CodeConditionStatement(condition, trueStatements));
property.GetStatements.Add(new CodeMethodReturnStatement(left));
property.Comments.Add(new CodeCommentStatement("<summary>", true));
property.Comments.Add(new CodeCommentStatement(Microsoft.Build.Tasks.SR.GetString("ResMgrPropertyComment"), true));
property.Comments.Add(new CodeCommentStatement("</summary>", true));
CodeFieldReferenceExpression expression = new CodeFieldReferenceExpression(null, "resourceCulture");
property2.GetStatements.Add(new CodeMethodReturnStatement(expression));
CodePropertySetValueReferenceExpression right = new CodePropertySetValueReferenceExpression();
property2.SetStatements.Add(new CodeAssignStatement(expression, right));
property2.Comments.Add(new CodeCommentStatement("<summary>", true));
property2.Comments.Add(new CodeCommentStatement(Microsoft.Build.Tasks.SR.GetString("CulturePropertyComment1"), true));
property2.Comments.Add(new CodeCommentStatement(Microsoft.Build.Tasks.SR.GetString("CulturePropertyComment2"), true));
property2.Comments.Add(new CodeCommentStatement("</summary>", true));
}
