1 mike  1.1.2.1 //%2005////////////////////////////////////////////////////////////////////////
  2               //
  3               // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
  4               // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
  5               // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
  6               // IBM Corp.; EMC Corporation, The Open Group.
  7               // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
  8               // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
  9               // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
 10               // EMC Corporation; VERITAS Software Corporation; The Open Group.
 11               //
 12               // Permission is hereby granted, free of charge, to any person obtaining a copy
 13               // of this software and associated documentation files (the "Software"), to
 14               // deal in the Software without restriction, including without limitation the
 15               // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 16               // sell copies of the Software, and to permit persons to whom the Software is
 17               // furnished to do so, subject to the following conditions:
 18               // 
 19               // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
 20               // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
 21               // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 22 mike  1.1.2.1 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 23               // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 24               // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 25               // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 26               // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 27               //
 28               //==============================================================================
 29               //
 30               // Author: Michael E. Brasher
 31               //
 32               //%/////////////////////////////////////////////////////////////////////////////
 33               
 34               #ifndef Pegasus_Buffer_h
 35               #define Pegasus_Buffer_h
 36               
 37               #include <Pegasus/Common/Config.h>
 38               #include <Pegasus/Common/Linkage.h>
 39               
 40               PEGASUS_NAMESPACE_BEGIN
 41               
 42               struct BufferRep
 43 mike  1.1.2.1 {
 44                   size_t size;
 45                   size_t cap;
 46                   char data[1];
 47               };
 48               
 49               class PEGASUS_COMMON_LINKAGE Buffer
 50               {
 51               public:
 52               
 53                   Buffer();
 54               
 55                   Buffer(const Buffer& x);
 56               
 57                   Buffer(const char* data, size_t size);
 58               
 59                   ~Buffer();
 60               
 61                   Buffer& operator=(const Buffer& x);
 62               
 63                   void swap(Buffer& x);
 64 mike  1.1.2.1 
 65                   size_t size() const;
 66               
 67                   size_t capacity() const;
 68               
 69                   const char* getData() const;
 70               
 71                   char get(size_t i) const;
 72               
 73                   void set(size_t i, char x);
 74               
 75                   const char& operator[](size_t i) const;
 76               
 77                   void reserveCapacity(size_t cap);
 78               
 79                   void grow(size_t size, char x = '\0');
 80               
 81                   void append(char x);
 82               
 83                   void append(const char* data, size_t size);
 84               
 85 mike  1.1.2.1     void append(char c1, char c2, char c3, char c4);
 86               
 87                   void append(
 88               	char c1, char c2, char c3, char c4, char c5, char c6, char c7, char c8);
 89               
 90                   void insert(size_t pos, const char* data, size_t size);
 91               
 92                   void remove(size_t pos, size_t size);
 93               
 94                   void remove(size_t pos);
 95               
 96                   void clear();
 97               
 98               private:
 99               
100                   void _reserve_aux(size_t cap);
101               
102                   void _append_char_aux();
103               
104                   BufferRep* _rep;
105                   static BufferRep _empty_rep;
106 mike  1.1.2.1 };
107               
108               inline Buffer::Buffer() : _rep(&_empty_rep)
109               {
110               }
111               
112               inline Buffer::~Buffer()
113               {
114                   if (_rep != &_empty_rep)
115               	free(_rep);
116               }
117               
118               inline void Buffer::swap(Buffer& x)
119               {
120                   BufferRep* tmp = _rep;
121                   _rep = x._rep;
122                   x._rep = tmp;
123               }
124               
125               inline size_t Buffer::size() const
126               {
127 mike  1.1.2.1     return _rep->size;
128               }
129               
130               inline size_t Buffer::capacity() const
131               {
132                   return _rep->cap;
133               }
134               
135               inline const char* Buffer::getData() const
136               {
137                   return _rep->data;
138               }
139               
140               inline char Buffer::get(size_t i) const
141               {
142                   return _rep->data[i];
143               }
144               
145               inline void Buffer::set(size_t i, char x)
146               {
147                   _rep->data[i] = x;
148 mike  1.1.2.1 }
149               
150               inline const char& Buffer::operator[](size_t i) const
151               {
152                   return _rep->data[i];
153               }
154               
155               inline void Buffer::reserveCapacity(size_t cap)
156               {
157                   if (cap > _rep->cap)
158               	_reserve_aux(cap);
159               }
160               
161               inline void Buffer::grow(size_t size, char x)
162               {
163                   size_t cap = _rep->size + size;
164               
165                   if (cap > _rep->cap)
166               	_reserve_aux(cap);
167               
168                   memset(_rep->data + _rep->size, x, size);
169 mike  1.1.2.1     _rep->size += size;
170               }
171               
172               inline void Buffer::append(char x)
173               {
174                   if (_rep->size == _rep->cap)
175               	_append_char_aux();
176               
177                   _rep->data[_rep->size++] = x;
178               }
179               
180               inline void Buffer::append(const char* data, size_t size)
181               {
182                   size_t cap = _rep->size + size;
183               
184                   if (cap > _rep->cap)
185               	_reserve_aux(cap);
186               
187                   memcpy(_rep->data + _rep->size, data, size);
188                   _rep->size += size;
189               }
190 mike  1.1.2.1 
191               inline void Buffer::clear()
192               {
193                   _rep->size = 0;
194               }
195               
196               inline void Buffer::remove(size_t pos)
197               {
198                   remove(pos, 1);
199               }
200               
201               inline void Buffer::append(char c1, char c2, char c3, char c4)
202               {
203                   size_t cap = _rep->size + 4;
204               
205                   if (cap > _rep->cap)
206               	_reserve_aux(cap);
207               
208                   char* p = _rep->data + _rep->size;
209                   p[0] = c1;
210                   p[1] = c2;
211 mike  1.1.2.1     p[2] = c3;
212                   p[3] = c4;
213                   _rep->size += 4;
214               }
215               
216               inline void Buffer::append(
217                   char c1, char c2, char c3, char c4, char c5, char c6, char c7, char c8)
218               {
219                   size_t cap = _rep->size + 8;
220               
221                   if (cap > _rep->cap)
222               	_reserve_aux(cap);
223               
224                   char* p = _rep->data + _rep->size;
225                   p[0] = c1;
226                   p[1] = c2;
227                   p[2] = c3;
228                   p[3] = c4;
229                   p[4] = c5;
230                   p[5] = c6;
231                   p[6] = c7;
232 mike  1.1.2.1     p[7] = c8;
233                   _rep->size += 8;
234               }
235               
236               inline bool operator==(const Buffer& x, const Buffer& y)
237               {
238                   return memcmp(x.getData(), y.getData(), x.size()) == 0;
239               }
240               
241               PEGASUS_NAMESPACE_END
242               
243               #endif /* Pegasus_Buffer_h */