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 virtual void ProcessAspect(ClassAspect aspect, int currentSlot)
		{
			if (aspect is FieldMetadata)
			{
				Process((FieldMetadata)aspect);
			}
		}

		public virtual void ProcessAspect(ClassAspect aspect, int currentSlot)
		{
			if (Accept(aspect))
			{
				ProcessAspect(aspect, currentSlot, _marshallingInfo.IsNull(currentSlot));
			}
			_marshallingInfo.BeginSlot();
		}

			protected override void ProcessAspect(ClassAspect aspect, int currentSlot, bool isNull
				)
			{
				if (!isNull)
				{
					aspect.DefragAspect(context);
				}
			}

		public virtual void ProcessAspectOnMissingClass(ClassAspect aspect, int currentSlot
			)
		{
			if (_marshallingInfo.IsNull(currentSlot))
			{
				return;
			}
			aspect.IncrementOffset(_marshallingInfo.Buffer());
		}

		public override int MarshalledLength(ObjectContainerBase stream, ClassAspect aspect
			)
		{
			int len = base.MarshalledLength(stream, aspect);
			if (!(aspect is FieldMetadata))
			{
				return len;
			}
			FieldMetadata field = (FieldMetadata)aspect;
			if (!HasBTreeIndex(field))
			{
				return len;
			}
			return len + Const4.IdLength;
		}

		public override void Write(Transaction trans, ClassMetadata clazz, ClassAspect aspect
			, ByteArrayBuffer writer)
		{
			base.Write(trans, clazz, aspect, writer);
			if (!(aspect is FieldMetadata))
			{
				return;
			}
			FieldMetadata field = (FieldMetadata)aspect;
			if (!HasBTreeIndex(field))
			{
				return;
			}
			writer.WriteIDOf(trans, field.GetIndex(trans));
		}

		public override int MarshalledLength(ObjectContainerBase stream, ClassAspect aspect
			)
		{
			int len = stream.StringIO().ShortLength(aspect.GetName());
			if (aspect is FieldMetadata)
			{
				FieldMetadata field = (FieldMetadata)aspect;
				if (field.NeedsArrayAndPrimitiveInfo())
				{
					len += 1;
				}
				if (!(field is VirtualFieldMetadata))
				{
					len += Const4.IdLength;
				}
			}
			return len;
		}

 private ClassAspect[] ToClassAspectArray(Collection4 aspects)
 {
     var array = new ClassAspect[aspects.Size()];
     aspects.ToArray(array);
     for (var i = 0; i < array.Length; i++)
     {
         array[i].SetHandle(i);
     }
     return array;
 }

 // do nothing
 public void ProcessAspect(ClassAspect aspect, int currentSlot)
 {
     if (aspect.IsEnabledOn(AspectVersionContextImpl.CheckAlwaysEnabled))
     {
         aspect.Deactivate(context);
     }
 }

 public void ProcessAspectOnMissingClass(ClassAspect aspect, int currentSlot)
 {
 }

 public bool SeekToField(ObjectHeaderContext context, ClassAspect field)
 {
     if (!StandardReferenceTypeHandlerIsUsed())
     {
         return false;
     }
     return Handlers4.FieldAwareTypeHandler(CorrectHandlerVersion(context)).SeekToField
         (context, field);
 }

			public override void ProcessAspectOnMissingClass(ClassAspect aspect, int currentSlot
				)
			{
				((MarshallingContext)context).IsNull(currentSlot, true);
			}

			public override bool Accept(ClassAspect aspect)
			{
				return aspect.IsEnabledOn(context);
			}

		private bool IsCollectIdTypehandlerAspect(ClassAspect aspect)
		{
			if (!(aspect is TypeHandlerAspect))
			{
				return false;
			}
			ITypeHandler4 typehandler = ((TypeHandlerAspect)aspect)._typeHandler;
			return Handlers4.IsCascading(typehandler);
		}

 private bool InstallTranslatorOnExistingAspect(IObjectTranslator translator, ClassAspect
     existingAspect, Collection4 aspects)
 {
     if (existingAspect is TranslatedAspect)
     {
         var translatedAspect = (TranslatedAspect) existingAspect;
         translatedAspect.InitializeTranslator(translator);
         _translator = translatedAspect;
         return false;
     }
     // older versions didn't store the aspect type properly
     _translator = new TranslatedAspect(this, translator);
     aspects.ReplaceByIdentity(existingAspect, _translator);
     return true;
 }

 private bool ReplaceAspectByName(Collection4 aspects, ClassAspect aspect)
 {
     var existing = AspectByName(aspects, aspect.GetName());
     if (existing == null)
     {
         return false;
     }
     aspects.ReplaceByIdentity(existing, aspect);
     return true;
 }

			public void Process(ITraverseAspectCommand command, ClassAspect currentAspect, int
				 currentSlot)
			{
				command.ProcessAspectOnMissingClass(currentAspect, currentSlot);
			}

		public virtual bool SeekToField(ObjectHeaderContext context, ClassAspect aspect)
		{
			BooleanByRef found = new BooleanByRef(false);
			ITraverseAspectCommand command = new _MarshallingInfoTraverseAspectCommand_456(aspect
				, found, context, EnsureFieldList(context));
			TraverseAllAspects(context, command);
			return found.value;
		}