foobar2000_io::stream_reader

#include <filesystem.h>

Inheritance diagram for foobar2000_io::stream_reader:

Public Member Functions
virtual t_size	read (void *p_buffer, t_size p_bytes, abort_callback &p_abort)=0
template<typename T >
void	read_bendian_t (T &p_object, abort_callback &p_abort)
template<typename T >
void	read_lendian_t (T &p_object, abort_callback &p_abort)
virtual void	read_object (void *p_buffer, t_size p_bytes, abort_callback &p_abort)
template<typename T >
void	read_object_t (T &p_object, abort_callback &p_abort)
void	read_string (pfc::string_base &p_out, abort_callback &p_abort)
pfc::string	read_string (abort_callback &p_abort)
void	read_string_ex (pfc::string_base &p_out, t_size p_bytes, abort_callback &p_abort)
pfc::string	read_string_ex (t_size p_len, abort_callback &p_abort)
void	read_string_nullterm (pfc::string_base &out, abort_callback &abort)
void	read_string_raw (pfc::string_base &p_out, abort_callback &p_abort)
template<typename t_outArray >
void	read_till_eof (t_outArray &out, abort_callback &abort)
virtual t_filesize	skip (t_filesize p_bytes, abort_callback &p_abort)
virtual void	skip_object (t_filesize p_bytes, abort_callback &p_abort)
t_filesize	skip_till_eof (abort_callback &abort)

Protected Member Functions
	stream_reader ()
	~stream_reader ()

Detailed Description

Generic interface to read data from a nonseekable stream. Also see: stream_writer, file.
Error handling: all methods may throw exception_io or one of derivatives on failure; exception_aborted when abort_callback is signaled.

Definition at line 92 of file filesystem.h.

Constructor & Destructor Documentation

foobar2000_io::stream_reader::stream_reader ( )

inlineprotected

Definition at line 159 of file filesystem.h.

{}

foobar2000_io::stream_reader::~stream_reader ( )

inlineprotected

Definition at line 160 of file filesystem.h.

{}

Member Function Documentation

virtual t_size foobar2000_io::stream_reader::read ( void *  p_buffer, t_size  p_bytes, abort_callback &  p_abort  )

pure virtual

Attempts to reads specified number of bytes from the stream.

Parameters

p_buffer	Receives data being read. Must have at least p_bytes bytes of space allocated.
p_bytes	Number of bytes to read.
p_abort	abort_callback object signaling user aborting the operation.

Returns

Number of bytes actually read. May be less than requested when EOF was reached.

template<typename T >

void foobar2000_io::stream_reader::read_bendian_t ( T &  p_object, abort_callback &  p_abort  )

inline

Helper template built around read_object. Reads single raw object from the stream; corrects byte order assuming stream uses big endian order.

Parameters

p_object	Receives object read from the stream on success.
p_abort	abort_callback object signaling user aborting the operation.

Definition at line 126 of file filesystem.h.

{read_object_t(p_object,p_abort); byte_order::order_be_to_native_t(p_object);}

template<typename T >

void foobar2000_io::stream_reader::read_lendian_t ( T &  p_object, abort_callback &  p_abort  )

inline

Helper template built around read_object. Reads single raw object from the stream; corrects byte order assuming stream uses little endian order.

Parameters

p_object	Receives object read from the stream on success.
p_abort	abort_callback object signaling user aborting the operation.

Definition at line 122 of file filesystem.h.

{read_object_t(p_object,p_abort); byte_order::order_le_to_native_t(p_object);}

void stream_reader::read_object ( void *  p_buffer, t_size  p_bytes, abort_callback &  p_abort  )

virtual

Reads specified number of bytes from the stream. If requested amount of bytes can't be read (e.g. EOF), throws exception_io_data_truncation.

Parameters

p_buffer	Receives data being read. Must have at least p_bytes bytes of space allocated.
p_bytes	Number of bytes to read.
p_abort	abort_callback object signaling user aborting the operation.

Definition at line 590 of file filesystem.cpp.

                                                                                       {
    if (read(p_buffer,p_bytes,p_abort) != p_bytes) throw exception_io_data_truncation();
}

template<typename T >

void foobar2000_io::stream_reader::read_object_t ( T &  p_object, abort_callback &  p_abort  )

inline

Helper template built around read_object. Reads single raw object from the stream.

Parameters

p_object	Receives object read from the stream on success.
p_abort	abort_callback object signaling user aborting the operation.

Definition at line 118 of file filesystem.h.

{pfc::assert_raw_type<T>(); read_object(&p_object,sizeof(p_object),p_abort);}

void stream_reader::read_string	(	pfc::string_base &	p_out,
		abort_callback &	p_abort
	)

Helper function; reads a string (with a 32-bit header indicating length in bytes followed by UTF-8 encoded data without a null terminator).

Definition at line 709 of file filesystem.cpp.

{
    t_uint32 length;
    read_lendian_t(length,p_abort);
    read_string_ex(p_out,length,p_abort);
}

pfc::string stream_reader::read_string

(

abort_callback &

p_abort

)

Helper function; reads a string (with a 32-bit header indicating length in bytes followed by UTF-8 encoded data without a null terminator).

