Memory streams

// Code that reads and writes bytes is usually written against the `Reader` and `Writer`
// interfaces rather than against `File`, and the Binary lesson's `ReadUint16` and `WriteUint16`
// are written that way. A memory stream is a `Reader` or `Writer` whose bytes live in memory, so
// the same code can run without a file at all:
//
//     ByteWriter    a `Writer` that keeps everything written in a block it grows as needed;
//                   `Bytes()` hands the bytes back
//     ByteReader    a `Reader` over a slice of bytes you already have; at the end it fails
//                   with `EndOfStream`, like a file
//
// That is how a format is tested without touching the disk, how a message is built in memory
// before it is sent in one piece, and how bytes that arrived some other way — over a network,
// embedded in the program — are read with the code that reads files.
//
// The file this program also writes lives in its package's `Bin/` folder, and is deleted at
// the end.
import Allocator::{ Allocator, SystemAllocator };
import FileSystem::{ DeleteFile, File, OpenOptions };
import Io::{ ByteReader, ByteWriter, Endian, IoError, Print, PrintLine, ReadInt16, ReadUint16,
             Reader, WriteInt16, WriteUint16, Writer };
import Path::{ OsString, Path };
import Text::TextError;

// A sensor's reading, in tenths of a degree: 215 is 21.5 °C.
struct Reading {
    sensor: uint16;
    tenths: int16;
}

// The format: a count, then each reading's sensor and temperature, two bytes each, little endian.
// It takes any `Writer`, so it neither knows nor cares where the bytes go.
func WriteReadings(out: &var Writer, readings: Reading[..]) -> ! IoError {
    WriteUint16(out, Endian::Little, readings.length as uint16)?;
    for reading in readings {
        WriteUint16(out, Endian::Little, reading.sensor)?;
        WriteInt16(out, Endian::Little, reading.tenths)?;
    }
}

// The other half of the format, from any `Reader`. A stream that ends part-way fails it.
func ReadReadings(input: &var Reader) -> ! IoError {
    let count = ReadUint16(input, Endian::Little)?;
    for _ in 0..count {
        let sensor = ReadUint16(input, Endian::Little)?;
        let tenths = ReadInt16(input, Endian::Little)?;
        PrintLine("  sensor {}  {:.1} C", sensor, tenths as float64 / 10.0);
    }
}

func Main() -> ! IoError | TextError {
    var system = SystemAllocator();
    let allocator: Allocator = system;
    let readings: Reading[3] = [Reading { sensor: 1, tenths: 215 },
                                Reading { sensor: 2, tenths: 198 },
                                Reading { sensor: 7, tenths: 230 }];

    // Into memory. The writer grows its block as bytes arrive.
    var memory = ByteWriter::New(allocator);
    WriteReadings(memory, readings[..])?;
    Print("memory: {} bytes:", memory.Length());
    for byte in memory.Bytes() {
        Print(" {:02x}", byte as uint8);
    }
    PrintLine();

    // Back out of memory, with the code that would read a file. Reading moves the reader's
    // position along, so it must be `var`; a `let` reader is refused:
    //
    //     error: argument 1 to 'ReadReadings' cannot borrow immutable 'reader' as
    //            '&var rux/io::Reader'
    var reader = ByteReader::New(memory.Bytes());
    ReadReadings(reader)?;

    // The same two functions, given a file.
    var holder = OsString::FromText(allocator, "Bin/readings.bin")?;
    let path = Path::FromView(holder.View());
    var writing = File::Open(allocator, path, OpenOptions::Writing())?;
    WriteReadings(writing, readings[..])?;
    writing.Close()?;
    var reading = File::Open(allocator, path, OpenOptions::Reading())?;
    PrintLine("file:   {} bytes", reading.Size()?);
    ReadReadings(reading)?;
    reading.Close()?;
    DeleteFile(allocator, path)?;

    // Damaged input, made without damaging a file: only the first 9 bytes of the 14.
    var cut = ByteReader::New(memory.Bytes()[..9]);
    PrintLine("cut:    9 bytes");
    ReadReadings(cut) catch {
        error if error.IsEnd() => {
            PrintLine("  ended inside a reading: refused");
        },
        error => fail error
    };
}