public virtual NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeObjectInfo BuildNnoi (object o, NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo classInfo, NeoDatis.Odb.Core.Layers.Layer2.Meta.AbstractObjectInfo [] values, long[] attributesIdentification, int[] attributeIds, System.Collections.Generic.IDictionary <object, NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeObjectInfo> alreadyReadObjects ) { NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeObjectInfo nnoi = new NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeObjectInfo (o, classInfo, values, attributesIdentification, attributeIds); if (storageEngine != null) { // for unit test purpose NeoDatis.Odb.Core.Transaction.ICache cache = storageEngine.GetSession(true).GetCache (); // Check if object is in the cache, if so sets its oid NeoDatis.Odb.OID oid = cache.GetOid(o, false); if (oid != null) { nnoi.SetOid(oid); // Sets some values to the new header to keep track of the infos // when // executing NeoDatis without closing it, just committing. // Bug reported by Andy NeoDatis.Odb.Core.Layers.Layer2.Meta.ObjectInfoHeader oih = cache.GetObjectInfoHeaderFromOid (oid, true); nnoi.GetHeader().SetObjectVersion(oih.GetObjectVersion()); nnoi.GetHeader().SetUpdateDate(oih.GetUpdateDate()); nnoi.GetHeader().SetCreationDate(oih.GetCreationDate()); } } return(nnoi); }
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 override void SetMetaModel(NeoDatis.Odb.Core.Layers.Layer2.Meta.MetaModel metaModel2) { NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo ci = null; NeoDatis.Odb.Core.Layers.Layer2.Meta.MetaModel metaModel = new NeoDatis.Odb.Core.Layers.Layer2.Meta.SessionMetaModel (); GetSession(true).SetMetaModel(metaModel); // Just add the classes System.Collections.IEnumerator iterator = metaModel2.GetAllClasses().GetEnumerator (); while (iterator.MoveNext()) { this.GetMetaModel().AddClass((NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo)iterator .Current); } // Now persists classes iterator = metaModel.GetAllClasses().GetEnumerator(); int i = 0; while (iterator.MoveNext()) { ci = (NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo)iterator.Current; if (ci.GetPosition() == -1) { objectWriter.PersistClass(ci, (i == 0 ? -2 : i - 1), false, false); } i++; } }
public NeoDatisStoredClass(ClassInfo ci, NeoDatisLocalConnection connection) { this.ci = ci; this.connection = connection; Name = ci.GetFullClassName(); var classAttributeInfos = ci.GetAttributes(); fields = classAttributeInfos.Select(cai => (Field) new NeoDatisField() {Name = cai.GetName(), DataType = cai.GetAttributeType().GetName()}).ToList(); }
public virtual NeoDatis.Odb.Core.Layers.Layer2.Meta.AbstractObjectInfo GetMetaRepresentation (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) { return(GetObjectInfo(o, ci, recursive, alreadyReadObjects, callback)); }
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>Reconnect an object to the current session.</summary> /// <remarks> /// Reconnect an object to the current session. It connects the object and /// all the dependent objects (Objects accessible from the object graph of the /// root object /// </remarks> public override void Reconnect(object @object) { if (@object == null) { throw new NeoDatis.Odb.ODBRuntimeException(NeoDatis.Odb.Core.NeoDatisError.ReconnectCanReconnectNullObject ); } NeoDatis.Odb.Core.Transaction.ICrossSessionCache crossSessionCache = NeoDatis.Odb.Impl.Core.Transaction.CacheFactory .GetCrossSessionCache(GetBaseIdentification().GetIdentification()); NeoDatis.Odb.OID oid = crossSessionCache.GetOid(@object); //in some situation the user can control the disconnect and reconnect //so before throws an exception test if in the current session //there is the object on the cache if (oid == null) { throw new NeoDatis.Odb.ODBRuntimeException(NeoDatis.Odb.Core.NeoDatisError.CrossSessionCacheNullOidForObject .AddParameter(@object)); } NeoDatis.Odb.Core.Layers.Layer2.Meta.ObjectInfoHeader oih = objectReader.ReadObjectInfoHeaderFromOid (oid, false); GetSession(true).AddObjectToCache(oid, @object, oih); // Retrieve Dependent Objects NeoDatis.Odb.Impl.Core.Layers.Layer1.Introspector.GetDependentObjectIntrospectingCallback getObjectsCallback = new NeoDatis.Odb.Impl.Core.Layers.Layer1.Introspector.GetDependentObjectIntrospectingCallback (); NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo ci = GetSession(true).GetMetaModel ().GetClassInfoFromId(oih.GetClassInfoId()); objectIntrospector.GetMetaRepresentation(@object, ci, true, null, getObjectsCallback ); System.Collections.Generic.ICollection <object> dependentObjects = getObjectsCallback .GetObjects(); System.Collections.Generic.IEnumerator <object> iterator = dependentObjects.GetEnumerator (); while (iterator.MoveNext()) { object o = iterator.Current; if (o != null) { oid = crossSessionCache.GetOid(o); if (oid == null) { throw new NeoDatis.Odb.ODBRuntimeException(NeoDatis.Odb.Core.NeoDatisError.CrossSessionCacheNullOidForObject .AddParameter(o)); } oih = objectReader.ReadObjectInfoHeaderFromOid(oid, false); GetSession(true).AddObjectToCache(oid, o, oih); } } }
public override System.IComparable ComputeIndexKey(NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo ci, NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfoIndex index) { NeoDatis.Odb.Impl.Core.Query.Criteria.CriteriaQuery q = (NeoDatis.Odb.Impl.Core.Query.Criteria.CriteriaQuery )query; NeoDatis.Odb.Core.Layers.Layer2.Meta.AttributeValuesMap values = q.GetCriteria(). GetValues(); // if values.hasOid() is true, this means that we are working of the full object, // the index key is then the oid and not the object itself if (values.HasOid()) { return(new NeoDatis.Odb.Core.Query.SimpleCompareKey(values.GetOid())); } return(NeoDatis.Odb.Core.Query.Execution.IndexTool.ComputeKey(classInfo, index, ( NeoDatis.Odb.Impl.Core.Query.Criteria.CriteriaQuery)query)); }
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); }
/// <summary> /// Saves the fact that something has changed in the class (number of objects /// or last object oid) /// </summary> /// <param name="classInfo"></param> /// <param name="uci"></param> public override void AddChangedClass(ClassInfo classInfo) { changedClasses[classInfo] = classInfo; SetHasChanged(true); }
public virtual ClassInfoCompareResult ExtractDifferences(ClassInfo newCI, bool update) { string attributeName = null; ClassAttributeInfo cai1 = null; ClassAttributeInfo cai2 = null; Meta.ClassInfoCompareResult result = new ClassInfoCompareResult(GetFullClassName()); bool isCompatible = true; IOdbList <ClassAttributeInfo> attributesToRemove = new OdbArrayList <ClassAttributeInfo>(10); IOdbList <ClassAttributeInfo> attributesToAdd = new OdbArrayList <ClassAttributeInfo>(10); int nbAttributes = attributes.Count; for (int id = 0; id < nbAttributes; id++) { // !!!WARNING : ID start with 1 and not 0 cai1 = attributes[id]; if (cai1 == null) { continue; } attributeName = cai1.GetName(); cai2 = newCI.GetAttributeInfoFromId(cai1.GetId()); if (cai2 == null) { result.AddCompatibleChange("Field '" + attributeName + "' has been removed"); if (update) { // Simply remove the attribute from meta-model attributesToRemove.Add(cai1); } } else { if (!ODBType.TypesAreCompatible(cai1.GetAttributeType(), cai2.GetAttributeType())) { result.AddIncompatibleChange("Type of Field '" + attributeName + "' has changed : old='" + cai1.GetFullClassname() + "' - new='" + cai2.GetFullClassname() + "'"); isCompatible = false; } } } int nbNewAttributes = newCI.attributes.Count; for (int id = 0; id < nbNewAttributes; id++) { // !!!WARNING : ID start with 1 and not 0 cai2 = newCI.attributes[id]; if (cai2 == null) { continue; } attributeName = cai2.GetName(); cai1 = GetAttributeInfoFromId(cai2.GetId()); if (cai1 == null) { result.AddCompatibleChange("Field '" + attributeName + "' has been added"); if (update) { // Sets the right id of attribute cai2.SetId(maxAttributeId + 1); maxAttributeId++; // Then adds the new attribute to the meta-model attributesToAdd.Add(cai2); } } } attributes.RemoveAll(attributesToRemove); attributes.AddAll(attributesToAdd); FillAttributesMap(); return(result); }
public virtual ClassInfo Duplicate(bool onlyData ) { ClassInfo ci = new ClassInfo (fullClassName); ci.extraInfo = extraInfo; ci.SetAttributes(attributes); ci.SetClassCategory(classCategory); ci.SetMaxAttributeId(maxAttributeId); if (onlyData) { return ci; } ci.SetAttributesDefinitionPosition(attributesDefinitionPosition); ci.SetBlockSize(blockSize); ci.SetExtraInfo(extraInfo); ci.SetId(id); ci.SetPreviousClassOID(previousClassOID); ci.SetNextClassOID(nextClassOID); ci.SetLastObjectInfoHeader(lastObjectInfoHeader); ci.SetPosition(position); ci.SetIndexes(indexes); return ci; }
public virtual ClassInfoCompareResult ExtractDifferences(ClassInfo newCI, bool update) { string attributeName = null; ClassAttributeInfo cai1 = null; ClassAttributeInfo cai2 = null; Meta.ClassInfoCompareResult result = new ClassInfoCompareResult(GetFullClassName()); bool isCompatible = true; IOdbList<ClassAttributeInfo> attributesToRemove = new OdbArrayList<ClassAttributeInfo>(10); IOdbList<ClassAttributeInfo> attributesToAdd = new OdbArrayList<ClassAttributeInfo>(10); int nbAttributes = attributes.Count; for (int id = 0; id < nbAttributes; id++) { // !!!WARNING : ID start with 1 and not 0 cai1 = attributes[id]; if (cai1 == null) { continue; } attributeName = cai1.GetName(); cai2 = newCI.GetAttributeInfoFromId(cai1.GetId()); if (cai2 == null) { result.AddCompatibleChange("Field '" + attributeName + "' has been removed"); if (update) { // Simply remove the attribute from meta-model attributesToRemove.Add(cai1); } } else { if (!ODBType.TypesAreCompatible(cai1.GetAttributeType(), cai2.GetAttributeType())) { result.AddIncompatibleChange("Type of Field '" + attributeName + "' has changed : old='" + cai1.GetFullClassname() + "' - new='" + cai2.GetFullClassname() + "'"); isCompatible = false; } } } int nbNewAttributes = newCI.attributes.Count; for (int id = 0; id < nbNewAttributes; id++) { // !!!WARNING : ID start with 1 and not 0 cai2 = newCI.attributes[id]; if (cai2 == null) { continue; } attributeName = cai2.GetName(); cai1 = GetAttributeInfoFromId(cai2.GetId()); if (cai1 == null) { result.AddCompatibleChange("Field '" + attributeName + "' has been added"); if (update) { // Sets the right id of attribute cai2.SetId(maxAttributeId + 1); maxAttributeId++; // Then adds the new attribute to the meta-model attributesToAdd.Add(cai2); } } } attributes.RemoveAll(attributesToRemove); attributes.AddAll(attributesToAdd); FillAttributesMap(); return result; }
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> </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; }
/// <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; }
/// <summary> /// Saves the fact that something has changed in the class (number of objects /// or last object oid) /// </summary> /// <param name="classInfo"></param> /// <param name="uci"></param> public override void AddChangedClass(ClassInfo classInfo) { changedClasses[classInfo] = classInfo; SetHasChanged(true); }
/// <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); }