Loading...
Searching...
No Matches
MemoryIO.h
Go to the documentation of this file.
//# MemoryIO.h: Class for IO in memory
//# Copyright (C) 1996,1999,2001
//# Associated Universities, Inc. Washington DC, USA.
//#
//# This library is free software; you can redistribute it and/or modify it
//# under the terms of the GNU Library General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or (at your
//# option) any later version.
//#
//# This library is distributed in the hope that it will be useful, but WITHOUT
//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
//# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
//# License for more details.
//#
//# You should have received a copy of the GNU Library General Public License
//# along with this library; if not, write to the Free Software Foundation,
//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
//#
//# Correspondence concerning AIPS++ should be addressed as follows:
//# Internet email: casa-feedback@nrao.edu.
//# Postal address: AIPS++ Project Office
//# National Radio Astronomy Observatory
//# 520 Edgemont Road
//# Charlottesville, VA 22903-2475 USA
#ifndef CASA_MEMORYIO_H
#define CASA_MEMORYIO_H
//# Includes
#include <casacore/casa/aips.h>
#include <casacore/casa/IO/ByteIO.h>
namespace casacore { //# NAMESPACE CASACORE - BEGIN
// <summary>Class for IO to a memory buffer.</summary>
// <use visibility=export>
// <reviewed reviewer="Friso Olnon" date="1996/11/06" tests="tByteIO" demos="">
// </reviewed>
// <prerequisite>
// <li> <linkto class=ByteIO>ByteIO</linkto>
// </prerequisite>
// <synopsis>
// This class is doing IO in a buffer in memory.
// It is part of the entire IO framework. It can for
// instance be used to store data in canonical format in a
// memory string and obtain it later.
// <p>
// The memory buffer can be dynamic, so it will be expanded when needed.
// This is done by allocating a larger buffer, copy the contents and
// throw the old buffer away.
// <br>
// The memory buffer can also be static to be sure that the pointer to
// the buffer will not change.
// The expand size determines if the memory buffer is static or dynamic.
// An expand size zero indicates a static buffer.
// <p>
// The memory buffer is seekable and readable. It depends on the
// constructor whether it is writable.
// <p>
// There are several ways in which the buffer can be created/passed:
// <ul>
// <li> Dynamic by passing an initial size and an expand size.
// However, an expand size zero can be used to assure that no more
// data is written than fits in the initial buffer (so once the
// buffer is created it gets static).
// In this way the buffer is readable and writable.
// <li> Static by passing a const buffer and its length.
// In this way the buffer is not writable.
// <li> Dynamic or static by passing a non-const buffer, its length,
// and an expand size (zero = static, >0 = dynamic)
// . The OpenOption indicates whether the buffer will be writable.
// Only for ByteIO::Old it will not be writable.
// The OpenOption also determines the initial seek position.
// Usually it is 0, but for ByteIO::Append it is the end of the buffer.
// </ul>
// The user can obtain a pointer to the buffer to extract the
// stored data from it. The length of the data can also be obtained.
// <p>
// Usually this class will be used in combination with, say, CanonicalIO
// and AipsIO.
// <example>
// <srcblock>
// // Create dynamic (expandable) memory buffer of length 100.
// // Use that as the sink of RawIO in AipsIO.
// MemoryIO membuf (100);
// RawIO rawio (&membuf);
// AipsIO stream (&rawio);
// // Write values.
// stream << (Int)10;
// stream << True;
// // Seek to beginning of buffer and read data in.
// stream.setpos (0);
// Int vali;
// Bool valb;
// stream >> vali >> valb;
//
// // One can obtain the buffer and its length and use it later.
// // (e.g. to write it in a non-AipsIO file).
// uChar* bufptr = membuf.getBuffer();
// uInt64 length = membuf.length();
//
// // It can also used to construct another MemoryIO object from it.
// // The following memory buffer is static and readonly.
// MemoryIO membuf2 (bufptr, length);
// membuf2.read (sizeof(vali), vali);
// membuf2.read (sizeof(valb), valb);
// </srcblock>
// </example>
// <motivation>
// Make it possible to do IO in a memory buffer.
// The first implementation used strstreambuf from the iostream package.
// However, that did not allow seeking and it was hard to get the length.
// </motivation>
class MemoryIO: public ByteIO
{
public:
// Construct a dynamic object with the given initial length.
explicit MemoryIO (uInt64 initialSize=65536, uInt64 expandSize=32768);
// Construct from a buffer with the given length.
// The buffer is readonly and cannot be expanded.
MemoryIO (const void* buffer, uInt64 size);
// Construct from the given buffer with the given length.
// The Byte::Option determines how the buffer will be used.
// The seek pointer is set to the beginning of the buffer, unless
// told otherwise below.
// <dl>
// <dt> New, NewNoReplace and Scratch
// <dd> The buffer is empty and is read/write.
// <dt> Old
// <dd> The buffer contains <src>size</src> bytes and is readonly.
// <dt> Update, Delete
// <dd> The buffer contains <src>size</src> bytes and is read/write.
// <dt> Append
// <dd> The buffer contains <src>size</src> bytes and is read/write.
// The seek pointer is set to the end of the buffer.
// </dl>
// When the buffer is writable, it will be expanded if needed.
// This means that <src>buffer</src> does not point to the data
// anymore. However, when <src>expandSize==0</src>, the buffer
// cannot be expanded and the pointer is always valid.
// <br>When canDelete is True, buffer expansion means that the
// old buffer gets deleted.
MemoryIO (void* buffer, uInt64 size, ByteIO::OpenOption,
uInt64 expandSize=0, Bool canDelete=False);
// Delete the Memory object.
// The data buffer is not deleted when constructed with the
// constructor taking a buffer pointer.
~MemoryIO();
// Write the number of bytes.
// When needed it expands the buffer.
// An exception is thrown when the buffer is not writable or
// when buffer expansion fails or is not possible.
virtual void write (Int64 size, const void* buf);
// Read <src>size</src> bytes from the memory buffer. Returns the number of
// bytes actually read. Will throw an Exception (AipsError) if the
// requested number of bytes could not be read unless throwException is set
// to False. Will always throw an exception if the buffer is not readable
// or the buffer pointer is at an invalid position.
virtual Int64 read (Int64 size, void* buf, Bool throwException=True);
// Clear the buffer; i.e. set the data length and seek pointer to zero.
void clear();
// Get the buffer containing the data.
// <br>The length of the data in the buffer can be obtained using the
// length() function.
const uChar* getBuffer() const;
// Get the length of the data in the buffer.
virtual Int64 length();
// Get the allocated length of the buffer.
uInt64 allocated() const;
// Get the expand size (0 = not expandable).
uInt64 expandSize() const;
// Is the IO stream readable?
virtual Bool isReadable() const;
// Is the IO stream writable?
virtual Bool isWritable() const;
// Is the IO stream seekable?
virtual Bool isSeekable() const;
// resize the internal buffer (if necessary) so that it is big enough
// to hold the specified number of bytes. Returns a non-const pointer
// to the buffer that can be used to write up to the specified number
// of bytes into the buffer. If less data is written into the buffer
// then the setUsed member funtion should be used to indicate how much
// of the buffer is valid. Throws an exception if the MemoryIO object
// is not writable or if it needs to increase the size of the internal
// buffer and the MemoryIO object is not expandable.
// <note role=warning> You should not use the supplied pointer to write
// more than length data points to the buffer</note>
uChar* setBuffer(uInt64 length);
// tell the MemoryIO object how much of its internal buffer is valid
// data. You only need to use this function if you are directly writing to
// the buffer using the pointer returned by the non-const getBuffer
// function. This function throws an exception if the number of bytes used
// is greater than the number allocated or if the MemoryIO object is not
// writeable.
void setUsed(uInt64 bytesUsed);
private:
//# Copy constructor, should not be used.
MemoryIO (const MemoryIO& that);
//# Assignment, should not be used.
MemoryIO& operator= (const MemoryIO& that);
// Reset the position pointer to the given value. It returns the
// new position.
// An exception is thrown when seeking before the start of the
// buffer or when seeking past the end of a readonly buffer.
// When seeking past the end of a writable buffer, the required
// amount of bytes is added and initialized to zero.
virtual Int64 doSeek (Int64 offset, ByteIO::SeekOption);
//# Expand the buffer to at least the given size. The specified size
//# will be used if it results in a larger buffer size. In this way the
//# buffer does not get reallocated too often. It returns a false status
//# when the buffer cannot be expanded.
Bool expand (uInt64 minSize);
uChar* itsBuffer;
Int64 itsAlloc;
Int64 itsExpandSize;
Int64 itsUsed;
Int64 itsPosition;
Bool itsReadable;
Bool itsWritable;
Bool itsCanDelete;
};
inline void MemoryIO::clear()
{
itsUsed = itsPosition = 0;
}
inline const uChar* MemoryIO::getBuffer() const
{
return itsBuffer;
}
inline uInt64 MemoryIO::allocated() const
{
return itsAlloc;
}
inline uInt64 MemoryIO::expandSize() const
{
return itsExpandSize;
}
} //# NAMESPACE CASACORE - END
#endif
casacore::ByteIO::SeekOption
SeekOption
Define the possible seek options.
Definition ByteIO.h:80
casacore::ByteIO::ByteIO
ByteIO()
The constructor does nothing.
Definition ByteIO.h:174
casacore::ByteIO::OpenOption
OpenOption
Define the possible ByteIO open options.
Definition ByteIO.h:63
casacore::MemoryIO::clear
void clear()
Clear the buffer; i.e.
Definition MemoryIO.h:253
casacore::MemoryIO::MemoryIO
MemoryIO(uInt64 initialSize=65536, uInt64 expandSize=32768)
Construct a dynamic object with the given initial length.
casacore::MemoryIO::length
virtual Int64 length()
Get the length of the data in the buffer.
casacore::MemoryIO::itsPosition
Int64 itsPosition
Definition MemoryIO.h:246
casacore::MemoryIO::itsWritable
Bool itsWritable
Definition MemoryIO.h:248
casacore::MemoryIO::doSeek
virtual Int64 doSeek(Int64 offset, ByteIO::SeekOption)
Reset the position pointer to the given value.
casacore::MemoryIO::itsCanDelete
Bool itsCanDelete
Definition MemoryIO.h:249
casacore::MemoryIO::itsAlloc
Int64 itsAlloc
Definition MemoryIO.h:243
casacore::MemoryIO::write
virtual void write(Int64 size, const void *buf)
Write the number of bytes.
casacore::MemoryIO::itsUsed
Int64 itsUsed
Definition MemoryIO.h:245
casacore::MemoryIO::itsReadable
Bool itsReadable
Definition MemoryIO.h:247
casacore::MemoryIO::operator=
MemoryIO & operator=(const MemoryIO &that)
casacore::MemoryIO::setUsed
void setUsed(uInt64 bytesUsed)
tell the MemoryIO object how much of its internal buffer is valid data.
casacore::MemoryIO::setBuffer
uChar * setBuffer(uInt64 length)
resize the internal buffer (if necessary) so that it is big enough to hold the specified number of by...
casacore::MemoryIO::allocated
uInt64 allocated() const
Get the allocated length of the buffer.
Definition MemoryIO.h:261
casacore::MemoryIO::MemoryIO
MemoryIO(const MemoryIO &that)
casacore::MemoryIO::isSeekable
virtual Bool isSeekable() const
Is the IO stream seekable?
casacore::MemoryIO::expand
Bool expand(uInt64 minSize)
casacore::MemoryIO::getBuffer
const uChar * getBuffer() const
Get the buffer containing the data.
Definition MemoryIO.h:257
casacore::MemoryIO::expandSize
uInt64 expandSize() const
Get the expand size (0 = not expandable).
Definition MemoryIO.h:265
casacore::MemoryIO::MemoryIO
MemoryIO(void *buffer, uInt64 size, ByteIO::OpenOption, uInt64 expandSize=0, Bool canDelete=False)
Construct from the given buffer with the given length.
casacore::MemoryIO::isReadable
virtual Bool isReadable() const
Is the IO stream readable?
casacore::MemoryIO::read
virtual Int64 read(Int64 size, void *buf, Bool throwException=True)
Read size bytes from the memory buffer.
casacore::MemoryIO::~MemoryIO
~MemoryIO()
Delete the Memory object.
casacore::MemoryIO::MemoryIO
MemoryIO(const void *buffer, uInt64 size)
Construct from a buffer with the given length.
casacore::MemoryIO::itsBuffer
uChar * itsBuffer
Definition MemoryIO.h:242
casacore::MemoryIO::itsExpandSize
Int64 itsExpandSize
Definition MemoryIO.h:244
casacore::MemoryIO::isWritable
virtual Bool isWritable() const
Is the IO stream writable?
casacore
this file contains all the compiler specific defines
Definition mainpage.dox:28
casacore::uChar
unsigned char uChar
Definition aipstype.h:45
casacore::False
const Bool False
Definition aipstype.h:42
casacore::offset
int offset(int, int) const
compute a linear offset from array indicies
casacore::Int64
long long Int64
Define the extra non-standard types used by Casacore (like proposed uSize, Size).
Definition aipsxtype.h:36
casacore::Bool
bool Bool
Define the standard types used by Casacore.
Definition aipstype.h:40
casacore::size
uInt size() const
Definition RecordInterface.h:224
casacore::True
const Bool True
Definition aipstype.h:41
casacore::uInt64
unsigned long long uInt64
Definition aipsxtype.h:37