std.Stream.InputStream convenience functions

[BBasile via Digitalmars-d]

On Sunday, 6 September 2015 at 02:19:41 UTC, bitwise wrote:
> On Saturday, 5 September 2015 at 23:00:43 UTC, BBasile wrote:
>> On Saturday, 5 September 2015 at 19:59:03 UTC, bitwise wrote:
>>> On Saturday, 5 September 2015 at 06:15:17 UTC, Jonathan M 
>>> Davis wrote:
>>>> [...]
>>>
>>> Thanks for the explanation, but could you give an example of 
>>> how Stream would be rangified?
>>
>> this was not addressed to me but here is how it should be done:
>>
>> ---
>> module runnable;
>>
>> import std.stdio;
>> import std.stream;
>> import std.algorithm;
>>
>> class RangifiedStream: MemoryStream
>> {
>>     auto range()
>>     {
>>         return Range(this);
>>     }
>>
>>     private struct Range
>>     {
>>         MemoryStream _str;
>>         ulong _curr;
>>
>>         this(MemoryStream str)
>>         {
>>             _str = str;
>>         }
>>
>>         void popFront()
>>         {
>>             _curr += 1;
>>         }
>>
>>         @property ubyte front()
>>         {
>>             ubyte result;
>>             _str.position = _curr;
>>             _str.read(result);
>>             _str.position = _str.position - 1;
>>             return result;
>>         }
>>
>>         @property bool empty()
>>         {
>>             return _curr == _str.size;
>>         }
>>     }
>> }
>>
>> void main(string[] args)
>> {
>>
>>     import std.range;
>>     assert( isInputRange!(RangifiedStream.Range));
>>
>>     RangifiedStream str = new RangifiedStream;
>>     ubyte[] src = [0,1,2,3,4,5,6,7,8,9];
>>     str.write(src);
>>
>>     str.range.each!(a => a.writeln);
>> }
>> ---
>>
>> The range has a reference to a stream. The range uses its own 
>> position and this is important since several ranges may 
>> co-exist at the same time. Here you just have a byte 
>> InputRange but it works...
>>
>> For FileStream the performances will be terrible (bad), 
>> because the position is hold by a a structure specific to the 
>> OS...
>>
>> I think I'll add this to my iz streams classes.
>
> If all we had was a flat array of bytes(or any uniform type), 
> then we wouldn't need a stream at all.
>
> My typical usage is something like this:
>
> int a = 1;
> float b = 2;
> string s = "3";
>
> MemoryStream ms = new MemoryStream();
> ms.write(a);
> ms.write(b);
> ms.write(s);
>
> // stash ms in a file, or send/receive over socket..
>
> int a = ms.readInt();
> float b = ms.readFloat();
> string s = ms.readString();
>
> doSomething(a, b, s);
>
> I'm not sure how you would go about rangifying something like 
> this.

Sorry but I just wanted to reply to your Q 'how Stream would be 
rangified?'. Put the primitives...period.

Obviously my previous example is not good because it's only for 
MemoryStream,
and OutputRange primitives miss.
Think more that the the Range will be defined for the Stream 
class:

---
struct StreamRange(ST, T)
if (is(ST : Stream))
{
     private:

         ulong _fpos, _bpos;
         ST _str;

     public:

         this(ST str)
         {
             _str = str;
             _bpos = str.size - T.sizeof;
         }

         @property T front()
         {
             T result;
             _str.position = _fpos;
             _str.read(&result, T.sizeof);
             _str.position = _fpos;
             return result;
         }

         @property T back()
         {
             T result;
             _str.position = _bpos;
             _str.read(&result, T.sizeof);
             _str.position = _bpos;
             return result;
         }

         @safe void popFront()
         {
             _fpos += T.sizeof;
         }

         @safe void popBack()
         {
             _bpos -= T.sizeof;
         }

         @property bool empty()
         {
             return (_fpos == _str.size) || (_fpos + T.sizeof > 
_str.size)
                     || (_bpos == 0) || (_bpos - T.sizeof < 0);
         }

         typeof(this) save()
         {
             typeof(this) result = typeof(this)(_str);
             result._fpos = _fpos;
             return result;
         }
}

// ....

auto rng = StreamRange!(MemoryStream,long)(instance);
auto rng = StreamRange!(FileStream,float)(instance);
---

Actually I have nothing against your helper functions (except 
that they don't make Streams compatible with std.algorithm 
functions).