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 DefragmentContextImpl(Db4objects.Db4o.Internal.DefragmentContextImpl parentContext
, ObjectHeader header)
{
_source = parentContext._source;
_target = parentContext._target;
_services = parentContext._services;
_objectHeader = header;
}
public DefragmentContextImpl(DefragmentContextImpl parentContext
, ObjectHeader header)
{
_source = parentContext._source;
_target = parentContext._target;
_services = parentContext._services;
_objectHeader = header;
}
public static void ProcessCopy(IDefragmentServices services, int sourceID, ISlotCopyHandler
command, ByteArrayBuffer sourceReader)
{
int targetID = services.StrictMappedID(sourceID);
Slot targetSlot = services.AllocateTargetSlot(sourceReader.Length());
services.Mapping().MapId(targetID, targetSlot);
Db4objects.Db4o.Internal.DefragmentContextImpl context = new Db4objects.Db4o.Internal.DefragmentContextImpl
(sourceReader, services);
command.ProcessCopy(context);
services.TargetWriteBytes(context, targetSlot.Address());
}
public void ProcessCopy(DefragmentContextImpl context)
{
ClassMetadata.DefragObject(context);
if (this._enclosing._objectCommitFrequency > 0)
{
this._enclosing._objectCount++;
if (this._enclosing._objectCount == this._enclosing._objectCommitFrequency)
{
services.TargetCommit();
services.Mapping().Commit();
this._enclosing._objectCount = 0;
}
}
}
public static Db4objects.Db4o.Internal.Marshall.ObjectHeader Defrag(DefragmentContextImpl
context)
{
ByteArrayBuffer source = context.SourceBuffer();
ByteArrayBuffer target = context.TargetBuffer();
Db4objects.Db4o.Internal.Marshall.ObjectHeader header = new Db4objects.Db4o.Internal.Marshall.ObjectHeader
(context.Services().SystemTrans().Container(), null, source);
int newID = context.Mapping().StrictMappedID(header.ClassMetadata().GetID());
Db4objects.Db4o.Internal.Marshall.SlotFormat slotFormat = header.SlotFormat();
slotFormat.WriteObjectClassID(target, newID);
slotFormat.SkipMarshallerInfo(target);
slotFormat.ReadHeaderAttributes(target);
return header;
}
public virtual void TargetWriteBytes(DefragmentContextImpl context, int address)
{
context.Write(_targetDb, address);
}
private int CopyAcceptedClasses(DefragmentContextImpl context, int acceptedClasses
)
{
int numClasses = context.ReadInt();
for (int classIdx = 0; classIdx < numClasses; classIdx++)
{
int classId = context.SourceBuffer().ReadInt();
if (!this.Accept(classId))
{
continue;
}
++acceptedClasses;
context.WriteMappedID(classId);
}
return acceptedClasses;
}
public void ProcessCopy(DefragmentContextImpl context)
{
this._enclosing._enclosing.DefragIndexNode(context);
}
public virtual void DefragIndexEntry(DefragmentContextImpl context)
{
_parentIdHandler.DefragIndexEntry(context);
_valueHandler.DefragIndexEntry(context);
}
public virtual void DefragIndexEntry(DefragmentContextImpl context)
{
throw new NotImplementedException();
}
public abstract void DefragReference(ClassMetadata arg1, DefragmentContextImpl arg2 , int arg3);
public abstract void DefragIndex(DefragmentContextImpl arg1);
public static void DefragObject(DefragmentContextImpl context)
{
var header = ObjectHeader.Defrag(context);
var childContext = new DefragmentContextImpl(context, header);
header.ClassMetadata().Defragment(childContext);
}
public virtual void DefragClass(DefragmentContextImpl context, int classIndexID)
{
var mf = MarshallerFamily.ForConverterVersion(Container().ConverterVersion
());
mf._class.Defrag(this, _container.StringIO(), context, classIndexID);
}
public static void Defragment(IDefragmentContext context, ArrayHandler handler)
{
int sourceAddress = context.SourceBuffer().ReadInt();
int length = context.SourceBuffer().ReadInt();
if (sourceAddress == 0 && length == 0)
{
context.TargetBuffer().WriteInt(0);
context.TargetBuffer().WriteInt(0);
return;
}
Slot slot = context.AllocateMappedTargetSlot(sourceAddress, length);
ByteArrayBuffer sourceBuffer = null;
try
{
sourceBuffer = context.SourceBufferByAddress(sourceAddress, length);
}
catch (IOException exc)
{
throw new Db4oIOException(exc);
}
DefragmentContextImpl payloadContext = new DefragmentContextImpl(sourceBuffer, (DefragmentContextImpl
)context);
handler.DefragmentSlot(payloadContext);
payloadContext.WriteToTarget(slot.Address());
context.TargetBuffer().WriteInt(slot.Address());
context.TargetBuffer().WriteInt(length);
}
void IIndexable4.DefragIndexEntry(DefragmentContextImpl context)
{
IncrementOffset(context);
}
public void DefragIndexEntry(DefragmentContextImpl context)
{
context.IncrementOffset(Const4.LongLength);
}
public void DefragIndexEntry(DefragmentContextImpl context)
{
context.CopyID();
}
public void ProcessCopy(DefragmentContextImpl context)
{
classMetadata.DefragClass(context, classIndexID);
}
// do nothing
public virtual void DefragIndexEntry(DefragmentContextImpl context)
{
}
public static void DefragIndex(DefragmentContextImpl context, IIndexable4 keyHandler
)
{
// count
int count = context.ReadInt();
// leafByte
byte leafByte = context.ReadByte();
bool isLeaf = (leafByte == 1);
context.CopyID();
// parent ID
context.CopyID();
// previous ID
context.CopyID();
// next ID
for (int i = 0; i < count; i++)
{
keyHandler.DefragIndexEntry(context);
if (!isLeaf)
{
context.CopyID();
}
}
}
public override void DefragIndexEntry(DefragmentContextImpl context)
{
int sourceId = context.CopyIDReturnOriginalID(true);
context.CurrentParentSourceID(sourceId);
}
public override void Defrag(ClassMetadata classMetadata, ClassAspect aspect, LatinStringIO
sio, DefragmentContextImpl context)
{
context.ReadByte();
base.Defrag(classMetadata, aspect, sio, context);
}
public DefragmentContextImpl(ByteArrayBuffer source, Db4objects.Db4o.Internal.DefragmentContextImpl
context) : this(source, context._services, context._objectHeader)
{
}
public _IProcedure4_136(ClassMarshaller _enclosing, IntByRef processedAspectCount
, int aspectCount, ClassMetadata classMetadata, LatinStringIO sio, DefragmentContextImpl
context)
{
this._enclosing = _enclosing;
this.processedAspectCount = processedAspectCount;
this.aspectCount = aspectCount;
this.classMetadata = classMetadata;
this.sio = sio;
this.context = context;
}
public override void DefragIndexEntry(DefragmentContextImpl context)
{
context.IncrementIntSize();
}
public virtual void DefragIndexEntry(DefragmentContextImpl context)
{
// we are storing ids in the btree, so the order will change when the ids change
// to properly defrag the btree we need to readd all the entries
throw new NotSupportedException();
}
public void DefragIndexEntry(DefragmentContextImpl context)
{
IncrementOffset(context);
}
public virtual void DefragIndexNode(DefragmentContextImpl context)
{
BTreeNode.DefragIndex(context, _keyHandler);
}
private int CopyDependentSlot(IDefragmentContext context, int sourceId)
{
try
{
ByteArrayBuffer sourceBuffer = context.SourceBufferById(sourceId);
Slot targetPayloadSlot = context.AllocateTargetSlot(sourceBuffer.Length());
int targetId = context.Services().TargetNewId();
context.Services().MapIDs(sourceId, targetId, false);
context.Services().Mapping().MapId(targetId, targetPayloadSlot);
DefragmentContextImpl payloadContext = new DefragmentContextImpl(sourceBuffer, (DefragmentContextImpl
)context);
int clazzId = payloadContext.CopyIDReturnOriginalID();
ITypeHandler4 payloadHandler = payloadContext.TypeHandlerForId(clazzId);
ITypeHandler4 versionedPayloadHandler = HandlerRegistry.CorrectHandlerVersion(payloadContext
, payloadHandler);
versionedPayloadHandler.Defragment(payloadContext);
payloadContext.WriteToTarget(targetPayloadSlot.Address());
return targetId;
}
catch (IOException ioexc)
{
throw new Db4oIOException(ioexc);
}
}
public void ProcessCopy(DefragmentContextImpl context)
{
int acceptedClasses = 0;
int numClassesOffset = context.TargetBuffer().Offset();
acceptedClasses = this.CopyAcceptedClasses(context, acceptedClasses);
this.WriteIntAt(context.TargetBuffer(), numClassesOffset, acceptedClasses);
}
public virtual void Defrag(ClassMetadata classMetadata, LatinStringIO sio, DefragmentContextImpl
context, int classIndexID)
{
ReadName(sio, context.SourceBuffer());
ReadName(sio, context.TargetBuffer());
int metaClassID = 0;
context.WriteInt(metaClassID);
// ancestor ID
context.CopyID();
context.WriteInt((classMetadata.HasClassIndex() ? IndexIDForWriting(classIndexID)
: 0));
int aspectCount = context.ReadInt();
if (aspectCount > classMetadata.DeclaredAspectCount())
{
throw new InvalidOperationException();
}
IntByRef processedAspectCount = new IntByRef(0);
classMetadata.TraverseDeclaredAspects(new _IProcedure4_136(this, processedAspectCount
, aspectCount, classMetadata, sio, context));
}
public override void DefragIndexEntry(DefragmentContextImpl context)
{
int sourceId = context.CopyIDReturnOriginalID(true);
context.CurrentParentSourceID(sourceId);
}
// do nothing
public virtual void DefragIndexEntry(DefragmentContextImpl context)
{
}
public virtual void DefragIndex(DefragmentContextImpl context)
{
context.IncrementOffset(DefragmentIncrementOffset);
context.CopyID();
}
