1 // 2 // Copyright (c) ZeroC, Inc. All rights reserved. 3 // 4 5 #ifndef ICE_BUFFER_H 6 #define ICE_BUFFER_H 7 8 #include <Ice/Config.h> 9 10 namespace IceInternal 11 { 12 13 class ICE_API Buffer : private IceUtil::noncopyable 14 { 15 public: 16 Buffer()17 Buffer() : i(b.begin()) { } Buffer(const Ice::Byte * beg,const Ice::Byte * end)18 Buffer(const Ice::Byte* beg, const Ice::Byte* end) : b(beg, end), i(b.begin()) { } Buffer(const std::vector<Ice::Byte> & v)19 Buffer(const std::vector<Ice::Byte>& v) : b(v), i(b.begin()) { } Buffer(Buffer & o,bool adopt)20 Buffer(Buffer& o, bool adopt) : b(o.b, adopt), i(b.begin()) { } 21 22 void swapBuffer(Buffer&); 23 24 class ICE_API Container : private IceUtil::noncopyable 25 { 26 public: 27 28 // 29 // Standard vector-like operations. 30 // 31 32 typedef Ice::Byte value_type; 33 typedef Ice::Byte* iterator; 34 typedef const Ice::Byte* const_iterator; 35 typedef Ice::Byte& reference; 36 typedef const Ice::Byte& const_reference; 37 typedef Ice::Byte* pointer; 38 typedef size_t size_type; 39 40 Container(); 41 Container(const_iterator, const_iterator); 42 Container(const std::vector<value_type>&); 43 Container(Container&, bool); 44 45 ~Container(); 46 begin()47 iterator begin() 48 { 49 return _buf; 50 } 51 begin()52 const_iterator begin() const 53 { 54 return _buf; 55 } 56 end()57 iterator end() 58 { 59 return _buf + _size; 60 } 61 end()62 const_iterator end() const 63 { 64 return _buf + _size; 65 } 66 size()67 size_type size() const 68 { 69 return _size; 70 } 71 empty()72 bool empty() const 73 { 74 return !_size; 75 } 76 77 void swap(Container&); 78 79 void clear(); 80 resize(size_type n)81 void resize(size_type n) // Inlined for performance reasons. 82 { 83 if(n == 0) 84 { 85 clear(); 86 } 87 else if(n > _capacity) 88 { 89 reserve(n); 90 } 91 _size = n; 92 } 93 reset()94 void reset() 95 { 96 if(_size > 0 && _size * 2 < _capacity) 97 { 98 // 99 // If the current buffer size is smaller than the 100 // buffer capacity, we shrink the buffer memory to the 101 // current size. This is to avoid holding onto too much 102 // memory if it's not needed anymore. 103 // 104 if(++_shrinkCounter > 2) 105 { 106 reserve(_size); 107 _shrinkCounter = 0; 108 } 109 } 110 else 111 { 112 _shrinkCounter = 0; 113 } 114 _size = 0; 115 } 116 push_back(value_type v)117 void push_back(value_type v) 118 { 119 resize(_size + 1); 120 _buf[_size - 1] = v; 121 } 122 123 reference operator[](size_type n) 124 { 125 assert(n < _size); 126 return _buf[n]; 127 } 128 129 const_reference operator[](size_type n) const 130 { 131 assert(n < _size); 132 return _buf[n]; 133 } 134 135 private: 136 137 Container(const Container&); 138 void operator=(const Container&); 139 void reserve(size_type); 140 141 pointer _buf; 142 size_type _size; 143 size_type _capacity; 144 int _shrinkCounter; 145 bool _owned; 146 }; 147 148 Container b; 149 Container::iterator i; 150 }; 151 152 } 153 154 #endif 155