protected void AddTypeInfoMapping(IMap <String, ITypeInfoItem> typeInfoMap, IValueObjectConfig config, String boMemberName, StringBuilder sb)
{
String voMemberName = config.GetValueObjectMemberName(boMemberName);
ITypeInfoItem voMember = TypeInfoProvider.GetHierarchicMember(config.ValueType, voMemberName);
if (voMember == null)
{
return;
}
typeInfoMap.Put(boMemberName, voMember);
if (sb == null)
{
return;
}
sb.Length = 0;
String voSpecifiedName = sb.Append(voMemberName).Append("Specified").ToString();
ITypeInfoItem voSpecifiedMember = TypeInfoProvider.GetHierarchicMember(config.ValueType, voSpecifiedName);
if (voSpecifiedMember == null)
{
return;
}
sb.Length = 0;
String boSpecifiedName = sb.Append(boMemberName).Append("Specified").ToString();
typeInfoMap.Put(boSpecifiedName, voSpecifiedMember);
}
public virtual void AfterPropertiesSet()
{
ParamChecker.AssertNotNull(EntityType, "EntityType");
ParamChecker.AssertNotNull(FilterMember, "FilterMember");
// It is intentended to have no null check for ModelContainer, because the class can be used without it!
typeInfoItem = TypeInfoProvider.GetHierarchicMember(EntityType, FilterMember);
}
public Object Invoke(String fieldName, Type enhancedType)
{
ITypeInfoItem[] members = new ITypeInfoItem[fields.Length];
for (int a = fields.Length; a-- > 0;)
{
FieldInfo[] field = ReflectUtil.GetDeclaredFieldInHierarchy(enhancedType, fields[a].Name);
members[a] = new FieldInfoItemASM(field[0]);
}
return(members);
}
public static void SetEntityType(Type entityType, ITypeInfoItem member, IProperties properties)
{
if (member is TypeInfoItem)
{
((TypeInfoItem)member).ElementType = entityType;
}
else
{
throw new Exception("TypeInfoItem not supported: " + member);
}
}
public void PostInit(ITypeInfoItem[] members)
{
this.Members = members;
for (int a = this.Members.Length; a-- > 0;)
{
ITypeInfoItem member = this.Members[a];
nameToMemberDict.Add(member.Name, member);
nameToXmlMemberDict.Add(member.XMLName, member);
}
}
public void Restore(Object target)
{
for (int b = allMembers.Length; b-- > 0;)
{
ITypeInfoItem member = allMembers[b];
Object originalValue = values[b];
if (!Equals(member.GetValue(target), originalValue))
{
member.SetValue(target, originalValue);
}
}
}
public Object PackInListType(IEnumerable referencedVOs, Type listType)
{
Object listTypeInst = Activator.CreateInstance(listType);
if (referencedVOs == null)
{
return(listType);
}
ITypeInfoItem accessor = GetListTypeAccessor(listType);
if (accessor.CanWrite)
{
if (!accessor.RealType.IsAssignableFrom(referencedVOs.GetType()))
{
ICollection <Object> targetCollection;
Type propertyType = accessor.RealType;
if (typeof(IList).IsAssignableFrom(propertyType))
{
targetCollection = new List <Object>();
foreach (Object item in referencedVOs)
{
targetCollection.Add(item);
}
}
// TODO type of Set
//else if (typeof(ISet).IsAssignableFrom(propertyType))
//{
// targetCollection = new HashSet<Object>(referencedVOs);
//}
else
{
throw new ArgumentException("Collection type of '" + propertyType.Name + "' is not supported");
}
referencedVOs = targetCollection;
}
accessor.SetValue(listTypeInst, referencedVOs);
}
else
{
IList internalList = (IList)accessor.GetValue(listTypeInst);
IEnumerator enumerator = referencedVOs.GetEnumerator();
while (enumerator.MoveNext())
{
Object entry = enumerator.Current;
internalList.Add(entry);
}
}
return(listTypeInst);
}
public virtual ITypeInfoItem GetHierarchicMember(Type entityType, String hierarchicMemberName)
{
String[] memberPath = memberPathSplitPattern.Split(hierarchicMemberName);
ITypeInfoItem[] members = new ITypeInfoItem[memberPath.Length];
Type currentType = entityType;
for (int a = 0, size = memberPath.Length; a < size; a++)
{
String memberName = memberPath[a];
ITypeInfo typeInfo = GetTypeInfo(currentType);
ITypeInfoItem member = typeInfo.GetMemberByName(memberName);
if (member == null)
{
String memberNameLower = memberName.ToLower();
IList <ITypeInfoItem> allMembers = typeInfo.Members;
for (int b = allMembers.Count; b-- > 0;)
{
if (allMembers[b].Name.ToLower().Equals(memberNameLower))
{
member = allMembers[b];
break;
}
}
if (member == null)
{
return(null);
}
}
currentType = member.RealType;
members[a] = member;
}
if (members.Length == 1)
{
return(members[0]);
}
else if (members.Length > 1)
{
ITypeInfoItem[] memberForParentPath = new ITypeInfoItem[members.Length - 1];
Array.Copy(members, 0, memberForParentPath, 0, memberForParentPath.Length);
ITypeInfoItem lastMember = members[members.Length - 1];
return(new EmbeddedTypeInfoItem(hierarchicMemberName, lastMember, memberForParentPath));
}
else
{
throw new ArgumentException("Must never happen");
}
}
public void SetValue(Object obj, Object value)
{
Object currentObj = obj;
for (int a = 0, size = memberPath.Length; a < size; a++)
{
ITypeInfoItem memberPathItem = memberPath[a];
Object childObj = memberPathItem.GetValue(currentObj, false);
if (childObj == null)
{
childObj = Activator.CreateInstance(memberPathItem.RealType);
memberPathItem.SetValue(currentObj, childObj);
}
currentObj = childObj;
}
childMember.SetValue(currentObj, value);
}
public virtual Object ReadObject(Type returnType, Type objType, int id, IReader reader)
{
Object obj = Activator.CreateInstance(objType);
if (id > 0)
{
reader.PutObjectWithId(obj, id);
}
reader.NextTag();
ITypeInfoItem[] members = reader.GetMembersOfType(objType);
int index = 0;
String valueAttribute = XmlDictionary.ValueAttribute;
String primitiveElement = XmlDictionary.PrimitiveElement;
ICommandBuilder commandBuilder = CommandBuilder;
ICommandTypeRegistry commandTypeRegistry = reader.CommandTypeRegistry;
IConversionHelper conversionHelper = ConversionHelper;
while (reader.IsStartTag())
{
ITypeInfoItem member = members[index++];
Object memberValue;
if (primitiveElement.Equals(reader.GetElementName()))
{
String value = reader.GetAttributeValue(valueAttribute);
memberValue = conversionHelper.ConvertValueToType(member.RealType, value);
reader.MoveOverElementEnd();
}
else
{
memberValue = reader.ReadObject(member.RealType);
}
if (memberValue is IObjectFuture)
{
IObjectFuture objectFuture = (IObjectFuture)memberValue;
IObjectCommand command = commandBuilder.Build(commandTypeRegistry, objectFuture, obj, member);
reader.AddObjectCommand(command);
}
else
{
member.SetValue(obj, memberValue);
}
}
return(obj);
}
public Object GetValue(Object obj, bool allowNullEquivalentValue)
{
Object currentObj = obj;
for (int a = 0, size = memberPath.Length; a < size; a++)
{
ITypeInfoItem memberPathItem = memberPath[a];
currentObj = memberPathItem.GetValue(currentObj, allowNullEquivalentValue);
if (currentObj == null)
{
if (allowNullEquivalentValue)
{
return(childMember.NullEquivalentValue);
}
return(null);
}
}
return(childMember.GetValue(currentObj, allowNullEquivalentValue));
}
public virtual void WriteObject(Object obj, Type type, IWriter writer)
{
writer.WriteStartElementEnd();
ITypeInfoItem[] members = writer.GetMembersOfType(type);
String valueAttribute = XmlDictionary.ValueAttribute;
String primitiveElement = XmlDictionary.PrimitiveElement;
for (int a = 0, size = members.Length; a < size; a++)
{
ITypeInfoItem field = members[a];
Object fieldValue = field.GetValue(obj, false);
if (field.RealType.IsPrimitive)
{
writer.WriteStartElement(primitiveElement);
String convertedValue = ConversionHelper.ConvertValueToType <String>(fieldValue);
writer.WriteAttribute(valueAttribute, convertedValue);
writer.WriteEndElement();
continue;
}
writer.WriteObject(fieldValue);
}
}
public static A GetAnnotation <A>(ITypeInfoItem member, bool inherit) where A : Attribute
{
return(member.GetAnnotation <A>());
}
protected void InitializeValueObjectMapping()
{
Object writeLock = GetWriteLock();
lock (writeLock)
{
this.businessObjectSaveOrder = null;
HashMap <Type, IISet <Type> > boTypeToBeforeBoTypes = new HashMap <Type, IISet <Type> >();
HashMap <Type, IISet <Type> > boTypeToAfterBoTypes = new HashMap <Type, IISet <Type> >();
foreach (Entry <Type, IValueObjectConfig> entry in ValueObjectMap.GetExtensions())
{
IValueObjectConfig voConfig = entry.Value;
Type entityType = voConfig.EntityType;
Type valueType = voConfig.ValueType;
IEntityMetaData metaData = GetMetaData(entityType);
if (metaData == null)
{
// Currently no bo metadata found. We can do nothing here
return;
}
IMap <String, ITypeInfoItem> boNameToVoMember = GetTypeInfoMapForVo(valueType);
foreach (RelationMember boMember in metaData.RelationMembers)
{
String boMemberName = boMember.Name;
String voMemberName = voConfig.GetValueObjectMemberName(boMemberName);
ITypeInfoItem voMember = boNameToVoMember.Get(boMemberName);
if (voConfig.IsIgnoredMember(voMemberName) || voMember == null)
{
continue;
}
Type voMemberRealType = voMember.RealType;
if (voConfig.HoldsListType(voMember.Name))
{
IPropertyInfo[] properties = PropertyInfoProvider.GetProperties(voMemberRealType);
if (properties.Length != 1)
{
throw new ArgumentException("ListTypes must have exactly one property");
}
voMemberRealType = TypeInfoProvider.GetMember(voMemberRealType, properties[0]).RealType;
}
if (!ImmutableTypeSet.IsImmutableType(voMemberRealType))
{
// vo member is either a list or a single direct relation to another VO
// This implies that a potential service can handle both VO types as new objects at once
continue;
}
// vo member only holds a id reference which implies that the related VO has to be persisted first to
// contain an id which can be referred to. But we do NOT know the related VO here, but we know
// the related BO where ALL potential VOs will be derived from:
Type boMemberElementType = boMember.ElementType;
if (Object.Equals(entityType, boMemberElementType))
{
continue;
}
AddBoTypeAfter(entityType, boMemberElementType, boTypeToBeforeBoTypes, boTypeToAfterBoTypes);
AddBoTypeBefore(entityType, boMemberElementType, boTypeToBeforeBoTypes, boTypeToAfterBoTypes);
}
}
List <Type> businessObjectSaveOrder = new List <Type>();
foreach (Type boType in boTypeToBeforeBoTypes.KeySet())
{
// BeforeBoType are types which have to be saved BEFORE saving the boType
bool added = false;
for (int a = 0, size = businessObjectSaveOrder.Count; a < size; a++)
{
Type orderedBoType = businessObjectSaveOrder[a];
// OrderedBoType is the type currently inserted at the correct position in the save order - as far as the keyset
// has been traversed, yet
ISet <Type> typesBeforeOrderedType = boTypeToBeforeBoTypes.Get(orderedBoType);
// typesBeforeOrderedType are types which have to be
bool orderedHasToBeAfterCurrent = typesBeforeOrderedType != null && typesBeforeOrderedType.Contains(boType);
if (!orderedHasToBeAfterCurrent)
{
// our boType has nothing to do with the orderedBoType. So we let is be at it is
continue;
}
businessObjectSaveOrder.Insert(a, boType);
added = true;
break;
}
if (!added)
{
businessObjectSaveOrder.Add(boType);
}
}
foreach (Type boType in boTypeToAfterBoTypes.KeySet())
{
if (boTypeToBeforeBoTypes.ContainsKey(boType))
{
// already handled in the previous loop
continue;
}
bool added = false;
for (int a = businessObjectSaveOrder.Count; a-- > 0;)
{
Type orderedBoType = businessObjectSaveOrder[a];
// OrderedBoType is the type currently inserted at the correct position in the save order - as far as the keyset
// has been traversed, yet
ISet <Type> typesBeforeOrderedType = boTypeToBeforeBoTypes.Get(orderedBoType);
bool orderedHasToBeAfterCurrent = typesBeforeOrderedType != null && typesBeforeOrderedType.Contains(boType);
if (!orderedHasToBeAfterCurrent)
{
// our boType has nothing to do with the orderedBoType. So we let it be as it is
continue;
}
businessObjectSaveOrder.Insert(a, boType);
added = true;
break;
}
if (!added)
{
businessObjectSaveOrder.Add(boType);
}
}
this.businessObjectSaveOrder = businessObjectSaveOrder.ToArray();
}
}
public EmbeddedTypeInfoItem(String name, ITypeInfoItem childMember, params ITypeInfoItem[] memberPath)
{
this.name = name;
this.childMember = childMember;
this.memberPath = memberPath;
}
public Type ReadFromAttribute(String classIdAttribute, String classNameAttribute, String classNamespaceAttribute, String classMemberAttribute, IReader reader)
{
String classIdValue = reader.GetAttributeValue(classIdAttribute);
int classId = 0;
if (classIdValue != null && classIdValue.Length > 0)
{
classId = Int32.Parse(classIdValue);
}
Type typeObj = (Type)reader.GetObjectById(classId, false);
if (typeObj != null)
{
return(typeObj);
}
String name = reader.GetAttributeValue(classNameAttribute);
String namespaceString = reader.GetAttributeValue(classNamespaceAttribute);
int dimensionCount = 0;
while (name.EndsWith("[]"))
{
dimensionCount++;
name = name.Substring(0, name.Length - 2);
}
typeObj = XmlTypeRegistry.GetType(name, namespaceString);
String classMemberValue = reader.GetAttributeValue(classMemberAttribute);
if (classMemberValue != null)
{
ITypeInfo typeInfo = TypeInfoProvider.GetTypeInfo(typeObj);
String[] memberNames = classMemberValue.Split(' ');
ITypeInfoItem[] members = new ITypeInfoItem[memberNames.Length];
for (int a = memberNames.Length; a-- > 0;)
{
String memberName = memberNames[a];
ITypeInfoItem member = typeInfo.GetMemberByXmlName(memberName);
if (member == null)
{
throw new Exception("No member found with xml name '" + memberName + "' on entity '" + typeObj.FullName + "'");
}
members[a] = member;
}
reader.PutMembersOfType(typeObj, members);
}
String gtIdValue = classIdAttribute.Equals("gti") ? null : reader.GetAttributeValue("gti");
Type genericArgumentType = null;
if (gtIdValue != null && gtIdValue.Length > 0)
{
genericArgumentType = ReadFromAttribute("gti", "gn", "gns", "gm", reader);
typeObj = typeObj.MakeGenericType(genericArgumentType);
}
while (dimensionCount-- > 0)
{
typeObj = typeObj.MakeArrayType();
}
reader.PutObjectWithId(typeObj, classId);
return(typeObj);
}
public Object UnpackListType(Object item)
{
ITypeInfoItem accessor = GetListTypeAccessor(item.GetType());
return(accessor.GetValue(item));
}
public bool IsMergeRelevant(ITypeInfoItem primitiveMember)
{
throw new NotSupportedException();
}
protected virtual bool EqualsItems(Type leftRealType, Object leftId, T right, ITypeInfoItem idMember)
{
if (right == null)
{
return(false);
}
Type rightRealType = ProxyHelper.GetRealType(right.GetType());
if (!leftRealType.Equals(rightRealType))
{
return(false);
}
Object rightId = idMember.GetValue(right);
leftId = ConversionHelper.ConvertValueToType(idMember.RealType, leftId);
return(Object.Equals(leftId, rightId));
}
protected void BackupObjects(Object obj, IDictionary <Object, RevertChangesSavepoint.IBackup> originalToValueBackup)
{
if (obj == null)
{
return;
}
Type objType = ProxyHelper.GetRealType(obj.GetType());
if (ImmutableTypeSet.IsImmutableType(objType) || originalToValueBackup.ContainsKey(obj))
{
return;
}
originalToValueBackup.Add(obj, null);
if (obj is Array)
{
Array sourceArray = (Array)obj;
RevertChangesSavepoint.ArrayBackup arrayBackup = new RevertChangesSavepoint.ArrayBackup((Array)sourceArray.Clone());
originalToValueBackup[obj] = arrayBackup;
Type elementType = sourceArray.GetType().GetElementType();
if (!ImmutableTypeSet.IsImmutableType(elementType))
{
for (int a = sourceArray.Length; a-- > 0;)
{
Object arrayItem = sourceArray.GetValue(a);
BackupObjects(arrayItem, originalToValueBackup);
}
}
return;
}
if (obj is IList)
{
IList list = (IList)obj;
Object[] array = new Object[list.Count];
list.CopyTo(array, 0);
RevertChangesSavepoint.ListBackup listBackup = new RevertChangesSavepoint.ListBackup(array);
originalToValueBackup[obj] = listBackup;
for (int a = list.Count; a-- > 0;)
{
Object item = list[a];
BackupObjects(item, originalToValueBackup);
}
return;
}
else if (obj is IEnumerable)
{
foreach (Object item in (IEnumerable)obj)
{
BackupObjects(item, originalToValueBackup);
}
return;
}
ITypeInfo typeInfo = TypeInfoProvider.GetTypeInfo(objType);
ITypeInfoItem[] members = typeInfo.Members;
Object[] originalValues = new Object[members.Length];
RevertChangesSavepoint.ObjectBackup objBackup = new RevertChangesSavepoint.ObjectBackup(members, originalValues);
originalToValueBackup[obj] = objBackup;
for (int b = members.Length; b-- > 0;)
{
ITypeInfoItem member = members[b];
Object originalValue = member.GetValue(obj);
originalValues[b] = originalValue;
BackupObjects(originalValue, originalToValueBackup);
}
}
public void WriteAsAttribute(Type type, String classIdAttribute, String classNameAttribute, String classNamespaceAttribute, String classMemberAttribute, IWriter writer)
{
Type realType = ProxyHelper.GetRealType(type);
int typeId = writer.GetIdOfObject(type);
if (typeId > 0)
{
writer.WriteAttribute(classIdAttribute, typeId.ToString());
return;
}
typeId = writer.AcquireIdForObject(realType);
writer.WriteAttribute(classIdAttribute, typeId.ToString());
StringBuilder sb = StringBuilder;
try
{
while (type.IsArray)
{
sb.Append("[]");
type = type.GetElementType();
}
String xmlName, xmlNamespace;
IXmlTypeKey xmlType;
Type genericArgumentType = null;
if (type.IsGenericType && !typeof(Nullable <>).Equals(type.GetGenericTypeDefinition()))
{
xmlType = XmlTypeRegistry.GetXmlType(type.GetGenericTypeDefinition());
genericArgumentType = type.GetGenericArguments()[0];
}
else
{
xmlType = XmlTypeRegistry.GetXmlType(type);
}
xmlName = xmlType.Name;
xmlNamespace = xmlType.Namespace;
if (sb.Length > 0)
{
sb.Insert(0, xmlName);
writer.WriteAttribute(classNameAttribute, sb.ToString());
sb.Length = 0;
}
else
{
writer.WriteAttribute(classNameAttribute, xmlName);
}
writer.WriteAttribute(classNamespaceAttribute, xmlNamespace);
if (genericArgumentType != null)
{
WriteAsAttribute(genericArgumentType, "gti", "gn", "gns", "gm", writer);
}
if (!realType.IsArray && !realType.IsEnum && !realType.IsInterface && !typeof(Type).Equals(realType))
{
ITypeInfo typeInfo = TypeInfoProvider.GetTypeInfo(type);
ITypeInfoItem[] members = typeInfo.Members;
List <ITypeInfoItem> membersToWrite = new List <ITypeInfoItem>(members.Length);
for (int a = 0, size = members.Length; a < size; a++)
{
ITypeInfoItem member = members[a];
if (member.IsXMLIgnore)
{
continue;
}
if (sb.Length > 0)
{
sb.Append(' ');
}
sb.Append(member.Name);
membersToWrite.Add(member);
}
if (sb.Length > 0)
{
writer.WriteAttribute(classMemberAttribute, sb.ToString());
sb.Length = 0;
}
writer.PutMembersOfType(type, ListUtil.ToArray(membersToWrite));
}
}
finally
{
sb.Length = 0;
}
}