jem::io Namespace Reference

This namespace contains classes and functions that provide support for input and output operations. More...

Classes
class	ArrayInputStream
class	ArrayOutputStream
class	BeginItem
class	BeginList
struct	BlankLine
class	BufferedInputStream
class	BufferedOutputStream
class	BufferedReader
class	BufferedWriter
class	CancelledIOException
class	CRCOutputStream
class	DataInput
class	DataInputStream
class	DataOutput
class	DataOutputStream
class	Deflator
class	DirListing
struct	EndItem
struct	EndList
class	EOFException
class	File
class	FileFlags
class	FileInfo
class	FileInputStream
class	FileName
class	FileOpenException
class	FileOutputStream
class	FileReader
class	FileStream
class	FileWriter
class	Fill
class	FilterInputStream
class	FilterOutputStream
class	FilterReader
class	FilterWriter
class	GzipFileReader
class	GzipFileWriter
class	GzipInputStream
class	GzipOutputStream
struct	Indent
class	Inflator
class	InputStream
class	InputStreamReader
class	IOException
	Signals an I/O error. More...
class	IOverflowException
class	LineNumberReader
class	Logger
class	NullInputStream
class	NullOutputStream
class	NullReader
class	NullTermReader
class	NullWriter
class	NumberFormat
class	NumberFormatter
class	ObjectInput
class	ObjectInputStream
class	ObjectOutput
class	ObjectOutputStream
class	ObjectStreamParams
struct	Outdent
class	OutputStream
class	OutputStreamWriter
class	PatternLogger
class	Pipe
class	PipedInputStream
class	PipedOutputStream
class	PipedReader
class	PipedWriter
class	PrefixWriter
class	PrintWriter
class	ReadBuffer
class	Reader
	Represents a text input stream. More...
class	Serializable
class	SerializationException
class	SimpleLogger
class	StderrWriter
class	StdinReader
class	StdoutWriter
class	StdTermReader
class	StringReader
class	StringWriter
class	SyncFailedException
class	TeeWriter
class	TermInput
class	TermReader
class	TextInput
	Provides an interface for reading text-based input. More...
class	TextOutput
	Provides an interface for writing text-based output. More...
class	WordCompleter
class	WriteBuffer
class	Writer
	Represents a text output stream. More...
class	ZipException
class	ZipInputStream
class	ZipOutputStream

Typedefs
typedef Deflator	ZlibDeflator
typedef Inflator	ZlibInflator

Enumerations
enum	ZipMode {   ZLIB_MODE,   RAW_ZLIB_MODE }

