protected Script CreateEmbeddedObjectInstance(PropertyInstance p_embeddedMemberTemplate, Member firstMember, String memberPath)
{
PropertyInstance property = PropertyInstance.FindByTemplate(firstMember.Name, firstMember.RealType, false);
PropertyInstance p_rootEntity = memberPathSplit == null ? null : EmbeddedTypeVisitor.GetRootEntityProperty(this);
return(delegate(IMethodVisitor mg2)
{
mg2.CallThisSetter(property, delegate(IMethodVisitor mg)
{
// Object p_embeddedMemberTemplate.createEmbeddedObject(Class<?> embeddedType, Class<?> entityType, Object parentObject, String
// memberPath)
mg.CallThisGetter(p_embeddedMemberTemplate);
mg.Push(firstMember.RealType); // embeddedType
if (p_rootEntity != null)
{
mg.CallThisGetter(p_rootEntity);
mg.CheckCast(EntityMetaDataHolderVisitor.m_template_getEntityMetaData.Owner);
mg.InvokeInterface(EntityMetaDataHolderVisitor.m_template_getEntityMetaData);
}
else
{
mg.CallThisGetter(EntityMetaDataHolderVisitor.m_template_getEntityMetaData);
}
mg.InvokeInterface(new MethodInstance(null, typeof(IEntityMetaData), typeof(Type), "get_EnhancedType"));
mg.LoadThis(); // parentObject
mg.Push(memberPath);
mg.InvokeVirtual(template_m_createEmbeddedObject);
mg.CheckCast(firstMember.RealType);
});
});
}
public static PropertyInstance GetEntityEqualsTemplateProperty(IClassVisitor cv)
{
Object bean = State.BeanContext.GetService(templateType);
PropertyInstance p_embeddedTypeTemplate = PropertyInstance.FindByTemplate(templatePropertyName, NewType.GetType(bean.GetType()), true);
if (p_embeddedTypeTemplate != null)
{
return(p_embeddedTypeTemplate);
}
return(cv.ImplementAssignedReadonlyProperty(templatePropertyName, bean));
}
public virtual PropertyInstance ImplementGetter(PropertyInstance property, FieldInstance field)
{
MethodInstance getter = property.Getter;
if (getter == null)
{
getter = new MethodInstance(State.NewType, MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.SpecialName,
property.PropertyType, "get_" + property.Name);
}
ImplementGetter(getter, field);
return(PropertyInstance.FindByTemplate(property, false));
}
public virtual PropertyInstance ImplementSetter(PropertyInstance property, FieldInstance field)
{
ParamChecker.AssertParamNotNull(property, "property");
ParamChecker.AssertParamNotNull(field, "field");
MethodInstance setter = property.Setter;
if (setter == null)
{
setter = new MethodInstance(State.NewType, MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.SpecialName,
NewType.VOID_TYPE, "set_" + property.Name, property.PropertyType);
}
ImplementSetter(setter, field);
return(PropertyInstance.FindByTemplate(property, false));
}
/**
* {@inheritDoc}
*/
public override void VisitEnd()
{
FieldInstance f_propertyChangeSupport = GetPropertyChangeSupportField();
PropertyInstance p_propertyChangeTemplate = GetPropertyChangeTemplatePI(this);
ImplementPropertyChangeConfigurable();
MethodInstance m_getPropertyChangeSupport = ImplementUsePropertyChangeSupport(p_propertyChangeTemplate, f_propertyChangeSupport);
f_propertyChangeSupport = State.GetAlreadyImplementedField(f_propertyChangeSupport.Name);
ImplementNotifyPropertyChanged(p_propertyChangeTemplate, m_getPropertyChangeSupport);
MethodInstance m_firePropertyChange = ImplementFirePropertyChange(p_propertyChangeTemplate);
ImplementNotifyPropertyChangedSource(p_propertyChangeTemplate, f_propertyChangeSupport);
if (properties == null)
{
ImplementCollectionChanged(p_propertyChangeTemplate);
ImplementPropertyChanged(p_propertyChangeTemplate);
// handle all properties found
IPropertyInfo[] props = PropertyInfoProvider.GetProperties(State.CurrentType);
foreach (IPropertyInfo prop in props)
{
if (prop.Name.EndsWith(ValueHolderIEC.GetNoInitSuffix()))
{
continue;
}
PropertyInstance propInfo = PropertyInstance.FindByTemplate(prop.Name, prop.PropertyType, true);
if (propInfo == null)
{
continue;
}
ImplementPropertyChangeOnProperty(propInfo, p_propertyChangeTemplate, m_firePropertyChange, f_propertyChangeSupport);
}
}
else
{
foreach (String propertyName in properties)
{
PropertyInstance propInfo = PropertyInstance.FindByTemplate(propertyName, (NewType)null, false);
ImplementPropertyChangeOnProperty(propInfo, p_propertyChangeTemplate, m_firePropertyChange, f_propertyChangeSupport);
}
}
base.VisitEnd();
}
protected void ImplementValueHolderCode(PropertyInstance p_valueHolderContainerTemplate, PropertyInstance p_targetCache, PropertyInstance p_relationMembers)
{
RelationMember[] relationMembers = metaData.RelationMembers;
NewType owner = State.NewType;
for (int relationIndex = relationMembers.Length; relationIndex-- > 0;)
{
RelationMember relationMember = relationMembers[relationIndex];
relationMember = (RelationMember)GetApplicableMember(relationMember);
if (relationMember == null)
{
// member is handled in another type
continue;
}
String propertyName = relationMember.Name;
IPropertyInfo propertyInfo = propertyInfoProvider.GetProperty(relationMember.DeclaringType, propertyName);
PropertyInstance prop = PropertyInstance.FindByTemplate(propertyInfo, true);
MethodInstance m_get = prop != null ? prop.Getter : new MethodInstance(((MethodPropertyInfo)propertyInfo).Getter);
MethodInstance m_set = prop != null ? prop.Setter : new MethodInstance(((MethodPropertyInfo)propertyInfo).Setter);
FieldInstance f_objRefs = GetObjRefsFieldByPropertyName(propertyName);
FieldInstance f_objRefs_existing = State.GetAlreadyImplementedField(f_objRefs.Name);
FieldInstance f_initialized = GetInitializedFieldByPropertyName(propertyName);
FieldInstance f_initialized_existing = State.GetAlreadyImplementedField(f_initialized.Name);
if (f_objRefs_existing == null)
{
f_objRefs_existing = ImplementField(f_objRefs);
ImplementGetter(new MethodInstance(null, MethodAttributes.Public, f_objRefs_existing.Type, "get_" + f_objRefs_existing.Name),
f_objRefs_existing);
ImplementSetter(
new MethodInstance(null, MethodAttributes.Public, NewType.VOID_TYPE, "set_" + f_objRefs_existing.Name, f_objRefs_existing.Type),
f_objRefs_existing);
}
if (f_initialized_existing == null)
{
f_initialized_existing = ImplementField(f_initialized);
ImplementGetter(new MethodInstance(null, MethodAttributes.Public, f_initialized_existing.Type, "get_" + f_initialized_existing.Name),
f_initialized_existing);
ImplementSetter(new MethodInstance(null, MethodAttributes.Public, NewType.VOID_TYPE, "set_" + f_initialized_existing.Name, f_initialized_existing.Type), f_initialized_existing);
}
ImplementRelationGetter(propertyName, m_get, m_set, relationIndex, p_valueHolderContainerTemplate, p_targetCache, p_relationMembers, f_initialized_existing, f_objRefs_existing);
ImplementRelationSetter(propertyName, m_set, f_initialized_existing, f_objRefs_existing);
}
}
public virtual PropertyInstance ImplementProperty(PropertyInstance property, Script getterScript, Script setterScript)
{
if (getterScript != null)
{
IMethodVisitor mv = VisitMethod(property.Getter);
getterScript.Invoke(mv);
mv.EndMethod();
}
if (setterScript != null)
{
IMethodVisitor mv = VisitMethod(property.Setter);
setterScript.Invoke(mv);
mv.EndMethod();
}
return(PropertyInstance.FindByTemplate(property, false));
}
public static PropertyInstance GetParentObjectProperty(IClassVisitor cv)
{
PropertyInstance p_parent = PropertyInstance.FindByTemplate(t_p_Parent, true);
if (p_parent != null)
{
return(p_parent);
}
FieldInstance f_parentObject = GetParentObjectField(cv);
p_parent = cv.ImplementGetter(t_p_Parent, f_parentObject);
if (p_parent == null)
{
throw new Exception("Must never happen");
}
return(p_parent);
}
/**
* 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);
}
public static PropertyInstance GetRootEntityProperty(IClassVisitor cv)
{
PropertyInstance p_root = PropertyInstance.FindByTemplate(t_p_Root, true);
if (p_root != null)
{
return(p_root);
}
PropertyInstance p_embeddedTypeTemplate = GetEmbeddedTypeTemplateProperty(cv);
p_root = cv.ImplementProperty(t_p_Root, delegate(IMethodVisitor mv)
{
mv.CallThisGetter(p_embeddedTypeTemplate);
mv.LoadThis();
mv.InvokeVirtual(m_getRoot);
mv.ReturnValue();
}, null);
if (p_root == null)
{
throw new Exception("Must never happen");
}
return(p_root);
}
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);
}
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();
}
}
