blob: 4c31a606ddc2ca9c618061b78ee6db69bc5a0978 [file] [log] [blame]
/* -*- c++ -*- */
/*
* Copyright (C) 2010 The Android Open Source Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#ifndef ANDROID_ASTL_STREAMBUF__
#define ANDROID_ASTL_STREAMBUF__
#include <char_traits.h>
namespace std {
/**
* Basic implementation of streambuf. The STL standard defines a
* basic_streambuf template that gets specialized for char and
* wchar. Since Android supports only char, we don't use a template
* here.
* Only output ops are supported.
* There are only 2 public entry points:
* - sputc
* - sputn
*/
class streambuf
{
public:
typedef char_traits<char> traits_type;
typedef traits_type::char_type char_type;
typedef traits_type::int_type int_type;
typedef streampos pos_type;
typedef streamoff off_type;
public:
virtual ~streambuf();
/**
* Entry points for derived buffer functions. The public version
* pubfoo dispatch to the protected foo member functions.
* @return -1 on failure.
*/
int pubsync() { return this->sync(); }
/**
* Entry point for all single-character output functions.
*/
int_type sputc(char_type c) {
// TODO: Should not rely on sputn, this is a temp implementation.
this->sputn(&c, 1);
return traits_type::to_int_type(c);
}
/**
* Write str[0] to str[n-1] to output sequence. Stops if sputc
* would return traits_type::eof().
* @param str A buffer area.
* @param num Maximum number of characters to write.
* @return The number of characters written.
*/
streamsize sputn(const char_type* str, streamsize num) {
return this->xsputn(str, num);
}
protected:
streambuf();
/**
* Access to the put area.
* - pbase() returns the beginning pointer for the output sequence.
* - pptr() returns the next pointer for the output sequence.
* - epptr() returns the end pointer for the output sequence.
* - pbump(int) Advance the write postion in the output sequence.
*/
char_type* pbase() const { return mPutBeg; }
char_type* pptr() const { return mPutCurr; }
char_type* epptr() const { return mPutEnd; }
void pbump(int num) {
if (mPutCurr + num > mPutCurr && mPutCurr + num <= mPutEnd) {
mPutCurr += num;
}
}
/**
* Set the 3 write pointers.
*/
void setp(char_type* beg, char_type* end) {
if (end >= beg) {
mPutBeg = mPutCurr = beg;
mPutEnd = end;
}
}
/**
* Sync buffer array. Provided by derived class.
* @return -1 on failure.
*/
virtual int sync() { return 0; }
/**
* See sputn. Provided by derived class.
*/
virtual streamsize xsputn(const char_type* str, streamsize num);
/**
* Consumes one char from the buffer, writes to the controlled
* sequence if possible. This is called when the buffer is
* full. Typically the impl will flush the buffer, write the
* character 'c'.
* Provided by derived class.
* @return traits::eof() in case of error, anything else otherwise.
*/
virtual int_type overflow(int_type /* c */ = traits_type::eof())
{ return traits_type::eof(); }
/**
* Minimal abstraction for an internal buffer.
* - put == output == write
*/
char_type* mPutBeg; // Start of put area.
char_type* mPutCurr; // Current put area.
char_type* mPutEnd; // End of put area.
private:
// No copy constructors.
streambuf(const streambuf& sb);
streambuf& operator=(const streambuf&) { return *this; }
};
} // namespace std
#endif