Functions
template<class Input >
void	decode (Input &in, bool &b)
template<class Input >
void	decode (Input &in, byte &b)
template<class Input >
void	decode (Input &in, char &c)
template<class Input >
void	decode (Input &in, short &i)
template<class Input >
void	decode (Input &in, unsigned short &i)
template<class Input >
void	decode (Input &in, int &i)
template<class Input >
void	decode (Input &in, unsigned int &i)
template<class Input >
void	decode (Input &in, lint &i)
template<class Input >
void	decode (Input &in, ulint &i)
template<class Input >
void	decode (Input &in, float &x)
template<class Input >
void	decode (Input &in, double &x)
template<class Input , class A , class B >
void	decode (Input &in, A &a, B &b)
template<class Input , class A , class B , class C >
void	decode (Input &in, A &a, B &b, C &c)
template<class Input , class A , class B , class C , class D >
void	decode (Input &in, A &a, B &b, C &c, D &d)
template<class Input , class A , class B , class C , class D , class E >
void	decode (Input &in, A &a, B &b, C &c, D &d, E &e)
template<class Input , class A , class B , class C , class D , class E , class F >
void	decode (Input &in, A &a, B &b, C &c, D &d, E &e, F &f)
template<class Input , class T >
void	decodeArray (Input &in, T *buf, idx_t len)
void	decodeError (const char *where)
void	decodeError (const char *where, const char *what)
template<class Input >
void	decodeArray (Input &in, bool *buf, idx_t n)
template<class Input >
void	decodeArray (Input &in, byte *buf, idx_t n)
template<class Input >
void	decodeArray (Input &in, char *buf, idx_t n)
template<class Input >
void	decodeArray (Input &in, short *buf, idx_t n)
template<class Input >
void	decodeArray (Input &in, int *buf, idx_t n)
template<class Input >
void	decodeArray (Input &in, lint *buf, idx_t n)
template<class Input >
void	decodeArray (Input &in, float *buf, idx_t n)
template<class Input >
void	decodeArray (Input &in, double *buf, idx_t n)
template<class Output >
void	encode (Output &out, bool b)
template<class Output >
void	encode (Output &out, byte b)
template<class Output >
void	encode (Output &out, char c)
template<class Output >
void	encode (Output &out, short i)
template<class Output >
void	encode (Output &out, int i)
template<class Output >
void	encode (Output &out, lint i)
template<class Output >
void	encode (Output &out, float x)
template<class Output >
void	encode (Output &out, double x)
template<class Output , class A , class B >
void	encode (Output &out, const A &a, const B &b)
template<class Output , class A , class B , class C >
void	encode (Output &out, const A &a, const B &b, const C &c)
template<class Output , class A , class B , class C , class D >
void	encode (Output &out, const A &a, const B &b, const C &c, const D &d)
template<class Output , class A , class B , class C , class D , class E >
void	encode (Output &out, const A &a, const B &b, const C &c, const D &d, const E &e)
template<class Output , class A , class B , class C , class D , class E , class F >
void	encode (Output &out, const A &a, const B &b, const C &c, const D &d, const E &e, const F &f)
template<class Output , class T >
void	encodeArray (Output &out, const T *buf, idx_t len)
template<class Output >
void	encodeArray (Output &out, const bool *buf, idx_t n)
template<class Output >
void	encodeArray (Output &out, const byte *buf, idx_t n)
template<class Output >
void	encodeArray (Output &out, const char *buf, idx_t n)
template<class Output >
void	encodeArray (Output &out, const short *buf, idx_t n)
template<class Output >
void	encodeArray (Output &out, const int *buf, idx_t n)
template<class Output >
void	encodeArray (Output &out, const lint *buf, idx_t n)
template<class Output >
void	encodeArray (Output &out, const float *buf, idx_t n)
template<class Output >
void	encodeArray (Output &out, const double *buf, idx_t n)
template<class Input >
void	decode (Input &in, FileInfo &info)
template<class Output >
void	encode (Output &out, const FileInfo &info)
void	print (PrintWriter &pr, const BeginList &list)
void	print (PrintWriter &pr, const BeginItem &item)
void	print (PrintWriter &pr, const EndItem &end)
void	print (PrintWriter &pr, const EndList &end)
void	decode (DataInput &in, NumberFormat &nf)
void	encode (DataOutput &out, const NumberFormat &nf)
template<class Input , class T >
void	decode (Input &in, Ref< T > &obj)
template<class Input >
void	decode (Input &in, Ref< Object > &obj)
template<class Output , class T >
void	encode (Output &out, const Ref< T > &obj)
Fill	fill (char ch, int end=48)
void	print (PrintWriter &out, const Space &sp)
void	print (PrintWriter &out, const EndLine &eol)
void	print (PrintWriter &out, const Indent &id)
void	print (PrintWriter &out, const Outdent &od)
void	print (PrintWriter &out, const BlankLine &bl)
void	print (PrintWriter &out, const Fill &fill)
bool	canZip ()
	Indicates whether data compression is supported. More...
template<class Iterator >
TextOutput &	printSequence (TextOutput &out, Iterator first, Iterator last, const char *separator)
	Prints a sequence of objects to a text output stream. More...
template<class Input , class T >
void	decode (Input &in, std::complex< T > &z)
template<class Output , class T >
void	encode (Output &out, const std::complex< T > &z)
template<class Output , class T >
void	print (Output &out, const std::complex< T > &z)

Variables
const BeginList	beginList
const BeginItem	beginItem
const EndItem	endItem
const EndList	endList
const byte	GZIP_MAGIC [2]
const int	DEFAULT_BUFSIZE
const Fill	dots
const Fill	spaces
const Indent	indent
const Outdent	outdent
const BlankLine	blankLine

Detailed Description

The namespace jem::io contains classes and functions that provide support for input and output operations, and object serialization. In particular, it exports the classes InputStream, OutputStream, Reader and Writer. The first two represent data streams while the last two represent text streams.

All classes and functions in this namespace can be found in the package jem.io.

Typedef Documentation

