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);
}
public static bool IsNative(System.Type clazz)
{
ODBType tc = null;
typesByName.TryGetValue(OdbClassUtil.GetFullName(clazz), out tc);
if (tc != null)
{
return(true);
}
if (clazz.IsArray)
{
//ODBType type = new ODBType(ODBType.ARRAY.isPrimitive,ODBType.ARRAY_ID,ODBType.ARRAY.getName(),0);
//type.subType = getFromClass(clazz.getComponentType());
return(true);
}
if (Map.superClass.IsAssignableFrom(clazz))
{
return(true);
}
// check if it is a list
if (Collection.superClass.IsAssignableFrom(clazz))
{
return(true);
}
return(false);
}
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);
}
/// <summary> </summary>
/// <param name="clazz">The class to instrospect
/// </param>
/// <param name="recursive">If true, goes does the hierarchy to try to analyse all classes
/// </param>
/// <param name="A">map with classname that are being introspected, to avoid recursive calls
///
/// </param>
/// <returns>
/// </returns>
private ClassInfoList InternalIntrospect(System.Type clazz, bool recursive, ClassInfoList classInfoList)
{
if (classInfoList != null)
{
ClassInfo existingCi = (ClassInfo)classInfoList.GetClassInfoWithName(OdbClassUtil.GetFullName(clazz));
if (existingCi != null)
{
return(classInfoList);
}
}
ClassInfo classInfo = new ClassInfo(OdbClassUtil.GetFullName(clazz));
classInfo.SetClassCategory(GetClassCategory(OdbClassUtil.GetFullName(clazz)));
if (classInfoList == null)
{
classInfoList = new ClassInfoList(classInfo);
}
else
{
classInfoList.AddClassInfo(classInfo);
}
// Field[] fields = clazz.getDeclaredFields();
//UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Class.getName' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
//m by cristi
IOdbList <FieldInfo> fields = GetAllFields(OdbClassUtil.GetFullName(clazz));
IOdbList <ClassAttributeInfo> attributes = new OdbArrayList <ClassAttributeInfo>(fields.Count);
ClassInfo ci = null;
for (int i = 0; i < fields.Count; i++)
{
System.Reflection.FieldInfo field = (System.Reflection.FieldInfo)fields[i];
//Console.WriteLine("Field " + field.Name + " , type = " + field.FieldType);
if (!ODBType.GetFromClass(field.FieldType).IsNative())
{
if (recursive)
{
classInfoList = InternalIntrospect(field.FieldType, recursive, classInfoList);
ci = classInfoList.GetClassInfoWithName(OdbClassUtil.GetFullName(field.FieldType));
}
else
{
ci = new ClassInfo(OdbClassUtil.GetFullName(field.FieldType));
}
}
else
{
ci = null;
}
attributes.Add(new ClassAttributeInfo((i + 1), field.Name, field.FieldType, OdbClassUtil.GetFullName(field.FieldType), ci));
}
classInfo.SetAttributes(attributes);
classInfo.SetMaxAttributeId(fields.Count);
return(classInfoList);
}
public virtual NeoDatis.Odb.Objects <T> GetObjects <T>(System.Type clazz, bool inMemory
, int startIndex, int endIndex)
{
if (isClosed)
{
throw new NeoDatis.Odb.ODBRuntimeException(NeoDatis.Odb.Core.NeoDatisError.OdbIsClosed
.AddParameter(baseIdentification.GetIdentification()));
}
return(objectReader.GetObjects <T>(new NeoDatis.Odb.Impl.Core.Query.Criteria.CriteriaQuery
(OdbClassUtil.GetFullName(clazz)), inMemory, startIndex, endIndex));
}
public static ODBType GetFromClass(System.Type clazz)
{
string className = OdbClassUtil.GetFullName(clazz);
if (NeoDatis.Tool.Wrappers.OdbClassUtil.IsEnum(clazz))
{
ODBType type = new ODBType(ODBType.Enum.isPrimitive, ODBType.EnumId, ODBType.Enum.GetName(), 0);
type.SetName(OdbClassUtil.GetFullName(clazz));
return(type);
}
// First check if it is a 'default type'
ODBType tc = null;
typesByName.TryGetValue(className, out tc);
if (tc != null)
{
return(tc);
}
// Then check if it is a 'non default type'
cacheOfTypesByName.TryGetValue(className, out tc);
if (tc != null)
{
return(tc);
}
if (IsArray(clazz))
{
ODBType type = new ODBType(ODBType.Array.isPrimitive, ODBType.ArrayId, ODBType.Array.GetName(), 0);
type.subType = GetFromClass(clazz.GetElementType());
cacheOfTypesByName.Add(className, type);
return(type);
}
if (IsMap(clazz))
{
cacheOfTypesByName.Add(className, Map);
return(Map);
}
// check if it is a list
if (IsCollection(clazz))
{
cacheOfTypesByName.Add(className, Collection);
return(Collection);
}
nb++;
ODBType nonNative = new ODBType(ODBType.NonNative.isPrimitive, NonNativeId, OdbClassUtil.GetFullName(clazz), 0);
cacheOfTypesByName.Add(className, nonNative);
return(nonNative);
}
public static string GetFullClassName(SimpleNativeQuery query)
{
System.Type clazz = query.GetType();
System.Reflection.MethodInfo[] methods = OdbReflection.GetMethods(clazz);
for (int i = 0; i < methods.Length; i++)
{
System.Reflection.MethodInfo method = methods[i];
System.Type[] attributes = OdbReflection.GetAttributeTypes(method);
if (method.Name.Equals(MatchMethodName) && attributes.Length == 1)
{
clazz = attributes[0];
methodsCache.Add(query, method);
return(OdbClassUtil.GetFullName(clazz));
}
}
throw new ODBRuntimeException(NeoDatisError.QueryNqMatchMethodNotImplemented.AddParameter(query.GetType().FullName));
}
/// <summary>Builds a class info from a class and an existing class info
///
/// <pre>
/// The existing class info is used to make sure that fields with the same name will have
/// the same id
/// </pre>
///
/// </summary>
/// <param name="fullClassName">The name of the class to get info
/// </param>
/// <param name="existingClassInfo">
/// </param>
/// <returns> A ClassInfo - a meta representation of the class
/// </returns>
public ClassInfo GetClassInfo(System.String fullClassName, ClassInfo existingClassInfo)
{
ClassInfo classInfo = new ClassInfo(fullClassName);
classInfo.SetClassCategory(GetClassCategory(fullClassName));
;
IOdbList <FieldInfo> fields = GetAllFields(fullClassName);
IOdbList <ClassAttributeInfo> attributes = new OdbArrayList <ClassAttributeInfo>(fields.Count);
int attributeId = -1;
int maxAttributeId = existingClassInfo.GetMaxAttributeId();
ClassInfo ci = null;
for (int i = 0; i < fields.Count; i++)
{
FieldInfo field = fields[i];
// Gets the attribute id from the existing class info
attributeId = existingClassInfo.GetAttributeId(field.Name);
if (attributeId == -1)
{
maxAttributeId++;
// The attibute with field.getName() does not exist in existing class info
// create a new id
attributeId = maxAttributeId;
}
if (!ODBType.GetFromClass(field.FieldType).IsNative())
{
ci = new ClassInfo(OdbClassUtil.GetFullName(field.FieldType));
}
else
{
ci = null;
}
attributes.Add(new ClassAttributeInfo(attributeId, field.Name, field.FieldType, OdbClassUtil.GetFullName(field.FieldType), ci));
}
classInfo.SetAttributes(attributes);
classInfo.SetMaxAttributeId(maxAttributeId);
return(classInfo);
}
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);
}
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);
}
public ValuesCriteriaQuery(System.Type aClass, NeoDatis.Odb.OID oid) : base(OdbClassUtil.GetFullName(aClass))
{
SetOidOfObjectToQuery(oid);
Init();
}
public virtual object BuildOneInstance(NonNativeObjectInfo objectInfo)
{
ICache cache = GetSession().GetCache();
// verify if the object is check to delete
if (objectInfo.IsDeletedObject())
{
throw new ODBRuntimeException(NeoDatisError.ObjectIsMarkedAsDeletedForOid.AddParameter(objectInfo.GetOid()));
}
// Then check if object is in cache
object o = cache.GetObjectWithOid(objectInfo.GetOid());
if (o != null)
{
return(o);
}
Type instanceClazz = null;
instanceClazz = classPool.GetClass(objectInfo.GetClassInfo().GetFullClassName());
try
{
o = classIntrospector.NewInstanceOf(instanceClazz);
}
catch (System.Exception e)
{
throw new ODBRuntimeException(NeoDatisError.InstanciationError.AddParameter(objectInfo.GetClassInfo().GetFullClassName()), e);
}
// This can happen if ODB can not create the instance
// TODO Check if returning null is correct
if (o == null)
{
return(null);
}
// Keep the initial hash code. In some cases, when the class redefines
// the hash code method
// Hash code can return wrong values when attributes are not set (when
// hash code depends on attribute values)
// Hash codes are used as the key of the map,
// So at the end of this method, if hash codes are different, object
// will be removed from the cache and inserted back
bool hashCodeIsOk = true;
int initialHashCode = 0;
try
{
initialHashCode = o.GetHashCode();
}
catch (System.Exception)
{
hashCodeIsOk = false;
}
// Adds this incomplete instance in the cache to manage cyclic reference
if (hashCodeIsOk)
{
cache.AddObject(objectInfo.GetOid(), o, objectInfo.GetHeader());
}
ClassInfo ci = objectInfo.GetClassInfo();
IOdbList <FieldInfo> fields = classIntrospector.GetAllFields(ci.GetFullClassName());
FieldInfo field = null;
AbstractObjectInfo aoi = null;
object value = null;
for (int i = 0; i < fields.Count; i++)
{
field = fields[i];
// Gets the id of this field
int attributeId = ci.GetAttributeId(field.Name);
if (OdbConfiguration.IsDebugEnabled(LogIdDebug))
{
DLogger.Debug("getting field with name " + field.Name + ", attribute id is " + attributeId);
}
aoi = objectInfo.GetAttributeValueFromId(attributeId);
// Check consistency
// ensureClassCompatibily(field,
// instanceInfo.getClassInfo().getAttributeinfo(i).getFullClassname());
if (aoi != null && (!aoi.IsNull()))
{
if (aoi.IsNative())
{
if (aoi.IsAtomicNativeObject())
{
if (aoi.IsNull())
{
value = null;
}
else
{
value = aoi.GetObject();
}
}
if (aoi.IsCollectionObject())
{
value = BuildCollectionInstance((CollectionObjectInfo)aoi);
// Manage a specific case of Set
/*
* if (typeof(Java.Util.Set).IsAssignableFrom(field.GetType()) && typeof(ICollection).IsAssignableFrom(value.GetType()))
* {
* Java.Util.Set s = new Java.Util.HashSet();
* s.AddAll((System.Collections.ICollection)value);
* value = s;
* }*/
}
if (aoi.IsArrayObject())
{
value = BuildArrayInstance((ArrayObjectInfo)aoi);
}
if (aoi.IsMapObject())
{
value = BuildMapInstance((MapObjectInfo)aoi);
}
if (aoi.IsEnumObject())
{
value = BuildEnumInstance((EnumNativeObjectInfo)aoi, field.FieldType);
}
}
else
{
if (aoi.IsNonNativeObject())
{
if (aoi.IsDeletedObject())
{
if (NeoDatis.Odb.OdbConfiguration.DisplayWarnings())
{
IError warning = NeoDatisError.AttributeReferencesADeletedObject
.AddParameter(objectInfo.GetClassInfo().GetFullClassName())
.AddParameter(objectInfo.GetOid()).AddParameter(field.Name);
DLogger.Info(warning.ToString());
}
value = null;
}
else
{
value = BuildOneInstance((NonNativeObjectInfo)aoi);
}
}
}
if (value != null)
{
if (OdbConfiguration.IsDebugEnabled(LogIdDebug))
{
DLogger.Debug("Setting field " + field.Name + "(" + field.GetType().FullName + ") to " + value + " / " + value.GetType().FullName);
}
try
{
field.SetValue(o, value);
}
catch (System.Exception e)
{
throw new ODBRuntimeException(NeoDatisError.InstanceBuilderWrongObjectContainerType
.AddParameter(objectInfo.GetClassInfo().GetFullClassName())
.AddParameter(value.GetType().FullName).AddParameter(field.GetType().FullName), e);
}
}
}
}
if (o != null && !OdbClassUtil.GetFullName(o.GetType()).Equals(objectInfo.GetClassInfo().GetFullClassName()))
{
new ODBRuntimeException(NeoDatisError.InstanceBuilderWrongObjectType
.AddParameter(objectInfo.GetClassInfo().GetFullClassName())
.AddParameter(o.GetType().FullName));
}
if (hashCodeIsOk || initialHashCode != o.GetHashCode())
{
// Bug (sf bug id=1875544 )detected by glsender
// This can happen when an object has redefined its own hashcode
// method and depends on the field values
// Then, we have to remove object from the cache and re-insert to
// correct map hash code
cache.RemoveObjectWithOid(objectInfo.GetOid());
// re-Adds instance in the cache
cache.AddObject(objectInfo.GetOid(), o, objectInfo.GetHeader());
}
if (triggerManager != null)
{
triggerManager.ManageSelectTriggerAfter(objectInfo.GetClassInfo().GetFullClassName
(), objectInfo, objectInfo.GetOid());
}
if (OdbConfiguration.ReconnectObjectsToSession())
{
ICrossSessionCache crossSessionCache = CacheFactory.GetCrossSessionCache(engine.GetBaseIdentification().GetIdentification());
crossSessionCache.AddObject(o, objectInfo.GetOid());
}
return(o);
}
/// <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);
}
public static string GetClass(NativeQuery query)
{
return(OdbClassUtil.GetFullName(query.GetObjectType()));
}
public System.Object NewInstanceOf(System.Type clazz)
{
System.Reflection.ConstructorInfo constructor = null;
constructor = classPool.GetConstrutor(OdbClassUtil.GetFullName(clazz));
if (constructor == null)
{
// Checks if exist a default constructor - with no parameters
constructor = clazz.GetConstructor(Type.EmptyTypes);
//UPGRADE_ISSUE: Method 'java.lang.reflect.AccessibleObject.setAccessible' was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1000_javalangreflectAccessibleObject'"
//c by cristi
//constructor.setAccessible(true);
if (constructor != null)
{
classPool.AddConstrutor(OdbClassUtil.GetFullName(clazz), constructor);
}
}
if (constructor != null)
{
System.Object o = constructor.Invoke(new System.Object[0]);
return(o);
}
if (clazz.IsValueType)
{
return(Activator.CreateInstance(clazz));
}
else
{
// else take the constructer with the smaller number of parameters
// and call it will null values
// @TODO Put this info in cache !
if (OdbConfiguration.IsDebugEnabled(LogId))
{
DLogger.Debug(clazz + " does not have default constructor! using a 'with parameter' constructor will null values");
}
System.Reflection.ConstructorInfo[] constructors = clazz.GetConstructors(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.DeclaredOnly);
if (clazz.IsInterface)
{
//@TODO This is not a good solution to manage interface
return(null);
}
if (constructors.Length == 0)
{
throw new ODBRuntimeException(NeoDatisError.ClassWithoutConstructor.AddParameter(clazz.AssemblyQualifiedName));
}
int numberOfParameters = 1000;
int bestConstructorIndex = 0;
for (int i = 0; i < constructors.Length; i++)
{
//UPGRADE_TODO: The equivalent in .NET for method 'java.lang.reflect.Constructor.getParameterTypes' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
if (constructors[i].GetParameters().Length < numberOfParameters)
{
bestConstructorIndex = i;
}
}
constructor = constructors[bestConstructorIndex];
//UPGRADE_TODO: The equivalent in .NET for method 'java.lang.reflect.Constructor.getParameterTypes' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
System.Object[] nulls = new System.Object[constructor.GetParameters().Length];
for (int i = 0; i < nulls.Length; i++)
{
//UPGRADE_TODO: The equivalent in .NET for method 'java.lang.reflect.Constructor.getParameterTypes' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
//m by cristi
if (constructor.GetParameters()[i].ParameterType == System.Type.GetType("System.Int32"))
{
nulls[i] = 0;
}
else
{
//UPGRADE_TODO: The equivalent in .NET for method 'java.lang.reflect.Constructor.getParameterTypes' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
if (constructor.GetParameters()[i].ParameterType == System.Type.GetType("System.Int64"))
{
nulls[i] = 0;
}
else
{
//UPGRADE_TODO: The equivalent in .NET for method 'java.lang.reflect.Constructor.getParameterTypes' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
if (constructor.GetParameters()[i].ParameterType == System.Type.GetType("System.Int16"))
{
nulls[i] = System.Int16.Parse("0");
}
else
{
//UPGRADE_TODO: The equivalent in .NET for method 'java.lang.reflect.Constructor.getParameterTypes' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
//main by cristi
if (constructor.GetParameters()[i].ParameterType == System.Type.GetType("System.SByte"))
{
nulls[i] = System.SByte.Parse("0");
}
else
{
//UPGRADE_TODO: The equivalent in .NET for method 'java.lang.reflect.Constructor.getParameterTypes' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
//m by cristi
if (constructor.GetParameters()[i].ParameterType == System.Type.GetType("System.Single"))
{
//UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
nulls[i] = System.Single.Parse("0");
}
else
{
//UPGRADE_TODO: The equivalent in .NET for method 'java.lang.reflect.Constructor.getParameterTypes' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
//m by cristi
if (constructor.GetParameters()[i].ParameterType == System.Type.GetType("System.Double"))
{
//UPGRADE_TODO: The differences in the format of parameters for constructor 'java.lang.Double.Double' may cause compilation errors. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1092'"
nulls[i] = System.Double.Parse("0");
}
else
{
nulls[i] = null;
}
}
}
}
}
}
}
System.Object object_Renamed = null;
//UPGRADE_ISSUE: Method 'java.lang.reflect.AccessibleObject.setAccessible' was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1000_javalangreflectAccessibleObject'"
//c by cristi
//constructor.setAccessible(true);
try
{
object_Renamed = constructor.Invoke(nulls);
}
catch (System.Exception e2)
{
throw new ODBRuntimeException(NeoDatisError.NoNullableConstructor.AddParameter("[" + DisplayUtility.ObjectArrayToString(constructor.GetParameters()) + "]").AddParameter(clazz.AssemblyQualifiedName), e2);
}
return(object_Renamed);
}
}
public ValuesCriteriaQuery(System.Type aClass) : base(OdbClassUtil.GetFullName(aClass))
{
Init();
}
public override void SetFullClassName(Type type)
{
fullClassName = OdbClassUtil.GetFullName(type);
}
public CriteriaQuery(System.Type aClass)
: this(OdbClassUtil.GetFullName(aClass))
{
}
public CriteriaQuery(System.Type aClass, NeoDatis.Odb.Core.Query.Criteria.ICriterion
criteria) : this(OdbClassUtil.GetFullName(aClass), criteria)
{
}
/// <summary>Store an object with the specific id</summary>
/// <param name="oid"></param>
/// <param name="@object"></param>
/// <returns></returns>
/// <></>
protected virtual NeoDatis.Odb.OID InternalStore(OID oid, object o)
{
if (GetSession(true).IsRollbacked())
{
throw new ODBRuntimeException(NeoDatisError.OdbHasBeenRollbacked.AddParameter(GetBaseIdentification().ToString()));
}
if (o == null)
{
throw new ODBRuntimeException(NeoDatisError.OdbCanNotStoreNullObject);
}
Type clazz = o.GetType();
if (ODBType.IsNative(clazz))
{
throw new ODBRuntimeException(NeoDatisError.OdbCanNotStoreNativeObjectDirectly
.AddParameter(clazz.FullName).AddParameter(ODBType.GetFromClass(clazz).GetName()).AddParameter(clazz.FullName));
}
// The object must be transformed into meta representation
ClassInfo ci = null;
string className = OdbClassUtil.GetFullName(clazz);
// first checks if the class of this object already exist in the
// metamodel
if (GetMetaModel().ExistClass(className))
{
ci = GetMetaModel().GetClassInfo(className, true);
}
else
{
ClassInfoList ciList = classIntrospector.Introspect(o.GetType(), true);
// All new classes found
objectWriter.AddClasses(ciList);
ci = ciList.GetMainClassInfo();
}
// first detects if we must perform an insert or an update
// If object is in the cache, we must perform an update, else an insert
bool mustUpdate = false;
ICache cache = GetSession(true).GetCache();
if (o != null)
{
OID cacheOid = cache.IdOfInsertingObject(o);
if (cacheOid != null)
{
return(cacheOid);
}
// throw new ODBRuntimeException("Inserting meta representation of
// an object without the object itself is not yet supported");
mustUpdate = cache.ExistObject(o);
}
// The introspection callback is used to execute some specific task (like calling trigger, for example) while introspecting the object
IIntrospectionCallback callback = introspectionCallbackForInsert;
if (mustUpdate)
{
callback = introspectionCallbackForUpdate;
}
// Transform the object into an ObjectInfo
NonNativeObjectInfo nnoi = (NonNativeObjectInfo)objectIntrospector.GetMetaRepresentation(o, ci, true, null, callback);
// During the introspection process, if object is to be updated, then the oid has been set
mustUpdate = nnoi.GetOid() != null;
if (mustUpdate)
{
return(objectWriter.UpdateNonNativeObjectInfo(nnoi, false));
}
return(objectWriter.InsertNonNativeObject(oid, nnoi, true));
}
