private void ThrowUnsupportedAdd(IReflectClass runtimeAncestor)
{
throw new InvalidOperationException("Unsupported class hierarchy change. Class "
+ runtimeAncestor.GetName() + " was added to hierarchy of " +
_runtimeClass.GetName
());
}
public DeleteContextImpl(Db4objects.Db4o.Internal.StatefulBuffer buffer, ObjectHeader
objectHeader, IReflectClass fieldClass, Config4Field fieldConfig) : base(buffer
.Transaction(), buffer, objectHeader)
{
_fieldClass = fieldClass;
_fieldConfig = fieldConfig;
}
public PrimitiveTypeMetadata(ObjectContainerBase container, ITypeHandler4 handler
, int id, IReflectClass classReflector) : base(container, classReflector)
{
_aspects = FieldMetadata.EmptyArray;
_typeHandler = handler;
_id = id;
}
internal QConClass(Transaction trans, QCon parent, QField field, IReflectClass claxx
) : base(trans, parent, field, null)
{
// C/S
if (claxx != null)
{
ObjectContainerBase container = trans.Container();
_classMetadata = container.ClassMetadataForReflectClass(claxx);
if (_classMetadata == null)
{
// could be an aliased class, try to resolve.
string className = claxx.GetName();
string aliasRunTimeName = container.Config().ResolveAliasStoredName(className);
if (!className.Equals(aliasRunTimeName))
{
_classMetadata = container.ClassMetadataForName(aliasRunTimeName);
}
}
if (claxx.Equals(container._handlers.IclassObject))
{
_classMetadata = (ClassMetadata)_classMetadata.TypeHandler();
}
}
_claxx = claxx;
}
public SelfField(string name, IReflectClass type, SelfClass selfclass, SelfReflectionRegistry
registry)
{
_name = name;
_type = type;
_selfclass = selfclass;
_registry = registry;
}
private void AssertKnownClasses(IReflectClass[] knownClasses)
{
for (int i = 0; i < knownClasses.Length; i++)
{
Assert.AreNotEqual(FullyQualifiedName(typeof(StoredClassFilterTestCase.SimpleClass
)), knownClasses[i].GetName());
}
}
public virtual IReflectClass GetComponentType(IReflectClass a_class)
{
while (a_class.IsArray())
{
a_class = a_class.GetComponentType();
}
return a_class;
}
public virtual bool CanHandleClass(IReflectClass claxx)
{
if (_mapHandler.CanHandleClass(claxx))
{
return true;
}
return ReplicationPlatform.IsBuiltinCollectionClass(_reflector, claxx);
}
public virtual IReflectClass ClassReflector(IReflector reflector)
{
if (_classReflector == null)
{
_classReflector = ((IBuiltinTypeHandler)GetHandler()).ClassReflector();
}
return _classReflector;
}
private void AssertKnownClasses(IReflectClass[] knownClasses)
{
for (var i = 0; i < knownClasses.Length; i++)
{
Assert.AreNotEqual(FullyQualifiedName(typeof (SimpleClass
)), knownClasses[i].GetName());
}
}
public virtual object CloneWithCounterparts(ICollectionSource sourceProvider, object
originalMap, IReflectClass claxx, ICounterpartFinder elementCloner)
{
IDictionary original = (IDictionary)originalMap;
IDictionary result = (IDictionary)EmptyClone(sourceProvider, original, claxx);
CopyState(original, result, elementCloner);
return result;
}
public virtual bool IsNDimensional(IReflectClass a_class)
{
if (a_class is GenericArrayClass)
{
return false;
}
return _delegate.IsNDimensional(a_class.GetDelegate());
}
private ClassInfo MapSuperclass(IReflectClass claxx)
{
IReflectClass superClass = claxx.GetSuperclass();
if (superClass != null)
{
return GetClassMeta(superClass);
}
return null;
}
public virtual IReflectClass CreateClass(string name, IReflectClass superClass, int
fieldCount)
{
var nativeClass = _delegate.ForName(name);
var clazz = new GenericClass(_reflector, nativeClass, name, (GenericClass
) superClass);
clazz.SetDeclaredFieldCount(fieldCount);
return clazz;
}
public virtual void RegisterReflector(IReflector reflector)
{
_classReflector = reflector.ForClass(JavaClass());
var clazz = PrimitiveJavaClass();
if (clazz != null)
{
_primitiveClassReflector = reflector.ForClass(clazz);
}
}
private ClassInfo NewUserClassMeta(IReflectClass claxx)
{
ClassInfo classMeta = ClassInfo.NewUserClass(claxx.GetName());
classMeta.SetSuperClass(MapSuperclass(claxx));
RegisterClassMeta(claxx.GetName(), classMeta);
classMeta.SetFields(MapFields(claxx.GetDeclaredFields(), ShouldStoreTransientFields
(claxx)));
return classMeta;
}
private static TypeName NameOf(IReflectClass typeToFind)
{
var name = TypeNameParser.ParseString(typeToFind.GetName());
if (typeToFind.IsArray() && !name.ArrayOf.HasValue)
{
return TypeName.CreateArrayOf(name, 1);
}
return name;
}
public virtual object EmptyClone(ICollectionSource sourceProvider, object original
, IReflectClass originalCollectionClass)
{
if (sourceProvider.IsProviderSpecific(original) || original is Hashtable)
{
return new Hashtable(((IDictionary)original).Count);
}
return _reflector.ForObject(original).NewInstance();
}
private ITypeDescription CreateArrayType(TypeName fullName,
IReflectClass classInfo, Func<TypeName, Maybe<IReflectClass>> classLookup,
IDictionary<string, ITypeDescription> knownTypes)
{
var innerType = GetOrCreateType(classInfo.GetComponentType(), classLookup, knownTypes);
var type = ArrayDescription.Create(innerType, fullName.OrderOfArray);
knownTypes[fullName.FullName] = type;
return type;
}
public virtual object NewInstance(IReflectClass componentType, int length)
{
componentType = componentType.GetDelegate();
if (componentType is GenericClass)
{
return new GenericArray(((GenericClass)componentType).ArrayClass(), length);
}
return _delegate.NewInstance(componentType, length);
}
public virtual IReflectClass GetComponentType(IReflectClass claxx)
{
claxx = claxx.GetDelegate();
if (claxx is GenericClass)
{
return claxx;
}
return _delegate.GetComponentType(claxx);
}
public virtual bool CallConstructor(IReflectClass clazz)
{
TernaryBool specialized = CallConstructorSpecialized(clazz);
if (!specialized.IsUnspecified())
{
return specialized.DefiniteYes();
}
return _config.CallConstructors().DefiniteYes();
}
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();
}
private void TraverseSuperclass(object @object, IReflectClass claxx)
{
IReflectClass superclass = claxx.GetSuperclass();
if (superclass == null)
{
return;
}
TraverseAllFields(@object, superclass);
}
public virtual IReflectField CreateField(IReflectClass parentType, string fieldName
, IReflectClass fieldType, bool isVirtual, bool isPrimitive, bool isArray, bool
isNArray)
{
if (isVirtual)
{
return new GenericVirtualField(fieldName);
}
return new GenericField(fieldName, fieldType, isPrimitive);
}
public HierarchyAnalyzer(ClassMetadata storedClass, IReflectClass runtimeClass)
{
if (storedClass == null || runtimeClass == null)
{
throw new ArgumentNullException();
}
_storedClass = storedClass;
_runtimeClass = runtimeClass;
_objectClass = runtimeClass.Reflector().ForClass(typeof(object));
}
public override object NewInstance(IReflectClass componentType, int[] dimensions)
{
Type type = GetNetType(componentType);
if (dimensions.Length == 1)
{
return UnfoldArrayCreation(type, dimensions, 0);
}
return UnfoldArrayCreation(GetArrayType(type, dimensions.Length - 1), dimensions, 0);
}
private void TraverseFields(object @object, IReflectClass claxx)
{
IEnumerator fields = FieldIterators.PersistentFields(claxx);
while (fields.MoveNext())
{
IReflectField field = (IReflectField)fields.Current;
object value = field.Get(@object);
QueueUpForTraversing(value);
}
}
public virtual object NewInstance(IReflectClass componentType, ArrayInfo info)
{
componentType = componentType.GetDelegate();
if (componentType is GenericClass)
{
int length = info.ElementCount();
return new GenericArray(((GenericClass)componentType).ArrayClass(), length);
}
return _delegate.NewInstance(componentType, info);
}
internal override QConClass ShareParentForClass(IReflectClass a_class, BooleanByRef
removeExisting)
{
if (i_parent == null)
{
return null;
}
QConClass newConstraint = new QConClass(i_trans, i_parent, GetField(), a_class);
Morph(removeExisting, newConstraint, a_class);
return newConstraint;
}
private void CopyFieldValuesAcross(object src, object dest, IReflectClass claxx,
IReplicationProviderInside sourceProvider, IReplicationProviderInside targetProvider
)
{
IEnumerator fields = FieldIterators.PersistentFields(claxx);
while (fields.MoveNext())
{
IReflectField field = (IReflectField)fields.Current;
object value = field.Get(src);
field.Set(dest, FindCounterpart(value, sourceProvider, targetProvider));
}
IReflectClass superclass = claxx.GetSuperclass();
if (superclass == null)
{
return;
}
CopyFieldValuesAcross(src, dest, superclass, sourceProvider, targetProvider);
}
private IConstraint AddClassConstraint(IReflectClass claxx)
{
if (IsTheObjectClass(claxx))
{
return(null);
}
if (claxx.IsInterface())
{
return(AddInterfaceConstraint(claxx));
}
Collection4 newConstraints = IntroduceClassConstrain(claxx);
if (newConstraints.IsEmpty())
{
QConClass qcc = new QConClass(_trans, claxx);
AddConstraint(qcc);
return(qcc);
}
return(ToConstraint(newConstraints));
}
public virtual object Coerce(IReflectClass valueClass, object value)
{
if (value == null)
{
return(_isPrimitive ? No4.Instance : value);
}
if (valueClass == null)
{
throw new ArgumentNullException();
}
if (GetHandler() is PrimitiveHandler)
{
return(((PrimitiveHandler)GetHandler()).Coerce(valueClass, value));
}
if (!CanHold(valueClass))
{
return(No4.Instance);
}
return(value);
}
public void TraverseObjTree(ref TreeGridNode rootNode, object currObj, string classname)
{
container = Db4oClient.Client;
IReflectClass refClass = DataLayerCommon.ReflectClassForName(classname);
if (refClass == null)
{
return;
}
string type1 = refClass.ToString();
if (!String.IsNullOrEmpty(type1))
{
try
{
IType type = Db4oClient.TypeResolver.Resolve(refClass);
if (type.IsPrimitive)
{
TreeGridNode node = new TreeGridNode();
rootNode.Nodes.Add(node);
node.Cells[0].Value = ClassNameFor(container.Ext().Reflector().ForObject(currObj).GetName());
node.Cells[1].Value = currObj.ToString();
node.Cells[1].ReadOnly = checkReadonlyStatus();
SetFieldType(node, type);
node.Tag = currObj;
node.ImageIndex = 2;
return;
}
IReflectField[] fieldArr = DataLayerCommon.GetDeclaredFieldsInHeirarchy(refClass);
rootNode = TraverseFields(rootNode, currObj, fieldArr);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
}
}
}
public void OnClassRegistered(ClassMetadata clazz)
{
// if(Platform4.isDb4oClass(clazz.getName())) {
// return;
// }
IReflectClass reflectClass = clazz.ClassReflector();
if (this.ActivatableClass().IsAssignableFrom(reflectClass))
{
return;
}
if (this.HasNoActivatingFields(reflectClass))
{
return;
}
NotTransparentActivationEnabled diagnostic = new NotTransparentActivationEnabled(
clazz);
DiagnosticProcessor processor = this._container.Handlers.DiagnosticProcessor();
processor.OnDiagnostic(diagnostic);
}
public bool IsArray()
{
try
{
IReflectClass rClass = DataLayerCommon.ReflectClassForName(m_classname);
if (rClass != null)
{
IReflectField rField = DataLayerCommon.GetDeclaredFieldInHeirarchy(rClass, m_fieldname);
if (rField != null)
{
return(rField.GetFieldType().IsArray());
}
}
return(false);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(false);
}
}
private ClassMetadata DetectFieldType()
{
IReflectClass claxx = _containingClass.ClassReflector();
if (claxx == null)
{
return(null);
}
_reflectField = claxx.GetDeclaredField(_name);
if (_reflectField == null)
{
return(null);
}
IReflectClass fieldType = _reflectField.GetFieldType();
if (fieldType == null)
{
return(null);
}
return(Handlers4.ErasedFieldType(Container(), fieldType));
}
public ITypeHandler4 ConfiguredTypeHandler(IReflectClass claxx)
{
object cachedHandler = _mapReflectorToTypeHandler.Get(claxx);
if (null != cachedHandler)
{
return((ITypeHandler4)cachedHandler);
}
ITypeHandler4 typeHandler = Container().ConfigImpl.TypeHandlerForClass(claxx, HandlerVersion
);
if (typeHandler is IBuiltinTypeHandler)
{
((IBuiltinTypeHandler)typeHandler).RegisterReflector(Reflector());
}
if (Handlers4.IsValueType(typeHandler))
{
MapClassToTypeHandler(claxx, typeHandler);
}
return(typeHandler);
}
public static IReflectField GetDeclaredFieldInHeirarchy(IReflectClass aClass, string attribute)
{
try
{
while (aClass != null)
{
IReflectField refField = GetDeclaredField(aClass, attribute);
if (refField != null)
{
return(refField);
}
aClass = aClass.GetSuperclass();
}
}
catch (Exception e)
{
LoggingHelper.HandleException(e);
}
return(null);
}
public static bool IsArray(object expandedObj)
{
try
{
if (expandedObj != null)
{
IReflectClass refClass = ReflectClassFor(expandedObj);
if (refClass != null)
{
IType type = Db4oClient.TypeResolver.Resolve(refClass);
return(type.IsArray);
}
}
return(false);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(false);
}
}
/// <exception cref="System.Exception"></exception>
protected virtual void AssertNullItem(object obj)
{
IReflectClass claxx = Reflector().ForObject(obj);
IReflectField[] fields = claxx.GetDeclaredFields();
for (int i = 0; i < fields.Length; ++i)
{
IReflectField field = fields[i];
if (field.IsStatic() || field.IsTransient())
{
continue;
}
IReflectClass type = field.GetFieldType();
if (Container().ClassMetadataForReflectClass(type).IsValueType())
{
continue;
}
object value = field.Get(obj);
Assert.IsNull(value);
}
}
private FieldInfo[] MapFields(IReflectField[] fields, bool shouldStoreTransientFields
)
{
if (!shouldStoreTransientFields)
{
fields = FilterTransientFields(fields);
}
FieldInfo[] fieldsMeta = new FieldInfo[fields.Length];
for (int i = 0; i < fields.Length; ++i)
{
IReflectField field = fields[i];
bool isArray = field.GetFieldType().IsArray();
IReflectClass fieldClass = isArray ? field.GetFieldType().GetComponentType() : field
.GetFieldType();
bool isPrimitive = fieldClass.IsPrimitive();
// TODO: need to handle NArray, currently it ignores NArray and alway sets NArray flag false.
fieldsMeta[i] = new FieldInfo(field.GetName(), GetClassMeta(fieldClass), isPrimitive
, isArray, false);
}
return(fieldsMeta);
}
public override object NewInstance(IReflectClass componentType, ArrayInfo info)
{
Type type = GetNetType(componentType);
if (info.Nullable())
{
type = NullableType(type);
}
MultidimensionalArrayInfo multiDimensionalInfo = info as MultidimensionalArrayInfo;
if (multiDimensionalInfo == null)
{
return(System.Array.CreateInstance(type, info.ElementCount()));
}
int[] dimensions = multiDimensionalInfo.Dimensions();
if (dimensions.Length == 1)
{
return(UnfoldArrayCreation(type, dimensions, 0));
}
return(UnfoldArrayCreation(GetArrayType(type, dimensions.Length - 1), dimensions, 0));
}
/// <summary>
/// This is to ensure that reflector.forObject(GenericArray) returns an instance of GenericArrayClass instead of GenericClass
/// http://tracker.db4o.com/jira/browse/COR-376
/// </summary>
public virtual void TestGenericArrayClass()
{
IExtObjectContainer oc = Fixture().Db();
InitGenericObjects();
IReflectClass elementType = oc.Reflector().ForName(PersonClassname);
object array = Reflector().Array().NewInstance(elementType, 5);
IReflectClass arrayClass = oc.Reflector().ForObject(array);
Assert.IsTrue(arrayClass.IsArray());
Assert.IsTrue(arrayClass is GenericArrayClass);
arrayClass = oc.Reflector().ForName(array.GetType().FullName);
Assert.IsTrue(arrayClass.IsArray());
Assert.IsTrue(arrayClass is GenericArrayClass);
arrayClass = oc.Reflector().ForClass(array.GetType());
Assert.IsTrue(arrayClass.IsArray());
Assert.IsTrue(arrayClass is GenericArrayClass);
Assert.AreEqual(arrayClass.GetName(), ReflectPlatform.FullyQualifiedName(array.GetType
()));
Assert.AreEqual("(GA) " + elementType.GetName(), array.ToString());
}
public static IEventDispatcher ForClass(ObjectContainerBase container, IReflectClass
classReflector)
{
if (container == null || classReflector == null)
{
throw new ArgumentNullException();
}
if (!container.DispatchsEvents())
{
return(NullDispatcher);
}
int count = EventCountFor(container);
if (count == 0)
{
return(NullDispatcher);
}
IReflectMethod[] handlers = EventHandlerTableFor(container, classReflector);
return(HasEventHandler(handlers) ? new EventDispatchers.EventDispatcherImpl(handlers
) : NullDispatcher);
}
private void EnsureClassRead(int id)
{
IReflectClass clazz = LookupByID(id);
ByteArrayBuffer classreader = _stream.ReadStatefulBufferById(_trans, id);
ClassMarshaller classMarshaller = MarshallerFamily()._class;
RawClassSpec classInfo = classMarshaller.ReadSpec(_trans, classreader);
string className = classInfo.Name();
// Having the class in the _classByName Map for now indicates
// that the class is fully read. This is breakable if we start
// returning GenericClass'es in other methods like forName
// even if a native class has not been found
if (LookupByName(className) != null)
{
return;
}
// step 2 add the class to _classByName and _classes to denote reading is completed
Register(className, clazz);
int numFields = classInfo.NumFields();
IReflectField[] fields = _builder.FieldArray(numFields);
IFieldMarshaller fieldMarshaller = MarshallerFamily()._field;
for (int i = 0; i < numFields; i++)
{
RawFieldSpec fieldInfo = fieldMarshaller.ReadSpec(_stream, classreader);
string fieldName = fieldInfo.Name();
IReflectClass fieldClass = ReflectClassForFieldSpec(fieldInfo, _stream.Reflector(
));
if (null == fieldClass && (fieldInfo.IsField() && !fieldInfo.IsVirtual()))
{
throw new InvalidOperationException("Could not read field type for '" + className
+ "." + fieldName + "'");
}
fields[i] = _builder.CreateField(clazz, fieldName, fieldClass, fieldInfo.IsVirtual
(), fieldInfo.IsPrimitive(), fieldInfo.IsArray(), fieldInfo.IsNArray());
}
_builder.InitFields(clazz, fields);
_listeners.NotifyListeners(clazz);
}
public Collection4 ForInterface(IReflectClass claxx)
{
Collection4 col = new Collection4();
ClassMetadataIterator i = Iterator();
while (i.MoveNext())
{
ClassMetadata clazz = i.CurrentClass();
IReflectClass candidate = clazz.ClassReflector();
if (!candidate.IsInterface())
{
if (claxx.IsAssignableFrom(candidate))
{
col.Add(clazz);
IEnumerator j = new Collection4(col).GetEnumerator();
while (j.MoveNext())
{
ClassMetadata existing = (ClassMetadata)j.Current;
if (existing != clazz)
{
ClassMetadata higher = clazz.GetHigherHierarchy(existing);
if (higher != null)
{
if (higher == clazz)
{
col.Remove(existing);
}
else
{
col.Remove(clazz);
}
}
}
}
}
}
}
return(col);
}
private static ReflectConstructorSpec FindConstructor(IReflectClass claxx, Tree sortedConstructors
)
{
if (sortedConstructors == null)
{
return(ReflectConstructorSpec.InvalidConstructor);
}
IEnumerator iter = new TreeNodeIterator(sortedConstructors);
while (iter.MoveNext())
{
var current = iter.Current;
var constructor = (IReflectConstructor)((TreeIntObject)current)._object;
var args = NullArgumentsFor(constructor);
var res = constructor.NewInstance(args);
if (res != null)
{
return(new ReflectConstructorSpec(constructor, args));
}
}
return(ReflectConstructorSpec.InvalidConstructor);
}
public int GetFieldCount()
{
try
{
IReflectClass rClass = DataLayerCommon.ReflectClassForName(m_className);
if (rClass != null)
{
IType type = Db4oClient.TypeResolver.Resolve(rClass);
if (!type.IsEditable)
{
IReflectField[] rFields = DataLayerCommon.GetDeclaredFieldsInHeirarchy(rClass);
return(rFields.Length);
}
}
return(0);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(0);
}
}
public Hashtable ResultsWithAttributes(object obj, Hashtable attributeList)
{
try
{
Hashtable hash = new Hashtable();
if (attributeList.Count != 0)
{
foreach (string attribute in attributeList.Keys)
{
hash = UpdateResults(obj, attribute);
}
if (hash != null)
{
hash.Add(BusinessConstants.DB4OBJECTS_REF, obj);
}
}
else
{
IReflectClass rClass = DataLayerCommon.ReflectClassForName(m_classname);
if (rClass != null)
{
IReflectField[] reff = DataLayerCommon.GetDeclaredFieldsInHeirarchy(rClass);
if (reff != null)
{
hash = checkforprimitives(reff, obj);
}
}
}
return(hash);
}
catch (Exception oEx)
{
LoggingHelper.HandleException(oEx);
return(null);
}
}
public static void SaveDictionary(object targetObject, string attribName, object newValue, object key)
{
try
{
IReflectClass rclass = DataLayerCommon.ReflectClassFor(targetObject);
if (rclass != null)
{
IReflectField rfield = DataLayerCommon.GetDeclaredFieldInHeirarchy(rclass, attribName);
if (rfield != null)
{
if (!(rfield is GenericVirtualField || rfield.IsStatic()))
{
object obj = rfield.Get(targetObject);
ICollection col = (ICollection)obj;
if (col is Hashtable)
{
Hashtable hash = (Hashtable)col;
hash.Remove(key);
hash.Add(key, newValue);
rfield.Set(targetObject, hash);
}
else if (col is IDictionary)
{
IDictionary dict = (IDictionary)col;
dict.Remove(key);
dict.Add(key, newValue);
rfield.Set(targetObject, dict);
}
}
}
}
}
catch (Exception oEx)
{
Db4oClient.Client.Rollback();
LoggingHelper.HandleException(oEx);
}
}
private void AssertStoredField(Type objectClass, string fieldName, object expectedFieldValue
, Type expectedFieldType, bool hasIndex, bool isArray)
{
IStoredClass storedClass = StoredClass(objectClass);
IStoredField[] storedFields = storedClass.GetStoredFields();
Assert.AreEqual(1, storedFields.Length);
IStoredField storedField = storedFields[0];
Assert.AreEqual(fieldName, storedField.GetName());
IStoredField storedFieldByName = storedClass.StoredField(fieldName, expectedFieldType
);
Assert.AreEqual(storedField, storedFieldByName);
object item = RetrieveOnlyInstance(objectClass);
Assert.AreEqual(expectedFieldValue, storedField.Get(item));
IReflectClass fieldType = storedField.GetStoredType();
Assert.AreEqual(Reflector().ForClass(expectedFieldType), fieldType);
Assert.AreEqual(isArray, storedField.IsArray());
if (IsMultiSession())
{
return;
}
Assert.AreEqual(hasIndex, storedField.HasIndex());
// FIXME: test rename
if (!hasIndex)
{
Assert.Expect(typeof(Exception), new _ICodeBlock_113(storedField));
}
else
{
IntByRef count = new IntByRef();
storedField.TraverseValues(new _IVisitor4_123(count, expectedFieldValue));
Assert.AreEqual(1, count.value);
}
}
private Collection4 IntroduceClassConstrain(IReflectClass claxx)
{
Collection4 newConstraints = new Collection4();
IEnumerator existingConstraints = IterateConstraints();
while (existingConstraints.MoveNext())
{
QCon existingConstraint = (QConObject)existingConstraints.Current;
BooleanByRef removeExisting = new BooleanByRef(false);
QCon newConstraint = existingConstraint.ShareParentForClass(claxx, removeExisting
);
if (newConstraint != null)
{
newConstraints.Add(newConstraint);
AddConstraint(newConstraint);
if (removeExisting.value)
{
RemoveConstraint(existingConstraint);
}
}
}
return(newConstraints);
}
/// <summary>returns a prototype object for a specific class.</summary>
/// <remarks>returns a prototype object for a specific class.</remarks>
public virtual object PrototypeForClass(Type clazz)
{
if (clazz == null)
{
throw new PrototypesException("Class can not be null");
}
IReflectClass claxx = _reflector.ForClass(clazz);
if (claxx == null)
{
throw new PrototypesException("Not found in the reflector: " + clazz);
}
string className = claxx.GetName();
Prototypes.Prototype prototype = (Prototypes.Prototype)_prototypes.Get(className);
if (prototype != null)
{
return(prototype.Object());
}
prototype = new Prototypes.Prototype(this, claxx);
_prototypes.Put(className, prototype);
return(prototype.Object());
}
public void SetIndex(ArrayList fieldnames, string className, ArrayList Indexed, string path, bool customConfig)
{
IObjectContainer con = null;
try
{
IEmbeddedConfiguration embeddedConfig = !customConfig?Db4oEmbedded.NewConfiguration() : Config();
for (int i = 0; i < fieldnames.Count; i++)
{
embeddedConfig.Common.ObjectClass(className).ObjectField(fieldnames[i].ToString()).Indexed(
Convert.ToBoolean(Indexed[i]));
}
con = Db4oEmbedded.OpenFile(embeddedConfig, path);
IReflectClass clazz = con.Ext().Reflector().ForName(className);
con.QueryByExample(clazz);
}
finally
{
con.Close();
}
}
private static IReflectMethod[] EventHandlerTableFor(ObjectContainerBase container
, IReflectClass classReflector)
{
IReflectClass[] parameterClasses =
{
container._handlers.IclassObjectcontainer
};
var methods = new IReflectMethod[Count];
for (var i = Count - 1; i >= 0; i--)
{
var method = classReflector.GetMethod(events[i], parameterClasses);
if (null == method)
{
method = classReflector.GetMethod(ToPascalCase(events[i]), parameterClasses);
}
if (method != null)
{
methods[i] = method;
}
}
return(methods);
}
private bool CanHold(IReflectClass type)
{
if (type == null)
{
throw new ArgumentNullException();
}
ITypeHandler4 typeHandler = GetHandler();
if (typeHandler is IQueryableTypeHandler)
{
if (((IQueryableTypeHandler)typeHandler).DescendsIntoMembers())
{
return(true);
}
}
IReflectClass classReflector = FieldType().ClassReflector();
if (classReflector.IsCollection())
{
return(true);
}
return(classReflector.IsAssignableFrom(type));
}
public static void SaveValues(long id, string attribName, object newValue, int offset)
{
try
{
object targetObject = Db4oClient.Client.Ext().GetByID(id);
Db4oClient.Client.Ext().Activate(targetObject, 2);
IReflectClass rclass = DataLayerCommon.ReflectClassFor(targetObject);
IReflectField rfield = DataLayerCommon.GetDeclaredFieldInHeirarchy(rclass, attribName);
IType type = new FieldDetails(rclass.GetName(), attribName).GetFieldType();
object obj = rfield.Get(targetObject);
if (obj is IDictionary)
{
SaveDictionary(targetObject, attribName, newValue, KeyAtIndex((IDictionary)obj, offset / 2));
}
else
{
if (rfield != null && !(rfield is GenericVirtualField || rfield.IsStatic()))
{
if (type.IsArray || type.IsCollection)
{
IList list = obj as IList;
if (null != list)
{
list[offset] = newValue;
rfield.Set(targetObject, list);
}
}
}
}
}
catch (Exception oEx)
{
Db4oClient.Client.Rollback();
LoggingHelper.HandleException(oEx);
}
}
private bool HasValueTypeBehavior(object obj)
{
bool isSimple = Platform4.IsSimple(obj.GetType());
if (isSimple)
{
return(true);
}
IReflectClass reflectClass = _container.Reflector().ForObject(obj);
if (Platform4.IsStruct(reflectClass))
{
return(true);
}
bool isEnum = Platform4.IsEnum(_container.Reflector(), reflectClass);
if (isEnum)
{
return(true);
}
ITypeHandler4 typeHandler = _container.TypeHandlerForClass(reflectClass);
return(Handlers4.IsValueType(typeHandler));
}
internal bool CreateClassMetadata(ClassMetadata clazz, IReflectClass reflectClazz
)
{
bool result = false;
_classMetadataCreationDepth++;
try
{
IReflectClass parentReflectClazz = reflectClazz.GetSuperclass();
ClassMetadata parentClazz = null;
if (parentReflectClazz != null && !parentReflectClazz.Equals(Container()._handlers
.IclassObject))
{
parentClazz = ProduceClassMetadata(parentReflectClazz);
}
result = Container().CreateClassMetadata(clazz, reflectClazz, parentClazz);
}
finally
{
_classMetadataCreationDepth--;
}
InitClassMetadataOnUp();
return(result);
}
