Loading...
Searching...
No Matches
BlockIO.h
Go to the documentation of this file.
//# BlockIO.h: Functions to perform IO for the Block class
//# Copyright (C) 1993,1994,1995,1999,2000,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_BLOCKIO_H
#define CASA_BLOCKIO_H
#include <casacore/casa/aips.h>
//# Forward declarations.
#include <casacore/casa/iosfwd.h>
namespace casacore { //# NAMESPACE CASACORE - BEGIN
template<class T> class Block;
class AipsIO;
// <summary>IO functions for Block</summary>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="" demos="">
// </reviewed>
// <use visibility=export>
//
// <synopsis>
// These functions allow the user to write either an entire or a
// partial <src>Block</src> out to an <src>ostream</src> or to
// <src>AipsIO</src>. These functions provide simple storage and
// display capabilities for <src>Block</src>.
// </synopsis>
//
// <linkfrom anchor=BlockIO classes="Block">
// Global Block <here>IO functions</here>
// </linkfrom>
//
// <group name='BlockIO'>
//# It appears that (at least for the SUN compiler) the 3rd argument
//# cannot be an uInt (otherwise the compiler says no match when
//# called as e.g. putBlock(ios,blk,10);).
//#
//# Note that as of 29-Dec-2008 the size of Block is a size_t, so nr should
//# also be a size_t. However, because AipsIO cannot handle sizes larger than
//# an uInt, it makes no sense to make that change.
//
// These functions allow the user to read and write <src>Block</src>s
// from the <src>AipsIO</src> stream.
//
// <src>putBlock</src> writes the <src>Block</src> to the stream. If
// a number, <src>nr</src>, of elements is specified, only the first
// <src>nr</src> elements will be written out to <src>AipsI0</src>.
//
// <src>getBlock</src> reads a <src>Block</src> in from an
// <src>AipsIO</src> stream.
//
// <group>
template<class T> void putBlock (AipsIO&, const Block<T>&, Int nr);
template<class T> void putBlock (AipsIO& ios, const Block<T>& blk)
{ putBlock (ios, blk, (Int)(blk.nelements())); }
template<class T> void getBlock (AipsIO&, Block<T>&);
// </group>
// These functions allow the user to write <src>Block</src>s out to
// a standard <src>ostream</src>. The user can either write the entire
// <src>Block</src> out to the stream, or if a number of elements,
// <src>nr</src>, is specified, only the first <src>nr</src> elements
// of the <src>Block</src> will be written out.
//
// <group>
template<class T> void showBlock (std::ostream&, const Block<T>&, Int nr);
template<class T> void showBlock (std::ostream& ios, const Block<T>& blk)
{ showBlock (ios, blk, (Int)(blk.nelements())); }
// </group>
// These are the standard shift operators for writing an entire
// <src>Block</src> out to a stream. Shift operators are provided
// to write the block out to either <src>AipsIO</src> or
// <src>ostream</src>. A shift operator is also provided for
// reading a <src>Block</src> in from <src>AipsIO</src>.
// <note> STL containers like vector and list are written in the same way as
// a Block, so they can be written one way and read back the other.
// </note>
//
// <group>
template<class T> AipsIO& operator<< (AipsIO& ios, const Block<T>& blk)
{
putBlock (ios, blk, (Int)(blk.nelements()));
return ios;
}
template<class T> AipsIO& operator>> (AipsIO& ios, Block<T>& blk)
{
getBlock (ios, blk);
return ios;
}
template<class T> std::ostream& operator<< (std::ostream& ios, const Block<T>& blk)
{
showBlock (ios, blk, (Int)(blk.nelements()));
return ios;
}
// </group>
// </group>
//# Implement the specialization for the void* data type.
//# This will not do anything at all.
//# This specialization is needed for StColMirAIO.cc.
inline void putBlock (AipsIO&, const Block<void*>&, Int)
{}
inline void getBlock (AipsIO&, Block<void*>&)
{}
inline void showBlock (AipsIO&, const Block<void*>&, Int)
{}
} //# NAMESPACE CASACORE - END
#ifndef CASACORE_NO_AUTO_TEMPLATES
#include <casacore/casa/Containers/BlockIO.tcc>
#endif //# CASACORE_NO_AUTO_TEMPLATES
#endif
casacore::AipsIO
Definition AipsIO.h:167
casacore::Block
Definition Block.h:140
casacore
this file contains all the compiler specific defines
Definition mainpage.dox:28
casacore::operator>>
friend AipsIO & operator>>(AipsIO &os, Record &rec)
Read the Record from an input stream.
Definition Record.h:462
casacore::operator<<
ostream & operator<<(ostream &os, const IComplex &)
Show on ostream.
casacore::showBlock
void showBlock(AipsIO &, const Block< void * > &, Int)
Definition BlockIO.h:136
casacore::putBlock
void putBlock(AipsIO &, const Block< void * > &, Int)
Definition BlockIO.h:132
casacore::getBlock
void getBlock(AipsIO &, Block< void * > &)
Definition BlockIO.h:134
casacore::Int
int Int
Definition aipstype.h:48
casacore::BlockIO_global_functions_BlockIO
Definition BlockIO.h:56
casacore::BlockIO_global_functions_BlockIO::showBlock
void showBlock(std::ostream &, const Block< T > &, Int nr)
These functions allow the user to write Blocks out to a standard ostream.
casacore::BlockIO_global_functions_BlockIO::putBlock
void putBlock(AipsIO &ios, const Block< T > &blk)
Definition BlockIO.h:78
casacore::BlockIO_global_functions_BlockIO::operator<<
AipsIO & operator<<(AipsIO &ios, const Block< T > &blk)
These are the standard shift operators for writing an entire Block out to a stream.
Definition BlockIO.h:108
casacore::BlockIO_global_functions_BlockIO::getBlock
void getBlock(AipsIO &, Block< T > &)
casacore::BlockIO_global_functions_BlockIO::showBlock
void showBlock(std::ostream &ios, const Block< T > &blk)
Definition BlockIO.h:94
casacore::BlockIO_global_functions_BlockIO::putBlock
void putBlock(AipsIO &, const Block< T > &, Int nr)
These functions allow the user to read and write Blocks from the AipsIO stream.
casacore::BlockIO_global_functions_BlockIO::operator>>
AipsIO & operator>>(AipsIO &ios, Block< T > &blk)
Definition BlockIO.h:114