~ubuntu-branches/ubuntu/trusty/bmagic/trusty

<h1>bmalloc.h</h1><a href="a00087.html">Go to the documentation of this file.</a><div class="fragment"><pre class="fragment"><a name="l00001"></a>00001 #ifndef BMALLOC__H__INCLUDED__

<a name="l00002"></a>00002 #define BMALLOC__H__INCLUDED__

<h1>bm.h</h1><a href="a00087.html">Go to the documentation of this file.</a><div class="fragment"><pre class="fragment"><a name="l00001"></a>00001 #ifndef BM__H__INCLUDED__

<a name="l00002"></a>00002 #define BM__H__INCLUDED__

<a name="l00003"></a>00003 /*

<a name="l00005"></a>00005

<a name="l00026"></a>00026

<a name="l00027"></a>00027 */

<a name="l00028"></a>00028

<a name="l00029"></a>00029 #include <stdlib.h>

<a name="l00030"></a>00030 #include <new>

<a name="l00031"></a>00031

<a name="l00032"></a>00032 namespace bm

<a name="l00033"></a>00033 {

<a name="l00034"></a>00034

<a name="l00035"></a>00035

<a name="l00036"></a>00036 /*! @defgroup alloc Memory Allocation

<a name="l00037"></a>00037 * Memory allocation related units

<a name="l00038"></a>00038 * @ingroup bmagic

<a name="l00039"></a>00039 *

<a name="l00040"></a>00040 * @{

<a name="l00041"></a>00041 */

<a name="l00042"></a>00042

<a name="l00043"></a>00043 /*!

<a name="l00044"></a>00044 @brief Default malloc based bitblock allocator class.

<a name="l00045"></a>00045

<a name="l00046"></a>00046 Functions allocate and deallocate conform to STL allocator specs.

<a name="l00047"></a>00047 @ingroup alloc

<a name="l00048"></a>00048 */

<a name="l00049"></a><a class="code" href="a00038.html">00049</a> class <a class="code" href="a00038.html" title="Default malloc based bitblock allocator class.">block_allocator</a>

<a name="l00050"></a>00050 {

<a name="l00051"></a>00051 public:

<a name="l00052"></a>00052 /**

<a name="l00053"></a>00053 The member function allocates storage for an array of n bm::word_t

<a name="l00054"></a>00054 elements, by calling malloc.

<a name="l00055"></a>00055 @return pointer to the allocated memory.

<a name="l00056"></a>00056 */

<a name="l00057"></a><a class="code" href="a00038.html#a1b90487ff442d774f3f9d888fb0e54ba">00057</a> static <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* <a class="code" href="a00038.html#a1b90487ff442d774f3f9d888fb0e54ba" title="The member function allocates storage for an array of n bm::word_t elements, by calling...">allocate</a>(size_t n, const void *)

<a name="l00058"></a>00058 {

<a name="l00059"></a>00059 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* ptr;

<a name="l00060"></a>00060 #if defined(BMSSE2OPT) || defined(BMSSE42OPT)

<a name="l00061"></a>00061 # ifdef _MSC_VER

<a name="l00062"></a>00062 ptr = (<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*) ::_aligned_malloc(n * sizeof(<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>), 16);

<a name="l00063"></a>00063 #else

<a name="l00064"></a>00064 ptr = (<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*) ::_mm_malloc(n * sizeof(<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>), 16);

<a name="l00065"></a>00065 # endif

<a name="l00066"></a>00066

<a name="l00067"></a>00067 #else

<a name="l00068"></a>00068 ptr = (<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*) ::malloc(n * sizeof(<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>));

<a name="l00069"></a>00069 #endif

<a name="l00070"></a>00070 if (!ptr)

<a name="l00071"></a>00071 {

<a name="l00072"></a>00072 throw std::bad_alloc();

100

<a name="l00073"></a>00073 }

101

<a name="l00074"></a>00074 return ptr;

102

<a name="l00075"></a>00075 }

103

<a name="l00076"></a>00076

104

<a name="l00077"></a>00077 /**

105

<a name="l00078"></a>00078 The member function frees storage for an array of n bm::word_t

106

<a name="l00079"></a>00079 elements, by calling free.

107

<a name="l00080"></a>00080 */

108

<a name="l00081"></a><a class="code" href="a00038.html#a68a3365e4decb87fef88c2fa9028c8e2">00081</a> static void <a class="code" href="a00038.html#a68a3365e4decb87fef88c2fa9028c8e2" title="The member function frees storage for an array of n bm::word_t elements, by calling...">deallocate</a>(<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* p, size_t)

109

<a name="l00082"></a>00082 {

110

<a name="l00083"></a>00083 #if defined(BMSSE2OPT) || defined(BMSSE42OPT)

111

<a name="l00084"></a>00084 # ifdef _MSC_VER

112

<a name="l00085"></a>00085 ::_aligned_free(p);

113

<a name="l00086"></a>00086 #else

114

<a name="l00087"></a>00087 ::_mm_free(p);

115

<a name="l00088"></a>00088 # endif

116

<a name="l00089"></a>00089

117

<a name="l00090"></a>00090 #else

118

<a name="l00091"></a>00091 ::free(p);

119

<a name="l00092"></a>00092 #endif

120

<a name="l00093"></a>00093 }

121

<a name="l00094"></a>00094

122

<a name="l00095"></a>00095 };

<a name="l00029"></a>00029

<a name="l00030"></a>00030 // define BM_NO_STL if you use BM in "STL free" environment and want

<a name="l00031"></a>00031 // to disable any references to STL headers

<a name="l00032"></a>00032 #ifndef BM_NO_STL

<a name="l00033"></a>00033 # include <iterator>

<a name="l00034"></a>00034 #endif

<a name="l00035"></a>00035

<a name="l00036"></a>00036 #ifdef _MSC_VER

<a name="l00037"></a>00037 #pragma warning( disable : 4311 4312)

<a name="l00038"></a>00038 #endif

<a name="l00039"></a>00039

<a name="l00040"></a>00040

<a name="l00041"></a>00041 #ifdef BMSSE42OPT

<a name="l00042"></a>00042 # ifdef BM64OPT

<a name="l00043"></a>00043 # undef BM64OPT

<a name="l00044"></a><a class="code" href="a00087.html#a79160de599e55f5070417d858cced751">00044</a> # define BM64_SSE4

<a name="l00045"></a>00045 # endif

<a name="l00046"></a>00046 # undef BMSSE2OPT

<a name="l00047"></a>00047 #endif

<a name="l00048"></a>00048

<a name="l00049"></a>00049

<a name="l00050"></a>00050 #include "<a class="code" href="a00091.html">bmconst.h</a>"

<a name="l00051"></a>00051 #include "<a class="code" href="a00092.html">bmdef.h</a>"

<a name="l00052"></a>00052

<a name="l00053"></a>00053

<a name="l00054"></a>00054 #ifdef BMSSE42OPT

<a name="l00055"></a><a class="code" href="a00087.html#aa2c8ca7e259c278f3a9605205679de03">00055</a> # define BMVECTOPT

<a name="l00056"></a>00056 # include "<a class="code" href="a00098.html">bmsse4.h</a>"

<a name="l00057"></a>00057 #endif

<a name="l00058"></a>00058

<a name="l00059"></a>00059 #ifdef BMSSE2OPT

<a name="l00060"></a>00060 # undef BM64OPT

<a name="l00061"></a>00061 # define BMVECTOPT

<a name="l00062"></a>00062 # include "<a class="code" href="a00097.html">bmsse2.h</a>"

<a name="l00063"></a>00063 #endif

<a name="l00064"></a>00064

<a name="l00065"></a>00065

<a name="l00066"></a>00066 #include "bmfwd.h"

<a name="l00067"></a>00067 #include "<a class="code" href="a00093.html">bmfunc.h</a>"

<a name="l00068"></a>00068 #include "<a class="code" href="a00103.html">bmvmin.h</a>"

<a name="l00069"></a>00069 #include "<a class="code" href="a00104.html">encoding.h</a>"

<a name="l00070"></a>00070 #include "<a class="code" href="a00090.html">bmalloc.h</a>"

<a name="l00071"></a>00071 #include "bmblocks.h"

<a name="l00072"></a>00072

100

<a name="l00073"></a><a class="code" href="a00115.html">00073</a> namespace bm

101

<a name="l00074"></a>00074 {

102

<a name="l00075"></a>00075

103

<a name="l00076"></a>00076

104

<a name="l00077"></a>00077 #ifdef BMCOUNTOPT

105

<a name="l00078"></a>00078

106

<a name="l00079"></a>00079 # define BMCOUNT_INC ++count_;

107

<a name="l00080"></a>00080 # define BMCOUNT_DEC --count_;

108

<a name="l00081"></a>00081 # define BMCOUNT_VALID(x) count_is_valid_ = x;

109

<a name="l00082"></a>00082 # define BMCOUNT_SET(x) count_ = x; count_is_valid_ = true;

110

<a name="l00083"></a>00083 # define BMCOUNT_ADJ(x) if (x) ++count_; else --count_;

111

<a name="l00084"></a>00084

112

<a name="l00085"></a>00085 #else

113

<a name="l00086"></a>00086

114

<a name="l00087"></a><a class="code" href="a00087.html#a911e3d9e9a293cafab1396a8700288e9">00087</a> # define BMCOUNT_INC

115

<a name="l00088"></a><a class="code" href="a00087.html#a809c66152f5967c1a1eb51e006206630">00088</a> # define BMCOUNT_DEC

116

<a name="l00089"></a><a class="code" href="a00087.html#a835c3ed1c5956735e59744cff81244dc">00089</a> # define BMCOUNT_VALID(x)

117

<a name="l00090"></a><a class="code" href="a00087.html#a1fbebc7fe3c22d768ff6e240437ee8f4">00090</a> # define BMCOUNT_SET(x)

118

<a name="l00091"></a><a class="code" href="a00087.html#aef4146eb86de042a6c34717f87b16c10">00091</a> # define BMCOUNT_ADJ(x)

119

<a name="l00092"></a>00092

120

<a name="l00093"></a>00093 #endif

121

<a name="l00094"></a>00094

122

<a name="l00095"></a>00095

123

<a name="l00096"></a>00096

124

<a name="l00097"></a>00097

125

<a name="l00098"></a>00098 // -------------------------------------------------------------------------

124

<a name="l00097"></a><a class="code" href="a00115.html#ac77813f2c2dfe40575830ba6a8373bcc">00097</a> typedef <a class="code" href="a00075.html" title="Template class implements memory saving set functionality.">bm::miniset<bm::block_allocator, bm::set_total_blocks></a> <a class="code" href="a00075.html" title="Template class implements memory saving set functionality.">mem_save_set</a>;

125

<a name="l00098"></a>00098

126

<a name="l00099"></a>00099

127

<a name="l00100"></a>00100 /*! @brief Default malloc based bitblock allocator class.

128

<a name="l00101"></a>00101

129

<a name="l00102"></a>00102 Functions allocate and deallocate conform to STL allocator specs.

130

<a name="l00103"></a>00103 */

131

<a name="l00104"></a><a class="code" href="a00077.html">00104</a> class <a class="code" href="a00077.html" title="Default malloc based bitblock allocator class.">ptr_allocator</a>

132

<a name="l00105"></a>00105 {

133

<a name="l00106"></a>00106 public:

134

<a name="l00107"></a>00107 /**

135

<a name="l00108"></a>00108 The member function allocates storage for an array of n void*

136

<a name="l00109"></a>00109 elements, by calling malloc.

137

<a name="l00110"></a>00110 @return pointer to the allocated memory.

138

<a name="l00111"></a>00111 */

139

<a name="l00112"></a><a class="code" href="a00077.html#a2ed8d55900bad5292e06be4af220aa38">00112</a> static void* <a class="code" href="a00077.html#a2ed8d55900bad5292e06be4af220aa38" title="The member function allocates storage for an array of n void* elements, by calling...">allocate</a>(size_t n, const void *)

140

<a name="l00113"></a>00113 {

141

<a name="l00114"></a>00114 void* ptr = ::malloc(n * sizeof(void*));

142

<a name="l00115"></a>00115 if (!ptr)

143

<a name="l00116"></a>00116 {

144

<a name="l00117"></a>00117 throw std::bad_alloc();

145

<a name="l00118"></a>00118 }

146

<a name="l00119"></a>00119 return ptr;

147

<a name="l00120"></a>00120 }

148

<a name="l00121"></a>00121

149

<a name="l00122"></a>00122 /**

150

<a name="l00123"></a>00123 The member function frees storage for an array of n bm::word_t

151

<a name="l00124"></a>00124 elements, by calling free.

152

<a name="l00125"></a>00125 */

153

<a name="l00126"></a><a class="code" href="a00077.html#ad7636f410ac891c14621d7bc3784a00c">00126</a> static void <a class="code" href="a00077.html#ad7636f410ac891c14621d7bc3784a00c" title="The member function frees storage for an array of n bm::word_t elements, by calling...">deallocate</a>(void* p, size_t)

154

<a name="l00127"></a>00127 {

155

<a name="l00128"></a>00128 ::free(p);

156

<a name="l00129"></a>00129 }

157

<a name="l00130"></a>00130 };

158

<a name="l00131"></a>00131

159

<a name="l00132"></a>00132 // -------------------------------------------------------------------------

160

<a name="l00133"></a>00133

161

<a name="l00134"></a>00134 /*! @brief BM style allocator adapter.

162

<a name="l00135"></a>00135

163

<a name="l00136"></a>00136 Template takes two parameters BA - allocator object for bit blocks and

164

<a name="l00137"></a>00137 PA - allocator object for pointer blocks.

165

<a name="l00138"></a>00138 */

166

<a name="l00139"></a><a class="code" href="a00073.html">00139</a> template<class BA, class PA> class <a class="code" href="a00073.html" title="BM style allocator adapter.">mem_alloc</a>

167

<a name="l00140"></a>00140 {

168

<a name="l00141"></a>00141 public:

169

<a name="l00142"></a><a class="code" href="a00073.html#a911e642666fb01c95152f34a8eea9d60">00142</a> typedef BA <a class="code" href="a00073.html#a911e642666fb01c95152f34a8eea9d60">block_allocator_type</a>;

170

<a name="l00143"></a><a class="code" href="a00073.html#a3585fb098e6798fe5aea1bd5dfaaa874">00143</a> typedef PA <a class="code" href="a00073.html#a3585fb098e6798fe5aea1bd5dfaaa874">ptr_allocator_type</a>;

171

<a name="l00144"></a>00144

172

<a name="l00145"></a>00145 public:

173

<a name="l00146"></a>00146

174

<a name="l00147"></a><a class="code" href="a00073.html#a0c83df2f625583b6958fb34d807b0014">00147</a> <a class="code" href="a00073.html#a0c83df2f625583b6958fb34d807b0014">mem_alloc</a>(const BA& block_alloc = BA(), const PA& ptr_alloc = PA())

175

<a name="l00148"></a>00148 : block_alloc_(block_alloc),

176

<a name="l00149"></a>00149 ptr_alloc_(ptr_alloc)

177

<a name="l00150"></a>00150 {}

178

<a name="l00151"></a>00151

179

<a name="l00152"></a>00152 /*! @brief Returns copy of the block allocator object

180

<a name="l00153"></a>00153 */

181

<a name="l00154"></a><a class="code" href="a00073.html#af77ba616b20ffaa1a0589ed537697e71">00154</a> <a class="code" href="a00073.html#a911e642666fb01c95152f34a8eea9d60">block_allocator_type</a> <a class="code" href="a00073.html#af77ba616b20ffaa1a0589ed537697e71" title="Returns copy of the block allocator object.">get_block_allocator</a>() const

182

<a name="l00155"></a>00155 {

183

<a name="l00156"></a>00156 return BA(block_alloc_);

184

<a name="l00157"></a>00157 }

185

<a name="l00158"></a>00158

186

<a name="l00159"></a>00159 /*! @brief Returns copy of the ptr allocator object

187

<a name="l00160"></a>00160 */

188

<a name="l00161"></a><a class="code" href="a00073.html#a16191ffe1d864b2f4f1e72c290768c82">00161</a> <a class="code" href="a00073.html#a3585fb098e6798fe5aea1bd5dfaaa874">ptr_allocator_type</a> <a class="code" href="a00073.html#a16191ffe1d864b2f4f1e72c290768c82" title="Returns copy of the ptr allocator object.">get_ptr_allocator</a>() const

189

<a name="l00162"></a>00162 {

190

<a name="l00163"></a>00163 return PA(block_alloc_);

191

<a name="l00164"></a>00164 }

127

<a name="l00100"></a>00100 /** @defgroup bmagic BitMagic C++ Library

128

<a name="l00101"></a>00101 * For more information please visit: http://bmagic.sourceforge.net

129

<a name="l00102"></a>00102 *

130

<a name="l00103"></a>00103 */

131

<a name="l00104"></a>00104

132

<a name="l00105"></a>00105

133

<a name="l00106"></a>00106 /** @defgroup bvector The Main bvector<> Group

134

<a name="l00107"></a>00107 * This is the main group. It includes bvector template: front end of the bm library.

135

<a name="l00108"></a>00108 * @ingroup bmagic

136

<a name="l00109"></a>00109 */

137

<a name="l00110"></a>00110

138

<a name="l00111"></a>00111

139

<a name="l00112"></a>00112

140

<a name="l00113"></a>00113

141

<a name="l00114"></a>00114 /*!

142

<a name="l00115"></a>00115 @brief bitvector with runtime compression of bits.

143

<a name="l00116"></a>00116 @ingroup bvector

144

<a name="l00117"></a>00117 */

145

<a name="l00118"></a>00118

146

<a name="l00119"></a>00119 template<class Alloc, class MS>

147

<a name="l00120"></a><a class="code" href="a00044.html">00120</a> class <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector</a>

148

<a name="l00121"></a>00121 {

149

<a name="l00122"></a>00122 public:

150

<a name="l00123"></a>00123

151

<a name="l00124"></a><a class="code" href="a00044.html#a0da32cb546602fa6874a5a4804192b6e">00124</a> typedef Alloc <a class="code" href="a00044.html#a0da32cb546602fa6874a5a4804192b6e">allocator_type</a>;

152

<a name="l00125"></a><a class="code" href="a00044.html#a1c89beac7542674fdc09cbcf024ab390">00125</a> typedef blocks_manager<Alloc, MS> <a class="code" href="a00044.html#a1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>;

153

<a name="l00126"></a>00126 /** Type used to count bits in the bit vector */

154

<a name="l00127"></a><a class="code" href="a00044.html#aba038b54cc8d548bb1c058dee0325884">00127</a> typedef <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00044.html#aba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a>;

155

<a name="l00128"></a>00128

156

<a name="l00129"></a>00129 /** Statistical information about bitset's memory allocation details. */

157

<a name="l00130"></a><a class="code" href="a00085.html">00130</a> struct <a class="code" href="a00085.html" title="Statistical information about bitset&#39;s memory allocation details.">statistics</a> : public <a class="code" href="a00043.html" title="Structure with statistical information about bitset&#39;s memory allocation details...">bv_statistics</a>

158

<a name="l00131"></a>00131 {};

159

<a name="l00132"></a>00132

160

<a name="l00133"></a>00133 /**

161

<a name="l00134"></a>00134 @brief Class reference implements an object for bit assignment.

162

<a name="l00135"></a>00135 Since C++ does not provide with build-in bit type supporting l-value

163

<a name="l00136"></a>00136 operations we have to emulate it.

164

<a name="l00137"></a>00137

165

<a name="l00138"></a>00138 @ingroup bvector

166

<a name="l00139"></a>00139 */

167

<a name="l00140"></a><a class="code" href="a00080.html">00140</a> class <a class="code" href="a00080.html" title="Class reference implements an object for bit assignment.">reference</a>

168

<a name="l00141"></a>00141 {

169

<a name="l00142"></a>00142 public:

170

<a name="l00143"></a><a class="code" href="a00080.html#ace927b54c909478e30a5dd38ccb0c0d6">00143</a> <a class="code" href="a00080.html#ace927b54c909478e30a5dd38ccb0c0d6">reference</a>(<a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& bv, <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> position)

171

<a name="l00144"></a>00144 : bv_(bv),

172

<a name="l00145"></a>00145 position_(position)

173

<a name="l00146"></a>00146 {}

174

<a name="l00147"></a>00147

175

<a name="l00148"></a><a class="code" href="a00080.html#a46fc4910419c5ea5de6158660fada675">00148</a> <a class="code" href="a00080.html#ace927b54c909478e30a5dd38ccb0c0d6">reference</a>(const <a class="code" href="a00080.html" title="Class reference implements an object for bit assignment.">reference</a>& ref)

176

<a name="l00149"></a>00149 : bv_(ref.bv_),

177

<a name="l00150"></a>00150 position_(ref.position_)

178

<a name="l00151"></a>00151 {

179

<a name="l00152"></a>00152 bv_.set(position_, ref.bv_.get_bit(position_));

180

<a name="l00153"></a>00153 }

181

<a name="l00154"></a>00154

182

<a name="l00155"></a><a class="code" href="a00080.html#a4d531a670ed0e8cfca01342fe02f030e">00155</a> <a class="code" href="a00080.html#a4d531a670ed0e8cfca01342fe02f030e">operator bool</a>() const

183

<a name="l00156"></a>00156 {

184

<a name="l00157"></a>00157 return bv_.get_bit(position_);

185

<a name="l00158"></a>00158 }

186

<a name="l00159"></a>00159

187

<a name="l00160"></a><a class="code" href="a00080.html#ac597a766c4942da598682c4917ee41c6">00160</a> const <a class="code" href="a00080.html" title="Class reference implements an object for bit assignment.">reference</a>& <a class="code" href="a00080.html#ac597a766c4942da598682c4917ee41c6">operator=</a>(const <a class="code" href="a00080.html" title="Class reference implements an object for bit assignment.">reference</a>& ref) const

188

<a name="l00161"></a>00161 {

189

<a name="l00162"></a>00162 bv_.set(position_, (bool)ref);

190

<a name="l00163"></a>00163 return *this;

191

<a name="l00164"></a>00164 }

192

<a name="l00165"></a>00165

193

<a name="l00166"></a>00166

194

<a name="l00167"></a>00167 /*! @brief Allocates and returns bit block.

195

<a name="l00168"></a>00168 @param alloc_factor

196

<a name="l00169"></a>00169 indicated how many blocks we want to allocate in chunk

197

<a name="l00170"></a>00170 total allocation is going to be bm::set_block_size * alloc_factor

198

<a name="l00171"></a>00171 Default allocation factor is 1

199

<a name="l00172"></a>00172 */

200

<a name="l00173"></a><a class="code" href="a00073.html#a65147da5bed4cb6130a0a95d71a80e94">00173</a> <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* <a class="code" href="a00073.html#a65147da5bed4cb6130a0a95d71a80e94" title="Allocates and returns bit block.">alloc_bit_block</a>(unsigned alloc_factor = 1)

201

<a name="l00174"></a>00174 {

202

<a name="l00175"></a>00175 return block_alloc_.allocate(<a class="code" href="a00110.html#a91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a> * alloc_factor, 0);

203

<a name="l00176"></a>00176 }

204

<a name="l00177"></a>00177

205

<a name="l00178"></a>00178 /*! @brief Frees bit block allocated by alloc_bit_block.

206

<a name="l00179"></a>00179 */

207

<a name="l00180"></a><a class="code" href="a00073.html#a348f8c8813e7765c7ceea5ba7a6342ca">00180</a> void <a class="code" href="a00073.html#a348f8c8813e7765c7ceea5ba7a6342ca" title="Frees bit block allocated by alloc_bit_block.">free_bit_block</a>(<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* block, unsigned alloc_factor = 1)

208

<a name="l00181"></a>00181 {

209

<a name="l00182"></a>00182 if (<a class="code" href="a00089.html#a13ba598909515339ceede09e3b9b0198">IS_VALID_ADDR</a>(block))

210

<a name="l00183"></a>00183 block_alloc_.deallocate(block, <a class="code" href="a00110.html#a91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a> * alloc_factor);

211

<a name="l00184"></a>00184 }

212

<a name="l00185"></a>00185

213

<a name="l00186"></a>00186 /*! @brief Allocates GAP block using bit block allocator (BA).

214

<a name="l00187"></a>00187

215

<a name="l00188"></a>00188 GAP blocks in BM library belong to levels. Each level has a

216

<a name="l00189"></a>00189 correspondent length described in bm::gap_len_table<>.

217

<a name="l00190"></a>00190

218

<a name="l00191"></a>00191 @param level GAP block level.

219

<a name="l00192"></a>00192 */

220

<a name="l00193"></a><a class="code" href="a00073.html#a6e5410e34efcc1e4af747b03795081dd">00193</a> <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">bm::gap_word_t</a>* <a class="code" href="a00073.html#a6e5410e34efcc1e4af747b03795081dd" title="Allocates GAP block using bit block allocator (BA).">alloc_gap_block</a>(unsigned level,

221

<a name="l00194"></a>00194 const <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* glevel_len)

222

<a name="l00195"></a>00195 {

223

<a name="l00196"></a>00196 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(level < <a class="code" href="a00110.html#a773e9f5341919d58000bd54d50038733">bm::gap_levels</a>);

224

<a name="l00197"></a>00197 unsigned len =

225

<a name="l00198"></a>00198 glevel_len[level] / (sizeof(<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>) / sizeof(<a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>));

226

<a name="l00199"></a>00199

227

<a name="l00200"></a>00200 return (<a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">bm::gap_word_t</a>*)block_alloc_.allocate(len, 0);

228

<a name="l00201"></a>00201 }

229

<a name="l00202"></a>00202

230

<a name="l00203"></a>00203 /*! @brief Frees GAP block using bot block allocator (BA)

231

<a name="l00204"></a>00204 */

232

<a name="l00205"></a><a class="code" href="a00073.html#a0a54ad389bbfbb1bec04133b97c64d9b">00205</a> void <a class="code" href="a00073.html#a0a54ad389bbfbb1bec04133b97c64d9b" title="Frees GAP block using bot block allocator (BA).">free_gap_block</a>(<a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">bm::gap_word_t</a>* block,

233

<a name="l00206"></a>00206 const <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* glevel_len)

234

<a name="l00207"></a>00207 {

235

<a name="l00208"></a>00208 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(<a class="code" href="a00089.html#a13ba598909515339ceede09e3b9b0198">IS_VALID_ADDR</a>((<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*)block));

236

<a name="l00209"></a>00209

237

<a name="l00210"></a>00210 unsigned len = <a class="code" href="a00114.html#ga0419ed06e2f0b7891e7d721546f5fb45" title="Returs GAP block capacity.">gap_capacity</a>(block, glevel_len);

238

<a name="l00211"></a>00211 len /= sizeof(<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>) / sizeof(<a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">bm::gap_word_t</a>);

239

<a name="l00212"></a>00212 block_alloc_.deallocate((<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*)block, len);

240

<a name="l00213"></a>00213 }

241

<a name="l00214"></a>00214

242

<a name="l00215"></a>00215 /*! @brief Allocates block of pointers.

243

<a name="l00216"></a>00216 */

244

<a name="l00217"></a><a class="code" href="a00073.html#a512a255f1afe5f3f8319e4b2b9c1eb4d">00217</a> void* <a class="code" href="a00073.html#a512a255f1afe5f3f8319e4b2b9c1eb4d" title="Allocates block of pointers.">alloc_ptr</a>(unsigned size = <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>)

245

<a name="l00218"></a>00218 {

246

<a name="l00219"></a>00219 return ptr_alloc_.allocate(size, 0);

247

<a name="l00220"></a>00220 }

248

<a name="l00221"></a>00221

249

<a name="l00222"></a>00222 /*! @brief Frees block of pointers.

250

<a name="l00223"></a>00223 */

251

<a name="l00224"></a><a class="code" href="a00073.html#a31bae2a441ae2d27724d2c938b45378c">00224</a> void <a class="code" href="a00073.html#a31bae2a441ae2d27724d2c938b45378c" title="Frees block of pointers.">free_ptr</a>(void* p, unsigned size = <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>)

252

<a name="l00225"></a>00225 {

253

<a name="l00226"></a>00226 if (p)

254

<a name="l00227"></a>00227 ptr_alloc_.deallocate(p, size);

255

<a name="l00228"></a>00228 }

256

<a name="l00229"></a>00229 private:

257

<a name="l00230"></a>00230 BA block_alloc_;

258

<a name="l00231"></a>00231 PA ptr_alloc_;

259

<a name="l00232"></a>00232 };

260

<a name="l00233"></a>00233

261

<a name="l00234"></a><a class="code" href="a00122.html#gab9059bfb40a6588cdbacfd93901593c1">00234</a> typedef <a class="code" href="a00073.html" title="BM style allocator adapter.">mem_alloc<block_allocator, ptr_allocator></a> <a class="code" href="a00073.html" title="BM style allocator adapter.">standard_allocator</a>;

262

<a name="l00235"></a>00235

263

<a name="l00236"></a>00236 /** @} */

264

<a name="l00237"></a>00237

265

<a name="l00238"></a>00238

266

<a name="l00239"></a>00239 } // namespace bm

267

<a name="l00240"></a>00240

193

<a name="l00166"></a><a class="code" href="a00080.html#ae7fd4a0de8fe3d984322e8a690feeb5a">00166</a> const <a class="code" href="a00080.html" title="Class reference implements an object for bit assignment.">reference</a>& <a class="code" href="a00080.html#ac597a766c4942da598682c4917ee41c6">operator=</a>(bool value) const

194

<a name="l00167"></a>00167 {

195

<a name="l00168"></a>00168 bv_.set(position_, value);

196

<a name="l00169"></a>00169 return *this;

197

<a name="l00170"></a>00170 }

198

<a name="l00171"></a>00171

199

<a name="l00172"></a><a class="code" href="a00080.html#ab761552f565e9ecfe263fd8325d50852">00172</a> bool <a class="code" href="a00080.html#ab761552f565e9ecfe263fd8325d50852">operator==</a>(const <a class="code" href="a00080.html" title="Class reference implements an object for bit assignment.">reference</a>& ref) const

200

<a name="l00173"></a>00173 {

201

<a name="l00174"></a>00174 return bool(*this) == bool(ref);

202

<a name="l00175"></a>00175 }

203

<a name="l00176"></a>00176

204

<a name="l00177"></a>00177 /*! Bitwise AND. Performs operation: bit = bit AND value */

205

<a name="l00178"></a><a class="code" href="a00080.html#a78514f588110835ecd21f3c8737b6a3f">00178</a> const <a class="code" href="a00080.html" title="Class reference implements an object for bit assignment.">reference</a>& <a class="code" href="a00080.html#a78514f588110835ecd21f3c8737b6a3f">operator&=</a>(bool value) const

206

<a name="l00179"></a>00179 {

207

<a name="l00180"></a>00180 bv_.set_bit_and(position_, value);

208

<a name="l00181"></a>00181 return *this;

209

<a name="l00182"></a>00182 }

210

<a name="l00183"></a>00183

211

<a name="l00184"></a>00184 /*! Bitwise OR. Performs operation: bit = bit OR value */

212

<a name="l00185"></a><a class="code" href="a00080.html#acbf8b97f7b52f1c9b81a1d9129986cff">00185</a> const <a class="code" href="a00080.html" title="Class reference implements an object for bit assignment.">reference</a>& <a class="code" href="a00080.html#acbf8b97f7b52f1c9b81a1d9129986cff">operator|=</a>(bool value) const

213

<a name="l00186"></a>00186 {

214

<a name="l00187"></a>00187 if (value != bv_.get_bit(position_))

215

<a name="l00188"></a>00188 {

216

<a name="l00189"></a>00189 bv_.set_bit(position_);

217

<a name="l00190"></a>00190 }

218

<a name="l00191"></a>00191 return *this;

219

<a name="l00192"></a>00192 }

220

<a name="l00193"></a>00193

221

<a name="l00194"></a>00194 /*! Bitwise exclusive-OR (XOR). Performs operation: bit = bit XOR value */

222

<a name="l00195"></a><a class="code" href="a00080.html#a94e3b8c46d1f83c5999c8eaf426b8e9b">00195</a> const <a class="code" href="a00080.html" title="Class reference implements an object for bit assignment.">reference</a>& <a class="code" href="a00080.html#a94e3b8c46d1f83c5999c8eaf426b8e9b">operator^=</a>(bool value) const

223

<a name="l00196"></a>00196 {

224

<a name="l00197"></a>00197 bv_.set(position_, value != bv_.get_bit(position_));

225

<a name="l00198"></a>00198 return *this;

226

<a name="l00199"></a>00199 }

227

<a name="l00200"></a>00200

228

<a name="l00201"></a>00201 /*! Logical Not operator */

229

<a name="l00202"></a><a class="code" href="a00080.html#aa214fa361c24c57c9fd4d26441ff6c12">00202</a> bool <a class="code" href="a00080.html#aa214fa361c24c57c9fd4d26441ff6c12">operator!</a>() const

230

<a name="l00203"></a>00203 {

231

<a name="l00204"></a>00204 return !bv_.get_bit(position_);

232

<a name="l00205"></a>00205 }

233

<a name="l00206"></a>00206

234

<a name="l00207"></a>00207 /*! Bit Not operator */

235

<a name="l00208"></a><a class="code" href="a00080.html#a70357e67d8022147971ad970a80108d0">00208</a> bool <a class="code" href="a00080.html#a70357e67d8022147971ad970a80108d0">operator~</a>() const

236

<a name="l00209"></a>00209 {

237

<a name="l00210"></a>00210 return !bv_.get_bit(position_);

238

<a name="l00211"></a>00211 }

239

<a name="l00212"></a>00212

240

<a name="l00213"></a>00213 /*! Negates the bit value */

241

<a name="l00214"></a><a class="code" href="a00080.html#a31f8e1425e1563f1f5890b77f736f323">00214</a> <a class="code" href="a00080.html" title="Class reference implements an object for bit assignment.">reference</a>& <a class="code" href="a00080.html#a31f8e1425e1563f1f5890b77f736f323">flip</a>()

242

<a name="l00215"></a>00215 {

243

<a name="l00216"></a>00216 bv_.flip(position_);

244

<a name="l00217"></a>00217 return *this;

245

<a name="l00218"></a>00218 }

246

<a name="l00219"></a>00219

247

<a name="l00220"></a>00220 private:

248

<a name="l00221"></a>00221 <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& bv_; //!< Reference variable on the parent.

249

<a name="l00222"></a>00222 <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> position_; //!< Position in the parent bitvector.

250

<a name="l00223"></a>00223 };

251

<a name="l00224"></a>00224

252

<a name="l00225"></a><a class="code" href="a00044.html#abd935c7ebeb4d3c65caf3d236d24708a">00225</a> typedef bool <a class="code" href="a00044.html#abd935c7ebeb4d3c65caf3d236d24708a">const_reference</a>;

253

<a name="l00226"></a>00226

254

<a name="l00227"></a>00227 /*!

255

<a name="l00228"></a>00228 @brief Base class for all iterators.

256

<a name="l00229"></a>00229 @ingroup bvector

257

<a name="l00230"></a>00230 */

258

<a name="l00231"></a><a class="code" href="a00072.html">00231</a> class <a class="code" href="a00072.html" title="Base class for all iterators.">iterator_base</a>

259

<a name="l00232"></a>00232 {

260

<a name="l00233"></a><a class="code" href="a00072.html#a5bb8687c5e87638689649a12c54187cb">00233</a> friend class <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector</a>;

261

<a name="l00234"></a>00234 public:

262

<a name="l00235"></a><a class="code" href="a00072.html#ac6063f4c924cf6702a6bdbf2a889a980">00235</a> <a class="code" href="a00072.html#ac6063f4c924cf6702a6bdbf2a889a980">iterator_base</a>() : <a class="code" href="a00072.html#ad341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a>(0), <a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>(bm::<a class="code" href="a00115.html#a104b924a1df81542db2a6296fbf26a65">id_max</a>), <a class="code" href="a00072.html#a6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a>(0) {}

263

<a name="l00236"></a>00236

264

<a name="l00237"></a><a class="code" href="a00072.html#ab3312a717f0f899c8349c257d85d30a6">00237</a> bool <a class="code" href="a00072.html#ab3312a717f0f899c8349c257d85d30a6">operator==</a>(const <a class="code" href="a00072.html" title="Base class for all iterators.">iterator_base</a>& it) const

265

<a name="l00238"></a>00238 {

266

<a name="l00239"></a>00239 return (<a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> == it.<a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>) && (<a class="code" href="a00072.html#ad341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a> == it.<a class="code" href="a00072.html#ad341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a>);

267

<a name="l00240"></a>00240 }

268

<a name="l00241"></a>00241

269

<a name="l00242"></a>00242 #endif

269

<a name="l00242"></a><a class="code" href="a00072.html#a479fe29cb33db62d7216ebc553ec9f0c">00242</a> bool <a class="code" href="a00072.html#a479fe29cb33db62d7216ebc553ec9f0c">operator!=</a>(const <a class="code" href="a00072.html" title="Base class for all iterators.">iterator_base</a>& it) const

270

<a name="l00243"></a>00243 {

271

<a name="l00244"></a>00244 return ! <a class="code" href="a00072.html#ab3312a717f0f899c8349c257d85d30a6">operator==</a>(it);

272

<a name="l00245"></a>00245 }

273

<a name="l00246"></a>00246

274

<a name="l00247"></a><a class="code" href="a00072.html#aac47c0d848ef2300708e32126579bed1">00247</a> bool <a class="code" href="a00072.html#aac47c0d848ef2300708e32126579bed1">operator < </a>(const <a class="code" href="a00072.html" title="Base class for all iterators.">iterator_base</a>& it) const

275

<a name="l00248"></a>00248 {

276

<a name="l00249"></a>00249 return <a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> < it.<a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>;

277

<a name="l00250"></a>00250 }

278

<a name="l00251"></a>00251

279

<a name="l00252"></a><a class="code" href="a00072.html#a2f0ea98e14ad5cface258eb2ac6abc23">00252</a> bool <a class="code" href="a00072.html#a2f0ea98e14ad5cface258eb2ac6abc23">operator <= </a>(const <a class="code" href="a00072.html" title="Base class for all iterators.">iterator_base</a>& it) const

280

<a name="l00253"></a>00253 {

281

<a name="l00254"></a>00254 return <a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> <= it.<a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>;

282

<a name="l00255"></a>00255 }

283

<a name="l00256"></a>00256

284

<a name="l00257"></a><a class="code" href="a00072.html#a418a0c30704aafc6f6aadb75b873da74">00257</a> bool <a class="code" href="a00072.html#a418a0c30704aafc6f6aadb75b873da74">operator > </a>(const <a class="code" href="a00072.html" title="Base class for all iterators.">iterator_base</a>& it) const

285

<a name="l00258"></a>00258 {

286

<a name="l00259"></a>00259 return <a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> > it.<a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>;

287

<a name="l00260"></a>00260 }

288

<a name="l00261"></a>00261

289

<a name="l00262"></a><a class="code" href="a00072.html#a227f59d61fc06bd398a1d282c94edb92">00262</a> bool <a class="code" href="a00072.html#a227f59d61fc06bd398a1d282c94edb92">operator >= </a>(const <a class="code" href="a00072.html" title="Base class for all iterators.">iterator_base</a>& it) const

290

<a name="l00263"></a>00263 {

291

<a name="l00264"></a>00264 return <a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> >= it.<a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>;

292

<a name="l00265"></a>00265 }

293

<a name="l00266"></a>00266

294

<a name="l00267"></a>00267 /**

295

<a name="l00268"></a>00268 \fn bool bm::bvector::iterator_base::valid() const

296

<a name="l00269"></a>00269 \brief Checks if iterator is still valid. Analog of != 0 comparison for pointers.

297

<a name="l00270"></a>00270 \returns true if iterator is valid.

298

<a name="l00271"></a>00271 */

299

<a name="l00272"></a><a class="code" href="a00072.html#aa06eb362d550d37b214591a113be4e7b">00272</a> bool <a class="code" href="a00072.html#aa06eb362d550d37b214591a113be4e7b" title="Checks if iterator is still valid.">valid</a>() const

300

<a name="l00273"></a>00273 {

301

<a name="l00274"></a>00274 return <a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> != <a class="code" href="a00115.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>;

302

<a name="l00275"></a>00275 }

303

<a name="l00276"></a>00276

304

<a name="l00277"></a>00277 /**

305

<a name="l00278"></a>00278 \fn bool bm::bvector::iterator_base::invalidate()

306

<a name="l00279"></a>00279 \brief Turns iterator into an invalid state.

307

<a name="l00280"></a>00280 */

308

<a name="l00281"></a><a class="code" href="a00072.html#a5566e1be1039764a8f4643f38b9d8f9e">00281</a> void <a class="code" href="a00072.html#a5566e1be1039764a8f4643f38b9d8f9e" title="Turns iterator into an invalid state.">invalidate</a>()

309

<a name="l00282"></a>00282 {

310

<a name="l00283"></a>00283 <a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> = <a class="code" href="a00115.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>;

311

<a name="l00284"></a>00284 }

312

<a name="l00285"></a>00285

313

<a name="l00286"></a>00286 public:

314

<a name="l00287"></a>00287

315

<a name="l00288"></a>00288 /** Information about current bitblock. */

316

<a name="l00289"></a><a class="code" href="a00035.html">00289</a> struct <a class="code" href="a00035.html" title="Information about current bitblock.">bitblock_descr</a>

317

<a name="l00290"></a>00290 {

318

<a name="l00291"></a><a class="code" href="a00035.html#a1493d1dde691bc56ac4fdd31ad8206b6">00291</a> const <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* <a class="code" href="a00035.html#a1493d1dde691bc56ac4fdd31ad8206b6" title="Word pointer.">ptr</a>; //!< Word pointer.

319

<a name="l00292"></a><a class="code" href="a00035.html#a98b3ad31436094a6709f012bdac61f58">00292</a> unsigned <a class="code" href="a00035.html#a98b3ad31436094a6709f012bdac61f58" title="Unpacked list of ON bits.">bits</a>[32]; //!< Unpacked list of ON bits

320

<a name="l00293"></a><a class="code" href="a00035.html#afa87824f495bddbc2b835193e524630e">00293</a> unsigned <a class="code" href="a00035.html#afa87824f495bddbc2b835193e524630e" title="Current position in the bit list.">idx</a>; //!< Current position in the bit list

321

<a name="l00294"></a><a class="code" href="a00035.html#a8f005df34342398c3ec65aa3f6f57db0">00294</a> unsigned <a class="code" href="a00035.html#a8f005df34342398c3ec65aa3f6f57db0" title="Number of ON bits.">cnt</a>; //!< Number of ON bits

322

<a name="l00295"></a><a class="code" href="a00035.html#ab83089689e5235239ebc50731e3d3c84">00295</a> <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00035.html#ab83089689e5235239ebc50731e3d3c84" title="Last bit position before.">pos</a>; //!< Last bit position before

323

<a name="l00296"></a>00296 };

324

<a name="l00297"></a>00297

325

<a name="l00298"></a>00298 /** Information about current DGAP block. */

326

<a name="l00299"></a><a class="code" href="a00060.html">00299</a> struct <a class="code" href="a00060.html" title="Information about current DGAP block.">dgap_descr</a>

327

<a name="l00300"></a>00300 {

328

<a name="l00301"></a><a class="code" href="a00060.html#a06ab78e3b3b9c52de9b491dc2ad3a72f">00301</a> const <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* <a class="code" href="a00060.html#a06ab78e3b3b9c52de9b491dc2ad3a72f" title="Word pointer.">ptr</a>; //!< Word pointer.

329

<a name="l00302"></a><a class="code" href="a00060.html#af7766714caa1c9cb00750cd8b91314c2">00302</a> <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a> <a class="code" href="a00060.html#af7766714caa1c9cb00750cd8b91314c2" title="Current dgap length.">gap_len</a>; //!< Current dgap length.

330

<a name="l00303"></a>00303 };

331

<a name="l00304"></a>00304

332

<a name="l00305"></a>00305 protected:

333

<a name="l00306"></a><a class="code" href="a00072.html#ad341d73f3dc97bb5e70befcae7cbf014">00306</a> <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>* <a class="code" href="a00072.html#ad341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a>; //!< Pointer on parent bitvector

334

<a name="l00307"></a><a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9">00307</a> <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>; //!< Bit position (bit idx)

335

<a name="l00308"></a><a class="code" href="a00072.html#a6d92e5c216b76dfbccbc2ebab1dd7b8d">00308</a> const <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* <a class="code" href="a00072.html#a6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a>; //!< Block pointer.(NULL-invalid)

336

<a name="l00309"></a><a class="code" href="a00072.html#a8a9a7fa7ba70eb1aa10180e40239fe7f">00309</a> unsigned <a class="code" href="a00072.html#a8a9a7fa7ba70eb1aa10180e40239fe7f" title="Type of block. 0-Bit, 1-GAP.">block_type_</a>; //!< Type of block. 0-Bit, 1-GAP

337

<a name="l00310"></a><a class="code" href="a00072.html#a07908a3bcc023120e8bbf4e81ba62139">00310</a> unsigned <a class="code" href="a00072.html#a07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a>; //!< Block index

338

<a name="l00311"></a>00311

339

<a name="l00312"></a>00312 /*! Block type dependent information for current block. */

340

<a name="l00313"></a><a class="code" href="a00040.html">00313</a> union <a class="code" href="a00040.html">block_descr</a>

341

<a name="l00314"></a>00314 {

342

<a name="l00315"></a><a class="code" href="a00040.html#a9e021a3ef144c7b26fa295ad4b64e164">00315</a> <a class="code" href="a00035.html" title="Information about current bitblock.">bitblock_descr</a> <a class="code" href="a00040.html#a9e021a3ef144c7b26fa295ad4b64e164" title="BitBlock related info.">bit_</a>; //!< BitBlock related info.

343

<a name="l00316"></a><a class="code" href="a00040.html#a00fd9ec3340550372d0d06865ce96e43">00316</a> <a class="code" href="a00060.html" title="Information about current DGAP block.">dgap_descr</a> <a class="code" href="a00040.html#a00fd9ec3340550372d0d06865ce96e43" title="DGAP block related info.">gap_</a>; //!< DGAP block related info.

344

<a name="l00317"></a>00317 } <a class="code" href="a00072.html#a47ba31f695597a948e7e18971f5c6236">bdescr_</a>;

345

<a name="l00318"></a>00318 };

346

<a name="l00319"></a>00319

347

<a name="l00320"></a>00320 /*!

348

<a name="l00321"></a>00321 @brief Output iterator iterator designed to set "ON" bits based on

349

<a name="l00322"></a>00322 input sequence of integers (bit indeces).

350

<a name="l00323"></a>00323

351

<a name="l00324"></a>00324 STL container can be converted to bvector using this iterator

352

<a name="l00325"></a>00325 Insert iterator guarantees the vector will be dynamically resized

353

<a name="l00326"></a>00326 (set_bit does not do that).

354

<a name="l00327"></a>00327

355

<a name="l00328"></a>00328 @note

356

<a name="l00329"></a>00329 If you have many bits to set it is a good idea to use output iterator

357

<a name="l00330"></a>00330 instead of explicitly calling set, because iterator may implement

358

<a name="l00331"></a>00331 some performance specific tricks to make sure bulk insert is fast.

359

<a name="l00332"></a>00332

360

<a name="l00333"></a>00333 @ingroup bvector

361

<a name="l00334"></a>00334 */

362

<a name="l00335"></a><a class="code" href="a00071.html">00335</a> class <a class="code" href="a00071.html" title="Output iterator iterator designed to set &quot;ON&quot; bits based on input sequence...">insert_iterator</a>

363

<a name="l00336"></a>00336 {

364

<a name="l00337"></a>00337 public:

365

<a name="l00338"></a>00338 #ifndef BM_NO_STL

366

<a name="l00339"></a><a class="code" href="a00071.html#a05191a66ec380649000b9b6ea14c06b7">00339</a> typedef std::output_iterator_tag <a class="code" href="a00071.html#a05191a66ec380649000b9b6ea14c06b7">iterator_category</a>;

367

<a name="l00340"></a>00340 #endif

368

<a name="l00341"></a><a class="code" href="a00071.html#ac4e9f9614f7075703835fb78b4898c9b">00341</a> typedef unsigned <a class="code" href="a00071.html#ac4e9f9614f7075703835fb78b4898c9b">value_type</a>;

369

<a name="l00342"></a><a class="code" href="a00071.html#a77f5e1410a06a9c0b8800c8dc9a8e7fa">00342</a> typedef void <a class="code" href="a00071.html#a77f5e1410a06a9c0b8800c8dc9a8e7fa">difference_type</a>;

370

<a name="l00343"></a><a class="code" href="a00071.html#a0751c5e25531fac92a3b8be471ae2ffc">00343</a> typedef void <a class="code" href="a00071.html#a0751c5e25531fac92a3b8be471ae2ffc">pointer</a>;

371

<a name="l00344"></a><a class="code" href="a00071.html#a7b51421d9465b502e0fade68b788bb04">00344</a> typedef void <a class="code" href="a00080.html" title="Class reference implements an object for bit assignment.">reference</a>;

372

<a name="l00345"></a>00345

373

<a name="l00346"></a><a class="code" href="a00071.html#ad0a9fbadaeac7315d837d180f09dc737">00346</a> <a class="code" href="a00071.html#ad0a9fbadaeac7315d837d180f09dc737">insert_iterator</a>(<a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvect</a>)

374

<a name="l00347"></a>00347 : <a class="code" href="a00071.html#ad6d883a5f4e66f397cc0ef2a71255032">bvect_</a>(bvect),

375

<a name="l00348"></a>00348 <a class="code" href="a00071.html#a2a3cb7001d4469b6b0491105dfd443c0">max_bit_</a>(bvect.<a class="code" href="a00044.html#a1b021e7217f530390511e16b9b25f631" title="return current size of the vector (bits)">size</a>())

376

<a name="l00349"></a>00349 {

377

<a name="l00350"></a>00350 }

378

<a name="l00351"></a>00351

379

<a name="l00352"></a><a class="code" href="a00071.html#a9f670d7a141a161b171930416621794a">00352</a> <a class="code" href="a00071.html" title="Output iterator iterator designed to set &quot;ON&quot; bits based on input sequence...">insert_iterator</a>& <a class="code" href="a00071.html#a9f670d7a141a161b171930416621794a">operator=</a>(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n)

380

<a name="l00353"></a>00353 {

381

<a name="l00354"></a>00354 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(n < <a class="code" href="a00115.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>);

382

<a name="l00355"></a>00355

383

<a name="l00356"></a>00356 if (n >= <a class="code" href="a00071.html#a2a3cb7001d4469b6b0491105dfd443c0">max_bit_</a>)

384

<a name="l00357"></a>00357 {

385

<a name="l00358"></a>00358 <a class="code" href="a00071.html#a2a3cb7001d4469b6b0491105dfd443c0">max_bit_</a> = n;

386

<a name="l00359"></a>00359 if (n >= <a class="code" href="a00071.html#ad6d883a5f4e66f397cc0ef2a71255032">bvect_</a>.size())

387

<a name="l00360"></a>00360 {

388

<a name="l00361"></a>00361 <a class="code" href="a00071.html#ad6d883a5f4e66f397cc0ef2a71255032">bvect_</a>.resize(n + 1);

389

<a name="l00362"></a>00362 }

390

<a name="l00363"></a>00363 }

391

<a name="l00364"></a>00364

392

<a name="l00365"></a>00365 <a class="code" href="a00071.html#ad6d883a5f4e66f397cc0ef2a71255032">bvect_</a>.set(n);

393

<a name="l00366"></a>00366 return *this;

394

<a name="l00367"></a>00367 }

395

<a name="l00368"></a>00368

396

<a name="l00369"></a>00369 /*! Returns *this without doing anything (no-op) */

397

<a name="l00370"></a><a class="code" href="a00071.html#aac559ecfa8a71ec712af743fa4e50196">00370</a> <a class="code" href="a00071.html" title="Output iterator iterator designed to set &quot;ON&quot; bits based on input sequence...">insert_iterator</a>& <a class="code" href="a00071.html#aac559ecfa8a71ec712af743fa4e50196">operator*</a>() { return *this; }

398

<a name="l00371"></a>00371 /*! Returns *this. This iterator does not move (no-op) */

399

<a name="l00372"></a><a class="code" href="a00071.html#a958e6d8020853b9bcbb2ba19eb0f7a71">00372</a> <a class="code" href="a00071.html" title="Output iterator iterator designed to set &quot;ON&quot; bits based on input sequence...">insert_iterator</a>& <a class="code" href="a00071.html#a958e6d8020853b9bcbb2ba19eb0f7a71">operator++</a>() { return *this; }

400

<a name="l00373"></a>00373 /*! Returns *this. This iterator does not move (no-op)*/

401

<a name="l00374"></a><a class="code" href="a00071.html#a438735f2ccbeb6dd88621328c3220470">00374</a> <a class="code" href="a00071.html" title="Output iterator iterator designed to set &quot;ON&quot; bits based on input sequence...">insert_iterator</a>& <a class="code" href="a00071.html#a438735f2ccbeb6dd88621328c3220470">operator++</a>(int) { return *this; }

402

<a name="l00375"></a>00375

403

<a name="l00376"></a>00376 protected:

404

<a name="l00377"></a><a class="code" href="a00071.html#ad6d883a5f4e66f397cc0ef2a71255032">00377</a> <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00071.html#ad6d883a5f4e66f397cc0ef2a71255032">bvect_</a>;

405

<a name="l00378"></a><a class="code" href="a00071.html#a2a3cb7001d4469b6b0491105dfd443c0">00378</a> <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00071.html#a2a3cb7001d4469b6b0491105dfd443c0">max_bit_</a>;

406

<a name="l00379"></a>00379 };

407

<a name="l00380"></a>00380

408

<a name="l00381"></a>00381 /*!

409

<a name="l00382"></a>00382 @brief Constant input iterator designed to enumerate "ON" bits

410

<a name="l00383"></a>00383 @ingroup bvector

411

<a name="l00384"></a>00384 */

412

<a name="l00385"></a><a class="code" href="a00063.html">00385</a> class <a class="code" href="a00063.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a> : public <a class="code" href="a00072.html" title="Base class for all iterators.">iterator_base</a>

413

<a name="l00386"></a>00386 {

414

<a name="l00387"></a>00387 public:

415

<a name="l00388"></a>00388 #ifndef BM_NO_STL

416

<a name="l00389"></a><a class="code" href="a00063.html#a0af72b4644bc1148f549d21a00330210">00389</a> typedef std::input_iterator_tag <a class="code" href="a00063.html#a0af72b4644bc1148f549d21a00330210">iterator_category</a>;

417

<a name="l00390"></a>00390 #endif

418

<a name="l00391"></a><a class="code" href="a00063.html#add1a3fd37bf2915c5689733969d9ce78">00391</a> typedef unsigned <a class="code" href="a00063.html#add1a3fd37bf2915c5689733969d9ce78">value_type</a>;

419

<a name="l00392"></a><a class="code" href="a00063.html#a46bd8935b22e5a83be62e9e8e00785e1">00392</a> typedef unsigned <a class="code" href="a00063.html#a46bd8935b22e5a83be62e9e8e00785e1">difference_type</a>;

420

<a name="l00393"></a><a class="code" href="a00063.html#ada062866d44923ecab233a51f4daf26e">00393</a> typedef unsigned* <a class="code" href="a00063.html#ada062866d44923ecab233a51f4daf26e">pointer</a>;

421

<a name="l00394"></a><a class="code" href="a00063.html#a827edd466230259a8047f2c26baf830f">00394</a> typedef unsigned& <a class="code" href="a00080.html" title="Class reference implements an object for bit assignment.">reference</a>;

422

<a name="l00395"></a>00395

423

<a name="l00396"></a>00396 public:

424

<a name="l00397"></a><a class="code" href="a00063.html#a4389008f0affee77ef761cab3e5d0f5d">00397</a> <a class="code" href="a00063.html#a4389008f0affee77ef761cab3e5d0f5d">enumerator</a>() : <a class="code" href="a00072.html" title="Base class for all iterators.">iterator_base</a>() {}

425

<a name="l00398"></a><a class="code" href="a00063.html#a9f59ce31704b3fe71cf41dc4eeffbd43">00398</a> <a class="code" href="a00063.html#a4389008f0affee77ef761cab3e5d0f5d">enumerator</a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>* <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvect</a>, int position)

426

<a name="l00399"></a>00399 : <a class="code" href="a00072.html" title="Base class for all iterators.">iterator_base</a>()

427

<a name="l00400"></a>00400 {

428

<a name="l00401"></a>00401 this-><a class="code" href="a00072.html#ad341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a> = const_cast<<a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>*>(bvect);

429

<a name="l00402"></a>00402 if (position == 0)

430

<a name="l00403"></a>00403 {

431

<a name="l00404"></a>00404 <a class="code" href="a00063.html#a7443e66e31258638cdee4ed3bc2d368c">go_first</a>();

432

<a name="l00405"></a>00405 }

433

<a name="l00406"></a>00406 else

434

<a name="l00407"></a>00407 {

435

<a name="l00408"></a>00408 this-><a class="code" href="a00072.html#a5566e1be1039764a8f4643f38b9d8f9e" title="Turns iterator into an invalid state.">invalidate</a>();

436

<a name="l00409"></a>00409 }

437

<a name="l00410"></a>00410 }

438

<a name="l00411"></a>00411

439

<a name="l00412"></a><a class="code" href="a00063.html#adc85b4fca8577fa3ab643fd087948f1b">00412</a> <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00063.html#adc85b4fca8577fa3ab643fd087948f1b">operator*</a>() const

440

<a name="l00413"></a>00413 {

441

<a name="l00414"></a>00414 return this-><a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>;

442

<a name="l00415"></a>00415 }

443

<a name="l00416"></a>00416

444

<a name="l00417"></a><a class="code" href="a00063.html#af47c7379555c7b42c7de1cf84f1cce6d">00417</a> <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00063.html#af47c7379555c7b42c7de1cf84f1cce6d">value</a>() const

445

<a name="l00418"></a>00418 {

446

<a name="l00419"></a>00419 return this-><a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>;

447

<a name="l00420"></a>00420 }

448

<a name="l00421"></a>00421

449

<a name="l00422"></a><a class="code" href="a00063.html#aab2b31ecf11e614cf2de6eab71d92512">00422</a> <a class="code" href="a00063.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a>& <a class="code" href="a00063.html#aab2b31ecf11e614cf2de6eab71d92512">operator++</a>()

450

<a name="l00423"></a>00423 {

451

<a name="l00424"></a>00424 return this-><a class="code" href="a00063.html#a58b4ee025ba7b6545eacad79e7031069">go_up</a>();

452

<a name="l00425"></a>00425 }

453

<a name="l00426"></a>00426

454

<a name="l00427"></a><a class="code" href="a00063.html#a1237d3258c73d41e93159063fb2708a0">00427</a> <a class="code" href="a00063.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a> <a class="code" href="a00063.html#aab2b31ecf11e614cf2de6eab71d92512">operator++</a>(int)

455

<a name="l00428"></a>00428 {

456

<a name="l00429"></a>00429 <a class="code" href="a00063.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a> tmp = *this;

457

<a name="l00430"></a>00430 this-><a class="code" href="a00063.html#a58b4ee025ba7b6545eacad79e7031069">go_up</a>();

458

<a name="l00431"></a>00431 return tmp;

459

<a name="l00432"></a>00432 }

460

<a name="l00433"></a>00433

461

<a name="l00434"></a>00434

462

<a name="l00435"></a><a class="code" href="a00063.html#a7443e66e31258638cdee4ed3bc2d368c">00435</a> void <a class="code" href="a00063.html#a7443e66e31258638cdee4ed3bc2d368c">go_first</a>()

463

<a name="l00436"></a>00436 {

464

<a name="l00437"></a>00437 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(this-><a class="code" href="a00072.html#ad341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a>);

465

<a name="l00438"></a>00438

466

<a name="l00439"></a>00439 #ifdef BMCOUNTOPT

467

<a name="l00440"></a>00440 if (this-><a class="code" href="a00072.html#ad341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a>->count_is_valid_ &&

468

<a name="l00441"></a>00441 this->bv_->count_ == 0)

469

<a name="l00442"></a>00442 {

470

<a name="l00443"></a>00443 this-><a class="code" href="a00072.html#a5566e1be1039764a8f4643f38b9d8f9e" title="Turns iterator into an invalid state.">invalidate</a>();

471

<a name="l00444"></a>00444 return;

472

<a name="l00445"></a>00445 }

473

<a name="l00446"></a>00446 #endif

474

<a name="l00447"></a>00447

475

<a name="l00448"></a>00448 <a class="code" href="a00044.html#a1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>* bman = &(this-><a class="code" href="a00072.html#ad341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a>->blockman_);

476

<a name="l00449"></a>00449 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*** blk_root = bman->blocks_root();

477

<a name="l00450"></a>00450

478

<a name="l00451"></a>00451 this-><a class="code" href="a00072.html#a07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a> = this-><a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>= 0;

479

<a name="l00452"></a>00452 unsigned i, j;

480

<a name="l00453"></a>00453

481

<a name="l00454"></a>00454 for (i = 0; i < bman->top_block_size(); ++i)

482

<a name="l00455"></a>00455 {

483

<a name="l00456"></a>00456 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>** blk_blk = blk_root[i];

484

<a name="l00457"></a>00457

485

<a name="l00458"></a>00458 if (blk_blk == 0) // not allocated

486

<a name="l00459"></a>00459 {

487

<a name="l00460"></a>00460 this-><a class="code" href="a00072.html#a07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a> += <a class="code" href="a00115.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>;

488

<a name="l00461"></a>00461 this-><a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += <a class="code" href="a00115.html#a4dedd13a7b8a27c5067b20118002f025">bm::bits_in_array</a>;

489

<a name="l00462"></a>00462 continue;

490

<a name="l00463"></a>00463 }

491

<a name="l00464"></a>00464

492

<a name="l00465"></a>00465

493

<a name="l00466"></a>00466 for (j = 0; j < <a class="code" href="a00115.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>; ++j,++(this-><a class="code" href="a00072.html#a07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a>))

494

<a name="l00467"></a>00467 {

495

<a name="l00468"></a>00468 this-><a class="code" href="a00072.html#a6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a> = blk_blk[j];

496

<a name="l00469"></a>00469

497

<a name="l00470"></a>00470 if (this-><a class="code" href="a00072.html#a6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a> == 0)

498

<a name="l00471"></a>00471 {

499

<a name="l00472"></a>00472 this-><a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += <a class="code" href="a00115.html#ae9916f69ced0347d94472d7944ea0e45">bits_in_block</a>;

500

<a name="l00473"></a>00473 continue;

501

<a name="l00474"></a>00474 }

502

<a name="l00475"></a>00475

503

<a name="l00476"></a>00476 if (<a class="code" href="a00092.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>((*bman), this-><a class="code" href="a00072.html#a6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a>, this-><a class="code" href="a00072.html#a07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a>))

504

<a name="l00477"></a>00477 {

505

<a name="l00478"></a>00478 this-><a class="code" href="a00072.html#a8a9a7fa7ba70eb1aa10180e40239fe7f" title="Type of block. 0-Bit, 1-GAP.">block_type_</a> = 1;

506

<a name="l00479"></a>00479 if (search_in_gapblock())

507

<a name="l00480"></a>00480 {

508

<a name="l00481"></a>00481 return;

509

<a name="l00482"></a>00482 }

510

<a name="l00483"></a>00483 }

511

<a name="l00484"></a>00484 else

512

<a name="l00485"></a>00485 {

513

<a name="l00486"></a>00486 this-><a class="code" href="a00072.html#a8a9a7fa7ba70eb1aa10180e40239fe7f" title="Type of block. 0-Bit, 1-GAP.">block_type_</a> = 0;

514

<a name="l00487"></a>00487 if (search_in_bitblock())

515

<a name="l00488"></a>00488 {

516

<a name="l00489"></a>00489 return;

517

<a name="l00490"></a>00490 }

518

<a name="l00491"></a>00491 }

519

<a name="l00492"></a>00492

520

<a name="l00493"></a>00493 } // for j

521

<a name="l00494"></a>00494

522

<a name="l00495"></a>00495 } // for i

523

<a name="l00496"></a>00496

524

<a name="l00497"></a>00497 this-><a class="code" href="a00072.html#a5566e1be1039764a8f4643f38b9d8f9e" title="Turns iterator into an invalid state.">invalidate</a>();

525

<a name="l00498"></a>00498 }

526

<a name="l00499"></a>00499

527

<a name="l00500"></a><a class="code" href="a00063.html#a58b4ee025ba7b6545eacad79e7031069">00500</a> <a class="code" href="a00063.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a>& <a class="code" href="a00063.html#a58b4ee025ba7b6545eacad79e7031069">go_up</a>()

528

<a name="l00501"></a>00501 {

529

<a name="l00502"></a>00502 // Current block search.

530

<a name="l00503"></a>00503 ++this-><a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>;

531

<a name="l00504"></a>00504 typedef typename <a class="code" href="a00040.html">iterator_base::block_descr</a> block_descr_type;

532

<a name="l00505"></a>00505

533

<a name="l00506"></a>00506 block_descr_type* bdescr = &(this-><a class="code" href="a00072.html#a47ba31f695597a948e7e18971f5c6236">bdescr_</a>);

534

<a name="l00507"></a>00507

535

<a name="l00508"></a>00508 switch (this-><a class="code" href="a00072.html#a8a9a7fa7ba70eb1aa10180e40239fe7f" title="Type of block. 0-Bit, 1-GAP.">block_type_</a>)

536

<a name="l00509"></a>00509 {

537

<a name="l00510"></a>00510 case 0: // BitBlock

538

<a name="l00511"></a>00511 {

539

<a name="l00512"></a>00512

540

<a name="l00513"></a>00513 // check if we can get the value from the

541

<a name="l00514"></a>00514 // bits cache

542

<a name="l00515"></a>00515

543

<a name="l00516"></a>00516 unsigned idx = ++(bdescr->bit_.idx);

544

<a name="l00517"></a>00517 if (idx < bdescr->bit_.cnt)

545

<a name="l00518"></a>00518 {

546

<a name="l00519"></a>00519 this-><a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> = bdescr->bit_.pos +

547

<a name="l00520"></a>00520 bdescr->bit_.bits[idx];

548

<a name="l00521"></a>00521 return *this;

549

<a name="l00522"></a>00522 }

550

<a name="l00523"></a>00523 this-><a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += 31 - bdescr->bit_.bits[--idx];

551

<a name="l00524"></a>00524

552

<a name="l00525"></a>00525 const <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* pend = this-><a class="code" href="a00072.html#a6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a> + <a class="code" href="a00115.html#a91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a>;

553

<a name="l00526"></a>00526

554

<a name="l00527"></a>00527 while (++(bdescr->bit_.ptr) < pend)

555

<a name="l00528"></a>00528 {

556

<a name="l00529"></a>00529 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a> w = *(bdescr->bit_.ptr);

557

<a name="l00530"></a>00530 if (w)

558

<a name="l00531"></a>00531 {

559

<a name="l00532"></a>00532 bdescr->bit_.idx = 0;

560

<a name="l00533"></a>00533 bdescr->bit_.pos = this-><a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>;

561

<a name="l00534"></a>00534 bdescr->bit_.cnt = <a class="code" href="a00120.html#ga3c81f6bff8866ec3ed0a94903eee96b7" title="Unpacks word into list of ON bit indexes (quad-bit based).">bm::bit_list_4</a>(w, bdescr->bit_.bits);

562

<a name="l00535"></a>00535 this-><a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += bdescr->bit_.bits[0];

563

<a name="l00536"></a>00536 return *this;

564

<a name="l00537"></a>00537 }

565

<a name="l00538"></a>00538 else

566

<a name="l00539"></a>00539 {

567

<a name="l00540"></a>00540 this-><a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += 32;

568

<a name="l00541"></a>00541 }

569

<a name="l00542"></a>00542 }

570

<a name="l00543"></a>00543

571

<a name="l00544"></a>00544 }

572

<a name="l00545"></a>00545 break;

573

<a name="l00546"></a>00546

574

<a name="l00547"></a>00547 case 1: // DGAP Block

575

<a name="l00548"></a>00548 {

576

<a name="l00549"></a>00549 if (--(bdescr->gap_.gap_len))

577

<a name="l00550"></a>00550 {

578

<a name="l00551"></a>00551 return *this;

579

<a name="l00552"></a>00552 }

580

<a name="l00553"></a>00553

581

<a name="l00554"></a>00554 // next gap is "OFF" by definition.

582

<a name="l00555"></a>00555 if (*(bdescr->gap_.ptr) == <a class="code" href="a00115.html#ad0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a> - 1)

583

<a name="l00556"></a>00556 {

584

<a name="l00557"></a>00557 break;

585

<a name="l00558"></a>00558 }

586

<a name="l00559"></a>00559 <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a> prev = *(bdescr->gap_.ptr);

587

<a name="l00560"></a>00560 register unsigned val = *(++(bdescr->gap_.ptr));

588

<a name="l00561"></a>00561

589

<a name="l00562"></a>00562 this-><a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += val - prev;

590

<a name="l00563"></a>00563 // next gap is now "ON"

591

<a name="l00564"></a>00564

592

<a name="l00565"></a>00565 if (*(bdescr->gap_.ptr) == <a class="code" href="a00115.html#ad0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a> - 1)

593

<a name="l00566"></a>00566 {

594

<a name="l00567"></a>00567 break;

595

<a name="l00568"></a>00568 }

596

<a name="l00569"></a>00569 prev = *(bdescr->gap_.ptr);

597

<a name="l00570"></a>00570 val = *(++(bdescr->gap_.ptr));

598

<a name="l00571"></a>00571 bdescr->gap_.gap_len = val - prev;

599

<a name="l00572"></a>00572 return *this; // next "ON" found;

600

<a name="l00573"></a>00573 }

601

<a name="l00574"></a>00574

602

<a name="l00575"></a>00575 default:

603

<a name="l00576"></a>00576 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(0);

604

<a name="l00577"></a>00577

605

<a name="l00578"></a>00578 } // switch

606

<a name="l00579"></a>00579

607

<a name="l00580"></a>00580

608

<a name="l00581"></a>00581 // next bit not present in the current block

609

<a name="l00582"></a>00582 // keep looking in the next blocks.

610

<a name="l00583"></a>00583 ++(this-><a class="code" href="a00072.html#a07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a>);

611

<a name="l00584"></a>00584 unsigned i = this-><a class="code" href="a00072.html#a07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a> >> <a class="code" href="a00115.html#ac1ff8647a089c751ec330cecee01907e">bm::set_array_shift</a>;

612

<a name="l00585"></a>00585 unsigned top_block_size = this-><a class="code" href="a00072.html#ad341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a>->blockman_.top_block_size();

613

<a name="l00586"></a>00586 for (; i < top_block_size; ++i)

614

<a name="l00587"></a>00587 {

615

<a name="l00588"></a>00588 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>** blk_blk = this-><a class="code" href="a00072.html#ad341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a>->blockman_.blocks_root()[i];

616

<a name="l00589"></a>00589 if (blk_blk == 0)

617

<a name="l00590"></a>00590 {

618

<a name="l00591"></a>00591 this-><a class="code" href="a00072.html#a07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a> += <a class="code" href="a00115.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>;

619

<a name="l00592"></a>00592 this-><a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += <a class="code" href="a00115.html#a4dedd13a7b8a27c5067b20118002f025">bm::bits_in_array</a>;

620

<a name="l00593"></a>00593 continue;

621

<a name="l00594"></a>00594 }

622

<a name="l00595"></a>00595

623

<a name="l00596"></a>00596 unsigned j = this-><a class="code" href="a00072.html#a07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a> & <a class="code" href="a00115.html#a00ffa7b38d7fcc7e522d864991a6de68">bm::set_array_mask</a>;

624

<a name="l00597"></a>00597

625

<a name="l00598"></a>00598 for(; j < <a class="code" href="a00115.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>; ++j, ++(this-><a class="code" href="a00072.html#a07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a>))

626

<a name="l00599"></a>00599 {

627

<a name="l00600"></a>00600 this-><a class="code" href="a00072.html#a6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a> = blk_blk[j];

628

<a name="l00601"></a>00601

629

<a name="l00602"></a>00602 if (this-><a class="code" href="a00072.html#a6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a> == 0)

630

<a name="l00603"></a>00603 {

631

<a name="l00604"></a>00604 this-><a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += <a class="code" href="a00115.html#ae9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a>;

632

<a name="l00605"></a>00605 continue;

633

<a name="l00606"></a>00606 }

634

<a name="l00607"></a>00607

635

<a name="l00608"></a>00608 if (<a class="code" href="a00092.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>((this-><a class="code" href="a00072.html#ad341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a>->blockman_),

636

<a name="l00609"></a>00609 this->block_,

637

<a name="l00610"></a>00610 this->block_idx_))

638

<a name="l00611"></a>00611 {

639

<a name="l00612"></a>00612 this-><a class="code" href="a00072.html#a8a9a7fa7ba70eb1aa10180e40239fe7f" title="Type of block. 0-Bit, 1-GAP.">block_type_</a> = 1;

640

<a name="l00613"></a>00613 if (search_in_gapblock())

641

<a name="l00614"></a>00614 {

642

<a name="l00615"></a>00615 return *this;

643

<a name="l00616"></a>00616 }

644

<a name="l00617"></a>00617 }

645

<a name="l00618"></a>00618 else

646

<a name="l00619"></a>00619 {

647

<a name="l00620"></a>00620 this-><a class="code" href="a00072.html#a8a9a7fa7ba70eb1aa10180e40239fe7f" title="Type of block. 0-Bit, 1-GAP.">block_type_</a> = 0;

648

<a name="l00621"></a>00621 if (search_in_bitblock())

649

<a name="l00622"></a>00622 {

650

<a name="l00623"></a>00623 return *this;

651

<a name="l00624"></a>00624 }

652

<a name="l00625"></a>00625 }

653

<a name="l00626"></a>00626

654

<a name="l00627"></a>00627

655

<a name="l00628"></a>00628 } // for j

656

<a name="l00629"></a>00629

657

<a name="l00630"></a>00630 } // for i

658

<a name="l00631"></a>00631

659

<a name="l00632"></a>00632

660

<a name="l00633"></a>00633 this-><a class="code" href="a00072.html#a5566e1be1039764a8f4643f38b9d8f9e" title="Turns iterator into an invalid state.">invalidate</a>();

661

<a name="l00634"></a>00634 return *this;

662

<a name="l00635"></a>00635 }

663

<a name="l00636"></a>00636

664

<a name="l00637"></a>00637

665

<a name="l00638"></a>00638 private:

666

<a name="l00639"></a>00639 bool search_in_bitblock()

667

<a name="l00640"></a>00640 {

668

<a name="l00641"></a>00641 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(this-><a class="code" href="a00072.html#a8a9a7fa7ba70eb1aa10180e40239fe7f" title="Type of block. 0-Bit, 1-GAP.">block_type_</a> == 0);

669

<a name="l00642"></a>00642

670

<a name="l00643"></a>00643 typedef typename <a class="code" href="a00040.html">iterator_base::block_descr</a> block_descr_type;

671

<a name="l00644"></a>00644 block_descr_type* bdescr = &(this-><a class="code" href="a00072.html#a47ba31f695597a948e7e18971f5c6236">bdescr_</a>);

672

<a name="l00645"></a>00645

673

<a name="l00646"></a>00646 // now lets find the first bit in block.

674

<a name="l00647"></a>00647 bdescr->bit_.ptr = this-><a class="code" href="a00072.html#a6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a>;

675

<a name="l00648"></a>00648

676

<a name="l00649"></a>00649 const <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">word_t</a>* ptr_end = this-><a class="code" href="a00072.html#a6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a> + <a class="code" href="a00115.html#a91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a>;

677

<a name="l00650"></a>00650

678

<a name="l00651"></a>00651 do

679

<a name="l00652"></a>00652 {

680

<a name="l00653"></a>00653 register <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a> w = *(bdescr->bit_.ptr);

681

<a name="l00654"></a>00654

682

<a name="l00655"></a>00655 if (w)

683

<a name="l00656"></a>00656 {

684

<a name="l00657"></a>00657 bdescr->bit_.idx = 0;

685

<a name="l00658"></a>00658 bdescr->bit_.pos = this-><a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>;

686

<a name="l00659"></a>00659 bdescr->bit_.cnt =

687

<a name="l00660"></a>00660 <a class="code" href="a00120.html#ga3c81f6bff8866ec3ed0a94903eee96b7" title="Unpacks word into list of ON bit indexes (quad-bit based).">bm::bit_list_4</a>(w, bdescr->bit_.bits);

688

<a name="l00661"></a>00661 this-><a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += bdescr->bit_.bits[0];

689

<a name="l00662"></a>00662

690

<a name="l00663"></a>00663 return true;

691

<a name="l00664"></a>00664 }

692

<a name="l00665"></a>00665 else

693

<a name="l00666"></a>00666 {

694

<a name="l00667"></a>00667 this-><a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += 32;

695

<a name="l00668"></a>00668 }

696

<a name="l00669"></a>00669

697

<a name="l00670"></a>00670 }

698

<a name="l00671"></a>00671 while (++(bdescr->bit_.ptr) < ptr_end);

699

<a name="l00672"></a>00672

700

<a name="l00673"></a>00673 return false;

701

<a name="l00674"></a>00674 }

702

<a name="l00675"></a>00675

703

<a name="l00676"></a>00676 bool search_in_gapblock()

704

<a name="l00677"></a>00677 {

705

<a name="l00678"></a>00678 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(this-><a class="code" href="a00072.html#a8a9a7fa7ba70eb1aa10180e40239fe7f" title="Type of block. 0-Bit, 1-GAP.">block_type_</a> == 1);

706

<a name="l00679"></a>00679

707

<a name="l00680"></a>00680 typedef typename iterator_base::block_descr block_descr_type;

708

<a name="l00681"></a>00681 block_descr_type* bdescr = &(this-><a class="code" href="a00072.html#a47ba31f695597a948e7e18971f5c6236">bdescr_</a>);

709

<a name="l00682"></a>00682

710

<a name="l00683"></a>00683 bdescr->gap_.ptr = <a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(this-><a class="code" href="a00072.html#a6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a>);

711

<a name="l00684"></a>00684 unsigned bitval = *(bdescr->gap_.ptr) & 1;

712

<a name="l00685"></a>00685

713

<a name="l00686"></a>00686 ++(bdescr->gap_.ptr);

714

<a name="l00687"></a>00687

715

<a name="l00688"></a>00688 do

716

<a name="l00689"></a>00689 {

717

<a name="l00690"></a>00690 register unsigned val = *(bdescr->gap_.ptr);

718

<a name="l00691"></a>00691

719

<a name="l00692"></a>00692 if (bitval)

720

<a name="l00693"></a>00693 {

721

<a name="l00694"></a>00694 <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* <a class="code" href="a00044.html#aad48c661f843e32c9893438a6f27a8f0" title="Returns enumerator pointing on the first non-zero bit.">first</a> = <a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(this-><a class="code" href="a00072.html#a6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a>) + 1;

722

<a name="l00695"></a>00695 if (bdescr->gap_.ptr == first)

723

<a name="l00696"></a>00696 {

724

<a name="l00697"></a>00697 bdescr->gap_.gap_len = val + 1;

725

<a name="l00698"></a>00698 }

726

<a name="l00699"></a>00699 else

727

<a name="l00700"></a>00700 {

728

<a name="l00701"></a>00701 bdescr->gap_.gap_len =

729

<a name="l00702"></a>00702 val - *(bdescr->gap_.ptr-1);

730

<a name="l00703"></a>00703 }

731

<a name="l00704"></a>00704

732

<a name="l00705"></a>00705 return true;

733

<a name="l00706"></a>00706 }

734

<a name="l00707"></a>00707 this-><a class="code" href="a00072.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += val + 1;

735

<a name="l00708"></a>00708

736

<a name="l00709"></a>00709 if (val == <a class="code" href="a00115.html#ad0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a> - 1)

737

<a name="l00710"></a>00710 {

738

<a name="l00711"></a>00711 break;

739

<a name="l00712"></a>00712 }

740

<a name="l00713"></a>00713

741

<a name="l00714"></a>00714 bitval ^= 1;

742

<a name="l00715"></a>00715 ++(bdescr->gap_.ptr);

743

<a name="l00716"></a>00716

744

<a name="l00717"></a>00717 } while (1);

745

<a name="l00718"></a>00718

746

<a name="l00719"></a>00719 return false;

747

<a name="l00720"></a>00720 }

748

<a name="l00721"></a>00721

749

<a name="l00722"></a>00722 };

750

<a name="l00723"></a>00723

751

<a name="l00724"></a>00724 /*!

752

<a name="l00725"></a>00725 @brief Constant input iterator designed to enumerate "ON" bits

753

<a name="l00726"></a>00726 counted_enumerator keeps bitcount, ie number of ON bits starting

754

<a name="l00727"></a>00727 from the position 0 in the bit string up to the currently enumerated bit

755

<a name="l00728"></a>00728

756

<a name="l00729"></a>00729 When increment operator called current position is increased by 1.

757

<a name="l00730"></a>00730

758

<a name="l00731"></a>00731 @ingroup bvector

759

<a name="l00732"></a>00732 */

760

<a name="l00733"></a><a class="code" href="a00049.html">00733</a> class <a class="code" href="a00049.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits counted_enumerator...">counted_enumerator</a> : public <a class="code" href="a00063.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a>

761

<a name="l00734"></a>00734 {

762

<a name="l00735"></a>00735 public:

763

<a name="l00736"></a>00736 #ifndef BM_NO_STL

764

<a name="l00737"></a><a class="code" href="a00049.html#a171919f2a88ab74fcea53f9f75225712">00737</a> typedef std::input_iterator_tag <a class="code" href="a00049.html#a171919f2a88ab74fcea53f9f75225712">iterator_category</a>;

765

<a name="l00738"></a>00738 #endif

766

<a name="l00739"></a><a class="code" href="a00049.html#a0a6f5329ef42122de9fcc754c0318cb6">00739</a> <a class="code" href="a00049.html#a0a6f5329ef42122de9fcc754c0318cb6">counted_enumerator</a>() : bit_count_(0){}

767

<a name="l00740"></a>00740

768

<a name="l00741"></a><a class="code" href="a00049.html#a4b0d8b4e7b7268707355b813434bcfcb">00741</a> <a class="code" href="a00049.html#a0a6f5329ef42122de9fcc754c0318cb6">counted_enumerator</a>(const <a class="code" href="a00063.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a>& en)

769

<a name="l00742"></a>00742 : <a class="code" href="a00063.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a>(en)

770

<a name="l00743"></a>00743 {

771

<a name="l00744"></a>00744 if (this-><a class="code" href="a00072.html#aa06eb362d550d37b214591a113be4e7b" title="Checks if iterator is still valid.">valid</a>())

772

<a name="l00745"></a>00745 bit_count_ = 1;

773

<a name="l00746"></a>00746 }

774

<a name="l00747"></a>00747

775

<a name="l00748"></a><a class="code" href="a00049.html#a9e2badd4602a744f1df04de7d9249314">00748</a> <a class="code" href="a00049.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits counted_enumerator...">counted_enumerator</a>& <a class="code" href="a00049.html#a9e2badd4602a744f1df04de7d9249314">operator=</a>(const <a class="code" href="a00063.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a>& en)

776

<a name="l00749"></a>00749 {

777

<a name="l00750"></a>00750 <a class="code" href="a00063.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a>* me = this;

778

<a name="l00751"></a>00751 *me = en;

779

<a name="l00752"></a>00752 if (this-><a class="code" href="a00072.html#aa06eb362d550d37b214591a113be4e7b" title="Checks if iterator is still valid.">valid</a>())

780

<a name="l00753"></a>00753 this->bit_count_ = 1;

781

<a name="l00754"></a>00754 return *this;

782

<a name="l00755"></a>00755 }

783

<a name="l00756"></a>00756

784

<a name="l00757"></a><a class="code" href="a00049.html#a65e58d9cb5ad45c89502c50e346c0f70">00757</a> <a class="code" href="a00049.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits counted_enumerator...">counted_enumerator</a>& <a class="code" href="a00049.html#a65e58d9cb5ad45c89502c50e346c0f70">operator++</a>()

785

<a name="l00758"></a>00758 {

786

<a name="l00759"></a>00759 this-><a class="code" href="a00063.html#a58b4ee025ba7b6545eacad79e7031069">go_up</a>();

787

<a name="l00760"></a>00760 if (this-><a class="code" href="a00072.html#aa06eb362d550d37b214591a113be4e7b" title="Checks if iterator is still valid.">valid</a>())

788

<a name="l00761"></a>00761 ++(this->bit_count_);

789

<a name="l00762"></a>00762 return *this;

790

<a name="l00763"></a>00763 }

791

<a name="l00764"></a>00764

792

<a name="l00765"></a><a class="code" href="a00049.html#a91b38c1ed0a8c913684ad02bcfd67b84">00765</a> <a class="code" href="a00049.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits counted_enumerator...">counted_enumerator</a> <a class="code" href="a00049.html#a65e58d9cb5ad45c89502c50e346c0f70">operator++</a>(int)

793

<a name="l00766"></a>00766 {

794

<a name="l00767"></a>00767 <a class="code" href="a00049.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits counted_enumerator...">counted_enumerator</a> tmp(*this);

795

<a name="l00768"></a>00768 this-><a class="code" href="a00063.html#a58b4ee025ba7b6545eacad79e7031069">go_up</a>();

796

<a name="l00769"></a>00769 if (this-><a class="code" href="a00072.html#aa06eb362d550d37b214591a113be4e7b" title="Checks if iterator is still valid.">valid</a>())

797

<a name="l00770"></a>00770 ++bit_count_;

798

<a name="l00771"></a>00771 return tmp;

799

<a name="l00772"></a>00772 }

800

<a name="l00773"></a>00773

801

<a name="l00774"></a>00774 /*! @brief Number of bits ON starting from the .

802

<a name="l00775"></a>00775

803

<a name="l00776"></a>00776 Method returns number of ON bits fromn the bit 0 to the current bit

804

<a name="l00777"></a>00777 For the first bit in bitvector it is 1, for the second 2

805

<a name="l00778"></a>00778 */

806

<a name="l00779"></a><a class="code" href="a00049.html#a61abf2ecf53823d347ea53adb3a8be4a">00779</a> <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00049.html#a61abf2ecf53823d347ea53adb3a8be4a" title="Number of bits ON starting from the .">count</a>() const { return bit_count_; }

807

<a name="l00780"></a>00780

808

<a name="l00781"></a>00781 private:

809

<a name="l00782"></a>00782 <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> bit_count_;

810

<a name="l00783"></a>00783 };

811

<a name="l00784"></a>00784

812

<a name="l00785"></a><a class="code" href="a00044.html#aeec1461fca400b5b4313765eb9e94c73">00785</a> friend class <a class="code" href="a00072.html" title="Base class for all iterators.">iterator_base</a>;

813

<a name="l00786"></a><a class="code" href="a00044.html#a71cabca9670588878381f72d16e059b8">00786</a> friend class <a class="code" href="a00063.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a>;

814

<a name="l00787"></a>00787

815

<a name="l00788"></a>00788 public:

816

<a name="l00789"></a>00789

817

<a name="l00790"></a>00790 #ifdef BMCOUNTOPT

818

<a name="l00791"></a>00791 <a class="code" href="a00044.html#aa2813ce4ce80ab8c6532e8b478b6d934" title="Constructs bvector class.">bvector</a>(<a class="code" href="a00118.html#gad0b87b3b7292383a864d27feaf1c9eff" title="Block allocation strategies.">strategy</a> strat = <a class="code" href="a00118.html#ggad0b87b3b7292383a864d27feaf1c9effa40920ae0ef7b4411d60463d8f576b5ba" title="No GAP compression strategy. All new blocks are bit blocks.">BM_BIT</a>,

819

<a name="l00792"></a>00792 const <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* glevel_len = <a class="code" href="a00067.html" title="Default GAP lengths table.">bm::gap_len_table<true>::_len</a>,

820

<a name="l00793"></a>00793 <a class="code" href="a00044.html#aba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> bv_size = <a class="code" href="a00115.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>,

821

<a name="l00794"></a>00794 const Alloc& alloc = Alloc())

822

<a name="l00795"></a>00795 : count_(0),

823

<a name="l00796"></a>00796 count_is_valid_(true),

824

<a name="l00797"></a>00797 blockman_(glevel_len, bv_size, alloc),

825

<a name="l00798"></a>00798 new_blocks_strat_(strat),

826

<a name="l00799"></a>00799 size_(bv_size)

827

<a name="l00800"></a>00800 {}

828

<a name="l00801"></a>00801

829

<a name="l00802"></a>00802 <a class="code" href="a00044.html#aa2813ce4ce80ab8c6532e8b478b6d934" title="Constructs bvector class.">bvector</a>(<a class="code" href="a00044.html#aba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> bv_size,

830

<a name="l00803"></a>00803 <a class="code" href="a00118.html#gad0b87b3b7292383a864d27feaf1c9eff" title="Block allocation strategies.">bm::strategy</a> strat = <a class="code" href="a00118.html#ggad0b87b3b7292383a864d27feaf1c9effa40920ae0ef7b4411d60463d8f576b5ba" title="No GAP compression strategy. All new blocks are bit blocks.">BM_BIT</a>,

831

<a name="l00804"></a>00804 const <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* glevel_len = <a class="code" href="a00067.html" title="Default GAP lengths table.">bm::gap_len_table<true>::_len</a>,

832

<a name="l00805"></a>00805 const Alloc& alloc = Alloc())

833

<a name="l00806"></a>00806 : count_(0),

834

<a name="l00807"></a>00807 count_is_valid_(true),

835

<a name="l00808"></a>00808 blockman_(glevel_len, bv_size, alloc),

836

<a name="l00809"></a>00809 new_blocks_strat_(strat),

837

<a name="l00810"></a>00810 size_(bv_size)

838

<a name="l00811"></a>00811 {}

839

<a name="l00812"></a>00812

840

<a name="l00813"></a>00813

841

<a name="l00814"></a>00814 <a class="code" href="a00044.html#aa2813ce4ce80ab8c6532e8b478b6d934" title="Constructs bvector class.">bvector</a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvect</a>)

842

<a name="l00815"></a>00815 : count_(bvect.count_),

843

<a name="l00816"></a>00816 count_is_valid_(bvect.count_is_valid_),

844

<a name="l00817"></a>00817 blockman_(bvect.blockman_),

845

<a name="l00818"></a>00818 new_blocks_strat_(bvect.new_blocks_strat_),

846

<a name="l00819"></a>00819 size_(bvect.size_)

847

<a name="l00820"></a>00820 {}

848

<a name="l00821"></a>00821

849

<a name="l00822"></a>00822 #else

850

<a name="l00823"></a>00823 /*!

851

<a name="l00824"></a>00824 \brief Constructs bvector class

852

<a name="l00825"></a>00825 \param strat - operation mode strategy,

853

<a name="l00826"></a>00826 BM_BIT - default strategy, bvector use plain bitset

854

<a name="l00827"></a>00827 blocks, (performance oriented strategy).

855

<a name="l00828"></a>00828 BM_GAP - memory effitent strategy, bvector allocates

856

<a name="l00829"></a>00829 blocks as array of intervals(gaps) and convert blocks

857

<a name="l00830"></a>00830 into plain bitsets only when enthropy grows.

858

<a name="l00831"></a>00831 \param glevel_len

859

<a name="l00832"></a>00832 - pointer on C-style array keeping GAP block sizes.

860

<a name="l00833"></a>00833 (Put bm::gap_len_table_min<true>::_len for GAP memory saving mode)

861

<a name="l00834"></a>00834 \param bv_size

862

<a name="l00835"></a>00835 - bvector size (number of bits addressable by bvector), bm::id_max means

863

<a name="l00836"></a>00836 "no limits" (recommended).

864

<a name="l00837"></a>00837 bit vector allocates this space dynamically on demand.

865

<a name="l00838"></a>00838

866

<a name="l00839"></a>00839 \sa bm::gap_len_table bm::gap_len_table_min set_new_blocks_strat

867

<a name="l00840"></a>00840 */

868

<a name="l00841"></a><a class="code" href="a00044.html#aa2813ce4ce80ab8c6532e8b478b6d934">00841</a> <a class="code" href="a00044.html#aa2813ce4ce80ab8c6532e8b478b6d934" title="Constructs bvector class.">bvector</a>(<a class="code" href="a00118.html#gad0b87b3b7292383a864d27feaf1c9eff" title="Block allocation strategies.">strategy</a> strat = <a class="code" href="a00118.html#ggad0b87b3b7292383a864d27feaf1c9effa40920ae0ef7b4411d60463d8f576b5ba" title="No GAP compression strategy. All new blocks are bit blocks.">BM_BIT</a>,

869

<a name="l00842"></a>00842 const <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* glevel_len = <a class="code" href="a00067.html" title="Default GAP lengths table.">bm::gap_len_table<true>::_len</a>,

870

<a name="l00843"></a>00843 <a class="code" href="a00044.html#aba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> bv_size = <a class="code" href="a00115.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>,

871

<a name="l00844"></a>00844 const Alloc& alloc = Alloc())

872

<a name="l00845"></a>00845 : blockman_(glevel_len, bv_size, alloc),

873

<a name="l00846"></a>00846 new_blocks_strat_(strat),

874

<a name="l00847"></a>00847 size_(bv_size)

875

<a name="l00848"></a>00848 {}

876

<a name="l00849"></a>00849

877

<a name="l00850"></a>00850 /*!

878

<a name="l00851"></a>00851 \brief Constructs bvector class

879

<a name="l00852"></a>00852 */

880

<a name="l00853"></a><a class="code" href="a00044.html#a3b95b73a26160b2b364e6e1e86167994">00853</a> <a class="code" href="a00044.html#aa2813ce4ce80ab8c6532e8b478b6d934" title="Constructs bvector class.">bvector</a>(<a class="code" href="a00044.html#aba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> bv_size,

881

<a name="l00854"></a>00854 <a class="code" href="a00118.html#gad0b87b3b7292383a864d27feaf1c9eff" title="Block allocation strategies.">strategy</a> strat = <a class="code" href="a00118.html#ggad0b87b3b7292383a864d27feaf1c9effa40920ae0ef7b4411d60463d8f576b5ba" title="No GAP compression strategy. All new blocks are bit blocks.">BM_BIT</a>,

882

<a name="l00855"></a>00855 const <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* glevel_len = <a class="code" href="a00067.html" title="Default GAP lengths table.">bm::gap_len_table<true>::_len</a>,

883

<a name="l00856"></a>00856 const Alloc& alloc = Alloc())

884

<a name="l00857"></a>00857 : blockman_(glevel_len, bv_size, alloc),

885

<a name="l00858"></a>00858 new_blocks_strat_(strat),

886

<a name="l00859"></a>00859 size_(bv_size)

887

<a name="l00860"></a>00860 {}

888

<a name="l00861"></a>00861

889

<a name="l00862"></a>00862

890

<a name="l00863"></a><a class="code" href="a00044.html#a95752bab343fd1b5483043dbbec98a96">00863</a> <a class="code" href="a00044.html#aa2813ce4ce80ab8c6532e8b478b6d934" title="Constructs bvector class.">bvector</a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvect</a>)

891

<a name="l00864"></a>00864 : blockman_(bvect.blockman_),

892

<a name="l00865"></a>00865 new_blocks_strat_(bvect.new_blocks_strat_),

893

<a name="l00866"></a>00866 size_(bvect.size_)

894

<a name="l00867"></a>00867 {}

895

<a name="l00868"></a>00868

896

<a name="l00869"></a>00869 #endif

897

<a name="l00870"></a>00870

898

<a name="l00871"></a><a class="code" href="a00044.html#ad6d691215d7945d1eab58f55055f32ad">00871</a> <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector</a>& <a class="code" href="a00044.html#ad6d691215d7945d1eab58f55055f32ad">operator=</a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvect</a>)

899

<a name="l00872"></a>00872 {

900

<a name="l00873"></a>00873 <a class="code" href="a00044.html#afe98c658c4ee54155e61f9bdfa7b9019" title="Clears every bit in the bitvector.">clear</a>(true); // memory free cleaning

901

<a name="l00874"></a>00874 <a class="code" href="a00044.html#a7be4f9e0741f43869f4dcd9607736c0e" title="Change size of the bvector.">resize</a>(bvect.<a class="code" href="a00044.html#a1b021e7217f530390511e16b9b25f631" title="return current size of the vector (bits)">size</a>());

902

<a name="l00875"></a>00875 <a class="code" href="a00044.html#a0eacd87603f41a9aea2126810183f83a" title="Logical OR operation.">bit_or</a>(bvect);

903

<a name="l00876"></a>00876 return *this;

904

<a name="l00877"></a>00877 }

905

<a name="l00878"></a>00878

906

<a name="l00879"></a><a class="code" href="a00044.html#a98a1223891cbd4e87245defb4e3f165e">00879</a> <a class="code" href="a00080.html" title="Class reference implements an object for bit assignment.">reference</a> <a class="code" href="a00044.html#a98a1223891cbd4e87245defb4e3f165e">operator[]</a>(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n)

907

<a name="l00880"></a>00880 {

908

<a name="l00881"></a>00881 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(n < size_);

909

<a name="l00882"></a>00882 return <a class="code" href="a00080.html" title="Class reference implements an object for bit assignment.">reference</a>(*this, n);

910

<a name="l00883"></a>00883 }

911

<a name="l00884"></a>00884

912

<a name="l00885"></a>00885

913

<a name="l00886"></a><a class="code" href="a00044.html#a3d71b08005a276991b031151e423760e">00886</a> bool <a class="code" href="a00044.html#a98a1223891cbd4e87245defb4e3f165e">operator[]</a>(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n) const

914

<a name="l00887"></a>00887 {

915

<a name="l00888"></a>00888 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(n < size_);

916

<a name="l00889"></a>00889 return <a class="code" href="a00044.html#a11458ca2e3570838da7b94a1e4563d97" title="returns true if bit n is set and false is bit n is 0.">get_bit</a>(n);

917

<a name="l00890"></a>00890 }

918

<a name="l00891"></a>00891

919

<a name="l00892"></a><a class="code" href="a00044.html#a1259c399b970e6fa3715d74387e682c6">00892</a> void <a class="code" href="a00044.html#a1259c399b970e6fa3715d74387e682c6">operator &= </a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvect</a>)

920

<a name="l00893"></a>00893 {

921

<a name="l00894"></a>00894 <a class="code" href="a00044.html#a051a39027c3b12751f172c20f2d03a0f" title="Logical AND operation.">bit_and</a>(bvect);

922

<a name="l00895"></a>00895 }

923

<a name="l00896"></a>00896

924

<a name="l00897"></a><a class="code" href="a00044.html#a3db27387f92cdfa4d883074d7bd525a6">00897</a> void <a class="code" href="a00044.html#a3db27387f92cdfa4d883074d7bd525a6">operator ^= </a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvect</a>)

925

<a name="l00898"></a>00898 {

926

<a name="l00899"></a>00899 <a class="code" href="a00044.html#a997a62ec2effcd60246fb9b72f30ccfa" title="Logical XOR operation.">bit_xor</a>(bvect);

927

<a name="l00900"></a>00900 }

928

<a name="l00901"></a>00901

929

<a name="l00902"></a><a class="code" href="a00044.html#a0a708b4c4c0ac810bd5c4d1280200b10">00902</a> void <a class="code" href="a00044.html#a0a708b4c4c0ac810bd5c4d1280200b10">operator |= </a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvect</a>)

930

<a name="l00903"></a>00903 {

931

<a name="l00904"></a>00904 <a class="code" href="a00044.html#a0eacd87603f41a9aea2126810183f83a" title="Logical OR operation.">bit_or</a>(bvect);

932

<a name="l00905"></a>00905 }

933

<a name="l00906"></a>00906

934

<a name="l00907"></a><a class="code" href="a00044.html#aef8c3032b194d7c127f1a14ef9506fb8">00907</a> void <a class="code" href="a00044.html#aef8c3032b194d7c127f1a14ef9506fb8">operator -= </a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvect</a>)

935

<a name="l00908"></a>00908 {

936

<a name="l00909"></a>00909 <a class="code" href="a00044.html#a6a8e699f9c0571f904d7cbaa2e3ed1f1" title="Logical SUB operation.">bit_sub</a>(bvect);

937

<a name="l00910"></a>00910 }

938

<a name="l00911"></a>00911

939

<a name="l00912"></a><a class="code" href="a00044.html#a278768eb0518183740f172628fe57976">00912</a> bool operator < (const bvector<Alloc, MS>& <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvect</a>) const

940

<a name="l00913"></a>00913 {

941

<a name="l00914"></a>00914 return <a class="code" href="a00044.html#aa2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">compare</a>(<a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvect</a>) < 0;

942

<a name="l00915"></a>00915 }

943

<a name="l00916"></a>00916

944

<a name="l00917"></a><a class="code" href="a00044.html#ad8ca63ae760dd647ad1dbdc9e489a046">00917</a> bool operator <= (const bvector<Alloc, MS>& <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvect</a>) const

945

<a name="l00918"></a>00918 {

946

<a name="l00919"></a>00919 return <a class="code" href="a00044.html#aa2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">compare</a>(<a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvect</a>) <= 0;

947

<a name="l00920"></a>00920 }

948

<a name="l00921"></a>00921

949

<a name="l00922"></a><a class="code" href="a00044.html#a3cf8dfe14ae27d78cb3c0bb90c2b6f19">00922</a> bool <a class="code" href="a00044.html#a3cf8dfe14ae27d78cb3c0bb90c2b6f19">operator > </a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvect</a>) const

950

<a name="l00923"></a>00923 {

951

<a name="l00924"></a>00924 return <a class="code" href="a00044.html#aa2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">compare</a>(bvect) > 0;

952

<a name="l00925"></a>00925 }

953

<a name="l00926"></a>00926

954

<a name="l00927"></a><a class="code" href="a00044.html#ac1946edc275e405998e986d210c6c829">00927</a> bool <a class="code" href="a00044.html#ac1946edc275e405998e986d210c6c829">operator >= </a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvect</a>) const

955

<a name="l00928"></a>00928 {

956

<a name="l00929"></a>00929 return <a class="code" href="a00044.html#aa2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">compare</a>(bvect) >= 0;

957

<a name="l00930"></a>00930 }

958

<a name="l00931"></a>00931

959

<a name="l00932"></a><a class="code" href="a00044.html#a7eae868e8565f4412cce23ff1f82fc4c">00932</a> bool <a class="code" href="a00044.html#a7eae868e8565f4412cce23ff1f82fc4c">operator == </a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvect</a>) const

960

<a name="l00933"></a>00933 {

961

<a name="l00934"></a>00934 return <a class="code" href="a00044.html#aa2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">compare</a>(bvect) == 0;

962

<a name="l00935"></a>00935 }

963

<a name="l00936"></a>00936

964

<a name="l00937"></a><a class="code" href="a00044.html#a0d82c126fe741d082b17a60c8617865f">00937</a> bool <a class="code" href="a00044.html#a0d82c126fe741d082b17a60c8617865f">operator != </a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvect</a>) const

965

<a name="l00938"></a>00938 {

966

<a name="l00939"></a>00939 return <a class="code" href="a00044.html#aa2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">compare</a>(bvect) != 0;

967

<a name="l00940"></a>00940 }

968

<a name="l00941"></a>00941

969

<a name="l00942"></a><a class="code" href="a00044.html#a281157317851c62d91d5ba6d32d33ec7">00942</a> <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> <a class="code" href="a00044.html#a281157317851c62d91d5ba6d32d33ec7">operator~</a>() const

970

<a name="l00943"></a>00943 {

971

<a name="l00944"></a>00944 return <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>(*this).invert();

972

<a name="l00945"></a>00945 }

973

<a name="l00946"></a>00946

974

<a name="l00947"></a><a class="code" href="a00044.html#a9af5dca8d808990b92bdf20b10b63198">00947</a> Alloc <a class="code" href="a00044.html#a9af5dca8d808990b92bdf20b10b63198">get_allocator</a>() const

975

<a name="l00948"></a>00948 {

976

<a name="l00949"></a>00949 return blockman_.get_allocator();

977

<a name="l00950"></a>00950 }

978

<a name="l00951"></a>00951

979

<a name="l00952"></a>00952

980

<a name="l00953"></a>00953 /*!

981

<a name="l00954"></a>00954 \brief Sets bit n.

982

<a name="l00955"></a>00955 \param n - index of the bit to be set.

983

<a name="l00956"></a>00956 \param val - new bit value

984

<a name="l00957"></a>00957 \return TRUE if bit was changed

985

<a name="l00958"></a>00958 */

986

<a name="l00959"></a><a class="code" href="a00044.html#a1769d9ed3a4ee41b03fc3ca4a0e5a58e">00959</a> bool <a class="code" href="a00044.html#a1769d9ed3a4ee41b03fc3ca4a0e5a58e" title="Sets bit n.">set_bit</a>(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val = true)

987

<a name="l00960"></a>00960 {

988

<a name="l00961"></a>00961 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(n < size_);

989

<a name="l00962"></a>00962 return set_bit_no_check(n, val);

990

<a name="l00963"></a>00963 }

991

<a name="l00964"></a>00964

992

<a name="l00965"></a>00965 /*!

993

<a name="l00966"></a>00966 \brief Sets bit n using bit AND with the provided value.

994

<a name="l00967"></a>00967 \param n - index of the bit to be set.

995

<a name="l00968"></a>00968 \param val - new bit value

996

<a name="l00969"></a>00969 \return TRUE if bit was changed

997

<a name="l00970"></a>00970 */

998

<a name="l00971"></a><a class="code" href="a00044.html#a432ac93e2bcd428f659810bb0e6cc9e8">00971</a> bool <a class="code" href="a00044.html#a432ac93e2bcd428f659810bb0e6cc9e8" title="Sets bit n using bit AND with the provided value.">set_bit_and</a>(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val = true)

999

<a name="l00972"></a>00972 {

1000

<a name="l00973"></a>00973 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(n < size_);

1001

<a name="l00974"></a>00974 return and_bit_no_check(n, val);

1002

<a name="l00975"></a>00975 }

1003

<a name="l00976"></a>00976

1004

<a name="l00977"></a>00977 /*!

1005

<a name="l00978"></a>00978 \brief Sets bit n only if current value is equal to the condition

1006

<a name="l00979"></a>00979 \param n - index of the bit to be set.

1007

<a name="l00980"></a>00980 \param val - new bit value

1008

<a name="l00981"></a>00981 \param condition - expected current value

1009

<a name="l00982"></a>00982 \return TRUE if bit was changed

1010

<a name="l00983"></a>00983 */

1011

<a name="l00984"></a><a class="code" href="a00044.html#ab769dc46d71c5df276d8403b20ed5eb0">00984</a> bool <a class="code" href="a00044.html#ab769dc46d71c5df276d8403b20ed5eb0" title="Sets bit n only if current value is equal to the condition.">set_bit_conditional</a>(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val, bool condition)

1012

<a name="l00985"></a>00985 {

1013

<a name="l00986"></a>00986 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(n < size_);

1014

<a name="l00987"></a>00987 if (val == condition) return false;

1015

<a name="l00988"></a>00988 return set_bit_conditional_impl(n, val, condition);

1016

<a name="l00989"></a>00989 }

1017

<a name="l00990"></a>00990

1018

<a name="l00991"></a>00991

1019

<a name="l00992"></a>00992 /*!

1020

<a name="l00993"></a>00993 \brief Sets bit n if val is true, clears bit n if val is false

1021

<a name="l00994"></a>00994 \param n - index of the bit to be set

1022

<a name="l00995"></a>00995 \param val - new bit value

1023

<a name="l00996"></a>00996 \return *this

1024

<a name="l00997"></a>00997 */

1025

<a name="l00998"></a><a class="code" href="a00044.html#abc85ec9da74de03ff7e2a6c836656dd8">00998</a> <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& set(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val = true)

1026

<a name="l00999"></a>00999 {

1027

<a name="l01000"></a>01000 <a class="code" href="a00044.html#a1769d9ed3a4ee41b03fc3ca4a0e5a58e" title="Sets bit n.">set_bit</a>(n, val);

1028

<a name="l01001"></a>01001 return *this;

1029

<a name="l01002"></a>01002 }

1030

<a name="l01003"></a>01003

1031

<a name="l01004"></a>01004

1032

<a name="l01005"></a>01005

1033

<a name="l01006"></a>01006 /*!

1034

<a name="l01007"></a>01007 \brief Sets every bit in this bitset to 1.

1035

<a name="l01008"></a>01008 \return *this

1036

<a name="l01009"></a>01009 */

1037

<a name="l01010"></a><a class="code" href="a00044.html#aa745480d136c8b0e6bc41afe951577c5">01010</a> <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& set()

1038

<a name="l01011"></a>01011 {

1039

<a name="l01012"></a>01012 <a class="code" href="a00087.html#a835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false)

1040

<a name="l01013"></a>01013 <a class="code" href="a00044.html#a14bc35b9b022018f10787b07a5b2af04" title="Sets all bits in the specified closed interval [left,right] Interval must be inside...">set_range</a>(0, size_ - 1, true);

1041

<a name="l01014"></a>01014 return *this;

1042

<a name="l01015"></a>01015 }

1043

<a name="l01016"></a>01016

1044

<a name="l01017"></a>01017

1045

<a name="l01018"></a>01018 /*!

1046

<a name="l01019"></a>01019 \brief Sets all bits in the specified closed interval [left,right]

1047

<a name="l01020"></a>01020 Interval must be inside the bvector's size.

1048

<a name="l01021"></a>01021 This method DOES NOT resize vector.

1049

<a name="l01022"></a>01022

1050

<a name="l01023"></a>01023 \param left - interval start

1051

<a name="l01024"></a>01024 \param right - interval end (closed interval)

1052

<a name="l01025"></a>01025 \param value - value to set interval in

1053

<a name="l01026"></a>01026

1054

<a name="l01027"></a>01027 \return *this

1055

<a name="l01028"></a>01028 */

1056

<a name="l01029"></a>01029 <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00044.html#a14bc35b9b022018f10787b07a5b2af04" title="Sets all bits in the specified closed interval [left,right] Interval must be inside...">set_range</a>(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> left,

1057

<a name="l01030"></a>01030 <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> right,

1058

<a name="l01031"></a>01031 bool value = true);

1059

<a name="l01032"></a>01032

1060

<a name="l01033"></a>01033

1061

<a name="l01034"></a>01034 /*! Function erturns insert iterator for this bitvector */

1062

<a name="l01035"></a><a class="code" href="a00044.html#ada0d32bbd1a135722a7790b13d866451">01035</a> <a class="code" href="a00071.html" title="Output iterator iterator designed to set &quot;ON&quot; bits based on input sequence...">insert_iterator</a> <a class="code" href="a00044.html#ada0d32bbd1a135722a7790b13d866451">inserter</a>()

1063

<a name="l01036"></a>01036 {

1064

<a name="l01037"></a>01037 return <a class="code" href="a00071.html" title="Output iterator iterator designed to set &quot;ON&quot; bits based on input sequence...">insert_iterator</a>(*this);

1065

<a name="l01038"></a>01038 }

1066

<a name="l01039"></a>01039

1067

<a name="l01040"></a>01040

1068

<a name="l01041"></a>01041 /*!

1069

<a name="l01042"></a>01042 \brief Clears bit n.

1070

<a name="l01043"></a>01043 \param n - bit's index to be cleaned.

1071

<a name="l01044"></a>01044 */

1072

<a name="l01045"></a><a class="code" href="a00044.html#a23106b542344f671ff5aff1887657a5d">01045</a> void <a class="code" href="a00044.html#a23106b542344f671ff5aff1887657a5d" title="Clears bit n.">clear_bit</a>(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n)

1073

<a name="l01046"></a>01046 {

1074

<a name="l01047"></a>01047 set(n, false);

1075

<a name="l01048"></a>01048 }

1076

<a name="l01049"></a>01049

1077

<a name="l01050"></a>01050

1078

<a name="l01051"></a>01051 /*!

1079

<a name="l01052"></a>01052 \brief Clears every bit in the bitvector.

1080

<a name="l01053"></a>01053

1081

<a name="l01054"></a>01054 \param free_mem if "true" (default) bvector frees the memory,

1082

<a name="l01055"></a>01055 otherwise sets blocks to 0.

1083

<a name="l01056"></a>01056 */

1084

<a name="l01057"></a><a class="code" href="a00044.html#afe98c658c4ee54155e61f9bdfa7b9019">01057</a> void <a class="code" href="a00044.html#afe98c658c4ee54155e61f9bdfa7b9019" title="Clears every bit in the bitvector.">clear</a>(bool free_mem = false)

1085

<a name="l01058"></a>01058 {

1086

<a name="l01059"></a>01059 blockman_.set_all_zero(free_mem);

1087

<a name="l01060"></a>01060 <a class="code" href="a00087.html#a1fbebc7fe3c22d768ff6e240437ee8f4">BMCOUNT_SET</a>(0);

1088

<a name="l01061"></a>01061 }

1089

<a name="l01062"></a>01062

1090

<a name="l01063"></a>01063 /*!

1091

<a name="l01064"></a>01064 \brief Clears every bit in the bitvector.

1092

<a name="l01065"></a>01065 \return *this;

1093

<a name="l01066"></a>01066 */

1094

<a name="l01067"></a><a class="code" href="a00044.html#a1b0d2eca7aa91d49374cf711407c9a43">01067</a> <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00044.html#a1b0d2eca7aa91d49374cf711407c9a43" title="Clears every bit in the bitvector.">reset</a>()

1095

<a name="l01068"></a>01068 {

1096

<a name="l01069"></a>01069 <a class="code" href="a00044.html#afe98c658c4ee54155e61f9bdfa7b9019" title="Clears every bit in the bitvector.">clear</a>();

1097

<a name="l01070"></a>01070 return *this;

1098

<a name="l01071"></a>01071 }

1099

<a name="l01072"></a>01072

1100

<a name="l01073"></a>01073

1101

<a name="l01074"></a>01074 /*!

1102

<a name="l01075"></a>01075 \brief Returns count of bits which are 1.

1103

<a name="l01076"></a>01076 \return Total number of bits ON.

1104

<a name="l01077"></a>01077 */

1105

<a name="l01078"></a>01078 <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00044.html#a71077c1315555301532e24d4d2b95ea2" title="Returns count of bits which are 1.">count</a>() const;

1106

<a name="l01079"></a>01079

1107

<a name="l01080"></a>01080 /**

1108

<a name="l01081"></a>01081 \brief Returns bvector's capacity (number of bits it can store)

1109

<a name="l01082"></a>01082 */

1110

<a name="l01083"></a><a class="code" href="a00044.html#ab3d054fafa5d361b7aafa3b36cadecc2">01083</a> <a class="code" href="a00044.html#aba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> <a class="code" href="a00044.html#ab3d054fafa5d361b7aafa3b36cadecc2" title="Returns bvector&#39;s capacity (number of bits it can store).">capacity</a>() const

1111

<a name="l01084"></a>01084 {

1112

<a name="l01085"></a>01085 return blockman_.capacity();

1113

<a name="l01086"></a>01086 }

1114

<a name="l01087"></a>01087

1115

<a name="l01088"></a>01088 /*!

1116

<a name="l01089"></a>01089 \brief return current size of the vector (bits)

1117

<a name="l01090"></a>01090 */

1118

<a name="l01091"></a><a class="code" href="a00044.html#a1b021e7217f530390511e16b9b25f631">01091</a> <a class="code" href="a00044.html#aba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> <a class="code" href="a00044.html#a1b021e7217f530390511e16b9b25f631" title="return current size of the vector (bits)">size</a>() const

1119

<a name="l01092"></a>01092 {

1120

<a name="l01093"></a>01093 return size_;

1121

<a name="l01094"></a>01094 }

1122

<a name="l01095"></a>01095

1123

<a name="l01096"></a>01096 /*!

1124

<a name="l01097"></a>01097 \brief Change size of the bvector

1125

<a name="l01098"></a>01098 \param new_size - new size in bits

1126

<a name="l01099"></a>01099 */

1127

<a name="l01100"></a>01100 void <a class="code" href="a00044.html#a7be4f9e0741f43869f4dcd9607736c0e" title="Change size of the bvector.">resize</a>(<a class="code" href="a00044.html#aba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> new_size);

1128

<a name="l01101"></a>01101

1129

<a name="l01102"></a>01102 /*! \brief Computes bitcount values for all bvector blocks

1130

<a name="l01103"></a>01103 \param arr - pointer on array of block bit counts

1131

<a name="l01104"></a>01104 \return Index of the last block counted.

1132

<a name="l01105"></a>01105 This number +1 gives you number of arr elements initialized during the

1133

<a name="l01106"></a>01106 function call.

1134

<a name="l01107"></a>01107 */

1135

<a name="l01108"></a><a class="code" href="a00044.html#a435752c1674607b625d5e9a54febaa5b">01108</a> unsigned <a class="code" href="a00044.html#a435752c1674607b625d5e9a54febaa5b" title="Computes bitcount values for all bvector blocks.">count_blocks</a>(unsigned* arr) const

1136

<a name="l01109"></a>01109 {

1137

<a name="l01110"></a>01110 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*** blk_root = blockman_.get_rootblock();

1138

<a name="l01111"></a>01111 typename blocks_manager_type::block_count_arr_func func(blockman_, &(arr[0]));

1139

<a name="l01112"></a>01112 <a class="code" href="a00115.html#ae8b342c25dc22d6cd26cb96d7ae796db">for_each_nzblock</a>(blk_root, blockman_.effective_top_block_size(),

1140

<a name="l01113"></a>01113 <a class="code" href="a00115.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>, func);

1141

<a name="l01114"></a>01114 return func.last_block();

1142

<a name="l01115"></a>01115 }

1143

<a name="l01116"></a>01116

1144

<a name="l01117"></a>01117 /*!

1145

<a name="l01118"></a>01118 \brief Returns count of 1 bits in the given diapason.

1146

<a name="l01119"></a>01119 \param left - index of first bit start counting from

1147

<a name="l01120"></a>01120 \param right - index of last bit

1148

<a name="l01121"></a>01121 \param block_count_arr - optional parameter (bitcount by bvector blocks)

1149

<a name="l01122"></a>01122 calculated by count_blocks method. Used to improve performance of

1150

<a name="l01123"></a>01123 wide range searches

1151

<a name="l01124"></a>01124 \return Total number of bits ON.

1152

<a name="l01125"></a>01125 */

1153

<a name="l01126"></a>01126 <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00044.html#adbe1a2423ce166b88a0b57e435af2733" title="Returns count of 1 bits in the given diapason.">count_range</a>(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> left,

1154

<a name="l01127"></a>01127 <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> right,

1155

<a name="l01128"></a>01128 unsigned* block_count_arr=0) const;

1156

<a name="l01129"></a>01129

1157

<a name="l01130"></a>01130

1158

<a name="l01131"></a><a class="code" href="a00044.html#a91adb243bd37e4e9798ba3e4f87e6e1e">01131</a> <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00044.html#a91adb243bd37e4e9798ba3e4f87e6e1e">recalc_count</a>()

1159

<a name="l01132"></a>01132 {

1160

<a name="l01133"></a>01133 <a class="code" href="a00087.html#a835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false)

1161

<a name="l01134"></a>01134 return <a class="code" href="a00044.html#a71077c1315555301532e24d4d2b95ea2" title="Returns count of bits which are 1.">count</a>();

1162

<a name="l01135"></a>01135 }

1163

<a name="l01136"></a>01136

1164

<a name="l01137"></a>01137 /*!

1165

<a name="l01138"></a>01138 Disables count cache. Next call to count() or recalc_count()

1166

<a name="l01139"></a>01139 restores count caching.

1167

<a name="l01140"></a>01140

1168

<a name="l01141"></a>01141 @note Works only if BMCOUNTOPT enabled(defined).

1169

<a name="l01142"></a>01142 Othewise does nothing.

1170

<a name="l01143"></a>01143 */

1171

<a name="l01144"></a><a class="code" href="a00044.html#ad18b82c801a21eeaf5bb519921bd23d8">01144</a> void <a class="code" href="a00044.html#ad18b82c801a21eeaf5bb519921bd23d8">forget_count</a>()

1172

<a name="l01145"></a>01145 {

1173

<a name="l01146"></a>01146 <a class="code" href="a00087.html#a835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false)

1174

<a name="l01147"></a>01147 }

1175

<a name="l01148"></a>01148

1176

<a name="l01149"></a>01149 /*!

1177

<a name="l01150"></a>01150 \brief Inverts all bits.

1178

<a name="l01151"></a>01151 */

1179

<a name="l01152"></a>01152 <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00044.html#a49af36cc1ea632cd3a2217b53b69dafc" title="Inverts all bits.">invert</a>();

1180

<a name="l01153"></a>01153

1181

<a name="l01154"></a>01154

1182

<a name="l01155"></a>01155 /*!

1183

<a name="l01156"></a>01156 \brief returns true if bit n is set and false is bit n is 0.

1184

<a name="l01157"></a>01157 \param n - Index of the bit to check.

1185

<a name="l01158"></a>01158 \return Bit value (1 or 0)

1186

<a name="l01159"></a>01159 */

1187

<a name="l01160"></a>01160 bool <a class="code" href="a00044.html#a11458ca2e3570838da7b94a1e4563d97" title="returns true if bit n is set and false is bit n is 0.">get_bit</a>(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n) const;

1188

<a name="l01161"></a>01161

1189

<a name="l01162"></a>01162 /*!

1190

<a name="l01163"></a>01163 \brief returns true if bit n is set and false is bit n is 0.

1191

<a name="l01164"></a>01164 \param n - Index of the bit to check.

1192

<a name="l01165"></a>01165 \return Bit value (1 or 0)

1193

<a name="l01166"></a>01166 */

1194

<a name="l01167"></a><a class="code" href="a00044.html#a59ffa64959f92cc259eea2f6d7b597df">01167</a> bool <a class="code" href="a00044.html#a59ffa64959f92cc259eea2f6d7b597df" title="returns true if bit n is set and false is bit n is 0.">test</a>(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n) const

1195

<a name="l01168"></a>01168 {

1196

<a name="l01169"></a>01169 return <a class="code" href="a00044.html#a11458ca2e3570838da7b94a1e4563d97" title="returns true if bit n is set and false is bit n is 0.">get_bit</a>(n);

1197

<a name="l01170"></a>01170 }

1198

<a name="l01171"></a>01171

1199

<a name="l01172"></a>01172 /*!

1200

<a name="l01173"></a>01173 \brief Returns true if any bits in this bitset are set, and otherwise returns false.

1201

<a name="l01174"></a>01174 \return true if any bit is set

1202

<a name="l01175"></a>01175 */

1203

<a name="l01176"></a><a class="code" href="a00044.html#a3d08364f13c365bd831ab4f0a909035e">01176</a> bool <a class="code" href="a00044.html#a3d08364f13c365bd831ab4f0a909035e" title="Returns true if any bits in this bitset are set, and otherwise returns false.">any</a>() const

1204

<a name="l01177"></a>01177 {

1205

<a name="l01178"></a>01178 #ifdef BMCOUNTOPT

1206

<a name="l01179"></a>01179 if (count_is_valid_ && count_) return true;

1207

<a name="l01180"></a>01180 #endif

1208

<a name="l01181"></a>01181

1209

<a name="l01182"></a>01182 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">word_t</a>*** blk_root = blockman_.get_rootblock();

1210

<a name="l01183"></a>01183 if (!blk_root)

1211

<a name="l01184"></a>01184 return false;

1212

<a name="l01185"></a>01185 typename blocks_manager_type::block_any_func func(blockman_);

1213

<a name="l01186"></a>01186 return <a class="code" href="a00115.html#a6f5cb8cbb105eae84d4b0f8a3bc1230f">for_each_nzblock_if</a>(blk_root,

1214

<a name="l01187"></a>01187 blockman_.effective_top_block_size(),

1215

<a name="l01188"></a>01188 <a class="code" href="a00115.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>,

1216

<a name="l01189"></a>01189 func);

1217

<a name="l01190"></a>01190 }

1218

<a name="l01191"></a>01191

1219

<a name="l01192"></a>01192 /*!

1220

<a name="l01193"></a>01193 \brief Returns true if no bits are set, otherwise returns false.

1221

<a name="l01194"></a>01194 */

1222

<a name="l01195"></a><a class="code" href="a00044.html#a1cb9799d8f1ae36f04527a14e9ff4784">01195</a> bool <a class="code" href="a00044.html#a1cb9799d8f1ae36f04527a14e9ff4784" title="Returns true if no bits are set, otherwise returns false.">none</a>() const

1223

<a name="l01196"></a>01196 {

1224

<a name="l01197"></a>01197 return !<a class="code" href="a00044.html#a3d08364f13c365bd831ab4f0a909035e" title="Returns true if any bits in this bitset are set, and otherwise returns false.">any</a>();

1225

<a name="l01198"></a>01198 }

1226

<a name="l01199"></a>01199

1227

<a name="l01200"></a>01200 /*!

1228

<a name="l01201"></a>01201 \brief Flips bit n

1229

<a name="l01202"></a>01202 \return *this

1230

<a name="l01203"></a>01203 */

1231

<a name="l01204"></a><a class="code" href="a00044.html#acf0fd4c4e19630fd02210f585c44491d">01204</a> <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00044.html#a73faf6a420061373a6c447ed94e18df2" title="Flips all bits.">flip</a>(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n)

1232

<a name="l01205"></a>01205 {

1233

<a name="l01206"></a>01206 set(n, !<a class="code" href="a00044.html#a11458ca2e3570838da7b94a1e4563d97" title="returns true if bit n is set and false is bit n is 0.">get_bit</a>(n));

1234

<a name="l01207"></a>01207 return *this;

1235

<a name="l01208"></a>01208 }

1236

<a name="l01209"></a>01209

1237

<a name="l01210"></a>01210 /*!

1238

<a name="l01211"></a>01211 \brief Flips all bits

1239

<a name="l01212"></a>01212 \return *this

1240

<a name="l01213"></a>01213 */

1241

<a name="l01214"></a><a class="code" href="a00044.html#a73faf6a420061373a6c447ed94e18df2">01214</a> <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00044.html#a73faf6a420061373a6c447ed94e18df2" title="Flips all bits.">flip</a>()

1242

<a name="l01215"></a>01215 {

1243

<a name="l01216"></a>01216 return <a class="code" href="a00044.html#a49af36cc1ea632cd3a2217b53b69dafc" title="Inverts all bits.">invert</a>();

1244

<a name="l01217"></a>01217 }

1245

<a name="l01218"></a>01218

1246

<a name="l01219"></a>01219 /*! \brief Exchanges content of bv and this bitvector.

1247

<a name="l01220"></a>01220 */

1248

<a name="l01221"></a><a class="code" href="a00044.html#ad7a4d5fb8a2418f45a366efd01cd3bcd">01221</a> void <a class="code" href="a00044.html#ad7a4d5fb8a2418f45a366efd01cd3bcd" title="Exchanges content of bv and this bitvector.">swap</a>(<a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& bv)

1249

<a name="l01222"></a>01222 {

1250

<a name="l01223"></a>01223 if (this != &bv)

1251

<a name="l01224"></a>01224 {

1252

<a name="l01225"></a>01225 blockman_.swap(bv.blockman_);

1253

<a name="l01226"></a>01226 <a class="code" href="a00115.html#afb2c1acc56270abb381741a709a2b17c" title="XOR swap two scalar variables.">bm::xor_swap</a>(size_,bv.size_);

1254

<a name="l01227"></a>01227 #ifdef BMCOUNTOPT

1255

<a name="l01228"></a>01228 <a class="code" href="a00087.html#a835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false)

1256

<a name="l01229"></a>01229 bv.<a class="code" href="a00044.html#a91adb243bd37e4e9798ba3e4f87e6e1e">recalc_count</a>();

1257

<a name="l01230"></a>01230 #endif

1258

<a name="l01231"></a>01231 }

1259

<a name="l01232"></a>01232 }

1260

<a name="l01233"></a>01233

1261

<a name="l01234"></a>01234

1262

<a name="l01235"></a>01235 /*!

1263

<a name="l01236"></a>01236 \fn bm::id_t bvector::get_first() const

1264

<a name="l01237"></a>01237 \brief Gets number of first bit which is ON.

1265

<a name="l01238"></a>01238 \return Index of the first 1 bit.

1266

<a name="l01239"></a>01239 \sa get_next, extract_next

1267

<a name="l01240"></a>01240 */

1268

<a name="l01241"></a><a class="code" href="a00044.html#af3129b35cabf0554d85711c085a8616d">01241</a> <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00044.html#af3129b35cabf0554d85711c085a8616d" title="Gets number of first bit which is ON.">get_first</a>() const { return check_or_next(0); }

1269

<a name="l01242"></a>01242

1270

<a name="l01243"></a>01243 /*!

1271

<a name="l01244"></a>01244 \fn bm::id_t bvector::get_next(bm::id_t prev) const

1272

<a name="l01245"></a>01245 \brief Finds the number of the next bit ON.

1273

<a name="l01246"></a>01246 \param prev - Index of the previously found bit.

1274

<a name="l01247"></a>01247 \return Index of the next bit which is ON or 0 if not found.

1275

<a name="l01248"></a>01248 \sa get_first, extract_next

1276

<a name="l01249"></a>01249 */

1277

<a name="l01250"></a><a class="code" href="a00044.html#adef9c095a682a9857068c280e37c8240">01250</a> <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00044.html#adef9c095a682a9857068c280e37c8240" title="Finds the number of the next bit ON.">get_next</a>(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> prev) const

1278

<a name="l01251"></a>01251 {

1279

<a name="l01252"></a>01252 return (++prev == <a class="code" href="a00115.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>) ? 0 : check_or_next(prev);

1280

<a name="l01253"></a>01253 }

1281

<a name="l01254"></a>01254

1282

<a name="l01255"></a>01255 /*!

1283

<a name="l01256"></a>01256 \fn bm::id_t bvector::extract_next(bm::id_t prev)

1284

<a name="l01257"></a>01257 \brief Finds the number of the next bit ON and sets it to 0.

1285

<a name="l01258"></a>01258 \param prev - Index of the previously found bit.

1286

<a name="l01259"></a>01259 \return Index of the next bit which is ON or 0 if not found.

1287

<a name="l01260"></a>01260 \sa get_first, get_next,

1288

<a name="l01261"></a>01261 */

1289

<a name="l01262"></a><a class="code" href="a00044.html#a0919f2a0499568605b380e5d5373948d">01262</a> <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00044.html#a0919f2a0499568605b380e5d5373948d" title="Finds the number of the next bit ON and sets it to 0.">extract_next</a>(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> prev)

1290

<a name="l01263"></a>01263 {

1291

<a name="l01264"></a>01264 return (++prev == <a class="code" href="a00115.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>) ? 0 : check_or_next_extract(prev);

1292

<a name="l01265"></a>01265 }

1293

<a name="l01266"></a>01266

1294

<a name="l01267"></a>01267

1295

<a name="l01268"></a>01268 /*!

1296

<a name="l01269"></a>01269 @brief Calculates bitvector statistics.

1297

<a name="l01270"></a>01270

1298

<a name="l01271"></a>01271 @param st - pointer on statistics structure to be filled in.

1299

<a name="l01272"></a>01272

1300

<a name="l01273"></a>01273 Function fills statistics structure containing information about how

1301

<a name="l01274"></a>01274 this vector uses memory and estimation of max. amount of memory

1302

<a name="l01275"></a>01275 bvector needs to serialize itself.

1303

<a name="l01276"></a>01276

1304

<a name="l01277"></a>01277 @sa statistics

1305

<a name="l01278"></a>01278 */

1306

<a name="l01279"></a>01279 void <a class="code" href="a00044.html#a1eaaac76a97b9eb1d3c11f21cf9385ac" title="Calculates bitvector statistics.">calc_stat</a>(struct <a class="code" href="a00085.html" title="Statistical information about bitset&#39;s memory allocation details.">bm::bvector<Alloc, MS>::statistics</a>* st) const;

1307

<a name="l01280"></a>01280

1308

<a name="l01281"></a>01281 /*!

1309

<a name="l01282"></a>01282 \brief Logical OR operation.

1310

<a name="l01283"></a>01283 \param vect - Argument vector.

1311

<a name="l01284"></a>01284 */

1312

<a name="l01285"></a><a class="code" href="a00044.html#a0eacd87603f41a9aea2126810183f83a">01285</a> <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00044.html#a0eacd87603f41a9aea2126810183f83a" title="Logical OR operation.">bit_or</a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& vect)

1313

<a name="l01286"></a>01286 {

1314

<a name="l01287"></a>01287 <a class="code" href="a00087.html#a835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false);

1315

<a name="l01288"></a>01288 <a class="code" href="a00044.html#af2c137de958a038f96e1149c51ea8a8f">combine_operation</a>(vect, <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a0c8cf0197857d0bd73a63037e2f2c5c5">BM_OR</a>);

1316

<a name="l01289"></a>01289 return *this;

1317

<a name="l01290"></a>01290 }

1318

<a name="l01291"></a>01291

1319

<a name="l01292"></a>01292 /*!

1320

<a name="l01293"></a>01293 \brief Logical AND operation.

1321

<a name="l01294"></a>01294 \param vect - Argument vector.

1322

<a name="l01295"></a>01295 */

1323

<a name="l01296"></a><a class="code" href="a00044.html#a051a39027c3b12751f172c20f2d03a0f">01296</a> <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00044.html#a051a39027c3b12751f172c20f2d03a0f" title="Logical AND operation.">bit_and</a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& vect)

1324

<a name="l01297"></a>01297 {

1325

<a name="l01298"></a>01298 <a class="code" href="a00087.html#a835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false);

1326

<a name="l01299"></a>01299 <a class="code" href="a00044.html#af2c137de958a038f96e1149c51ea8a8f">combine_operation</a>(vect, <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a546fdf33b301e5b9bee0591522ed9250">BM_AND</a>);

1327

<a name="l01300"></a>01300 return *this;

1328

<a name="l01301"></a>01301 }

1329

<a name="l01302"></a>01302

1330

<a name="l01303"></a>01303 /*!

1331

<a name="l01304"></a>01304 \brief Logical XOR operation.

1332

<a name="l01305"></a>01305 \param vect - Argument vector.

1333

<a name="l01306"></a>01306 */

1334

<a name="l01307"></a><a class="code" href="a00044.html#a997a62ec2effcd60246fb9b72f30ccfa">01307</a> <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00044.html#a997a62ec2effcd60246fb9b72f30ccfa" title="Logical XOR operation.">bit_xor</a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& vect)

1335

<a name="l01308"></a>01308 {

1336

<a name="l01309"></a>01309 <a class="code" href="a00087.html#a835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false);

1337

<a name="l01310"></a>01310 <a class="code" href="a00044.html#af2c137de958a038f96e1149c51ea8a8f">combine_operation</a>(vect, <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a45c2fe36efb72dc03f03a842d253f64c">BM_XOR</a>);

1338

<a name="l01311"></a>01311 return *this;

1339

<a name="l01312"></a>01312 }

1340

<a name="l01313"></a>01313

1341

<a name="l01314"></a>01314 /*!

1342

<a name="l01315"></a>01315 \brief Logical SUB operation.

1343

<a name="l01316"></a>01316 \param vect - Argument vector.

1344

<a name="l01317"></a>01317 */

1345

<a name="l01318"></a><a class="code" href="a00044.html#a6a8e699f9c0571f904d7cbaa2e3ed1f1">01318</a> <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00044.html#a6a8e699f9c0571f904d7cbaa2e3ed1f1" title="Logical SUB operation.">bit_sub</a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& vect)

1346

<a name="l01319"></a>01319 {

1347

<a name="l01320"></a>01320 <a class="code" href="a00087.html#a835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false);

1348

<a name="l01321"></a>01321 <a class="code" href="a00044.html#af2c137de958a038f96e1149c51ea8a8f">combine_operation</a>(vect, <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a1df0f4de7126bb2f7ce69d7a005affb5">BM_SUB</a>);

1349

<a name="l01322"></a>01322 return *this;

1350

<a name="l01323"></a>01323 }

1351

<a name="l01324"></a>01324

1352

<a name="l01325"></a>01325

1353

<a name="l01326"></a>01326 /*!

1354

<a name="l01327"></a>01327 \brief Sets new blocks allocation strategy.

1355

<a name="l01328"></a>01328 \param strat - Strategy code 0 - bitblocks allocation only.

1356

<a name="l01329"></a>01329 1 - Blocks mutation mode (adaptive algorithm)

1357

<a name="l01330"></a>01330 */

1358

<a name="l01331"></a><a class="code" href="a00044.html#ab1094180d03cbc961d62f0f453097452">01331</a> void <a class="code" href="a00044.html#ab1094180d03cbc961d62f0f453097452" title="Sets new blocks allocation strategy.">set_new_blocks_strat</a>(<a class="code" href="a00118.html#gad0b87b3b7292383a864d27feaf1c9eff" title="Block allocation strategies.">strategy</a> strat)

1359

<a name="l01332"></a>01332 {

1360

<a name="l01333"></a>01333 new_blocks_strat_ = strat;

1361

<a name="l01334"></a>01334 }

1362

<a name="l01335"></a>01335

1363

<a name="l01336"></a>01336 /*!

1364

<a name="l01337"></a>01337 \brief Returns blocks allocation strategy.

1365

<a name="l01338"></a>01338 \return - Strategy code 0 - bitblocks allocation only.

1366

<a name="l01339"></a>01339 1 - Blocks mutation mode (adaptive algorithm)

1367

<a name="l01340"></a>01340 \sa set_new_blocks_strat

1368

<a name="l01341"></a>01341 */

1369

<a name="l01342"></a><a class="code" href="a00044.html#ad971c541fa259278e9dcf541b2d128c9">01342</a> <a class="code" href="a00118.html#gad0b87b3b7292383a864d27feaf1c9eff" title="Block allocation strategies.">strategy</a> <a class="code" href="a00044.html#ad971c541fa259278e9dcf541b2d128c9" title="Returns blocks allocation strategy.">get_new_blocks_strat</a>() const

1370

<a name="l01343"></a>01343 {

1371

<a name="l01344"></a>01344 return new_blocks_strat_;

1372

<a name="l01345"></a>01345 }

1373

<a name="l01346"></a>01346

1374

<a name="l01347"></a>01347

1375

<a name="l01348"></a>01348 /*!

1376

<a name="l01349"></a>01349 \brief Optimization mode

1377

<a name="l01350"></a>01350 Every next level means additional checks (better compression vs time)

1378

<a name="l01351"></a>01351 \sa optimize

1379

<a name="l01352"></a>01352 */

1380

<a name="l01353"></a><a class="code" href="a00044.html#a05f1e977cb5e6208838afc7e7b69e5f0">01353</a> enum <a class="code" href="a00044.html#a05f1e977cb5e6208838afc7e7b69e5f0" title="Optimization mode Every next level means additional checks (better compression vs...">optmode</a>

1381

<a name="l01354"></a>01354 {

1382

<a name="l01355"></a><a class="code" href="a00044.html#a05f1e977cb5e6208838afc7e7b69e5f0ab9b4d2133014db3d5dbd9c2eda332d19">01355</a> <a class="code" href="a00044.html#a05f1e977cb5e6208838afc7e7b69e5f0ab9b4d2133014db3d5dbd9c2eda332d19" title="Free unused 0 blocks.">opt_free_0</a> = 1, ///< Free unused 0 blocks

1383

<a name="l01356"></a><a class="code" href="a00044.html#a05f1e977cb5e6208838afc7e7b69e5f0a9b54164042434a520ff7e7464e4b43b0">01356</a> <a class="code" href="a00044.html#a05f1e977cb5e6208838afc7e7b69e5f0a9b54164042434a520ff7e7464e4b43b0" title="Free unused 0 and 1 blocks.">opt_free_01</a> = 2, ///< Free unused 0 and 1 blocks

1384

<a name="l01357"></a><a class="code" href="a00044.html#a05f1e977cb5e6208838afc7e7b69e5f0a85f191ba55048d1c436e1e948e9be783">01357</a> <a class="code" href="a00044.html#a05f1e977cb5e6208838afc7e7b69e5f0a85f191ba55048d1c436e1e948e9be783" title="compress blocks when possible">opt_compress</a> = 3 ///< compress blocks when possible

1385

<a name="l01358"></a>01358 };

1386

<a name="l01359"></a>01359

1387

<a name="l01360"></a>01360 /*!

1388

<a name="l01361"></a>01361 \brief Optimize memory bitvector's memory allocation.

1389

<a name="l01362"></a>01362

1390

<a name="l01363"></a>01363 Function analyze all blocks in the bitvector, compresses blocks

1391

<a name="l01364"></a>01364 with a regular structure, frees some memory. This function is recommended

1392

<a name="l01365"></a>01365 after a bulk modification of the bitvector using set_bit, clear_bit or

1393

<a name="l01366"></a>01366 logical operations.

1394

<a name="l01367"></a>01367

1395

<a name="l01368"></a>01368 Optionally function can calculate vector post optimization statistics

1396

<a name="l01369"></a>01369

1397

<a name="l01370"></a>01370 @sa optmode, optimize_gap_size

1398

<a name="l01371"></a>01371 */

1399

<a name="l01372"></a>01372 void <a class="code" href="a00044.html#abd522c13e26c2b8f84636fe8b6648dcb" title="Optimize memory bitvector&#39;s memory allocation.">optimize</a>(<a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* temp_block = 0,

1400

<a name="l01373"></a>01373 <a class="code" href="a00044.html#a05f1e977cb5e6208838afc7e7b69e5f0" title="Optimization mode Every next level means additional checks (better compression vs...">optmode</a> opt_mode = <a class="code" href="a00044.html#a05f1e977cb5e6208838afc7e7b69e5f0a85f191ba55048d1c436e1e948e9be783" title="compress blocks when possible">opt_compress</a>,

1401

<a name="l01374"></a>01374 statistics* stat = 0);

1402

<a name="l01375"></a>01375

1403

<a name="l01376"></a>01376 /*!

1404

<a name="l01377"></a>01377 \brief Optimize sizes of GAP blocks

1405

<a name="l01378"></a>01378

1406

<a name="l01379"></a>01379 This method runs an analysis to find optimal GAP levels for the

1407

<a name="l01380"></a>01380 specific vector. Current GAP compression algorithm uses several fixed

1408

<a name="l01381"></a>01381 GAP sizes. By default bvector uses some reasonable preset.

1409

<a name="l01382"></a>01382 */

1410

<a name="l01383"></a>01383 void <a class="code" href="a00044.html#a3942e3f6ea9fa54fcdb78a35a85008e5" title="Optimize sizes of GAP blocks.">optimize_gap_size</a>();

1411

<a name="l01384"></a>01384

1412

<a name="l01385"></a>01385

1413

<a name="l01386"></a>01386 /*!

1414

<a name="l01387"></a>01387 @brief Sets new GAP lengths table. All GAP blocks will be reallocated

1415

<a name="l01388"></a>01388 to match the new scheme.

1416

<a name="l01389"></a>01389

1417

<a name="l01390"></a>01390 @param glevel_len - pointer on C-style array keeping GAP block sizes.

1418

<a name="l01391"></a>01391 */

1419

<a name="l01392"></a>01392 void <a class="code" href="a00044.html#a40d82dec62efe90b0810ccd06b62163e" title="Sets new GAP lengths table. All GAP blocks will be reallocated to match the new scheme...">set_gap_levels</a>(const <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* glevel_len);

1420

<a name="l01393"></a>01393

1421

<a name="l01394"></a>01394 /*!

1422

<a name="l01395"></a>01395 \brief Lexicographical comparison with a bitvector.

1423

<a name="l01396"></a>01396

1424

<a name="l01397"></a>01397 Function compares current bitvector with the provided argument

1425

<a name="l01398"></a>01398 bit by bit and returns -1 if our bitvector less than the argument,

1426

<a name="l01399"></a>01399 1 - greater, 0 - equal.

1427

<a name="l01400"></a>01400 */

1428

<a name="l01401"></a>01401 int <a class="code" href="a00044.html#aa2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">compare</a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvect</a>) const;

1429

<a name="l01402"></a>01402

1430

<a name="l01403"></a>01403 /*! @brief Allocates temporary block of memory.

1431

<a name="l01404"></a>01404

1432

<a name="l01405"></a>01405 Temp block can be passed to bvector functions requiring some temp memory

1433

<a name="l01406"></a>01406 for their operation. (like serialize)

1434

<a name="l01407"></a>01407

1435

<a name="l01408"></a>01408 @note method is marked const, but it's not quite true, since

1436

<a name="l01409"></a>01409 it can in some cases modify the state of the block allocator

1437

<a name="l01410"></a>01410 (if it has a state). (Can be important in MT programs).

1438

<a name="l01411"></a>01411

1439

<a name="l01412"></a>01412 @sa free_tempblock

1440

<a name="l01413"></a>01413 */

1441

<a name="l01414"></a><a class="code" href="a00044.html#ab7d74cc7b7d6c6e77dd3634ecbb35e4f">01414</a> <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* <a class="code" href="a00044.html#ab7d74cc7b7d6c6e77dd3634ecbb35e4f" title="Allocates temporary block of memory.">allocate_tempblock</a>() const

1442

<a name="l01415"></a>01415 {

1443

<a name="l01416"></a>01416 <a class="code" href="a00044.html#a1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>* bm =

1444

<a name="l01417"></a>01417 const_cast<<a class="code" href="a00044.html#a1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>*>(&blockman_);

1445

<a name="l01418"></a>01418 return bm->get_allocator().alloc_bit_block();

1446

<a name="l01419"></a>01419 }

1447

<a name="l01420"></a>01420

1448

<a name="l01421"></a>01421 /*! @brief Frees temporary block of memory.

1449

<a name="l01422"></a>01422

1450

<a name="l01423"></a>01423 @note method is marked const, but it's not quite true, since

1451

<a name="l01424"></a>01424 it can in some cases modify the state of the block allocator

1452

<a name="l01425"></a>01425 (if it has a state). (Can be important in MT programs).

1453

<a name="l01426"></a>01426

1454

<a name="l01427"></a>01427 @sa allocate_tempblock

1455

<a name="l01428"></a>01428 */

1456

<a name="l01429"></a><a class="code" href="a00044.html#a311bbf4841d2a25a2e7f59f6861f1592">01429</a> void <a class="code" href="a00044.html#a311bbf4841d2a25a2e7f59f6861f1592" title="Frees temporary block of memory.">free_tempblock</a>(<a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* block) const

1457

<a name="l01430"></a>01430 {

1458

<a name="l01431"></a>01431 <a class="code" href="a00044.html#a1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>* bm =

1459

<a name="l01432"></a>01432 const_cast<<a class="code" href="a00044.html#a1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>*>(&blockman_);

1460

<a name="l01433"></a>01433 bm->get_allocator().free_bit_block(block);

1461

<a name="l01434"></a>01434 }

1462

<a name="l01435"></a>01435

1463

<a name="l01436"></a>01436 /**

1464

<a name="l01437"></a>01437 \brief Returns enumerator pointing on the first non-zero bit.

1465

<a name="l01438"></a>01438 */

1466

<a name="l01439"></a><a class="code" href="a00044.html#aad48c661f843e32c9893438a6f27a8f0">01439</a> <a class="code" href="a00063.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a> <a class="code" href="a00044.html#aad48c661f843e32c9893438a6f27a8f0" title="Returns enumerator pointing on the first non-zero bit.">first</a>() const

1467

<a name="l01440"></a>01440 {

1468

<a name="l01441"></a>01441 typedef typename <a class="code" href="a00063.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">bvector<Alloc, MS>::enumerator</a> enumerator_type;

1469

<a name="l01442"></a>01442 return enumerator_type(this, 0);

1470

<a name="l01443"></a>01443 }

1471

<a name="l01444"></a>01444

1472

<a name="l01445"></a>01445 /**

1473

<a name="l01446"></a>01446 \fn bvector::enumerator bvector::end() const

1474

<a name="l01447"></a>01447 \brief Returns enumerator pointing on the next bit after the last.

1475

<a name="l01448"></a>01448 */

1476

<a name="l01449"></a><a class="code" href="a00044.html#a2c6e522f858fdc466765d2c0f269f590">01449</a> <a class="code" href="a00063.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a> <a class="code" href="a00044.html#a2c6e522f858fdc466765d2c0f269f590" title="Returns enumerator pointing on the next bit after the last.">end</a>() const

1477

<a name="l01450"></a>01450 {

1478

<a name="l01451"></a>01451 typedef typename <a class="code" href="a00063.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">bvector<Alloc, MS>::enumerator</a> enumerator_type;

1479

<a name="l01452"></a>01452 return enumerator_type(this, 1);

1480

<a name="l01453"></a>01453 }

1481

<a name="l01454"></a>01454

1482

<a name="l01455"></a>01455

1483

<a name="l01456"></a><a class="code" href="a00044.html#a68bb64dca7f60aa1828ddd4be63418dc">01456</a> const <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* <a class="code" href="a00044.html#a68bb64dca7f60aa1828ddd4be63418dc">get_block</a>(unsigned nb) const

1484

<a name="l01457"></a>01457 {

1485

<a name="l01458"></a>01458 return blockman_.get_block(nb);

1486

<a name="l01459"></a>01459 }

1487

<a name="l01460"></a>01460

1488

<a name="l01461"></a>01461 void <a class="code" href="a00044.html#af2c137de958a038f96e1149c51ea8a8f">combine_operation</a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvect</a>,

1489

<a name="l01462"></a>01462 <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1" title="Bit operations enumeration.">bm::operation</a> opcode);

1490

<a name="l01463"></a>01463

1491

<a name="l01464"></a>01464 private:

1492

<a name="l01465"></a>01465

1493

<a name="l01466"></a>01466 <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> check_or_next(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> prev) const;

1494

<a name="l01467"></a>01467

1495

<a name="l01468"></a>01468 /// check if specified bit is 1, and set it to 0

1496

<a name="l01469"></a>01469 /// if specified bit is 0, scan for the next 1 and returns it

1497

<a name="l01470"></a>01470 /// if no 1 found returns 0

1498

<a name="l01471"></a>01471 <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> check_or_next_extract(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> prev);

1499

<a name="l01472"></a>01472

1500

<a name="l01473"></a>01473 /**

1501

<a name="l01474"></a>01474 \brief Set specified bit without checking preconditions (size, etc)

1502

<a name="l01475"></a>01475 */

1503

<a name="l01476"></a>01476 bool set_bit_no_check(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val);

1504

<a name="l01477"></a>01477

1505

<a name="l01478"></a>01478 /**

1506

<a name="l01479"></a>01479 \brief AND specified bit without checking preconditions (size, etc)

1507

<a name="l01480"></a>01480 */

1508

<a name="l01481"></a>01481 bool and_bit_no_check(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val);

1509

<a name="l01482"></a>01482

1510

<a name="l01483"></a>01483 bool set_bit_conditional_impl(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val, bool condition);

1511

<a name="l01484"></a>01484

1512

<a name="l01485"></a>01485

1513

<a name="l01486"></a>01486 void combine_operation_with_block(unsigned nb,

1514

<a name="l01487"></a>01487 unsigned gap,

1515

<a name="l01488"></a>01488 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk,

1516

<a name="l01489"></a>01489 const <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* arg_blk,

1517

<a name="l01490"></a>01490 int arg_gap,

1518

<a name="l01491"></a>01491 <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1" title="Bit operations enumeration.">bm::operation</a> opcode);

1519

<a name="l01492"></a>01492 public:

1520

<a name="l01493"></a><a class="code" href="a00044.html#a894bfd0e43484e819694c6560cd4207c">01493</a> void combine_operation_with_block(unsigned nb,

1521

<a name="l01494"></a>01494 const <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* arg_blk,

1522

<a name="l01495"></a>01495 int arg_gap,

1523

<a name="l01496"></a>01496 <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1" title="Bit operations enumeration.">bm::operation</a> opcode)

1524

<a name="l01497"></a>01497 {

1525

<a name="l01498"></a>01498 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk = const_cast<<a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*>(<a class="code" href="a00044.html#a68bb64dca7f60aa1828ddd4be63418dc">get_block</a>(nb));

1526

<a name="l01499"></a>01499 bool gap = <a class="code" href="a00092.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>((*this), blk, nb);

1527

<a name="l01500"></a>01500 combine_operation_with_block(nb, gap, blk, arg_blk, arg_gap, opcode);

1528

<a name="l01501"></a>01501 }

1529

<a name="l01502"></a>01502 private:

1530

<a name="l01503"></a>01503 void <a class="code" href="a00115.html#abecd5b24d5e394fd46a9db514cfa659a" title="Internal function computes different distance metrics.">combine_count_operation_with_block</a>(unsigned nb,

1531

<a name="l01504"></a>01504 const <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* arg_blk,

1532

<a name="l01505"></a>01505 int arg_gap,

1533

<a name="l01506"></a>01506 <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1" title="Bit operations enumeration.">bm::operation</a> opcode)

1534

<a name="l01507"></a>01507 {

1535

<a name="l01508"></a>01508 const <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk = <a class="code" href="a00044.html#a68bb64dca7f60aa1828ddd4be63418dc">get_block</a>(nb);

1536

<a name="l01509"></a>01509 bool gap = <a class="code" href="a00092.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>((*this), blk, nb);

1537

<a name="l01510"></a>01510 <a class="code" href="a00115.html#abecd5b24d5e394fd46a9db514cfa659a" title="Internal function computes different distance metrics.">combine_count_operation_with_block</a>(nb, gap, blk, arg_blk, arg_gap, opcode);

1538

<a name="l01511"></a>01511 }

1539

<a name="l01512"></a>01512

1540

<a name="l01513"></a>01513

1541

<a name="l01514"></a>01514 /**

1542

<a name="l01515"></a>01515 \brief Extends GAP block to the next level or converts it to bit block.

1543

<a name="l01516"></a>01516 \param nb - Block's linear index.

1544

<a name="l01517"></a>01517 \param blk - Blocks's pointer

1545

<a name="l01518"></a>01518 */

1546

<a name="l01519"></a>01519 void extend_gap_block(unsigned nb, <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* blk)

1547

<a name="l01520"></a>01520 {

1548

<a name="l01521"></a>01521 blockman_.extend_gap_block(nb, blk);

1549

<a name="l01522"></a>01522 }

1550

<a name="l01523"></a>01523

1551

<a name="l01524"></a>01524 /**

1552

<a name="l01525"></a>01525 \brief Set range without validity checking

1553

<a name="l01526"></a>01526 */

1554

<a name="l01527"></a>01527 void set_range_no_check(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> left,

1555

<a name="l01528"></a>01528 <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> right,

1556

<a name="l01529"></a>01529 bool value);

1557

<a name="l01530"></a>01530 public:

1558

<a name="l01531"></a>01531

1559

<a name="l01532"></a><a class="code" href="a00044.html#a9599df0386dfc7e6bad95fde7e4b3ee8">01532</a> const <a class="code" href="a00044.html#a1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>& <a class="code" href="a00044.html#a9599df0386dfc7e6bad95fde7e4b3ee8">get_blocks_manager</a>() const

1560

<a name="l01533"></a>01533 {

1561

<a name="l01534"></a>01534 return blockman_;

1562

<a name="l01535"></a>01535 }

1563

<a name="l01536"></a>01536

1564

<a name="l01537"></a><a class="code" href="a00044.html#aa531c7278812888bca2d1617bb19e0b0">01537</a> <a class="code" href="a00044.html#a1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>& <a class="code" href="a00044.html#a9599df0386dfc7e6bad95fde7e4b3ee8">get_blocks_manager</a>()

1565

<a name="l01538"></a>01538 {

1566

<a name="l01539"></a>01539 return blockman_;

1567

<a name="l01540"></a>01540 }

1568

<a name="l01541"></a>01541

1569

<a name="l01542"></a>01542

1570

<a name="l01543"></a>01543 private:

1571

<a name="l01544"></a>01544

1572

<a name="l01545"></a>01545 // This block defines two additional hidden variables used for bitcount

1573

<a name="l01546"></a>01546 // optimization, in rare cases can make bitvector thread unsafe.

1574

<a name="l01547"></a>01547 #ifdef BMCOUNTOPT

1575

<a name="l01548"></a>01548 mutable <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">id_t</a> count_; //!< number of 1 bits in the vector

1576

<a name="l01549"></a>01549 mutable bool count_is_valid_; //!< actualization flag

1577

<a name="l01550"></a>01550 #endif

1578

<a name="l01551"></a>01551

1579

<a name="l01552"></a>01552 <a class="code" href="a00044.html#a1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a> blockman_; //!< bitblocks manager

1580

<a name="l01553"></a>01553 <a class="code" href="a00118.html#gad0b87b3b7292383a864d27feaf1c9eff" title="Block allocation strategies.">strategy</a> new_blocks_strat_; //!< block allocation strategy

1581

<a name="l01554"></a>01554 <a class="code" href="a00044.html#aba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> size_; //!< size in bits

1582

<a name="l01555"></a>01555 };

1583

<a name="l01556"></a>01556

1584

<a name="l01557"></a>01557

1585

<a name="l01558"></a>01558

1586

<a name="l01559"></a>01559

1587

<a name="l01560"></a>01560

1588

<a name="l01561"></a>01561 //---------------------------------------------------------------------

1589

<a name="l01562"></a>01562

1590

<a name="l01563"></a>01563 template<class Alloc, class MS>

1591

<a name="l01564"></a><a class="code" href="a00115.html#ac766cc15ae8feca9e21a36c49bf3b557">01564</a> inline <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> <a class="code" href="a00115.html#ac766cc15ae8feca9e21a36c49bf3b557">operator& </a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& v1,

1592

<a name="l01565"></a>01565 const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& v2)

1593

<a name="l01566"></a>01566 {

1594

<a name="l01567"></a>01567 #ifdef BM_USE_EXPLICIT_TEMP

1595

<a name="l01568"></a>01568 <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> ret(v1);

1596

<a name="l01569"></a>01569 ret.<a class="code" href="a00044.html#a051a39027c3b12751f172c20f2d03a0f" title="Logical AND operation.">bit_and</a>(v2);

1597

<a name="l01570"></a>01570 return ret;

1598

<a name="l01571"></a>01571 #else

1599

<a name="l01572"></a>01572 return <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>(v1).bit_and(v2);

1600

<a name="l01573"></a>01573 #endif

1601

<a name="l01574"></a>01574 }

1602

<a name="l01575"></a>01575

1603

<a name="l01576"></a>01576 //---------------------------------------------------------------------

1604

<a name="l01577"></a>01577

1605

<a name="l01578"></a>01578 template<class Alloc, class MS>

1606

<a name="l01579"></a><a class="code" href="a00115.html#a5cc9411c5170df52c1c4ea436ef32745">01579</a> inline <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> <a class="code" href="a00115.html#a5cc9411c5170df52c1c4ea436ef32745">operator| </a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& v1,

1607

<a name="l01580"></a>01580 const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc></a>& v2)

1608

<a name="l01581"></a>01581 {

1609

<a name="l01582"></a>01582 #ifdef BM_USE_EXPLICIT_TEMP

1610

<a name="l01583"></a>01583 <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> ret(v1);

1611

<a name="l01584"></a>01584 ret.<a class="code" href="a00044.html#a0eacd87603f41a9aea2126810183f83a" title="Logical OR operation.">bit_or</a>(v2);

1612

<a name="l01585"></a>01585 return ret;

1613

<a name="l01586"></a>01586 #else

1614

<a name="l01587"></a>01587 return <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>(v1).bit_or(v2);

1615

<a name="l01588"></a>01588 #endif

1616

<a name="l01589"></a>01589 }

1617

<a name="l01590"></a>01590

1618

<a name="l01591"></a>01591 //---------------------------------------------------------------------

1619

<a name="l01592"></a>01592

1620

<a name="l01593"></a>01593 template<class Alloc, class MS>

1621

<a name="l01594"></a><a class="code" href="a00115.html#a7042429992aec5891a3df1b0bddea05f">01594</a> inline <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> <a class="code" href="a00115.html#a7042429992aec5891a3df1b0bddea05f">operator^ </a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& v1,

1622

<a name="l01595"></a>01595 const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& v2)

1623

<a name="l01596"></a>01596 {

1624

<a name="l01597"></a>01597 #ifdef BM_USE_EXPLICIT_TEMP

1625

<a name="l01598"></a>01598 <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> ret(v1);

1626

<a name="l01599"></a>01599 ret.<a class="code" href="a00044.html#a997a62ec2effcd60246fb9b72f30ccfa" title="Logical XOR operation.">bit_xor</a>(v2);

1627

<a name="l01600"></a>01600 return ret;

1628

<a name="l01601"></a>01601 #else

1629

<a name="l01602"></a>01602 return <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>(v1).bit_xor(v2);

1630

<a name="l01603"></a>01603 #endif

1631

<a name="l01604"></a>01604 }

1632

<a name="l01605"></a>01605

1633

<a name="l01606"></a>01606 //---------------------------------------------------------------------

1634

<a name="l01607"></a>01607

1635

<a name="l01608"></a>01608 template<class Alloc, class MS>

1636

<a name="l01609"></a><a class="code" href="a00115.html#afe23d0ced66b48b9c4214e0b00dcc5ac">01609</a> inline <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> <a class="code" href="a00115.html#afe23d0ced66b48b9c4214e0b00dcc5ac">operator- </a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& v1,

1637

<a name="l01610"></a>01610 const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& v2)

1638

<a name="l01611"></a>01611 {

1639

<a name="l01612"></a>01612 #ifdef BM_USE_EXPLICIT_TEMP

1640

<a name="l01613"></a>01613 <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> ret(v1);

1641

<a name="l01614"></a>01614 ret.<a class="code" href="a00044.html#a6a8e699f9c0571f904d7cbaa2e3ed1f1" title="Logical SUB operation.">bit_sub</a>(v2);

1642

<a name="l01615"></a>01615 return ret;

1643

<a name="l01616"></a>01616 #else

1644

<a name="l01617"></a>01617 return <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>(v1).bit_sub(v2);

1645

<a name="l01618"></a>01618 #endif

1646

<a name="l01619"></a>01619 }

1647

<a name="l01620"></a>01620

1648

<a name="l01621"></a>01621

1649

<a name="l01622"></a>01622

1650

<a name="l01623"></a>01623

1651

<a name="l01624"></a>01624 // -----------------------------------------------------------------------

1652

<a name="l01625"></a>01625

1653

<a name="l01626"></a>01626 template<typename Alloc, typename MS>

1654

<a name="l01627"></a><a class="code" href="a00044.html#a14bc35b9b022018f10787b07a5b2af04">01627</a> <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00044.html#a14bc35b9b022018f10787b07a5b2af04" title="Sets all bits in the specified closed interval [left,right] Interval must be inside...">bvector<Alloc, MS>::set_range</a>(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> left,

1655

<a name="l01628"></a>01628 <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> right,

1656

<a name="l01629"></a>01629 bool value)

1657

<a name="l01630"></a>01630 {

1658

<a name="l01631"></a>01631 if (right < left)

1659

<a name="l01632"></a>01632 {

1660

<a name="l01633"></a>01633 return <a class="code" href="a00044.html#a14bc35b9b022018f10787b07a5b2af04" title="Sets all bits in the specified closed interval [left,right] Interval must be inside...">set_range</a>(right, left, value);

1661

<a name="l01634"></a>01634 }

1662

<a name="l01635"></a>01635

1663

<a name="l01636"></a>01636 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(left < size_);

1664

<a name="l01637"></a>01637 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(right < size_);

1665

<a name="l01638"></a>01638

1666

<a name="l01639"></a>01639 <a class="code" href="a00087.html#a835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false)

1667

<a name="l01640"></a>01640 <a class="code" href="a00092.html#a7e6f87ba3230dece2125af5c32e84b05">BM_SET_MMX_GUARD</a>

1668

<a name="l01641"></a>01641

1669

<a name="l01642"></a>01642 set_range_no_check(left, right, value);

1670

<a name="l01643"></a>01643

1671

<a name="l01644"></a>01644 return *this;

1672

<a name="l01645"></a>01645 }

1673

<a name="l01646"></a>01646

1674

<a name="l01647"></a>01647 // -----------------------------------------------------------------------

1675

<a name="l01648"></a>01648

1676

<a name="l01649"></a>01649 template<typename Alloc, typename MS>

1677

<a name="l01650"></a><a class="code" href="a00044.html#a71077c1315555301532e24d4d2b95ea2">01650</a> <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00044.html#a71077c1315555301532e24d4d2b95ea2" title="Returns count of bits which are 1.">bvector<Alloc, MS>::count</a>() const

1678

<a name="l01651"></a>01651 {

1679

<a name="l01652"></a>01652 #ifdef BMCOUNTOPT

1680

<a name="l01653"></a>01653 if (count_is_valid_) return count_;

1681

<a name="l01654"></a>01654 #endif

1682

<a name="l01655"></a>01655 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">word_t</a>*** blk_root = blockman_.get_rootblock();

1683

<a name="l01656"></a>01656 if (!blk_root)

1684

<a name="l01657"></a>01657 {

1685

<a name="l01658"></a>01658 <a class="code" href="a00087.html#a1fbebc7fe3c22d768ff6e240437ee8f4">BMCOUNT_SET</a>(0);

1686

<a name="l01659"></a>01659 return 0;

1687

<a name="l01660"></a>01660 }

1688

<a name="l01661"></a>01661 typename blocks_manager_type::block_count_func func(blockman_);

1689

<a name="l01662"></a>01662 <a class="code" href="a00115.html#ae8b342c25dc22d6cd26cb96d7ae796db">for_each_nzblock</a>(blk_root, blockman_.effective_top_block_size(),

1690

<a name="l01663"></a>01663 <a class="code" href="a00115.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>, func);

1691

<a name="l01664"></a>01664

1692

<a name="l01665"></a>01665 <a class="code" href="a00087.html#a1fbebc7fe3c22d768ff6e240437ee8f4">BMCOUNT_SET</a>(func.count());

1693

<a name="l01666"></a>01666 return func.count();

1694

<a name="l01667"></a>01667 }

1695

<a name="l01668"></a>01668

1696

<a name="l01669"></a>01669 // -----------------------------------------------------------------------

1697

<a name="l01670"></a>01670

1698

<a name="l01671"></a>01671 template<typename Alloc, typename MS>

1699

<a name="l01672"></a><a class="code" href="a00044.html#a7be4f9e0741f43869f4dcd9607736c0e">01672</a> void <a class="code" href="a00044.html#a7be4f9e0741f43869f4dcd9607736c0e" title="Change size of the bvector.">bvector<Alloc, MS>::resize</a>(size_type new_size)

1700

<a name="l01673"></a>01673 {

1701

<a name="l01674"></a>01674 if (size_ == new_size) return; // nothing to do

1702

<a name="l01675"></a>01675 if (size_ < new_size) // size grows

1703

<a name="l01676"></a>01676 {

1704

<a name="l01677"></a>01677 blockman_.reserve(new_size);

1705

<a name="l01678"></a>01678 size_ = new_size;

1706

<a name="l01679"></a>01679 }

1707

<a name="l01680"></a>01680 else // shrink

1708

<a name="l01681"></a>01681 {

1709

<a name="l01682"></a>01682 <a class="code" href="a00044.html#a14bc35b9b022018f10787b07a5b2af04" title="Sets all bits in the specified closed interval [left,right] Interval must be inside...">set_range</a>(new_size, size_ - 1, false); // clear the tail

1710

<a name="l01683"></a>01683 size_ = new_size;

1711

<a name="l01684"></a>01684 }

1712

<a name="l01685"></a>01685 }

1713

<a name="l01686"></a>01686

1714

<a name="l01687"></a>01687 // -----------------------------------------------------------------------

1715

<a name="l01688"></a>01688

1716

<a name="l01689"></a>01689 template<typename Alloc, typename MS>

1717

<a name="l01690"></a><a class="code" href="a00044.html#adbe1a2423ce166b88a0b57e435af2733">01690</a> <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00044.html#adbe1a2423ce166b88a0b57e435af2733" title="Returns count of 1 bits in the given diapason.">bvector<Alloc, MS>::count_range</a>(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> left,

1718

<a name="l01691"></a>01691 <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> right,

1719

<a name="l01692"></a>01692 unsigned* block_count_arr) const

1720

<a name="l01693"></a>01693 {

1721

<a name="l01694"></a>01694 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(left <= right);

1722

<a name="l01695"></a>01695

1723

<a name="l01696"></a>01696 unsigned <a class="code" href="a00044.html#a71077c1315555301532e24d4d2b95ea2" title="Returns count of bits which are 1.">count</a> = 0;

1724

<a name="l01697"></a>01697

1725

<a name="l01698"></a>01698 // calculate logical number of start and destination blocks

1726

<a name="l01699"></a>01699 unsigned nblock_left = unsigned(left >> <a class="code" href="a00115.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

1727

<a name="l01700"></a>01700 unsigned nblock_right = unsigned(right >> <a class="code" href="a00115.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

1728

<a name="l01701"></a>01701

1729

<a name="l01702"></a>01702 const <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* block = blockman_.get_block(nblock_left);

1730

<a name="l01703"></a>01703 bool left_gap = <a class="code" href="a00092.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nblock_left);

1731

<a name="l01704"></a>01704

1732

<a name="l01705"></a>01705 unsigned nbit_left = unsigned(left & <a class="code" href="a00115.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

1733

<a name="l01706"></a>01706 unsigned nbit_right = unsigned(right & bm::set_block_mask);

1734

<a name="l01707"></a>01707

1735

<a name="l01708"></a>01708 unsigned r =

1736

<a name="l01709"></a>01709 (nblock_left == nblock_right) ? nbit_right : (<a class="code" href="a00115.html#ae9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a>-1);

1737

<a name="l01710"></a>01710

1738

<a name="l01711"></a>01711 typename blocks_manager_type::block_count_func func(blockman_);

1739

<a name="l01712"></a>01712

1740

<a name="l01713"></a>01713 if (block)

1741

<a name="l01714"></a>01714 {

1742

<a name="l01715"></a>01715 if ((nbit_left == 0) && (r == (<a class="code" href="a00115.html#ae9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a>-1))) // whole block

1743

<a name="l01716"></a>01716 {

1744

<a name="l01717"></a>01717 if (block_count_arr)

1745

<a name="l01718"></a>01718 {

1746

<a name="l01719"></a>01719 count += block_count_arr[nblock_left];

1747

<a name="l01720"></a>01720 }

1748

<a name="l01721"></a>01721 else

1749

<a name="l01722"></a>01722 {

1750

<a name="l01723"></a>01723 func(block, nblock_left);

1751

<a name="l01724"></a>01724 }

1752

<a name="l01725"></a>01725 }

1753

<a name="l01726"></a>01726 else

1754

<a name="l01727"></a>01727 {

1755

<a name="l01728"></a>01728 if (left_gap)

1756

<a name="l01729"></a>01729 {

1757

<a name="l01730"></a>01730 count += <a class="code" href="a00115.html#a7324ebded429e15361f62117a2ff18d1" title="Counts 1 bits in GAP buffer in the closed [left, right] diapason.">gap_bit_count_range</a>(<a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block),

1758

<a name="l01731"></a>01731 (<a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>)nbit_left,

1759

<a name="l01732"></a>01732 (<a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>)r);

1760

<a name="l01733"></a>01733 }

1761

<a name="l01734"></a>01734 else

1762

<a name="l01735"></a>01735 {

1763

<a name="l01736"></a>01736 count += <a class="code" href="a00120.html#ga2485f707b2629c5ce7681cf9fe385b91">bit_block_calc_count_range</a>(block, nbit_left, r);

1764

<a name="l01737"></a>01737 }

1765

<a name="l01738"></a>01738 }

1766

<a name="l01739"></a>01739 }

1767

<a name="l01740"></a>01740

1768

<a name="l01741"></a>01741 if (nblock_left == nblock_right) // in one block

1769

<a name="l01742"></a>01742 {

1770

<a name="l01743"></a>01743 return count + func.count();

1771

<a name="l01744"></a>01744 }

1772

<a name="l01745"></a>01745

1773

<a name="l01746"></a>01746 for (unsigned nb = nblock_left+1; nb < nblock_right; ++nb)

1774

<a name="l01747"></a>01747 {

1775

<a name="l01748"></a>01748 block = blockman_.get_block(nb);

1776

<a name="l01749"></a>01749 if (block_count_arr)

1777

<a name="l01750"></a>01750 {

1778

<a name="l01751"></a>01751 count += block_count_arr[nb];

1779

<a name="l01752"></a>01752 }

1780

<a name="l01753"></a>01753 else

1781

<a name="l01754"></a>01754 {

1782

<a name="l01755"></a>01755 if (block)

1783

<a name="l01756"></a>01756 func(block, nb);

1784

<a name="l01757"></a>01757 }

1785

<a name="l01758"></a>01758 }

1786

<a name="l01759"></a>01759 count += func.count();

1787

<a name="l01760"></a>01760

1788

<a name="l01761"></a>01761 block = blockman_.get_block(nblock_right);

1789

<a name="l01762"></a>01762 bool right_gap = <a class="code" href="a00092.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nblock_right);

1790

<a name="l01763"></a>01763

1791

<a name="l01764"></a>01764 if (block)

1792

<a name="l01765"></a>01765 {

1793

<a name="l01766"></a>01766 if (right_gap)

1794

<a name="l01767"></a>01767 {

1795

<a name="l01768"></a>01768 count += <a class="code" href="a00115.html#a7324ebded429e15361f62117a2ff18d1" title="Counts 1 bits in GAP buffer in the closed [left, right] diapason.">gap_bit_count_range</a>(<a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block),

1796

<a name="l01769"></a>01769 (<a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>)0,

1797

<a name="l01770"></a>01770 (<a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>)nbit_right);

1798

<a name="l01771"></a>01771 }

1799

<a name="l01772"></a>01772 else

1800

<a name="l01773"></a>01773 {

1801

<a name="l01774"></a>01774 count += <a class="code" href="a00120.html#ga2485f707b2629c5ce7681cf9fe385b91">bit_block_calc_count_range</a>(block, 0, nbit_right);

1802

<a name="l01775"></a>01775 }

1803

<a name="l01776"></a>01776 }

1804

<a name="l01777"></a>01777

1805

<a name="l01778"></a>01778 return count;

1806

<a name="l01779"></a>01779 }

1807

<a name="l01780"></a>01780

1808

<a name="l01781"></a>01781 // -----------------------------------------------------------------------

1809

<a name="l01782"></a>01782

1810

<a name="l01783"></a>01783 template<typename Alloc, typename MS>

1811

<a name="l01784"></a><a class="code" href="a00044.html#a49af36cc1ea632cd3a2217b53b69dafc">01784</a> <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00044.html#a49af36cc1ea632cd3a2217b53b69dafc" title="Inverts all bits.">bvector<Alloc, MS>::invert</a>()

1812

<a name="l01785"></a>01785 {

1813

<a name="l01786"></a>01786 <a class="code" href="a00087.html#a835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false)

1814

<a name="l01787"></a>01787 <a class="code" href="a00092.html#a7e6f87ba3230dece2125af5c32e84b05">BM_SET_MMX_GUARD</a>

1815

<a name="l01788"></a>01788

1816

<a name="l01789"></a>01789 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*** blk_root = blockman_.get_rootblock();

1817

<a name="l01790"></a>01790 typename blocks_manager_type::block_invert_func func(blockman_);

1818

<a name="l01791"></a>01791 <a class="code" href="a00115.html#a86742a3e17527be5a9743f26b36a7691">for_each_block</a>(blk_root, blockman_.top_block_size(),

1819

<a name="l01792"></a>01792 <a class="code" href="a00115.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>, func);

1820

<a name="l01793"></a>01793 if (size_ == <a class="code" href="a00115.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>)

1821

<a name="l01794"></a>01794 {

1822

<a name="l01795"></a>01795 set_bit_no_check(<a class="code" href="a00115.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>, false);

1823

<a name="l01796"></a>01796 }

1824

<a name="l01797"></a>01797 else

1825

<a name="l01798"></a>01798 {

1826

<a name="l01799"></a>01799 set_range_no_check(size_, <a class="code" href="a00115.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>, false);

1827

<a name="l01800"></a>01800 }

1828

<a name="l01801"></a>01801

1829

<a name="l01802"></a>01802 return *this;

1830

<a name="l01803"></a>01803 }

1831

<a name="l01804"></a>01804

1832

<a name="l01805"></a>01805 // -----------------------------------------------------------------------

1833

<a name="l01806"></a>01806

1834

<a name="l01807"></a>01807 template<typename Alloc, typename MS>

1835

<a name="l01808"></a><a class="code" href="a00044.html#a11458ca2e3570838da7b94a1e4563d97">01808</a> bool <a class="code" href="a00044.html#a11458ca2e3570838da7b94a1e4563d97" title="returns true if bit n is set and false is bit n is 0.">bvector<Alloc, MS>::get_bit</a>(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n) const

1836

<a name="l01809"></a>01809 {

1837

<a name="l01810"></a>01810 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(n < size_);

1838

<a name="l01811"></a>01811

1839

<a name="l01812"></a>01812 // calculate logical block number

1840

<a name="l01813"></a>01813 unsigned nblock = unsigned(n >> <a class="code" href="a00115.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

1841

<a name="l01814"></a>01814

1842

<a name="l01815"></a>01815 const <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* block = blockman_.get_block(nblock);

1843

<a name="l01816"></a>01816

1844

<a name="l01817"></a>01817 if (block)

1845

<a name="l01818"></a>01818 {

1846

<a name="l01819"></a>01819 // calculate word number in block and bit

1847

<a name="l01820"></a>01820 unsigned nbit = unsigned(n & <a class="code" href="a00115.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

1848

<a name="l01821"></a>01821 unsigned is_set;

1849

<a name="l01822"></a>01822

1850

<a name="l01823"></a>01823 if (<a class="code" href="a00092.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nblock))

1851

<a name="l01824"></a>01824 {

1852

<a name="l01825"></a>01825 is_set = <a class="code" href="a00119.html#ga866352ef5986a7d2b709795d127b666b" title="Tests if bit = pos is true.">gap_test</a>(<a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block), nbit);

1853

<a name="l01826"></a>01826 }

1854

<a name="l01827"></a>01827 else

1855

<a name="l01828"></a>01828 {

1856

<a name="l01829"></a>01829 unsigned nword = unsigned(nbit >> <a class="code" href="a00115.html#a83d76bccf6fe3770f32d5ba11d2a37ad">bm::set_word_shift</a>);

1857

<a name="l01830"></a>01830 nbit &= <a class="code" href="a00115.html#addbf345be3733d5e4575d71733ed1da8">bm::set_word_mask</a>;

1858

<a name="l01831"></a>01831

1859

<a name="l01832"></a>01832 is_set = (block[nword] & (((<a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>)1) << nbit));

1860

<a name="l01833"></a>01833 }

1861

<a name="l01834"></a>01834 return is_set != 0;

1862

<a name="l01835"></a>01835 }

1863

<a name="l01836"></a>01836 return false;

1864

<a name="l01837"></a>01837 }

1865

<a name="l01838"></a>01838

1866

<a name="l01839"></a>01839 // -----------------------------------------------------------------------

1867

<a name="l01840"></a>01840

1868

<a name="l01841"></a>01841 template<typename Alloc, typename MS>

1869

<a name="l01842"></a><a class="code" href="a00044.html#abd522c13e26c2b8f84636fe8b6648dcb">01842</a> void <a class="code" href="a00044.html#abd522c13e26c2b8f84636fe8b6648dcb" title="Optimize memory bitvector&#39;s memory allocation.">bvector<Alloc, MS>::optimize</a>(<a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* temp_block,

1870

<a name="l01843"></a>01843 <a class="code" href="a00044.html#a05f1e977cb5e6208838afc7e7b69e5f0" title="Optimization mode Every next level means additional checks (better compression vs...">optmode</a> opt_mode,

1871

<a name="l01844"></a>01844 <a class="code" href="a00085.html" title="Statistical information about bitset&#39;s memory allocation details.">statistics</a>* stat)

1872

<a name="l01845"></a>01845 {

1873

<a name="l01846"></a>01846 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">word_t</a>*** blk_root = blockman_.blocks_root();

1874

<a name="l01847"></a>01847

1875

<a name="l01848"></a>01848 if (!temp_block)

1876

<a name="l01849"></a>01849 temp_block = blockman_.check_allocate_tempblock();

1877

<a name="l01850"></a>01850

1878

<a name="l01851"></a>01851 typename

1879

<a name="l01852"></a>01852 blocks_manager_type::block_opt_func opt_func(blockman_,

1880

<a name="l01853"></a>01853 temp_block,

1881

<a name="l01854"></a>01854 (int)opt_mode,

1882

<a name="l01855"></a>01855 stat);

1883

<a name="l01856"></a>01856 if (stat)

1884

<a name="l01857"></a>01857 {

1885

<a name="l01858"></a>01858 stat-><a class="code" href="a00043.html#a4ec8ba190b4ba31c431c008402881c62" title="Number of bit blocks.">bit_blocks</a> = stat-><a class="code" href="a00043.html#a4dcfd64e9ab0be5472e3c2b04e551f81" title="Number of GAP blocks.">gap_blocks</a>

1886

<a name="l01859"></a>01859 = stat-><a class="code" href="a00043.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a>

1887

<a name="l01860"></a>01860 = stat-><a class="code" href="a00043.html#ad3b2190eb4afe24ecd56323cbc0a7666" title="Memory used by bitvector including temp and service blocks.">memory_used</a>

1888

<a name="l01861"></a>01861 = 0;

1889

<a name="l01862"></a>01862 ::memcpy(stat-><a class="code" href="a00043.html#acc08d9637cc25d02d3a50c061ba221e1" title="GAP lengths used by bvector.">gap_levels</a>,

1890

<a name="l01863"></a>01863 blockman_.glen(), sizeof(<a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>) * <a class="code" href="a00115.html#a773e9f5341919d58000bd54d50038733">bm::gap_levels</a>);

1891

<a name="l01864"></a>01864 stat-><a class="code" href="a00043.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> = sizeof(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">id_t</a>) * 4;

1892

<a name="l01865"></a>01865

1893

<a name="l01866"></a>01866 }

1894

<a name="l01867"></a>01867

1895

<a name="l01868"></a>01868 <a class="code" href="a00115.html#ae8b342c25dc22d6cd26cb96d7ae796db">for_each_nzblock</a>(blk_root, blockman_.effective_top_block_size(),

1896

<a name="l01869"></a>01869 <a class="code" href="a00115.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>, opt_func);

1897

<a name="l01870"></a>01870

1898

<a name="l01871"></a>01871 if (stat)

1899

<a name="l01872"></a>01872 {

1900

<a name="l01873"></a>01873 unsigned safe_inc = stat-><a class="code" href="a00043.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> / 10; // 10% increment

1901

<a name="l01874"></a>01874 if (!safe_inc) safe_inc = 256;

1902

<a name="l01875"></a>01875 stat-><a class="code" href="a00043.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> += safe_inc;

1903

<a name="l01876"></a>01876 stat-><a class="code" href="a00043.html#ad3b2190eb4afe24ecd56323cbc0a7666" title="Memory used by bitvector including temp and service blocks.">memory_used</a> += sizeof(*this) - sizeof(blockman_);

1904

<a name="l01877"></a>01877 stat-><a class="code" href="a00043.html#ad3b2190eb4afe24ecd56323cbc0a7666" title="Memory used by bitvector including temp and service blocks.">memory_used</a> += blockman_.mem_used();

1905

<a name="l01878"></a>01878 }

1906

<a name="l01879"></a>01879 }

1907

<a name="l01880"></a>01880

1908

<a name="l01881"></a>01881 // -----------------------------------------------------------------------

1909

<a name="l01882"></a>01882

1910

<a name="l01883"></a>01883 template<typename Alloc, typename MS>

1911

<a name="l01884"></a><a class="code" href="a00044.html#a3942e3f6ea9fa54fcdb78a35a85008e5">01884</a> void <a class="code" href="a00044.html#a3942e3f6ea9fa54fcdb78a35a85008e5" title="Optimize sizes of GAP blocks.">bvector<Alloc, MS>::optimize_gap_size</a>()

1912

<a name="l01885"></a>01885 {

1913

<a name="l01886"></a>01886 struct <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector</a><Alloc, MS>::<a class="code" href="a00085.html" title="Statistical information about bitset&#39;s memory allocation details.">statistics</a> st;

1914

<a name="l01887"></a>01887 <a class="code" href="a00044.html#a1eaaac76a97b9eb1d3c11f21cf9385ac" title="Calculates bitvector statistics.">calc_stat</a>(&st);

1915

<a name="l01888"></a>01888

1916

<a name="l01889"></a>01889 if (!st.gap_blocks)

1917

<a name="l01890"></a>01890 return;

1918

<a name="l01891"></a>01891

1919

<a name="l01892"></a>01892 <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a> opt_glen[bm::<a class="code" href="a00115.html#a773e9f5341919d58000bd54d50038733">gap_levels</a>];

1920

<a name="l01893"></a>01893 ::memcpy(opt_glen, st.gap_levels, bm::gap_levels * sizeof(*opt_glen));

1921

<a name="l01894"></a>01894

1922

<a name="l01895"></a>01895 <a class="code" href="a00119.html#ga2daff3a0ceda6fef87d3b0e892da5813" title="Finds optimal gap blocks lengths.">improve_gap_levels</a>(st.gap_length,

1923

<a name="l01896"></a>01896 st.gap_length + st.gap_blocks,

1924

<a name="l01897"></a>01897 opt_glen);

1925

<a name="l01898"></a>01898

1926

<a name="l01899"></a>01899 <a class="code" href="a00044.html#a40d82dec62efe90b0810ccd06b62163e" title="Sets new GAP lengths table. All GAP blocks will be reallocated to match the new scheme...">set_gap_levels</a>(opt_glen);

1927

<a name="l01900"></a>01900 }

1928

<a name="l01901"></a>01901

1929

<a name="l01902"></a>01902 // -----------------------------------------------------------------------

1930

<a name="l01903"></a>01903

1931

<a name="l01904"></a>01904 template<typename Alloc, typename MS>

1932

<a name="l01905"></a><a class="code" href="a00044.html#a40d82dec62efe90b0810ccd06b62163e">01905</a> void <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector</a><Alloc, MS>::<a class="code" href="a00044.html#a40d82dec62efe90b0810ccd06b62163e" title="Sets new GAP lengths table. All GAP blocks will be reallocated to match the new scheme...">set_gap_levels</a>(const gap_word_t* glevel_len)

1933

<a name="l01906"></a>01906 {

1934

<a name="l01907"></a>01907 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">word_t</a>*** blk_root = blockman_.blocks_root();

1935

<a name="l01908"></a>01908

1936

<a name="l01909"></a>01909 typename

1937

<a name="l01910"></a>01910 blocks_manager_type::gap_level_func gl_func(blockman_, glevel_len);

1938

<a name="l01911"></a>01911

1939

<a name="l01912"></a>01912 <a class="code" href="a00115.html#ae8b342c25dc22d6cd26cb96d7ae796db">for_each_nzblock</a>(blk_root, blockman_.top_block_size(),

1940

<a name="l01913"></a>01913 <a class="code" href="a00115.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>, gl_func);

1941

<a name="l01914"></a>01914

1942

<a name="l01915"></a>01915 blockman_.set_glen(glevel_len);

1943

<a name="l01916"></a>01916 }

1944

<a name="l01917"></a>01917

1945

<a name="l01918"></a>01918 // -----------------------------------------------------------------------

1946

<a name="l01919"></a>01919

1947

<a name="l01920"></a>01920 template<typename Alloc, typename MS>

1948

<a name="l01921"></a><a class="code" href="a00044.html#aa2294dbf9374fd906f74a796d147c255">01921</a> int <a class="code" href="a00044.html#aa2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">bvector<Alloc, MS>::compare</a>(const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvect</a>) const

1949

<a name="l01922"></a>01922 {

1950

<a name="l01923"></a>01923 int res;

1951

<a name="l01924"></a>01924 unsigned bn = 0;

1952

<a name="l01925"></a>01925

1953

<a name="l01926"></a>01926 unsigned top_blocks = blockman_.effective_top_block_size();

1954

<a name="l01927"></a>01927 unsigned bvect_top_blocks = bvect.blockman_.effective_top_block_size();

1955

<a name="l01928"></a>01928

1956

<a name="l01929"></a>01929 if (bvect_top_blocks > top_blocks) top_blocks = bvect_top_blocks;

1957

<a name="l01930"></a>01930

1958

<a name="l01931"></a>01931 for (unsigned i = 0; i < top_blocks; ++i)

1959

<a name="l01932"></a>01932 {

1960

<a name="l01933"></a>01933 const <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* const* blk_blk = blockman_.get_topblock(i);

1961

<a name="l01934"></a>01934 const <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* const* arg_blk_blk =

1962

<a name="l01935"></a>01935 bvect.blockman_.get_topblock(i);

1963

<a name="l01936"></a>01936

1964

<a name="l01937"></a>01937 if (blk_blk == arg_blk_blk)

1965

<a name="l01938"></a>01938 {

1966

<a name="l01939"></a>01939 bn += <a class="code" href="a00115.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>;

1967

<a name="l01940"></a>01940 continue;

1968

<a name="l01941"></a>01941 }

1969

<a name="l01942"></a>01942

1970

<a name="l01943"></a>01943 for (unsigned j = 0; j < <a class="code" href="a00115.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>; ++j, ++bn)

1971

<a name="l01944"></a>01944 {

1972

<a name="l01945"></a>01945 const <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* arg_blk = arg_blk_blk ? arg_blk_blk[j] : 0;

1973

<a name="l01946"></a>01946 const <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk = blk_blk ? blk_blk[j] : 0;

1974

<a name="l01947"></a>01947 if (blk == arg_blk) continue;

1975

<a name="l01948"></a>01948

1976

<a name="l01949"></a>01949 // If one block is zero we check if the other one has at least

1977

<a name="l01950"></a>01950 // one bit ON

1978

<a name="l01951"></a>01951

1979

<a name="l01952"></a>01952 if (!blk || !arg_blk)

1980

<a name="l01953"></a>01953 {

1981

<a name="l01954"></a>01954 const <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* pblk;

1982

<a name="l01955"></a>01955 bool is_gap;

1983

<a name="l01956"></a>01956

1984

<a name="l01957"></a>01957 if (blk)

1985

<a name="l01958"></a>01958 {

1986

<a name="l01959"></a>01959 pblk = blk;

1987

<a name="l01960"></a>01960 res = 1;

1988

<a name="l01961"></a>01961 is_gap = <a class="code" href="a00092.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>((*this), blk, bn);

1989

<a name="l01962"></a>01962 }

1990

<a name="l01963"></a>01963 else

1991

<a name="l01964"></a>01964 {

1992

<a name="l01965"></a>01965 pblk = arg_blk;

1993

<a name="l01966"></a>01966 res = -1;

1994

<a name="l01967"></a>01967 is_gap = <a class="code" href="a00092.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(bvect, arg_blk, bn);

1995

<a name="l01968"></a>01968 }

1996

<a name="l01969"></a>01969

1997

<a name="l01970"></a>01970 if (is_gap)

1998

<a name="l01971"></a>01971 {

1999

<a name="l01972"></a>01972 if (!<a class="code" href="a00119.html#ga690ff7c8b16e1821a77663b7194267e7" title="Temporary inverts all bits in the GAP buffer.">gap_is_all_zero</a>(<a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(pblk), <a class="code" href="a00115.html#ad0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a>))

2000

<a name="l01973"></a>01973 {

2001

<a name="l01974"></a>01974 return res;

2002

<a name="l01975"></a>01975 }

2003

<a name="l01976"></a>01976 }

2004

<a name="l01977"></a>01977 else

2005

<a name="l01978"></a>01978 {

2006

<a name="l01979"></a>01979 <a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>* blk1 = (<a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">wordop_t</a>*)pblk;

2007

<a name="l01980"></a>01980 <a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>* blk2 =

2008

<a name="l01981"></a>01981 (<a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">wordop_t</a>*)(pblk + bm::set_block_size);

2009

<a name="l01982"></a>01982 if (!<a class="code" href="a00120.html#gac6cfb9f92e4df6bb4c76f6efb2382860" title="Returns &quot;true&quot; if all bits in the block are 0.">bit_is_all_zero</a>(blk1, blk2))

2010

<a name="l01983"></a>01983 {

2011

<a name="l01984"></a>01984 return res;

2012

<a name="l01985"></a>01985 }

2013

<a name="l01986"></a>01986 }

2014

<a name="l01987"></a>01987

2015

<a name="l01988"></a>01988 continue;

2016

<a name="l01989"></a>01989 }

2017

<a name="l01990"></a>01990

2018

<a name="l01991"></a>01991 bool arg_gap = <a class="code" href="a00092.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(bvect, arg_blk, bn);

2019

<a name="l01992"></a>01992 bool gap = <a class="code" href="a00092.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>((*this), blk, bn);

2020

<a name="l01993"></a>01993

2021

<a name="l01994"></a>01994 if (arg_gap != gap)

2022

<a name="l01995"></a>01995 {

2023

<a name="l01996"></a>01996 <a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a> temp_blk[<a class="code" href="a00115.html#a7049fd70220fc3a3072e9f82abf4ad66">bm::set_block_size_op</a>];

2024

<a name="l01997"></a>01997 <a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>* blk1;

2025

<a name="l01998"></a>01998 <a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>* blk2;

2026

<a name="l01999"></a>01999

2027

<a name="l02000"></a>02000 if (gap)

2028

<a name="l02001"></a>02001 {

2029

<a name="l02002"></a>02002 <a class="code" href="a00119.html#ga4862f4dcdcb7c0575e2e2db9e5f2a849" title="GAP block to bitblock conversion.">gap_convert_to_bitset</a>((<a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*)temp_blk,

2030

<a name="l02003"></a>02003 <a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk));

2031

<a name="l02004"></a>02004

2032

<a name="l02005"></a>02005 blk1 = (<a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>*)temp_blk;

2033

<a name="l02006"></a>02006 blk2 = (<a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>*)arg_blk;

2034

<a name="l02007"></a>02007 }

2035

<a name="l02008"></a>02008 else

2036

<a name="l02009"></a>02009 {

2037

<a name="l02010"></a>02010 <a class="code" href="a00119.html#ga4862f4dcdcb7c0575e2e2db9e5f2a849" title="GAP block to bitblock conversion.">gap_convert_to_bitset</a>((<a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*)temp_blk,

2038

<a name="l02011"></a>02011 <a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(arg_blk));

2039

<a name="l02012"></a>02012

2040

<a name="l02013"></a>02013 blk1 = (<a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>*)blk;

2041

<a name="l02014"></a>02014 blk2 = (<a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>*)temp_blk;

2042

<a name="l02015"></a>02015

2043

<a name="l02016"></a>02016 }

2044

<a name="l02017"></a>02017 res = <a class="code" href="a00120.html#ga91fe9566575d9d66e1bb9d030b3d29a0" title="Lexicographical comparison of BIT buffers.">bitcmp</a>(blk1, blk2, <a class="code" href="a00115.html#a7049fd70220fc3a3072e9f82abf4ad66">bm::set_block_size_op</a>);

2045

<a name="l02018"></a>02018

2046

<a name="l02019"></a>02019 }

2047

<a name="l02020"></a>02020 else

2048

<a name="l02021"></a>02021 {

2049

<a name="l02022"></a>02022 if (gap)

2050

<a name="l02023"></a>02023 {

2051

<a name="l02024"></a>02024 res = <a class="code" href="a00119.html#ga406952734f1b05962941b32e37b3eb96" title="Lexicographical comparison of GAP buffers.">gapcmp</a>(<a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk), <a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(arg_blk));

2052

<a name="l02025"></a>02025 }

2053

<a name="l02026"></a>02026 else

2054

<a name="l02027"></a>02027 {

2055

<a name="l02028"></a>02028 res = <a class="code" href="a00120.html#ga91fe9566575d9d66e1bb9d030b3d29a0" title="Lexicographical comparison of BIT buffers.">bitcmp</a>((<a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>*)blk,

2056

<a name="l02029"></a>02029 (<a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>*)arg_blk,

2057

<a name="l02030"></a>02030 <a class="code" href="a00115.html#a7049fd70220fc3a3072e9f82abf4ad66">bm::set_block_size_op</a>);

2058

<a name="l02031"></a>02031 }

2059

<a name="l02032"></a>02032 }

2060

<a name="l02033"></a>02033

2061

<a name="l02034"></a>02034 if (res != 0)

2062

<a name="l02035"></a>02035 {

2063

<a name="l02036"></a>02036 return res;

2064

<a name="l02037"></a>02037 }

2065

<a name="l02038"></a>02038

2066

<a name="l02039"></a>02039

2067

<a name="l02040"></a>02040 } // for j

2068

<a name="l02041"></a>02041

2069

<a name="l02042"></a>02042 } // for i

2070

<a name="l02043"></a>02043

2071

<a name="l02044"></a>02044 return 0;

2072

<a name="l02045"></a>02045 }

2073

<a name="l02046"></a>02046

2074

<a name="l02047"></a>02047

2075

<a name="l02048"></a>02048 // -----------------------------------------------------------------------

2076

<a name="l02049"></a>02049

2077

<a name="l02050"></a>02050 template<typename Alloc, typename MS>

2078

<a name="l02051"></a><a class="code" href="a00044.html#a1eaaac76a97b9eb1d3c11f21cf9385ac">02051</a> void <a class="code" href="a00044.html#a1eaaac76a97b9eb1d3c11f21cf9385ac" title="Calculates bitvector statistics.">bvector<Alloc, MS>::calc_stat</a>(struct <a class="code" href="a00085.html" title="Statistical information about bitset&#39;s memory allocation details.">bvector<Alloc, MS>::statistics</a>* st) const

2079

<a name="l02052"></a>02052 {

2080

<a name="l02053"></a>02053 st-><a class="code" href="a00043.html#a4ec8ba190b4ba31c431c008402881c62" title="Number of bit blocks.">bit_blocks</a> = st-><a class="code" href="a00043.html#a4dcfd64e9ab0be5472e3c2b04e551f81" title="Number of GAP blocks.">gap_blocks</a>

2081

<a name="l02054"></a>02054 = st-><a class="code" href="a00043.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a>

2082

<a name="l02055"></a>02055 = st-><a class="code" href="a00043.html#ad3b2190eb4afe24ecd56323cbc0a7666" title="Memory used by bitvector including temp and service blocks.">memory_used</a> = 0;

2083

<a name="l02056"></a>02056

2084

<a name="l02057"></a>02057 ::memcpy(st-><a class="code" href="a00043.html#acc08d9637cc25d02d3a50c061ba221e1" title="GAP lengths used by bvector.">gap_levels</a>,

2085

<a name="l02058"></a>02058 blockman_.glen(), sizeof(<a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>) * <a class="code" href="a00115.html#a773e9f5341919d58000bd54d50038733">bm::gap_levels</a>);

2086

<a name="l02059"></a>02059

2087

<a name="l02060"></a>02060 unsigned empty_blocks = 0;

2088

<a name="l02061"></a>02061 unsigned blocks_memory = 0;

2089

<a name="l02062"></a>02062 <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* gapl_ptr = st-><a class="code" href="a00043.html#a824dd18d515305d159c48a697696cbb6" title="Array of all GAP block lengths in the bvector.">gap_length</a>;

2090

<a name="l02063"></a>02063

2091

<a name="l02064"></a>02064 st-><a class="code" href="a00043.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> = sizeof(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">id_t</a>) * 4;

2092

<a name="l02065"></a>02065

2093

<a name="l02066"></a>02066 unsigned block_idx = 0;

2094

<a name="l02067"></a>02067

2095

<a name="l02068"></a>02068 unsigned top_size = blockman_.effective_top_block_size();

2096

<a name="l02069"></a>02069 // Walk the blocks, calculate statistics.

2097

<a name="l02070"></a>02070 for (unsigned i = 0; i < top_size; ++i)

2098

<a name="l02071"></a>02071 {

2099

<a name="l02072"></a>02072 const <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* const* blk_blk = blockman_.get_topblock(i);

2100

<a name="l02073"></a>02073

2101

<a name="l02074"></a>02074 if (!blk_blk)

2102

<a name="l02075"></a>02075 {

2103

<a name="l02076"></a>02076 block_idx += <a class="code" href="a00115.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>;

2104

<a name="l02077"></a>02077 st-><a class="code" href="a00043.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> += sizeof(unsigned) + 1;

2105

<a name="l02078"></a>02078 continue;

2106

<a name="l02079"></a>02079 }

2107

<a name="l02080"></a>02080

2108

<a name="l02081"></a>02081 for (unsigned j = 0;j < <a class="code" href="a00115.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>; ++j, ++block_idx)

2109

<a name="l02082"></a>02082 {

2110

<a name="l02083"></a>02083 const <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk = blk_blk[j];

2111

<a name="l02084"></a>02084 if (<a class="code" href="a00092.html#a13ba598909515339ceede09e3b9b0198">IS_VALID_ADDR</a>(blk))

2112

<a name="l02085"></a>02085 {

2113

<a name="l02086"></a>02086 st-><a class="code" href="a00043.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> += empty_blocks << 2;

2114

<a name="l02087"></a>02087 empty_blocks = 0;

2115

<a name="l02088"></a>02088

2116

<a name="l02089"></a>02089 if (<a class="code" href="a00092.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, blk, block_idx)) // gap block

2117

<a name="l02090"></a>02090 {

2118

<a name="l02091"></a>02091 ++(st-><a class="code" href="a00043.html#a4dcfd64e9ab0be5472e3c2b04e551f81" title="Number of GAP blocks.">gap_blocks</a>);

2119

<a name="l02092"></a>02092

2120

<a name="l02093"></a>02093 <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">bm::gap_word_t</a>* gap_blk = <a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk);

2121

<a name="l02094"></a>02094

2122

<a name="l02095"></a>02095 unsigned mem_used =

2123

<a name="l02096"></a>02096 <a class="code" href="a00119.html#ga0419ed06e2f0b7891e7d721546f5fb45" title="Returs GAP block capacity.">bm::gap_capacity</a>(gap_blk, blockman_.glen())

2124

<a name="l02097"></a>02097 * sizeof(<a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>);

2125

<a name="l02098"></a>02098

2126

<a name="l02099"></a>02099 *gapl_ptr = <a class="code" href="a00119.html#gad6bfb9da9950b0df8983a9faf9db5042" title="Returs GAP block length.">gap_length</a>(gap_blk);

2127

<a name="l02100"></a>02100

2128

<a name="l02101"></a>02101 st-><a class="code" href="a00043.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> += *gapl_ptr * sizeof(<a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>);

2129

<a name="l02102"></a>02102 blocks_memory += mem_used;

2130

<a name="l02103"></a>02103

2131

<a name="l02104"></a>02104 ++gapl_ptr;

2132

<a name="l02105"></a>02105 }

2133

<a name="l02106"></a>02106 else // bit block

2134

<a name="l02107"></a>02107 {

2135

<a name="l02108"></a>02108 ++(st-><a class="code" href="a00043.html#a4ec8ba190b4ba31c431c008402881c62" title="Number of bit blocks.">bit_blocks</a>);

2136

<a name="l02109"></a>02109 unsigned mem_used = sizeof(<a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>) * bm::set_block_size;

2137

<a name="l02110"></a>02110 st-><a class="code" href="a00043.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> += mem_used;

2138

<a name="l02111"></a>02111 blocks_memory += mem_used;

2139

<a name="l02112"></a>02112 }

2140

<a name="l02113"></a>02113 }

2141

<a name="l02114"></a>02114 else

2142

<a name="l02115"></a>02115 {

2143

<a name="l02116"></a>02116 ++empty_blocks;

2144

<a name="l02117"></a>02117 }

2145

<a name="l02118"></a>02118 }

2146

<a name="l02119"></a>02119 }

2147

<a name="l02120"></a>02120

2148

<a name="l02121"></a>02121 unsigned safe_inc = st-><a class="code" href="a00043.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> / 10; // 10% increment

2149

<a name="l02122"></a>02122 if (!safe_inc) safe_inc = 256;

2150

<a name="l02123"></a>02123 st-><a class="code" href="a00043.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> += safe_inc;

2151

<a name="l02124"></a>02124

2152

<a name="l02125"></a>02125 // Calc size of different odd and temporary things.

2153

<a name="l02126"></a>02126

2154

<a name="l02127"></a>02127 st-><a class="code" href="a00043.html#ad3b2190eb4afe24ecd56323cbc0a7666" title="Memory used by bitvector including temp and service blocks.">memory_used</a> += sizeof(*this) - sizeof(blockman_);

2155

<a name="l02128"></a>02128 st-><a class="code" href="a00043.html#ad3b2190eb4afe24ecd56323cbc0a7666" title="Memory used by bitvector including temp and service blocks.">memory_used</a> += blockman_.mem_used();

2156

<a name="l02129"></a>02129 st-><a class="code" href="a00043.html#ad3b2190eb4afe24ecd56323cbc0a7666" title="Memory used by bitvector including temp and service blocks.">memory_used</a> += blocks_memory;

2157

<a name="l02130"></a>02130 }

2158

<a name="l02131"></a>02131

2159

<a name="l02132"></a>02132

2160

<a name="l02133"></a>02133 // -----------------------------------------------------------------------

2161

<a name="l02134"></a>02134

2162

<a name="l02135"></a>02135

2163

<a name="l02136"></a>02136 template<class Alloc, class MS>

2164

<a name="l02137"></a>02137 bool <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS>::set_bit_no_check</a>(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val)

2165

<a name="l02138"></a>02138 {

2166

<a name="l02139"></a>02139 // calculate logical block number

2167

<a name="l02140"></a>02140 unsigned nblock = unsigned(n >> <a class="code" href="a00115.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

2168

<a name="l02141"></a>02141

2169

<a name="l02142"></a>02142 int block_type;

2170

<a name="l02143"></a>02143

2171

<a name="l02144"></a>02144 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk =

2172

<a name="l02145"></a>02145 blockman_.check_allocate_block(nblock,

2173

<a name="l02146"></a>02146 val,

2174

<a name="l02147"></a>02147 <a class="code" href="a00044.html#ad971c541fa259278e9dcf541b2d128c9" title="Returns blocks allocation strategy.">get_new_blocks_strat</a>(),

2175

<a name="l02148"></a>02148 &block_type);

2176

<a name="l02149"></a>02149

2177

<a name="l02150"></a>02150 if (!blk) return false;

2178

<a name="l02151"></a>02151

2179

<a name="l02152"></a>02152 // calculate word number in block and bit

2180

<a name="l02153"></a>02153 unsigned nbit = unsigned(n & <a class="code" href="a00115.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2181

<a name="l02154"></a>02154

2182

<a name="l02155"></a>02155 if (block_type == 1) // gap

2183

<a name="l02156"></a>02156 {

2184

<a name="l02157"></a>02157 unsigned is_set;

2185

<a name="l02158"></a>02158 unsigned new_block_len;

2186

<a name="l02159"></a>02159

2187

<a name="l02160"></a>02160 new_block_len =

2188

<a name="l02161"></a>02161 <a class="code" href="a00119.html#ga69186bd13bda27e04b3e33683ff884c2" title="Abstract distance(similarity) operation for GAP buffers. Receives functor F as a...">gap_set_value</a>(val, <a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk), nbit, &is_set);

2189

<a name="l02162"></a>02162 if (is_set)

2190

<a name="l02163"></a>02163 {

2191

<a name="l02164"></a>02164 <a class="code" href="a00087.html#aef4146eb86de042a6c34717f87b16c10">BMCOUNT_ADJ</a>(val)

2192

<a name="l02165"></a>02165

2193

<a name="l02166"></a>02166 unsigned threshold =

2194

<a name="l02167"></a>02167 bm::<a class="code" href="a00119.html#ga94a5371b5dc6a1560d95d7c2dde88815" title="Returs GAP block capacity limit.">gap_limit</a>(<a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk), blockman_.glen());

2195

<a name="l02168"></a>02168

2196

<a name="l02169"></a>02169 if (new_block_len > threshold)

2197

<a name="l02170"></a>02170 {

2198

<a name="l02171"></a>02171 extend_gap_block(nblock, <a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk));

2199

<a name="l02172"></a>02172 }

2200

<a name="l02173"></a>02173 return true;

2201

<a name="l02174"></a>02174 }

2202

<a name="l02175"></a>02175 }

2203

<a name="l02176"></a>02176 else // bit block

2204

<a name="l02177"></a>02177 {

2205

<a name="l02178"></a>02178 unsigned nword = unsigned(nbit >> <a class="code" href="a00115.html#a83d76bccf6fe3770f32d5ba11d2a37ad">bm::set_word_shift</a>);

2206

<a name="l02179"></a>02179 nbit &= <a class="code" href="a00115.html#addbf345be3733d5e4575d71733ed1da8">bm::set_word_mask</a>;

2207

<a name="l02180"></a>02180

2208

<a name="l02181"></a>02181 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* word = blk + nword;

2209

<a name="l02182"></a>02182 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a> mask = (((<a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>)1) << nbit);

2210

<a name="l02183"></a>02183

2211

<a name="l02184"></a>02184 if (val)

2212

<a name="l02185"></a>02185 {

2213

<a name="l02186"></a>02186 if ( ((*word) & mask) == 0 )

2214

<a name="l02187"></a>02187 {

2215

<a name="l02188"></a>02188 *word |= mask; // set bit

2216

<a name="l02189"></a>02189 <a class="code" href="a00087.html#a911e3d9e9a293cafab1396a8700288e9">BMCOUNT_INC</a>;

2217

<a name="l02190"></a>02190 return true;

2218

<a name="l02191"></a>02191 }

2219

<a name="l02192"></a>02192 }

2220

<a name="l02193"></a>02193 else

2221

<a name="l02194"></a>02194 {

2222

<a name="l02195"></a>02195 if ((*word) & mask)

2223

<a name="l02196"></a>02196 {

2224

<a name="l02197"></a>02197 *word &= ~mask; // clear bit

2225

<a name="l02198"></a>02198 <a class="code" href="a00087.html#a809c66152f5967c1a1eb51e006206630">BMCOUNT_DEC</a>;

2226

<a name="l02199"></a>02199 return true;

2227

<a name="l02200"></a>02200 }

2228

<a name="l02201"></a>02201 }

2229

<a name="l02202"></a>02202 }

2230

<a name="l02203"></a>02203 return false;

2231

<a name="l02204"></a>02204 }

2232

<a name="l02205"></a>02205

2233

<a name="l02206"></a>02206 // -----------------------------------------------------------------------

2234

<a name="l02207"></a>02207

2235

<a name="l02208"></a>02208 template<class Alloc, class MS>

2236

<a name="l02209"></a>02209 bool bvector<Alloc, MS>::set_bit_conditional_impl(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n,

2237

<a name="l02210"></a>02210 bool val,

2238

<a name="l02211"></a>02211 bool condition)

2239

<a name="l02212"></a>02212 {

2240

<a name="l02213"></a>02213 // calculate logical block number

2241

<a name="l02214"></a>02214 unsigned nblock = unsigned(n >> <a class="code" href="a00115.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

2242

<a name="l02215"></a>02215

2243

<a name="l02216"></a>02216 int block_type;

2244

<a name="l02217"></a>02217 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk =

2245

<a name="l02218"></a>02218 blockman_.check_allocate_block(nblock,

2246

<a name="l02219"></a>02219 val,

2247

<a name="l02220"></a>02220 <a class="code" href="a00044.html#ad971c541fa259278e9dcf541b2d128c9" title="Returns blocks allocation strategy.">get_new_blocks_strat</a>(),

2248

<a name="l02221"></a>02221 &block_type);

2249

<a name="l02222"></a>02222 if (!blk)

2250

<a name="l02223"></a>02223 return false;

2251

<a name="l02224"></a>02224

2252

<a name="l02225"></a>02225 // calculate word number in block and bit

2253

<a name="l02226"></a>02226 unsigned nbit = unsigned(n & <a class="code" href="a00115.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2254

<a name="l02227"></a>02227

2255

<a name="l02228"></a>02228 if (block_type == 1) // gap

2256

<a name="l02229"></a>02229 {

2257

<a name="l02230"></a>02230 <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">bm::gap_word_t</a>* gap_blk = <a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk);

2258

<a name="l02231"></a>02231 bool old_val = (<a class="code" href="a00119.html#ga866352ef5986a7d2b709795d127b666b" title="Tests if bit = pos is true.">gap_test</a>(gap_blk, nbit) != 0);

2259

<a name="l02232"></a>02232

2260

<a name="l02233"></a>02233 if (old_val != condition)

2261

<a name="l02234"></a>02234 {

2262

<a name="l02235"></a>02235 return false;

2263

<a name="l02236"></a>02236 }

2264

<a name="l02237"></a>02237

2265

<a name="l02238"></a>02238 if (val != old_val)

2266

<a name="l02239"></a>02239 {

2267

<a name="l02240"></a>02240 unsigned is_set;

2268

<a name="l02241"></a>02241 unsigned new_block_len =

2269

<a name="l02242"></a>02242 <a class="code" href="a00119.html#ga69186bd13bda27e04b3e33683ff884c2" title="Abstract distance(similarity) operation for GAP buffers. Receives functor F as a...">gap_set_value</a>(val, gap_blk, nbit, &is_set);

2270

<a name="l02243"></a>02243 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(is_set);

2271

<a name="l02244"></a>02244 <a class="code" href="a00087.html#aef4146eb86de042a6c34717f87b16c10">BMCOUNT_ADJ</a>(val)

2272

<a name="l02245"></a>02245

2273

<a name="l02246"></a>02246 unsigned threshold =

2274

<a name="l02247"></a>02247 bm::<a class="code" href="a00119.html#ga94a5371b5dc6a1560d95d7c2dde88815" title="Returs GAP block capacity limit.">gap_limit</a>(gap_blk, blockman_.glen());

2275

<a name="l02248"></a>02248 if (new_block_len > threshold)

2276

<a name="l02249"></a>02249 {

2277

<a name="l02250"></a>02250 extend_gap_block(nblock, gap_blk);

2278

<a name="l02251"></a>02251 }

2279

<a name="l02252"></a>02252 return true;

2280

<a name="l02253"></a>02253 }

2281

<a name="l02254"></a>02254 }

2282

<a name="l02255"></a>02255 else // bit block

2283

<a name="l02256"></a>02256 {

2284

<a name="l02257"></a>02257 unsigned nword = unsigned(nbit >> <a class="code" href="a00115.html#a83d76bccf6fe3770f32d5ba11d2a37ad">bm::set_word_shift</a>);

2285

<a name="l02258"></a>02258 nbit &= <a class="code" href="a00115.html#addbf345be3733d5e4575d71733ed1da8">bm::set_word_mask</a>;

2286

<a name="l02259"></a>02259

2287

<a name="l02260"></a>02260 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* word = blk + nword;

2288

<a name="l02261"></a>02261 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a> mask = (((<a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>)1) << nbit);

2289

<a name="l02262"></a>02262 bool is_set = ((*word) & mask) != 0;

2290

<a name="l02263"></a>02263

2291

<a name="l02264"></a>02264 if (is_set != condition)

2292

<a name="l02265"></a>02265 {

2293

<a name="l02266"></a>02266 return false;

2294

<a name="l02267"></a>02267 }

2295

<a name="l02268"></a>02268 if (is_set != val) // need to change bit

2296

<a name="l02269"></a>02269 {

2297

<a name="l02270"></a>02270 if (val) // set bit

2298

<a name="l02271"></a>02271 {

2299

<a name="l02272"></a>02272 *word |= mask;

2300

<a name="l02273"></a>02273 <a class="code" href="a00087.html#a911e3d9e9a293cafab1396a8700288e9">BMCOUNT_INC</a>;

2301

<a name="l02274"></a>02274 }

2302

<a name="l02275"></a>02275 else // clear bit

2303

<a name="l02276"></a>02276 {

2304

<a name="l02277"></a>02277 *word &= ~mask;

2305

<a name="l02278"></a>02278 <a class="code" href="a00087.html#a809c66152f5967c1a1eb51e006206630">BMCOUNT_DEC</a>;

2306

<a name="l02279"></a>02279 }

2307

<a name="l02280"></a>02280 return true;

2308

<a name="l02281"></a>02281 }

2309

<a name="l02282"></a>02282 }

2310

<a name="l02283"></a>02283 return false;

2311

<a name="l02284"></a>02284

2312

<a name="l02285"></a>02285 }

2313

<a name="l02286"></a>02286

2314

<a name="l02287"></a>02287 // -----------------------------------------------------------------------

2315

<a name="l02288"></a>02288

2316

<a name="l02289"></a>02289

2317

<a name="l02290"></a>02290 template<class Alloc, class MS>

2318

<a name="l02291"></a>02291 bool bvector<Alloc, MS>::and_bit_no_check(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val)

2319

<a name="l02292"></a>02292 {

2320

<a name="l02293"></a>02293 // calculate logical block number

2321

<a name="l02294"></a>02294 unsigned nblock = unsigned(n >> <a class="code" href="a00115.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

2322

<a name="l02295"></a>02295

2323

<a name="l02296"></a>02296 int block_type;

2324

<a name="l02297"></a>02297 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk =

2325

<a name="l02298"></a>02298 blockman_.check_allocate_block(nblock,

2326

<a name="l02299"></a>02299 val,

2327

<a name="l02300"></a>02300 <a class="code" href="a00044.html#ad971c541fa259278e9dcf541b2d128c9" title="Returns blocks allocation strategy.">get_new_blocks_strat</a>(),

2328

<a name="l02301"></a>02301 &block_type);

2329

<a name="l02302"></a>02302 if (!blk) return false;

2330

<a name="l02303"></a>02303

2331

<a name="l02304"></a>02304 // calculate word number in block and bit

2332

<a name="l02305"></a>02305 unsigned nbit = unsigned(n & <a class="code" href="a00115.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2333

<a name="l02306"></a>02306

2334

<a name="l02307"></a>02307 if (block_type == 1) // gap

2335

<a name="l02308"></a>02308 {

2336

<a name="l02309"></a>02309 <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">bm::gap_word_t</a>* gap_blk = <a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk);

2337

<a name="l02310"></a>02310 bool old_val = (<a class="code" href="a00119.html#ga866352ef5986a7d2b709795d127b666b" title="Tests if bit = pos is true.">gap_test</a>(gap_blk, nbit) != 0);

2338

<a name="l02311"></a>02311

2339

<a name="l02312"></a>02312 bool new_val = val & old_val;

2340

<a name="l02313"></a>02313 if (new_val != old_val)

2341

<a name="l02314"></a>02314 {

2342

<a name="l02315"></a>02315 unsigned is_set;

2343

<a name="l02316"></a>02316 unsigned new_block_len =

2344

<a name="l02317"></a>02317 <a class="code" href="a00119.html#ga69186bd13bda27e04b3e33683ff884c2" title="Abstract distance(similarity) operation for GAP buffers. Receives functor F as a...">gap_set_value</a>(new_val, gap_blk, nbit, &is_set);

2345

<a name="l02318"></a>02318 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(is_set);

2346

<a name="l02319"></a>02319 <a class="code" href="a00087.html#aef4146eb86de042a6c34717f87b16c10">BMCOUNT_ADJ</a>(val)

2347

<a name="l02320"></a>02320

2348

<a name="l02321"></a>02321 unsigned threshold =

2349

<a name="l02322"></a>02322 bm::<a class="code" href="a00119.html#ga94a5371b5dc6a1560d95d7c2dde88815" title="Returs GAP block capacity limit.">gap_limit</a>(gap_blk, blockman_.glen());

2350

<a name="l02323"></a>02323 if (new_block_len > threshold)

2351

<a name="l02324"></a>02324 {

2352

<a name="l02325"></a>02325 extend_gap_block(nblock, gap_blk);

2353

<a name="l02326"></a>02326 }

2354

<a name="l02327"></a>02327 return true;

2355

<a name="l02328"></a>02328 }

2356

<a name="l02329"></a>02329 }

2357

<a name="l02330"></a>02330 else // bit block

2358

<a name="l02331"></a>02331 {

2359

<a name="l02332"></a>02332 unsigned nword = unsigned(nbit >> <a class="code" href="a00115.html#a83d76bccf6fe3770f32d5ba11d2a37ad">bm::set_word_shift</a>);

2360

<a name="l02333"></a>02333 nbit &= <a class="code" href="a00115.html#addbf345be3733d5e4575d71733ed1da8">bm::set_word_mask</a>;

2361

<a name="l02334"></a>02334

2362

<a name="l02335"></a>02335 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* word = blk + nword;

2363

<a name="l02336"></a>02336 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a> mask = (((<a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>)1) << nbit);

2364

<a name="l02337"></a>02337 bool is_set = ((*word) & mask) != 0;

2365

<a name="l02338"></a>02338

2366

<a name="l02339"></a>02339 bool new_val = is_set & val;

2367

<a name="l02340"></a>02340 if (new_val != val) // need to change bit

2368

<a name="l02341"></a>02341 {

2369

<a name="l02342"></a>02342 if (new_val) // set bit

2370

<a name="l02343"></a>02343 {

2371

<a name="l02344"></a>02344 *word |= mask;

2372

<a name="l02345"></a>02345 <a class="code" href="a00087.html#a911e3d9e9a293cafab1396a8700288e9">BMCOUNT_INC</a>;

2373

<a name="l02346"></a>02346 }

2374

<a name="l02347"></a>02347 else // clear bit

2375

<a name="l02348"></a>02348 {

2376

<a name="l02349"></a>02349 *word &= ~mask;

2377

<a name="l02350"></a>02350 <a class="code" href="a00087.html#a809c66152f5967c1a1eb51e006206630">BMCOUNT_DEC</a>;

2378

<a name="l02351"></a>02351 }

2379

<a name="l02352"></a>02352 return true;

2380

<a name="l02353"></a>02353 }

2381

<a name="l02354"></a>02354 }

2382

<a name="l02355"></a>02355 return false;

2383

<a name="l02356"></a>02356 }

2384

<a name="l02357"></a>02357

2385

<a name="l02358"></a>02358

2386

<a name="l02359"></a>02359 //---------------------------------------------------------------------

2387

<a name="l02360"></a>02360

2388

<a name="l02361"></a>02361 template<class Alloc, class MS>

2389

<a name="l02362"></a>02362 <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> bvector<Alloc, MS>::check_or_next(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> prev) const

2390

<a name="l02363"></a>02363 {

2391

<a name="l02364"></a>02364 for (;;)

2392

<a name="l02365"></a>02365 {

2393

<a name="l02366"></a>02366 unsigned nblock = unsigned(prev >> <a class="code" href="a00115.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

2394

<a name="l02367"></a>02367 if (nblock >= <a class="code" href="a00115.html#a505011007f54598794e0b9477c0b0b11">bm::set_total_blocks</a>)

2395

<a name="l02368"></a>02368 break;

2396

<a name="l02369"></a>02369

2397

<a name="l02370"></a>02370 if (blockman_.is_subblock_null(nblock >> <a class="code" href="a00115.html#ac1ff8647a089c751ec330cecee01907e">bm::set_array_shift</a>))

2398

<a name="l02371"></a>02371 {

2399

<a name="l02372"></a>02372 prev += (<a class="code" href="a00115.html#a2d1bf97ae342a7759943e62090fcf5d3">bm::set_blkblk_mask</a> + 1) -

2400

<a name="l02373"></a>02373 (prev & <a class="code" href="a00115.html#a2d1bf97ae342a7759943e62090fcf5d3">bm::set_blkblk_mask</a>);

2401

<a name="l02374"></a>02374 }

2402

<a name="l02375"></a>02375 else

2403

<a name="l02376"></a>02376 {

2404

<a name="l02377"></a>02377 unsigned nbit = unsigned(prev & <a class="code" href="a00115.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2405

<a name="l02378"></a>02378 int no_more_blocks;

2406

<a name="l02379"></a>02379 const <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* block =

2407

<a name="l02380"></a>02380 blockman_.get_block(nblock, &no_more_blocks);

2408

<a name="l02381"></a>02381

2409

<a name="l02382"></a>02382 if (no_more_blocks)

2410

<a name="l02383"></a>02383 {

2411

<a name="l02384"></a>02384 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(block == 0);

2412

<a name="l02385"></a>02385 break;

2413

<a name="l02386"></a>02386 }

2414

<a name="l02387"></a>02387

2415

<a name="l02388"></a>02388 if (block)

2416

<a name="l02389"></a>02389 {

2417

<a name="l02390"></a>02390 if (<a class="code" href="a00092.html#a074acb37afea68caaffe3832d326eb44">IS_FULL_BLOCK</a>(block)) return prev;

2418

<a name="l02391"></a>02391 if (<a class="code" href="a00092.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nblock))

2419

<a name="l02392"></a>02392 {

2420

<a name="l02393"></a>02393 if (<a class="code" href="a00119.html#gaa7df7193094353ea24b8519debf745be" title="Searches for the next 1 bit in the GAP block.">bm::gap_find_in_block</a>(<a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block),

2421

<a name="l02394"></a>02394 nbit,

2422

<a name="l02395"></a>02395 &prev))

2423

<a name="l02396"></a>02396 {

2424

<a name="l02397"></a>02397 return prev;

2425

<a name="l02398"></a>02398 }

2426

<a name="l02399"></a>02399 }

2427

<a name="l02400"></a>02400 else

2428

<a name="l02401"></a>02401 {

2429

<a name="l02402"></a>02402 if (<a class="code" href="a00120.html#gad6a7c549a625df7aa7d68d43a57238c7" title="Searches for the next 1 bit in the BIT block.">bm::bit_find_in_block</a>(block, nbit, &prev))

2430

<a name="l02403"></a>02403 {

2431

<a name="l02404"></a>02404 return prev;

2432

<a name="l02405"></a>02405 }

2433

<a name="l02406"></a>02406 }

2434

<a name="l02407"></a>02407 }

2435

<a name="l02408"></a>02408 else

2436

<a name="l02409"></a>02409 {

2437

<a name="l02410"></a>02410 prev += (<a class="code" href="a00115.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a> + 1) -

2438

<a name="l02411"></a>02411 (prev & <a class="code" href="a00115.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2439

<a name="l02412"></a>02412 }

2440

<a name="l02413"></a>02413

2441

<a name="l02414"></a>02414 }

2442

<a name="l02415"></a>02415 if (!prev) break;

2443

<a name="l02416"></a>02416 }

2444

<a name="l02417"></a>02417

2445

<a name="l02418"></a>02418 return 0;

2446

<a name="l02419"></a>02419 }

2447

<a name="l02420"></a>02420

2448

<a name="l02421"></a>02421

2449

<a name="l02422"></a>02422 //---------------------------------------------------------------------

2450

<a name="l02423"></a>02423

2451

<a name="l02424"></a>02424 template<class Alloc, class MS>

2452

<a name="l02425"></a>02425 <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> bvector<Alloc, MS>::check_or_next_extract(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> prev)

2453

<a name="l02426"></a>02426 {

2454

<a name="l02427"></a>02427 for (;;)

2455

<a name="l02428"></a>02428 {

2456

<a name="l02429"></a>02429 unsigned nblock = unsigned(prev >> <a class="code" href="a00115.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

2457

<a name="l02430"></a>02430 if (nblock >= <a class="code" href="a00115.html#a505011007f54598794e0b9477c0b0b11">bm::set_total_blocks</a>) break;

2458

<a name="l02431"></a>02431

2459

<a name="l02432"></a>02432 if (blockman_.is_subblock_null(nblock >> <a class="code" href="a00115.html#ac1ff8647a089c751ec330cecee01907e">bm::set_array_shift</a>))

2460

<a name="l02433"></a>02433 {

2461

<a name="l02434"></a>02434 prev += (<a class="code" href="a00115.html#a2d1bf97ae342a7759943e62090fcf5d3">bm::set_blkblk_mask</a> + 1) -

2462

<a name="l02435"></a>02435 (prev & <a class="code" href="a00115.html#a2d1bf97ae342a7759943e62090fcf5d3">bm::set_blkblk_mask</a>);

2463

<a name="l02436"></a>02436 }

2464

<a name="l02437"></a>02437 else

2465

<a name="l02438"></a>02438 {

2466

<a name="l02439"></a>02439 unsigned nbit = unsigned(prev & <a class="code" href="a00115.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2467

<a name="l02440"></a>02440

2468

<a name="l02441"></a>02441 int no_more_blocks;

2469

<a name="l02442"></a>02442 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* block =

2470

<a name="l02443"></a>02443 blockman_.get_block(nblock, &no_more_blocks);

2471

<a name="l02444"></a>02444

2472

<a name="l02445"></a>02445 if (no_more_blocks)

2473

<a name="l02446"></a>02446 {

2474

<a name="l02447"></a>02447 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(block == 0);

2475

<a name="l02448"></a>02448 break;

2476

<a name="l02449"></a>02449 }

2477

<a name="l02450"></a>02450

2478

<a name="l02451"></a>02451

2479

<a name="l02452"></a>02452 if (block)

2480

<a name="l02453"></a>02453 {

2481

<a name="l02454"></a>02454 if (<a class="code" href="a00092.html#a074acb37afea68caaffe3832d326eb44">IS_FULL_BLOCK</a>(block))

2482

<a name="l02455"></a>02455 {

2483

<a name="l02456"></a>02456 set(prev, false);

2484

<a name="l02457"></a>02457 return prev;

2485

<a name="l02458"></a>02458 }

2486

<a name="l02459"></a>02459 if (<a class="code" href="a00092.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nblock))

2487

<a name="l02460"></a>02460 {

2488

<a name="l02461"></a>02461 unsigned is_set;

2489

<a name="l02462"></a>02462 unsigned new_block_len =

2490

<a name="l02463"></a>02463 <a class="code" href="a00119.html#ga69186bd13bda27e04b3e33683ff884c2" title="Abstract distance(similarity) operation for GAP buffers. Receives functor F as a...">gap_set_value</a>(0, <a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block), nbit, &is_set);

2491

<a name="l02464"></a>02464 if (is_set) {

2492

<a name="l02465"></a>02465 <a class="code" href="a00087.html#a809c66152f5967c1a1eb51e006206630">BMCOUNT_DEC</a>

2493

<a name="l02466"></a>02466 unsigned threshold =

2494

<a name="l02467"></a>02467 <a class="code" href="a00119.html#ga94a5371b5dc6a1560d95d7c2dde88815" title="Returs GAP block capacity limit.">bm::gap_limit</a>(<a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block), blockman_.glen());

2495

<a name="l02468"></a>02468 if (new_block_len > threshold)

2496

<a name="l02469"></a>02469 {

2497

<a name="l02470"></a>02470 extend_gap_block(nblock, <a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block));

2498

<a name="l02471"></a>02471 }

2499

<a name="l02472"></a>02472 return prev;

2500

<a name="l02473"></a>02473 } else {

2501

<a name="l02474"></a>02474 if (<a class="code" href="a00119.html#gaa7df7193094353ea24b8519debf745be" title="Searches for the next 1 bit in the GAP block.">bm::gap_find_in_block</a>(<a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block),

2502

<a name="l02475"></a>02475 nbit,

2503

<a name="l02476"></a>02476 &prev))

2504

<a name="l02477"></a>02477 {

2505

<a name="l02478"></a>02478 set(prev, false);

2506

<a name="l02479"></a>02479 return prev;

2507

<a name="l02480"></a>02480 }

2508

<a name="l02481"></a>02481 }

2509

<a name="l02482"></a>02482 }

2510

<a name="l02483"></a>02483 else // bit block

2511

<a name="l02484"></a>02484 {

2512

<a name="l02485"></a>02485 if (<a class="code" href="a00120.html#gad6a7c549a625df7aa7d68d43a57238c7" title="Searches for the next 1 bit in the BIT block.">bm::bit_find_in_block</a>(block, nbit, &prev))

2513

<a name="l02486"></a>02486 {

2514

<a name="l02487"></a>02487 <a class="code" href="a00087.html#a809c66152f5967c1a1eb51e006206630">BMCOUNT_DEC</a>

2515

<a name="l02488"></a>02488

2516

<a name="l02489"></a>02489 unsigned nbit =

2517

<a name="l02490"></a>02490 unsigned(prev & <a class="code" href="a00115.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2518

<a name="l02491"></a>02491 unsigned nword =

2519

<a name="l02492"></a>02492 unsigned(nbit >> <a class="code" href="a00115.html#a83d76bccf6fe3770f32d5ba11d2a37ad">bm::set_word_shift</a>);

2520

<a name="l02493"></a>02493 nbit &= <a class="code" href="a00115.html#addbf345be3733d5e4575d71733ed1da8">bm::set_word_mask</a>;

2521

<a name="l02494"></a>02494 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* word = block + nword;

2522

<a name="l02495"></a>02495 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a> mask = ((<a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>)1) << nbit;

2523

<a name="l02496"></a>02496 *word &= ~mask;

2524

<a name="l02497"></a>02497

2525

<a name="l02498"></a>02498 return prev;

2526

<a name="l02499"></a>02499 }

2527

<a name="l02500"></a>02500 }

2528

<a name="l02501"></a>02501 }

2529

<a name="l02502"></a>02502 else

2530

<a name="l02503"></a>02503 {

2531

<a name="l02504"></a>02504 prev += (<a class="code" href="a00115.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a> + 1) -

2532

<a name="l02505"></a>02505 (prev & <a class="code" href="a00115.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2533

<a name="l02506"></a>02506 }

2534

<a name="l02507"></a>02507

2535

<a name="l02508"></a>02508 }

2536

<a name="l02509"></a>02509 if (!prev) break;

2537

<a name="l02510"></a>02510 }

2538

<a name="l02511"></a>02511

2539

<a name="l02512"></a>02512 return 0;

2540

<a name="l02513"></a>02513 }

2541

<a name="l02514"></a>02514

2542

<a name="l02515"></a>02515 //---------------------------------------------------------------------

2543

<a name="l02516"></a>02516

2544

<a name="l02517"></a>02517 template<class Alloc, class MS>

2545

<a name="l02518"></a><a class="code" href="a00044.html#af2c137de958a038f96e1149c51ea8a8f">02518</a> void <a class="code" href="a00044.html#af2c137de958a038f96e1149c51ea8a8f">bvector<Alloc, MS>::combine_operation</a>(

2546

<a name="l02519"></a>02519 const <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvect</a>,

2547

<a name="l02520"></a>02520 <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1" title="Bit operations enumeration.">bm::operation</a> opcode)

2548

<a name="l02521"></a>02521 {

2549

<a name="l02522"></a>02522 typedef void (*block_bit_op)(<a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*, const bm::word_t*);

2550

<a name="l02523"></a>02523 typedef void (*block_bit_op_next)(bm::word_t*,

2551

<a name="l02524"></a>02524 const bm::word_t*,

2552

<a name="l02525"></a>02525 bm::word_t*,

2553

<a name="l02526"></a>02526 const bm::word_t*);

2554

<a name="l02527"></a>02527

2555

<a name="l02528"></a>02528 unsigned top_blocks = blockman_.top_block_size();

2556

<a name="l02529"></a>02529 unsigned bvect_top_blocks = bvect.blockman_.top_block_size();

2557

<a name="l02530"></a>02530

2558

<a name="l02531"></a>02531 if (size_ == bvect.size_)

2559

<a name="l02532"></a>02532 {

2560

<a name="l02533"></a>02533 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(top_blocks >= bvect_top_blocks);

2561

<a name="l02534"></a>02534 }

2562

<a name="l02535"></a>02535 else

2563

<a name="l02536"></a>02536 if (size_ < bvect.size_) // this vect shorter than the arg.

2564

<a name="l02537"></a>02537 {

2565

<a name="l02538"></a>02538 size_ = bvect.size_;

2566

<a name="l02539"></a>02539 // stretch our capacity

2567

<a name="l02540"></a>02540 blockman_.reserve_top_blocks(bvect_top_blocks);

2568

<a name="l02541"></a>02541 top_blocks = blockman_.top_block_size();

2569

<a name="l02542"></a>02542 }

2570

<a name="l02543"></a>02543 else

2571

<a name="l02544"></a>02544 if (size_ > bvect.size_) // this vector larger

2572

<a name="l02545"></a>02545 {

2573

<a name="l02546"></a>02546 if (opcode == <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a546fdf33b301e5b9bee0591522ed9250">BM_AND</a>) // clear the tail with zeros

2574

<a name="l02547"></a>02547 {

2575

<a name="l02548"></a>02548 <a class="code" href="a00044.html#a14bc35b9b022018f10787b07a5b2af04" title="Sets all bits in the specified closed interval [left,right] Interval must be inside...">set_range</a>(bvect.size_, size_ - 1, false);

2576

<a name="l02549"></a>02549 if (bvect_top_blocks < top_blocks)

2577

<a name="l02550"></a>02550 {

2578

<a name="l02551"></a>02551 // not to scan blocks we already swiped

2579

<a name="l02552"></a>02552 top_blocks = bvect_top_blocks;

2580

<a name="l02553"></a>02553 }

2581

<a name="l02554"></a>02554 }

2582

<a name="l02555"></a>02555 }

2583

<a name="l02556"></a>02556

2584

<a name="l02557"></a>02557 bm::word_t*** blk_root = blockman_.blocks_root();

2585

<a name="l02558"></a>02558 unsigned block_idx = 0;

2586

<a name="l02559"></a>02559 unsigned i, j;

2587

<a name="l02560"></a>02560

2588

<a name="l02561"></a>02561 <a class="code" href="a00092.html#a7e6f87ba3230dece2125af5c32e84b05">BM_SET_MMX_GUARD</a>

2589

<a name="l02562"></a>02562

2590

<a name="l02563"></a>02563 // calculate effective top size to avoid overscan

2591

<a name="l02564"></a>02564 top_blocks = blockman_.effective_top_block_size();

2592

<a name="l02565"></a>02565 if (top_blocks < bvect.blockman_.effective_top_block_size())

2593

<a name="l02566"></a>02566 {

2594

<a name="l02567"></a>02567 if (opcode != <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a546fdf33b301e5b9bee0591522ed9250">BM_AND</a>)

2595

<a name="l02568"></a>02568 {

2596

<a name="l02569"></a>02569 top_blocks = bvect.blockman_.effective_top_block_size();

2597

<a name="l02570"></a>02570 }

2598

<a name="l02571"></a>02571 }

2599

<a name="l02572"></a>02572

2600

<a name="l02573"></a>02573 for (i = 0; i < top_blocks; ++i)

2601

<a name="l02574"></a>02574 {

2602

<a name="l02575"></a>02575 bm::word_t** blk_blk = blk_root[i];

2603

<a name="l02576"></a>02576

2604

<a name="l02577"></a>02577 if (blk_blk == 0) // not allocated

2605

<a name="l02578"></a>02578 {

2606

<a name="l02579"></a>02579 if (opcode == <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a546fdf33b301e5b9bee0591522ed9250">BM_AND</a>) // 0 AND anything == 0

2607

<a name="l02580"></a>02580 {

2608

<a name="l02581"></a>02581 block_idx += <a class="code" href="a00115.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>;

2609

<a name="l02582"></a>02582 continue;

2610

<a name="l02583"></a>02583 }

2611

<a name="l02584"></a>02584 const bm::word_t* const* bvbb = bvect.blockman_.get_topblock(i);

2612

<a name="l02585"></a>02585 if (bvbb == 0) // skip it because 0 OP 0 == 0

2613

<a name="l02586"></a>02586 {

2614

<a name="l02587"></a>02587 block_idx += <a class="code" href="a00115.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>;

2615

<a name="l02588"></a>02588 continue;

2616

<a name="l02589"></a>02589 }

2617

<a name="l02590"></a>02590 // 0 - self, non-zero argument

2618

<a name="l02591"></a>02591 for (j = 0; j < <a class="code" href="a00115.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>; ++j,++block_idx)

2619

<a name="l02592"></a>02592 {

2620

<a name="l02593"></a>02593 const bm::word_t* arg_blk =

2621

<a name="l02594"></a>02594 bvect.blockman_.get_block(i, j);

2622

<a name="l02595"></a>02595 if (arg_blk != 0)

2623

<a name="l02596"></a>02596 {

2624

<a name="l02597"></a>02597 bool arg_gap =

2625

<a name="l02598"></a>02598 <a class="code" href="a00092.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(bvect.blockman_, arg_blk, block_idx);

2626

<a name="l02599"></a>02599 combine_operation_with_block(block_idx, 0, 0,

2627

<a name="l02600"></a>02600 arg_blk, arg_gap,

2628

<a name="l02601"></a>02601 opcode);

2629

<a name="l02602"></a>02602 }

2630

<a name="l02603"></a>02603

2631

<a name="l02604"></a>02604 } // for j

2632

<a name="l02605"></a>02605 continue;

2633

<a name="l02606"></a>02606 }

2634

<a name="l02607"></a>02607

2635

<a name="l02608"></a>02608 for (j = 0; j < <a class="code" href="a00115.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>; ++j, ++block_idx)

2636

<a name="l02609"></a>02609 {

2637

<a name="l02610"></a>02610 bm::word_t* blk = blk_blk[j];

2638

<a name="l02611"></a>02611 const bm::word_t* arg_blk = bvect.blockman_.get_block(i, j);

2639

<a name="l02612"></a>02612

2640

<a name="l02613"></a>02613 if (arg_blk || blk)

2641

<a name="l02614"></a>02614 {

2642

<a name="l02615"></a>02615 if (opcode == <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a546fdf33b301e5b9bee0591522ed9250">BM_AND</a>)

2643

<a name="l02616"></a>02616 {

2644

<a name="l02617"></a>02617 if (!blk) continue;

2645

<a name="l02618"></a>02618 if (!arg_blk)

2646

<a name="l02619"></a>02619 {

2647

<a name="l02620"></a>02620 if (blk) blockman_.zero_block(block_idx);

2648

<a name="l02621"></a>02621 continue;

2649

<a name="l02622"></a>02622 }

2650

<a name="l02623"></a>02623 }

2651

<a name="l02624"></a>02624

2652

<a name="l02625"></a>02625 bool arg_gap = <a class="code" href="a00092.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(bvect.blockman_, arg_blk, block_idx);

2653

<a name="l02626"></a>02626 bool gap = <a class="code" href="a00092.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>((*this).blockman_, blk, block_idx);

2654

<a name="l02627"></a>02627 combine_operation_with_block(block_idx, gap, blk,

2655

<a name="l02628"></a>02628 arg_blk, arg_gap,

2656

<a name="l02629"></a>02629 opcode);

2657

<a name="l02630"></a>02630 }

2658

<a name="l02631"></a>02631

2659

<a name="l02632"></a>02632 } // for j

2660

<a name="l02633"></a>02633

2661

<a name="l02634"></a>02634 } // for i

2662

<a name="l02635"></a>02635

2663

<a name="l02636"></a>02636 }

2664

<a name="l02637"></a>02637

2665

<a name="l02638"></a>02638

2666

<a name="l02639"></a>02639 //---------------------------------------------------------------------

2667

<a name="l02640"></a>02640

2668

<a name="l02641"></a>02641

2669

<a name="l02642"></a>02642 template<class Alloc, class MS>

2670

<a name="l02643"></a>02643 void

2671

<a name="l02644"></a>02644 <a class="code" href="a00044.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS>::combine_operation_with_block</a>(unsigned nb,

2672

<a name="l02645"></a>02645 unsigned gap,

2673

<a name="l02646"></a>02646 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk,

2674

<a name="l02647"></a>02647 const <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* arg_blk,

2675

<a name="l02648"></a>02648 int arg_gap,

2676

<a name="l02649"></a>02649 <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1" title="Bit operations enumeration.">bm::operation</a> opcode)

2677

<a name="l02650"></a>02650 {

2678

<a name="l02651"></a>02651 if (!blk && arg_gap && (opcode == <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a0c8cf0197857d0bd73a63037e2f2c5c5">BM_OR</a> || opcode == <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a45c2fe36efb72dc03f03a842d253f64c">BM_XOR</a>))

2679

<a name="l02652"></a>02652 {

2680

<a name="l02653"></a>02653 blk =

2681

<a name="l02654"></a>02654 blockman_.check_allocate_block(nb,

2682

<a name="l02655"></a>02655 0,

2683

<a name="l02656"></a>02656 <a class="code" href="a00118.html#ggad0b87b3b7292383a864d27feaf1c9effa7fe09d1d7c62a813db922c396c0cbc9c" title="GAP compression is ON.">BM_GAP</a>,

2684

<a name="l02657"></a>02657 (int*)&gap,

2685

<a name="l02658"></a>02658 false /*no null return*/);

2686

<a name="l02659"></a>02659 }

2687

<a name="l02660"></a>02660

2688

<a name="l02661"></a>02661 if (gap) // our block GAP-type

2689

<a name="l02662"></a>02662 {

2690

<a name="l02663"></a>02663 if (arg_gap) // both blocks GAP-type

2691

<a name="l02664"></a>02664 {

2692

<a name="l02665"></a>02665 <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a> tmp_buf[<a class="code" href="a00115.html#a9b1715d6d9164d56172e75bbbd0e3000">bm::gap_equiv_len</a> * 3]; // temporary result

2693

<a name="l02666"></a>02666 <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* res;

2694

<a name="l02667"></a>02667 unsigned res_len;

2695

<a name="l02668"></a>02668

2696

<a name="l02669"></a>02669 <a class="code" href="a00115.html#a8402de852093e5b23b5825f1974b9c12">gap_operation_func_type</a> gfunc =

2697

<a name="l02670"></a>02670 operation_functions<true>::gap_operation(opcode);

2698

<a name="l02671"></a>02671 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(gfunc);

2699

<a name="l02672"></a>02672 res = (*gfunc)(<a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk),

2700

<a name="l02673"></a>02673 <a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(arg_blk),

2701

<a name="l02674"></a>02674 tmp_buf,

2702

<a name="l02675"></a>02675 res_len);

2703

<a name="l02676"></a>02676 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(res == tmp_buf);

2704

<a name="l02677"></a>02677 ++res_len;// = bm::gap_length(res);

2705

<a name="l02678"></a>02678

2706

<a name="l02679"></a>02679 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(!(res == tmp_buf && res_len == 0));

2707

<a name="l02680"></a>02680

2708

<a name="l02681"></a>02681 // if as a result of the operation gap block turned to zero

2709

<a name="l02682"></a>02682 // we can now replace it with NULL

2710

<a name="l02683"></a>02683 if (<a class="code" href="a00119.html#ga690ff7c8b16e1821a77663b7194267e7" title="Temporary inverts all bits in the GAP buffer.">gap_is_all_zero</a>(res, <a class="code" href="a00115.html#ad0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a>))

2711

<a name="l02684"></a>02684 {

2712

<a name="l02685"></a>02685 blockman_.zero_block(nb);

2713

<a name="l02686"></a>02686 return;

2714

<a name="l02687"></a>02687 }

2715

<a name="l02688"></a>02688

2716

<a name="l02689"></a>02689 // mutation check

2717

<a name="l02690"></a>02690

2718

<a name="l02691"></a>02691 int level = <a class="code" href="a00119.html#ga1defe73aa4227a0e7204363ac6bb1ac1" title="Returs GAP blocks capacity level.">gap_level</a>(<a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk));

2719

<a name="l02692"></a>02692 unsigned threshold = blockman_.glen(level)-4;

2720

<a name="l02693"></a>02693 int new_level = <a class="code" href="a00119.html#ga3bfaebeeb4b2d479c5a9ac9d57607165" title="Calculates GAP block capacity level.">gap_calc_level</a>(res_len, blockman_.glen());

2721

<a name="l02694"></a>02694

2722

<a name="l02695"></a>02695 if (new_level == -1)

2723

<a name="l02696"></a>02696 {

2724

<a name="l02697"></a>02697 blockman_.convert_gap2bitset(nb, res);

2725

<a name="l02698"></a>02698 return;

2726

<a name="l02699"></a>02699 }

2727

<a name="l02700"></a>02700

2728

<a name="l02701"></a>02701 if (res_len > threshold)

2729

<a name="l02702"></a>02702 {

2730

<a name="l02703"></a>02703 <a class="code" href="a00119.html#ga501aa9bf029e7f9ea9518e7003fe5549" title="Sets GAP block capacity level.">set_gap_level</a>(res, new_level);

2731

<a name="l02704"></a>02704 <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* new_blk =

2732

<a name="l02705"></a>02705 blockman_.allocate_gap_block(new_level, res);

2733

<a name="l02706"></a>02706

2734

<a name="l02707"></a>02707 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* p = (<a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*)new_blk;

2735

<a name="l02708"></a>02708 <a class="code" href="a00092.html#a93dbdb1a62ca0ce33149d3249dbf386e">BMSET_PTRGAP</a>(p);

2736

<a name="l02709"></a>02709

2737

<a name="l02710"></a>02710 blockman_.set_block_ptr(nb, p);

2738

<a name="l02711"></a>02711 blockman_.get_allocator().free_gap_block(<a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk),

2739

<a name="l02712"></a>02712 blockman_.glen());

2740

<a name="l02713"></a>02713 return;

2741

<a name="l02714"></a>02714 }

2742

<a name="l02715"></a>02715

2743

<a name="l02716"></a>02716 // gap opeartion result is in the temporary buffer

2744

<a name="l02717"></a>02717 // we copy it back to the gap_block

2745

<a name="l02718"></a>02718

2746

<a name="l02719"></a>02719 <a class="code" href="a00119.html#ga501aa9bf029e7f9ea9518e7003fe5549" title="Sets GAP block capacity level.">set_gap_level</a>(tmp_buf, level);

2747

<a name="l02720"></a>02720 ::memcpy(<a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk), tmp_buf, res_len * sizeof(<a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>));

2748

<a name="l02721"></a>02721 return;

2749

<a name="l02722"></a>02722 }

2750

<a name="l02723"></a>02723 else // argument is BITSET-type (own block is GAP)

2751

<a name="l02724"></a>02724 {

2752

<a name="l02725"></a>02725 // since we can not combine blocks of mixed type

2753

<a name="l02726"></a>02726 // we need to convert our block to bitset

2754

<a name="l02727"></a>02727

2755

<a name="l02728"></a>02728 if (arg_blk == 0) // Combining against an empty block

2756

<a name="l02729"></a>02729 {

2757

<a name="l02730"></a>02730 switch (opcode)

2758

<a name="l02731"></a>02731 {

2759

<a name="l02732"></a>02732 case <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a546fdf33b301e5b9bee0591522ed9250">BM_AND</a>: // ("Value" AND 0) == 0

2760

<a name="l02733"></a>02733 blockman_.zero_block(nb);

2761

<a name="l02734"></a>02734 return;

2762

<a name="l02735"></a>02735 case <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a0c8cf0197857d0bd73a63037e2f2c5c5">BM_OR</a>: case <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a1df0f4de7126bb2f7ce69d7a005affb5">BM_SUB</a>: case <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a45c2fe36efb72dc03f03a842d253f64c">BM_XOR</a>:

2763

<a name="l02736"></a>02736 return; // nothing to do

2764

<a name="l02737"></a>02737 }

2765

<a name="l02738"></a>02738 }

2766

<a name="l02739"></a>02739 <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* gap_blk = <a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk);

2767

<a name="l02740"></a>02740 if (opcode == <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a546fdf33b301e5b9bee0591522ed9250">BM_AND</a>)

2768

<a name="l02741"></a>02741 {

2769

<a name="l02742"></a>02742 unsigned gap_cnt = <a class="code" href="a00119.html#ga570a6f573ffb9ac9e41a688d2bdc6004" title="Calculates number of bits ON in GAP buffer.">gap_bit_count</a>(gap_blk);

2770

<a name="l02743"></a>02743 if (gap_cnt < 128)

2771

<a name="l02744"></a>02744 {

2772

<a name="l02745"></a>02745 <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a> tmp_buf[<a class="code" href="a00115.html#a9b1715d6d9164d56172e75bbbd0e3000">bm::gap_equiv_len</a> * 3];

2773

<a name="l02746"></a>02746 <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a> arr_len =

2774

<a name="l02747"></a>02747 <a class="code" href="a00119.html#ga5cd7e0cfee401da1b8f702151c083b27" title="Convert gap block into array of ints corresponding to 1 bits.">gap_convert_to_arr</a>(tmp_buf, gap_blk,

2775

<a name="l02748"></a>02748 <a class="code" href="a00115.html#a9b1715d6d9164d56172e75bbbd0e3000">bm::gap_equiv_len</a>-10);

2776

<a name="l02749"></a>02749 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(gap_cnt == arr_len);

2777

<a name="l02750"></a>02750 blockman_.zero_block(nb);

2778

<a name="l02751"></a>02751 unsigned arr_i = 0;

2779

<a name="l02752"></a>02752 int block_type;

2780

<a name="l02753"></a>02753 blk =

2781

<a name="l02754"></a>02754 blockman_.check_allocate_block(nb,

2782

<a name="l02755"></a>02755 true,

2783

<a name="l02756"></a>02756 <a class="code" href="a00118.html#ggad0b87b3b7292383a864d27feaf1c9effa7fe09d1d7c62a813db922c396c0cbc9c" title="GAP compression is ON.">BM_GAP</a>,

2784

<a name="l02757"></a>02757 &block_type,

2785

<a name="l02758"></a>02758 false //no null return

2786

<a name="l02759"></a>02759 );

2787

<a name="l02760"></a>02760 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(block_type==1); // GAP

2788

<a name="l02761"></a>02761 gap_blk = <a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk);

2789

<a name="l02762"></a>02762 unsigned threshold = <a class="code" href="a00119.html#ga94a5371b5dc6a1560d95d7c2dde88815" title="Returs GAP block capacity limit.">bm::gap_limit</a>(gap_blk, blockman_.glen());

2790

<a name="l02763"></a>02763 for (; arr_i < arr_len; ++arr_i)

2791

<a name="l02764"></a>02764 {

2792

<a name="l02765"></a>02765 <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a> bit_idx = tmp_buf[arr_i];

2793

<a name="l02766"></a>02766 if (<a class="code" href="a00120.html#ga9bccc586aa791f98f1bec284b799102c" title="Test 1 bit in a block.">bm::test_bit</a>(arg_blk, bit_idx))

2794

<a name="l02767"></a>02767 {

2795

<a name="l02768"></a>02768 unsigned is_set;

2796

<a name="l02769"></a>02769 unsigned new_block_len =

2797

<a name="l02770"></a>02770 <a class="code" href="a00119.html#ga69186bd13bda27e04b3e33683ff884c2" title="Abstract distance(similarity) operation for GAP buffers. Receives functor F as a...">gap_set_value</a>(true, gap_blk, bit_idx, &is_set);

2798

<a name="l02771"></a>02771 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(is_set);

2799

<a name="l02772"></a>02772 if (new_block_len > threshold)

2800

<a name="l02773"></a>02773 {

2801

<a name="l02774"></a>02774 gap_blk =

2802

<a name="l02775"></a>02775 blockman_.extend_gap_block(nb, gap_blk);

2803

<a name="l02776"></a>02776 if (gap_blk == 0) // mutated into bit-block

2804

<a name="l02777"></a>02777 {

2805

<a name="l02778"></a>02778 blk = blockman_.check_allocate_block(

2806

<a name="l02779"></a>02779 nb,

2807

<a name="l02780"></a>02780 true,

2808

<a name="l02781"></a>02781 this-><a class="code" href="a00044.html#ad971c541fa259278e9dcf541b2d128c9" title="Returns blocks allocation strategy.">get_new_blocks_strat</a>(),

2809

<a name="l02782"></a>02782 &block_type,

2810

<a name="l02783"></a>02783 false // no null return

2811

<a name="l02784"></a>02784 );

2812

<a name="l02785"></a>02785 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(block_type == 0); // BIT

2813

<a name="l02786"></a>02786 // target block degraded into plain bit-block

2814

<a name="l02787"></a>02787 for (++arr_i; arr_i < arr_len; ++arr_i)

2815

<a name="l02788"></a>02788 {

2816

<a name="l02789"></a>02789 bit_idx = tmp_buf[arr_i];

2817

<a name="l02790"></a>02790 if (<a class="code" href="a00120.html#ga9bccc586aa791f98f1bec284b799102c" title="Test 1 bit in a block.">bm::test_bit</a>(arg_blk, bit_idx))

2818

<a name="l02791"></a>02791 {

2819

<a name="l02792"></a>02792 <a class="code" href="a00120.html#gad698b5242f5b629aa28e7338b7150497" title="Sets bits to 1 in the bitblock.">or_bit_block</a>(blk, bit_idx, 1);

2820

<a name="l02793"></a>02793 }

2821

<a name="l02794"></a>02794 } // for arr_i

2822

<a name="l02795"></a>02795 return;

2823

<a name="l02796"></a>02796 } // if gap mutated

2824

<a name="l02797"></a>02797 }

2825

<a name="l02798"></a>02798 } // for arr_i

2826

<a name="l02799"></a>02799 }

2827

<a name="l02800"></a>02800

2828

<a name="l02801"></a>02801 return;

2829

<a name="l02802"></a>02802 }

2830

<a name="l02803"></a>02803 } // BM_AND

2831

<a name="l02804"></a>02804

2832

<a name="l02805"></a>02805 blk = blockman_.convert_gap2bitset(nb, gap_blk);

2833

<a name="l02806"></a>02806 }

2834

<a name="l02807"></a>02807 }

2835

<a name="l02808"></a>02808 else // our block is BITSET-type

2836

<a name="l02809"></a>02809 {

2837

<a name="l02810"></a>02810 if (arg_gap) // argument block is GAP-type

2838

<a name="l02811"></a>02811 {

2839

<a name="l02812"></a>02812 if (<a class="code" href="a00092.html#a13ba598909515339ceede09e3b9b0198">IS_VALID_ADDR</a>(blk))

2840

<a name="l02813"></a>02813 {

2841

<a name="l02814"></a>02814 // special case, maybe we can do the job without

2842

<a name="l02815"></a>02815 // converting the GAP argument to bitblock

2843

<a name="l02816"></a>02816 <a class="code" href="a00115.html#a18a8f03b151ca3a6d5e39e7709fb6c7c">gap_operation_to_bitset_func_type</a> gfunc =

2844

<a name="l02817"></a>02817 operation_functions<true>::gap_op_to_bit(opcode);

2845

<a name="l02818"></a>02818 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(gfunc);

2846

<a name="l02819"></a>02819 (*gfunc)(blk, <a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(arg_blk));

2847

<a name="l02820"></a>02820 return;

2848

<a name="l02821"></a>02821 }

2849

<a name="l02822"></a>02822

2850

<a name="l02823"></a>02823 // the worst case we need to convert argument block to

2851

<a name="l02824"></a>02824 // bitset type.

2852

<a name="l02825"></a>02825 <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* temp_blk = (<a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>*) blockman_.check_allocate_tempblock();

2853

<a name="l02826"></a>02826 arg_blk =

2854

<a name="l02827"></a>02827 <a class="code" href="a00119.html#ga3f01bb7c1ae7983aa8c4ba82e1e3f54c" title="Smart GAP block to bitblock conversion.">gap_convert_to_bitset_smart</a>((<a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*)temp_blk,

2855

<a name="l02828"></a>02828 <a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(arg_blk),

2856

<a name="l02829"></a>02829 <a class="code" href="a00115.html#ad0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a>);

2857

<a name="l02830"></a>02830

2858

<a name="l02831"></a>02831 }

2859

<a name="l02832"></a>02832 }

2860

<a name="l02833"></a>02833

2861

<a name="l02834"></a>02834 // Now here we combine two plain bitblocks using supplied bit function.

2862

<a name="l02835"></a>02835 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* dst = blk;

2863

<a name="l02836"></a>02836

2864

<a name="l02837"></a>02837 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* ret;

2865

<a name="l02838"></a>02838 if (dst == 0 && arg_blk == 0)

2866

<a name="l02839"></a>02839 {

2867

<a name="l02840"></a>02840 return;

2868

<a name="l02841"></a>02841 }

2869

<a name="l02842"></a>02842

2870

<a name="l02843"></a>02843 switch (opcode)

2871

<a name="l02844"></a>02844 {

2872

<a name="l02845"></a>02845 case <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a546fdf33b301e5b9bee0591522ed9250">BM_AND</a>:

2873

<a name="l02846"></a>02846 ret = <a class="code" href="a00120.html#ga869fce5348076d4c7b92adcc2f1a49ab" title="bitblock AND operation.">bit_operation_and</a>(dst, arg_blk);

2874

<a name="l02847"></a>02847 goto copy_block;

2875

<a name="l02848"></a>02848 case <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a45c2fe36efb72dc03f03a842d253f64c">BM_XOR</a>:

2876

<a name="l02849"></a>02849 ret = <a class="code" href="a00120.html#ga179de722e87ccf8189d975ca6beed025" title="bitblock XOR operation.">bit_operation_xor</a>(dst, arg_blk);

2877

<a name="l02850"></a>02850 if (ret && (ret == arg_blk) && <a class="code" href="a00092.html#a074acb37afea68caaffe3832d326eb44">IS_FULL_BLOCK</a>(dst))

2878

<a name="l02851"></a>02851 {

2879

<a name="l02852"></a>02852 ret = blockman_.get_allocator().alloc_bit_block();

2880

<a name="l02853"></a>02853 #ifdef BMVECTOPT

2881

<a name="l02854"></a>02854 <a class="code" href="a00098.html#a9b8caa31ab90cbfbc99b5728352e5456">VECT_XOR_ARR_2_MASK</a>(ret,

2882

<a name="l02855"></a>02855 arg_blk,

2883

<a name="l02856"></a>02856 arg_blk + bm::set_block_size,

2884

<a name="l02857"></a>02857 <a class="code" href="a00115.html#ad81dea46a256b93b2af3568ce409d40b">bm::all_bits_mask</a>);

2885

<a name="l02858"></a>02858 #else

2886

<a name="l02859"></a>02859 <a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>* dst_ptr = (<a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">wordop_t</a>*)ret;

2887

<a name="l02860"></a>02860 const <a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>* wrd_ptr = (<a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">wordop_t</a>*) arg_blk;

2888

<a name="l02861"></a>02861 const <a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>* wrd_end =

2889

<a name="l02862"></a>02862 (<a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">wordop_t</a>*) (arg_blk + bm::set_block_size);

2890

<a name="l02863"></a>02863

2891

<a name="l02864"></a>02864 do

2892

<a name="l02865"></a>02865 {

2893

<a name="l02866"></a>02866 dst_ptr[0] = <a class="code" href="a00115.html#ad81dea46a256b93b2af3568ce409d40b">bm::all_bits_mask</a> ^ wrd_ptr[0];

2894

<a name="l02867"></a>02867 dst_ptr[1] = <a class="code" href="a00115.html#ad81dea46a256b93b2af3568ce409d40b">bm::all_bits_mask</a> ^ wrd_ptr[1];

2895

<a name="l02868"></a>02868 dst_ptr[2] = <a class="code" href="a00115.html#ad81dea46a256b93b2af3568ce409d40b">bm::all_bits_mask</a> ^ wrd_ptr[2];

2896

<a name="l02869"></a>02869 dst_ptr[3] = <a class="code" href="a00115.html#ad81dea46a256b93b2af3568ce409d40b">bm::all_bits_mask</a> ^ wrd_ptr[3];

2897

<a name="l02870"></a>02870

2898

<a name="l02871"></a>02871 dst_ptr+=4;

2899

<a name="l02872"></a>02872 wrd_ptr+=4;

2900

<a name="l02873"></a>02873

2901

<a name="l02874"></a>02874 } while (wrd_ptr < wrd_end);

2902

<a name="l02875"></a>02875 #endif

2903

<a name="l02876"></a>02876 break;

2904

<a name="l02877"></a>02877 }

2905

<a name="l02878"></a>02878 goto copy_block;

2906

<a name="l02879"></a>02879 case <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a0c8cf0197857d0bd73a63037e2f2c5c5">BM_OR</a>:

2907

<a name="l02880"></a>02880 ret = <a class="code" href="a00120.html#ga0e945a9eaae699ad40f63b3f0632e6f9" title="Block OR operation. Makes analysis if block is 0 or FULL.">bit_operation_or</a>(dst, arg_blk);

2908

<a name="l02881"></a>02881 copy_block:

2909

<a name="l02882"></a>02882 if (ret && (ret == arg_blk) && !<a class="code" href="a00092.html#a074acb37afea68caaffe3832d326eb44">IS_FULL_BLOCK</a>(ret))

2910

<a name="l02883"></a>02883 {

2911

<a name="l02884"></a>02884 ret = blockman_.get_allocator().alloc_bit_block();

2912

<a name="l02885"></a>02885 <a class="code" href="a00120.html#ga9090de87d53e7f25eff96c8259b3485c" title="Bitblock copy operation.">bit_block_copy</a>(ret, arg_blk);

2913

<a name="l02886"></a>02886 }

2914

<a name="l02887"></a>02887 break;

2915

<a name="l02888"></a>02888

2916

<a name="l02889"></a>02889 case <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a1df0f4de7126bb2f7ce69d7a005affb5">BM_SUB</a>:

2917

<a name="l02890"></a>02890 ret = <a class="code" href="a00120.html#gad7afa9bce28a376360ca4826960d669f" title="bitblock SUB operation.">bit_operation_sub</a>(dst, arg_blk);

2918

<a name="l02891"></a>02891 if (ret && ret == arg_blk)

2919

<a name="l02892"></a>02892 {

2920

<a name="l02893"></a>02893 ret = blockman_.get_allocator().alloc_bit_block();

2921

<a name="l02894"></a>02894 #ifdef BMVECTOPT

2922

<a name="l02895"></a>02895 <a class="code" href="a00098.html#a7d425b68d8217dc37d33c660e39a61e1">VECT_ANDNOT_ARR_2_MASK</a>(ret,

2923

<a name="l02896"></a>02896 arg_blk,

2924

<a name="l02897"></a>02897 arg_blk + bm::set_block_size,

2925

<a name="l02898"></a>02898 <a class="code" href="a00115.html#ad81dea46a256b93b2af3568ce409d40b">bm::all_bits_mask</a>);

2926

<a name="l02899"></a>02899 #else

2927

<a name="l02900"></a>02900

2928

<a name="l02901"></a>02901 <a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>* dst_ptr = (<a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">wordop_t</a>*)ret;

2929

<a name="l02902"></a>02902 const <a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>* wrd_ptr = (<a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">wordop_t</a>*) arg_blk;

2930

<a name="l02903"></a>02903 const <a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>* wrd_end =

2931

<a name="l02904"></a>02904 (<a class="code" href="a00115.html#a7176bf7817550ca24cb6612bd8d7957d">wordop_t</a>*) (arg_blk + bm::set_block_size);

2932

<a name="l02905"></a>02905

2933

<a name="l02906"></a>02906 do

2934

<a name="l02907"></a>02907 {

2935

<a name="l02908"></a>02908 dst_ptr[0] = <a class="code" href="a00115.html#ad81dea46a256b93b2af3568ce409d40b">bm::all_bits_mask</a> & ~wrd_ptr[0];

2936

<a name="l02909"></a>02909 dst_ptr[1] = <a class="code" href="a00115.html#ad81dea46a256b93b2af3568ce409d40b">bm::all_bits_mask</a> & ~wrd_ptr[1];

2937

<a name="l02910"></a>02910 dst_ptr[2] = <a class="code" href="a00115.html#ad81dea46a256b93b2af3568ce409d40b">bm::all_bits_mask</a> & ~wrd_ptr[2];

2938

<a name="l02911"></a>02911 dst_ptr[3] = <a class="code" href="a00115.html#ad81dea46a256b93b2af3568ce409d40b">bm::all_bits_mask</a> & ~wrd_ptr[3];

2939

<a name="l02912"></a>02912

2940

<a name="l02913"></a>02913 dst_ptr+=4;

2941

<a name="l02914"></a>02914 wrd_ptr+=4;

2942

<a name="l02915"></a>02915

2943

<a name="l02916"></a>02916 } while (wrd_ptr < wrd_end);

2944

<a name="l02917"></a>02917 #endif

2945

<a name="l02918"></a>02918 }

2946

<a name="l02919"></a>02919 break;

2947

<a name="l02920"></a>02920 default:

2948

<a name="l02921"></a>02921 <a class="code" href="a00092.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(0);

2949

<a name="l02922"></a>02922 ret = 0;

2950

<a name="l02923"></a>02923 }

2951

<a name="l02924"></a>02924

2952

<a name="l02925"></a>02925 if (ret != dst) // block mutation

2953

<a name="l02926"></a>02926 {

2954

<a name="l02927"></a>02927 blockman_.set_block(nb, ret);

2955

<a name="l02928"></a>02928 blockman_.get_allocator().free_bit_block(dst);

2956

<a name="l02929"></a>02929 }

2957

<a name="l02930"></a>02930 }

2958

<a name="l02931"></a>02931

2959

<a name="l02932"></a>02932 //---------------------------------------------------------------------

2960

<a name="l02933"></a>02933

2961

<a name="l02934"></a>02934 template<class Alloc, class MS>

2962

<a name="l02935"></a>02935 void bvector<Alloc, MS>::set_range_no_check(<a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> left,

2963

<a name="l02936"></a>02936 <a class="code" href="a00115.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> right,

2964

<a name="l02937"></a>02937 bool value)

2965

<a name="l02938"></a>02938 {

2966

<a name="l02939"></a>02939 // calculate logical number of start and destination blocks

2967

<a name="l02940"></a>02940 unsigned nblock_left = unsigned(left >> <a class="code" href="a00115.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

2968

<a name="l02941"></a>02941 unsigned nblock_right = unsigned(right >> <a class="code" href="a00115.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

2969

<a name="l02942"></a>02942

2970

<a name="l02943"></a>02943 <a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* block = blockman_.get_block(nblock_left);

2971

<a name="l02944"></a>02944 bool left_gap = <a class="code" href="a00092.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nblock_left);

2972

<a name="l02945"></a>02945

2973

<a name="l02946"></a>02946 unsigned nbit_left = unsigned(left & <a class="code" href="a00115.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2974

<a name="l02947"></a>02947 unsigned nbit_right = unsigned(right & <a class="code" href="a00115.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2975

<a name="l02948"></a>02948

2976

<a name="l02949"></a>02949 unsigned r =

2977

<a name="l02950"></a>02950 (nblock_left == nblock_right) ? nbit_right :(<a class="code" href="a00115.html#ae9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a>-1);

2978

<a name="l02951"></a>02951

2979

<a name="l02952"></a>02952 <a class="code" href="a00115.html#ac654d6319039a86546d235a236fc7cf6">bm::gap_word_t</a> tmp_gap_blk[5] = {0,};

2980

<a name="l02953"></a>02953

2981

<a name="l02954"></a>02954 // Set bits in the starting block

2982

<a name="l02955"></a>02955

2983

<a name="l02956"></a>02956 unsigned nb;

2984

<a name="l02957"></a>02957 if ((nbit_left == 0) && (r == <a class="code" href="a00115.html#ae9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a> - 1)) // full block

2985

<a name="l02958"></a>02958 {

2986

<a name="l02959"></a>02959 nb = nblock_left;

2987

<a name="l02960"></a>02960 }

2988

<a name="l02961"></a>02961 else

2989

<a name="l02962"></a>02962 {

2990

<a name="l02963"></a>02963 <a class="code" href="a00119.html#ga5d49355eb9dd7947699e20f3a2a75ef5" title="Init gap block so it has block in it (can be whole block).">gap_init_range_block</a>(tmp_gap_blk,

2991

<a name="l02964"></a>02964 nbit_left, r, value, <a class="code" href="a00115.html#ae9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a>);

2992

<a name="l02965"></a>02965

2993

<a name="l02966"></a>02966 combine_operation_with_block(nblock_left,

2994

<a name="l02967"></a>02967 left_gap,

2995

<a name="l02968"></a>02968 block,

2996

<a name="l02969"></a>02969 (<a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*) tmp_gap_blk,

2997

<a name="l02970"></a>02970 1,

2998

<a name="l02971"></a>02971 value ? <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a0c8cf0197857d0bd73a63037e2f2c5c5">BM_OR</a> : <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a546fdf33b301e5b9bee0591522ed9250">BM_AND</a>);

2999

<a name="l02972"></a>02972

3000

<a name="l02973"></a>02973 if (nblock_left == nblock_right) // in one block

3001

<a name="l02974"></a>02974 return;

3002

<a name="l02975"></a>02975 nb = nblock_left+1;

3003

<a name="l02976"></a>02976 }

3004

<a name="l02977"></a>02977

3005

<a name="l02978"></a>02978 // Set (or clear) all full blocks between left and right

3006

<a name="l02979"></a>02979

3007

<a name="l02980"></a>02980 unsigned nb_to = nblock_right + (nbit_right ==(<a class="code" href="a00115.html#ae9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a>-1));

3008

<a name="l02981"></a>02981

3009

<a name="l02982"></a>02982 if (value)

3010

<a name="l02983"></a>02983 {

3011

<a name="l02984"></a>02984 for (; nb < nb_to; ++nb)

3012

<a name="l02985"></a>02985 {

3013

<a name="l02986"></a>02986 block = blockman_.get_block(nb);

3014

<a name="l02987"></a>02987 if (<a class="code" href="a00092.html#a074acb37afea68caaffe3832d326eb44">IS_FULL_BLOCK</a>(block))

3015

<a name="l02988"></a>02988 continue;

3016

<a name="l02989"></a>02989

3017

<a name="l02990"></a>02990 bool is_gap = <a class="code" href="a00092.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nb);

3018

<a name="l02991"></a>02991

3019

<a name="l02992"></a>02992 blockman_.set_block(nb, <a class="code" href="a00092.html#a1365569f85f442c4914a3579f55df99b">FULL_BLOCK_ADDR</a>);

3020

<a name="l02993"></a>02993 blockman_.set_block_bit(nb);

3021

<a name="l02994"></a>02994

3022

<a name="l02995"></a>02995 if (is_gap)

3023

<a name="l02996"></a>02996 {

3024

<a name="l02997"></a>02997 blockman_.get_allocator().free_gap_block(<a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block),

3025

<a name="l02998"></a>02998 blockman_.glen());

3026

<a name="l02999"></a>02999 }

3027

<a name="l03000"></a>03000 else

3028

<a name="l03001"></a>03001 {

3029

<a name="l03002"></a>03002 blockman_.get_allocator().free_bit_block(block);

3030

<a name="l03003"></a>03003 }

3031

<a name="l03004"></a>03004

3032

<a name="l03005"></a>03005 } // for

3033

<a name="l03006"></a>03006 }

3034

<a name="l03007"></a>03007 else // value == 0

3035

<a name="l03008"></a>03008 {

3036

<a name="l03009"></a>03009 for (; nb < nb_to; ++nb)

3037

<a name="l03010"></a>03010 {

3038

<a name="l03011"></a>03011 block = blockman_.get_block(nb);

3039

<a name="l03012"></a>03012 if (block == 0) // nothing to do

3040

<a name="l03013"></a>03013 continue;

3041

<a name="l03014"></a>03014 bool is_gap = <a class="code" href="a00092.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nb);

3042

<a name="l03015"></a>03015 blockman_.set_block(nb, 0, false /*bit*/);

3043

<a name="l03016"></a>03016 //blockman_.set_block_bit(nb);

3044

<a name="l03017"></a>03017

3045

<a name="l03018"></a>03018 if (is_gap)

3046

<a name="l03019"></a>03019 {

3047

<a name="l03020"></a>03020 blockman_.get_allocator().free_gap_block(<a class="code" href="a00092.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block),

3048

<a name="l03021"></a>03021 blockman_.glen());

3049

<a name="l03022"></a>03022 }

3050

<a name="l03023"></a>03023 else

3051

<a name="l03024"></a>03024 {

3052

<a name="l03025"></a>03025 blockman_.get_allocator().free_bit_block(block);

3053

<a name="l03026"></a>03026 }

3054

<a name="l03027"></a>03027

3055

<a name="l03028"></a>03028 } // for

3056

<a name="l03029"></a>03029 } // if value else

3057

<a name="l03030"></a>03030

3058

<a name="l03031"></a>03031 if (nb_to > nblock_right)

3059

<a name="l03032"></a>03032 return;

3060

<a name="l03033"></a>03033

3061

<a name="l03034"></a>03034 block = blockman_.get_block(nblock_right);

3062

<a name="l03035"></a>03035 bool right_gap = <a class="code" href="a00092.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nblock_right);

3063

<a name="l03036"></a>03036

3064

<a name="l03037"></a>03037 <a class="code" href="a00119.html#ga5d49355eb9dd7947699e20f3a2a75ef5" title="Init gap block so it has block in it (can be whole block).">gap_init_range_block</a>(tmp_gap_blk,

3065

<a name="l03038"></a>03038 0, nbit_right, value, <a class="code" href="a00115.html#ae9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a>);

3066

<a name="l03039"></a>03039

3067

<a name="l03040"></a>03040 combine_operation_with_block(nblock_right,

3068

<a name="l03041"></a>03041 right_gap,

3069

<a name="l03042"></a>03042 block,

3070

<a name="l03043"></a>03043 (<a class="code" href="a00115.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*) tmp_gap_blk,

3071

<a name="l03044"></a>03044 1,

3072

<a name="l03045"></a>03045 value ? <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a0c8cf0197857d0bd73a63037e2f2c5c5">BM_OR</a> : <a class="code" href="a00115.html#a42405343976ec931388381cea4092bf1a546fdf33b301e5b9bee0591522ed9250">BM_AND</a>);

3073

<a name="l03046"></a>03046

3074

<a name="l03047"></a>03047 }

3075

<a name="l03048"></a>03048

3076

<a name="l03049"></a>03049 //---------------------------------------------------------------------

3077

<a name="l03050"></a>03050

3078

<a name="l03051"></a>03051

3079

<a name="l03052"></a>03052 } // namespace

3080

<a name="l03053"></a>03053

3081

<a name="l03054"></a>03054 #include "<a class="code" href="a00101.html">bmundef.h</a>"

3082

<a name="l03055"></a>03055

3083

<a name="l03056"></a>03056 #ifdef _MSC_VER

3084

<a name="l03057"></a>03057 #pragma warning( default : 4311 4312)

3085

<a name="l03058"></a>03058 #endif

3086

<a name="l03059"></a>03059

3087

<a name="l03060"></a>03060

3088

<a name="l03061"></a>03061 #endif

270

3089

</pre></div></div>

271

<hr size="1"/><address style="text-align: right;">Generated on Sun Nov 22 10:49:35 2009 for BitMagic by

3090

<hr size="1"/><address style="text-align: right;">Generated on Fri Jan 8 20:09:19 2010 for BitMagic by

272

3091

273

3092

274

3093

</body>

Older »