154 lines
4.7 KiB
C++
154 lines
4.7 KiB
C++
/**
|
|
* @file bufferstream.h
|
|
* @brief Public-facing declaration for the BufferStream adapter class
|
|
*
|
|
* $LicenseInfo:firstyear=2012&license=viewerlgpl$
|
|
* Second Life Viewer Source Code
|
|
* Copyright (C) 2012, Linden Research, Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation;
|
|
* version 2.1 of the License only.
|
|
*
|
|
* 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
|
|
* $/LicenseInfo$
|
|
*/
|
|
|
|
#ifndef _LLCORE_BUFFER_STREAM_H_
|
|
#define _LLCORE_BUFFER_STREAM_H_
|
|
|
|
|
|
#include <sstream>
|
|
#include <cstdlib>
|
|
|
|
#include "bufferarray.h"
|
|
|
|
|
|
/// @file bufferstream.h
|
|
///
|
|
/// std::streambuf and std::iostream adapters for BufferArray
|
|
/// objects.
|
|
///
|
|
/// BufferArrayStreamBuf inherits std::streambuf and implements
|
|
/// an unbuffered interface for streambuf. This may or may not
|
|
/// be the most time efficient implementation and it is a little
|
|
/// challenging.
|
|
///
|
|
/// BufferArrayStream inherits std::iostream and will be the
|
|
/// adapter object most callers will be interested in (though
|
|
/// it uses BufferArrayStreamBuf internally). Instances allow
|
|
/// for the usual streaming operators ('<<', '>>') and serialization
|
|
/// methods.
|
|
///
|
|
/// Example of LLSD serialization to a BufferArray:
|
|
///
|
|
/// BufferArray * ba = new BufferArray;
|
|
/// BufferArrayStream bas(ba);
|
|
/// LLSDSerialize::toXML(llsd, bas);
|
|
/// operationOnBufferArray(ba);
|
|
/// ba->release();
|
|
/// ba = NULL;
|
|
/// // operationOnBufferArray and bas are each holding
|
|
/// // references to the ba instance at this point.
|
|
///
|
|
|
|
namespace LLCore
|
|
{
|
|
|
|
|
|
// =====================================================
|
|
// BufferArrayStreamBuf
|
|
// =====================================================
|
|
|
|
/// Adapter class to put a std::streambuf interface on a BufferArray
|
|
///
|
|
/// Application developers will rarely be interested in anything
|
|
/// other than the constructor and even that will rarely be used
|
|
/// except indirectly via the @BufferArrayStream class. The
|
|
/// choice of interfaces implemented yields a bufferless adapter
|
|
/// that doesn't used either the input or output pointer triplets
|
|
/// of the more common buffered implementations. This may or may
|
|
/// not be faster and that question could stand to be looked at
|
|
/// sometime.
|
|
///
|
|
|
|
class BufferArrayStreamBuf : public std::streambuf
|
|
{
|
|
public:
|
|
/// Constructor increments the reference count on the
|
|
/// BufferArray argument and calls release() on destruction.
|
|
BufferArrayStreamBuf(BufferArray * array);
|
|
virtual ~BufferArrayStreamBuf();
|
|
|
|
private:
|
|
BufferArrayStreamBuf(const BufferArrayStreamBuf &); // Not defined
|
|
void operator=(const BufferArrayStreamBuf &); // Not defined
|
|
|
|
public:
|
|
// Input interfaces from std::streambuf
|
|
int_type underflow();
|
|
int_type uflow();
|
|
int_type pbackfail(int_type ch);
|
|
std::streamsize showmanyc();
|
|
|
|
// Output interfaces from std::streambuf
|
|
int_type overflow(int c);
|
|
std::streamsize xsputn(const char * src, std::streamsize count);
|
|
|
|
// Common/misc interfaces from std::streambuf
|
|
std::streampos seekoff(std::streamoff off, std::ios_base::seekdir way, std::ios_base::openmode which);
|
|
|
|
protected:
|
|
BufferArray * mBufferArray; // Ref counted
|
|
size_t mReadCurPos;
|
|
int mReadCurBlock;
|
|
const char * mReadBegin;
|
|
const char * mReadCur;
|
|
const char * mReadEnd;
|
|
size_t mWriteCurPos;
|
|
|
|
}; // end class BufferArrayStreamBuf
|
|
|
|
|
|
// =====================================================
|
|
// BufferArrayStream
|
|
// =====================================================
|
|
|
|
/// Adapter class that supplies streaming operators to BufferArray
|
|
///
|
|
/// Provides a streaming adapter to an existing BufferArray
|
|
/// instance so that the convenient '<<' and '>>' conversions
|
|
/// can be applied to a BufferArray. Very convenient for LLSD
|
|
/// serialization and parsing as well.
|
|
|
|
class BufferArrayStream : public std::iostream
|
|
{
|
|
public:
|
|
/// Constructor increments the reference count on the
|
|
/// BufferArray argument and calls release() on destruction.
|
|
BufferArrayStream(BufferArray * ba);
|
|
~BufferArrayStream();
|
|
|
|
protected:
|
|
BufferArrayStream(const BufferArrayStream &);
|
|
void operator=(const BufferArrayStream &);
|
|
|
|
protected:
|
|
BufferArrayStreamBuf mStreamBuf;
|
|
}; // end class BufferArrayStream
|
|
|
|
|
|
} // end namespace LLCore
|
|
|
|
#endif // _LLCORE_BUFFER_STREAM_H_
|