| /* -*- 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 |