private IConstraint AddInterfaceConstraint(IReflectClass claxx) { Collection4 classes = Stream().ClassCollection().ForInterface(claxx); if (classes.Size() == 0) { QConClass qcc = new QConClass(_trans, null, null, claxx); AddConstraint(qcc); return(qcc); } IEnumerator i = classes.GetEnumerator(); IConstraint constr = null; while (i.MoveNext()) { ClassMetadata classMetadata = (ClassMetadata)i.Current; IReflectClass classMetadataClaxx = classMetadata.ClassReflector(); if (classMetadataClaxx != null) { if (!classMetadataClaxx.IsInterface()) { if (constr == null) { constr = Constrain(classMetadataClaxx); } else { constr = constr.Or(Constrain(classMetadata.ClassReflector())); } } } } return(constr); }
public override bool CanSkip(ObjectReference @ref) { ClassMetadata clazz = @ref.ClassMetadata(); return(clazz.Reflector().ForClass(typeof(IActivatable)).IsAssignableFrom(clazz.ClassReflector ()) && !_query.IsModified(@ref.GetObject())); }
private bool IsTAAware(ClassMetadata classMetadata) { GenericReflector reflector = classMetadata.Reflector(); return(reflector.ForClass(typeof(IActivatable)).IsAssignableFrom(classMetadata.ClassReflector ())); }
public ClassMetadata ReadClassMetadata(ClassMetadata classMetadata, IReflectClass clazz) { if (classMetadata == null) { throw new ArgumentNullException(); } if (!classMetadata.StateUnread()) { return(classMetadata); } _classMetadataCreationDepth++; try { classMetadata.ResolveNameConfigAndReflector(this, clazz); IReflectClass claxx = classMetadata.ClassReflector(); if (claxx != null) { _classMetadataByClass.Put(claxx, classMetadata); classMetadata.ReadThis(); classMetadata.CheckChanges(); _initClassMetadataOnUp.Add(classMetadata); } } finally { _classMetadataCreationDepth--; } InitClassMetadataOnUp(); return(classMetadata); }
private void EnsureAllClassesRead() { bool allClassesRead = false; while (!allClassesRead) { Collection4 unreadClasses = new Collection4(); int numClasses = _classes.Size(); IEnumerator classIter = _classes.GetEnumerator(); while (classIter.MoveNext()) { ClassMetadata clazz = (ClassMetadata)classIter.Current; if (clazz.StateUnread()) { unreadClasses.Add(clazz); } } IEnumerator unreadIter = unreadClasses.GetEnumerator(); while (unreadIter.MoveNext()) { ClassMetadata clazz = (ClassMetadata)unreadIter.Current; clazz = ReadClassMetadata(clazz, null); if (clazz.ClassReflector() == null) { clazz.ForceRead(); } } allClassesRead = (_classes.Size() == numClasses); } ApplyReadAs(); }
public virtual IReflectClass ClassReflector(IReflector reflector, ClassMetadata classMetadata , bool isPrimitive) { return(isPrimitive ? Handlers4.PrimitiveClassReflector(classMetadata, reflector) : classMetadata.ClassReflector()); }
public virtual IReflectClass ClassReflector(IReflector reflector, ClassMetadata classMetadata , bool isPrimitive) { return isPrimitive ? Handlers4.PrimitiveClassReflector(classMetadata, reflector) : classMetadata.ClassReflector(); }
protected override bool Accept(ClassMetadata classmetadata) { #if CF || SILVERLIGHT return(false); #else return(NetReflector.ToNative(classmetadata.ClassReflector()) == typeof(DateTimeOffset)); #endif }
protected override bool Accept(ClassMetadata classmetadata) { #if CF || SILVERLIGHT return false; #else return NetReflector.ToNative(classmetadata.ClassReflector()) == typeof (DateTimeOffset); #endif }
private static object ToEnum(IContext context, int classId, long enumValue) { ClassMetadata clazz = Container(context).ClassMetadataForID(classId); Type enumType = NetReflector.ToNative(clazz.ClassReflector()); return(Enum.ToObject(enumType, enumValue)); }
public void Visit(object obj) { ClassMetadata classMetadata = (ClassMetadata)obj; QConClass qcc = new QConClass(this._enclosing._trans, classMetadata.ClassReflector ()); this._enclosing.AddConstraint(qcc); this._enclosing.ToConstraint(this._enclosing.i_constraints).Or(qcc); }
protected override bool Accept(ClassMetadata classmetadata) { var isGuid = NetReflector.ToNative(classmetadata.ClassReflector()) == typeof (Guid); if (!isGuid) { classmetadata.TraverseDeclaredFields(reindexer); } return isGuid; }
protected override bool Accept(ClassMetadata classmetadata) { var isGuid = NetReflector.ToNative(classmetadata.ClassReflector()) == typeof(Guid); if (!isGuid) { classmetadata.TraverseDeclaredFields(reindexer); } return(isGuid); }
public virtual IList Analyze() { IList ancestors = new ArrayList(); ClassMetadata storedAncestor = _storedClass.GetAncestor(); IReflectClass runtimeAncestor = _runtimeClass.GetSuperclass(); while (storedAncestor != null) { if (runtimeAncestor == storedAncestor.ClassReflector()) { ancestors.Add(new HierarchyAnalyzer.Same(storedAncestor)); } else { do { ancestors.Add(new HierarchyAnalyzer.Removed(storedAncestor)); storedAncestor = storedAncestor.GetAncestor(); if (null == storedAncestor) { if (IsObject(runtimeAncestor)) { return(ancestors); } ThrowUnsupportedAdd(runtimeAncestor); } if (runtimeAncestor == storedAncestor.ClassReflector()) { ancestors.Add(new HierarchyAnalyzer.Same(storedAncestor)); break; } }while (storedAncestor != null); } storedAncestor = storedAncestor.GetAncestor(); runtimeAncestor = runtimeAncestor.GetSuperclass(); } if (runtimeAncestor != null && (!IsObject(runtimeAncestor))) { ThrowUnsupportedAdd(runtimeAncestor); } return(ancestors); }
public virtual void TestClassMetadataForName() { string className = CrossPlatformServices.FullyQualifiedName(typeof(InternalObjectContainerAPITestCase.Item )); ClassMetadata clazz = ((IInternalObjectContainer)Db()).ClassMetadataForName(className ); Assert.AreEqual(className, clazz.GetName()); Assert.AreEqual(Reflector().ForClass(typeof(InternalObjectContainerAPITestCase.Item )), clazz.ClassReflector()); }
public virtual bool SkipClass(ClassMetadata classMetadata) { if (classMetadata.GetName() == null) { return true; } var claxx = classMetadata.ClassReflector(); if (Stream()._handlers.IclassInternal.IsAssignableFrom(claxx)) { return true; } return false; }
public void AddClassMetadata(ClassMetadata clazz) { Container().SetDirtyInSystemTransaction(this); _classes.Add(clazz); if (clazz.StateUnread()) { _classMetadataByBytes.Put(clazz.i_nameBytes, clazz); } else { _classMetadataByClass.Put(clazz.ClassReflector(), clazz); } RegisterClassMetadataById(clazz); }
public virtual bool SkipClass(ClassMetadata classMetadata) { if (classMetadata.GetName() == null) { return(true); } IReflectClass claxx = classMetadata.ClassReflector(); if (Stream()._handlers.IclassInternal.IsAssignableFrom(claxx)) { return(true); } return(false); }
public void RefreshClassCache(ClassMetadata clazz, IReflectClass oldReflector) { if (clazz.StateUnread()) { _classMetadataByBytes.Put(clazz.ReadName(_systemTransaction), clazz); } else { if (oldReflector != null) { _classMetadataByClass.Remove(oldReflector); } _classMetadataByClass.Put(clazz.ClassReflector(), clazz); } }
private void DeleteMembers(StatefulBuffer objectBytes) { ObjectHeader oh = new ObjectHeader(_clazz, objectBytes); DeleteInfo info = (DeleteInfo)TreeInt.Find(_transaction._delete, _id); if (info != null) { if (info._cascade > _cascade) { _cascade = info._cascade; } } objectBytes.SetCascadeDeletes(_cascade); DeleteContextImpl context = new DeleteContextImpl(objectBytes, oh, _clazz.ClassReflector (), null); _clazz.DeleteMembers(context, _typeInfo, true); }
public override void LoadFromClassIndexes(ClassMetadataIterator iter) { // duplicates because of inheritance hierarchies ByRef duplicates = new ByRef(); while (iter.MoveNext()) { ClassMetadata classMetadata = iter.CurrentClass(); if (classMetadata.GetName() != null) { IReflectClass claxx = classMetadata.ClassReflector(); if (claxx == null || !(Stream()._handlers.IclassInternal.IsAssignableFrom(claxx))) { IClassIndexStrategy index = classMetadata.Index(); index.TraverseAll(_transaction, new _IVisitor4_130(this, duplicates)); } } } }
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 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 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); }
internal virtual ClassMetadata ReadClassMetadata() { if (_classMetadata == null) { Read(); if (_bytes != null) { Seek(0); ObjectContainerBase stream = Container(); var objectHeader = new ObjectHeader(stream, _bytes); _classMetadata = objectHeader.ClassMetadata(); if (_classMetadata != null) { if (stream._handlers.IclassCompare.IsAssignableFrom(_classMetadata.ClassReflector ())) { ReadThis(false); } } } } return(_classMetadata); }
internal virtual void Analyze(Transaction trans) { _ref = trans.ReferenceForObject(_obj); if (_ref != null) { _classMetadata = _ref.ClassMetadata(); return; } var claxx = _container.Reflector().ForObject(_obj); if (claxx == null) { NotStorable(_obj, claxx); return; } if (!DetectClassMetadata(trans, claxx)) { return; } if (IsValueType(_classMetadata)) { NotStorable(_obj, _classMetadata.ClassReflector()); } }
internal virtual ClassMetadata ReadClassMetadata() { if (_classMetadata == null) { Read(); if (_bytes != null) { Seek(0); ObjectContainerBase stream = Container(); var objectHeader = new ObjectHeader(stream, _bytes); _classMetadata = objectHeader.ClassMetadata(); if (_classMetadata != null) { if (stream._handlers.IclassCompare.IsAssignableFrom(_classMetadata.ClassReflector ())) { ReadThis(false); } } } } return _classMetadata; }
private bool IsTAAware(ClassMetadata classMetadata) { var reflector = classMetadata.Reflector(); return reflector.ForClass(typeof (IActivatable)).IsAssignableFrom(classMetadata.ClassReflector ()); }
protected override bool Accept(ClassMetadata classmetadata) { return(NetReflector.ToNative(classmetadata.ClassReflector()) == typeof(Guid)); }
protected override bool Accept(ClassMetadata classmetadata) { var type = NetReflector.ToNative(classmetadata.ClassReflector()); return type != null ? type.IsEnum : false; }
protected override bool Accept(ClassMetadata classmetadata) { var type = NetReflector.ToNative(classmetadata.ClassReflector()); return(type != null ? type.IsEnum : false); }
protected override bool Accept(ClassMetadata classmetadata) { return NetReflector.ToNative(classmetadata.ClassReflector()) == typeof(Guid); }
private void AddFieldConstraint(ClassMetadata containingClass, FieldMetadata field ) { QConClass qcc = new QConClass(this._enclosing._trans, null, field.QField(this._enclosing ._trans), containingClass.ClassReflector()); this._enclosing.AddConstraint(qcc); this._enclosing.ToConstraint(this._enclosing.i_constraints).Or(qcc); }
private void AddFieldConstraint(ClassMetadata containingClass, FieldMetadata field ) { var qcc = new QConClass(_enclosing._trans, null, field.QField(_enclosing ._trans), containingClass.ClassReflector()); _enclosing.AddConstraint(qcc); _enclosing.ToConstraint(_enclosing.i_constraints).Or(qcc); }