/// <summary>
/// Writes blocks of bytes to the current sink using data read from a list.
/// </summary>
/// <param name="sink"></param>
/// <param name="source"></param>
/// <param name="offset"></param>
/// <param name="count"></param>
/// <param name="bufferSize">
/// The size of the temporary buffer used to copy elements from the provided source.
/// </param>
internal static void Write(ITriflesByteWriter sink, IList <byte> source, int offset, int count, int bufferSize = 0)
{
Checker.NotNull(sink, "sink");
Checker.NotNull(source, "source");
Checker.SpanInRange(source.Count, offset, count, "offset", "count");
WriteNoCheck(sink, source, offset, count, bufferSize);
}
internal static void ReadFully(ITriflesByteReader source, byte[] buffer, int offset, int count)
{
Checker.NotNull(source, "source");
Checker.NotNull(buffer, "buffer");
Checker.SpanInRange(buffer.Length, offset, count, "offset", "count");
ReadFullyNoCheck(source, buffer, offset, count);
}
public StreamTriflesByteWriter(Stream sink)
{
Checker.NotNull(sink, "sink");
if (!sink.CanWrite)
{
throw new ArgumentException("This stream does not support writing.", "sink");
}
this.sink = sink;
}
internal static IEnumerable <int> ReadViaArray(ITriflesByteReader source, ulong maxCount, byte[] buffer, bool requireFullCount)
{
Checker.NotNull(buffer, "buffer");
if (maxCount > 0)
{
EnsureBufferNonZero(buffer);
}
return(ReadViaArrayNoCheck(source, maxCount, buffer, requireFullCount));
}
public StreamTriflesByteReader(Stream source)
{
Checker.NotNull(source, "source");
if (!source.CanRead)
{
throw new ArgumentException("This stream does not support reading.", "source");
}
this.source = source;
}
// Pre-check parameters for Get*Bytes()
private static void CheckGetNBytes(IList <byte> value, int startIndex, int count)
{
Checker.NotNull(value, "value");
int size = value.Count;
if (startIndex < 0 || startIndex > size - count)
{
throw new ArgumentOutOfRangeException("startIndex");
}
}
internal static void ReadViaArray(ITriflesByteReader source, ulong maxCount, Action <byte[], int, int> fillAction, byte[] buffer = null, bool requireFullCount = false)
{
Checker.NotNull(fillAction, "fillAction");
if (buffer == null)
{
buffer = new byte[MathTrifles.Min(maxCount, DefaultReadBufferSize)];
}
foreach (var countThisPass in ReadViaArray(source, maxCount, buffer, requireFullCount))
{
fillAction(buffer, 0, countThisPass);
}
}
internal static void ReadViaArray(ITriflesByteReader source, Action <byte[], int, int> fillAction, byte[] buffer = null)
{
Checker.NotNull(fillAction, "fillAction");
if (buffer == null)
{
buffer = new byte[DefaultReadBufferSize];
}
foreach (var countThisPass in ReadViaArray(source, buffer))
{
fillAction(buffer, 0, countThisPass);
}
}
// Pre-check parameters for Swap*Bytes()
private static void CheckSwapN(byte[] buffer, int startIndex, int length)
{
Checker.NotNull(buffer, "buffer");
int size = buffer.Length;
if (startIndex < 0 || startIndex > size)
{
throw new ArgumentOutOfRangeException("startIndex");
}
if (startIndex > size - length)
{
throw new ArgumentOutOfRangeException("length");
}
}
public BinaryWriterTriflesByteWriter(BinaryWriter sink)
{
Checker.NotNull(sink, "sink");
this.sink = sink;
}
internal static ITriflesByteWriter ToTriflesByteWriter(ITriflesByteWriter sink)
{
Checker.NotNull(sink, "sink");
return(sink);
}
/// <summary>
/// Writes blocks of bytes to the current sink using data read from a sequence.
/// </summary>
/// <param name="sink"></param>
/// <param name="source"></param>
/// <param name="bufferSize">
/// The size of the temporary buffer used to copy elements from the provided source.
/// </param>
internal static void Write(ITriflesByteWriter sink, IEnumerable <byte> source, int bufferSize = 0)
{
Checker.NotNull(sink, "sink");
Checker.NotNull(source, "source");
WriteNoCheck(sink, source, bufferSize);
}
/// <summary>
/// Writes blocks of bytes to the current sink using data read from a list.
/// </summary>
/// <param name="sink"></param>
/// <param name="source"></param>
/// <param name="bufferSize">
/// The size of the temporary buffer used to copy elements from the provided source.
/// </param>
internal static void Write(ITriflesByteWriter sink, IList <byte> source, int bufferSize = 0)
{
Checker.NotNull(sink, "sink");
Checker.NotNull(source, "source");
WriteNoCheck(sink, source, 0, source.Count, bufferSize);
}
/// <summary>
/// Returns a deferred option that will contain the value of the dictionary at the given key,
/// if the dictionary contains the key, or an empty option otherwise. Since this option is
/// deferred, repeated evaluations (of <see cref="IOpt{T}.Fix()"/>, <see
/// cref="OptExtensions.Single{T}(IOpt{T})"/>, and so forth) reflect the current state of the
/// dictionary rather than its state as of the call to this method.
/// </summary>
/// <typeparam name="TKey"></typeparam>
/// <typeparam name="TValue"></typeparam>
/// <param name="source"></param>
/// <param name="key"></param>
/// <returns></returns>
public static IOpt <TValue> ValueOpt <TKey, TValue>(this IDictionary <TKey, TValue> source, TKey key)
{
Checker.NotNull(source, "source");
return(Opt.Defer(() => ValueFixOpt0(source, key)));
}
public BinaryReaderTriflesByteReader(BinaryReader source)
{
Checker.NotNull(source, "source");
this.source = source;
}
internal static ITriflesByteReader ToTriflesByteReader(ITriflesByteReader source)
{
Checker.NotNull(source, "source");
return(source);
}
/// <summary>
/// Creates an option whose value is the result of calling the given function.
/// </summary>
/// <param name="getCurrentFixedValue">A function that returns the current value of the option as an <see cref="Opt{T}"/>.</param>
public DeferredOpt(Func <Opt <T> > getCurrentFixedValue)
{
this.getCurrentFixedValue = Checker.NotNull(getCurrentFixedValue, "getCurrentFixedValue");
}
internal static IEnumerable <int> ReadViaArray(ITriflesByteReader source, byte[] buffer)
{
Checker.NotNull(buffer, "buffer");
EnsureBufferNonZero(buffer);
return(ReadViaArrayNoCheck(source, buffer));
}