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

		public override void Defragment(IDefragmentContext context)
		{
			int payLoadOffSet = context.ReadInt();
			if (payLoadOffSet == 0)
			{
				return;
			}
			int savedOffSet = context.Offset();
			context.Seek(payLoadOffSet);
			int classMetadataId = context.CopyIDReturnOriginalID();
			ITypeHandler4 typeHandler = CorrectTypeHandlerVersionFor(context, classMetadataId
				);
			if (typeHandler != null)
			{
				if (IsPlainObject(typeHandler))
				{
					context.CopySlotlessID();
				}
				else
				{
					SeekSecondaryOffset(context, typeHandler);
					context.Defragment(typeHandler);
				}
			}
			context.Seek(savedOffSet);
		}

		public virtual void Defragment(IDefragmentContext context)
		{
			DefragmentElementHandlerId(context);
			ITypeHandler4 handler = ReadElementTypeHandler(context, context);
			int elementCount = context.ReadInt();
			for (int i = 0; i < elementCount; i++)
			{
				context.Defragment(handler);
			}
		}

 public virtual void Defragment(IDefragmentContext context)
 {
     var pos = context.Offset();
     var id = context.ReadInt();
     var bTree = NewBTree(context, id);
     var services = (DefragmentServicesImpl) context.Services();
     var collector = new IDMappingCollector();
     services.RegisterBTreeIDs(bTree, collector);
     collector.Flush(services);
     context.Seek(pos);
     context.CopyID();
     bTree.DefragBTree(services);
 }

		public override void Defragment(IDefragmentContext context)
		{
			int sourceId = context.SourceBuffer().ReadInt();
			if (sourceId == 0)
			{
				context.TargetBuffer().WriteInt(0);
				return;
			}
			int targetId = 0;
			try
			{
				targetId = context.MappedID(sourceId);
			}
			catch (MappingNotFoundException)
			{
				targetId = CopyDependentSlot(context, sourceId);
			}
			context.TargetBuffer().WriteInt(targetId);
		}

		public override void Defragment(IDefragmentContext context)
		{
			int sourceAddress = context.SourceBuffer().ReadInt();
			int length = context.SourceBuffer().ReadInt();
			if (sourceAddress == 0 && length == 0)
			{
				context.TargetBuffer().WriteInt(0);
				context.TargetBuffer().WriteInt(0);
				return;
			}
			int targetAddress = 0;
			try
			{
				targetAddress = context.CopySlotToNewMapped(sourceAddress, length);
			}
			catch (IOException exc)
			{
				throw new Db4oIOException(exc);
			}
			context.TargetBuffer().WriteInt(targetAddress);
			context.TargetBuffer().WriteInt(length);
		}

 public virtual void Defragment(IDefragmentContext context)
 {
     DefragmentElementHandlerId(context);
     ReadArrayHandler(context).Defragment(context);
 }

 public virtual void Defragment(IDefragmentContext context)
 {
     CorrectHandlerVersion(context).Defragment(context);
 }

		public void Defragment(IDefragmentContext context)
		{
			context.Defragment(TypeHandler());
		}

		private void DefragmentWriteMappedClassId(IDefragmentContext context, ArrayInfo info
			, int classIdOffset)
		{
			ByteArrayBuffer targetBuffer = context.TargetBuffer();
			int currentOffset = targetBuffer.Offset();
			targetBuffer.Seek(classIdOffset);
			int classID = ClassIDFromInfo(Container(context), info);
			int mappedID = context.MappedID(classID);
			int marshalledMappedId = ClassIdToMarshalledClassId(mappedID, info.Primitive());
			targetBuffer.WriteInt(marshalledMappedId);
			targetBuffer.Seek(currentOffset);
		}

 public virtual void Defragment(IDefragmentContext context)
 {
     context.IncrementOffset(LinkLength());
 }

		public virtual void Defragment(IDefragmentContext context)
		{
			if (context.ClassMetadata().HasIdentity())
			{
				DefragmentSlot(context);
			}
			else
			{
				context.IncrementOffset(LinkLength());
			}
		}

		private static void IncrementOffset(IDefragmentContext context)
		{
			context.IncrementOffset(GuidSize);
		}

 public _MarshallingInfoTraverseAspectCommand_35(IDefragmentContext context, IMarshallingInfo
     baseArg1) : base(baseArg1)
 {
     this.context = context;
 }

 public virtual void Defragment(IDefragmentContext context)
 {
     TraverseAllAspects(context, new _MarshallingInfoTraverseAspectCommand_35(context,
         EnsureFieldList(context)));
 }

		public virtual void Defragment(IDefragmentContext context)
		{
			KeyValueHandlerPair handlers = ReadKeyValueTypeHandlers(context, context);
			int elementCount = context.ReadInt();
			for (int i = elementCount; i > 0; i--)
			{
				context.Defragment(handlers._keyHandler);
				context.Defragment(handlers._valueHandler);
			}
		}

 public override void DefragAspect(IDefragmentContext context)
 {
     throw new InvalidOperationException("Type handler for '" + ContainingClass() +
                                         "' could not be found. Defragment cannot proceed. "
                                         + " Please ensure all required types are available and try again.");
 }

 public virtual void Defragment(IDefragmentContext context)
 {
     throw new NotImplementedException();
 }

 private static void DefragmentElementHandlerId(IDefragmentContext context)
 {
     int offset = context.Offset();
     context.CopyID();
     context.Seek(offset);
 }

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