/**
* public boolean hasPendingChanges() { return isToBeUpdated() || isToBeCreated() || isToBeDeleted(); }
*/
protected void ImplementHasPendingChanges(PropertyInstance p_hasPendingChanges, PropertyInstance p_ToBeUpdated, PropertyInstance p_ToBeCreated,
PropertyInstance p_ToBeDeleted)
{
IMethodVisitor mg = VisitMethod(p_hasPendingChanges.Getter);
p_hasPendingChanges = PropertyInstance.FindByTemplate(p_hasPendingChanges, false);
p_hasPendingChanges.AddAnnotation(c_ignoreToBeUpdated);
p_hasPendingChanges.AddAnnotation(c_fireThisOPC, p_ToBeCreated.Name);
p_hasPendingChanges.AddAnnotation(c_fireThisOPC, p_ToBeUpdated.Name);
p_hasPendingChanges.AddAnnotation(c_fireThisOPC, p_ToBeDeleted.Name);
Label trueLabel = mg.NewLabel();
mg.LoadThis();
mg.InvokeVirtual(p_ToBeUpdated.Getter);
mg.IfZCmp(CompareOperator.NE, trueLabel);
mg.LoadThis();
mg.InvokeVirtual(p_ToBeCreated.Getter);
mg.IfZCmp(CompareOperator.NE, trueLabel);
mg.LoadThis();
mg.InvokeVirtual(p_ToBeDeleted.Getter);
mg.IfZCmp(CompareOperator.NE, trueLabel);
mg.Push(false);
mg.ReturnValue();
mg.Mark(trueLabel);
mg.Push(true);
mg.ReturnValue();
mg.EndMethod();
}
protected void ImplementNotifyPropertyChanged(PropertyInstance p_propertyChangeTemplate, MethodInstance m_getPropertyChangeSupport)
{
// implement IPropertyChanged
foreach (MethodInfo rMethod in typeof(INotifyPropertyChanged).GetMethods())
{
MethodInstance existingMethod = MethodInstance.FindByTemplate(rMethod, true);
if (existingMethod != null)
{
continue;
}
MethodInstance method = new MethodInstance(rMethod);
IMethodVisitor mg = VisitMethod(method);
mg.CallThisGetter(p_propertyChangeTemplate);
// this.propertyChangeSupport
mg.CallThisGetter(m_getPropertyChangeSupport);
// listener
mg.LoadArg(0);
if ("add_PropertyChanged".Equals(method.Name))
{
// addPropertyChangeListener(propertyChangeSupport, listener)
mg.InvokeVirtual(m_addPropertyChangeListener);
}
else
{
// removePropertyChangeListener(propertyChangeSupport, listener)
mg.InvokeVirtual(m_removePropertyChangeListener);
}
mg.ReturnValue();
mg.EndMethod();
}
}
public virtual void InvokeVirtual(MethodInstance method)
{
if (mv != null)
{
mv.InvokeVirtual(method);
}
}
protected Type InvokeGetProperty(IMethodVisitor mv, IPropertyInfo property, Type typeOfArgumentOnStack)
{
if (property is MethodPropertyInfo)
{
MethodInfo method = ((MethodPropertyInfo)property).Getter;
MethodInstance mi = new MethodInstance(method);
if (method.DeclaringType.IsInterface)
{
mv.InvokeInterface(mi);
}
else
{
if (!mi.Owner.Equals(typeOfArgumentOnStack))
{
mv.CheckCast(mi.Owner);
}
mv.InvokeVirtual(mi);
typeOfArgumentOnStack = mi.ReturnType.Type;
}
}
else
{
FieldInfo field = ((FieldPropertyInfo)property).BackingField;
FieldInstance fi = new FieldInstance(field);
mv.GetField(fi);
typeOfArgumentOnStack = fi.Type.Type;
}
return(typeOfArgumentOnStack);
}
protected MethodInstance ImplementUsePropertyChangeSupport(PropertyInstance p_propertyChangeTemplate, FieldInstance f_propertyChangeSupport)
{
MethodInstance m_getPropertyChangeSupport = MethodInstance.FindByTemplate(template_m_usePropertyChangeSupport, true);
if (m_getPropertyChangeSupport == null)
{
// create field that holds propertyChangeSupport
f_propertyChangeSupport = ImplementField(f_propertyChangeSupport);
IMethodVisitor mg = VisitMethod(template_m_usePropertyChangeSupport);
HideFromDebug(mg.Method);
Label l_pcsValid = mg.NewLabel();
mg.GetThisField(f_propertyChangeSupport);
mg.Dup();
mg.IfNonNull(l_pcsValid);
mg.Pop(); // remove 2nd null instance from stack caused by previous dup
mg.PutThisField(f_propertyChangeSupport, delegate(IMethodVisitor mg2)
{
mg.CallThisGetter(p_propertyChangeTemplate);
mg.LoadThis();
mg.InvokeVirtual(m_newPropertyChangeSupport);
});
mg.GetThisField(f_propertyChangeSupport);
mg.Mark(l_pcsValid);
mg.ReturnValue(); // return instance already on the stack by both branches
mg.EndMethod();
m_getPropertyChangeSupport = mg.Method;
}
return(m_getPropertyChangeSupport);
}
protected void ImplementToStringMethod(PropertyInstance p_entityEqualsTemplate)
{
{
MethodInstance methodTemplate = new MethodInstance(null, typeof(Object), typeof(String), "ToString");
MethodInstance method = MethodInstance.FindByTemplate(methodTemplate, true);
if (NewType.GetType(typeof(Object)).Equals(method.Owner) || method.Access.HasFlag(MethodAttributes.Abstract))
{
IMethodVisitor mg = VisitMethod(methodTemplate);
mg.CallThisGetter(p_entityEqualsTemplate);
mg.LoadThis();
mg.LoadThis();
mg.InvokeVirtual(entityEquals_toString_Obj);
mg.ReturnValue();
mg.EndMethod();
}
}
{
MethodInstance methodTemplate = new MethodInstance(null, typeof(IPrintable), typeof(void), "ToString", typeof(StringBuilder));
MethodInstance method = MethodInstance.FindByTemplate(methodTemplate, true);
if (method == null || method.Access.HasFlag(MethodAttributes.Abstract))
{
IMethodVisitor mg = VisitMethod(methodTemplate);
mg.CallThisGetter(p_entityEqualsTemplate);
mg.LoadThis();
mg.LoadArgs();
mg.InvokeVirtual(entityEquals_toString_Printable);
mg.ReturnValue();
mg.EndMethod();
}
}
}
protected static void ImplementDefaultDelegatingMethod(IMethodVisitor mg, PropertyInstance p_compositeIdTemplate, PropertyInstance p_idMembers,
MethodInstance delegatedMethod)
{
mg.CallThisGetter(p_compositeIdTemplate);
mg.CallThisGetter(p_idMembers);
mg.LoadThis();
mg.LoadArgs();
mg.InvokeVirtual(delegatedMethod);
mg.ReturnValue();
mg.EndMethod();
}
protected void ImplementSetUninitialized(PropertyInstance p_valueHolderContainerTemplate, PropertyInstance p_valueHolderContainerEntry)
{
{
IMethodVisitor mv = VisitMethod(m_template_setUninitialized_Member);
mv.CallThisGetter(p_valueHolderContainerEntry);
mv.LoadThis();
mv.LoadArgs();
mv.InvokeVirtual(m_vhce_setUninitialized_Member);
mv.ReturnValue();
mv.EndMethod();
}
}
protected void InvokeSetProperty(IMethodVisitor mv, IPropertyInfo property)
{
if (property is MethodPropertyInfo)
{
MethodInfo method = ((MethodPropertyInfo)property).Setter;
mv.InvokeVirtual(new MethodInstance(method));
}
else
{
FieldInfo field = ((FieldPropertyInfo)property).BackingField;
mv.PutField(new FieldInstance(field));
}
}
protected void ImplementConstructor(MethodInstance template_m_setPrimitivePropertyPrivilege, MethodInstance template_m_setRelationPropertyPrivilege)
{
IBytecodeBehaviorState state = State;
ConstructorInfo constructor = state.CurrentType.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[] { typeof(bool), typeof(bool), typeof(bool), typeof(bool), typeof(bool),
typeof(IPropertyPrivilege[]), typeof(IPropertyPrivilege[]) }, null);
ConstructorInstance c_method = new ConstructorInstance(constructor);
IMethodVisitor mg = VisitMethod(c_method);
mg.LoadThis();
mg.LoadArgs();
mg.InvokeConstructor(c_method);
Type propertyPrivilegeType = typeof(IPropertyPrivilege);
for (int primitiveIndex = 0, size = metaData.PrimitiveMembers.Length; primitiveIndex < size; primitiveIndex++)
{
mg.LoadThis();
mg.Push(primitiveIndex);
mg.LoadArg(5);
mg.Push(primitiveIndex);
mg.ArrayLoad(propertyPrivilegeType);
mg.InvokeVirtual(template_m_setPrimitivePropertyPrivilege);
}
for (int relationIndex = 0, size = metaData.RelationMembers.Length; relationIndex < size; relationIndex++)
{
mg.LoadThis();
mg.Push(relationIndex);
mg.LoadArg(6);
mg.Push(relationIndex);
mg.ArrayLoad(propertyPrivilegeType);
mg.InvokeVirtual(template_m_setRelationPropertyPrivilege);
}
mg.ReturnValue();
mg.EndMethod();
}
protected void ImplementToString()
{
PropertyInstance p_objRefTemplate = GetObjRefTemplatePI(this);
MethodInstance methodSb;
{
methodSb = MethodInstance.FindByTemplate(template_m_toStringSb, true);
if (methodSb == null || methodSb.Access.HasFlag(MethodAttributes.Abstract))
{
IMethodVisitor mg = VisitMethod(template_m_toStringSb);
mg.CallThisGetter(p_objRefTemplate);
mg.LoadThis();
mg.LoadArgs();
mg.InvokeVirtual(m_objRef_toStringSb);
mg.ReturnValue();
mg.EndMethod();
methodSb = mg.Method;
}
}
{
MethodInstance method = MethodInstance.FindByTemplate(template_m_toString, true);
if (method == null || NewType.GetType(typeof(Object)).Equals(method.Owner) || methodSb.Access.HasFlag(MethodAttributes.Abstract))
{
IMethodVisitor mg = VisitMethod(template_m_toString);
LocalVariableInfo loc_sb = mg.NewLocal(typeof(StringBuilder));
mg.LoadThis();
mg.NewInstance(c_stringBuilder, null);
mg.StoreLocal(loc_sb);
mg.LoadLocal(loc_sb);
mg.InvokeVirtual(methodSb);
mg.LoadLocal(loc_sb);
mg.InvokeVirtual(new MethodInstance(null, typeof(StringBuilder), typeof(String), "ToString"));
mg.ReturnValue();
mg.EndMethod();
}
}
}
protected void ImplementHashCodeMethod(PropertyInstance p_entityEqualsTemplate)
{
MethodInstance methodTemplate = new MethodInstance(null, typeof(Object), typeof(int), "GetHashCode");
MethodInstance method = MethodInstance.FindByTemplate(methodTemplate, true);
if (NewType.GetType(typeof(Object)).Equals(method.Owner) || method.Access.HasFlag(MethodAttributes.Abstract))
{
IMethodVisitor mg = VisitMethod(methodTemplate);
mg.CallThisGetter(p_entityEqualsTemplate);
mg.LoadThis();
mg.LoadArgs();
mg.InvokeVirtual(entityEquals_HashCode);
mg.ReturnValue();
mg.EndMethod();
}
}
protected void ImplementHashCode()
{
PropertyInstance p_objRefTemplate = GetObjRefTemplatePI(this);
MethodInstance method = MethodInstance.FindByTemplate(template_m_hashCode, true);
if (method == null || method.Access.HasFlag(MethodAttributes.Abstract))
{
IMethodVisitor mg = VisitMethod(template_m_hashCode);
mg.CallThisGetter(p_objRefTemplate);
mg.LoadThis();
mg.LoadArgs();
mg.InvokeVirtual(m_objRef_hashCode);
mg.ReturnValue();
mg.EndMethod();
}
}
protected void ImplementGetAttribute(IPropertyInfo[] property)
{
HashMap <Type, Attribute> typeToAttributeMap = new HashMap <Type, Attribute>();
Attribute[] annotations = property[property.Length - 1].GetAnnotations();
foreach (Attribute annotation in annotations)
{
typeToAttributeMap.Put(annotation.GetType(), annotation);
}
FieldInstance f_typeToAttributeMap = ImplementStaticAssignedField("sf__typeToAttributeMap", typeToAttributeMap);
IMethodVisitor mv = VisitMethod(template_m_getAttribute);
mv.GetThisField(f_typeToAttributeMap);
mv.LoadArg(0);
mv.InvokeVirtual(new MethodInstance(null, typeof(HashMap <Type, Attribute>), typeof(Attribute), "Get", typeof(Type)));
// mv.CheckCast(typeof(Attribute));
mv.ReturnValue();
mv.EndMethod();
}
protected void ImplementPropertyChanged(PropertyInstance p_propertyChangeTemplate)
{
MethodInstance m_propertyChanged_super = MethodInstance.FindByTemplate(template_m_PropertyChanged, true);
IMethodVisitor mv = VisitMethod(template_m_PropertyChanged);
if (m_propertyChanged_super != null)
{
mv.LoadThis();
mv.LoadArgs();
mv.InvokeSuperOfCurrentMethod();
}
mv.CallThisGetter(p_propertyChangeTemplate);
mv.LoadThis();
mv.LoadArgs();
// call PCT.HandlePropertyChange(this, sender, arg)
mv.InvokeVirtual(m_handlePropertyChange);
mv.ReturnValue();
mv.EndMethod();
}
protected void ImplementSelfGetter(PropertyInstance p_valueHolderContainerTemplate)
{
NewType owner = State.NewType;
MethodInstance m_getSelf = new MethodInstance(owner, typeof(IValueHolderContainer), typeof(IObjRelation), "Get__Self", typeof(int));
{
// public IObjRelation getSelf(String memberName)
// {
// return ValueHolderContainerTemplate.GetSelf(this, relationIndex);
// }
IMethodVisitor mv = VisitMethod(m_getSelf);
mv.CallThisGetter(p_valueHolderContainerTemplate);
// this
mv.LoadThis();
// relationIndex
mv.LoadArgs();
mv.InvokeVirtual(m_template_getSelf);
mv.ReturnValue();
mv.EndMethod();
}
}
public override void VisitEnd()
{
MethodInstance m_get__Id = MethodInstance.FindByTemplate(GetIdMethodCreator.template_m_entityEquals_getId, true);
if (m_get__Id != null)
{
base.VisitEnd();
return;
}
MethodInstance m_getEntityMetaData = EntityMetaDataHolderVisitor.GetImplementedGetEntityMetaData(this, metaData);
IMethodVisitor mg = VisitMethod(GetIdMethodCreator.template_m_entityEquals_getId);
mg.CallThisGetter(m_getEntityMetaData);
mg.InvokeInterface(new MethodInstance(null, typeof(IEntityMetaData), typeof(PrimitiveMember), "get_IdMember"));
mg.LoadThis();
mg.Push(false);
mg.InvokeVirtual(EntityMetaDataMemberVisitor.template_m_getValueWithFlag);
mg.ReturnValue();
mg.EndMethod();
base.VisitEnd();
}
/**
* public boolean isToBeCreated() { return get__Id() == null; }
*
* @param owner
*/
protected PropertyInstance ImplementToBeCreated(PropertyInstance p_toBeCreated)
{
IMethodVisitor mg = VisitMethod(p_toBeCreated.Getter);
p_toBeCreated = PropertyInstance.FindByTemplate(p_toBeCreated, false);
Member idMember = metaData.IdMember;
if (idMember is CompositeIdMember)
{
List <String> names = new List <String>();
foreach (Member itemMember in ((CompositeIdMember)idMember).Members)
{
names.Add(itemMember.Name);
}
p_toBeCreated.AddAnnotation(c_fireThisOPC, new Object[] { names.ToArray() });
}
else
{
p_toBeCreated.AddAnnotation(c_fireThisOPC, idMember.Name);
}
Label trueLabel = mg.NewLabel();
mg.LoadThis();
mg.InvokeVirtual(GetIdMethodCreator.GetGetId());
mg.IfNull(trueLabel);
mg.Push(false);
mg.ReturnValue();
mg.Mark(trueLabel);
mg.Push(true);
mg.ReturnValue();
mg.EndMethod();
return(p_toBeCreated);
}
protected void ImplementRelationGetter(String propertyName, MethodInstance m_getMethod_template, MethodInstance m_setMethod, int relationIndex,
PropertyInstance p_valueHolderContainerTemplate, PropertyInstance p_targetCache, PropertyInstance p_relationMembers, FieldInstance f_initialized,
FieldInstance f_objRefs)
{
// public String getPropertyName()
// {
// if (!PropertyName$initialized)
// {
// setPropertyName(RelationsGetterVisitor.valueHolderContainer_getValue(this, $relationMembers, get__IndexOfPropertyName(), $targetCache, $beanContext,
// propertyName$objRefs));
// }
// return super.getPropertyName();
// }
Script script_getVHC;
if (EmbeddedEnhancementHint.HasMemberPath(State.Context))
{
PropertyInstance p_rootEntity = EmbeddedTypeVisitor.GetRootEntityProperty(this);
script_getVHC = delegate(IMethodVisitor mv)
{
mv.CallThisGetter(p_rootEntity);
};
}
else
{
script_getVHC = delegate(IMethodVisitor mv)
{
// this
mv.LoadThis();
};
}
MethodInstance m_getMethod;
{
PropertyInstance p_cacheModification = SetCacheModificationMethodCreator.GetCacheModificationPI(this);
MethodInstance m_getMethod_scoped = new MethodInstance(State.NewType,
MethodAttributes.HideBySig | MethodAttributes.Private | MethodAttributes.Final, NewType.VOID_TYPE, propertyName + "$DoInitialize");
{
IMethodVisitor mg = VisitMethod(m_getMethod_scoped);
// this => for this.setPropertyName(...)
mg.LoadThis();
// call template.getValue(..)
mg.CallThisGetter(p_valueHolderContainerTemplate);
// getVhc()
script_getVHC.Invoke(mg);
// $relationMembers
mg.CallThisGetter(p_relationMembers);
// get__IndexOfPropertyName()
mg.Push(relationIndex);
// $targetCache
mg.CallThisGetter(p_targetCache);
// propertyName$objRefs
mg.GetThisField(f_objRefs);
mg.InvokeVirtual(m_template_getValue);
mg.CheckCast(m_setMethod.Parameters[0].Type);
mg.InvokeVirtual(m_setMethod);
mg.ReturnValue();
mg.EndMethod();
}
{
IMethodVisitor mg = base.VisitMethod(m_getMethod_template);
m_getMethod = mg.Method;
HideFromDebug(m_getMethod);
Label l_initialized = mg.NewLabel();
mg.GetThisField(f_initialized);
mg.PushEnum(ValueHolderState.INIT);
mg.IfCmp(typeof(ValueHolderState), CompareOperator.EQ, l_initialized);
SetCacheModificationMethodCreator.CacheModificationInternalUpdate(p_cacheModification, mg,
delegate(IMethodVisitor mv2)
{
mv2.LoadThis();
mv2.InvokeOnExactOwner(m_getMethod_scoped);
});
mg.Mark(l_initialized);
mg.LoadThis();
mg.InvokeSuperOfCurrentMethod();
mg.ReturnValue();
mg.EndMethod();
}
}
// public String getPropertyName$NoInit()
// {
// return super.getPropertyName();
// }
{
MethodInstance m_getNoInit = m_getMethod_template.DeriveName(ValueHolderIEC.GetGetterNameOfRelationPropertyWithNoInit(propertyName));
IMethodVisitor mg = base.VisitMethod(m_getNoInit);
PropertyInstance p_getNoInit = PropertyInstance.FindByTemplate(propertyName + ValueHolderIEC.GetNoInitSuffix(), m_getNoInit.ReturnType, false);
p_getNoInit.AddAnnotation(c_fireThisOPC, propertyName);
p_getNoInit.AddAnnotation(c_fireTargetOPC, propertyName);
mg.LoadThis();
mg.InvokeSuper(m_getMethod);
mg.ReturnValue();
mg.EndMethod();
}
}
protected void ImplementPropertyChangeOnProperty(PropertyInstance propertyInfo,
PropertyInstance p_propertyChangeTemplate, MethodInstance m_firePropertyChange, FieldInstance f_propertyChangeSupport)
{
// add property change detection and notification
if (propertyInfo.Getter == null || propertyInfo.Setter == null)
{
return;
}
if (InitializeEmbeddedMemberVisitor.IsEmbeddedMember(metaData, propertyInfo.Name))
{
return;
}
PropertyInstance p_getterMethodHandle = ImplementAssignedReadonlyProperty(propertyInfo.Name + "$MethodHandle",
new MethodHandleValueResolver(PropertyInfoProvider, propertyInfo.Name));
Type propertyType = propertyInfo.PropertyType.Type;
MethodInstance m_hasPropertyChanged = GetApplicableHasPropertyChangedOverload(propertyType);
// check value type of last parameter
bool isBoxingNeededForHasPropertyChanged = IsBoxingNeededForHasPropertyChangedOverload(m_hasPropertyChanged, propertyType);
IMethodVisitor mg = VisitMethod(propertyInfo.Setter);
Label l_finish = mg.NewLabel();
Label l_noOldValue = mg.NewLabel();
Label l_noChangeCheck = mg.NewLabel();
LocalVariableInfo loc_oldValue;
if (isBoxingNeededForHasPropertyChanged)
{
loc_oldValue = mg.NewLocal(typeof(Object));
}
else
{
loc_oldValue = mg.NewLocal(propertyType);
}
LocalVariableInfo loc_valueChanged = mg.NewLocal <bool>();
MethodInstance m_getSuper = EnhancerUtil.GetSuperGetter(propertyInfo);
bool relationProperty = m_getSuper.Name.EndsWith(ValueHolderIEC.GetNoInitSuffix());
// initialize flag with false
mg.Push(false);
mg.StoreLocal(loc_valueChanged);
// initialize oldValue with null
mg.PushNullOrZero(loc_oldValue.LocalType);
mg.StoreLocal(loc_oldValue);
if (relationProperty)
{
// check if a setter call to an UNINITIALIZED relation occured with value null
// if it the case there would be no PCE because oldValue & newValue are both null
// but we need a PCE in this special case
Label l_noSpecialHandling = mg.NewLabel();
FieldInstance f_state = State.GetAlreadyImplementedField(ValueHolderIEC.GetInitializedFieldName(propertyInfo.Name));
mg.GetThisField(f_state);
mg.PushEnum(ValueHolderState.INIT);
mg.IfCmp(typeof(ValueHolderState), CompareOperator.EQ, l_noSpecialHandling);
mg.Push(true);
mg.StoreLocal(loc_valueChanged);
mg.Mark(l_noSpecialHandling);
}
// check if value should be checked to decide for a PCE
mg.LoadLocal(loc_valueChanged);
mg.IfZCmp(CompareOperator.NE, l_noOldValue);
// get old field value calling super property getter
mg.LoadThis();
mg.InvokeOnExactOwner(m_getSuper);
if (isBoxingNeededForHasPropertyChanged)
{
mg.Box(propertyType);
}
mg.StoreLocal(loc_oldValue);
mg.Mark(l_noOldValue);
// set new field value calling super property setter
mg.LoadThis();
mg.LoadArg(0);
mg.InvokeOnExactOwner(EnhancerUtil.GetSuperSetter(propertyInfo));
mg.PopIfReturnValue(EnhancerUtil.GetSuperSetter(propertyInfo));
// check if value should be checked to decide for a PCE
mg.LoadLocal(loc_valueChanged);
mg.IfZCmp(CompareOperator.NE, l_noChangeCheck);
LocalVariableInfo loc_newValue = null;
if (isBoxingNeededForHasPropertyChanged)
{
loc_newValue = mg.NewLocal(typeof(Object)); // loc_1 Object newValue
// Object loc_1 = (Object)value;
mg.LoadArg(0);
mg.Box(propertyType);
mg.StoreLocal(loc_newValue);
}
mg.CallThisGetter(p_propertyChangeTemplate);
// call HasPropertyChanged (static)
mg.LoadThis(); // "this" as Object obj
mg.Push(propertyInfo.Name); // String propertyName
mg.LoadLocal(loc_oldValue);
if (loc_newValue != null)
{
mg.LoadLocal(loc_newValue);
}
else
{
mg.LoadArg(0);
}
mg.InvokeVirtual(m_hasPropertyChanged);
//// if (!result)
//// { return; }
mg.IfZCmp(CompareOperator.EQ, l_finish);
mg.Mark(l_noChangeCheck);
// call firePropertyChange on this
mg.LoadThis();
// propertyChangeSupport
mg.GetThisField(f_propertyChangeSupport);
// property
mg.CallThisGetter(p_getterMethodHandle);
// oldValue
mg.LoadLocal(loc_oldValue);
if (!isBoxingNeededForHasPropertyChanged && propertyType.IsValueType)
{
// old value has not already been boxed but it is now necessary
mg.ValueOf(propertyType);
}
// newValue
if (loc_newValue != null)
{
mg.LoadLocal(loc_newValue);
}
else
{
mg.LoadArg(0);
if (propertyType.IsValueType)
{
mg.ValueOf(propertyType);
}
}
// firePropertyChange(propertyChangeSupport, property, oldValue, newValue)
mg.InvokeVirtual(m_firePropertyChange);
// return
mg.Mark(l_finish);
mg.ReturnVoidOrThis();
mg.EndMethod();
}
protected PropertyInstance ImplementNotifyPropertyChangedSource(PropertyInstance p_propertyChangeTemplate,
FieldInstance f_propertyChangeSupport)
{
MethodInstance m_onPropertyChanged_Values = MethodInstance.FindByTemplate(template_m_onPropertyChanged_Values, true);
if (m_onPropertyChanged_Values == null)
{
IMethodVisitor mv = VisitMethod(template_m_onPropertyChanged_Values);
mv.CallThisGetter(p_propertyChangeTemplate);
mv.LoadThis();
mv.GetThisField(f_propertyChangeSupport);
// getMethodHandle(sender, propertyName)
mv.CallThisGetter(p_propertyChangeTemplate);
mv.LoadThis();
mv.LoadArg(0);
mv.InvokeVirtual(m_getMethodHandle);
mv.LoadArg(1);
mv.LoadArg(2);
// firePropertyChange(sender, propertyChangeSupport, property, oldValue, newValue)
mv.InvokeVirtual(m_firePropertyChange);
mv.PopIfReturnValue(m_firePropertyChange);
mv.ReturnVoidOrThis();
mv.EndMethod();
m_onPropertyChanged_Values = mv.Method;
}
MethodInstance m_onPropertyChanged = MethodInstance.FindByTemplate(template_m_onPropertyChanged, true);
if (m_onPropertyChanged == null)
{
IMethodVisitor mv = VisitMethod(template_m_onPropertyChanged);
mv.LoadThis();
mv.LoadArg(0);
mv.PushNull();
mv.PushNull();
mv.InvokeVirtual(m_onPropertyChanged_Values);
mv.PopIfReturnValue(m_onPropertyChanged_Values);
mv.ReturnVoidOrThis();
mv.EndMethod();
m_onPropertyChanged = mv.Method;
}
PropertyInstance p_pceHandlers = PropertyInstance.FindByTemplate(p_propertyChangeSupport, true);
if (p_pceHandlers == null)
{
HideFromDebug(ImplementGetter(p_propertyChangeSupport.Getter, f_propertyChangeSupport));
p_pceHandlers = PropertyInstance.FindByTemplate(p_propertyChangeSupport, false);
}
if (EmbeddedEnhancementHint.HasMemberPath(State.Context))
{
PropertyInstance p_parentEntity = EmbeddedTypeVisitor.GetParentObjectProperty(this);
if (MethodInstance.FindByTemplate(p_parentChildEventHandler.Getter, true) == null)
{
IMethodVisitor mv = VisitMethod(p_parentChildEventHandler.Getter);
mv.CallThisGetter(p_parentEntity);
mv.InvokeInterface(p_parentChildEventHandler.Getter);
mv.ReturnValue();
mv.EndMethod();
HideFromDebug(mv.Method);
}
if (MethodInstance.FindByTemplate(p_collectionEventHandler.Getter, true) == null)
{
IMethodVisitor mv = VisitMethod(p_collectionEventHandler.Getter);
mv.CallThisGetter(p_parentEntity);
mv.InvokeInterface(p_collectionEventHandler.Getter);
mv.ReturnValue();
mv.EndMethod();
HideFromDebug(mv.Method);
}
}
else
{
if (MethodInstance.FindByTemplate(p_parentChildEventHandler.Getter, true) == null)
{
HideFromDebug(ImplementLazyInitProperty(p_parentChildEventHandler, delegate(IMethodVisitor mv)
{
MethodInstance method = new MethodInstance(null, typeof(NotifyPropertyChangedClassVisitor), typeof(PropertyChangedEventHandler), "CreateParentChildEventHandler", typeof(Object));
mv.LoadThis();
mv.InvokeStatic(method);
}));
}
if (MethodInstance.FindByTemplate(p_collectionEventHandler.Getter, true) == null)
{
HideFromDebug(ImplementLazyInitProperty(p_collectionEventHandler, delegate(IMethodVisitor mv)
{
MethodInstance method = new MethodInstance(null, typeof(NotifyPropertyChangedClassVisitor), typeof(NotifyCollectionChangedEventHandler), "CreateCollectionEventHandler", typeof(Object));
mv.LoadThis();
mv.InvokeStatic(method);
}));
}
}
//MethodAttributes ma = MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig;
//{
// ConstructorInfo pceaCI = typeof(PropertyChangedEventArgs).GetConstructor(new Type[] { typeof(String) });
// MethodBuilder mb = VisitorUtil.DefineMethod(vs, onPropertyChangedMI_string, ma);
// ILGenerator gen = mb.GetILGenerator();
// gen.Emit(OpCodes.Ldarg_0);
// gen.Emit(OpCodes.Ldarg_1);
// gen.Emit(OpCodes.Newobj, pceaCI);
// gen.Emit(OpCodes.Call, onPropertyChangedMI_pceArg);
// gen.Emit(OpCodes.Ret);
//}
//{
// MethodBuilder mb = VisitorUtil.DefineMethod(vs, onPropertyChangedMI_pceArg, ma);
// ILGenerator gen = mb.GetILGenerator();
// gen.Emit(OpCodes.Ldarg_0);
// gen.Emit(OpCodes.Call, pctPI.GetGetMethod());
// gen.Emit(OpCodes.Ldarg_0);
// gen.Emit(OpCodes.Ldarg_1);
// gen.Emit(OpCodes.Call, FirePropertyChangedMI);
// gen.Emit(OpCodes.Ret);
//}
// List<PropertyChangedEventHandler> PropertyChangedEventHandlers { get; }
//void OnPropertyChanged(String propertyName);
//void OnPropertyChanged(PropertyChangedEventArgs args);
return(p_pceHandlers);
}