public void InitExisting(BinaryReader reader, Func <string, Type> typeResolver)
{
ThrowOnInitialized();
_version = reader.ReadVersion();
if (_version != Versions.Ver0)
{
throw new IncompatibleVersionException(GetType(), _version);
}
_headerSerializer = reader.ReadTypeAndInstantiate <IBinSerializer <THeader> >(typeResolver, false);
_headerSerializer.InitExisting(reader, typeResolver);
_dataSerializer = reader.ReadTypeAndInstantiate <IBinSerializer <TItem> >(typeResolver, false);
_dataSerializer.InitExisting(reader, typeResolver);
ItemCount = reader.ReadInt32();
_itemTypeSize = reader.ReadInt32();
if (CalculateTypeSize() != _itemTypeSize)
{
throw Utils.GetItemSizeChangedException(this, null, _itemTypeSize);
}
IsInitialized = true;
}
/// <summary>
/// Serialize header info into a memory stream and return as a byte array.
/// This method must match the reading sequence in the
/// <see cref="Open(System.IO.Stream,System.Func{string,System.Type})"/>.
/// </summary>
private ArraySegment <byte> CreateHeader()
{
var memStream = new MemoryStream();
var memWriter = new BinaryWriter(memStream);
//
// Serialize header values
//
// Header size will be replaced by an actual length later
memWriter.Write(FileSignature);
memWriter.Write(0);
memWriter.WriteVersion(BaseVersion);
if (BaseVersion == Versions.Ver0 || BaseVersion == Versions.Ver1)
{
WriteHeaderV0(memWriter);
}
else if (BaseVersion == Versions.Ver2)
{
WriteHeaderV2(memWriter);
}
else
{
throw new IncompatibleVersionException(GetType(), BaseVersion);
}
IBinSerializer srlzr = NonGenericSerializer;
if (srlzr.TypeSize <= 0)
{
throw new BinaryFileException(
"Serializer {0} reported incorrect type size {1} for type {2}",
srlzr.GetType().ToDebugStr(), srlzr.TypeSize,
srlzr.ItemType.ToDebugStr());
}
_enableMemMappedAccessOnRead = false;
_enableMemMappedAccessOnWrite = false;
// Header size must be dividable by the item size
var headerSize =
(int)Utils.RoundUpToMultiple(memWriter.BaseStream.Position, srlzr.TypeSize);
if (memStream.Capacity < headerSize)
{
memStream.Capacity = headerSize;
}
// Override the header size value at the 5th byte of the header.
// The first 4 bytes are taken up by the 4 byte signature
memWriter.Seek(sizeof(int), SeekOrigin.Begin);
memWriter.Write(headerSize);
HeaderSize = headerSize;
return(new ArraySegment <byte>(memStream.GetBuffer(), 0, headerSize));
}
public static SerializerException GetItemSizeChangedException(
[NotNull] IBinSerializer serializer, string tag, int itemSize)
{
if (serializer == null)
{
throw new ArgumentNullException("serializer");
}
return(new SerializerException(
"Serializer {0} ({1}){2} was created with ItemSize={3}, but now the ItemSize={4}",
serializer.GetType().ToDebugStr(),
serializer.Version,
tag == null ? "" : " Tag='" + tag + "'",
itemSize,
serializer.TypeSize));
}
public BinBlockSerializer()
{
_headerSerializer = new DefaultTypeSerializer <THeader>();
_dataSerializer = new DefaultTypeSerializer <TItem>();
ItemCount = 100;
}
protected abstract void SetSerializer(IBinSerializer nonGenericSerializer);
/// <summary> Used by <see cref="BinaryFile.Open(System.IO.Stream,System.Func{string,System.Type})"/> when opening an existing file </summary>
protected override sealed void SetSerializer(IBinSerializer nonGenericSerializer)
{
_serializer = (IBinSerializer <T>)nonGenericSerializer;
}