Definition at line 965 of file filesystem.cpp.

                                                             {
    t_uint32 len;
    read_lendian_t(len,p_abort);
    return read_string_ex(len,p_abort);
}

void stream_reader::read_string_ex	(	pfc::string_base &	p_out,
		t_size	p_bytes,
		abort_callback &	p_abort
	)

Helper function; reads a string of specified length from the stream.

Definition at line 689 of file filesystem.cpp.

                                                                                                 {
    const t_size expBase = 64*1024;
    if (p_bytes > expBase) {
        pfc::array_t<char> temp;
        t_size allocWalk = expBase;
        t_size done = 0;
        for(;;) {
            const t_size target = pfc::min_t(allocWalk, p_bytes);
            temp.set_size(target);
            read_object(temp.get_ptr() + done, target - done, p_abort);
            if (target == p_bytes) break;
            done = target;
            allocWalk <<= 1;
        }
        p_out.set_string(temp.get_ptr(), p_bytes);
    } else {
        pfc::string_buffer buf(p_out, p_bytes);
        read_object(buf.get_ptr(),p_bytes,p_abort);
    }
}

pfc::string stream_reader::read_string_ex	(	t_size	p_len,
		abort_callback &	p_abort
	)

Helper function; reads a string of specified length from the stream.

Definition at line 970 of file filesystem.cpp.

                                                                             {
    pfc::rcptr_t<pfc::string8> temp; temp.new_t();
    read_object(temp->lock_buffer(p_len),p_len,p_abort);
    temp->unlock_buffer();
    return pfc::string::t_data(temp);
}

void stream_reader::read_string_nullterm	(	pfc::string_base &	out,
		abort_callback &	abort
	)

Definition at line 1028 of file filesystem.cpp.

                                                                                       {
    enum { bufCount = 256 };
    char buffer[bufCount];
    out.reset();
    size_t w = 0;
    for(;;) {
        char & c = buffer[w];
        this->read_object( &c, 1, abort );
        if (c == 0) {
            out.add_string( buffer, w ); break;
        }
        if (++w == bufCount ) {
            out.add_string( buffer, bufCount ); w = 0;
        }
    }
}

void stream_reader::read_string_raw	(	pfc::string_base &	p_out,
		abort_callback &	p_abort
	)

Helper function; alternate way of storing strings; assumes string takes space up to end of stream.

Definition at line 716 of file filesystem.cpp.

                                                                                   {
    enum {delta = 256};
    char buffer[delta];
    p_out.reset();
    for(;;) {
        t_size delta_done;
        delta_done = read(buffer,delta,p_abort);
        p_out.add_string(buffer,delta_done);
        if (delta_done < delta) break;
    }
}

template<typename t_outArray >

void foobar2000_io::stream_reader::read_till_eof ( t_outArray &  out, abort_callback &  abort  )

inline

Definition at line 145 of file filesystem.h.

                                                                     {
            pfc::assert_raw_type<typename t_outArray::t_item>();
            const t_size itemWidth = sizeof(typename t_outArray::t_item);
            out.set_size(pfc::max_t<t_size>(1,256 / itemWidth)); t_size done = 0;
            for(;;) {
                t_size delta = out.get_size() - done;
                t_size delta2 = read(out.get_ptr() + done, delta * itemWidth, abort ) / itemWidth;
                done += delta2;
                if (delta2 != delta) break;
                out.set_size(out.get_size() << 1);
            }
            out.set_size(done);
        }

t_filesize stream_reader::skip ( t_filesize  p_bytes, abort_callback &  p_abort  )

virtual

Attempts to skip specified number of bytes in the stream.

Parameters

p_bytes	Number of bytes to skip.
p_abort	abort_callback object signaling user aborting the operation.

Returns

Number of bytes actually skipped, May be less than requested when EOF was reached.

Reimplemented in foobar2000_io::file.

Definition at line 602 of file filesystem.cpp.

{
    t_uint8 temp[256];
    t_filesize todo = p_bytes, done = 0;
    while(todo > 0) {
        t_size delta,deltadone;
        delta = sizeof(temp);
        if (delta > todo) delta = (t_size) todo;
        deltadone = read(temp,delta,p_abort);
        done += deltadone;
        todo -= deltadone;
        if (deltadone < delta) break;
    }
    return done;
}

void stream_reader::skip_object ( t_filesize  p_bytes, abort_callback &  p_abort  )

virtual

Skips specified number of bytes in the stream. If requested amount of bytes can't be skipped (e.g. EOF), throws exception_io_data_truncation.

Parameters

p_bytes	Number of bytes to skip.
p_abort	abort_callback object signaling user aborting the operation.

Definition at line 618 of file filesystem.cpp.

                                                                           {
    if (skip(p_bytes,p_abort) != p_bytes) throw exception_io_data_truncation();
}

t_filesize stream_reader::skip_till_eof

(

abort_callback &

abort

)

Definition at line 1045 of file filesystem.cpp.

                                                              {
    t_filesize atOnce = 1024 * 1024;
    t_filesize done = 0;
    for (;; ) {
        abort.check();
        t_filesize did = this->skip(atOnce, abort);
        done += did;
        if (did != atOnce) break;
    }
    return done;
}

---

The documentation for this class was generated from the following files:

• foobar2000/SDK/filesystem.h
• foobar2000/SDK/filesystem.cpp