private System.Collections.Generic.IDictionary <AbstractObjectInfo, AbstractObjectInfo> IntrospectGenericMap(
System.Collections.Generic.IDictionary <object, object> map,
bool introspect,
IDictionary <object, NonNativeObjectInfo> alreadyReadObjects, IIntrospectionCallback callback)
{
System.Collections.Generic.IDictionary <AbstractObjectInfo, AbstractObjectInfo> mapCopy = new OdbHashMap <AbstractObjectInfo, AbstractObjectInfo>();
System.Collections.Generic.ICollection <object> keySet = map.Keys;
System.Collections.IEnumerator keys = keySet.GetEnumerator();
NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo ciKey = null;
NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo ciValue = null;
NeoDatis.Odb.Core.Layers.Layer2.Meta.AbstractObjectInfo aoiForKey = null;
NeoDatis.Odb.Core.Layers.Layer2.Meta.AbstractObjectInfo aoiForValue = null;
while (keys.MoveNext())
{
object key = keys.Current;
object value = map[key];
if (key != null)
{
ciKey = GetClassInfo(OdbClassUtil.GetFullName(key.GetType()));
if (value != null)
{
ciValue = GetClassInfo(OdbClassUtil.GetFullName(value.GetType()));
}
aoiForKey = GetObjectInfo(key, ciKey, introspect, alreadyReadObjects, callback);
aoiForValue = GetObjectInfo(value, ciValue, introspect, alreadyReadObjects, callback);
mapCopy.Add(aoiForKey, aoiForValue);
}
}
return(mapCopy);
}
private NeoDatis.Odb.Core.Layers.Layer2.Meta.CollectionObjectInfo IntrospectCollection
(System.Collections.ICollection collection, bool introspect, System.Collections.Generic.IDictionary
<object, NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeObjectInfo> alreadyReadObjects
, NeoDatis.Odb.Core.Layers.Layer2.Meta.ODBType type, NeoDatis.Odb.Core.Layers.Layer1.Introspector.IIntrospectionCallback
callback)
{
if (collection == null)
{
return(new NeoDatis.Odb.Core.Layers.Layer2.Meta.CollectionObjectInfo());
}
// A collection that contain all meta representations of the collection
// objects
System.Collections.Generic.ICollection <NeoDatis.Odb.Core.Layers.Layer2.Meta.AbstractObjectInfo
> collectionCopy = new System.Collections.Generic.List <NeoDatis.Odb.Core.Layers.Layer2.Meta.AbstractObjectInfo
>(collection.Count);
// A collection to keep references all all non native objects of the
// collection
// This will be used later to get all non native objects contained in an
// object
System.Collections.Generic.ICollection <NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeObjectInfo
> nonNativesObjects = new System.Collections.Generic.List <NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeObjectInfo
>(collection.Count);
NeoDatis.Odb.Core.Layers.Layer2.Meta.AbstractObjectInfo aoi = null;
System.Collections.IEnumerator iterator = collection.GetEnumerator();
while (iterator.MoveNext())
{
object o = iterator.Current;
NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo ci = null;
// Null objects are not inserted in list
if (o != null)
{
ci = GetClassInfo(OdbClassUtil.GetFullName(o.GetType()));
aoi = GetObjectInfo(o, ci, introspect, alreadyReadObjects, callback);
collectionCopy.Add(aoi);
if (aoi.IsNonNativeObject())
{
// o is not null, call the callback with it
//callback.objectFound(o);
// This is a non native object
nonNativesObjects.Add((NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeObjectInfo)aoi
);
}
}
}
NeoDatis.Odb.Core.Layers.Layer2.Meta.CollectionObjectInfo coi = new NeoDatis.Odb.Core.Layers.Layer2.Meta.CollectionObjectInfo
(collectionCopy, nonNativesObjects);
string realCollectionClassName = OdbClassUtil.GetFullName(collection.GetType());
if (realCollectionClassName.IndexOf("$") != -1)
{
coi.SetRealCollectionClassName(type.GetDefaultInstanciationClass().FullName);
}
else
{
coi.SetRealCollectionClassName(realCollectionClassName);
}
return(coi);
}
public virtual bool Match(AbstractObjectInfo
aoi)
{
if (criterion == null)
{
return true;
}
return criterion.Match(aoi);
}
public virtual object BuildOneInstance(AbstractObjectInfo objectInfo)
{
object o = null;
if (objectInfo is NonNativeNullObjectInfo)
{
return null;
}
if (objectInfo.GetType() == typeof(NonNativeObjectInfo))
{
o = BuildOneInstance((NonNativeObjectInfo)objectInfo);
}
else
{
// instantiation cache is not used for native objects
o = BuildOneInstance((NativeObjectInfo)objectInfo);
}
return o;
}
private bool HasChanged(AbstractObjectInfo aoi1
, AbstractObjectInfo aoi2, int objectRecursionLevel
)
{
// If one is null and the other not
if (aoi1.IsNull() != aoi2.IsNull())
{
return true;
}
if (aoi1.IsNonNativeObject() && aoi2.IsNonNativeObject())
{
return HasChanged((NonNativeObjectInfo)aoi1,
(NonNativeObjectInfo)aoi2, objectRecursionLevel
+ 1);
}
if (aoi1.IsNative() && aoi2.IsNative())
{
return HasChanged((NativeObjectInfo)aoi1, (NativeObjectInfo
)aoi2, 0);
}
return false;
}
private NeoDatis.Odb.Core.Layers.Layer2.Meta.ArrayObjectInfo IntrospectArray(object
array, bool introspect, System.Collections.Generic.IDictionary <object, NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeObjectInfo
> alreadyReadObjects, NeoDatis.Odb.Core.Layers.Layer2.Meta.ODBType valueType, NeoDatis.Odb.Core.Layers.Layer1.Introspector.IIntrospectionCallback
callback)
{
int length = NeoDatis.Tool.Wrappers.OdbReflection.GetArrayLength(array);
System.Type elementType = array.GetType().GetElementType();
NeoDatis.Odb.Core.Layers.Layer2.Meta.ODBType type = NeoDatis.Odb.Core.Layers.Layer2.Meta.ODBType
.GetFromClass(elementType);
if (type.IsAtomicNative())
{
return(IntropectAtomicNativeArray(array, type));
}
if (!introspect)
{
return(new NeoDatis.Odb.Core.Layers.Layer2.Meta.ArrayObjectInfo((object[])array));
}
object[] arrayCopy = new object[length];
for (int i = 0; i < length; i++)
{
object o = NeoDatis.Tool.Wrappers.OdbReflection.GetArrayElement(array, i);
NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo ci = null;
if (o != null)
{
ci = GetClassInfo(OdbClassUtil.GetFullName(o.GetType()));
NeoDatis.Odb.Core.Layers.Layer2.Meta.AbstractObjectInfo aoi = GetObjectInfo(o, ci
, introspect, alreadyReadObjects, callback);
arrayCopy[i] = aoi;
}
else
{
arrayCopy[i] = new NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeNullObjectInfo();
}
}
NeoDatis.Odb.Core.Layers.Layer2.Meta.ArrayObjectInfo arrayOfAoi = new NeoDatis.Odb.Core.Layers.Layer2.Meta.ArrayObjectInfo
(arrayCopy, valueType, type.GetId());
return(arrayOfAoi);
}
public virtual bool HasChanged(AbstractObjectInfo
aoi1, AbstractObjectInfo aoi2)
{
return HasChanged(aoi1, aoi2, -1);
}
private void StoreChangedObject(NonNativeObjectInfo
aoi1, NonNativeObjectInfo aoi2, int fieldId
, AbstractObjectInfo oldValue, AbstractObjectInfo
newValue, string message, int objectRecursionLevel)
{
if (aoi1 != null && aoi2 != null)
{
if (aoi1.GetOid() != null && aoi1.GetOid().Equals(aoi2.GetOid()))
{
changedObjectMetaRepresentations.Add(aoi2);
changes.Add(new ChangedObjectInfo(aoi1
.GetClassInfo(), aoi2.GetClassInfo(), fieldId, oldValue, newValue, message, objectRecursionLevel
));
// also the max recursion level
if (objectRecursionLevel > maxObjectRecursionLevel)
{
maxObjectRecursionLevel = objectRecursionLevel;
}
nbChanges++;
}
else
{
newObjects.Add(aoi2.GetObject());
string fieldName = aoi1.GetClassInfo().GetAttributeInfoFromId(fieldId).GetName();
// keep track of the position where the reference must be
// updated - use aoi1 to get position, because aoi2 do not have position defined yet
long positionToUpdateReference = aoi1.GetAttributeDefinitionPosition(fieldId);
StoreNewObjectReference(positionToUpdateReference, aoi2, objectRecursionLevel, fieldName
);
}
}
else
{
//newObjectMetaRepresentations.add(aoi2);
NeoDatis.Tool.DLogger.Info("Non native object with null object");
}
}
private bool ClassAreCompatible(AbstractObjectInfo
value1, AbstractObjectInfo value2)
{
System.Type clazz1 = value1.GetType();
System.Type clazz2 = value2.GetType();
if (clazz1 == clazz2)
{
return true;
}
if ((clazz1 == typeof(NonNativeObjectInfo))
&& (clazz2 == typeof(NeoDatis.Odb.Core.Server.Layers.Layer2.Meta.ClientNonNativeObjectInfo
)))
{
return true;
}
return false;
}
private void StoreArrayChange(NonNativeObjectInfo
nnoi, int arrayAttributeId, int arrayIndex, AbstractObjectInfo
value, bool supportInPlaceUpdate)
{
nbChanges++;
ArrayModifyElement ame = new ArrayModifyElement
(nnoi, arrayAttributeId, arrayIndex, value, supportInPlaceUpdate);
arrayChanges.Add(ame);
}
/// <summary>
/// An object reference has changed and the new object has not been checked, so disabled in place update
/// TODO this is not good => all reference update will be done by full update and not in place update
/// </summary>
/// <param name="value"></param>
private void AddPendingVerification(AbstractObjectInfo
value)
{
supportInPlaceUpdate = false;
}
protected virtual NeoDatis.Odb.Core.Layers.Layer2.Meta.AbstractObjectInfo GetNativeObjectInfoInternal
(NeoDatis.Odb.Core.Layers.Layer2.Meta.ODBType type, object o, bool recursive
, System.Collections.Generic.IDictionary <object, NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeObjectInfo
> alreadyReadObjects, NeoDatis.Odb.Core.Layers.Layer1.Introspector.IIntrospectionCallback
callback)
{
NeoDatis.Odb.Core.Layers.Layer2.Meta.AbstractObjectInfo aoi = null;
if (type.IsAtomicNative())
{
if (o == null)
{
aoi = new NeoDatis.Odb.Core.Layers.Layer2.Meta.NullNativeObjectInfo(type.GetId());
}
else
{
aoi = new NeoDatis.Odb.Core.Layers.Layer2.Meta.AtomicNativeObjectInfo(o, type
.GetId());
}
}
else
{
if (type.IsCollection())
{
aoi = IntrospectCollection((System.Collections.ICollection)o, recursive, alreadyReadObjects
, type, callback);
}
else
{
if (type.IsArray())
{
if (o == null)
{
aoi = new NeoDatis.Odb.Core.Layers.Layer2.Meta.ArrayObjectInfo(null);
}
else
{
// Gets the type of the elements of the array
string realArrayClassName = OdbClassUtil.GetFullName(o.GetType().GetElementType());
NeoDatis.Odb.Core.Layers.Layer2.Meta.ArrayObjectInfo aroi = null;
if (recursive)
{
aroi = IntrospectArray(o, recursive, alreadyReadObjects, type, callback);
}
else
{
aroi = new NeoDatis.Odb.Core.Layers.Layer2.Meta.ArrayObjectInfo((object[])o
);
}
aroi.SetRealArrayComponentClassName(realArrayClassName);
aoi = aroi;
}
}
else
{
if (type.IsMap())
{
if (o == null)
{
aoi = new NeoDatis.Odb.Core.Layers.Layer2.Meta.MapObjectInfo(null, type, type.GetDefaultInstanciationClass
().FullName);
}
else
{
MapObjectInfo moi = null;
string realMapClassName = OdbClassUtil.GetFullName(o.GetType());
bool isGeneric = o.GetType().IsGenericType;
if (isGeneric)
{
moi = new MapObjectInfo(IntrospectGenericMap((System.Collections.Generic.IDictionary <object, object>)o, recursive, alreadyReadObjects, callback), type, realMapClassName);
}
else
{
moi = new MapObjectInfo(IntrospectNonGenericMap((System.Collections.IDictionary)o, recursive, alreadyReadObjects, callback), type, realMapClassName);
}
if (realMapClassName.IndexOf("$") != -1)
{
moi.SetRealMapClassName(OdbClassUtil.GetFullName(type.GetDefaultInstanciationClass()));
}
aoi = moi;
}
}
else
{
if (type.IsEnum())
{
System.Enum enumObject = (System.Enum)o;
if (enumObject == null)
{
aoi = new NeoDatis.Odb.Core.Layers.Layer2.Meta.NullNativeObjectInfo(type.GetSize(
));
}
else
{
Type t = enumObject.GetType();
string enumClassName = enumObject == null ? null : OdbClassUtil.GetFullName(enumObject.GetType());
// Here we must check if the enum is already in the meta model. Enum must be stored in the meta
// model to optimize its storing as we need to keep track of the enum class
// for each enum stored. So instead of storing the enum class name, we can store enum class id, a long
// instead of the full enum class name string
NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo ci = GetClassInfo(enumClassName);
string enumValue = enumObject == null ? null : enumObject.ToString();
aoi = new NeoDatis.Odb.Core.Layers.Layer2.Meta.EnumNativeObjectInfo(ci, enumValue
);
}
}
}
}
}
}
return(aoi);
}
/// <summary>
/// Build a meta representation of an object
/// <pre>
/// warning: When an object has two fields with the same name (a private field with the same name in a parent class, the deeper field (of the parent) is ignored!)
/// </pre>
/// </summary>
/// <param name="o"></param>
/// <param name="ci"></param>
/// <param name="recursive"></param>
/// <returns>The ObjectInfo</returns>
protected virtual NeoDatis.Odb.Core.Layers.Layer2.Meta.AbstractObjectInfo GetObjectInfoInternal
(NeoDatis.Odb.Core.Layers.Layer2.Meta.AbstractObjectInfo nnoi, object o, NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo
ci, bool recursive, System.Collections.Generic.IDictionary <object, NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeObjectInfo
> alreadyReadObjects, NeoDatis.Odb.Core.Layers.Layer1.Introspector.IIntrospectionCallback
callback)
{
object value = null;
if (o == null)
{
return(NeoDatis.Odb.Core.Layers.Layer2.Meta.NullNativeObjectInfo.GetInstance());
}
System.Type clazz = o.GetType();
NeoDatis.Odb.Core.Layers.Layer2.Meta.ODBType type = NeoDatis.Odb.Core.Layers.Layer2.Meta.ODBType
.GetFromClass(clazz);
string className = OdbClassUtil.GetFullName(clazz);
if (type.IsNative())
{
return(GetNativeObjectInfoInternal(type, o, recursive, alreadyReadObjects,
callback));
}
// sometimes the clazz.getName() may not match the ci.getClassName()
// It happens when the attribute is an interface or superclass of the
// real attribute class
// In this case, ci must be updated to the real class info
if (ci != null && !clazz.FullName.Equals(ci.GetFullClassName()))
{
ci = GetClassInfo(className);
nnoi = null;
}
NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeObjectInfo mainAoi = (NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeObjectInfo
)nnoi;
bool isRootObject = false;
if (alreadyReadObjects == null)
{
alreadyReadObjects = new NeoDatis.Tool.Wrappers.Map.OdbHashMap <object, NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeObjectInfo
>();
isRootObject = true;
}
if (o != null)
{
NonNativeObjectInfo cachedNnoi = null;
alreadyReadObjects.TryGetValue(o, out cachedNnoi);
if (cachedNnoi != null)
{
ObjectReference or = new ObjectReference(cachedNnoi);
return(or);
}
if (callback != null)
{
callback.ObjectFound(o);
}
}
if (mainAoi == null)
{
mainAoi = BuildNnoi(o, ci, null, null, null, alreadyReadObjects);
}
alreadyReadObjects[o] = mainAoi;
NeoDatis.Tool.Wrappers.List.IOdbList <System.Reflection.FieldInfo> fields = classIntrospector.GetAllFields(className);
NeoDatis.Odb.Core.Layers.Layer2.Meta.AbstractObjectInfo aoi = null;
int attributeId = -1;
// For all fields
for (int i = 0; i < fields.Count; i++)
{
System.Reflection.FieldInfo field = fields[i];
try
{
value = field.GetValue(o);
attributeId = ci.GetAttributeId(field.Name);
if (attributeId == -1)
{
throw new ODBRuntimeException(NeoDatisError.ObjectIntrospectorNoFieldWithName.AddParameter(ci.GetFullClassName()).AddParameter(field.Name));
}
ODBType valueType = null;
if (value == null)
{
// If value is null, take the type from the field type
// declared in the class
valueType = ODBType.GetFromClass(field.FieldType);
}
else
{
// Else take the real attribute type!
valueType = ODBType.GetFromClass(value.GetType());
}
// for native fields
if (valueType.IsNative())
{
aoi = GetNativeObjectInfoInternal(valueType, value, recursive, alreadyReadObjects, callback);
mainAoi.SetAttributeValue(attributeId, aoi);
}
else
{
//callback.objectFound(value);
// Non Native Objects
if (value == null)
{
ClassInfo clai = GetClassInfo(OdbClassUtil.GetFullName(field.GetType()));
aoi = new NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeNullObjectInfo(clai);
mainAoi.SetAttributeValue(attributeId, aoi);
}
else
{
ClassInfo clai = GetClassInfo(OdbClassUtil.GetFullName(value.GetType()));
if (recursive)
{
aoi = GetObjectInfoInternal(null, value, clai, recursive, alreadyReadObjects, callback
);
mainAoi.SetAttributeValue(attributeId, aoi);
}
else
{
// When it is not recursive, simply add the object
// values.add(value);
throw new NeoDatis.Odb.ODBRuntimeException(NeoDatis.Odb.Core.NeoDatisError.InternalError
.AddParameter("Should not enter here - ObjectIntrospector - 'simply add the object'"
));
}
}
}
}
catch (System.ArgumentException e)
{
throw new NeoDatis.Odb.ODBRuntimeException(NeoDatis.Odb.Core.NeoDatisError.InternalError
.AddParameter("in getObjectInfoInternal"), e);
}
catch (System.MemberAccessException e)
{
throw new NeoDatis.Odb.ODBRuntimeException(NeoDatis.Odb.Core.NeoDatisError.InternalError
.AddParameter("getObjectInfoInternal"), e);
}
}
if (isRootObject)
{
alreadyReadObjects.Clear();
alreadyReadObjects = null;
}
return(mainAoi);
}
