public virtual void ReadTypeInfo(Transaction trans, IReadBuffer buffer, ArrayInfo
info, int classID)
{
BitMap4 typeInfoBitmap = new BitMap4(buffer.ReadByte());
info.Primitive(typeInfoBitmap.IsTrue(0));
info.Nullable(typeInfoBitmap.IsTrue(1));
}
public virtual void WriteTypeInfo(IWriteContext context, ArrayInfo info)
{
BitMap4 typeInfoBitmap = new BitMap4(2);
typeInfoBitmap.Set(0, info.Primitive());
typeInfoBitmap.Set(1, info.Nullable());
context.WriteByte(typeInfoBitmap.GetByte(0));
}
public override IReflectClass ReflectClassFromElementsEntry(ObjectContainerBase container
, ArrayInfo info, int classID)
{
if (classID == Const4.IgnoreId)
{
// TODO: Here is a low-frequency mistake, extremely unlikely.
// If classID == 99999 by accident then we will get ignore.
return null;
}
info.Primitive(false);
if (UseJavaHandling())
{
if (classID < Const4.Primitive)
{
info.Primitive(true);
classID -= Const4.Primitive;
}
}
classID = -classID;
ClassMetadata classMetadata = container.ClassMetadataForID(classID);
if (classMetadata != null)
{
return ClassReflector(container.Reflector(), classMetadata, info.Primitive());
}
return null;
}
public virtual bool HasNullBitmap(ArrayInfo info)
{
if (info.Nullable())
{
return true;
}
return !info.Primitive();
}
public virtual int ClassIDFromInfo(ObjectContainerBase container, ArrayInfo info)
{
ClassMetadata classMetadata = container.ProduceClassMetadata(info.ReflectClass());
if (classMetadata == null)
{
return 0;
}
return classMetadata.GetID();
}
public virtual object NewInstance(IReflectClass componentType, ArrayInfo info)
{
componentType = componentType.GetDelegate();
if (componentType is GenericClass)
{
int length = info.ElementCount();
return new GenericArray(((GenericClass)componentType).ArrayClass(), length);
}
return _delegate.NewInstance(componentType, info);
}
private void ReadDimensions(ArrayInfo info, IReadBuffer buffer, int dimensionCount
)
{
var dim = new int[dimensionCount];
for (var i = 0; i < dim.Length; i++)
{
dim[i] = buffer.ReadInt();
}
((MultidimensionalArrayInfo) info).Dimensions(dim);
info.ElementCount(ElementCount(dim));
}
protected override void ReadElements(IReadContext context, ArrayInfo info, object
array)
{
if (array == null)
{
return;
}
object[] objects = new object[info.ElementCount()];
ReadInto(context, info, objects);
ArrayReflector(Container(context)).Shape(objects, 0, array, ((MultidimensionalArrayInfo
)info).Dimensions(), 0);
}
public override int ClassIDFromInfo(ObjectContainerBase container, ArrayInfo info
)
{
ClassMetadata classMetadata = container.ProduceClassMetadata(info.ReflectClass());
if (classMetadata == null)
{
// TODO: This one is a terrible low-frequency blunder !!!
// If YapClass-ID == 99999 then we will get IGNORE back.
// Discovered on adding the primitives
return Const4.IgnoreId;
}
return classMetadata.GetID();
}
public virtual IReflectClass ReflectClassFromElementsEntry(ObjectContainerBase container
, ArrayInfo info, int classID)
{
if (classID == 0)
{
return null;
}
ClassMetadata classMetadata = container.ClassMetadataForID(classID);
if (classMetadata == null)
{
return null;
}
return ClassReflector(container.Reflector(), classMetadata, info.Primitive());
}
public virtual void Analyze(object obj, ArrayInfo info)
{
}
protected virtual void AnalyzeDimensions(ObjectContainerBase container, object obj
, ArrayInfo info)
{
info.ElementCount(ArrayReflector(container).GetLength(obj));
}
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);
}
protected virtual void WriteDimensions(IWriteContext context, ArrayInfo info)
{
context.WriteInt(info.ElementCount());
}
protected virtual int ClassIDFromInfo(ObjectContainerBase container, ArrayInfo info
)
{
return _versionHelper.ClassIDFromInfo(container, info);
}
public override bool HasNullBitmap(ArrayInfo info)
{
return false;
}
// do nothing, the byte for additional type information was added after format 3
public override void ReadTypeInfo(Transaction trans, IReadBuffer buffer, ArrayInfo
info, int classID)
{
}
protected bool HasNullBitmap(ArrayInfo info)
{
return _versionHelper.HasNullBitmap(info);
}
protected virtual void ReadElements(IReadContext context, ArrayInfo info, object
array)
{
ReadInto(context, info, array);
}
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);
}
private Db4objects.Db4o.Internal.ClassMetadata ClassMetadata(IDefragmentContext context
, ArrayInfo info)
{
int classMetadataId = ClassIDFromInfo(Container(context), info);
return Container(context).ClassMetadataForID(classMetadataId);
}
private ITypeHandler4 CorrectHandlerVersion(IDefragmentContext context, ITypeHandler4
handler, ArrayInfo info)
{
Db4objects.Db4o.Internal.ClassMetadata classMetadata = ClassMetadata(context, info
);
return HandlerRegistry.CorrectHandlerVersion(context, handler, classMetadata);
}
private int MarshalledClassID(ObjectContainerBase container, ArrayInfo info)
{
return ClassIdToMarshalledClassId(ClassIDFromInfo(container, info), info.Primitive
());
}
public virtual object NewInstance(IReflectClass componentType, ArrayInfo info)
{
// TODO: implement multidimensional arrays.
int length = info.ElementCount();
return NewInstance(componentType, length);
}
public override void WriteTypeInfo(IWriteContext context, ArrayInfo info)
{
}
protected virtual void WriteElements(IWriteContext context, object obj, ArrayInfo
info)
{
if (HandleAsByteArray(obj))
{
context.WriteBytes((byte[])obj);
}
else
{
// byte[] performance optimisation
if (HasNullBitmap(info))
{
BitMap4 nullItems = NullItemsMap(ArrayReflector(Container(context)), obj);
WriteNullBitmap(context, nullItems);
for (int i = 0; i < info.ElementCount(); i++)
{
if (!nullItems.IsTrue(i))
{
context.WriteObject(_handler, ArrayReflector(Container(context)).Get(obj, i));
}
}
}
else
{
for (int i = 0; i < info.ElementCount(); i++)
{
context.WriteObject(_handler, ArrayReflector(Container(context)).Get(obj, i));
}
}
}
}
protected virtual void WriteInfo(IWriteContext context, ArrayInfo info)
{
WriteHeader(context, info);
WriteDimensions(context, info);
}
private void WriteHeader(IWriteContext context, ArrayInfo info)
{
context.WriteInt(MarshalledClassID(Container(context), info));
_versionHelper.WriteTypeInfo(context, info);
}
protected void ReadInto(IReadContext context, ArrayInfo info, object array)
{
if (array == null)
{
return;
}
if (HandleAsByteArray(array))
{
context.ReadBytes((byte[])array);
// byte[] performance optimisation
return;
}
if (HasNullBitmap(info))
{
BitMap4 nullBitMap = ReadNullBitmap(context, info.ElementCount());
for (int i = 0; i < info.ElementCount(); i++)
{
object obj = nullBitMap.IsTrue(i) ? null : context.ReadObject(_handler);
ArrayReflector(Container(context)).Set(array, i, obj);
}
}
else
{
for (int i = 0; i < info.ElementCount(); i++)
{
ArrayReflector(Container(context)).Set(array, i, context.ReadObject(_handler));
}
}
}
private void ReflectClassFromElementsEntry(ObjectContainerBase container, ArrayInfo
info, int classID)
{
info.ReflectClass(_versionHelper.ReflectClassFromElementsEntry(container, info, classID
));
}
