private IReflectClass ForGenericObject(GenericObject genericObject)
{
Db4objects.Db4o.Reflect.Generic.GenericClass claxx = genericObject._class;
if (claxx == null)
{
throw new InvalidOperationException();
}
string name = claxx.GetName();
if (name == null)
{
throw new InvalidOperationException();
}
Db4objects.Db4o.Reflect.Generic.GenericClass existingClass = (Db4objects.Db4o.Reflect.Generic.GenericClass
)ForName(name);
if (existingClass == null)
{
_repository.Register(claxx);
return(claxx);
}
// TODO: Using .equals() here would be more consistent with
// the equals() method in GenericClass.
if (existingClass != claxx)
{
throw new InvalidOperationException();
}
return(claxx);
}
private GenericField[] Fields(GenericClass personClass, GenericReflector reflector
)
{
return new GenericField[] { new GenericField("surname", reflector.ForClass(typeof(
string)), false), new GenericField("birthdate", reflector.ForClass(typeof(DateTime
)), false), new GenericField("bestFriend", personClass, false), new GenericField
("nArray", reflector.ForClass(typeof(int[][])), true) };
}
public virtual Db4objects.Db4o.Reflect.Generic.GenericClass ArrayClass()
{
if (_array != null)
{
return _array;
}
_array = new GenericArrayClass(_reflector, this, _name, _superclass);
return _array;
}
public virtual IReflectClass CreateClass(string name, IReflectClass superClass, int
fieldCount)
{
IReflectClass nativeClass = _delegate.ForName(name);
GenericClass clazz = new GenericClass(_reflector, nativeClass, name, (GenericClass
)superClass);
clazz.SetDeclaredFieldCount(fieldCount);
return clazz;
}
public GenericClass(GenericReflector reflector, IReflectClass delegateClass, string
name, Db4objects.Db4o.Reflect.Generic.GenericClass superclass)
{
_reflector = reflector;
_delegate = delegateClass;
_name = name;
_superclass = superclass;
_hashCode = _name.GetHashCode();
}
public virtual Db4objects.Db4o.Reflect.Generic.GenericClass ArrayClass()
{
if (_array != null)
{
return(_array);
}
_array = new GenericArrayClass(_reflector, this, _name, _superclass);
return(_array);
}
public GenericClass(GenericReflector reflector, IReflectClass delegateClass, string
name, Db4objects.Db4o.Reflect.Generic.GenericClass superclass)
{
_reflector = reflector;
_delegate = delegateClass;
_name = name;
_superclass = superclass;
_hashCode = _name.GetHashCode();
}
/// <summary>todo: Move the GenericClass creation into a utility/factory class.</summary>
/// <remarks>todo: Move the GenericClass creation into a utility/factory class.</remarks>
/// <returns></returns>
public virtual GenericClass InitGenericClass()
{
GenericReflector reflector = new GenericReflector(null, Platform4.ReflectorForType
(typeof(GenericObjectsTest)));
GenericClass _objectIClass = (GenericClass)reflector.ForClass(typeof(object));
GenericClass result = new GenericClass(reflector, null, PersonClassname, _objectIClass
);
result.InitFields(Fields(result, reflector));
return result;
}
public Db4oStoredClass(Db4objects.Db4o.Ext.IStoredClass clazz, Db4oLocalConnection connection)
{
this.connection = connection;
Name = clazz.GetName();
genericClass = connection.GetGenericClass(clazz.GetName());
List<Field> list = new List<Field>();
IStoredField[] storedFields = clazz.GetStoredFields();
foreach (IStoredField field in storedFields)
{
list.Add(new Db4oField(field));
}
Fields = list;
}
public Db4oStoredClass(GenericClass clazz)
{
this.genericClass = clazz;
Name = clazz.GetName();
var list = new List<Field>();
IReflectField[] declaredFields = clazz.GetDeclaredFields();
foreach (IReflectField field in declaredFields)
{
list.Add(new Db4oField(field));
}
Fields = list;
}
private Db4objects.Db4o.Reflect.Generic.GenericClass GenericClass(IReflectClass clazz
)
{
Db4objects.Db4o.Reflect.Generic.GenericClass ret;
string name = clazz.GetName();
if (name.Equals(ReflectPlatform.FullyQualifiedName(typeof(GenericArray))))
{
// special case, comparing name because can't compare class == class directly with ReflectClass
ret = new GenericArrayClass(this, clazz, name, null);
}
else
{
ret = new Db4objects.Db4o.Reflect.Generic.GenericClass(this, clazz, name, null);
}
return(ret);
}
public override bool Equals(object obj)
{
if (this == obj)
{
return(true);
}
if (obj == null || GetType() != obj.GetType())
{
return(false);
}
Db4objects.Db4o.Reflect.Generic.GenericClass otherGC = (Db4objects.Db4o.Reflect.Generic.GenericClass
)obj;
if (_hashCode != otherGC.GetHashCode())
{
return(false);
}
return(_name.Equals(otherGC._name));
}
public virtual IReflectClass GetSuperclass()
{
if (_superclass != null)
{
return(_superclass);
}
if (_delegate == null)
{
return(_reflector.ForClass(typeof(object)));
}
IReflectClass delegateSuperclass = _delegate.GetSuperclass();
if (delegateSuperclass != null)
{
_superclass = _reflector.EnsureDelegate(delegateSuperclass);
}
return(_superclass);
}
internal virtual Db4objects.Db4o.Reflect.Generic.GenericClass EnsureDelegate(IReflectClass
clazz)
{
if (clazz == null)
{
return(null);
}
Db4objects.Db4o.Reflect.Generic.GenericClass claxx = (Db4objects.Db4o.Reflect.Generic.GenericClass
)_repository.LookupByName(clazz.GetName());
if (claxx == null)
{
// We don't have to worry about the superclass, it can be null
// because handling is delegated anyway
claxx = GenericClass(clazz);
_repository.Register(claxx);
}
return(claxx);
}
public virtual object DeepClone(object obj)
{
GenericReflector reflector = (GenericReflector)obj;
Db4objects.Db4o.Reflect.Generic.GenericClass superClass = null;
if (_superclass != null)
{
_superclass = (Db4objects.Db4o.Reflect.Generic.GenericClass)reflector.ForName(_superclass
.GetName());
}
Db4objects.Db4o.Reflect.Generic.GenericClass ret = new Db4objects.Db4o.Reflect.Generic.GenericClass
(reflector, _delegate, _name, superClass);
GenericField[] fields = new GenericField[_fields.Length];
for (int i = 0; i < fields.Length; i++)
{
fields[i] = (GenericField)_fields[i].DeepClone(reflector);
}
ret.InitFields(fields);
return ret;
}
public virtual object DeepClone(object obj)
{
GenericReflector reflector = (GenericReflector)obj;
Db4objects.Db4o.Reflect.Generic.GenericClass superClass = null;
if (_superclass != null)
{
_superclass = (Db4objects.Db4o.Reflect.Generic.GenericClass)reflector.ForName(_superclass
.GetName());
}
Db4objects.Db4o.Reflect.Generic.GenericClass ret = new Db4objects.Db4o.Reflect.Generic.GenericClass
(reflector, _delegate, _name, superClass);
GenericField[] fields = new GenericField[_fields.Length];
for (int i = 0; i < fields.Length; i++)
{
fields[i] = (GenericField)_fields[i].DeepClone(reflector);
}
ret.InitFields(fields);
return(ret);
}
public object Run()
{
Db4objects.Db4o.Reflect.Generic.GenericClass existing = (Db4objects.Db4o.Reflect.Generic.GenericClass
) this._enclosing._repository.LookupByID(id);
if (existing != null)
{
if (null != converter)
{
}
else
{
// existing.setSecondClass();
existing.SetConverter(null);
}
return(null);
}
IReflectClass clazz = this._enclosing._delegate.ForName(name);
Db4objects.Db4o.Reflect.Generic.GenericClass claxx = null;
if (clazz != null)
{
claxx = this._enclosing.EnsureDelegate(clazz);
}
else
{
claxx = new Db4objects.Db4o.Reflect.Generic.GenericClass(this._enclosing, null, name
, null);
this._enclosing.Register(claxx);
claxx.InitFields(new GenericField[] { new GenericField(null, null, true) });
claxx.SetConverter(converter);
}
// claxx.setSecondClass();
claxx.SetPrimitive();
this._enclosing._repository.Register(id, claxx);
return(null);
}
public virtual IReflectClass GetSuperclass()
{
if (_superclass != null)
{
return _superclass;
}
if (_delegate == null)
{
return _reflector.ForClass(typeof(object));
}
IReflectClass delegateSuperclass = _delegate.GetSuperclass();
if (delegateSuperclass != null)
{
_superclass = _reflector.EnsureDelegate(delegateSuperclass);
}
return _superclass;
}
/// <summary>Register a class</summary>
/// <param name="clazz">class</param>
public virtual void Register(GenericClass clazz)
{
WithLock(new _IClosure4_303(this, clazz));
}
public GenericArrayClass(GenericReflector reflector, IReflectClass delegateClass,
string name, GenericClass superclass) : base(reflector, delegateClass, name, superclass
)
{
}
public virtual GenericClass ClassMetaToGenericClass(GenericReflector reflector, ClassInfo
classMeta)
{
if (classMeta.IsSystemClass())
{
return (GenericClass)reflector.ForName(classMeta.GetClassName());
}
string className = classMeta.GetClassName();
// look up from generic class table.
GenericClass genericClass = LookupGenericClass(className);
if (genericClass != null)
{
return genericClass;
}
IReflectClass reflectClass = reflector.ForName(className);
if (reflectClass != null)
{
return (GenericClass)reflectClass;
}
GenericClass genericSuperClass = null;
ClassInfo superClassMeta = classMeta.GetSuperClass();
if (superClassMeta != null)
{
genericSuperClass = ClassMetaToGenericClass(reflector, superClassMeta);
}
genericClass = new GenericClass(reflector, null, className, genericSuperClass);
RegisterGenericClass(className, genericClass);
FieldInfo[] fields = classMeta.GetFields();
GenericField[] genericFields = new GenericField[fields.Length];
for (int i = 0; i < fields.Length; ++i)
{
ClassInfo fieldClassMeta = fields[i].GetFieldClass();
string fieldName = fields[i].GetFieldName();
GenericClass genericFieldClass = ClassMetaToGenericClass(reflector, fieldClassMeta
);
genericFields[i] = new GenericField(fieldName, genericFieldClass, fields[i]._isPrimitive
);
}
genericClass.InitFields(genericFields);
return genericClass;
}
private void RegisterGenericClass(string className, GenericClass classMeta)
{
_genericClassTable.Put(className, classMeta);
((GenericReflector)classMeta.Reflector()).Register(classMeta);
}
private GenericClass GenericClass(IReflectClass clazz
)
{
GenericClass ret;
var name = clazz.GetName();
if (name.Equals(ReflectPlatform.FullyQualifiedName(typeof (GenericArray))))
{
// special case, comparing name because can't compare class == class directly with ReflectClass
ret = new GenericArrayClass(this, clazz, name, null);
}
else
{
ret = new GenericClass(this, clazz, name, null);
}
return ret;
}
public GenericArrayClass(GenericReflector reflector, IReflectClass delegateClass,
string name, GenericClass superclass) : base(reflector, delegateClass, name, superclass
)
{
}
public GenericObject(GenericClass clazz)
{
_class = clazz;
}
public GenericArray(GenericClass clazz, int size)
{
_clazz = clazz;
_data = new object[size];
}
public _IClosure4_303(GenericReflector _enclosing, Db4objects.Db4o.Reflect.Generic.GenericClass
clazz)
{
this._enclosing = _enclosing;
this.clazz = clazz;
}
public _IClosure4_303(GenericReflector _enclosing, GenericClass
clazz)
{
this._enclosing = _enclosing;
this.clazz = clazz;
}
/// <summary>Register a class</summary>
/// <param name="clazz">class</param>
public virtual void Register(Db4objects.Db4o.Reflect.Generic.GenericClass clazz)
{
WithLock(new _IClosure4_303(this, clazz));
}
public GenericObject(GenericClass clazz)
{
_class = clazz;
}
public GenericArray(GenericClass clazz, int size)
{
_clazz = clazz;
_data = new object[size];
}
public GenericField(string name, IReflectClass clazz, bool primitive)
{
_name = name;
_type = (GenericClass)clazz;
_primitive = primitive;
}
public _IClosure4_303(GenericReflector _enclosing, GenericClass
clazz)
{
this._enclosing = _enclosing;
this.clazz = clazz;
}
public object Run()
{
Db4objects.Db4o.Reflect.Generic.GenericClass existing = (Db4objects.Db4o.Reflect.Generic.GenericClass
)this._enclosing._repository.LookupByID(id);
if (existing != null)
{
if (null != converter)
{
}
else
{
// existing.setSecondClass();
existing.SetConverter(null);
}
return null;
}
IReflectClass clazz = this._enclosing._delegate.ForName(name);
Db4objects.Db4o.Reflect.Generic.GenericClass claxx = null;
if (clazz != null)
{
claxx = this._enclosing.EnsureDelegate(clazz);
}
else
{
claxx = new Db4objects.Db4o.Reflect.Generic.GenericClass(this._enclosing, null, name
, null);
this._enclosing.Register(claxx);
claxx.InitFields(new GenericField[] { new GenericField(null, null, true) });
claxx.SetConverter(converter);
}
// claxx.setSecondClass();
claxx.SetPrimitive();
this._enclosing._repository.Register(id, claxx);
return null;
}
/// <summary>Register a class</summary>
/// <param name="clazz">class</param>
public virtual void Register(GenericClass clazz)
{
WithLock(new _IClosure4_303(this, clazz));
}
public GenericField(string name, IReflectClass clazz, bool primitive)
{
_name = name;
_type = (GenericClass)clazz;
_primitive = primitive;
}
public object Run()
{
var existing = (GenericClass
) _enclosing._repository.LookupByID(id);
if (existing != null)
{
if (null != converter)
{
}
else
{
// existing.setSecondClass();
existing.SetConverter(null);
}
return null;
}
var clazz = _enclosing._delegate.ForName(name);
GenericClass claxx = null;
if (clazz != null)
{
claxx = _enclosing.EnsureDelegate(clazz);
}
else
{
claxx = new GenericClass(_enclosing, null, name
, null);
_enclosing.Register(claxx);
claxx.InitFields(new[] {new GenericField(null, null, true)});
claxx.SetConverter(converter);
}
// claxx.setSecondClass();
claxx.SetPrimitive();
_enclosing._repository.Register(id, claxx);
return null;
}
