/// <summary>
/// Returns an array of <see cref="DateTime"/> instances read from the <paramref name="stream"/>.
/// </summary>
/// <param name="stream">The extended <see cref="Stream"/> instance.</param>
/// <param name="count">The number of values to read.</param>
/// <param name="coding">The <see cref="DateTimeCoding"/> in which the data is stored.</param>
/// <param name="converter">The <see cref="ByteConverter"/> to use for converting multibyte data.</param>
/// <returns>The array of values read from the current stream.</returns>
public static DateTime[] ReadDateTimes(this Stream stream, int count,
DateTimeCoding coding = DateTimeCoding.NetTicks, ByteConverter converter = null)
{
converter = converter ?? ByteConverter.System;
return(ReadMany(stream, count,
() => ReadDateTime(stream, coding, converter)));
}
/// <summary>
/// Writes a <see cref="DateTime"/> value asynchronously to the <paramref name="stream"/>.
/// </summary>
/// <param name="stream">The extended <see cref="Stream"/> instance.</param>
/// <param name="value">The value to write.</param>
/// <param name="coding">The <see cref="DateTimeCoding"/> in which the data is stored.</param>
/// <param name="converter">The <see cref="ByteConverter"/> to use for converting multibyte data.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
public static async Task WriteAsync(this Stream stream, DateTime value,
DateTimeCoding coding = DateTimeCoding.NetTicks, ByteConverter converter = null,
CancellationToken cancellationToken = default(CancellationToken))
{
converter = converter ?? ByteConverter.System;
switch (coding)
{
case DateTimeCoding.NetTicks:
await WriteAsync(stream, value.Ticks, converter, cancellationToken);
break;
case DateTimeCoding.CTime:
await WriteAsync(stream, (UInt32)GetCTimeTicks(value), converter,
cancellationToken);
break;
case DateTimeCoding.CTime64:
await WriteAsync(stream, (UInt64)GetCTimeTicks(value), converter,
cancellationToken);
break;
default:
throw new ArgumentException($"Invalid {nameof(DateTimeCoding)}.", nameof(coding));
}
}
/// <summary>
/// Returns an array of <see cref="DateTime"/> instances read asynchronously from the <paramref name="stream"/>.
/// </summary>
/// <param name="stream">The extended <see cref="Stream"/> instance.</param>
/// <param name="count">The number of values to read.</param>
/// <param name="coding">The <see cref="DateTimeCoding"/> in which the data is stored.</param>
/// <param name="converter">The <see cref="ByteConverter"/> to use for converting multibyte data.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
/// <returns>The array of values read from the current stream.</returns>
public static async Task <DateTime[]> ReadDateTimesAsync(this Stream stream, int count,
DateTimeCoding coding = DateTimeCoding.NetTicks, ByteConverter converter = null,
CancellationToken cancellationToken = default(CancellationToken))
{
converter = converter ?? ByteConverter.System;
return(await ReadManyAsync(stream, count,
() => ReadDateTimeAsync(stream, coding, converter, cancellationToken)));
}
/// <summary>
/// Writes an enumerable of <see cref="DateTime"/> values to the <paramref name="stream"/>.
/// </summary>
/// <param name="stream">The extended <see cref="Stream"/> instance.</param>
/// <param name="values">The values to write.</param>
/// <param name="coding">The <see cref="DateTimeCoding"/> in which the data is stored.</param>
/// <param name="converter">The <see cref="ByteConverter"/> to use for converting multibyte data.</param>
public static void Write(this Stream stream, IEnumerable <DateTime> values,
DateTimeCoding coding = DateTimeCoding.NetTicks, ByteConverter converter = null)
{
converter = converter ?? ByteConverter.System;
foreach (var value in values)
{
Write(stream, value, coding, converter);
}
}
/// <summary>
/// Writes an enumerable of <see cref="DateTime"/> asynchronously values to the <paramref name="stream"/>.
/// </summary>
/// <param name="stream">The extended <see cref="Stream"/> instance.</param>
/// <param name="values">The values to write.</param>
/// <param name="coding">The <see cref="DateTimeCoding"/> in which the data is stored.</param>
/// <param name="converter">The <see cref="ByteConverter"/> to use for converting multibyte data.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
public static async Task WriteAsync(this Stream stream, IEnumerable <DateTime> values,
DateTimeCoding coding = DateTimeCoding.NetTicks, ByteConverter converter = null,
CancellationToken cancellationToken = default(CancellationToken))
{
converter = converter ?? ByteConverter.System;
foreach (var value in values)
{
await WriteAsync(stream, value, coding, converter, cancellationToken);
}
}
// ---- CONSTRUCTORS -------------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="BinaryStream"/> class with the given default configuration.
/// </summary>
/// <param name="baseStream">The output stream.</param>
/// <param name="converter">The <see cref="ByteConverter"/> to use. Defaults to
/// <see cref="ByteConverter.System"/>.</param>
/// <param name="encoding">The character encoding to use. Defaults to <see cref="Encoding.UTF8"/>.</param>
/// <param name="booleanCoding">The <see cref="BinaryData.BooleanCoding"/> data format to use for
/// <see cref="Boolean"/> values.</param>
/// <param name="dateTimeCoding">The <see cref="BinaryData.DateTimeCoding"/> data format to use for
/// <see cref="DateTime"/> values.</param>
/// <param name="stringCoding">The <see cref="BinaryData.StringCoding"/> data format to use for
/// <see cref="String"/> values.</param>
/// <param name="leaveOpen"><c>true</c> to leave the base stream open after the <see cref="BinaryStream"/>
/// object is disposed; otherwise <c>false</c>.</param>
/// <exception cref="ArgumentException">The stream does not support writing or is already closed.</exception>
/// <exception cref="ArgumentNullException">output is null.</exception>
public BinaryStream(Stream baseStream, ByteConverter converter = null, Encoding encoding = null,
BooleanCoding booleanCoding = BooleanCoding.Byte, DateTimeCoding dateTimeCoding = DateTimeCoding.NetTicks,
StringCoding stringCoding = StringCoding.VariableByteCount, bool leaveOpen = false)
{
BaseStream = baseStream;
ByteConverter = converter;
Encoding = encoding;
BooleanCoding = booleanCoding;
DateTimeCoding = dateTimeCoding;
StringCoding = stringCoding;
_leaveOpen = leaveOpen;
}
// ---- METHODS (PUBLIC) ---------------------------------------------------------------------------------------
// ---- Read ----
/// <summary>
/// Returns a <see cref="DateTime"/> instance read from the <paramref name="stream"/>.
/// </summary>
/// <param name="stream">The extended <see cref="Stream"/> instance.</param>
/// <param name="coding">The <see cref="DateTimeCoding"/> in which the data is stored.</param>
/// <param name="converter">The <see cref="ByteConverter"/> to use for converting multibyte data.</param>
/// <returns>The value read from the current stream.</returns>
public static DateTime ReadDateTime(this Stream stream, DateTimeCoding coding = DateTimeCoding.NetTicks,
ByteConverter converter = null)
{
switch (coding)
{
case DateTimeCoding.NetTicks:
return(ReadDateTimeAsNetTicks(stream, converter));
case DateTimeCoding.CTime:
return(ReadDateTimeAsCTime(stream, converter));
case DateTimeCoding.CTime64:
return(ReadDateTimeAsCTime64(stream, converter));
default:
throw new ArgumentException($"Invalid {nameof(DateTimeCoding)}.", nameof(coding));
}
}
/// <summary>
/// Returns a <see cref="DateTime"/> instance read asynchronously from the <paramref name="stream"/>.
/// </summary>
/// <param name="stream">The extended <see cref="Stream"/> instance.</param>
/// <param name="coding">The <see cref="DateTimeCoding"/> in which the data is stored.</param>
/// <param name="converter">The <see cref="ByteConverter"/> to use for converting multibyte data.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
/// <returns>The value read from the current stream.</returns>
public static async Task <DateTime> ReadDateTimeAsync(this Stream stream,
DateTimeCoding coding = DateTimeCoding.NetTicks, ByteConverter converter = null,
CancellationToken cancellationToken = default(CancellationToken))
{
switch (coding)
{
case DateTimeCoding.NetTicks:
return(await ReadDateTimeAsNetTicksAsync(stream, converter, cancellationToken));
case DateTimeCoding.CTime:
return(await ReadDateTimeAsCTimeAsync(stream, converter, cancellationToken));
case DateTimeCoding.CTime64:
return(await ReadDateTimeAsCTime64Async(stream, converter, cancellationToken));
default:
throw new ArgumentException($"Invalid {nameof(DateTimeCoding)}.", nameof(coding));
}
}
// ---- Write ----
/// <summary>
/// Writes a <see cref="DateTime"/> value to the <paramref name="stream"/>.
/// </summary>
/// <param name="stream">The extended <see cref="Stream"/> instance.</param>
/// <param name="value">The value to write.</param>
/// <param name="coding">The <see cref="DateTimeCoding"/> in which the data is stored.</param>
/// <param name="converter">The <see cref="ByteConverter"/> to use for converting multibyte data.</param>
public static void Write(this Stream stream, DateTime value, DateTimeCoding coding = DateTimeCoding.NetTicks,
ByteConverter converter = null)
{
converter = converter ?? ByteConverter.System;
switch (coding)
{
case DateTimeCoding.NetTicks:
Write(stream, value.Ticks, converter);
break;
case DateTimeCoding.CTime:
Write(stream, (UInt32)GetCTimeTicks(value), converter);
break;
case DateTimeCoding.CTime64:
Write(stream, (UInt64)GetCTimeTicks(value), converter);
break;
default:
throw new ArgumentException($"Invalid {nameof(DateTimeCoding)}.", nameof(coding));
}
}
/// <summary>
/// Writes an enumerable of <see cref="DateTime"/> values asynchronously to the <paramref name="stream"/>.
/// </summary>
/// <param name="stream">The extended <see cref="Stream"/> instance.</param>
/// <param name="values">The values to write.</param>
/// <param name="coding">The <see cref="DateTimeCoding"/> in which the data is stored.</param>
/// <param name="converter">The <see cref="ByteConverter"/> to use for converting multibyte data.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
public static async Task WriteDateTimesAsync(this Stream stream, IEnumerable <DateTime> values,
DateTimeCoding coding = DateTimeCoding.NetTicks, ByteConverter converter = null,
CancellationToken cancellationToken = default(CancellationToken))
{
await WriteAsync(stream, values, coding, converter, cancellationToken);
}
/// <summary>
/// Writes an enumerable of <see cref="DateTime"/> values to the <paramref name="stream"/>.
/// </summary>
/// <param name="stream">The extended <see cref="Stream"/> instance.</param>
/// <param name="values">The values to write.</param>
/// <param name="coding">The <see cref="DateTimeCoding"/> in which the data is stored.</param>
/// <param name="converter">The <see cref="ByteConverter"/> to use for converting multibyte data.</param>
public static void WriteDateTimes(this Stream stream, IEnumerable <DateTime> values,
DateTimeCoding coding = DateTimeCoding.NetTicks, ByteConverter converter = null)
{
Write(stream, values, coding, converter);
}
/// <summary>
/// Writes a <see cref="DateTime"/> value to the <paramref name="stream"/>.
/// </summary>
/// <param name="stream">The extended <see cref="Stream"/> instance.</param>
/// <param name="value">The value to write.</param>
/// <param name="coding">The <see cref="DateTimeCoding"/> in which the data is stored.</param>
/// <param name="converter">The <see cref="ByteConverter"/> to use for converting multibyte data.</param>
public static void WriteDateTime(this Stream stream, DateTime value,
DateTimeCoding coding = DateTimeCoding.NetTicks, ByteConverter converter = null)
{
Write(stream, value, coding, converter);
}
