예제 #1
0
        protected virtual bool ObjectCanUpdate(Db4objects.Db4o.Internal.Transaction transaction
                                               , object obj)
        {
            ObjectContainerBase container = transaction.Container();

            return(container.Callbacks().ObjectCanUpdate(transaction, this) && _class.DispatchEvent
                       (transaction, obj, EventDispatchers.CanUpdate));
        }
예제 #2
0
        private void ObjectOnNew(Db4objects.Db4o.Internal.Transaction transaction, object
                                 obj)
        {
            ObjectContainerBase container = transaction.Container();

            container.Callbacks().ObjectOnNew(transaction, this);
            _class.DispatchEvent(transaction, obj, EventDispatchers.New);
        }
예제 #3
0
 /// <exception cref="Db4objects.Db4o.Ext.Db4oIOException"></exception>
 public virtual bool Close()
 {
     lock (Lock())
     {
         if (IsClosed())
         {
             return(false);
         }
         if (!_server.IsClosed())
         {
             if (!_server.ConfigImpl.IsReadOnly())
             {
                 Commit();
             }
         }
         _server.Callbacks().CloseOnStarted(this);
         _server.CloseTransaction(_transaction, false, false);
         _closed = true;
         return(true);
     }
 }
예제 #4
0
        public virtual void WriteUpdate(Db4objects.Db4o.Internal.Transaction transaction,
                                        IUpdateDepth updatedepth)
        {
            ContinueSet(transaction, updatedepth);
            // make sure, a concurrent new, possibly triggered by objectOnNew
            // is written to the file
            // preventing recursive
            if (!BeginProcessing())
            {
                return;
            }
            object obj = GetObject();

            if (!ObjectCanUpdate(transaction, obj) || !IsActive() || obj == null || !ClassMetadata
                    ().IsModified(obj))
            {
                EndProcessing();
                return;
            }
            MarshallingContext context = new MarshallingContext(transaction, this, updatedepth
                                                                , false);

            if (context.UpdateDepth().Negative())
            {
                EndProcessing();
                return;
            }
            ObjectContainerBase container = transaction.Container();

            LogEvent(container, "update", Const4.State);
            SetStateClean();
            context.PurgeFieldIndexEntriesOnUpdate(transaction, container._handlers.ArrayType
                                                       (obj));
            Handlers4.Write(_class.TypeHandler(), context, obj);
            if (context.UpdateDepth().CanSkip(this))
            {
                EndProcessing();
                return;
            }
            Pointer4        pointer = context.AllocateSlot();
            ByteArrayBuffer buffer  = context.ToWriteBuffer(pointer);

            container.WriteUpdate(transaction, pointer, _class, container._handlers.ArrayType
                                      (obj), buffer);
            if (IsActive())
            {
                SetStateClean();
            }
            EndProcessing();
            container.Callbacks().ObjectOnUpdate(transaction, this);
            ClassMetadata().DispatchEvent(transaction, obj, EventDispatchers.Update);
        }