private ITypeHandler4 CorrectHandlerVersion(IDefragmentContext context, ITypeHandler4 handler, ArrayInfo info) { Db4objects.Db4o.Internal.ClassMetadata classMetadata = ClassMetadata(context, info ); return(HandlerRegistry.CorrectHandlerVersion(context, handler, classMetadata)); }
public override int InstanceCount(ClassMetadata clazz, Transaction trans) { lock (Lock()) { return clazz.IndexEntryCount(trans); } }
public virtual IActivationDepth ActivationDepthFor(ClassMetadata classMetadata, ActivationMode mode) { Record(new MethodCall("activationDepthFor", new object[] { classMetadata, mode }) ); return _delegate.ActivationDepthFor(classMetadata, mode); }
internal virtual void Analyze(Transaction trans) { _ref = trans.ReferenceForObject(_obj); if (_ref != null) { _classMetadata = _ref.ClassMetadata(); return; } IReflectClass claxx = _container.Reflector().ForObject(_obj); if (claxx == null) { NotStorable(_obj, claxx); return; } if (!DetectClassMetadata(trans, claxx)) { return; } if (IsValueType(_classMetadata)) { NotStorable(_obj, _classMetadata.ClassReflector(), " Value types can only be stored embedded in parent objects." ); } }
/// <exception cref="Db4objects.Db4o.CorruptionException"></exception> /// <exception cref="System.IO.IOException"></exception> public void ProcessObjectSlot(DefragmentServicesImpl services, ClassMetadata classMetadata , int id) { ByteArrayBuffer sourceBuffer = services.SourceBufferByID(id); DefragmentContextImpl.ProcessCopy(services, id, new _ISlotCopyHandler_43(this, services ), sourceBuffer); }
public override Db4objects.Db4o.Internal.ClassMetadata ClassMetadata() { if (_classMetadata != null) { return(_classMetadata); } Read(); if (_bytes == null) { return(null); } Seek(0); ObjectContainerBase stream = Container(); ObjectHeader objectHeader = new ObjectHeader(stream, _bytes); _classMetadata = objectHeader.ClassMetadata(); if (_classMetadata != null) { if (stream._handlers.IclassCompare.IsAssignableFrom(_classMetadata.ClassReflector ())) { ReadThis(false); } } return(_classMetadata); }
/// <exception cref="Db4objects.Db4o.Ext.Db4oIOException"></exception> private DatabaseIdentityIDAndUUID ReadDatabaseIdentityIDAndUUID (ObjectContainerBase container, ClassMetadata classMetadata, Slot oldSlot, bool checkClass) { if (DTrace.enabled) { DTrace.RereadOldUuid.LogLength(oldSlot.Address(), oldSlot.Length()); } var reader = container.DecryptedBufferByAddress(oldSlot.Address(), oldSlot .Length()); if (checkClass) { var realClass = ClassMetadata.ReadClass(container, reader); if (realClass != classMetadata) { return null; } } if (classMetadata.SeekToField(container.Transaction, reader, this) == HandlerVersion .Invalid) { return null; } return new DatabaseIdentityIDAndUUID(reader.ReadInt(), reader.ReadLong ()); }
public ModifiedAspectTraversalStrategy(ClassMetadata classMetadata, IList ancestors ) { _classDiffs = new ArrayList(); _classDiffs.Add(new HierarchyAnalyzer.Same(classMetadata)); Sharpen.Collections.AddAll(_classDiffs, ancestors); }
public static Sharpen.Util.ISet BuildHierarchy(ClassMetadataRepository repository ) { ClassMetadataIterator classIter = repository.Iterator(); IDictionary nodes = new Hashtable(); Sharpen.Util.ISet roots = new HashSet(); while (classIter.MoveNext()) { Db4objects.Db4o.Internal.ClassMetadata clazz = classIter.CurrentClass(); Db4objects.Db4o.Filestats.ClassNode node = new Db4objects.Db4o.Filestats.ClassNode (clazz); nodes[clazz.GetName()] = node; if (clazz.GetAncestor() == null) { roots.Add(node); } } for (IEnumerator nodeIter = nodes.Values.GetEnumerator(); nodeIter.MoveNext();) { Db4objects.Db4o.Filestats.ClassNode node = ((Db4objects.Db4o.Filestats.ClassNode) nodeIter.Current); Db4objects.Db4o.Internal.ClassMetadata ancestor = node.ClassMetadata().GetAncestor (); if (ancestor != null) { ((Db4objects.Db4o.Filestats.ClassNode)nodes[ancestor.GetName()]).AddSubClass(node ); } } return(roots); }
private void CascadeActivation(IActivationContext context) { IActivationDepth depth = context.Depth(); if (!depth.RequiresActivation()) { return; } if (depth.Mode().IsDeactivate()) { Container().StillToDeactivate(_transaction, context.TargetObject(), depth, false); } else { // FIXME: [TA] do we really need to check for isValueType here? Db4objects.Db4o.Internal.ClassMetadata classMetadata = context.ClassMetadata(); if (classMetadata.IsStruct()) { classMetadata.CascadeActivation(context); } else { Container().StillToActivate(context); } } }
internal virtual void Process(ClassMetadata newClassMetadata) { if (_pending.Contains(newClassMetadata)) { return; } ClassMetadata ancestor = newClassMetadata.GetAncestor(); if (ancestor != null) { Process(ancestor); } _pending.Add(newClassMetadata); _members.Add(newClassMetadata); if (_running) { return; } _running = true; try { CheckInits(); _pending = new Collection4(); } finally { _running = false; } }
internal QCandidates(LocalTransaction a_trans, ClassMetadata a_classMetadata, QField a_field, bool isTopLevel) { // Transaction necessary as reference to stream // collection of all constraints // possible class information // possible field information // current executing constraint, only set where needed _result = new QueryResultCandidates(this); _isTopLevel = isTopLevel; i_trans = a_trans; _classMetadata = a_classMetadata; _field = a_field; if (a_field == null || a_field._fieldMetadata == null || !(a_field._fieldMetadata .GetHandler() is StandardReferenceTypeHandler)) { return; } ClassMetadata yc = ((StandardReferenceTypeHandler)a_field._fieldMetadata.GetHandler ()).ClassMetadata(); if (_classMetadata == null) { _classMetadata = yc; } else { yc = _classMetadata.GetHigherOrCommonHierarchy(yc); if (yc != null) { _classMetadata = yc; } } }
internal QCandidates(LocalTransaction a_trans, ClassMetadata a_classMetadata, QField a_field) { // Transaction necessary as reference to stream // root of the QCandidate tree // collection of all constraints // possible class information // possible field information // current executing constraint, only set where needed i_trans = a_trans; i_classMetadata = a_classMetadata; _field = a_field; if (a_field == null || a_field._fieldMetadata == null || !(a_field._fieldMetadata .GetHandler() is StandardReferenceTypeHandler)) { return; } ClassMetadata yc = ((StandardReferenceTypeHandler)a_field._fieldMetadata.GetHandler ()).ClassMetadata(); if (i_classMetadata == null) { i_classMetadata = yc; } else { yc = i_classMetadata.GetHigherOrCommonHierarchy(yc); if (yc != null) { i_classMetadata = yc; } } }
public override void Defrag(ClassMetadata classMetadata, ClassAspect aspect, LatinStringIO sio, DefragmentContextImpl context) { base.Defrag(classMetadata, aspect, sio, context); if (!(aspect is FieldMetadata)) { return; } FieldMetadata field = (FieldMetadata)aspect; if (field.IsVirtual()) { return; } if (field.HasIndex()) { BTree index = field.GetIndex(context.SystemTrans()); int targetIndexID = context.CopyID(); if (targetIndexID != 0) { index.DefragBTree(context.Services()); } } else { context.WriteInt(0); } }
public override void Write(Transaction trans, ClassMetadata clazz, ClassAspect aspect , ByteArrayBuffer writer) { writer.WriteShortString(trans, aspect.GetName()); if (!(aspect is FieldMetadata)) { return; } FieldMetadata field = (FieldMetadata)aspect; field.Alive(); if (field.IsVirtual()) { return; } ITypeHandler4 handler = field.GetHandler(); if (handler is StandardReferenceTypeHandler) { // TODO: ensure there is a test case, to make this happen if (((StandardReferenceTypeHandler)handler).ClassMetadata().GetID() == 0) { trans.Container().NeedsUpdate(clazz); } } writer.WriteInt(field.FieldTypeID()); BitMap4 bitmap = new BitMap4(3); bitmap.Set(0, field.IsPrimitive()); bitmap.Set(1, Handlers4.HandlesArray(handler)); bitmap.Set(2, Handlers4.HandlesMultidimensionalArray(handler)); // keep the order writer.WriteByte(bitmap.GetByte(0)); }
public _IProcedure4_39(ClassMarshaller _enclosing, Transaction trans, ClassMetadata clazz, ByteArrayBuffer writer) { this._enclosing = _enclosing; this.trans = trans; this.clazz = clazz; this.writer = writer; }
public MsgD GetWriter(Transaction trans, Pointer4 pointer, ClassMetadata classMetadata , int param, ByteArrayBuffer buffer) { return GetWriter(trans, pointer, buffer, new[] { classMetadata.GetID(), param }); }
public WriteUpdateProcessor(LocalTransaction transaction, int id, ClassMetadata clazz , ArrayType typeInfo) { _transaction = transaction; _id = id; _clazz = clazz; _typeInfo = typeInfo; }
protected override int InternalDeclaredAspectCount(Db4objects.Db4o.Internal.ClassMetadata classMetadata) { int aspectCount = classMetadata._aspects.Length; context.WriteDeclaredAspectCount(aspectCount); return(aspectCount); }
public Diff(Db4objects.Db4o.Internal.ClassMetadata classMetadata) { if (classMetadata == null) { throw new ArgumentNullException(); } _classMetadata = classMetadata; }
private void RegisterClassMetadataById(ClassMetadata clazz) { if (clazz.GetID() == 0) { clazz.Write(_systemTransaction); } _classMetadataByID.Put(clazz.GetID(), clazz); }
public virtual IUpdateDepth Adjust(ClassMetadata clazz) { if (clazz.CascadesOnDeleteOrUpdate()) { return AdjustDepthToBorders().Descend(); } return Descend(); }
public Diff(Db4objects.Db4o.Internal.ClassMetadata classMetadata) { if (classMetadata == null) { throw new ArgumentNullException(); } _classMetadata = classMetadata; }
private ITypeHandler4 TypeHandlerFor(IInternalCandidate candidate) { Db4objects.Db4o.Internal.ClassMetadata classMetadata = candidate.ClassMetadata(); if (classMetadata != null) { return(classMetadata.TypeHandler()); } return(null); }
public override IActivationDepth Descend(ClassMetadata metadata) { if (_depth < 1) { return this; } return new Db4objects.Db4o.Internal.Activation.FixedActivationDepth(_depth - 1, _mode ); }
public override Db4objects.Db4o.Internal.ClassMetadata ClassMetadata() { Db4objects.Db4o.Internal.ClassMetadata classMetadata = _reference.ClassMetadata(); if (classMetadata == null) { throw new InvalidOperationException(); } return(classMetadata); }
public TypeHandlerAspect(ClassMetadata classMetadata, ITypeHandler4 typeHandler) { if (Handlers4.IsValueType(typeHandler)) { throw new InvalidOperationException(); } _ownerMetadata = classMetadata; _typeHandler = typeHandler; }
public StoredClassImpl(Transaction transaction, ClassMetadata classMetadata) { if (classMetadata == null) { throw new ArgumentException(); } _transaction = transaction; _classMetadata = classMetadata; }
public MsgD GetWriter(Transaction trans, Pointer4 pointer, ClassMetadata classMetadata , ByteArrayBuffer buffer) { if (classMetadata == null) { return GetWriter(trans, pointer, buffer, new int[] { 0 }); } return GetWriter(trans, pointer, buffer, new int[] { classMetadata.GetID() }); }
private int ConfiguredActivationDepth(ClassMetadata metadata) { Config4Class config = metadata.ConfigOrAncestorConfig(); if (config != null && _mode.IsActivate()) { return config.AdjustActivationDepth(_depth); } return _depth; }
public override IActivationDepth Descend(ClassMetadata metadata) { if (null == metadata) { return new Db4objects.Db4o.Internal.Activation.LegacyActivationDepth(_depth - 1, _mode); } return new Db4objects.Db4o.Internal.Activation.LegacyActivationDepth(DescendDepth (metadata), _mode); }
private int DescendDepth(ClassMetadata metadata) { int depth = ConfiguredActivationDepth(metadata) - 1; if (metadata.IsStruct()) { // We also have to instantiate structs completely every time. return Math.Max(1, depth); } return depth; }
protected override void ReadIndex(ObjectContainerBase stream, ClassMetadata clazz , ByteArrayBuffer reader) { int indexID = reader.ReadInt(); if (indexID == 0) { return; } clazz.Index().Read(stream, indexID); }
/// <exception cref="Db4objects.Db4o.CorruptionException"></exception> /// <exception cref="System.IO.IOException"></exception> public void ProcessClass(DefragmentServicesImpl services, ClassMetadata classMetadata , int id, int classIndexID) { if (services.MappedID(id, -1) == -1) { Sharpen.Runtime.Err.WriteLine("MAPPING NOT FOUND: " + id); } DefragmentContextImpl.ProcessCopy(services, id, new _ISlotCopyHandler_34(classMetadata , classIndexID)); }
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 virtual bool RebuildIndexForClass(LocalObjectContainer container, ClassMetadata classMetadata) { long[] ids = classMetadata.GetIDs(); for (int i = 0; i < ids.Length; i++) { RebuildIndexForObject(container, (int)ids[i]); } return ids.Length > 0; }
private void AssertClassHandler() { int id1 = StoreItem(); int id2 = StoreItem(); int smallerID = Math.Min(id1, id2); int biggerID = Math.Max(id1, id2); ClassMetadata classMetadata = new ClassMetadata(Container(), Reflector().ForClass (typeof(Comparable4TestCase.Item))); AssertHandlerComparison((IComparable4)classMetadata.TypeHandler(), smallerID, biggerID ); }
public virtual void Write(Transaction trans, ClassMetadata clazz, ByteArrayBuffer writer) { writer.WriteShortString(trans, clazz.NameToWrite()); int intFormerlyKnownAsMetaClassID = 0; writer.WriteInt(intFormerlyKnownAsMetaClassID); writer.WriteIDOf(trans, clazz._ancestor); WriteIndex(trans, clazz, writer); writer.WriteInt(clazz.DeclaredAspectCount()); clazz.TraverseDeclaredAspects(new _IProcedure4_39(this, trans, clazz, writer)); }
private ITypeHandler4 TypeHandlerFor(Db4objects.Db4o.Internal.Query.Processor.QCandidate candidate) { Db4objects.Db4o.Internal.ClassMetadata classMetadata = candidate.ReadClassMetadata (); if (classMetadata != null) { return(classMetadata.TypeHandler()); } return(null); }
public override IPreparedComparison PrepareComparison(ObjectContainerBase container , object constraint) { Db4objects.Db4o.Internal.ClassMetadata classMetadata = ClassMetadata(); if (classMetadata == null) { return(null); } return(classMetadata.PrepareComparison(container.Transaction.Context(), constraint )); }
public override IReflectClass ClassReflector(IReflector reflector, ClassMetadata classMetadata, bool isPrimitive) { IReflectClass primitiveClaxx = Handlers4.PrimitiveClassReflector(classMetadata, reflector ); if (primitiveClaxx != null) { return primitiveClaxx; } return base.ClassReflector(reflector, classMetadata, isPrimitive); }
internal void Store(Db4objects.Db4o.Internal.Transaction trans, Db4objects.Db4o.Internal.ClassMetadata classMetadata, object obj) { _object = obj; _class = classMetadata; int id = trans.Container().IdForNewUserObject(trans); SetID(id); // will be ended in continueset() BeginProcessing(); BitTrue(Const4.Continue); }
public virtual void ClassMetadata(Db4objects.Db4o.Internal.ClassMetadata classMetadata ) { if (_class == classMetadata) { return; } if (_class != null) { throw new InvalidOperationException("Object types aren't supposed to change!"); } _class = classMetadata; }
private FieldMetadata FieldMetadataFrom(QField qField, Db4objects.Db4o.Internal.ClassMetadata type) { FieldMetadata existingField = qField.GetFieldMetadata(); if (existingField != null) { return existingField; } FieldMetadata field = type.FieldMetadataForName(qField.Name()); if (field != null) { field.Alive(); } return field; }
private ObjectHeader(ObjectContainerBase container, Db4objects.Db4o.Internal.ClassMetadata classMetadata, IReadWriteBuffer reader) { int classID = reader.ReadInt(); _marshallerFamily = ReadMarshallerFamily(reader, classID); classID = NormalizeID(classID); _classMetadata = (classMetadata != null ? classMetadata : container.ClassMetadataForID (classID)); // This check has been added to cope with defragment in debug mode: SlotDefragment#setIdentity() // will trigger calling this constructor with a source db class metadata and a target db stream, // thus _classMetadata==null. There may be a better solution, since this call is just meant to // skip the object header. _headerAttributes = SlotFormat().ReadHeaderAttributes((ByteArrayBuffer)reader); }
public virtual void CascadeActivationToChild(object obj) { if (obj == null) { return; } IActivationContext cascadingContext = ForObject(obj); Db4objects.Db4o.Internal.ClassMetadata classMetadata = cascadingContext.ClassMetadata (); if (classMetadata == null || !classMetadata.HasIdentity()) { return; } CascadeActivation(cascadingContext.Descend()); }
internal virtual IPreparedComparison PrepareComparison(ObjectContainerBase container , object constraint) { IContext context = container.Transaction.Context(); if (_fieldMetadata != null) { return(_fieldMetadata.PrepareComparison(context, constraint)); } if (_classMetadata != null) { return(_classMetadata.PrepareComparison(context, constraint)); } IReflector reflector = container.Reflector(); Db4objects.Db4o.Internal.ClassMetadata classMetadata = null; if (_bytes != null) { classMetadata = container.ProduceClassMetadata(reflector.ForObject(constraint)); } else { if (_member != null) { classMetadata = container.ClassMetadataForReflectClass(reflector.ForObject(_member )); } } if (classMetadata != null) { if (_member != null && _member.GetType().IsArray) { ITypeHandler4 arrayElementTypehandler = classMetadata.TypeHandler(); if (reflector.Array().IsNDimensional(MemberClass())) { MultidimensionalArrayHandler mah = new MultidimensionalArrayHandler(arrayElementTypehandler , false); return(mah.PrepareComparison(context, _member)); } ArrayHandler ya = new ArrayHandler(arrayElementTypehandler, false); return(ya.PrepareComparison(context, _member)); } return(classMetadata.PrepareComparison(context, constraint)); } return(null); }
protected void Analyze(ObjectContainerBase container, object obj, ArrayInfo info) { // TODO: Move as much analysis as possible to ReflectArray#analyze() ArrayReflector(container).Analyze(obj, info); IReflectClass claxx = ComponentType(container, obj); Db4objects.Db4o.Internal.ClassMetadata classMetadata = container.ProduceClassMetadata (claxx); bool primitive = IsPrimitive(container.Reflector(), claxx, classMetadata); if (primitive) { claxx = classMetadata.ClassReflector(); } info.Primitive(primitive); info.ReflectClass(claxx); AnalyzeDimensions(container, obj, info); }
private void CheckInstanceOfCompare() { if (_member is ICompare) { _member = ((ICompare)_member).Compare(); LocalObjectContainer stream = Container(); _classMetadata = stream.ClassMetadataForReflectClass(stream.Reflector().ForObject (_member)); _key = stream.GetID(Transaction(), _member); if (_key == 0) { SetBytes(null); } else { SetBytes(stream.ReadBufferById(Transaction(), _key)); } } }
internal virtual Db4objects.Db4o.Internal.ClassMetadata ReadClassMetadata() { if (_classMetadata == null) { Read(); if (_bytes != null) { Seek(0); ObjectContainerBase stream = Container(); ObjectHeader objectHeader = new ObjectHeader(stream, _bytes); _classMetadata = objectHeader.ClassMetadata(); if (_classMetadata != null) { if (stream._handlers.IclassCompare.IsAssignableFrom(_classMetadata.ClassReflector ())) { ReadThis(false); } } } } return _classMetadata; }
private bool DetectClassMetadata(Transaction trans, IReflectClass claxx) { _classMetadata = _container.GetActiveClassMetadata(claxx); if (_classMetadata != null) { if (!_classMetadata.IsStorable()) { NotStorable(_obj, claxx); return(false); } return(true); } _classMetadata = _container.ProduceClassMetadata(claxx); if (_classMetadata == null || !_classMetadata.IsStorable()) { NotStorable(_obj, claxx); return(false); } // The following may return a reference if the object is held // in a static variable somewhere ( often: Enums) that gets // stored or associated on initialization of the ClassMetadata. _ref = trans.ReferenceForObject(_obj); return(true); }
public ObjectReference(Db4objects.Db4o.Internal.ClassMetadata classMetadata, int id) : this(id) { _class = classMetadata; }
protected IReflectClass ClassReflector(IReflector reflector, Db4objects.Db4o.Internal.ClassMetadata classMetadata, bool isPrimitive) { return(_versionHelper.ClassReflector(reflector, classMetadata, isPrimitive)); }
protected bool IsPrimitive(IReflector reflector, IReflectClass claxx, Db4objects.Db4o.Internal.ClassMetadata classMetadata) { return(_versionHelper.IsPrimitive(reflector, claxx, classMetadata)); }
public ClassNode(Db4objects.Db4o.Internal.ClassMetadata clazz) { _clazz = clazz; }
public ObjectHeader(Db4objects.Db4o.Internal.ClassMetadata classMetadata, IReadWriteBuffer reader) : this(null, classMetadata, reader) { }
public virtual void ClassMetadata(Db4objects.Db4o.Internal.ClassMetadata classMetadata ) { _classMetadata = classMetadata; }
public StandardReferenceTypeHandler(Db4objects.Db4o.Internal.ClassMetadata classMetadata ) { ClassMetadata(classMetadata); }
public virtual void ClassMetadata(ClassMetadata classMetadata) { _classMetadata = classMetadata; }
protected override int InternalDeclaredAspectCount(Db4objects.Db4o.Internal.ClassMetadata classMetadata) { return(context.ReadInt()); }