First cut of the sstream implementation.
Added the sstream header file the stringbuf and stringstream classes.
Added missing openmode flags in ios_base.h
diff --git a/include/ios_base.h b/include/ios_base.h
index 2fe6660..57f3913 100644
--- a/include/ios_base.h
+++ b/include/ios_base.h
@@ -56,6 +56,18 @@
ios_baseflags_floatfield = ios_baseflags_scientific | ios_baseflags_fixed,
ios_baseflags_end = 1 << 15
};
+
+// Openmode
+enum IosBaseOpenmode {
+ ios_baseopenmode_app = 1 << 0,
+ ios_baseopenmode_ate = 1 << 1,
+ ios_baseopenmode_binary = 1 << 2,
+ ios_baseopenmode_in = 1 << 3,
+ ios_baseopenmode_out = 1 << 4,
+ ios_baseopenmode_trunc = 1 << 5,
+ ios_baseopenmode_end = 1 << 6
+};
+
} // namespace android
namespace std {
@@ -74,9 +86,6 @@
class ios_base
{
public:
- typedef int io_state;
- typedef int open_mode;
- typedef int seek_dir;
typedef std::streampos streampos;
typedef std::streamoff streamoff;
@@ -87,6 +96,11 @@
public:
virtual ~ios_base();
typedef int fmtflags;
+ typedef int iostate;
+ typedef int openmode;
+ typedef int seekdir;
+
+ // FLAGS
// boolalpha: Insert and extract bool type in alphabetic format.
// dec: Convert integer input or generates integer output in
@@ -151,6 +165,24 @@
// Clears 'mask'.
void unsetf(fmtflags mask);
+
+ // OPENMODE
+
+ // app: seek to end before each write.
+ // ate: open and seek to end imediately after opening.
+ // binary: perform I/O in binary mode.
+ // in: open for input.
+ // out: open for output.
+ // trunc: truncate and existing stream when opening.
+ static const openmode app = android::ios_baseopenmode_app;
+ static const openmode ate = android::ios_baseopenmode_ate;
+ static const openmode binary = android::ios_baseopenmode_binary;
+ static const openmode in = android::ios_baseopenmode_in;
+ static const openmode out = android::ios_baseopenmode_out;
+ static const openmode trunc = android::ios_baseopenmode_trunc;
+
+ // PRECISION and WIDTH
+
/**
* @return The precision (number of digits after the decimal
* point) to generate on certain output conversions. 6 by default.
diff --git a/include/sstream b/include/sstream
new file mode 100644
index 0000000..ec75297
--- /dev/null
+++ b/include/sstream
@@ -0,0 +1,121 @@
+/* -*- 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_SSTREAM__
+#define ANDROID_ASTL_SSTREAM__
+
+#include <char_traits.h>
+#include <ios_base.h>
+#include <streambuf>
+#include <string>
+#include <ostream>
+
+namespace std {
+
+// Declare basic_stringbuf which is a buffer implemented using a std::string.
+// Then declare stringstream which implement a stream using basic_stringbuf.
+
+struct basic_stringbuf : public streambuf {
+ public:
+ typedef streambuf::traits_type traits_type;
+ typedef streambuf::char_type char_type;
+ typedef streambuf::int_type int_type;
+ typedef streambuf::pos_type pos_type;
+ typedef streambuf::off_type off_type;
+
+ // Construct an instance, in/out by default.
+ explicit basic_stringbuf(ios_base::openmode mode =
+ ios_base::in | ios_base::out);
+
+ // Construct an instance and copy str into the underlying buffer
+ // and initialize the input and output sequence according to the
+ // flags set in mode.
+ explicit basic_stringbuf(const string& str,
+ ios_base::openmode mode =
+ ios_base::in | ios_base::out);
+
+ virtual ~basic_stringbuf();
+
+ // @return A copy of the underlying buffer. If the buffer was
+ // creted in input mode, this is equal to the the input
+ // sequence. Otherwise it is equal to the output sequence.
+ // TODO: In the standard a copy is returned instead of const ref -
+ // not sure why.
+ const string& str() const;
+
+ // Clear the current buffer then copy the content of str into
+ // it. Initialize the input/output sequences according to the mode
+ // used.
+ // @param str The string to use as a new sequence.
+ void str(const string & str);
+
+ // @return -1 on output stream otherwise the number char available
+ // for reading.
+ streamsize in_avail();
+
+ protected:
+ // Override the default impl from ostream to do the work.
+ virtual streamsize xsputn(const char_type* str, streamsize num);
+
+ ios_base::openmode mMode;
+ string mString;
+};
+
+// In a regular STL this is <char> full specialization.
+typedef basic_stringbuf stringbuf;
+
+
+class stringstream : public ostream {
+ public:
+ explicit stringstream(ios_base::openmode mode =
+ ios_base::in | ios_base::out);
+
+ explicit stringstream(const string& str,
+ ios_base::openmode mode =
+ ios_base::in | ios_base::out);
+ virtual ~stringstream();
+
+ const string& str() const { return mStringBuf.str(); }
+ void str(const string & str) { mStringBuf.str(str); }
+
+ // TODO: move this to ostream.
+ ostream& put(char c);
+
+ private:
+ basic_stringbuf mStringBuf;
+};
+
+// In a regular STL stringstream inherits from ostringstream and
+// istringstream. Since we use stringstream everywhere we just declare
+// ostringstream as an alias to pass compilation.
+typedef stringstream ostringstream;
+
+} // namespace std
+
+#endif // ANDROID_ASTL_SSTREAM__
diff --git a/src/Android.mk b/src/Android.mk
index 0dcf05d..85b1a68 100644
--- a/src/Android.mk
+++ b/src/Android.mk
@@ -23,6 +23,7 @@
ios_pos_types.cpp \
list.cpp \
ostream.cpp \
+ sstream.cpp \
stdio_filebuf.cpp \
streambuf.cpp \
string.cpp
diff --git a/src/sstream.cpp b/src/sstream.cpp
new file mode 100644
index 0000000..a97540c
--- /dev/null
+++ b/src/sstream.cpp
@@ -0,0 +1,87 @@
+/*
+ * 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.
+ */
+
+#include <sstream>
+#include <streambuf>
+#include <ios_base.h>
+
+namespace std {
+
+// basic_stringbuf
+
+basic_stringbuf::basic_stringbuf(ios_base::openmode mode) :
+ mMode(mode) { }
+
+basic_stringbuf::basic_stringbuf(const string& str, ios_base::openmode mode) :
+ mMode(mode), mString(str) { }
+
+basic_stringbuf::~basic_stringbuf() { }
+
+const string& basic_stringbuf::str() const {
+ return mString;
+}
+
+void basic_stringbuf::str(const string& str) {
+ mString = str;
+}
+
+streamsize basic_stringbuf::in_avail() {
+ if (mMode & std::ios_base::in) {
+ return mString.size();
+ } else {
+ return -1;
+ }
+}
+
+streamsize basic_stringbuf::xsputn(const char_type* str, streamsize num) {
+ mString.append(str, num);
+ return num;
+}
+
+
+// stringstream
+
+stringstream::stringstream(std::ios_base::openmode mode)
+ : mStringBuf(mode) {
+ this->init(&mStringBuf);
+}
+
+stringstream::stringstream(const string& str,
+ std::ios_base::openmode mode)
+ : mStringBuf(str, mode) {
+ this->init(&mStringBuf);
+}
+
+stringstream::~stringstream() {}
+
+ostream& stringstream::put(char c) {
+ mStringBuf.sputc(c);
+ return *this;
+}
+
+} // namespace std
diff --git a/tests/Android.mk b/tests/Android.mk
index ddf3974..3233619 100644
--- a/tests/Android.mk
+++ b/tests/Android.mk
@@ -73,6 +73,7 @@
test_list.cpp \
test_memory.cpp \
test_set.cpp \
+ test_sstream.cpp \
test_streambuf.cpp \
test_string.cpp \
test_type_traits.cpp \
diff --git a/tests/test_sstream.cpp b/tests/test_sstream.cpp
new file mode 100644
index 0000000..d229fd5
--- /dev/null
+++ b/tests/test_sstream.cpp
@@ -0,0 +1,118 @@
+/* -*- 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.
+ */
+
+#include "../include/sstream"
+#ifndef ANDROID_ASTL_SSTREAM__
+#error "Wrong header included!!"
+#endif
+#include "common.h"
+
+#include <ios_base.h>
+#include <string>
+
+namespace android {
+using std::stringbuf;
+using std::stringstream;
+using std::string;
+
+bool testConstructor() {
+ {
+ string str("Get out of here and get me some money too.");
+ stringbuf buf1(str);
+ stringbuf buf2(str, std::ios_base::in);
+ stringbuf buf3(str, std::ios_base::out);
+
+ EXPECT_TRUE(buf1.str() == str);
+ EXPECT_TRUE(buf2.str() == str);
+ EXPECT_TRUE(buf3.str() == str);
+ }
+ return true;
+}
+
+bool testInAvail() {
+ {
+ string str("Get out of here and get me some money too.");
+ stringbuf buf1(str);
+ stringbuf buf2(str, std::ios_base::in);
+ stringbuf buf3(str, std::ios_base::out);
+ stringbuf buf4;
+
+ std::streamsize len1 = buf1.in_avail();
+ std::streamsize len2 = buf2.in_avail();
+ std::streamsize len3 = buf3.in_avail();
+ std::streamsize len4 = buf4.in_avail();
+
+ EXPECT_TRUE(len1 > 0);
+ EXPECT_TRUE(len2 > 0);
+ EXPECT_TRUE(len3 == -1); // out only
+ EXPECT_TRUE(len4 == 0); // out only
+ }
+ return true;
+}
+
+bool testNulChar() {
+ string str("String with \0 in the middle", 27);
+ stringbuf buf(str);
+
+ EXPECT_TRUE(buf.in_avail() == 27);
+ EXPECT_TRUE(buf.str().size() == 27);
+ return true;
+}
+
+bool testPut() {
+ stringbuf buf;
+
+ buf.sputc('A');
+ buf.sputc('B');
+ buf.sputc('C');
+ buf.sputc('D');
+ EXPECT_TRUE(buf.str() == "ABCD");
+
+ buf.sputn(" alphabet", 9);
+ EXPECT_TRUE(buf.str() == "ABCD alphabet");
+ return true;
+}
+
+bool testStringStream() {
+ stringstream ss;
+
+ ss << "This is: " << 10 << std::endl;
+ EXPECT_TRUE(ss.str() == "This is: 10\n");
+ return true;
+}
+} // namespace android
+
+int main(int argc, char **argv){
+ FAIL_UNLESS(testConstructor);
+ FAIL_UNLESS(testInAvail);
+ FAIL_UNLESS(testNulChar);
+ FAIL_UNLESS(testPut);
+ FAIL_UNLESS(testStringStream);
+ return kPassed;
+}
