ToSeekableInputStream.h File Reference

#include "Stroika/Foundation/StroikaPreComp.h"
#include "Stroika/Foundation/Streams/InputStream.h"
#include "Stroika/Foundation/Traversal/Iterable.h"
#include "ToSeekableInputStream.inl"

Go to the source code of this file.

Namespaces
namespace	Stroika::Foundation

Functions
template<typename ELEMENT_TYPE >
auto	Stroika::Foundation::Streams::ToSeekableInputStream::New (const Ptr< ELEMENT_TYPE > &in) -> Ptr< ELEMENT_TYPE >

Detailed Description

Note

Code-Status: Beta

Definition in file ToSeekableInputStream.h.

Function Documentation

New()

template<typename ELEMENT_TYPE >

auto Stroika::Foundation::Streams::ToSeekableInputStream::New

(

const Ptr< ELEMENT_TYPE > &

in

)

-> Ptr<ELEMENT_TYPE>

Not all input streams are seekable, but throwing a little memory at it, its easy to assure they are all seekable.

That's what this utility does: maps the given input stream into a functionally identical one, except possibly adding seekability.

If the argument stream is already seekable, New () just returns its argument (so perhaps a misnomer but I thought better to follow factory pattern).

Example Usage

InputStream::Ptr<byte> in = ToSeekableInputStream::New<byte> (existingInputStream);

A socket is the canonical stream you might want this for: there is nowhere to seek back TO, because the bytes are gone once read (IO::Network::SocketStream::IsSeekable () returns false; so does InputStreamFromStdIStream constructed eNotSeekable - over cin, say). Wrapping one lets code that must read the same input twice do so:

Example Usage

SocketStream::Ptr      socketStream = SocketStream::New (connectionSocket);
InputStream::Ptr<byte> in          = ToSeekableInputStream::New<byte> (socketStream);
DoFirstPass (in);
in.Seek (0);        // legal only because of the wrapper; socketStream itself cannot seek
DoSecondPass (in);  // sees the very same bytes again, served out of the cache

That two-pass shape is why this exists: see Providers::LibXML2::Provider::SAXParse (), which needs it when asked to both validate against a schema and report parse events, because that reads twice.

Note

this helper does not require it be given the input stream at SeekOffset 0, but for pretty obvious reasons it cannot produce a stream that permits seeking backwards from where it starts. This is checked via assertions.

this helper may be problematic with very large streams, as it caches the stream in memory as it reads, and would eventually run out.

ELEMENT_TYPE is effectively limited to byte today: SeekRead () accumulates into the cache through a hardcoded 'byte' buffer, so instantiating this for any other element type will not compile.

Definition at line 16 of file ToSeekableInputStream.inl.