]> git.xonotic.org Git - xonotic/netradiant.git/blob - libs/stream/stringstream.h
transformpath: do not segfault if environment variable is missing
[xonotic/netradiant.git] / libs / stream / stringstream.h
1 /*
2    Copyright (C) 2001-2006, William Joseph.
3    All Rights Reserved.
4
5    This file is part of GtkRadiant.
6
7    GtkRadiant is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    GtkRadiant is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with GtkRadiant; if not, write to the Free Software
19    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20  */
21
22 #if !defined( INCLUDED_STREAM_STRINGSTREAM_H )
23 #define INCLUDED_STREAM_STRINGSTREAM_H
24
25 #include "itextstream.h"
26 #include "string/string.h"
27 #include <vector>
28
29
30 /// \brief A wrapper around a STL vector of char.
31 /// Maintains a null-terminated array of char.
32 /// Provides a limited STL-style interface to push and pop characters at the end of the string.
33 class StringBuffer
34 {
35 std::vector<char> m_string;
36 public:
37 StringBuffer(){
38         m_string.push_back( '\0' );
39 }
40 explicit StringBuffer( std::size_t capacity ){
41         m_string.reserve( capacity );
42         m_string.push_back( '\0' );
43 }
44 explicit StringBuffer( const char* string ) : m_string( string, string + string_length( string ) + 1 ){
45 }
46
47 typedef std::vector<char>::iterator iterator;
48 typedef std::vector<char>::const_iterator const_iterator;
49
50 iterator begin(){
51         return m_string.begin();
52 }
53 const_iterator begin() const {
54         return m_string.begin();
55 }
56 iterator end(){
57         return m_string.end() - 1;
58 }
59 const_iterator end() const {
60         return m_string.end() - 1;
61 }
62
63 void push_back( char c ){
64         m_string.insert( end(), c );
65 }
66 void pop_back(){
67         m_string.erase( end() - 1 );
68 }
69 void push_range( const char* first, const char* last ){
70         m_string.insert( end(), first, last );
71 }
72 void push_string( const char* string ){
73         push_range( string, string + string_length( string ) );
74 }
75 char* c_str(){
76         return &( *m_string.begin() );
77 }
78 const char* c_str() const {
79         return &( *m_string.begin() );
80 }
81
82 char& back(){
83         return *( end() - 1 );
84 }
85 const char& back() const {
86         return *( end() - 1 );
87 }
88 bool empty() const {
89         return m_string.size() == 1;
90 }
91 void clear(){
92         m_string.clear();
93         m_string.push_back( '\0' );
94 }
95 };
96
97 /// \brief A TextOutputStream which writes to a StringBuffer.
98 /// Similar to std::stringstream.
99 class StringOutputStream : public TextOutputStream
100 {
101 StringBuffer m_string;
102 public:
103 typedef StringBuffer::iterator iterator;
104 typedef StringBuffer::const_iterator const_iterator;
105
106 StringOutputStream(){
107 }
108 explicit StringOutputStream( std::size_t capacity ) : m_string( capacity ){
109 }
110 std::size_t write( const char* buffer, std::size_t length ){
111         m_string.push_range( buffer, buffer + length );
112         return length;
113 }
114
115 iterator begin(){
116         return m_string.begin();
117 }
118 const_iterator begin() const {
119         return m_string.begin();
120 }
121 iterator end(){
122         return m_string.end();
123 }
124 const_iterator end() const {
125         return m_string.end();
126 }
127
128 bool empty() const {
129         return m_string.empty();
130 }
131 char* c_str(){
132         return m_string.c_str();
133 }
134 const char* c_str() const {
135         return m_string.c_str();
136 }
137 void clear(){
138         m_string.clear();
139 }
140 };
141
142 template<typename T>
143 inline StringOutputStream& operator<<( StringOutputStream& ostream, const T& t ){
144         return ostream_write( ostream, t );
145 }
146
147
148 #endif