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); }