typedef Deflator jem::io::ZlibDeflator

typedef Inflator jem::io::ZlibInflator

Enumeration Type Documentation

enum jem::io::ZipMode

Enumerator
ZLIB_MODE
RAW_ZLIB_MODE

Function Documentation

template<class Input >

void jem::io::decode	(	Input &	in,
		bool &	b
	)

Examples:

DataParser.cpp.

template<class Input >

void jem::io::decode	(	Input &	in,
		byte &	b
	)

template<class Input >

void jem::io::decode	(	Input &	in,
		char &	c
	)

template<class Input >

void jem::io::decode	(	Input &	in,
		short &	i
	)

template<class Input >

void jem::io::decode	(	Input &	in,
		unsigned short &	i
	)

template<class Input >

void jem::io::decode	(	Input &	in,
		int &	i
	)

template<class Input >

void jem::io::decode	(	Input &	in,
		unsigned int &	i
	)

template<class Input >

void jem::io::decode	(	Input &	in,
		lint &	i
	)

template<class Input >

void jem::io::decode	(	Input &	in,
		ulint &	i
	)

template<class Input >

void jem::io::decode	(	Input &	in,
		float &	x
	)

template<class Input >

void jem::io::decode	(	Input &	in,
		double &	x
	)

template<class Input , class A , class B >

void jem::io::decode	(	Input &	in,
		A &	a,
		B &	b
	)

template<class Input , class A , class B , class C >

void jem::io::decode	(	Input &	in,
		A &	a,
		B &	b,
		C &	c
	)

template<class Input , class A , class B , class C , class D >

void jem::io::decode	(	Input &	in,
		A &	a,
		B &	b,
		C &	c,
		D &	d
	)

template<class Input , class A , class B , class C , class D , class E >

void jem::io::decode	(	Input &	in,
		A &	a,
		B &	b,
		C &	c,
		D &	d,
		E &	e
	)

template<class Input , class A , class B , class C , class D , class E , class F >

void jem::io::decode	(	Input &	in,
		A &	a,
		B &	b,
		C &	c,
		D &	d,
		E &	e,
		F &	f
	)

template<class Input , class T >

void jem::io::decodeArray	(	Input &	in,
		T *	buf,
		idx_t	len
	)

void jem::io::decodeError

(

const char *

where

)

void jem::io::decodeError	(	const char *	where,
		const char *	what
	)

template<class Input >

void jem::io::decodeArray	(	Input &	in,
		bool *	buf,
		idx_t	n
	)

template<class Input >

void jem::io::decodeArray	(	Input &	in,
		byte *	buf,
		idx_t	n
	)

template<class Input >

void jem::io::decodeArray	(	Input &	in,
		char *	buf,
		idx_t	n
	)

template<class Input >

void jem::io::decodeArray	(	Input &	in,
		short *	buf,
		idx_t	n
	)

template<class Input >

void jem::io::decodeArray	(	Input &	in,
		int *	buf,
		idx_t	n
	)

template<class Input >

void jem::io::decodeArray	(	Input &	in,
		lint *	buf,
		idx_t	n
	)

template<class Input >

void jem::io::decodeArray	(	Input &	in,
		float *	buf,
		idx_t	n
	)

template<class Input >

void jem::io::decodeArray	(	Input &	in,
		double *	buf,
		idx_t	n
	)

template<class Output >

void jem::io::encode	(	Output &	out,
		bool	b
	)

Examples:

DataParser.cpp.

template<class Output >

void jem::io::encode	(	Output &	out,
		byte	b
	)

template<class Output >

void jem::io::encode	(	Output &	out,
		char	c
	)

template<class Output >

void jem::io::encode	(	Output &	out,
		short	i
	)

template<class Output >

void jem::io::encode	(	Output &	out,
		int	i
	)

template<class Output >

void jem::io::encode	(	Output &	out,
		lint	i
	)

template<class Output >

void jem::io::encode	(	Output &	out,
		float	x
	)

template<class Output >

void jem::io::encode	(	Output &	out,
		double	x
	)

template<class Output , class A , class B >

void jem::io::encode	(	Output &	out,
		const A &	a,
		const B &	b
	)

template<class Output , class A , class B , class C >

void jem::io::encode	(	Output &	out,
		const A &	a,
		const B &	b,
		const C &	c
	)

template<class Output , class A , class B , class C , class D >

