protected Type UnboxType(Type type)
{
Type unwrappedType = ImmutableTypeSet.GetUnwrappedType(type);
if (unwrappedType != null)
{
return(unwrappedType);
}
return(type);
}
protected void ImplementPrimitives()
{
Member[] primitiveMembers = metaData.PrimitiveMembers;
FieldInstance[] f_primitives = new FieldInstance[primitiveMembers.Length];
FieldInstance[] f_nullFlags = new FieldInstance[primitiveMembers.Length];
Type[] fieldType = new Type[primitiveMembers.Length];
for (int primitiveIndex = 0, size = primitiveMembers.Length; primitiveIndex < size; primitiveIndex++)
{
Member member = primitiveMembers[primitiveIndex];
Type realType = member.RealType;
Type nativeType = ImmutableTypeSet.GetUnwrappedType(realType);
bool isNullable = true;
if (nativeType == null)
{
nativeType = realType;
isNullable = false;
}
if (!nativeType.IsPrimitive)
{
nativeType = typeof(Object);
}
if (isNullable)
{
// field is a nullable numeric field. We need a flag field to handle true null case
FieldInstance f_nullFlag = ImplementField(new FieldInstance(FieldAttributes.Private, CacheMapEntryVisitor.GetFieldName(member) + "$isNull", typeof(bool)));
f_nullFlags[primitiveIndex] = f_nullFlag;
}
fieldType[primitiveIndex] = nativeType;
FieldInstance f_primitive = ImplementField(new FieldInstance(FieldAttributes.Private, CacheMapEntryVisitor.GetFieldName(member), nativeType));
f_primitives[primitiveIndex] = f_primitive;
}
ImplementGetPrimitive(primitiveMembers, f_primitives, f_nullFlags);
ImplementGetPrimitives(primitiveMembers, f_primitives, f_nullFlags);
ImplementSetPrimitives(primitiveMembers, f_primitives, f_nullFlags);
}
public PropertyEntry(Type type, String propertyName)
{
this.propertyName = propertyName;
LinkedHashSet <String> propertyNames = new LinkedHashSet <String>();
propertyNames.Add(propertyName);
PropertyInfo prop = type.GetProperty(propertyName);
doesModifyToBeUpdated = !AnnotationUtil.IsAnnotationPresent <IgnoreToBeUpdated>(prop, false);
isParentChildSetter = AnnotationUtil.IsAnnotationPresent <ParentChild>(prop, false);
isAddedRemovedCheckNecessary = !prop.PropertyType.IsPrimitive && ImmutableTypeSet.GetUnwrappedType(prop.PropertyType) == null &&
!typeof(String).Equals(prop.PropertyType) && !prop.PropertyType.IsValueType;
EvaluateDependentProperties(type, prop, propertyNames);
while (true)
{
int startCount = propertyNames.Count;
foreach (String currPropertyName in new List <String>(propertyNames))
{
PropertyInfo currProp = type.GetProperty(currPropertyName);
if (currProp.CanWrite)
{
continue;
}
// Is is just an evaluating property which has to be re-evaluated because of the change on the current property
EvaluateDependentProperties(type, currProp, propertyNames);
}
if (startCount == propertyNames.Count)
{
break;
}
}
this.propertyNames = propertyNames.ToArray();
bool firesToBeCreatedPCE = false;
unknownValues = CreateArrayOfValues(UNKNOWN_VALUE, this.propertyNames.Length);
pceArgs = new PropertyChangedEventArgs[propertyNames.Count];
int index = 0;
foreach (String invokedPropertyName in propertyNames)
{
pceArgs[index] = new PropertyChangedEventArgs(invokedPropertyName);
index++;
firesToBeCreatedPCE |= "ToBeCreated".Equals(invokedPropertyName);
}
this.firesToBeCreatedPCE = firesToBeCreatedPCE;
if (prop.CanRead)
{
getDelegate = TypeUtility.GetMemberGetDelegate(type, ValueHolderIEC.GetGetterNameOfRelationPropertyWithNoInit(prop.Name), true);
if (getDelegate == null)
{
getDelegate = TypeUtility.GetMemberGetDelegate(type, prop.Name);
}
}
if (prop.CanWrite)
{
setDelegate = TypeUtility.GetMemberSetDelegate(type, ValueHolderIEC.GetSetterNameOfRelationPropertyWithNoInit(prop.Name), true);
if (setDelegate == null)
{
setDelegate = TypeUtility.GetMemberSetDelegate(type, prop.Name);
}
}
}
public static FieldInstance ImplementNativeField(IClassVisitor cv, Member member, MethodInstance m_get, MethodInstance m_set)
{
if (member == null)
{
// NoOp implementation
{
IMethodVisitor mv = cv.VisitMethod(m_get);
mv.PushNull();
mv.ReturnValue();
mv.EndMethod();
}
{
IMethodVisitor mv = cv.VisitMethod(m_set);
mv.ReturnValue();
mv.EndMethod();
}
return(null);
}
if (member is CompositeIdMember ||
(!member.RealType.IsPrimitive && ImmutableTypeSet.GetUnwrappedType(member.RealType) == null))
{
// no business case for any complex efforts
FieldInstance f_id2 = cv.ImplementField(new FieldInstance(FieldAttributes.Private, GetFieldName(member), typeof(Object)));
cv.ImplementGetter(m_get, f_id2);
cv.ImplementSetter(m_set, f_id2);
return(f_id2);
}
Type nativeType = member.RealType;
if (!nativeType.IsPrimitive)
{
nativeType = ImmutableTypeSet.GetUnwrappedType(nativeType);
}
FieldInstance f_id = cv.ImplementField(new FieldInstance(FieldAttributes.Private, GetFieldName(member), nativeType));
{
IMethodVisitor mv = cv.VisitMethod(m_get);
mv.GetThisField(f_id);
mv.ValueOf(nativeType);
mv.ReturnValue();
mv.EndMethod();
}
{
IMethodVisitor mv = cv.VisitMethod(m_set);
mv.PutThisField(f_id, delegate(IMethodVisitor mg)
{
Label l_isNotNull = mg.NewLabel();
Label l_finish = mg.NewLabel();
mg.LoadArg(0);
mg.IfNonNull(l_isNotNull);
mg.PushNullOrZero(nativeType);
mg.GoTo(l_finish);
mg.Mark(l_isNotNull);
mg.LoadArg(0);
mg.Unbox(nativeType);
mg.Mark(l_finish);
});
mv.ReturnValue();
mv.EndMethod();
}
return(f_id);
}
