/// <summary>
/// Reads the meta number from this record stream.
/// This method only reads from the stream but does not change the current value of MetaNumber property.
/// </summary>
/// <returns>The meta number stored in this stream.</returns>
protected int ReadMetaNumber()
{
if (_infoPos == -1)
{
throw new InvalidOperationException();
}
_infoStream.SeekTo(_infoPos);
if (!_infoStream.Check(IOChecks.RecordStream))
{
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
return(_infoStream.ReadInt32());
}
/// <summary>
/// Reads a Boolean array from this stream.
/// </summary>
/// <param name="stream">The stream to read.</param>
/// <param name="validityCheck">Set this parameter <c>true</c> if there is a check code before the Boolean array to prevent data corruption; otherwise, set this <c>false</c>.</param>
/// <returns>
/// A Boolean array read from the stream.
/// </returns>
/// <exception cref="System.IO.InvalidDataException">Raises if data in the stream is corrupted.</exception>
public static bool[] ReadBooleans(this Stream stream, bool validityCheck = true)
{
if (!validityCheck || stream.Check(IOChecks.Booleans))
{
var len = stream.ReadInt32();
if (len == 0)
{
return(null);
}
else if (len < 0)
{
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
var count = (int)Math.Ceiling(len / 8f);
var bytes = stream.ReadBytes(count);
var bools = new bool[len];
for (int i = 0; i < len; i++)
{
bools[i] = bytes.GetBit(i);
}
return(bools);
}
else
{
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
}
public static string[] ReadTextList(this Stream stream, Encoding encoding, bool validityCheck)
{
if (!validityCheck || stream.Check(IOChecks.StringList))
{
var stringCount = stream.ReadInt32();
if (stringCount < 0)
{
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
if (stringCount != 0)
{
var output = new string[stringCount];
if (encoding == null)
{
encoding = Encoding.UTF8;
}
for (int i = 0; i < stringCount; ++i)
{
output[i] = stream.ReadText(encoding, false);
}
return(output);
}
return(null);
}
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
static void _innerReadList <T>(_readItem <T> read, Stream stream, IList <T> list, bool validityCheck = true)
{
//var pos = stream.Position;
if (!validityCheck || stream.Check((Int64)29))
{
while (true)
{
//reads and checks length
var len = stream.ReadInt32();
if (len < 0)
{
//stream.SeekTo(pos);
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
//reads and checks occupancy
var occupancy = stream.ReadInt32();
if (occupancy < 0)
{
//stream.SeekTo(pos);
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
//reads and check next point
var next = stream.ReadInt64();
if (next < 0)
{
//stream.SeekTo(pos);
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
for (int i = 0; i < occupancy; i++)
{
list.Add((T)read(stream));
}
if (next == 0 || occupancy < len)
{
break;
}
else
{
stream.SeekTo(next);
}
}
}
else
{
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
}
/// <summary>
/// Reads objects from this stream and stores them in a list.
/// </summary>
/// <param name="stream">A <see cref="System.IO.Stream"/>.</param>
/// <param name="list">A list used to store the objects.</param>
/// <param name="converter">A delegate used to convert the read bytes to the desired object.</param>
/// <param name="validityCheck">Indicates whether to read a countersign from the stream and perform the validity check.</param>
public static void ReadObjects <T>(this Stream stream,
IList <T> list, BytesToObjectConverter <T> converter, bool validityCheck = true)
{
var pos = stream.Position;
if (!validityCheck || stream.Check((Int64)29))
{
while (true)
{
var len = stream.ReadInt32();
if (len < 0)
{
stream.SeekTo(pos);
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
var occupancy = stream.ReadInt32();
if (occupancy < 0)
{
stream.SeekTo(pos);
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
var next = stream.ReadInt64();
while (occupancy > 0)
{
var p1 = stream.Position;
var b = stream.ReadByteArray(validityCheck);
var advance = stream.Position - p1;
occupancy -= (int)advance;
list.Add(converter(b));
}
if (next <= 0)
{
break;
}
else
{
stream.SeekTo(next);
}
}
}
else
{
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
}
/// <summary>
/// Reads a System.Segment object from this stream.
/// </summary>
/// <param name="stream">This stream.</param>
/// <returns>A System.Segment object.</returns>
internal static SegmentMapping ReadSegmentMapping(this Stream stream, bool validityCheck = false)
{
if (!validityCheck || stream.Check(IOChecks.Common))
{
var b = new SegmentMapping();
b.OriginalStartPosition = stream.ReadInt32();
b.OriginalEndPosition = stream.ReadInt32();
b.MappingStartPosition = stream.ReadInt32();
b.MappingEndPosition = stream.ReadInt32();
return(b);
}
else
{
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
}
/// <summary>
/// Reads string dictionary items from this stream.
/// </summary>
/// <param name="stream">The stream to read from.</param>
/// <param name="dictionary">A dictionary that stores dictionary items read from the stream.</param>
/// <param name="validityCheck">
/// <c>true</c> if a code is written into the stream
/// and any reading method can check this code to determine whether the data is not corrupted.
/// </param>
/// <returns>A string dictionary read from the stream.</returns>
public static void ReadStringDictionary(this Stream stream, IDictionary <string, string> dictionary, bool validityCheck = true)
{
if (validityCheck)
{
stream.Check(IOChecks.StringList);
}
var count = stream.ReadInt32();
if (count == 0)
{
return;
}
while (count-- > 0)
{
dictionary.Add(stream.ReadString(false), stream.ReadString(false));
}
}
/// <summary>
/// Reads a string instance from this stream.
/// </summary>
/// <param name="stream">The stream to read from.</param>
/// <param name="validityCheck">Indicates whether to read
/// a countersign before the string and perform data-validity check.</param>
/// <returns>A string read from the stream.</returns>
public static string ReadString(this Stream stream, bool validityCheck = false)
{
if (!validityCheck || stream.Check((Int64)17))
{
byte para = (byte)stream.ReadByte();
if (para == byte.MaxValue)
{
return(string.Empty);
}
if (para <= 0x0F)
{
return(_srstring(stream, para));
}
int len;
if (para.GetBitAt6())
{
para = para.SetBitZeroAt6();
len = stream.ReadByte();
}
else if (para.GetBitAt7())
{
para = para.SetBitZeroAt7();
len = (int)stream.ReadUInt16();
}
else
{
len = (int)stream.ReadUInt32();
}
byte cp = (byte)(para & 0x30);
Encoding coder = _getCoder(cp);
if (coder == null)
{
coder = Encoding.GetEncoding(stream.ReadUInt16());
}
var alg = (ByteCompressionMethods)((byte)(para & 0xCF));
return(coder.GetString(stream.ReadBytes(len).DeCompress(alg)));
}
else
{
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
}
/// <summary>
/// Skips a byte array in this stream.
/// </summary>
/// <param name="stream">A stream.</param>
/// <param name="validityCheck">Set this parameter <c>true</c> if there is a check code before the array to skip; otherwise, set this <c>false</c>.</param>
/// <exception cref="System.IO.InvalidDataException">Raises if data in the stream is corrupted.</exception>
public static void SkipByteArray(this Stream stream, bool validityCheck)
{
if (!validityCheck || stream.Check((Int64)37))
{
var len = stream.ReadInt32();
if (len < 0)
{
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
else if (len > 0)
{
stream.SeekForward(len);
}
}
else
{
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
}
/// <summary>
/// Skips a string instance in this stream.
/// </summary>
/// <param name="stream">The stream to operate on.</param>
/// <param name="validityCheck">Indicates whether to read
/// a countersign before the string and perform data-validity check.</param>
public static void SkipString(this Stream stream, bool validityCheck = true)
{
if (!validityCheck || stream.Check((Int64)17))
{
byte para = (byte)stream.ReadByte();
if (para == byte.MaxValue)
{
return;
}
if (para <= 0x0F)
{
_sfstring(stream); return;
}
int len = 0;
if (para.GetBitAt6())
{
len += stream.ReadByte();
}
else if (para.GetBitAt7())
{
len += stream.ReadUInt16();
}
else
{
len += Convert.ToInt32(stream.ReadUInt32());
}
byte cp = (byte)(para & 0x30);
if (cp == 0x00)
{
len += 2;
}
stream.Seek(len, SeekOrigin.Current);
}
else
{
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
}
/// <summary>
/// Reads a string dictionary from this stream.
/// </summary>
/// <param name="stream">The stream to read from.</param>
/// <param name="validityCheck">
/// <c>true</c> if a code is written into the stream
/// and any reading method can check this code to determine whether the data is not corrupted.
/// </param>
/// <returns>A string dictionary read from the stream.</returns>
public static Dictionary <string, string> ReadStringDictionary <T>(this Stream stream, bool validityCheck = true)
{
if (validityCheck)
{
stream.Check(IOChecks.StringList);
}
var count = stream.ReadInt32();
if (count == 0)
{
return(null);
}
var set = new Dictionary <string, string>();
while (count-- > 0)
{
set.Add(stream.ReadString(false), stream.ReadString(false));
}
return(set);
}
/// <summary>
/// Reads a byte array from this stream.
/// </summary>
/// <param name="stream">The stream to read from.</param>
/// <param name="validityCheck">Set this parameter <c>true</c> if there is a check code before the array to detect data corruption; otherwise, set this <c>false</c>.</param>
/// <returns>
/// The byte array read from the stream.
/// </returns>
/// <exception cref="System.IO.InvalidDataException">Raises if data in the stream is corrupted.</exception>
public static byte[] ReadByteArray(this Stream stream, bool validityCheck)
{
if (!validityCheck || stream.Check((Int64)37))
{
var len = stream.ReadInt32();
if (len == 0)
{
return(null);
}
else if (len < 0)
{
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
return(stream.ReadBytes(len));
}
else
{
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
}
/// <summary>
/// Reads a string hash set from this stream.
/// </summary>
/// <param name="stream">The stream to read from.</param>
/// <param name="validityCheck">
/// <c>true</c> if a code is written into the stream
/// and any reading method can check this code to determine whether the data is not corrupted.
/// </param>
/// <returns>A string hash set read from the stream.</returns>
public static HashSet <string> ReadStringHashSet(this Stream stream, bool validityCheck = true)
{
if (validityCheck)
{
stream.Check((Int64)18);
}
var count = stream.ReadInt32();
if (count == 0)
{
return(null);
}
var set = new HashSet <string>();
while (count-- > 0)
{
set.Add(stream.ReadString(false));
}
return(set);
}
/// <summary>
/// Reads a System.DateTime integer array from this stream. The method does not require an argument specifying the length of the array; <seealso cref="ReadDateTimes"/>.
/// </summary>
/// <param name="stream">The stream to read.</param>
/// <param name="validityCheck">Set this parameter <c>true</c> if there is a check code before the array to prevent data corruption; otherwise, set this <c>false</c>.</param>
/// <param name="buffer">A byte array used to temporarily store data read from the stream.</param>
/// <returns>
/// The System.DateTime array read from the stream.
/// </returns>
/// <exception cref="System.IO.InvalidDataException">Raises if data in the stream is corrupted.</exception>
public static DateTime[] ReadDateTimeArray(this Stream stream, byte[] buffer, bool validityCheck = true)
{
if (!validityCheck || stream.Check((long)37))
{
var len = stream.ReadInt32(buffer);
if (len == 0)
{
return(null);
}
else if (len < 0)
{
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
return(stream.ReadDateTimes(len, buffer));
}
else
{
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
}
/// <summary>
/// Reads a System.DateTime integer array from this stream into the specified buffer. This method avoids an additional data copy to enchance performance.
/// </summary>
/// <param name="stream">The stream to read.</param>
/// <param name="validityCheck">Set this parameter <c>true</c> if there is a check code before the array to prevent data corruption; otherwise, set this <c>false</c>.</param>
/// <param name="buffer">A byte array used to store data read from the stream. You may later get a DateTime pointer of this array for fast iteration.</param>
/// <returns>
/// true if the array read from the stream is not empty; otherwise, false.
/// </returns>
/// <exception cref="System.IO.InvalidDataException">Raises if data in the stream is corrupted.</exception>
public static unsafe bool ReadDateTimeArrayToBuffer(this Stream stream, byte[] buffer, bool validityCheck = true)
{
if (!validityCheck || stream.Check((long)37))
{
var len = stream.ReadInt32(buffer);
if (len == 0)
{
return(false);
}
else if (len < 0)
{
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
stream.Read(buffer, 0, len * sizeof(DateTime));
return(true);
}
else
{
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
}
public static IEnumerator <string> ReadStringListEnumerator(this Stream stream, bool validityCheck = true)
{
if (!validityCheck || stream.Check(IOChecks.StringList))
{
var stringCount = stream.ReadInt32();
if (stringCount < 0)
{
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
else if (stringCount != 0)
{
for (int i = 0; i < stringCount; ++i)
{
yield return(stream.ReadString(false));
}
}
}
else
{
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
}
static void _innerWriteList <T>(_writeItem <T> write, Stream stream, IList <T> list, WritingMode mode = WritingMode.New, bool validityCheck = true)
{
//TODO need to deal with objects of variable binary length
if (mode == WritingMode.New)
{
if (validityCheck)
{
stream.WriteCheckCode((long)29);
}
if (list == null || list.Count == 0)
{
stream.WriteInt32(0); // current block length (total number of available slots for the objects to write)
stream.WriteInt32(0); // current block occupancy (actual number of objects in the current block)
stream.WriteInt64(0); // next block position
return;
}
stream.WriteInt32(list.Count);
stream.WriteInt32(list.Count);
stream.WriteInt64(0);
for (var i = 0; i < list.Count; i++)
{
write(stream, list[i]);
}
}
else if (mode == WritingMode.Override)
{
if (!validityCheck || stream.Check((Int64)29))
{
var i = 0;
var totalItemCountToWrite = list.Count;
while (true)
{
var count = stream.ReadInt32();
if (list.Count == 0)
{
stream.SkipInt32();
stream.WriteInt32(0); // writes occupancy as zero
return;
}
var occupancyCountPtrPos = stream.Position;
stream.SkipInt32();
var nextPtrPos = stream.Position;
var nextBlockPosition = stream.ReadInt64();
var oi = i;
for (; count > 0 && i < totalItemCountToWrite; count--, i++)
{
write(stream, list[i]);
}
var currPos = stream.Position;
stream.SeekTo(occupancyCountPtrPos);
stream.WriteInt32(i - oi);
stream.SeekTo(currPos);
if (i < totalItemCountToWrite)
{
if (nextBlockPosition == 0)
{
stream.SeekTo(nextPtrPos); // writes the position of the new block
stream.WriteInt64(stream.Length);
stream.SeekToEnd();
stream.WriteInt32(totalItemCountToWrite - i);
stream.WriteInt32(totalItemCountToWrite - i);
stream.WriteInt64(0);
for (; i < totalItemCountToWrite; i++)
{
write(stream, list[i]);
}
break;
}
else
{
stream.SeekTo(nextBlockPosition);
}
}
else
{
break;
}
}
}
else
{
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
}
}
/// <summary>
/// Writes a set of objects, each of them fetched from an enumerator, to this stream.
/// </summary>
/// <param name="stream">A <see cref="System.IO.Stream"/>.</param>
/// <param name="enumerator">An enumerator used to get each object.</param>
/// <param name="mode">Indicates whether to override existing list or create a new list in the stream.</param>
/// <param name="converter">A delegate used to convert each item in the list to a byte array.</param>
/// <param name="validityCheck">Indicates whether to write a validity-check countersign before the list in the stream.</param>
public static void WriteObjects <T>(this Stream stream, IEnumerator enumerator, WritingMode mode,
ObjectToBytesConverter <T> converter, bool validityCheck = true)
{
if (mode == WritingMode.New)
{
if (validityCheck)
{
stream.WriteCheckCode((Int64)29);
}
if (enumerator.MoveNext())
{
_writeEnumeratorToEnd(stream, enumerator, converter, validityCheck);
}
else
{
stream.WriteInt32(0);
stream.WriteInt32(0);
stream.WriteInt64(0);
}
}
else
{
if (!validityCheck || stream.Check((Int64)29))
{
int i = 0;
bool moreObjs = enumerator.MoveNext();
if (!moreObjs)
{
stream.SkipInt32();
stream.WriteInt32(0);
var next = stream.ReadInt64();
stream.WriteInt64(-Math.Abs(next));
return;
}
while (moreObjs)
{
var len = stream.ReadInt32();
var olen = len;
var usedLenPos = stream.Position;
var usedLen = stream.ReadInt32();
var nextPtrPos = stream.Position;
var next = stream.ReadInt64();
int objLen;
for (; len > 0 && moreObjs; len -= objLen, i++)
{
var b = converter((T)enumerator.Current);
objLen = stream._byteArrayOccupancy(b, validityCheck);
if (objLen > len)
{
break;
}
else
{
stream.WriteByteArray(b, validityCheck);
moreObjs = enumerator.MoveNext();
}
}
var nUsedLen = olen - len;
var currPos = stream.Position;
stream.SeekTo(usedLenPos);
stream.WriteInt32(nUsedLen);
stream.SeekTo(currPos);
if (moreObjs)
{
if (next == 0)
{
stream.SeekTo(nextPtrPos);
stream.WriteInt64(stream.Length);
stream.SeekToEnd();
_writeEnumeratorToEnd(stream, enumerator, converter, validityCheck);
break;
}
else
{
if (next < 0)
{
stream.SeekTo(nextPtrPos);
next = -next;
stream.WriteInt64(next);
}
stream.SeekTo(next);
}
}
else
{
if (next != 0)
{
currPos = stream.Position;
stream.SeekTo(nextPtrPos);
stream.WriteInt64(-Math.Abs(next));
stream.SeekTo(currPos);
break;
}
}
}
}
else
{
throw new InvalidDataException(IOResources.ERR_StreamExtension_DataIrrecognizable);
}
}
}