void jem::io::encode	(	Output &	out,
		const A &	a,
		const B &	b,
		const C &	c,
		const D &	d
	)

template<class Output , class A , class B , class C , class D , class E >

void jem::io::encode	(	Output &	out,
		const A &	a,
		const B &	b,
		const C &	c,
		const D &	d,
		const E &	e
	)

template<class Output , class A , class B , class C , class D , class E , class F >

void jem::io::encode	(	Output &	out,
		const A &	a,
		const B &	b,
		const C &	c,
		const D &	d,
		const E &	e,
		const F &	f
	)

template<class Output , class T >

void jem::io::encodeArray	(	Output &	out,
		const T *	buf,
		idx_t	len
	)

template<class Output >

void jem::io::encodeArray	(	Output &	out,
		const bool *	buf,
		idx_t	n
	)

template<class Output >

void jem::io::encodeArray	(	Output &	out,
		const byte *	buf,
		idx_t	n
	)

template<class Output >

void jem::io::encodeArray	(	Output &	out,
		const char *	buf,
		idx_t	n
	)

template<class Output >

void jem::io::encodeArray	(	Output &	out,
		const short *	buf,
		idx_t	n
	)

template<class Output >

void jem::io::encodeArray	(	Output &	out,
		const int *	buf,
		idx_t	n
	)

template<class Output >

void jem::io::encodeArray	(	Output &	out,
		const lint *	buf,
		idx_t	n
	)

template<class Output >

void jem::io::encodeArray	(	Output &	out,
		const float *	buf,
		idx_t	n
	)

template<class Output >

void jem::io::encodeArray	(	Output &	out,
		const double *	buf,
		idx_t	n
	)

template<class Input >

void jem::io::decode	(	Input &	in,
		FileInfo &	info
	)

template<class Output >

void jem::io::encode	(	Output &	out,
		const FileInfo &	info
	)

void jem::io::print	(	PrintWriter &	pr,
		const BeginList &	list
	)

Examples:

Array.cpp, BitSet.cpp, Database.cpp, DataParser.cpp, Event.cpp, game-of-life.cpp, Properties.cpp, System.cpp, TextInput.cpp, and Tuple.cpp.

void jem::io::print	(	PrintWriter &	pr,
		const BeginItem &	item
	)

void jem::io::print	(	PrintWriter &	pr,
		const EndItem &	end
	)

void jem::io::print	(	PrintWriter &	pr,
		const EndList &	end
	)

void jem::io::decode	(	DataInput &	in,
		NumberFormat &	nf
	)

void jem::io::encode	(	DataOutput &	out,
		const NumberFormat &	nf
	)

template<class Input , class T >

void jem::io::decode	(	Input &	in,
		Ref< T > &	obj
	)

template<class Input >

void jem::io::decode	(	Input &	in,
		Ref< Object > &	obj
	)

template<class Output , class T >

void jem::io::encode	(	Output &	out,
		const Ref< T > &	obj
	)

Fill jem::io::fill	(	char	ch,
		int	end = 48
	)

void jem::io::print	(	PrintWriter &	out,
		const Space &	sp
	)

void jem::io::print	(	PrintWriter &	out,
		const EndLine &	eol
	)

void jem::io::print	(	PrintWriter &	out,
		const Indent &	id
	)

void jem::io::print	(	PrintWriter &	out,
		const Outdent &	od
	)

void jem::io::print	(	PrintWriter &	out,
		const BlankLine &	bl
	)

void jem::io::print	(	PrintWriter &	out,
		const Fill &	fill
	)

template<class Input , class T >

void jem::io::decode	(	Input &	in,
		std::complex< T > &	z
	)

template<class Output , class T >

void jem::io::encode	(	Output &	out,
		const std::complex< T > &	z
	)

template<class Output , class T >

void jem::io::print	(	Output &	out,
		const std::complex< T > &	z
	)

Variable Documentation

const BeginList jem::io::beginList

const BeginItem jem::io::beginItem

const EndItem jem::io::endItem

const EndList jem::io::endList

const byte jem::io::GZIP_MAGIC[2]

const int jem::io::DEFAULT_BUFSIZE

const Fill jem::io::dots

const Fill jem::io::spaces

const Indent jem::io::indent

const Outdent jem::io::outdent

const BlankLine jem::io::blankLine