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

<a name="l00089"></a><a class="code" href="a00088.html#c77813f2c2dfe40575830ba6a8373bcc">00089</a> typedef <a class="code" href="a00060.html" title="Template class implements memory saving set functionality.">bm::miniset<bm::block_allocator, bm::set_total_blocks></a> <a class="code" href="a00060.html" title="Template class implements memory saving set functionality.">mem_save_set</a>;

114

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

115

<a name="l00091"></a>00091

116

<a name="l00092"></a>00092 /** @defgroup bmagic BitMagic C++ Library

117

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

118

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

119

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

120

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

121

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

122

<a name="l00098"></a>00098 /** @defgroup bvector The Main bvector<> Group

123

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

124

<a name="l00100"></a>00100 * @ingroup bmagic

125

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

126

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

127

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

128

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

129

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

130

<a name="l00106"></a>00106 /*!

131

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

132

<a name="l00108"></a>00108 @ingroup bvector

133

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

134

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

135

<a name="l00111"></a>00111 template<class Alloc, class MS>

136

<a name="l00112"></a><a class="code" href="a00036.html">00112</a> class <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector</a>

137

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

138

<a name="l00114"></a>00114 public:

139

<a name="l00115"></a>00115

140

<a name="l00116"></a><a class="code" href="a00036.html#0da32cb546602fa6874a5a4804192b6e">00116</a> typedef Alloc <a class="code" href="a00036.html#0da32cb546602fa6874a5a4804192b6e">allocator_type</a>;

141

<a name="l00117"></a><a class="code" href="a00036.html#1c89beac7542674fdc09cbcf024ab390">00117</a> typedef blocks_manager<Alloc, MS> <a class="code" href="a00036.html#1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>;

142

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

143

<a name="l00119"></a><a class="code" href="a00036.html#ba038b54cc8d548bb1c058dee0325884">00119</a> typedef <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00036.html#ba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a>;

144

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

145

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

146

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

147

<a name="l00123"></a>00123 {};

148

<a name="l00124"></a>00124

149

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

150

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

151

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

152

<a name="l00128"></a>00128 operations we have to emulate it.

153

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

154

<a name="l00130"></a>00130 @ingroup bvector

155

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

156

<a name="l00132"></a><a class="code" href="a00064.html">00132</a> class <a class="code" href="a00064.html" title="Class reference implements an object for bit assignment.">reference</a>

157

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

158

<a name="l00134"></a>00134 public:

159

<a name="l00135"></a><a class="code" href="a00064.html#ce927b54c909478e30a5dd38ccb0c0d6">00135</a> <a class="code" href="a00064.html#ce927b54c909478e30a5dd38ccb0c0d6">reference</a>(<a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& bv, <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> position)

160

<a name="l00136"></a>00136 : bv_(bv),

161

<a name="l00137"></a>00137 position_(position)

162

<a name="l00138"></a>00138 {}

163

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

164

<a name="l00140"></a><a class="code" href="a00064.html#46fc4910419c5ea5de6158660fada675">00140</a> <a class="code" href="a00064.html#ce927b54c909478e30a5dd38ccb0c0d6">reference</a>(const <a class="code" href="a00064.html" title="Class reference implements an object for bit assignment.">reference</a>& ref)

165

<a name="l00141"></a>00141 : bv_(ref.bv_),

166

<a name="l00142"></a>00142 position_(ref.position_)

167

<a name="l00143"></a>00143 {

168

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

169

<a name="l00145"></a>00145 }

170

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

171

<a name="l00147"></a><a class="code" href="a00064.html#4d531a670ed0e8cfca01342fe02f030e">00147</a> <a class="code" href="a00064.html#4d531a670ed0e8cfca01342fe02f030e">operator bool</a>() const

172

<a name="l00148"></a>00148 {

173

<a name="l00149"></a>00149 return bv_.get_bit(position_);

174

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

175

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

176

<a name="l00152"></a><a class="code" href="a00064.html#c597a766c4942da598682c4917ee41c6">00152</a> const <a class="code" href="a00064.html" title="Class reference implements an object for bit assignment.">reference</a>& <a class="code" href="a00064.html#c597a766c4942da598682c4917ee41c6">operator=</a>(const <a class="code" href="a00064.html" title="Class reference implements an object for bit assignment.">reference</a>& ref) const

177

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

178

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

179

<a name="l00155"></a>00155 return *this;

180

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

181

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

182

<a name="l00158"></a><a class="code" href="a00064.html#e7fd4a0de8fe3d984322e8a690feeb5a">00158</a> const <a class="code" href="a00064.html" title="Class reference implements an object for bit assignment.">reference</a>& <a class="code" href="a00064.html#c597a766c4942da598682c4917ee41c6">operator=</a>(bool value) const

183

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

184

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

185

<a name="l00161"></a>00161 return *this;

186

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

187

<a name="l00163"></a>00163

188

<a name="l00164"></a><a class="code" href="a00064.html#b761552f565e9ecfe263fd8325d50852">00164</a> bool <a class="code" href="a00064.html#b761552f565e9ecfe263fd8325d50852">operator==</a>(const <a class="code" href="a00064.html" title="Class reference implements an object for bit assignment.">reference</a>& ref) const

189

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

190

<a name="l00166"></a>00166 return bool(*this) == bool(ref);

191

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

192

<a name="l00168"></a>00168

193

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

194

<a name="l00170"></a><a class="code" href="a00064.html#78514f588110835ecd21f3c8737b6a3f">00170</a> const <a class="code" href="a00064.html" title="Class reference implements an object for bit assignment.">reference</a>& <a class="code" href="a00064.html#78514f588110835ecd21f3c8737b6a3f">operator&=</a>(bool value) const

195

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

196

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

197

<a name="l00173"></a>00173 return *this;

198

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

199

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

200

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

201

<a name="l00177"></a><a class="code" href="a00064.html#cbf8b97f7b52f1c9b81a1d9129986cff">00177</a> const <a class="code" href="a00064.html" title="Class reference implements an object for bit assignment.">reference</a>& <a class="code" href="a00064.html#cbf8b97f7b52f1c9b81a1d9129986cff">operator|=</a>(bool value) const

202

<a name="l00178"></a>00178 {

203

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

204

<a name="l00180"></a>00180 {

205

<a name="l00181"></a>00181 bv_.set_bit(position_);

206

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

207

<a name="l00183"></a>00183 return *this;

208

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

209

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

210

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

211

<a name="l00187"></a><a class="code" href="a00064.html#94e3b8c46d1f83c5999c8eaf426b8e9b">00187</a> const <a class="code" href="a00064.html" title="Class reference implements an object for bit assignment.">reference</a>& <a class="code" href="a00064.html#94e3b8c46d1f83c5999c8eaf426b8e9b">operator^=</a>(bool value) const

212

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

213

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

214

<a name="l00190"></a>00190 return *this;

215

<a name="l00191"></a>00191 }

216

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

217

<a name="l00193"></a>00193 /*! Logical Not operator */

218

<a name="l00194"></a><a class="code" href="a00064.html#a214fa361c24c57c9fd4d26441ff6c12">00194</a> bool <a class="code" href="a00064.html#a214fa361c24c57c9fd4d26441ff6c12">operator!</a>() const

219

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

220

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

221

<a name="l00197"></a>00197 }

222

<a name="l00198"></a>00198

223

<a name="l00199"></a>00199 /*! Bit Not operator */

224

<a name="l00200"></a><a class="code" href="a00064.html#70357e67d8022147971ad970a80108d0">00200</a> bool <a class="code" href="a00064.html#70357e67d8022147971ad970a80108d0">operator~</a>() const

225

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

226

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

227

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

228

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

229

<a name="l00205"></a>00205 /*! Negates the bit value */

230

<a name="l00206"></a><a class="code" href="a00064.html#31f8e1425e1563f1f5890b77f736f323">00206</a> <a class="code" href="a00064.html" title="Class reference implements an object for bit assignment.">reference</a>& <a class="code" href="a00064.html#31f8e1425e1563f1f5890b77f736f323">flip</a>()

231

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

232

<a name="l00208"></a>00208 bv_.flip(position_);

233

<a name="l00209"></a>00209 return *this;

234

<a name="l00210"></a>00210 }

235

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

236

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

237

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

238

<a name="l00214"></a>00214 <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> position_; //!< Position in the parent bitvector.

239

<a name="l00215"></a>00215 };

240

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

241

<a name="l00217"></a><a class="code" href="a00036.html#bd935c7ebeb4d3c65caf3d236d24708a">00217</a> typedef bool <a class="code" href="a00036.html#bd935c7ebeb4d3c65caf3d236d24708a">const_reference</a>;

242

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

243

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

244

<a name="l00220"></a>00220 @brief Base class for all iterators.

245

<a name="l00221"></a>00221 @ingroup bvector

246

<a name="l00222"></a>00222 */

247

<a name="l00223"></a><a class="code" href="a00057.html">00223</a> class <a class="code" href="a00057.html" title="Base class for all iterators.">iterator_base</a>

248

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

249

<a name="l00225"></a><a class="code" href="a00057.html#5bb8687c5e87638689649a12c54187cb">00225</a> friend class <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector</a>;

250

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

251

<a name="l00227"></a><a class="code" href="a00057.html#c6063f4c924cf6702a6bdbf2a889a980">00227</a> <a class="code" href="a00057.html#c6063f4c924cf6702a6bdbf2a889a980">iterator_base</a>() : <a class="code" href="a00057.html#d341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a>(0), <a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>(bm::<a class="code" href="a00088.html#104b924a1df81542db2a6296fbf26a65">id_max</a>), <a class="code" href="a00057.html#6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a>(0) {}

252

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

253

<a name="l00229"></a><a class="code" href="a00057.html#b3312a717f0f899c8349c257d85d30a6">00229</a> bool <a class="code" href="a00057.html#b3312a717f0f899c8349c257d85d30a6">operator==</a>(const <a class="code" href="a00057.html" title="Base class for all iterators.">iterator_base</a>& it) const

254

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

255

<a name="l00231"></a>00231 return (<a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> == it.<a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>) && (<a class="code" href="a00057.html#d341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a> == it.<a class="code" href="a00057.html#d341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a>);

256

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

257

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

258

<a name="l00234"></a><a class="code" href="a00057.html#479fe29cb33db62d7216ebc553ec9f0c">00234</a> bool <a class="code" href="a00057.html#479fe29cb33db62d7216ebc553ec9f0c">operator!=</a>(const <a class="code" href="a00057.html" title="Base class for all iterators.">iterator_base</a>& it) const

259

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

260

<a name="l00236"></a>00236 return ! <a class="code" href="a00057.html#b3312a717f0f899c8349c257d85d30a6">operator==</a>(it);

261

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

262

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

263

<a name="l00239"></a><a class="code" href="a00057.html#ac47c0d848ef2300708e32126579bed1">00239</a> bool <a class="code" href="a00057.html#ac47c0d848ef2300708e32126579bed1">operator < </a>(const <a class="code" href="a00057.html" title="Base class for all iterators.">iterator_base</a>& it) const

264

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

265

<a name="l00241"></a>00241 return <a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> < it.<a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>;

266

<a name="l00242"></a>00242 }

267

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

268

<a name="l00244"></a><a class="code" href="a00057.html#2f0ea98e14ad5cface258eb2ac6abc23">00244</a> bool <a class="code" href="a00057.html#2f0ea98e14ad5cface258eb2ac6abc23">operator <= </a>(const <a class="code" href="a00057.html" title="Base class for all iterators.">iterator_base</a>& it) const

269

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

270

<a name="l00246"></a>00246 return <a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> <= it.<a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>;

271

<a name="l00247"></a>00247 }

272

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

273

<a name="l00249"></a><a class="code" href="a00057.html#418a0c30704aafc6f6aadb75b873da74">00249</a> bool <a class="code" href="a00057.html#418a0c30704aafc6f6aadb75b873da74">operator > </a>(const <a class="code" href="a00057.html" title="Base class for all iterators.">iterator_base</a>& it) const

274

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

275

<a name="l00251"></a>00251 return <a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> > it.<a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>;

276

<a name="l00252"></a>00252 }

277

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

278

<a name="l00254"></a><a class="code" href="a00057.html#227f59d61fc06bd398a1d282c94edb92">00254</a> bool <a class="code" href="a00057.html#227f59d61fc06bd398a1d282c94edb92">operator >= </a>(const <a class="code" href="a00057.html" title="Base class for all iterators.">iterator_base</a>& it) const

279

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

280

<a name="l00256"></a>00256 return <a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> >= it.<a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>;

281

<a name="l00257"></a>00257 }

282

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

283

<a name="l00259"></a>00259 /**

284

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

285

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

286

<a name="l00262"></a>00262 \returns true if iterator is valid.

287

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

288

<a name="l00264"></a><a class="code" href="a00057.html#a06eb362d550d37b214591a113be4e7b">00264</a> bool <a class="code" href="a00057.html#a06eb362d550d37b214591a113be4e7b" title="Checks if iterator is still valid.">valid</a>() const

289

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

290

<a name="l00266"></a>00266 return <a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> != <a class="code" href="a00088.html#104b924a1df81542db2a6296fbf26a65">bm::id_max</a>;

291

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

292

<a name="l00268"></a>00268

293

<a name="l00269"></a>00269 /**

294

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

295

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

296

<a name="l00272"></a>00272 */

297

<a name="l00273"></a><a class="code" href="a00057.html#5566e1be1039764a8f4643f38b9d8f9e">00273</a> void <a class="code" href="a00057.html#5566e1be1039764a8f4643f38b9d8f9e" title="Turns iterator into an invalid state.">invalidate</a>()

298

<a name="l00274"></a>00274 {

299

<a name="l00275"></a>00275 <a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> = <a class="code" href="a00088.html#104b924a1df81542db2a6296fbf26a65">bm::id_max</a>;

300

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

301

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

302

<a name="l00278"></a>00278 public:

303

<a name="l00279"></a>00279

304

<a name="l00280"></a>00280 /** Information about current bitblock. */

305

<a name="l00281"></a><a class="code" href="a00027.html">00281</a> struct <a class="code" href="a00027.html" title="Information about current bitblock.">bitblock_descr</a>

306

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

307

<a name="l00283"></a><a class="code" href="a00027.html#1493d1dde691bc56ac4fdd31ad8206b6">00283</a> const <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* <a class="code" href="a00027.html#1493d1dde691bc56ac4fdd31ad8206b6" title="Word pointer.">ptr</a>; //!< Word pointer.

308

<a name="l00284"></a><a class="code" href="a00027.html#98b3ad31436094a6709f012bdac61f58">00284</a> unsigned <a class="code" href="a00027.html#98b3ad31436094a6709f012bdac61f58" title="Unpacked list of ON bits.">bits</a>[32]; //!< Unpacked list of ON bits

309

<a name="l00285"></a><a class="code" href="a00027.html#fa87824f495bddbc2b835193e524630e">00285</a> unsigned <a class="code" href="a00027.html#fa87824f495bddbc2b835193e524630e" title="Current position in the bit list.">idx</a>; //!< Current position in the bit list

310

<a name="l00286"></a><a class="code" href="a00027.html#8f005df34342398c3ec65aa3f6f57db0">00286</a> unsigned <a class="code" href="a00027.html#8f005df34342398c3ec65aa3f6f57db0" title="Number of ON bits.">cnt</a>; //!< Number of ON bits

311

<a name="l00287"></a><a class="code" href="a00027.html#b83089689e5235239ebc50731e3d3c84">00287</a> <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00027.html#b83089689e5235239ebc50731e3d3c84" title="Last bit position before.">pos</a>; //!< Last bit position before

312

<a name="l00288"></a>00288 };

313

<a name="l00289"></a>00289

314

<a name="l00290"></a>00290 /** Information about current DGAP block. */

315

<a name="l00291"></a><a class="code" href="a00049.html">00291</a> struct <a class="code" href="a00049.html" title="Information about current DGAP block.">dgap_descr</a>

316

<a name="l00292"></a>00292 {

317

<a name="l00293"></a><a class="code" href="a00049.html#06ab78e3b3b9c52de9b491dc2ad3a72f">00293</a> const <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>* <a class="code" href="a00049.html#06ab78e3b3b9c52de9b491dc2ad3a72f" title="Word pointer.">ptr</a>; //!< Word pointer.

318

<a name="l00294"></a><a class="code" href="a00049.html#f7766714caa1c9cb00750cd8b91314c2">00294</a> <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a> <a class="code" href="a00049.html#f7766714caa1c9cb00750cd8b91314c2" title="Current dgap length.">gap_len</a>; //!< Current dgap length.

319

<a name="l00295"></a>00295 };

320

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

321

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

322

<a name="l00298"></a><a class="code" href="a00057.html#d341d73f3dc97bb5e70befcae7cbf014">00298</a> <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>* <a class="code" href="a00057.html#d341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a>; //!< Pointer on parent bitvector

323

<a name="l00299"></a><a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9">00299</a> <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>; //!< Bit position (bit idx)

324

<a name="l00300"></a><a class="code" href="a00057.html#6d92e5c216b76dfbccbc2ebab1dd7b8d">00300</a> const <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* <a class="code" href="a00057.html#6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a>; //!< Block pointer.(NULL-invalid)

325

<a name="l00301"></a><a class="code" href="a00057.html#8a9a7fa7ba70eb1aa10180e40239fe7f">00301</a> unsigned <a class="code" href="a00057.html#8a9a7fa7ba70eb1aa10180e40239fe7f" title="Type of block. 0-Bit, 1-GAP.">block_type_</a>; //!< Type of block. 0-Bit, 1-GAP

326

<a name="l00302"></a><a class="code" href="a00057.html#07908a3bcc023120e8bbf4e81ba62139">00302</a> unsigned <a class="code" href="a00057.html#07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a>; //!< Block index

327

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

328

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

329

<a name="l00305"></a><a class="code" href="a00032.html">00305</a> union <a class="code" href="a00032.html">block_descr</a>

330

<a name="l00306"></a>00306 {

331

<a name="l00307"></a><a class="code" href="a00032.html#9e021a3ef144c7b26fa295ad4b64e164">00307</a> <a class="code" href="a00027.html" title="Information about current bitblock.">bitblock_descr</a> <a class="code" href="a00032.html#9e021a3ef144c7b26fa295ad4b64e164" title="BitBlock related info.">bit_</a>; //!< BitBlock related info.

332

<a name="l00308"></a><a class="code" href="a00032.html#00fd9ec3340550372d0d06865ce96e43">00308</a> <a class="code" href="a00049.html" title="Information about current DGAP block.">dgap_descr</a> <a class="code" href="a00032.html#00fd9ec3340550372d0d06865ce96e43" title="DGAP block related info.">gap_</a>; //!< DGAP block related info.

333

<a name="l00309"></a>00309 } <a class="code" href="a00057.html#47ba31f695597a948e7e18971f5c6236">bdescr_</a>;

334

<a name="l00310"></a>00310 };

335

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

336

<a name="l00312"></a>00312 /*!

337

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

338

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

339

<a name="l00315"></a>00315

340

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

341

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

342

<a name="l00318"></a>00318 (set_bit does not do that).

343

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

344

<a name="l00320"></a>00320 @note

345

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

346

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

347

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

348

<a name="l00324"></a>00324

349

<a name="l00325"></a>00325 @ingroup bvector

350

<a name="l00326"></a>00326 */

351

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

352

<a name="l00328"></a>00328 {

353

<a name="l00329"></a>00329 public:

354

<a name="l00330"></a>00330 #ifndef BM_NO_STL

355

<a name="l00331"></a><a class="code" href="a00056.html#05191a66ec380649000b9b6ea14c06b7">00331</a> typedef std::output_iterator_tag <a class="code" href="a00056.html#05191a66ec380649000b9b6ea14c06b7">iterator_category</a>;

356

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

357

<a name="l00333"></a><a class="code" href="a00056.html#c4e9f9614f7075703835fb78b4898c9b">00333</a> typedef unsigned <a class="code" href="a00056.html#c4e9f9614f7075703835fb78b4898c9b">value_type</a>;

358

<a name="l00334"></a><a class="code" href="a00056.html#77f5e1410a06a9c0b8800c8dc9a8e7fa">00334</a> typedef void <a class="code" href="a00056.html#77f5e1410a06a9c0b8800c8dc9a8e7fa">difference_type</a>;

359

<a name="l00335"></a><a class="code" href="a00056.html#0751c5e25531fac92a3b8be471ae2ffc">00335</a> typedef void <a class="code" href="a00056.html#0751c5e25531fac92a3b8be471ae2ffc">pointer</a>;

360

<a name="l00336"></a><a class="code" href="a00056.html#7b51421d9465b502e0fade68b788bb04">00336</a> typedef void <a class="code" href="a00064.html" title="Class reference implements an object for bit assignment.">reference</a>;

361

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

362

<a name="l00338"></a><a class="code" href="a00056.html#d0a9fbadaeac7315d837d180f09dc737">00338</a> <a class="code" href="a00056.html#d0a9fbadaeac7315d837d180f09dc737">insert_iterator</a>(<a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvect</a>)

363

<a name="l00339"></a>00339 : <a class="code" href="a00056.html#d6d883a5f4e66f397cc0ef2a71255032">bvect_</a>(bvect),

364

<a name="l00340"></a>00340 <a class="code" href="a00056.html#2a3cb7001d4469b6b0491105dfd443c0">max_bit_</a>(bvect.<a class="code" href="a00036.html#1b021e7217f530390511e16b9b25f631" title="return current size of the vector (bits)">size</a>())

365

<a name="l00341"></a>00341 {

366

<a name="l00342"></a>00342 }

367

<a name="l00343"></a>00343

368

<a name="l00344"></a><a class="code" href="a00056.html#9f670d7a141a161b171930416621794a">00344</a> <a class="code" href="a00056.html" title="Output iterator iterator designed to set &quot;ON&quot; bits based on input sequence...">insert_iterator</a>& <a class="code" href="a00056.html#9f670d7a141a161b171930416621794a">operator=</a>(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n)

369

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

370

<a name="l00346"></a>00346 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(n < <a class="code" href="a00088.html#104b924a1df81542db2a6296fbf26a65">bm::id_max</a>);

371

<a name="l00347"></a>00347

372

<a name="l00348"></a>00348 if (n >= <a class="code" href="a00056.html#2a3cb7001d4469b6b0491105dfd443c0">max_bit_</a>)

373

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

374

<a name="l00350"></a>00350 <a class="code" href="a00056.html#2a3cb7001d4469b6b0491105dfd443c0">max_bit_</a> = n;

375

<a name="l00351"></a>00351 if (n >= <a class="code" href="a00056.html#d6d883a5f4e66f397cc0ef2a71255032">bvect_</a>.size())

376

<a name="l00352"></a>00352 {

377

<a name="l00353"></a>00353 <a class="code" href="a00056.html#d6d883a5f4e66f397cc0ef2a71255032">bvect_</a>.resize(n + 1);

378

<a name="l00354"></a>00354 }

379

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

380

<a name="l00356"></a>00356

381

<a name="l00357"></a>00357 <a class="code" href="a00056.html#d6d883a5f4e66f397cc0ef2a71255032">bvect_</a>.set(n);

382

<a name="l00358"></a>00358 return *this;

383

<a name="l00359"></a>00359 }

384

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

385

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

386

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

387

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

388

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

389

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

390

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

391

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

392

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

393

<a name="l00369"></a><a class="code" href="a00056.html#d6d883a5f4e66f397cc0ef2a71255032">00369</a> <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00056.html#d6d883a5f4e66f397cc0ef2a71255032">bvect_</a>;

394

<a name="l00370"></a><a class="code" href="a00056.html#2a3cb7001d4469b6b0491105dfd443c0">00370</a> <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00056.html#2a3cb7001d4469b6b0491105dfd443c0">max_bit_</a>;

395

<a name="l00371"></a>00371 };

396

<a name="l00372"></a>00372

397

<a name="l00373"></a>00373 /*!

398

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

399

<a name="l00375"></a>00375 @ingroup bvector

400

<a name="l00376"></a>00376 */

401

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

402

<a name="l00378"></a>00378 {

403

<a name="l00379"></a>00379 public:

404

<a name="l00380"></a>00380 #ifndef BM_NO_STL

405

<a name="l00381"></a><a class="code" href="a00051.html#0af72b4644bc1148f549d21a00330210">00381</a> typedef std::input_iterator_tag <a class="code" href="a00051.html#0af72b4644bc1148f549d21a00330210">iterator_category</a>;

406

<a name="l00382"></a>00382 #endif

407

<a name="l00383"></a><a class="code" href="a00051.html#dd1a3fd37bf2915c5689733969d9ce78">00383</a> typedef unsigned <a class="code" href="a00051.html#dd1a3fd37bf2915c5689733969d9ce78">value_type</a>;

408

<a name="l00384"></a><a class="code" href="a00051.html#46bd8935b22e5a83be62e9e8e00785e1">00384</a> typedef unsigned <a class="code" href="a00051.html#46bd8935b22e5a83be62e9e8e00785e1">difference_type</a>;

409

<a name="l00385"></a><a class="code" href="a00051.html#da062866d44923ecab233a51f4daf26e">00385</a> typedef unsigned* <a class="code" href="a00051.html#da062866d44923ecab233a51f4daf26e">pointer</a>;

410

<a name="l00386"></a><a class="code" href="a00051.html#827edd466230259a8047f2c26baf830f">00386</a> typedef unsigned& <a class="code" href="a00064.html" title="Class reference implements an object for bit assignment.">reference</a>;

411

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

412

<a name="l00388"></a>00388 public:

413

<a name="l00389"></a><a class="code" href="a00051.html#4389008f0affee77ef761cab3e5d0f5d">00389</a> <a class="code" href="a00051.html#4389008f0affee77ef761cab3e5d0f5d">enumerator</a>() : <a class="code" href="a00057.html" title="Base class for all iterators.">iterator_base</a>() {}

414

<a name="l00390"></a><a class="code" href="a00051.html#9f59ce31704b3fe71cf41dc4eeffbd43">00390</a> <a class="code" href="a00051.html#4389008f0affee77ef761cab3e5d0f5d">enumerator</a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>* <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvect</a>, int position)

415

<a name="l00391"></a>00391 : <a class="code" href="a00057.html" title="Base class for all iterators.">iterator_base</a>()

416

<a name="l00392"></a>00392 {

417

<a name="l00393"></a>00393 this-><a class="code" href="a00057.html#d341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a> = const_cast<<a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>*>(bvect);

418

<a name="l00394"></a>00394 if (position == 0)

419

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

420

<a name="l00396"></a>00396 <a class="code" href="a00051.html#7443e66e31258638cdee4ed3bc2d368c">go_first</a>();

421

<a name="l00397"></a>00397 }

422

<a name="l00398"></a>00398 else

423

<a name="l00399"></a>00399 {

424

<a name="l00400"></a>00400 this-><a class="code" href="a00057.html#5566e1be1039764a8f4643f38b9d8f9e" title="Turns iterator into an invalid state.">invalidate</a>();

425

<a name="l00401"></a>00401 }

426

<a name="l00402"></a>00402 }

427

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

428

<a name="l00404"></a><a class="code" href="a00051.html#dc85b4fca8577fa3ab643fd087948f1b">00404</a> <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00051.html#dc85b4fca8577fa3ab643fd087948f1b">operator*</a>() const

429

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

430

<a name="l00406"></a>00406 return this-><a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>;

431

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

432

<a name="l00408"></a>00408

433

<a name="l00409"></a><a class="code" href="a00051.html#ab2b31ecf11e614cf2de6eab71d92512">00409</a> <a class="code" href="a00051.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a>& <a class="code" href="a00051.html#ab2b31ecf11e614cf2de6eab71d92512">operator++</a>()

434

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

435

<a name="l00411"></a>00411 return this-><a class="code" href="a00051.html#58b4ee025ba7b6545eacad79e7031069">go_up</a>();

436

<a name="l00412"></a>00412 }

437

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

438

<a name="l00414"></a><a class="code" href="a00051.html#1237d3258c73d41e93159063fb2708a0">00414</a> <a class="code" href="a00051.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a> <a class="code" href="a00051.html#ab2b31ecf11e614cf2de6eab71d92512">operator++</a>(int)

439

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

440

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

441

<a name="l00417"></a>00417 this-><a class="code" href="a00051.html#58b4ee025ba7b6545eacad79e7031069">go_up</a>();

442

<a name="l00418"></a>00418 return tmp;

443

<a name="l00419"></a>00419 }

444

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

445

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

446

<a name="l00422"></a><a class="code" href="a00051.html#7443e66e31258638cdee4ed3bc2d368c">00422</a> void <a class="code" href="a00051.html#7443e66e31258638cdee4ed3bc2d368c">go_first</a>()

447

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

448

<a name="l00424"></a>00424 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(this-><a class="code" href="a00057.html#d341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a>);

449

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

450

<a name="l00426"></a>00426 #ifdef BMCOUNTOPT

451

<a name="l00427"></a>00427 if (this-><a class="code" href="a00057.html#d341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a>->count_is_valid_ &&

452

<a name="l00428"></a>00428 this->bv_->count_ == 0)

453

<a name="l00429"></a>00429 {

454

<a name="l00430"></a>00430 this-><a class="code" href="a00057.html#5566e1be1039764a8f4643f38b9d8f9e" title="Turns iterator into an invalid state.">invalidate</a>();

455

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

456

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

457

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

458

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

459

<a name="l00435"></a>00435 <a class="code" href="a00036.html#1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>* bman = &(this-><a class="code" href="a00057.html#d341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a>->blockman_);

460

<a name="l00436"></a>00436 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*** blk_root = bman->blocks_root();

461

<a name="l00437"></a>00437

462

<a name="l00438"></a>00438 this-><a class="code" href="a00057.html#07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a> = this-><a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>= 0;

463

<a name="l00439"></a>00439 unsigned i, j;

464

<a name="l00440"></a>00440

465

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

466

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

467

<a name="l00443"></a>00443 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>** blk_blk = blk_root[i];

468

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

469

<a name="l00445"></a>00445 if (blk_blk == 0) // not allocated

470

<a name="l00446"></a>00446 {

471

<a name="l00447"></a>00447 this-><a class="code" href="a00057.html#07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a> += <a class="code" href="a00088.html#40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>;

472

<a name="l00448"></a>00448 this-><a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += <a class="code" href="a00088.html#4dedd13a7b8a27c5067b20118002f025">bm::bits_in_array</a>;

473

<a name="l00449"></a>00449 continue;

474

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

475

<a name="l00451"></a>00451

476

<a name="l00452"></a>00452

477

<a name="l00453"></a>00453 for (j = 0; j < <a class="code" href="a00088.html#40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>; ++j,++(this-><a class="code" href="a00057.html#07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a>))

478

<a name="l00454"></a>00454 {

479

<a name="l00455"></a>00455 this-><a class="code" href="a00057.html#6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a> = blk_blk[j];

480

<a name="l00456"></a>00456

481

<a name="l00457"></a>00457 if (this-><a class="code" href="a00057.html#6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a> == 0)

482

<a name="l00458"></a>00458 {

483

<a name="l00459"></a>00459 this-><a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += <a class="code" href="a00088.html#e9916f69ced0347d94472d7944ea0e45">bits_in_block</a>;

484

<a name="l00460"></a>00460 continue;

485

<a name="l00461"></a>00461 }

486

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

487

<a name="l00463"></a>00463 if (<a class="code" href="a00072.html#862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>((*bman), this-><a class="code" href="a00057.html#6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a>, this-><a class="code" href="a00057.html#07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a>))

488

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

489

<a name="l00465"></a>00465 this-><a class="code" href="a00057.html#8a9a7fa7ba70eb1aa10180e40239fe7f" title="Type of block. 0-Bit, 1-GAP.">block_type_</a> = 1;

490

<a name="l00466"></a>00466 if (search_in_gapblock())

491

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

492

<a name="l00468"></a>00468 return;

493

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

494

<a name="l00470"></a>00470 }

495

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

496

<a name="l00472"></a>00472 {

497

<a name="l00473"></a>00473 this-><a class="code" href="a00057.html#8a9a7fa7ba70eb1aa10180e40239fe7f" title="Type of block. 0-Bit, 1-GAP.">block_type_</a> = 0;

498

<a name="l00474"></a>00474 if (search_in_bitblock())

499

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

500

<a name="l00476"></a>00476 return;

501

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

502

<a name="l00478"></a>00478 }

503

<a name="l00479"></a>00479

504

<a name="l00480"></a>00480 } // for j

505

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

506

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

507

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

508

<a name="l00484"></a>00484 this-><a class="code" href="a00057.html#5566e1be1039764a8f4643f38b9d8f9e" title="Turns iterator into an invalid state.">invalidate</a>();

509

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

510

<a name="l00486"></a>00486

511

<a name="l00487"></a><a class="code" href="a00051.html#58b4ee025ba7b6545eacad79e7031069">00487</a> <a class="code" href="a00051.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a>& <a class="code" href="a00051.html#58b4ee025ba7b6545eacad79e7031069">go_up</a>()

512

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

513

<a name="l00489"></a>00489 // Current block search.

514

<a name="l00490"></a>00490 ++this-><a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>;

515

<a name="l00491"></a>00491 typedef typename <a class="code" href="a00032.html">iterator_base::block_descr</a> block_descr_type;

516

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

517

<a name="l00493"></a>00493 block_descr_type* bdescr = &(this-><a class="code" href="a00057.html#47ba31f695597a948e7e18971f5c6236">bdescr_</a>);

518

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

519

<a name="l00495"></a>00495 switch (this-><a class="code" href="a00057.html#8a9a7fa7ba70eb1aa10180e40239fe7f" title="Type of block. 0-Bit, 1-GAP.">block_type_</a>)

520

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

521

<a name="l00497"></a>00497 case 0: // BitBlock

522

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

523

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

524

<a name="l00500"></a>00500 // check if we can get the value from the

525

<a name="l00501"></a>00501 // bits cache

526

<a name="l00502"></a>00502

527

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

528

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

529

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

530

<a name="l00506"></a>00506 this-><a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> = bdescr->bit_.pos +

531

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

532

<a name="l00508"></a>00508 return *this;

533

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

534

<a name="l00510"></a>00510 this-><a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += 31 - bdescr->bit_.bits[--idx];

535

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

536

<a name="l00512"></a>00512 const <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* pend = this-><a class="code" href="a00057.html#6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a> + <a class="code" href="a00088.html#91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a>;

537

<a name="l00513"></a>00513

538

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

539

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

540

<a name="l00516"></a>00516 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a> w = *(bdescr->bit_.ptr);

541

<a name="l00517"></a>00517 if (w)

542

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

543

<a name="l00519"></a>00519 bdescr->bit_.idx = 0;

544

<a name="l00520"></a>00520 bdescr->bit_.pos = this-><a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>;

545

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

546

<a name="l00522"></a>00522 this-><a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += bdescr->bit_.bits[0];

547

<a name="l00523"></a>00523 return *this;

548

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

549

<a name="l00525"></a>00525 else

550

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

551

<a name="l00527"></a>00527 this-><a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += 32;

552

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

553

<a name="l00529"></a>00529 }

554

<a name="l00530"></a>00530

555

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

556

<a name="l00532"></a>00532 break;

557

<a name="l00533"></a>00533

558

<a name="l00534"></a>00534 case 1: // DGAP Block

559

<a name="l00535"></a>00535 {

560

<a name="l00536"></a>00536 if (--(bdescr->gap_.gap_len))

561

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

562

<a name="l00538"></a>00538 return *this;

563

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

564

<a name="l00540"></a>00540

565

<a name="l00541"></a>00541 // next gap is "OFF" by definition.

566

<a name="l00542"></a>00542 if (*(bdescr->gap_.ptr) == <a class="code" href="a00088.html#d0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a> - 1)

567

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

568

<a name="l00544"></a>00544 break;

569

<a name="l00545"></a>00545 }

570

<a name="l00546"></a>00546 <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a> prev = *(bdescr->gap_.ptr);

571

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

572

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

573

<a name="l00549"></a>00549 this-><a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += val - prev;

574

<a name="l00550"></a>00550 // next gap is now "ON"

575

<a name="l00551"></a>00551

576

<a name="l00552"></a>00552 if (*(bdescr->gap_.ptr) == <a class="code" href="a00088.html#d0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a> - 1)

577

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

578

<a name="l00554"></a>00554 break;

579

<a name="l00555"></a>00555 }

580

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

581

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

582

<a name="l00558"></a>00558 bdescr->gap_.gap_len = val - prev;

583

<a name="l00559"></a>00559 return *this; // next "ON" found;

584

<a name="l00560"></a>00560 }

585

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

586

<a name="l00562"></a>00562 default:

587

<a name="l00563"></a>00563 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(0);

588

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

589

<a name="l00565"></a>00565 } // switch

590

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

591

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

592

<a name="l00568"></a>00568 // next bit not present in the current block

593

<a name="l00569"></a>00569 // keep looking in the next blocks.

594

<a name="l00570"></a>00570 ++(this-><a class="code" href="a00057.html#07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a>);

595

<a name="l00571"></a>00571 unsigned i = this-><a class="code" href="a00057.html#07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a> >> <a class="code" href="a00088.html#c1ff8647a089c751ec330cecee01907e">bm::set_array_shift</a>;

596

<a name="l00572"></a>00572 unsigned top_block_size = this-><a class="code" href="a00057.html#d341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a>->blockman_.top_block_size();

597

<a name="l00573"></a>00573 for (; i < top_block_size; ++i)

598

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

599

<a name="l00575"></a>00575 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>** blk_blk = this-><a class="code" href="a00057.html#d341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a>->blockman_.blocks_root()[i];

600

<a name="l00576"></a>00576 if (blk_blk == 0)

601

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

602

<a name="l00578"></a>00578 this-><a class="code" href="a00057.html#07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a> += <a class="code" href="a00088.html#40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>;

603

<a name="l00579"></a>00579 this-><a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += <a class="code" href="a00088.html#4dedd13a7b8a27c5067b20118002f025">bm::bits_in_array</a>;

604

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

605

<a name="l00581"></a>00581 }

606

<a name="l00582"></a>00582

607

<a name="l00583"></a>00583 unsigned j = this-><a class="code" href="a00057.html#07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a> & <a class="code" href="a00088.html#00ffa7b38d7fcc7e522d864991a6de68">bm::set_array_mask</a>;

608

<a name="l00584"></a>00584

609

<a name="l00585"></a>00585 for(; j < <a class="code" href="a00088.html#40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>; ++j, ++(this-><a class="code" href="a00057.html#07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a>))

610

<a name="l00586"></a>00586 {

611

<a name="l00587"></a>00587 this-><a class="code" href="a00057.html#6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a> = blk_blk[j];

612

<a name="l00588"></a>00588

613

<a name="l00589"></a>00589 if (this-><a class="code" href="a00057.html#6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a> == 0)

614

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

615

<a name="l00591"></a>00591 this-><a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += <a class="code" href="a00088.html#e9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a>;

616

<a name="l00592"></a>00592 continue;

617

<a name="l00593"></a>00593 }

618

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

619

<a name="l00595"></a>00595 if (<a class="code" href="a00072.html#862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>((this-><a class="code" href="a00057.html#d341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a>->blockman_),

620

<a name="l00596"></a>00596 this->block_,

621

<a name="l00597"></a>00597 this->block_idx_))

622

<a name="l00598"></a>00598 {

623

<a name="l00599"></a>00599 this-><a class="code" href="a00057.html#8a9a7fa7ba70eb1aa10180e40239fe7f" title="Type of block. 0-Bit, 1-GAP.">block_type_</a> = 1;

624

<a name="l00600"></a>00600 if (search_in_gapblock())

625

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

626

<a name="l00602"></a>00602 return *this;

627

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

628

<a name="l00604"></a>00604 }

629

<a name="l00605"></a>00605 else

630

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

631

<a name="l00607"></a>00607 this-><a class="code" href="a00057.html#8a9a7fa7ba70eb1aa10180e40239fe7f" title="Type of block. 0-Bit, 1-GAP.">block_type_</a> = 0;

632

<a name="l00608"></a>00608 if (search_in_bitblock())

633

<a name="l00609"></a>00609 {

634

<a name="l00610"></a>00610 return *this;

635

<a name="l00611"></a>00611 }

636

<a name="l00612"></a>00612 }

637

<a name="l00613"></a>00613

638

<a name="l00614"></a>00614

639

<a name="l00615"></a>00615 } // for j

640

<a name="l00616"></a>00616

641

<a name="l00617"></a>00617 } // for i

642

<a name="l00618"></a>00618

643

<a name="l00619"></a>00619

644

<a name="l00620"></a>00620 this-><a class="code" href="a00057.html#5566e1be1039764a8f4643f38b9d8f9e" title="Turns iterator into an invalid state.">invalidate</a>();

645

<a name="l00621"></a>00621 return *this;

646

<a name="l00622"></a>00622 }

647

<a name="l00623"></a>00623

648

<a name="l00624"></a>00624

649

<a name="l00625"></a>00625 private:

650

<a name="l00626"></a>00626 bool search_in_bitblock()

651

<a name="l00627"></a>00627 {

652

<a name="l00628"></a>00628 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(this-><a class="code" href="a00057.html#8a9a7fa7ba70eb1aa10180e40239fe7f" title="Type of block. 0-Bit, 1-GAP.">block_type_</a> == 0);

653

<a name="l00629"></a>00629

654

<a name="l00630"></a>00630 typedef typename <a class="code" href="a00032.html">iterator_base::block_descr</a> block_descr_type;

655

<a name="l00631"></a>00631 block_descr_type* bdescr = &(this-><a class="code" href="a00057.html#47ba31f695597a948e7e18971f5c6236">bdescr_</a>);

656

<a name="l00632"></a>00632

657

<a name="l00633"></a>00633 // now lets find the first bit in block.

658

<a name="l00634"></a>00634 bdescr->bit_.ptr = this-><a class="code" href="a00057.html#6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a>;

659

<a name="l00635"></a>00635

660

<a name="l00636"></a>00636 const <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">word_t</a>* ptr_end = this-><a class="code" href="a00057.html#6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a> + <a class="code" href="a00088.html#91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a>;

661

<a name="l00637"></a>00637

662

<a name="l00638"></a>00638 do

663

<a name="l00639"></a>00639 {

664

<a name="l00640"></a>00640 register <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a> w = *(bdescr->bit_.ptr);

665

<a name="l00641"></a>00641

666

<a name="l00642"></a>00642 if (w)

667

<a name="l00643"></a>00643 {

668

<a name="l00644"></a>00644 bdescr->bit_.idx = 0;

669

<a name="l00645"></a>00645 bdescr->bit_.pos = this-><a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>;

670

<a name="l00646"></a>00646 bdescr->bit_.cnt =

671

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

672

<a name="l00648"></a>00648 this-><a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += bdescr->bit_.bits[0];

673

<a name="l00649"></a>00649

674

<a name="l00650"></a>00650 return true;

675

<a name="l00651"></a>00651 }

676

<a name="l00652"></a>00652 else

677

<a name="l00653"></a>00653 {

678

<a name="l00654"></a>00654 this-><a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += 32;

679

<a name="l00655"></a>00655 }

680

<a name="l00656"></a>00656

681

<a name="l00657"></a>00657 }

682

<a name="l00658"></a>00658 while (++(bdescr->bit_.ptr) < ptr_end);

683

<a name="l00659"></a>00659

684

<a name="l00660"></a>00660 return false;

685

<a name="l00661"></a>00661 }

686

<a name="l00662"></a>00662

687

<a name="l00663"></a>00663 bool search_in_gapblock()

688

<a name="l00664"></a>00664 {

689

<a name="l00665"></a>00665 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(this-><a class="code" href="a00057.html#8a9a7fa7ba70eb1aa10180e40239fe7f" title="Type of block. 0-Bit, 1-GAP.">block_type_</a> == 1);

690

<a name="l00666"></a>00666

691

<a name="l00667"></a>00667 typedef typename iterator_base::block_descr block_descr_type;

692

<a name="l00668"></a>00668 block_descr_type* bdescr = &(this-><a class="code" href="a00057.html#47ba31f695597a948e7e18971f5c6236">bdescr_</a>);

693

<a name="l00669"></a>00669

694

<a name="l00670"></a>00670 bdescr->gap_.ptr = <a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(this-><a class="code" href="a00057.html#6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a>);

695

<a name="l00671"></a>00671 unsigned bitval = *(bdescr->gap_.ptr) & 1;

696

<a name="l00672"></a>00672

697

<a name="l00673"></a>00673 ++(bdescr->gap_.ptr);

698

<a name="l00674"></a>00674

699

<a name="l00675"></a>00675 do

700

<a name="l00676"></a>00676 {

701

<a name="l00677"></a>00677 register unsigned val = *(bdescr->gap_.ptr);

702

<a name="l00678"></a>00678

703

<a name="l00679"></a>00679 if (bitval)

704

<a name="l00680"></a>00680 {

705

<a name="l00681"></a>00681 <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>* <a class="code" href="a00036.html#ad48c661f843e32c9893438a6f27a8f0" title="Returns enumerator pointing on the first non-zero bit.">first</a> = <a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(this-><a class="code" href="a00057.html#6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a>) + 1;

706

<a name="l00682"></a>00682 if (bdescr->gap_.ptr == first)

707

<a name="l00683"></a>00683 {

708

<a name="l00684"></a>00684 bdescr->gap_.gap_len = val + 1;

709

<a name="l00685"></a>00685 }

710

<a name="l00686"></a>00686 else

711

<a name="l00687"></a>00687 {

712

<a name="l00688"></a>00688 bdescr->gap_.gap_len =

713

<a name="l00689"></a>00689 val - *(bdescr->gap_.ptr-1);

714

<a name="l00690"></a>00690 }

715

<a name="l00691"></a>00691

716

<a name="l00692"></a>00692 return true;

717

<a name="l00693"></a>00693 }

718

<a name="l00694"></a>00694 this-><a class="code" href="a00057.html#9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += val + 1;

719

<a name="l00695"></a>00695

720

<a name="l00696"></a>00696 if (val == <a class="code" href="a00088.html#d0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a> - 1)

721

<a name="l00697"></a>00697 {

722

<a name="l00698"></a>00698 break;

723

<a name="l00699"></a>00699 }

724

<a name="l00700"></a>00700

725

<a name="l00701"></a>00701 bitval ^= 1;

726

<a name="l00702"></a>00702 ++(bdescr->gap_.ptr);

727

<a name="l00703"></a>00703

728

<a name="l00704"></a>00704 } while (1);

729

<a name="l00705"></a>00705

730

<a name="l00706"></a>00706 return false;

731

<a name="l00707"></a>00707 }

732

<a name="l00708"></a>00708

733

<a name="l00709"></a>00709 };

734

<a name="l00710"></a>00710

735

<a name="l00711"></a>00711 /*!

736

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

737

<a name="l00713"></a>00713 counted_enumerator keeps bitcount, ie number of ON bits starting

738

<a name="l00714"></a>00714 from the position 0 in the bit string up to the currently enumerated bit

739

<a name="l00715"></a>00715

740

<a name="l00716"></a>00716 When increment operator called current position is increased by 1.

741

<a name="l00717"></a>00717

742

<a name="l00718"></a>00718 @ingroup bvector

743

<a name="l00719"></a>00719 */

744

<a name="l00720"></a><a class="code" href="a00041.html">00720</a> class <a class="code" href="a00041.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits counted_enumerator...">counted_enumerator</a> : public <a class="code" href="a00051.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a>

745

<a name="l00721"></a>00721 {

746

<a name="l00722"></a>00722 public:

747

<a name="l00723"></a>00723 #ifndef BM_NO_STL

748

<a name="l00724"></a><a class="code" href="a00041.html#171919f2a88ab74fcea53f9f75225712">00724</a> typedef std::input_iterator_tag <a class="code" href="a00041.html#171919f2a88ab74fcea53f9f75225712">iterator_category</a>;

749

<a name="l00725"></a>00725 #endif

750

<a name="l00726"></a><a class="code" href="a00041.html#0a6f5329ef42122de9fcc754c0318cb6">00726</a> <a class="code" href="a00041.html#0a6f5329ef42122de9fcc754c0318cb6">counted_enumerator</a>() : bit_count_(0){}

751

<a name="l00727"></a>00727

752

<a name="l00728"></a><a class="code" href="a00041.html#4b0d8b4e7b7268707355b813434bcfcb">00728</a> <a class="code" href="a00041.html#0a6f5329ef42122de9fcc754c0318cb6">counted_enumerator</a>(const <a class="code" href="a00051.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a>& en)

753

<a name="l00729"></a>00729 : <a class="code" href="a00051.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a>(en)

754

<a name="l00730"></a>00730 {

755

<a name="l00731"></a>00731 if (this-><a class="code" href="a00057.html#a06eb362d550d37b214591a113be4e7b" title="Checks if iterator is still valid.">valid</a>())

756

<a name="l00732"></a>00732 bit_count_ = 1;

757

<a name="l00733"></a>00733 }

758

<a name="l00734"></a>00734

759

<a name="l00735"></a><a class="code" href="a00041.html#9e2badd4602a744f1df04de7d9249314">00735</a> <a class="code" href="a00041.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits counted_enumerator...">counted_enumerator</a>& <a class="code" href="a00041.html#9e2badd4602a744f1df04de7d9249314">operator=</a>(const <a class="code" href="a00051.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a>& en)

760

<a name="l00736"></a>00736 {

761

<a name="l00737"></a>00737 <a class="code" href="a00051.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a>* me = this;

762

<a name="l00738"></a>00738 *me = en;

763

<a name="l00739"></a>00739 if (this-><a class="code" href="a00057.html#a06eb362d550d37b214591a113be4e7b" title="Checks if iterator is still valid.">valid</a>())

764

<a name="l00740"></a>00740 this->bit_count_ = 1;

765

<a name="l00741"></a>00741 return *this;

766

<a name="l00742"></a>00742 }

767

<a name="l00743"></a>00743

768

<a name="l00744"></a><a class="code" href="a00041.html#65e58d9cb5ad45c89502c50e346c0f70">00744</a> <a class="code" href="a00041.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits counted_enumerator...">counted_enumerator</a>& <a class="code" href="a00041.html#65e58d9cb5ad45c89502c50e346c0f70">operator++</a>()

769

<a name="l00745"></a>00745 {

770

<a name="l00746"></a>00746 this-><a class="code" href="a00051.html#58b4ee025ba7b6545eacad79e7031069">go_up</a>();

771

<a name="l00747"></a>00747 if (this-><a class="code" href="a00057.html#a06eb362d550d37b214591a113be4e7b" title="Checks if iterator is still valid.">valid</a>())

772

<a name="l00748"></a>00748 ++(this->bit_count_);

773

<a name="l00749"></a>00749 return *this;

774

<a name="l00750"></a>00750 }

775

<a name="l00751"></a>00751

776

<a name="l00752"></a><a class="code" href="a00041.html#91b38c1ed0a8c913684ad02bcfd67b84">00752</a> <a class="code" href="a00041.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits counted_enumerator...">counted_enumerator</a> <a class="code" href="a00041.html#65e58d9cb5ad45c89502c50e346c0f70">operator++</a>(int)

777

<a name="l00753"></a>00753 {

778

<a name="l00754"></a>00754 <a class="code" href="a00041.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits counted_enumerator...">counted_enumerator</a> tmp(*this);

779

<a name="l00755"></a>00755 this-><a class="code" href="a00051.html#58b4ee025ba7b6545eacad79e7031069">go_up</a>();

780

<a name="l00756"></a>00756 if (this-><a class="code" href="a00057.html#a06eb362d550d37b214591a113be4e7b" title="Checks if iterator is still valid.">valid</a>())

781

<a name="l00757"></a>00757 ++bit_count_;

782

<a name="l00758"></a>00758 return tmp;

783

<a name="l00759"></a>00759 }

784

<a name="l00760"></a>00760

785

<a name="l00761"></a>00761 /*! @brief Number of bits ON starting from the .

786

<a name="l00762"></a>00762

787

<a name="l00763"></a>00763 Method returns number of ON bits fromn the bit 0 to the current bit

788

<a name="l00764"></a>00764 For the first bit in bitvector it is 1, for the second 2

789

<a name="l00765"></a>00765 */

790

<a name="l00766"></a><a class="code" href="a00041.html#61abf2ecf53823d347ea53adb3a8be4a">00766</a> <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00041.html#61abf2ecf53823d347ea53adb3a8be4a" title="Number of bits ON starting from the .">count</a>() const { return bit_count_; }

791

<a name="l00767"></a>00767

792

<a name="l00768"></a>00768 private:

793

<a name="l00769"></a>00769 <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> bit_count_;

794

<a name="l00770"></a>00770 };

795

<a name="l00771"></a>00771

796

<a name="l00772"></a><a class="code" href="a00036.html#eec1461fca400b5b4313765eb9e94c73">00772</a> friend class <a class="code" href="a00057.html" title="Base class for all iterators.">iterator_base</a>;

797

<a name="l00773"></a><a class="code" href="a00036.html#71cabca9670588878381f72d16e059b8">00773</a> friend class <a class="code" href="a00051.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a>;

798

<a name="l00774"></a>00774

799

<a name="l00775"></a>00775 public:

800

<a name="l00776"></a>00776

801

<a name="l00777"></a>00777 #ifdef BMCOUNTOPT

802

<a name="l00778"></a>00778 <a class="code" href="a00036.html#a2813ce4ce80ab8c6532e8b478b6d934" title="Constructs bvector class.">bvector</a>(<a class="code" href="a00091.html#gd0b87b3b7292383a864d27feaf1c9eff" title="Block allocation strategies.">strategy</a> strat = <a class="code" href="a00091.html#ggd0b87b3b7292383a864d27feaf1c9eff40920ae0ef7b4411d60463d8f576b5ba" title="No GAP compression strategy. All new blocks are bit blocks.">BM_BIT</a>,

803

<a name="l00779"></a>00779 const <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>* glevel_len = <a class="code" href="a00053.html" title="Default GAP lengths table.">bm::gap_len_table<true>::_len</a>,

804

<a name="l00780"></a>00780 <a class="code" href="a00036.html#ba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> bv_size = <a class="code" href="a00088.html#104b924a1df81542db2a6296fbf26a65">bm::id_max</a>,

805

<a name="l00781"></a>00781 const Alloc& alloc = Alloc())

806

<a name="l00782"></a>00782 : count_(0),

807

<a name="l00783"></a>00783 count_is_valid_(true),

808

<a name="l00784"></a>00784 blockman_(glevel_len, bv_size, alloc),

809

<a name="l00785"></a>00785 new_blocks_strat_(strat),

810

<a name="l00786"></a>00786 size_(bv_size)

811

<a name="l00787"></a>00787 {}

812

<a name="l00788"></a>00788

813

<a name="l00789"></a>00789 <a class="code" href="a00036.html#a2813ce4ce80ab8c6532e8b478b6d934" title="Constructs bvector class.">bvector</a>(<a class="code" href="a00036.html#ba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> bv_size,

814

<a name="l00790"></a>00790 <a class="code" href="a00091.html#gd0b87b3b7292383a864d27feaf1c9eff" title="Block allocation strategies.">bm::strategy</a> strat = <a class="code" href="a00091.html#ggd0b87b3b7292383a864d27feaf1c9eff40920ae0ef7b4411d60463d8f576b5ba" title="No GAP compression strategy. All new blocks are bit blocks.">BM_BIT</a>,

815

<a name="l00791"></a>00791 const <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>* glevel_len = <a class="code" href="a00053.html" title="Default GAP lengths table.">bm::gap_len_table<true>::_len</a>,

816

<a name="l00792"></a>00792 const Alloc& alloc = Alloc())

817

<a name="l00793"></a>00793 : count_(0),

818

<a name="l00794"></a>00794 count_is_valid_(true),

819

<a name="l00795"></a>00795 blockman_(glevel_len, bv_size, alloc),

820

<a name="l00796"></a>00796 new_blocks_strat_(strat),

821

<a name="l00797"></a>00797 size_(bv_size)

822

<a name="l00798"></a>00798 {}

823

<a name="l00799"></a>00799

824

<a name="l00800"></a>00800

825

<a name="l00801"></a>00801 <a class="code" href="a00036.html#a2813ce4ce80ab8c6532e8b478b6d934" title="Constructs bvector class.">bvector</a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvect</a>)

826

<a name="l00802"></a>00802 : count_(bvect.count_),

827

<a name="l00803"></a>00803 count_is_valid_(bvect.count_is_valid_),

828

<a name="l00804"></a>00804 blockman_(bvect.blockman_),

829

<a name="l00805"></a>00805 new_blocks_strat_(bvect.new_blocks_strat_),

830

<a name="l00806"></a>00806 size_(bvect.size_)

831

<a name="l00807"></a>00807 {}

832

<a name="l00808"></a>00808

833

<a name="l00809"></a>00809 #else

834

<a name="l00810"></a>00810 /*!

835

<a name="l00811"></a>00811 \brief Constructs bvector class

836

<a name="l00812"></a>00812 \param strat - operation mode strategy,

837

<a name="l00813"></a>00813 BM_BIT - default strategy, bvector use plain bitset

838

<a name="l00814"></a>00814 blocks, (performance oriented strategy).

839

<a name="l00815"></a>00815 BM_GAP - memory effitent strategy, bvector allocates

840

<a name="l00816"></a>00816 blocks as array of intervals(gaps) and convert blocks

841

<a name="l00817"></a>00817 into plain bitsets only when enthropy grows.

842

<a name="l00818"></a>00818 \param glevel_len

843

<a name="l00819"></a>00819 - pointer on C-style array keeping GAP block sizes.

844

<a name="l00820"></a>00820 (Put bm::gap_len_table_min<true>::_len for GAP memory saving mode)

845

<a name="l00821"></a>00821 \param bv_size

846

<a name="l00822"></a>00822 - bvector size (number of bits addressable by bvector), bm::id_max means

847

<a name="l00823"></a>00823 "no limits" (recommended).

848

<a name="l00824"></a>00824 bit vector allocates this space dynamically on demand.

849

<a name="l00825"></a>00825

850

<a name="l00826"></a>00826 \sa bm::gap_len_table bm::gap_len_table_min set_new_blocks_strat

851

<a name="l00827"></a>00827 */

852

<a name="l00828"></a><a class="code" href="a00036.html#a2813ce4ce80ab8c6532e8b478b6d934">00828</a> <a class="code" href="a00036.html#a2813ce4ce80ab8c6532e8b478b6d934" title="Constructs bvector class.">bvector</a>(<a class="code" href="a00091.html#gd0b87b3b7292383a864d27feaf1c9eff" title="Block allocation strategies.">strategy</a> strat = <a class="code" href="a00091.html#ggd0b87b3b7292383a864d27feaf1c9eff40920ae0ef7b4411d60463d8f576b5ba" title="No GAP compression strategy. All new blocks are bit blocks.">BM_BIT</a>,

853

<a name="l00829"></a>00829 const <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>* glevel_len = <a class="code" href="a00053.html" title="Default GAP lengths table.">bm::gap_len_table<true>::_len</a>,

854

<a name="l00830"></a>00830 <a class="code" href="a00036.html#ba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> bv_size = <a class="code" href="a00088.html#104b924a1df81542db2a6296fbf26a65">bm::id_max</a>,

855

<a name="l00831"></a>00831 const Alloc& alloc = Alloc())

856

<a name="l00832"></a>00832 : blockman_(glevel_len, bv_size, alloc),

857

<a name="l00833"></a>00833 new_blocks_strat_(strat),

858

<a name="l00834"></a>00834 size_(bv_size)

859

<a name="l00835"></a>00835 {}

860

<a name="l00836"></a>00836

861

<a name="l00837"></a>00837 /*!

862

<a name="l00838"></a>00838 \brief Constructs bvector class

863

<a name="l00839"></a>00839 */

864

<a name="l00840"></a><a class="code" href="a00036.html#3b95b73a26160b2b364e6e1e86167994">00840</a> <a class="code" href="a00036.html#a2813ce4ce80ab8c6532e8b478b6d934" title="Constructs bvector class.">bvector</a>(<a class="code" href="a00036.html#ba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> bv_size,

865

<a name="l00841"></a>00841 <a class="code" href="a00091.html#gd0b87b3b7292383a864d27feaf1c9eff" title="Block allocation strategies.">strategy</a> strat = <a class="code" href="a00091.html#ggd0b87b3b7292383a864d27feaf1c9eff40920ae0ef7b4411d60463d8f576b5ba" title="No GAP compression strategy. All new blocks are bit blocks.">BM_BIT</a>,

866

<a name="l00842"></a>00842 const <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>* glevel_len = <a class="code" href="a00053.html" title="Default GAP lengths table.">bm::gap_len_table<true>::_len</a>,

867

<a name="l00843"></a>00843 const Alloc& alloc = Alloc())

868

<a name="l00844"></a>00844 : blockman_(glevel_len, bv_size, alloc),

869

<a name="l00845"></a>00845 new_blocks_strat_(strat),

870

<a name="l00846"></a>00846 size_(bv_size)

871

<a name="l00847"></a>00847 {}

872

<a name="l00848"></a>00848

873

<a name="l00849"></a>00849

874

<a name="l00850"></a><a class="code" href="a00036.html#95752bab343fd1b5483043dbbec98a96">00850</a> <a class="code" href="a00036.html#a2813ce4ce80ab8c6532e8b478b6d934" title="Constructs bvector class.">bvector</a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvect</a>)

875

<a name="l00851"></a>00851 : blockman_(bvect.blockman_),

876

<a name="l00852"></a>00852 new_blocks_strat_(bvect.new_blocks_strat_),

877

<a name="l00853"></a>00853 size_(bvect.size_)

878

<a name="l00854"></a>00854 {}

879

<a name="l00855"></a>00855

880

<a name="l00856"></a>00856 #endif

881

<a name="l00857"></a>00857

882

<a name="l00858"></a><a class="code" href="a00036.html#d6d691215d7945d1eab58f55055f32ad">00858</a> <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector</a>& <a class="code" href="a00036.html#d6d691215d7945d1eab58f55055f32ad">operator=</a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvect</a>)

883

<a name="l00859"></a>00859 {

884

<a name="l00860"></a>00860 <a class="code" href="a00036.html#fe98c658c4ee54155e61f9bdfa7b9019" title="Clears every bit in the bitvector.">clear</a>(true); // memory free cleaning

885

<a name="l00861"></a>00861 <a class="code" href="a00036.html#7be4f9e0741f43869f4dcd9607736c0e" title="Change size of the bvector.">resize</a>(bvect.<a class="code" href="a00036.html#1b021e7217f530390511e16b9b25f631" title="return current size of the vector (bits)">size</a>());

886

<a name="l00862"></a>00862 <a class="code" href="a00036.html#0eacd87603f41a9aea2126810183f83a" title="Logical OR operation.">bit_or</a>(bvect);

887

<a name="l00863"></a>00863 return *this;

888

<a name="l00864"></a>00864 }

889

<a name="l00865"></a>00865

890

<a name="l00866"></a><a class="code" href="a00036.html#98a1223891cbd4e87245defb4e3f165e">00866</a> <a class="code" href="a00064.html" title="Class reference implements an object for bit assignment.">reference</a> <a class="code" href="a00036.html#98a1223891cbd4e87245defb4e3f165e">operator[]</a>(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n)

891

<a name="l00867"></a>00867 {

892

<a name="l00868"></a>00868 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(n < size_);

893

<a name="l00869"></a>00869 return <a class="code" href="a00064.html" title="Class reference implements an object for bit assignment.">reference</a>(*this, n);

894

<a name="l00870"></a>00870 }

895

<a name="l00871"></a>00871

896

<a name="l00872"></a>00872

897

<a name="l00873"></a><a class="code" href="a00036.html#3d71b08005a276991b031151e423760e">00873</a> bool <a class="code" href="a00036.html#98a1223891cbd4e87245defb4e3f165e">operator[]</a>(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n) const

898

<a name="l00874"></a>00874 {

899

<a name="l00875"></a>00875 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(n < size_);

900

<a name="l00876"></a>00876 return <a class="code" href="a00036.html#11458ca2e3570838da7b94a1e4563d97" title="returns true if bit n is set and false is bit n is 0.">get_bit</a>(n);

901

<a name="l00877"></a>00877 }

902

<a name="l00878"></a>00878

903

<a name="l00879"></a><a class="code" href="a00036.html#1259c399b970e6fa3715d74387e682c6">00879</a> void <a class="code" href="a00036.html#1259c399b970e6fa3715d74387e682c6">operator &= </a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvect</a>)

904

<a name="l00880"></a>00880 {

905

<a name="l00881"></a>00881 <a class="code" href="a00036.html#051a39027c3b12751f172c20f2d03a0f" title="Logical AND operation.">bit_and</a>(bvect);

906

<a name="l00882"></a>00882 }

907

<a name="l00883"></a>00883

908

<a name="l00884"></a><a class="code" href="a00036.html#3db27387f92cdfa4d883074d7bd525a6">00884</a> void <a class="code" href="a00036.html#3db27387f92cdfa4d883074d7bd525a6">operator ^= </a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvect</a>)

909

<a name="l00885"></a>00885 {

910

<a name="l00886"></a>00886 <a class="code" href="a00036.html#997a62ec2effcd60246fb9b72f30ccfa" title="Logical XOR operation.">bit_xor</a>(bvect);

911

<a name="l00887"></a>00887 }

912

<a name="l00888"></a>00888

913

<a name="l00889"></a><a class="code" href="a00036.html#0a708b4c4c0ac810bd5c4d1280200b10">00889</a> void <a class="code" href="a00036.html#0a708b4c4c0ac810bd5c4d1280200b10">operator |= </a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvect</a>)

914

<a name="l00890"></a>00890 {

915

<a name="l00891"></a>00891 <a class="code" href="a00036.html#0eacd87603f41a9aea2126810183f83a" title="Logical OR operation.">bit_or</a>(bvect);

916

<a name="l00892"></a>00892 }

917

<a name="l00893"></a>00893

918

<a name="l00894"></a><a class="code" href="a00036.html#ef8c3032b194d7c127f1a14ef9506fb8">00894</a> void <a class="code" href="a00036.html#ef8c3032b194d7c127f1a14ef9506fb8">operator -= </a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvect</a>)

919

<a name="l00895"></a>00895 {

920

<a name="l00896"></a>00896 <a class="code" href="a00036.html#6a8e699f9c0571f904d7cbaa2e3ed1f1" title="Logical SUB operation.">bit_sub</a>(bvect);

921

<a name="l00897"></a>00897 }

922

<a name="l00898"></a>00898

923

<a name="l00899"></a><a class="code" href="a00036.html#278768eb0518183740f172628fe57976">00899</a> bool operator < (const bvector<Alloc, MS>& <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvect</a>) const

924

<a name="l00900"></a>00900 {

925

<a name="l00901"></a>00901 return <a class="code" href="a00036.html#a2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">compare</a>(<a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvect</a>) < 0;

926

<a name="l00902"></a>00902 }

927

<a name="l00903"></a>00903

928

<a name="l00904"></a><a class="code" href="a00036.html#d8ca63ae760dd647ad1dbdc9e489a046">00904</a> bool operator <= (const bvector<Alloc, MS>& <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvect</a>) const

929

<a name="l00905"></a>00905 {

930

<a name="l00906"></a>00906 return <a class="code" href="a00036.html#a2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">compare</a>(<a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvect</a>) <= 0;

931

<a name="l00907"></a>00907 }

932

<a name="l00908"></a>00908

933

<a name="l00909"></a><a class="code" href="a00036.html#3cf8dfe14ae27d78cb3c0bb90c2b6f19">00909</a> bool <a class="code" href="a00036.html#3cf8dfe14ae27d78cb3c0bb90c2b6f19">operator > </a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvect</a>) const

934

<a name="l00910"></a>00910 {

935

<a name="l00911"></a>00911 return <a class="code" href="a00036.html#a2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">compare</a>(bvect) > 0;

936

<a name="l00912"></a>00912 }

937

<a name="l00913"></a>00913

938

<a name="l00914"></a><a class="code" href="a00036.html#c1946edc275e405998e986d210c6c829">00914</a> bool <a class="code" href="a00036.html#c1946edc275e405998e986d210c6c829">operator >= </a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvect</a>) const

939

<a name="l00915"></a>00915 {

940

<a name="l00916"></a>00916 return <a class="code" href="a00036.html#a2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">compare</a>(bvect) >= 0;

941

<a name="l00917"></a>00917 }

942

<a name="l00918"></a>00918

943

<a name="l00919"></a><a class="code" href="a00036.html#7eae868e8565f4412cce23ff1f82fc4c">00919</a> bool <a class="code" href="a00036.html#7eae868e8565f4412cce23ff1f82fc4c">operator == </a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvect</a>) const

944

<a name="l00920"></a>00920 {

945

<a name="l00921"></a>00921 return <a class="code" href="a00036.html#a2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">compare</a>(bvect) == 0;

946

<a name="l00922"></a>00922 }

947

<a name="l00923"></a>00923

948

<a name="l00924"></a><a class="code" href="a00036.html#0d82c126fe741d082b17a60c8617865f">00924</a> bool <a class="code" href="a00036.html#0d82c126fe741d082b17a60c8617865f">operator != </a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvect</a>) const

949

<a name="l00925"></a>00925 {

950

<a name="l00926"></a>00926 return <a class="code" href="a00036.html#a2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">compare</a>(bvect) != 0;

951

<a name="l00927"></a>00927 }

952

<a name="l00928"></a>00928

953

<a name="l00929"></a><a class="code" href="a00036.html#281157317851c62d91d5ba6d32d33ec7">00929</a> <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> <a class="code" href="a00036.html#281157317851c62d91d5ba6d32d33ec7">operator~</a>() const

954

<a name="l00930"></a>00930 {

955

<a name="l00931"></a>00931 return <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>(*this).invert();

956

<a name="l00932"></a>00932 }

957

<a name="l00933"></a>00933

958

<a name="l00934"></a><a class="code" href="a00036.html#9af5dca8d808990b92bdf20b10b63198">00934</a> Alloc <a class="code" href="a00036.html#9af5dca8d808990b92bdf20b10b63198">get_allocator</a>() const

959

<a name="l00935"></a>00935 {

960

<a name="l00936"></a>00936 return blockman_.get_allocator();

961

<a name="l00937"></a>00937 }

962

<a name="l00938"></a>00938

963

<a name="l00939"></a>00939

964

<a name="l00940"></a>00940 /*!

965

<a name="l00941"></a>00941 \brief Sets bit n.

966

<a name="l00942"></a>00942 \param n - index of the bit to be set.

967

<a name="l00943"></a>00943 \param val - new bit value

968

<a name="l00944"></a>00944 \return TRUE if bit was changed

969

<a name="l00945"></a>00945 */

970

<a name="l00946"></a><a class="code" href="a00036.html#1769d9ed3a4ee41b03fc3ca4a0e5a58e">00946</a> bool <a class="code" href="a00036.html#1769d9ed3a4ee41b03fc3ca4a0e5a58e" title="Sets bit n.">set_bit</a>(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val = true)

971

<a name="l00947"></a>00947 {

972

<a name="l00948"></a>00948 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(n < size_);

973

<a name="l00949"></a>00949 return set_bit_no_check(n, val);

974

<a name="l00950"></a>00950 }

975

<a name="l00951"></a>00951

976

<a name="l00952"></a>00952 /*!

977

<a name="l00953"></a>00953 \brief Sets bit n using bit AND with the provided value.

978

<a name="l00954"></a>00954 \param n - index of the bit to be set.

979

<a name="l00955"></a>00955 \param val - new bit value

980

<a name="l00956"></a>00956 \return TRUE if bit was changed

981

<a name="l00957"></a>00957 */

982

<a name="l00958"></a><a class="code" href="a00036.html#432ac93e2bcd428f659810bb0e6cc9e8">00958</a> bool <a class="code" href="a00036.html#432ac93e2bcd428f659810bb0e6cc9e8" title="Sets bit n using bit AND with the provided value.">set_bit_and</a>(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val = true)

983

<a name="l00959"></a>00959 {

984

<a name="l00960"></a>00960 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(n < size_);

985

<a name="l00961"></a>00961 return and_bit_no_check(n, val);

986

<a name="l00962"></a>00962 }

987

<a name="l00963"></a>00963

988

<a name="l00964"></a>00964 /*!

989

<a name="l00965"></a>00965 \brief Sets bit n only if current value is equal to the condition

990

<a name="l00966"></a>00966 \param n - index of the bit to be set.

991

<a name="l00967"></a>00967 \param val - new bit value

992

<a name="l00968"></a>00968 \param condition - expected current value

993

<a name="l00969"></a>00969 \return TRUE if bit was changed

994

<a name="l00970"></a>00970 */

995

<a name="l00971"></a><a class="code" href="a00036.html#b769dc46d71c5df276d8403b20ed5eb0">00971</a> bool <a class="code" href="a00036.html#b769dc46d71c5df276d8403b20ed5eb0" title="Sets bit n only if current value is equal to the condition.">set_bit_conditional</a>(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val, bool condition)

996

<a name="l00972"></a>00972 {

997

<a name="l00973"></a>00973 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(n < size_);

998

<a name="l00974"></a>00974 if (val == condition) return false;

999

<a name="l00975"></a>00975 return set_bit_conditional_impl(n, val, condition);

1000

<a name="l00976"></a>00976 }

1001

<a name="l00977"></a>00977

1002

<a name="l00978"></a>00978

1003

<a name="l00979"></a>00979 /*!

1004

<a name="l00980"></a>00980 \brief Sets bit n if val is true, clears bit n if val is false

1005

<a name="l00981"></a>00981 \param n - index of the bit to be set

1006

<a name="l00982"></a>00982 \param val - new bit value

1007

<a name="l00983"></a>00983 \return *this

1008

<a name="l00984"></a>00984 */

1009

<a name="l00985"></a><a class="code" href="a00036.html#bc85ec9da74de03ff7e2a6c836656dd8">00985</a> <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& set(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val = true)

1010

<a name="l00986"></a>00986 {

1011

<a name="l00987"></a>00987 <a class="code" href="a00036.html#1769d9ed3a4ee41b03fc3ca4a0e5a58e" title="Sets bit n.">set_bit</a>(n, val);

1012

<a name="l00988"></a>00988 return *this;

1013

<a name="l00989"></a>00989 }

1014

<a name="l00990"></a>00990

1015

<a name="l00991"></a>00991

1016

<a name="l00992"></a>00992

1017

<a name="l00993"></a>00993 /*!

1018

<a name="l00994"></a>00994 \brief Sets every bit in this bitset to 1.

1019

<a name="l00995"></a>00995 \return *this

1020

<a name="l00996"></a>00996 */

1021

<a name="l00997"></a><a class="code" href="a00036.html#a745480d136c8b0e6bc41afe951577c5">00997</a> <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& set()

1022

<a name="l00998"></a>00998 {

1023

<a name="l00999"></a>00999 <a class="code" href="a00068.html#835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false)

1024

<a name="l01000"></a>01000 <a class="code" href="a00036.html#14bc35b9b022018f10787b07a5b2af04" title="Sets all bits in the specified closed interval [left,right] Interval must be inside...">set_range</a>(0, size_ - 1, true);

1025

<a name="l01001"></a>01001 return *this;

1026

<a name="l01002"></a>01002 }

1027

<a name="l01003"></a>01003

1028

<a name="l01004"></a>01004

1029

<a name="l01005"></a>01005 /*!

1030

<a name="l01006"></a>01006 \brief Sets all bits in the specified closed interval [left,right]

1031

<a name="l01007"></a>01007 Interval must be inside the bvector's size.

1032

<a name="l01008"></a>01008 This method DOES NOT resize vector.

1033

<a name="l01009"></a>01009

1034

<a name="l01010"></a>01010 \param left - interval start

1035

<a name="l01011"></a>01011 \param right - interval end (closed interval)

1036

<a name="l01012"></a>01012 \param value - value to set interval in

1037

<a name="l01013"></a>01013

1038

<a name="l01014"></a>01014 \return *this

1039

<a name="l01015"></a>01015 */

1040

<a name="l01016"></a>01016 <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00036.html#14bc35b9b022018f10787b07a5b2af04" title="Sets all bits in the specified closed interval [left,right] Interval must be inside...">set_range</a>(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> left,

1041

<a name="l01017"></a>01017 <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> right,

1042

<a name="l01018"></a>01018 bool value = true);

1043

<a name="l01019"></a>01019

1044

<a name="l01020"></a>01020

1045

<a name="l01021"></a>01021 /*! Function erturns insert iterator for this bitvector */

1046

<a name="l01022"></a><a class="code" href="a00036.html#da0d32bbd1a135722a7790b13d866451">01022</a> <a class="code" href="a00056.html" title="Output iterator iterator designed to set &quot;ON&quot; bits based on input sequence...">insert_iterator</a> <a class="code" href="a00036.html#da0d32bbd1a135722a7790b13d866451">inserter</a>()

1047

<a name="l01023"></a>01023 {

1048

<a name="l01024"></a>01024 return <a class="code" href="a00056.html" title="Output iterator iterator designed to set &quot;ON&quot; bits based on input sequence...">insert_iterator</a>(*this);

1049

<a name="l01025"></a>01025 }

1050

<a name="l01026"></a>01026

1051

<a name="l01027"></a>01027

1052

<a name="l01028"></a>01028 /*!

1053

<a name="l01029"></a>01029 \brief Clears bit n.

1054

<a name="l01030"></a>01030 \param n - bit's index to be cleaned.

1055

<a name="l01031"></a>01031 */

1056

<a name="l01032"></a><a class="code" href="a00036.html#23106b542344f671ff5aff1887657a5d">01032</a> void <a class="code" href="a00036.html#23106b542344f671ff5aff1887657a5d" title="Clears bit n.">clear_bit</a>(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n)

1057

<a name="l01033"></a>01033 {

1058

<a name="l01034"></a>01034 set(n, false);

1059

<a name="l01035"></a>01035 }

1060

<a name="l01036"></a>01036

1061

<a name="l01037"></a>01037

1062

<a name="l01038"></a>01038 /*!

1063

<a name="l01039"></a>01039 \brief Clears every bit in the bitvector.

1064

<a name="l01040"></a>01040

1065

<a name="l01041"></a>01041 \param free_mem if "true" (default) bvector frees the memory,

1066

<a name="l01042"></a>01042 otherwise sets blocks to 0.

1067

<a name="l01043"></a>01043 */

1068

<a name="l01044"></a><a class="code" href="a00036.html#fe98c658c4ee54155e61f9bdfa7b9019">01044</a> void <a class="code" href="a00036.html#fe98c658c4ee54155e61f9bdfa7b9019" title="Clears every bit in the bitvector.">clear</a>(bool free_mem = false)

1069

<a name="l01045"></a>01045 {

1070

<a name="l01046"></a>01046 blockman_.set_all_zero(free_mem);

1071

<a name="l01047"></a>01047 <a class="code" href="a00068.html#1fbebc7fe3c22d768ff6e240437ee8f4">BMCOUNT_SET</a>(0);

1072

<a name="l01048"></a>01048 }

1073

<a name="l01049"></a>01049

1074

<a name="l01050"></a>01050 /*!

1075

<a name="l01051"></a>01051 \brief Clears every bit in the bitvector.

1076

<a name="l01052"></a>01052 \return *this;

1077

<a name="l01053"></a>01053 */

1078

<a name="l01054"></a><a class="code" href="a00036.html#1b0d2eca7aa91d49374cf711407c9a43">01054</a> <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00036.html#1b0d2eca7aa91d49374cf711407c9a43" title="Clears every bit in the bitvector.">reset</a>()

1079

<a name="l01055"></a>01055 {

1080

<a name="l01056"></a>01056 <a class="code" href="a00036.html#fe98c658c4ee54155e61f9bdfa7b9019" title="Clears every bit in the bitvector.">clear</a>();

1081

<a name="l01057"></a>01057 return *this;

1082

<a name="l01058"></a>01058 }

1083

<a name="l01059"></a>01059

1084

<a name="l01060"></a>01060

1085

<a name="l01061"></a>01061 /*!

1086

<a name="l01062"></a>01062 \brief Returns count of bits which are 1.

1087

<a name="l01063"></a>01063 \return Total number of bits ON.

1088

<a name="l01064"></a>01064 */

1089

<a name="l01065"></a>01065 <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00036.html#71077c1315555301532e24d4d2b95ea2" title="Returns count of bits which are 1.">count</a>() const;

1090

<a name="l01066"></a>01066

1091

<a name="l01067"></a>01067 /**

1092

<a name="l01068"></a>01068 \brief Returns bvector's capacity (number of bits it can store)

1093

<a name="l01069"></a>01069 */

1094

<a name="l01070"></a><a class="code" href="a00036.html#b3d054fafa5d361b7aafa3b36cadecc2">01070</a> <a class="code" href="a00036.html#ba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> <a class="code" href="a00036.html#b3d054fafa5d361b7aafa3b36cadecc2" title="Returns bvector&#39;s capacity (number of bits it can store).">capacity</a>() const

1095

<a name="l01071"></a>01071 {

1096

<a name="l01072"></a>01072 return blockman_.capacity();

1097

<a name="l01073"></a>01073 }

1098

<a name="l01074"></a>01074

1099

<a name="l01075"></a>01075 /*!

1100

<a name="l01076"></a>01076 \brief return current size of the vector (bits)

1101

<a name="l01077"></a>01077 */

1102

<a name="l01078"></a><a class="code" href="a00036.html#1b021e7217f530390511e16b9b25f631">01078</a> <a class="code" href="a00036.html#ba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> <a class="code" href="a00036.html#1b021e7217f530390511e16b9b25f631" title="return current size of the vector (bits)">size</a>() const

1103

<a name="l01079"></a>01079 {

1104

<a name="l01080"></a>01080 return size_;

1105

<a name="l01081"></a>01081 }

1106

<a name="l01082"></a>01082

1107

<a name="l01083"></a>01083 /*!

1108

<a name="l01084"></a>01084 \brief Change size of the bvector

1109

<a name="l01085"></a>01085 \param new_size - new size in bits

1110

<a name="l01086"></a>01086 */

1111

<a name="l01087"></a>01087 void <a class="code" href="a00036.html#7be4f9e0741f43869f4dcd9607736c0e" title="Change size of the bvector.">resize</a>(<a class="code" href="a00036.html#ba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> new_size);

1112

<a name="l01088"></a>01088

1113

<a name="l01089"></a>01089 /*! \brief Computes bitcount values for all bvector blocks

1114

<a name="l01090"></a>01090 \param arr - pointer on array of block bit counts

1115

<a name="l01091"></a>01091 \return Index of the last block counted.

1116

<a name="l01092"></a>01092 This number +1 gives you number of arr elements initialized during the

1117

<a name="l01093"></a>01093 function call.

1118

<a name="l01094"></a>01094 */

1119

<a name="l01095"></a><a class="code" href="a00036.html#435752c1674607b625d5e9a54febaa5b">01095</a> unsigned <a class="code" href="a00036.html#435752c1674607b625d5e9a54febaa5b" title="Computes bitcount values for all bvector blocks.">count_blocks</a>(unsigned* arr) const

1120

<a name="l01096"></a>01096 {

1121

<a name="l01097"></a>01097 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*** blk_root = blockman_.get_rootblock();

1122

<a name="l01098"></a>01098 typename blocks_manager_type::block_count_arr_func func(blockman_, &(arr[0]));

1123

<a name="l01099"></a>01099 <a class="code" href="a00088.html#e8b342c25dc22d6cd26cb96d7ae796db">for_each_nzblock</a>(blk_root, blockman_.effective_top_block_size(),

1124

<a name="l01100"></a>01100 <a class="code" href="a00088.html#40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>, func);

1125

<a name="l01101"></a>01101 return func.last_block();

1126

<a name="l01102"></a>01102 }

1127

<a name="l01103"></a>01103

1128

<a name="l01104"></a>01104 /*!

1129

<a name="l01105"></a>01105 \brief Returns count of 1 bits in the given diapason.

1130

<a name="l01106"></a>01106 \param left - index of first bit start counting from

1131

<a name="l01107"></a>01107 \param right - index of last bit

1132

<a name="l01108"></a>01108 \param block_count_arr - optional parameter (bitcount by bvector blocks)

1133

<a name="l01109"></a>01109 calculated by count_blocks method. Used to improve performance of

1134

<a name="l01110"></a>01110 wide range searches

1135

<a name="l01111"></a>01111 \return Total number of bits ON.

1136

<a name="l01112"></a>01112 */

1137

<a name="l01113"></a>01113 <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00036.html#dbe1a2423ce166b88a0b57e435af2733" title="Returns count of 1 bits in the given diapason.">count_range</a>(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> left,

1138

<a name="l01114"></a>01114 <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> right,

1139

<a name="l01115"></a>01115 unsigned* block_count_arr=0) const;

1140

<a name="l01116"></a>01116

1141

<a name="l01117"></a>01117

1142

<a name="l01118"></a><a class="code" href="a00036.html#91adb243bd37e4e9798ba3e4f87e6e1e">01118</a> <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00036.html#91adb243bd37e4e9798ba3e4f87e6e1e">recalc_count</a>()

1143

<a name="l01119"></a>01119 {

1144

<a name="l01120"></a>01120 <a class="code" href="a00068.html#835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false)

1145

<a name="l01121"></a>01121 return <a class="code" href="a00036.html#71077c1315555301532e24d4d2b95ea2" title="Returns count of bits which are 1.">count</a>();

1146

<a name="l01122"></a>01122 }

1147

<a name="l01123"></a>01123

1148

<a name="l01124"></a>01124 /*!

1149

<a name="l01125"></a>01125 Disables count cache. Next call to count() or recalc_count()

1150

<a name="l01126"></a>01126 restores count caching.

1151

<a name="l01127"></a>01127

1152

<a name="l01128"></a>01128 @note Works only if BMCOUNTOPT enabled(defined).

1153

<a name="l01129"></a>01129 Othewise does nothing.

1154

<a name="l01130"></a>01130 */

1155

<a name="l01131"></a><a class="code" href="a00036.html#d18b82c801a21eeaf5bb519921bd23d8">01131</a> void <a class="code" href="a00036.html#d18b82c801a21eeaf5bb519921bd23d8">forget_count</a>()

1156

<a name="l01132"></a>01132 {

1157

<a name="l01133"></a>01133 <a class="code" href="a00068.html#835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false)

1158

<a name="l01134"></a>01134 }

1159

<a name="l01135"></a>01135

1160

<a name="l01136"></a>01136 /*!

1161

<a name="l01137"></a>01137 \brief Inverts all bits.

1162

<a name="l01138"></a>01138 */

1163

<a name="l01139"></a>01139 <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00036.html#49af36cc1ea632cd3a2217b53b69dafc" title="Inverts all bits.">invert</a>();

1164

<a name="l01140"></a>01140

1165

<a name="l01141"></a>01141

1166

<a name="l01142"></a>01142 /*!

1167

<a name="l01143"></a>01143 \brief returns true if bit n is set and false is bit n is 0.

1168

<a name="l01144"></a>01144 \param n - Index of the bit to check.

1169

<a name="l01145"></a>01145 \return Bit value (1 or 0)

1170

<a name="l01146"></a>01146 */

1171

<a name="l01147"></a>01147 bool <a class="code" href="a00036.html#11458ca2e3570838da7b94a1e4563d97" title="returns true if bit n is set and false is bit n is 0.">get_bit</a>(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n) const;

1172

<a name="l01148"></a>01148

1173

<a name="l01149"></a>01149 /*!

1174

<a name="l01150"></a>01150 \brief returns true if bit n is set and false is bit n is 0.

1175

<a name="l01151"></a>01151 \param n - Index of the bit to check.

1176

<a name="l01152"></a>01152 \return Bit value (1 or 0)

1177

<a name="l01153"></a>01153 */

1178

<a name="l01154"></a><a class="code" href="a00036.html#59ffa64959f92cc259eea2f6d7b597df">01154</a> bool <a class="code" href="a00036.html#59ffa64959f92cc259eea2f6d7b597df" title="returns true if bit n is set and false is bit n is 0.">test</a>(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n) const

1179

<a name="l01155"></a>01155 {

1180

<a name="l01156"></a>01156 return <a class="code" href="a00036.html#11458ca2e3570838da7b94a1e4563d97" title="returns true if bit n is set and false is bit n is 0.">get_bit</a>(n);

1181

<a name="l01157"></a>01157 }

1182

<a name="l01158"></a>01158

1183

<a name="l01159"></a>01159 /*!

1184

<a name="l01160"></a>01160 \brief Returns true if any bits in this bitset are set, and otherwise returns false.

1185

<a name="l01161"></a>01161 \return true if any bit is set

1186

<a name="l01162"></a>01162 */

1187

<a name="l01163"></a><a class="code" href="a00036.html#3d08364f13c365bd831ab4f0a909035e">01163</a> bool <a class="code" href="a00036.html#3d08364f13c365bd831ab4f0a909035e" title="Returns true if any bits in this bitset are set, and otherwise returns false.">any</a>() const

1188

<a name="l01164"></a>01164 {

1189

<a name="l01165"></a>01165 #ifdef BMCOUNTOPT

1190

<a name="l01166"></a>01166 if (count_is_valid_ && count_) return true;

1191

<a name="l01167"></a>01167 #endif

1192

<a name="l01168"></a>01168

1193

<a name="l01169"></a>01169 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">word_t</a>*** blk_root = blockman_.get_rootblock();

1194

<a name="l01170"></a>01170 if (!blk_root)

1195

<a name="l01171"></a>01171 return false;

1196

<a name="l01172"></a>01172 typename blocks_manager_type::block_any_func func(blockman_);

1197

<a name="l01173"></a>01173 return <a class="code" href="a00088.html#6f5cb8cbb105eae84d4b0f8a3bc1230f">for_each_nzblock_if</a>(blk_root,

1198

<a name="l01174"></a>01174 blockman_.effective_top_block_size(),

1199

<a name="l01175"></a>01175 <a class="code" href="a00088.html#40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>,

1200

<a name="l01176"></a>01176 func);

1201

<a name="l01177"></a>01177 }

1202

<a name="l01178"></a>01178

1203

<a name="l01179"></a>01179 /*!

1204

<a name="l01180"></a>01180 \brief Returns true if no bits are set, otherwise returns false.

1205

<a name="l01181"></a>01181 */

1206

<a name="l01182"></a><a class="code" href="a00036.html#1cb9799d8f1ae36f04527a14e9ff4784">01182</a> bool <a class="code" href="a00036.html#1cb9799d8f1ae36f04527a14e9ff4784" title="Returns true if no bits are set, otherwise returns false.">none</a>() const

1207

<a name="l01183"></a>01183 {

1208

<a name="l01184"></a>01184 return !<a class="code" href="a00036.html#3d08364f13c365bd831ab4f0a909035e" title="Returns true if any bits in this bitset are set, and otherwise returns false.">any</a>();

1209

<a name="l01185"></a>01185 }

1210

<a name="l01186"></a>01186

1211

<a name="l01187"></a>01187 /*!

1212

<a name="l01188"></a>01188 \brief Flips bit n

1213

<a name="l01189"></a>01189 \return *this

1214

<a name="l01190"></a>01190 */

1215

<a name="l01191"></a><a class="code" href="a00036.html#cf0fd4c4e19630fd02210f585c44491d">01191</a> <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00036.html#73faf6a420061373a6c447ed94e18df2" title="Flips all bits.">flip</a>(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n)

1216

<a name="l01192"></a>01192 {

1217

<a name="l01193"></a>01193 set(n, !<a class="code" href="a00036.html#11458ca2e3570838da7b94a1e4563d97" title="returns true if bit n is set and false is bit n is 0.">get_bit</a>(n));

1218

<a name="l01194"></a>01194 return *this;

1219

<a name="l01195"></a>01195 }

1220

<a name="l01196"></a>01196

1221

<a name="l01197"></a>01197 /*!

1222

<a name="l01198"></a>01198 \brief Flips all bits

1223

<a name="l01199"></a>01199 \return *this

1224

<a name="l01200"></a>01200 */

1225

<a name="l01201"></a><a class="code" href="a00036.html#73faf6a420061373a6c447ed94e18df2">01201</a> <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00036.html#73faf6a420061373a6c447ed94e18df2" title="Flips all bits.">flip</a>()

1226

<a name="l01202"></a>01202 {

1227

<a name="l01203"></a>01203 return <a class="code" href="a00036.html#49af36cc1ea632cd3a2217b53b69dafc" title="Inverts all bits.">invert</a>();

1228

<a name="l01204"></a>01204 }

1229

<a name="l01205"></a>01205

1230

<a name="l01206"></a>01206 /*! \brief Exchanges content of bv and this bitvector.

1231

<a name="l01207"></a>01207 */

1232

<a name="l01208"></a><a class="code" href="a00036.html#d7a4d5fb8a2418f45a366efd01cd3bcd">01208</a> void <a class="code" href="a00036.html#d7a4d5fb8a2418f45a366efd01cd3bcd" title="Exchanges content of bv and this bitvector.">swap</a>(<a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& bv)

1233

<a name="l01209"></a>01209 {

1234

<a name="l01210"></a>01210 if (this != &bv)

1235

<a name="l01211"></a>01211 {

1236

<a name="l01212"></a>01212 blockman_.swap(bv.blockman_);

1237

<a name="l01213"></a>01213 <a class="code" href="a00088.html#fb2c1acc56270abb381741a709a2b17c" title="XOR swap two scalar variables.">bm::xor_swap</a>(size_,bv.size_);

1238

<a name="l01214"></a>01214 #ifdef BMCOUNTOPT

1239

<a name="l01215"></a>01215 <a class="code" href="a00068.html#835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false)

1240

<a name="l01216"></a>01216 bv.<a class="code" href="a00036.html#91adb243bd37e4e9798ba3e4f87e6e1e">recalc_count</a>();

1241

<a name="l01217"></a>01217 #endif

1242

<a name="l01218"></a>01218 }

1243

<a name="l01219"></a>01219 }

1244

<a name="l01220"></a>01220

1245

<a name="l01221"></a>01221

1246

<a name="l01222"></a>01222 /*!

1247

<a name="l01223"></a>01223 \fn bm::id_t bvector::get_first() const

1248

<a name="l01224"></a>01224 \brief Gets number of first bit which is ON.

1249

<a name="l01225"></a>01225 \return Index of the first 1 bit.

1250

<a name="l01226"></a>01226 \sa get_next, extract_next

1251

<a name="l01227"></a>01227 */

1252

<a name="l01228"></a><a class="code" href="a00036.html#f3129b35cabf0554d85711c085a8616d">01228</a> <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00036.html#f3129b35cabf0554d85711c085a8616d" title="Gets number of first bit which is ON.">get_first</a>() const { return check_or_next(0); }

1253

<a name="l01229"></a>01229

1254

<a name="l01230"></a>01230 /*!

1255

<a name="l01231"></a>01231 \fn bm::id_t bvector::get_next(bm::id_t prev) const

1256

<a name="l01232"></a>01232 \brief Finds the number of the next bit ON.

1257

<a name="l01233"></a>01233 \param prev - Index of the previously found bit.

1258

<a name="l01234"></a>01234 \return Index of the next bit which is ON or 0 if not found.

1259

<a name="l01235"></a>01235 \sa get_first, extract_next

1260

<a name="l01236"></a>01236 */

1261

<a name="l01237"></a><a class="code" href="a00036.html#def9c095a682a9857068c280e37c8240">01237</a> <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00036.html#def9c095a682a9857068c280e37c8240" title="Finds the number of the next bit ON.">get_next</a>(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> prev) const

1262

<a name="l01238"></a>01238 {

1263

<a name="l01239"></a>01239 return (++prev == <a class="code" href="a00088.html#104b924a1df81542db2a6296fbf26a65">bm::id_max</a>) ? 0 : check_or_next(prev);

1264

<a name="l01240"></a>01240 }

1265

<a name="l01241"></a>01241

1266

<a name="l01242"></a>01242 /*!

1267

<a name="l01243"></a>01243 \fn bm::id_t bvector::extract_next(bm::id_t prev)

1268

<a name="l01244"></a>01244 \brief Finds the number of the next bit ON and sets it to 0.

1269

<a name="l01245"></a>01245 \param prev - Index of the previously found bit.

1270

<a name="l01246"></a>01246 \return Index of the next bit which is ON or 0 if not found.

1271

<a name="l01247"></a>01247 \sa get_first, get_next,

1272

<a name="l01248"></a>01248 */

1273

<a name="l01249"></a><a class="code" href="a00036.html#0919f2a0499568605b380e5d5373948d">01249</a> <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00036.html#0919f2a0499568605b380e5d5373948d" title="Finds the number of the next bit ON and sets it to 0.">extract_next</a>(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> prev)

1274

<a name="l01250"></a>01250 {

1275

<a name="l01251"></a>01251 return (++prev == <a class="code" href="a00088.html#104b924a1df81542db2a6296fbf26a65">bm::id_max</a>) ? 0 : check_or_next_extract(prev);

1276

<a name="l01252"></a>01252 }

1277

<a name="l01253"></a>01253

1278

<a name="l01254"></a>01254

1279

<a name="l01255"></a>01255 /*!

1280

<a name="l01256"></a>01256 @brief Calculates bitvector statistics.

1281

<a name="l01257"></a>01257

1282

<a name="l01258"></a>01258 @param st - pointer on statistics structure to be filled in.

1283

<a name="l01259"></a>01259

1284

<a name="l01260"></a>01260 Function fills statistics structure containing information about how

1285

<a name="l01261"></a>01261 this vector uses memory and estimation of max. amount of memory

1286

<a name="l01262"></a>01262 bvector needs to serialize itself.

1287

<a name="l01263"></a>01263

1288

<a name="l01264"></a>01264 @sa statistics

1289

<a name="l01265"></a>01265 */

1290

<a name="l01266"></a>01266 void <a class="code" href="a00036.html#1eaaac76a97b9eb1d3c11f21cf9385ac" title="Calculates bitvector statistics.">calc_stat</a>(struct <a class="code" href="a00067.html" title="Statistical information about bitset&#39;s memory allocation details.">bm::bvector<Alloc, MS>::statistics</a>* st) const;

1291

<a name="l01267"></a>01267

1292

<a name="l01268"></a>01268 /*!

1293

<a name="l01269"></a>01269 \brief Logical OR operation.

1294

<a name="l01270"></a>01270 \param vect - Argument vector.

1295

<a name="l01271"></a>01271 */

1296

<a name="l01272"></a><a class="code" href="a00036.html#0eacd87603f41a9aea2126810183f83a">01272</a> <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00036.html#0eacd87603f41a9aea2126810183f83a" title="Logical OR operation.">bit_or</a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& vect)

1297

<a name="l01273"></a>01273 {

1298

<a name="l01274"></a>01274 <a class="code" href="a00068.html#835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false);

1299

<a name="l01275"></a>01275 <a class="code" href="a00036.html#f2c137de958a038f96e1149c51ea8a8f">combine_operation</a>(vect, <a class="code" href="a00088.html#42405343976ec931388381cea4092bf10c8cf0197857d0bd73a63037e2f2c5c5">BM_OR</a>);

1300

<a name="l01276"></a>01276 return *this;

1301

<a name="l01277"></a>01277 }

1302

<a name="l01278"></a>01278

1303

<a name="l01279"></a>01279 /*!

1304

<a name="l01280"></a>01280 \brief Logical AND operation.

1305

<a name="l01281"></a>01281 \param vect - Argument vector.

1306

<a name="l01282"></a>01282 */

1307

<a name="l01283"></a><a class="code" href="a00036.html#051a39027c3b12751f172c20f2d03a0f">01283</a> <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00036.html#051a39027c3b12751f172c20f2d03a0f" title="Logical AND operation.">bit_and</a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& vect)

1308

<a name="l01284"></a>01284 {

1309

<a name="l01285"></a>01285 <a class="code" href="a00068.html#835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false);

1310

<a name="l01286"></a>01286 <a class="code" href="a00036.html#f2c137de958a038f96e1149c51ea8a8f">combine_operation</a>(vect, <a class="code" href="a00088.html#42405343976ec931388381cea4092bf1546fdf33b301e5b9bee0591522ed9250">BM_AND</a>);

1311

<a name="l01287"></a>01287 return *this;

1312

<a name="l01288"></a>01288 }

1313

<a name="l01289"></a>01289

1314

<a name="l01290"></a>01290 /*!

1315

<a name="l01291"></a>01291 \brief Logical XOR operation.

1316

<a name="l01292"></a>01292 \param vect - Argument vector.

1317

<a name="l01293"></a>01293 */

1318

<a name="l01294"></a><a class="code" href="a00036.html#997a62ec2effcd60246fb9b72f30ccfa">01294</a> <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00036.html#997a62ec2effcd60246fb9b72f30ccfa" title="Logical XOR operation.">bit_xor</a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& vect)

1319

<a name="l01295"></a>01295 {

1320

<a name="l01296"></a>01296 <a class="code" href="a00068.html#835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false);

1321

<a name="l01297"></a>01297 <a class="code" href="a00036.html#f2c137de958a038f96e1149c51ea8a8f">combine_operation</a>(vect, <a class="code" href="a00088.html#42405343976ec931388381cea4092bf145c2fe36efb72dc03f03a842d253f64c">BM_XOR</a>);

1322

<a name="l01298"></a>01298 return *this;

1323

<a name="l01299"></a>01299 }

1324

<a name="l01300"></a>01300

1325

<a name="l01301"></a>01301 /*!

1326

<a name="l01302"></a>01302 \brief Logical SUB operation.

1327

<a name="l01303"></a>01303 \param vect - Argument vector.

1328

<a name="l01304"></a>01304 */

1329

<a name="l01305"></a><a class="code" href="a00036.html#6a8e699f9c0571f904d7cbaa2e3ed1f1">01305</a> <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00036.html#6a8e699f9c0571f904d7cbaa2e3ed1f1" title="Logical SUB operation.">bit_sub</a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& vect)

1330

<a name="l01306"></a>01306 {

1331

<a name="l01307"></a>01307 <a class="code" href="a00068.html#835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false);

1332

<a name="l01308"></a>01308 <a class="code" href="a00036.html#f2c137de958a038f96e1149c51ea8a8f">combine_operation</a>(vect, <a class="code" href="a00088.html#42405343976ec931388381cea4092bf11df0f4de7126bb2f7ce69d7a005affb5">BM_SUB</a>);

1333

<a name="l01309"></a>01309 return *this;

1334

<a name="l01310"></a>01310 }

1335

<a name="l01311"></a>01311

1336

<a name="l01312"></a>01312

1337

<a name="l01313"></a>01313 /*!

1338

<a name="l01314"></a>01314 \brief Sets new blocks allocation strategy.

1339

<a name="l01315"></a>01315 \param strat - Strategy code 0 - bitblocks allocation only.

1340

<a name="l01316"></a>01316 1 - Blocks mutation mode (adaptive algorithm)

1341

<a name="l01317"></a>01317 */

1342

<a name="l01318"></a><a class="code" href="a00036.html#b1094180d03cbc961d62f0f453097452">01318</a> void <a class="code" href="a00036.html#b1094180d03cbc961d62f0f453097452" title="Sets new blocks allocation strategy.">set_new_blocks_strat</a>(<a class="code" href="a00091.html#gd0b87b3b7292383a864d27feaf1c9eff" title="Block allocation strategies.">strategy</a> strat)

1343

<a name="l01319"></a>01319 {

1344

<a name="l01320"></a>01320 new_blocks_strat_ = strat;

1345

<a name="l01321"></a>01321 }

1346

<a name="l01322"></a>01322

1347

<a name="l01323"></a>01323 /*!

1348

<a name="l01324"></a>01324 \brief Returns blocks allocation strategy.

1349

<a name="l01325"></a>01325 \return - Strategy code 0 - bitblocks allocation only.

1350

<a name="l01326"></a>01326 1 - Blocks mutation mode (adaptive algorithm)

1351

<a name="l01327"></a>01327 \sa set_new_blocks_strat

1352

<a name="l01328"></a>01328 */

1353

<a name="l01329"></a><a class="code" href="a00036.html#d971c541fa259278e9dcf541b2d128c9">01329</a> <a class="code" href="a00091.html#gd0b87b3b7292383a864d27feaf1c9eff" title="Block allocation strategies.">strategy</a> <a class="code" href="a00036.html#d971c541fa259278e9dcf541b2d128c9" title="Returns blocks allocation strategy.">get_new_blocks_strat</a>() const

1354

<a name="l01330"></a>01330 {

1355

<a name="l01331"></a>01331 return new_blocks_strat_;

1356

<a name="l01332"></a>01332 }

1357

<a name="l01333"></a>01333

1358

<a name="l01334"></a>01334 void <a class="code" href="a00036.html#38b22b8b4063ffa46beb8e04a972c4bd">stat</a>(unsigned blocks=0) const;

1359

<a name="l01335"></a>01335

1360

<a name="l01336"></a>01336 /*!

1361

<a name="l01337"></a>01337 \brief Optimization mode

1362

<a name="l01338"></a>01338 Every next level means additional checks (better compression vs time)

1363

<a name="l01339"></a>01339 \sa optimize

1364

<a name="l01340"></a>01340 */

1365

<a name="l01341"></a><a class="code" href="a00036.html#05f1e977cb5e6208838afc7e7b69e5f0">01341</a> enum <a class="code" href="a00036.html#05f1e977cb5e6208838afc7e7b69e5f0" title="Optimization mode Every next level means additional checks (better compression vs...">optmode</a>

1366

<a name="l01342"></a>01342 {

1367

<a name="l01343"></a><a class="code" href="a00036.html#05f1e977cb5e6208838afc7e7b69e5f0b9b4d2133014db3d5dbd9c2eda332d19">01343</a> <a class="code" href="a00036.html#05f1e977cb5e6208838afc7e7b69e5f0b9b4d2133014db3d5dbd9c2eda332d19" title="Free unused 0 blocks.">opt_free_0</a> = 1, ///< Free unused 0 blocks

1368

<a name="l01344"></a><a class="code" href="a00036.html#05f1e977cb5e6208838afc7e7b69e5f09b54164042434a520ff7e7464e4b43b0">01344</a> <a class="code" href="a00036.html#05f1e977cb5e6208838afc7e7b69e5f09b54164042434a520ff7e7464e4b43b0" title="Free unused 0 and 1 blocks.">opt_free_01</a> = 2, ///< Free unused 0 and 1 blocks

1369

<a name="l01345"></a><a class="code" href="a00036.html#05f1e977cb5e6208838afc7e7b69e5f085f191ba55048d1c436e1e948e9be783">01345</a> <a class="code" href="a00036.html#05f1e977cb5e6208838afc7e7b69e5f085f191ba55048d1c436e1e948e9be783" title="compress blocks when possible">opt_compress</a> = 3 ///< compress blocks when possible

1370

<a name="l01346"></a>01346 };

1371

<a name="l01347"></a>01347

1372

<a name="l01348"></a>01348 /*!

1373

<a name="l01349"></a>01349 \brief Optimize memory bitvector's memory allocation.

1374

<a name="l01350"></a>01350

1375

<a name="l01351"></a>01351 Function analyze all blocks in the bitvector, compresses blocks

1376

<a name="l01352"></a>01352 with a regular structure, frees some memory. This function is recommended

1377

<a name="l01353"></a>01353 after a bulk modification of the bitvector using set_bit, clear_bit or

1378

<a name="l01354"></a>01354 logical operations.

1379

<a name="l01355"></a>01355

1380

<a name="l01356"></a>01356 Optionally function can calculate vector post optimization statistics

1381

<a name="l01357"></a>01357

1382

<a name="l01358"></a>01358 @sa optmode, optimize_gap_size

1383

<a name="l01359"></a>01359 */

1384

<a name="l01360"></a>01360 void <a class="code" href="a00036.html#bd522c13e26c2b8f84636fe8b6648dcb" title="Optimize memory bitvector&#39;s memory allocation.">optimize</a>(<a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* temp_block = 0,

1385

<a name="l01361"></a>01361 <a class="code" href="a00036.html#05f1e977cb5e6208838afc7e7b69e5f0" title="Optimization mode Every next level means additional checks (better compression vs...">optmode</a> opt_mode = <a class="code" href="a00036.html#05f1e977cb5e6208838afc7e7b69e5f085f191ba55048d1c436e1e948e9be783" title="compress blocks when possible">opt_compress</a>,

1386

<a name="l01362"></a>01362 statistics* <a class="code" href="a00036.html#38b22b8b4063ffa46beb8e04a972c4bd">stat</a> = 0);

1387

<a name="l01363"></a>01363

1388

<a name="l01364"></a>01364 /*!

1389

<a name="l01365"></a>01365 \brief Optimize sizes of GAP blocks

1390

<a name="l01366"></a>01366

1391

<a name="l01367"></a>01367 This method runs an analysis to find optimal GAP levels for the

1392

<a name="l01368"></a>01368 specific vector. Current GAP compression algorithm uses several fixed

1393

<a name="l01369"></a>01369 GAP sizes. By default bvector uses some reasonable preset.

1394

<a name="l01370"></a>01370 */

1395

<a name="l01371"></a>01371 void <a class="code" href="a00036.html#3942e3f6ea9fa54fcdb78a35a85008e5" title="Optimize sizes of GAP blocks.">optimize_gap_size</a>();

1396

<a name="l01372"></a>01372

1397

<a name="l01373"></a>01373

1398

<a name="l01374"></a>01374 /*!

1399

<a name="l01375"></a>01375 @brief Sets new GAP lengths table. All GAP blocks will be reallocated

1400

<a name="l01376"></a>01376 to match the new scheme.

1401

<a name="l01377"></a>01377

1402

<a name="l01378"></a>01378 @param glevel_len - pointer on C-style array keeping GAP block sizes.

1403

<a name="l01379"></a>01379 */

1404

<a name="l01380"></a>01380 void <a class="code" href="a00036.html#40d82dec62efe90b0810ccd06b62163e" 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="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>* glevel_len);

1405

<a name="l01381"></a>01381

1406

<a name="l01382"></a>01382 /*!

1407

<a name="l01383"></a>01383 \brief Lexicographical comparison with a bitvector.

1408

<a name="l01384"></a>01384

1409

<a name="l01385"></a>01385 Function compares current bitvector with the provided argument

1410

<a name="l01386"></a>01386 bit by bit and returns -1 if our bitvector less than the argument,

1411

<a name="l01387"></a>01387 1 - greater, 0 - equal.

1412

<a name="l01388"></a>01388 */

1413

<a name="l01389"></a>01389 int <a class="code" href="a00036.html#a2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">compare</a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvect</a>) const;

1414

<a name="l01390"></a>01390

1415

<a name="l01391"></a>01391 /*! @brief Allocates temporary block of memory.

1416

<a name="l01392"></a>01392

1417

<a name="l01393"></a>01393 Temp block can be passed to bvector functions requiring some temp memory

1418

<a name="l01394"></a>01394 for their operation. (like serialize)

1419

<a name="l01395"></a>01395

1420

<a name="l01396"></a>01396 @note method is marked const, but it's not quite true, since

1421

<a name="l01397"></a>01397 it can in some cases modify the state of the block allocator

1422

<a name="l01398"></a>01398 (if it has a state). (Can be important in MT programs).

1423

<a name="l01399"></a>01399

1424

<a name="l01400"></a>01400 @sa free_tempblock

1425

<a name="l01401"></a>01401 */

1426

<a name="l01402"></a><a class="code" href="a00036.html#b7d74cc7b7d6c6e77dd3634ecbb35e4f">01402</a> <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* <a class="code" href="a00036.html#b7d74cc7b7d6c6e77dd3634ecbb35e4f" title="Allocates temporary block of memory.">allocate_tempblock</a>() const

1427

<a name="l01403"></a>01403 {

1428

<a name="l01404"></a>01404 <a class="code" href="a00036.html#1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>* bm =

1429

<a name="l01405"></a>01405 const_cast<<a class="code" href="a00036.html#1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>*>(&blockman_);

1430

<a name="l01406"></a>01406 return bm->get_allocator().alloc_bit_block();

1431

<a name="l01407"></a>01407 }

1432

<a name="l01408"></a>01408

1433

<a name="l01409"></a>01409 /*! @brief Frees temporary block of memory.

1434

<a name="l01410"></a>01410

1435

<a name="l01411"></a>01411 @note method is marked const, but it's not quite true, since

1436

<a name="l01412"></a>01412 it can in some cases modify the state of the block allocator

1437

<a name="l01413"></a>01413 (if it has a state). (Can be important in MT programs).

1438

<a name="l01414"></a>01414

1439

<a name="l01415"></a>01415 @sa allocate_tempblock

1440

<a name="l01416"></a>01416 */

1441

<a name="l01417"></a><a class="code" href="a00036.html#311bbf4841d2a25a2e7f59f6861f1592">01417</a> void <a class="code" href="a00036.html#311bbf4841d2a25a2e7f59f6861f1592" title="Frees temporary block of memory.">free_tempblock</a>(<a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* block) const

1442

<a name="l01418"></a>01418 {

1443

<a name="l01419"></a>01419 <a class="code" href="a00036.html#1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>* bm =

1444

<a name="l01420"></a>01420 const_cast<<a class="code" href="a00036.html#1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>*>(&blockman_);

1445

<a name="l01421"></a>01421 bm->get_allocator().free_bit_block(block);

1446

<a name="l01422"></a>01422 }

1447

<a name="l01423"></a>01423

1448

<a name="l01424"></a>01424 /**

1449

<a name="l01425"></a>01425 \brief Returns enumerator pointing on the first non-zero bit.

1450

<a name="l01426"></a>01426 */

1451

<a name="l01427"></a><a class="code" href="a00036.html#ad48c661f843e32c9893438a6f27a8f0">01427</a> <a class="code" href="a00051.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a> <a class="code" href="a00036.html#ad48c661f843e32c9893438a6f27a8f0" title="Returns enumerator pointing on the first non-zero bit.">first</a>() const

1452

<a name="l01428"></a>01428 {

1453

<a name="l01429"></a>01429 typedef typename <a class="code" href="a00051.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">bvector<Alloc, MS>::enumerator</a> enumerator_type;

1454

<a name="l01430"></a>01430 return enumerator_type(this, 0);

1455

<a name="l01431"></a>01431 }

1456

<a name="l01432"></a>01432

1457

<a name="l01433"></a>01433 /**

1458

<a name="l01434"></a>01434 \fn bvector::enumerator bvector::end() const

1459

<a name="l01435"></a>01435 \brief Returns enumerator pointing on the next bit after the last.

1460

<a name="l01436"></a>01436 */

1461

<a name="l01437"></a><a class="code" href="a00036.html#2c6e522f858fdc466765d2c0f269f590">01437</a> <a class="code" href="a00051.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a> <a class="code" href="a00036.html#2c6e522f858fdc466765d2c0f269f590" title="Returns enumerator pointing on the next bit after the last.">end</a>() const

1462

<a name="l01438"></a>01438 {

1463

<a name="l01439"></a>01439 typedef typename <a class="code" href="a00051.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">bvector<Alloc, MS>::enumerator</a> enumerator_type;

1464

<a name="l01440"></a>01440 return enumerator_type(this, 1);

1465

<a name="l01441"></a>01441 }

1466

<a name="l01442"></a>01442

1467

<a name="l01443"></a>01443

1468

<a name="l01444"></a><a class="code" href="a00036.html#68bb64dca7f60aa1828ddd4be63418dc">01444</a> const <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* <a class="code" href="a00036.html#68bb64dca7f60aa1828ddd4be63418dc">get_block</a>(unsigned nb) const

1469

<a name="l01445"></a>01445 {

1470

<a name="l01446"></a>01446 return blockman_.get_block(nb);

1471

<a name="l01447"></a>01447 }

1472

<a name="l01448"></a>01448

1473

<a name="l01449"></a>01449 void <a class="code" href="a00036.html#f2c137de958a038f96e1149c51ea8a8f">combine_operation</a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvect</a>,

1474

<a name="l01450"></a>01450 <a class="code" href="a00088.html#42405343976ec931388381cea4092bf1" title="Bit operations enumeration.">bm::operation</a> opcode);

1475

<a name="l01451"></a>01451

1476

<a name="l01452"></a>01452 private:

1477

<a name="l01453"></a>01453

1478

<a name="l01454"></a>01454 <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> check_or_next(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> prev) const;

1479

<a name="l01455"></a>01455

1480

<a name="l01456"></a>01456 /// check if specified bit is 1, and set it to 0

1481

<a name="l01457"></a>01457 /// if specified bit is 0, scan for the next 1 and returns it

1482

<a name="l01458"></a>01458 /// if no 1 found returns 0

1483

<a name="l01459"></a>01459 <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> check_or_next_extract(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> prev);

1484

<a name="l01460"></a>01460

1485

<a name="l01461"></a>01461 /**

1486

<a name="l01462"></a>01462 \brief Set specified bit without checking preconditions (size, etc)

1487

<a name="l01463"></a>01463 */

1488

<a name="l01464"></a>01464 bool set_bit_no_check(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val);

1489

<a name="l01465"></a>01465

1490

<a name="l01466"></a>01466 /**

1491

<a name="l01467"></a>01467 \brief AND specified bit without checking preconditions (size, etc)

1492

<a name="l01468"></a>01468 */

1493

<a name="l01469"></a>01469 bool and_bit_no_check(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val);

1494

<a name="l01470"></a>01470

1495

<a name="l01471"></a>01471 bool set_bit_conditional_impl(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val, bool condition);

1496

<a name="l01472"></a>01472

1497

<a name="l01473"></a>01473

1498

<a name="l01474"></a>01474 void combine_operation_with_block(unsigned nb,

1499

<a name="l01475"></a>01475 unsigned gap,

1500

<a name="l01476"></a>01476 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk,

1501

<a name="l01477"></a>01477 const <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* arg_blk,

1502

<a name="l01478"></a>01478 int arg_gap,

1503

<a name="l01479"></a>01479 <a class="code" href="a00088.html#42405343976ec931388381cea4092bf1" title="Bit operations enumeration.">bm::operation</a> opcode);

1504

<a name="l01480"></a>01480 public:

1505

<a name="l01481"></a><a class="code" href="a00036.html#894bfd0e43484e819694c6560cd4207c">01481</a> void combine_operation_with_block(unsigned nb,

1506

<a name="l01482"></a>01482 const <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* arg_blk,

1507

<a name="l01483"></a>01483 int arg_gap,

1508

<a name="l01484"></a>01484 <a class="code" href="a00088.html#42405343976ec931388381cea4092bf1" title="Bit operations enumeration.">bm::operation</a> opcode)

1509

<a name="l01485"></a>01485 {

1510

<a name="l01486"></a>01486 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk = const_cast<<a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*>(<a class="code" href="a00036.html#68bb64dca7f60aa1828ddd4be63418dc">get_block</a>(nb));

1511

<a name="l01487"></a>01487 bool gap = <a class="code" href="a00072.html#862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>((*this), blk, nb);

1512

<a name="l01488"></a>01488 combine_operation_with_block(nb, gap, blk, arg_blk, arg_gap, opcode);

1513

<a name="l01489"></a>01489 }

1514

<a name="l01490"></a>01490 private:

1515

<a name="l01491"></a>01491 void combine_count_operation_with_block(unsigned nb,

1516

<a name="l01492"></a>01492 const <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* arg_blk,

1517

<a name="l01493"></a>01493 int arg_gap,

1518

<a name="l01494"></a>01494 <a class="code" href="a00088.html#42405343976ec931388381cea4092bf1" title="Bit operations enumeration.">bm::operation</a> opcode)

1519

<a name="l01495"></a>01495 {

1520

<a name="l01496"></a>01496 const <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk = <a class="code" href="a00036.html#68bb64dca7f60aa1828ddd4be63418dc">get_block</a>(nb);

1521

<a name="l01497"></a>01497 bool gap = <a class="code" href="a00072.html#862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>((*this), blk, nb);

1522

<a name="l01498"></a>01498 combine_count_operation_with_block(nb, gap, blk, arg_blk, arg_gap, opcode);

1523

<a name="l01499"></a>01499 }

1524

<a name="l01500"></a>01500

1525

<a name="l01501"></a>01501

1526

<a name="l01502"></a>01502 /**

1527

<a name="l01503"></a>01503 \brief Extends GAP block to the next level or converts it to bit block.

1528

<a name="l01504"></a>01504 \param nb - Block's linear index.

1529

<a name="l01505"></a>01505 \param blk - Blocks's pointer

1530

<a name="l01506"></a>01506 */

1531

<a name="l01507"></a>01507 void extend_gap_block(unsigned nb, <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>* blk)

1532

<a name="l01508"></a>01508 {

1533

<a name="l01509"></a>01509 blockman_.extend_gap_block(nb, blk);

1534

<a name="l01510"></a>01510 }

1535

<a name="l01511"></a>01511

1536

<a name="l01512"></a>01512 /**

1537

<a name="l01513"></a>01513 \brief Set range without validity checking

1538

<a name="l01514"></a>01514 */

1539

<a name="l01515"></a>01515 void set_range_no_check(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> left,

1540

<a name="l01516"></a>01516 <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> right,

1541

<a name="l01517"></a>01517 bool value);

1542

<a name="l01518"></a>01518 public:

1543

<a name="l01519"></a>01519

1544

<a name="l01520"></a><a class="code" href="a00036.html#9599df0386dfc7e6bad95fde7e4b3ee8">01520</a> const <a class="code" href="a00036.html#1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>& <a class="code" href="a00036.html#9599df0386dfc7e6bad95fde7e4b3ee8">get_blocks_manager</a>() const

1545

<a name="l01521"></a>01521 {

1546

<a name="l01522"></a>01522 return blockman_;

1547

<a name="l01523"></a>01523 }

1548

<a name="l01524"></a>01524

1549

<a name="l01525"></a><a class="code" href="a00036.html#a531c7278812888bca2d1617bb19e0b0">01525</a> <a class="code" href="a00036.html#1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>& <a class="code" href="a00036.html#9599df0386dfc7e6bad95fde7e4b3ee8">get_blocks_manager</a>()

1550

<a name="l01526"></a>01526 {

1551

<a name="l01527"></a>01527 return blockman_;

1552

<a name="l01528"></a>01528 }

1553

<a name="l01529"></a>01529

1554

<a name="l01530"></a>01530

1555

<a name="l01531"></a>01531 private:

1556

<a name="l01532"></a>01532

1557

<a name="l01533"></a>01533 // This block defines two additional hidden variables used for bitcount

1558

<a name="l01534"></a>01534 // optimization, in rare cases can make bitvector thread unsafe.

1559

<a name="l01535"></a>01535 #ifdef BMCOUNTOPT

1560

<a name="l01536"></a>01536 mutable <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">id_t</a> count_; //!< number of 1 bits in the vector

1561

<a name="l01537"></a>01537 mutable bool count_is_valid_; //!< actualization flag

1562

<a name="l01538"></a>01538 #endif

1563

<a name="l01539"></a>01539

1564

<a name="l01540"></a>01540 <a class="code" href="a00036.html#1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a> blockman_; //!< bitblocks manager

1565

<a name="l01541"></a>01541 <a class="code" href="a00091.html#gd0b87b3b7292383a864d27feaf1c9eff" title="Block allocation strategies.">strategy</a> new_blocks_strat_; //!< block allocation strategy

1566

<a name="l01542"></a>01542 <a class="code" href="a00036.html#ba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> size_; //!< size in bits

1567

<a name="l01543"></a>01543 };

1568

<a name="l01544"></a>01544

1569

<a name="l01545"></a>01545

1570

<a name="l01546"></a>01546

1571

<a name="l01547"></a>01547

1572

<a name="l01548"></a>01548

1573

<a name="l01549"></a>01549 //---------------------------------------------------------------------

1574

<a name="l01550"></a>01550

1575

<a name="l01551"></a>01551 template<class Alloc, class MS>

1576

<a name="l01552"></a><a class="code" href="a00088.html#c766cc15ae8feca9e21a36c49bf3b557">01552</a> inline <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> <a class="code" href="a00088.html#c766cc15ae8feca9e21a36c49bf3b557">operator& </a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& v1,

1577

<a name="l01553"></a>01553 const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& v2)

1578

<a name="l01554"></a>01554 {

1579

<a name="l01555"></a>01555 #ifdef BM_USE_EXPLICIT_TEMP

1580

<a name="l01556"></a>01556 <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> ret(v1);

1581

<a name="l01557"></a>01557 ret.<a class="code" href="a00036.html#051a39027c3b12751f172c20f2d03a0f" title="Logical AND operation.">bit_and</a>(v2);

1582

<a name="l01558"></a>01558 return ret;

1583

<a name="l01559"></a>01559 #else

1584

<a name="l01560"></a>01560 return <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>(v1).bit_and(v2);

1585

<a name="l01561"></a>01561 #endif

1586

<a name="l01562"></a>01562 }

1587

<a name="l01563"></a>01563

1588

<a name="l01564"></a>01564 //---------------------------------------------------------------------

1589

<a name="l01565"></a>01565

1590

<a name="l01566"></a>01566 template<class Alloc, class MS>

1591

<a name="l01567"></a><a class="code" href="a00088.html#5cc9411c5170df52c1c4ea436ef32745">01567</a> inline <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> <a class="code" href="a00088.html#5cc9411c5170df52c1c4ea436ef32745">operator| </a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& v1,

1592

<a name="l01568"></a>01568 const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc></a>& v2)

1593

<a name="l01569"></a>01569 {

1594

<a name="l01570"></a>01570 #ifdef BM_USE_EXPLICIT_TEMP

1595

<a name="l01571"></a>01571 <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> ret(v1);

1596

<a name="l01572"></a>01572 ret.<a class="code" href="a00036.html#0eacd87603f41a9aea2126810183f83a" title="Logical OR operation.">bit_or</a>(v2);

1597

<a name="l01573"></a>01573 return ret;

1598

<a name="l01574"></a>01574 #else

1599

<a name="l01575"></a>01575 return <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>(v1).bit_or(v2);

1600

<a name="l01576"></a>01576 #endif

1601

<a name="l01577"></a>01577 }

1602

<a name="l01578"></a>01578

1603

<a name="l01579"></a>01579 //---------------------------------------------------------------------

1604

<a name="l01580"></a>01580

1605

<a name="l01581"></a>01581 template<class Alloc, class MS>

1606

<a name="l01582"></a><a class="code" href="a00088.html#7042429992aec5891a3df1b0bddea05f">01582</a> inline <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> <a class="code" href="a00088.html#7042429992aec5891a3df1b0bddea05f">operator^ </a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& v1,

1607

<a name="l01583"></a>01583 const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& v2)

1608

<a name="l01584"></a>01584 {

1609

<a name="l01585"></a>01585 #ifdef BM_USE_EXPLICIT_TEMP

1610

<a name="l01586"></a>01586 <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> ret(v1);

1611

<a name="l01587"></a>01587 ret.<a class="code" href="a00036.html#997a62ec2effcd60246fb9b72f30ccfa" title="Logical XOR operation.">bit_xor</a>(v2);

1612

<a name="l01588"></a>01588 return ret;

1613

<a name="l01589"></a>01589 #else

1614

<a name="l01590"></a>01590 return <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>(v1).bit_xor(v2);

1615

<a name="l01591"></a>01591 #endif

1616

<a name="l01592"></a>01592 }

1617

<a name="l01593"></a>01593

1618

<a name="l01594"></a>01594 //---------------------------------------------------------------------

1619

<a name="l01595"></a>01595

1620

<a name="l01596"></a>01596 template<class Alloc, class MS>

1621

<a name="l01597"></a><a class="code" href="a00088.html#fe23d0ced66b48b9c4214e0b00dcc5ac">01597</a> inline <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> <a class="code" href="a00088.html#fe23d0ced66b48b9c4214e0b00dcc5ac">operator- </a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& v1,

1622

<a name="l01598"></a>01598 const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& v2)

1623

<a name="l01599"></a>01599 {

1624

<a name="l01600"></a>01600 #ifdef BM_USE_EXPLICIT_TEMP

1625

<a name="l01601"></a>01601 <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> ret(v1);

1626

<a name="l01602"></a>01602 ret.<a class="code" href="a00036.html#6a8e699f9c0571f904d7cbaa2e3ed1f1" title="Logical SUB operation.">bit_sub</a>(v2);

1627

<a name="l01603"></a>01603 return ret;

1628

<a name="l01604"></a>01604 #else

1629

<a name="l01605"></a>01605 return <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>(v1).bit_sub(v2);

1630

<a name="l01606"></a>01606 #endif

1631

<a name="l01607"></a>01607 }

1632

<a name="l01608"></a>01608

1633

<a name="l01609"></a>01609

1634

<a name="l01610"></a>01610

1635

<a name="l01611"></a>01611

1636

<a name="l01612"></a>01612 // -----------------------------------------------------------------------

1637

<a name="l01613"></a>01613

1638

<a name="l01614"></a>01614 template<typename Alloc, typename MS>

1639

<a name="l01615"></a><a class="code" href="a00036.html#14bc35b9b022018f10787b07a5b2af04">01615</a> <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00036.html#14bc35b9b022018f10787b07a5b2af04" 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="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> left,

1640

<a name="l01616"></a>01616 <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> right,

1641

<a name="l01617"></a>01617 bool value)

1642

<a name="l01618"></a>01618 {

1643

<a name="l01619"></a>01619 if (right < left)

1644

<a name="l01620"></a>01620 {

1645

<a name="l01621"></a>01621 return <a class="code" href="a00036.html#14bc35b9b022018f10787b07a5b2af04" title="Sets all bits in the specified closed interval [left,right] Interval must be inside...">set_range</a>(right, left, value);

1646

<a name="l01622"></a>01622 }

1647

<a name="l01623"></a>01623

1648

<a name="l01624"></a>01624 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(left < size_);

1649

<a name="l01625"></a>01625 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(right < size_);

1650

<a name="l01626"></a>01626

1651

<a name="l01627"></a>01627 <a class="code" href="a00068.html#835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false)

1652

<a name="l01628"></a>01628 <a class="code" href="a00072.html#7e6f87ba3230dece2125af5c32e84b05">BM_SET_MMX_GUARD</a>

1653

<a name="l01629"></a>01629

1654

<a name="l01630"></a>01630 set_range_no_check(left, right, value);

1655

<a name="l01631"></a>01631

1656

<a name="l01632"></a>01632 return *this;

1657

<a name="l01633"></a>01633 }

1658

<a name="l01634"></a>01634

1659

<a name="l01635"></a>01635 // -----------------------------------------------------------------------

1660

<a name="l01636"></a>01636

1661

<a name="l01637"></a>01637 template<typename Alloc, typename MS>

1662

<a name="l01638"></a><a class="code" href="a00036.html#71077c1315555301532e24d4d2b95ea2">01638</a> <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00036.html#71077c1315555301532e24d4d2b95ea2" title="Returns count of bits which are 1.">bvector<Alloc, MS>::count</a>() const

1663

<a name="l01639"></a>01639 {

1664

<a name="l01640"></a>01640 #ifdef BMCOUNTOPT

1665

<a name="l01641"></a>01641 if (count_is_valid_) return count_;

1666

<a name="l01642"></a>01642 #endif

1667

<a name="l01643"></a>01643 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">word_t</a>*** blk_root = blockman_.get_rootblock();

1668

<a name="l01644"></a>01644 if (!blk_root)

1669

<a name="l01645"></a>01645 {

1670

<a name="l01646"></a>01646 <a class="code" href="a00068.html#1fbebc7fe3c22d768ff6e240437ee8f4">BMCOUNT_SET</a>(0);

1671

<a name="l01647"></a>01647 return 0;

1672

<a name="l01648"></a>01648 }

1673

<a name="l01649"></a>01649 typename blocks_manager_type::block_count_func func(blockman_);

1674

<a name="l01650"></a>01650 <a class="code" href="a00088.html#e8b342c25dc22d6cd26cb96d7ae796db">for_each_nzblock</a>(blk_root, blockman_.effective_top_block_size(),

1675

<a name="l01651"></a>01651 <a class="code" href="a00088.html#40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>, func);

1676

<a name="l01652"></a>01652

1677

<a name="l01653"></a>01653 <a class="code" href="a00068.html#1fbebc7fe3c22d768ff6e240437ee8f4">BMCOUNT_SET</a>(func.count());

1678

<a name="l01654"></a>01654 return func.count();

1679

<a name="l01655"></a>01655 }

1680

<a name="l01656"></a>01656

1681

<a name="l01657"></a>01657 // -----------------------------------------------------------------------

1682

<a name="l01658"></a>01658

1683

<a name="l01659"></a>01659 template<typename Alloc, typename MS>

1684

<a name="l01660"></a><a class="code" href="a00036.html#7be4f9e0741f43869f4dcd9607736c0e">01660</a> void <a class="code" href="a00036.html#7be4f9e0741f43869f4dcd9607736c0e" title="Change size of the bvector.">bvector<Alloc, MS>::resize</a>(size_type new_size)

1685

<a name="l01661"></a>01661 {

1686

<a name="l01662"></a>01662 if (size_ == new_size) return; // nothing to do

1687

<a name="l01663"></a>01663 if (size_ < new_size) // size grows

1688

<a name="l01664"></a>01664 {

1689

<a name="l01665"></a>01665 blockman_.reserve(new_size);

1690

<a name="l01666"></a>01666 size_ = new_size;

1691

<a name="l01667"></a>01667 }

1692

<a name="l01668"></a>01668 else // shrink

1693

<a name="l01669"></a>01669 {

1694

<a name="l01670"></a>01670 <a class="code" href="a00036.html#14bc35b9b022018f10787b07a5b2af04" 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

1695

<a name="l01671"></a>01671 size_ = new_size;

1696

<a name="l01672"></a>01672 }

1697

<a name="l01673"></a>01673 }

1698

<a name="l01674"></a>01674

1699

<a name="l01675"></a>01675 // -----------------------------------------------------------------------

1700

<a name="l01676"></a>01676

1701

<a name="l01677"></a>01677 template<typename Alloc, typename MS>

1702

<a name="l01678"></a><a class="code" href="a00036.html#dbe1a2423ce166b88a0b57e435af2733">01678</a> <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00036.html#dbe1a2423ce166b88a0b57e435af2733" title="Returns count of 1 bits in the given diapason.">bvector<Alloc, MS>::count_range</a>(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> left,

1703

<a name="l01679"></a>01679 <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> right,

1704

<a name="l01680"></a>01680 unsigned* block_count_arr) const

1705

<a name="l01681"></a>01681 {

1706

<a name="l01682"></a>01682 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(left <= right);

1707

<a name="l01683"></a>01683

1708

<a name="l01684"></a>01684 unsigned <a class="code" href="a00036.html#71077c1315555301532e24d4d2b95ea2" title="Returns count of bits which are 1.">count</a> = 0;

1709

<a name="l01685"></a>01685

1710

<a name="l01686"></a>01686 // calculate logical number of start and destination blocks

1711

<a name="l01687"></a>01687 unsigned nblock_left = unsigned(left >> <a class="code" href="a00088.html#d8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

1712

<a name="l01688"></a>01688 unsigned nblock_right = unsigned(right >> <a class="code" href="a00088.html#d8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

1713

<a name="l01689"></a>01689

1714

<a name="l01690"></a>01690 const <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* block = blockman_.get_block(nblock_left);

1715

<a name="l01691"></a>01691 bool left_gap = <a class="code" href="a00072.html#862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nblock_left);

1716

<a name="l01692"></a>01692

1717

<a name="l01693"></a>01693 unsigned nbit_left = unsigned(left & <a class="code" href="a00088.html#201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

1718

<a name="l01694"></a>01694 unsigned nbit_right = unsigned(right & bm::set_block_mask);

1719

<a name="l01695"></a>01695

1720

<a name="l01696"></a>01696 unsigned r =

1721

<a name="l01697"></a>01697 (nblock_left == nblock_right) ? nbit_right : (<a class="code" href="a00088.html#e9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a>-1);

1722

<a name="l01698"></a>01698

1723

<a name="l01699"></a>01699 typename blocks_manager_type::block_count_func func(blockman_);

1724

<a name="l01700"></a>01700

1725

<a name="l01701"></a>01701 if (block)

1726

<a name="l01702"></a>01702 {

1727

<a name="l01703"></a>01703 if ((nbit_left == 0) && (r == (<a class="code" href="a00088.html#e9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a>-1))) // whole block

1728

<a name="l01704"></a>01704 {

1729

<a name="l01705"></a>01705 if (block_count_arr)

1730

<a name="l01706"></a>01706 {

1731

<a name="l01707"></a>01707 count += block_count_arr[nblock_left];

1732

<a name="l01708"></a>01708 }

1733

<a name="l01709"></a>01709 else

1734

<a name="l01710"></a>01710 {

1735

<a name="l01711"></a>01711 func(block, nblock_left);

1736

<a name="l01712"></a>01712 }

1737

<a name="l01713"></a>01713 }

1738

<a name="l01714"></a>01714 else

1739

<a name="l01715"></a>01715 {

1740

<a name="l01716"></a>01716 if (left_gap)

1741

<a name="l01717"></a>01717 {

1742

<a name="l01718"></a>01718 count += <a class="code" href="a00088.html#7324ebded429e15361f62117a2ff18d1" title="Counts 1 bits in GAP buffer in the closed [left, right] diapason.">gap_bit_count_range</a>(<a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block),

1743

<a name="l01719"></a>01719 (<a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>)nbit_left,

1744

<a name="l01720"></a>01720 (<a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>)r);

1745

<a name="l01721"></a>01721 }

1746

<a name="l01722"></a>01722 else

1747

<a name="l01723"></a>01723 {

1748

<a name="l01724"></a>01724 count += <a class="code" href="a00093.html#g2485f707b2629c5ce7681cf9fe385b91">bit_block_calc_count_range</a>(block, nbit_left, r);

1749

<a name="l01725"></a>01725 }

1750

<a name="l01726"></a>01726 }

1751

<a name="l01727"></a>01727 }

1752

<a name="l01728"></a>01728

1753

<a name="l01729"></a>01729 if (nblock_left == nblock_right) // in one block

1754

<a name="l01730"></a>01730 {

1755

<a name="l01731"></a>01731 return count + func.count();

1756

<a name="l01732"></a>01732 }

1757

<a name="l01733"></a>01733

1758

<a name="l01734"></a>01734 for (unsigned nb = nblock_left+1; nb < nblock_right; ++nb)

1759

<a name="l01735"></a>01735 {

1760

<a name="l01736"></a>01736 block = blockman_.get_block(nb);

1761

<a name="l01737"></a>01737 if (block_count_arr)

1762

<a name="l01738"></a>01738 {

1763

<a name="l01739"></a>01739 count += block_count_arr[nb];

1764

<a name="l01740"></a>01740 }

1765

<a name="l01741"></a>01741 else

1766

<a name="l01742"></a>01742 {

1767

<a name="l01743"></a>01743 if (block)

1768

<a name="l01744"></a>01744 func(block, nb);

1769

<a name="l01745"></a>01745 }

1770

<a name="l01746"></a>01746 }

1771

<a name="l01747"></a>01747 count += func.count();

1772

<a name="l01748"></a>01748

1773

<a name="l01749"></a>01749 block = blockman_.get_block(nblock_right);

1774

<a name="l01750"></a>01750 bool right_gap = <a class="code" href="a00072.html#862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nblock_right);

1775

<a name="l01751"></a>01751

1776

<a name="l01752"></a>01752 if (block)

1777

<a name="l01753"></a>01753 {

1778

<a name="l01754"></a>01754 if (right_gap)

1779

<a name="l01755"></a>01755 {

1780

<a name="l01756"></a>01756 count += <a class="code" href="a00088.html#7324ebded429e15361f62117a2ff18d1" title="Counts 1 bits in GAP buffer in the closed [left, right] diapason.">gap_bit_count_range</a>(<a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block),

1781

<a name="l01757"></a>01757 (<a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>)0,

1782

<a name="l01758"></a>01758 (<a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>)nbit_right);

1783

<a name="l01759"></a>01759 }

1784

<a name="l01760"></a>01760 else

1785

<a name="l01761"></a>01761 {

1786

<a name="l01762"></a>01762 count += <a class="code" href="a00093.html#g2485f707b2629c5ce7681cf9fe385b91">bit_block_calc_count_range</a>(block, 0, nbit_right);

1787

<a name="l01763"></a>01763 }

1788

<a name="l01764"></a>01764 }

1789

<a name="l01765"></a>01765

1790

<a name="l01766"></a>01766 return count;

1791

<a name="l01767"></a>01767 }

1792

<a name="l01768"></a>01768

1793

<a name="l01769"></a>01769 // -----------------------------------------------------------------------

1794

<a name="l01770"></a>01770

1795

<a name="l01771"></a>01771 template<typename Alloc, typename MS>

1796

<a name="l01772"></a><a class="code" href="a00036.html#49af36cc1ea632cd3a2217b53b69dafc">01772</a> <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00036.html#49af36cc1ea632cd3a2217b53b69dafc" title="Inverts all bits.">bvector<Alloc, MS>::invert</a>()

1797

<a name="l01773"></a>01773 {

1798

<a name="l01774"></a>01774 <a class="code" href="a00068.html#835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false)

1799

<a name="l01775"></a>01775 <a class="code" href="a00072.html#7e6f87ba3230dece2125af5c32e84b05">BM_SET_MMX_GUARD</a>

1800

<a name="l01776"></a>01776

1801

<a name="l01777"></a>01777 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*** blk_root = blockman_.get_rootblock();

1802

<a name="l01778"></a>01778 typename blocks_manager_type::block_invert_func func(blockman_);

1803

<a name="l01779"></a>01779 <a class="code" href="a00088.html#86742a3e17527be5a9743f26b36a7691">for_each_block</a>(blk_root, blockman_.top_block_size(),

1804

<a name="l01780"></a>01780 <a class="code" href="a00088.html#40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>, func);

1805

<a name="l01781"></a>01781 if (size_ == <a class="code" href="a00088.html#104b924a1df81542db2a6296fbf26a65">bm::id_max</a>)

1806

<a name="l01782"></a>01782 {

1807

<a name="l01783"></a>01783 set_bit_no_check(<a class="code" href="a00088.html#104b924a1df81542db2a6296fbf26a65">bm::id_max</a>, false);

1808

<a name="l01784"></a>01784 }

1809

<a name="l01785"></a>01785 else

1810

<a name="l01786"></a>01786 {

1811

<a name="l01787"></a>01787 set_range_no_check(size_, <a class="code" href="a00088.html#104b924a1df81542db2a6296fbf26a65">bm::id_max</a>, false);

1812

<a name="l01788"></a>01788 }

1813

<a name="l01789"></a>01789

1814

<a name="l01790"></a>01790 return *this;

1815

<a name="l01791"></a>01791 }

1816

<a name="l01792"></a>01792

1817

<a name="l01793"></a>01793 // -----------------------------------------------------------------------

1818

<a name="l01794"></a>01794

1819

<a name="l01795"></a>01795 template<typename Alloc, typename MS>

1820

<a name="l01796"></a><a class="code" href="a00036.html#11458ca2e3570838da7b94a1e4563d97">01796</a> bool <a class="code" href="a00036.html#11458ca2e3570838da7b94a1e4563d97" 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="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n) const

1821

<a name="l01797"></a>01797 {

1822

<a name="l01798"></a>01798 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(n < size_);

1823

<a name="l01799"></a>01799

1824

<a name="l01800"></a>01800 // calculate logical block number

1825

<a name="l01801"></a>01801 unsigned nblock = unsigned(n >> <a class="code" href="a00088.html#d8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

1826

<a name="l01802"></a>01802

1827

<a name="l01803"></a>01803 const <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* block = blockman_.get_block(nblock);

1828

<a name="l01804"></a>01804

1829

<a name="l01805"></a>01805 if (block)

1830

<a name="l01806"></a>01806 {

1831

<a name="l01807"></a>01807 // calculate word number in block and bit

1832

<a name="l01808"></a>01808 unsigned nbit = unsigned(n & <a class="code" href="a00088.html#201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

1833

<a name="l01809"></a>01809 unsigned is_set;

1834

<a name="l01810"></a>01810

1835

<a name="l01811"></a>01811 if (<a class="code" href="a00072.html#862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nblock))

1836

<a name="l01812"></a>01812 {

1837

<a name="l01813"></a>01813 is_set = <a class="code" href="a00092.html#g866352ef5986a7d2b709795d127b666b" title="Tests if bit = pos is true.">gap_test</a>(<a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block), nbit);

1838

<a name="l01814"></a>01814 }

1839

<a name="l01815"></a>01815 else

1840

<a name="l01816"></a>01816 {

1841

<a name="l01817"></a>01817 unsigned nword = unsigned(nbit >> <a class="code" href="a00088.html#83d76bccf6fe3770f32d5ba11d2a37ad">bm::set_word_shift</a>);

1842

<a name="l01818"></a>01818 nbit &= <a class="code" href="a00088.html#ddbf345be3733d5e4575d71733ed1da8">bm::set_word_mask</a>;

1843

<a name="l01819"></a>01819

1844

<a name="l01820"></a>01820 is_set = (block[nword] & (((<a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>)1) << nbit));

1845

<a name="l01821"></a>01821 }

1846

<a name="l01822"></a>01822 return is_set != 0;

1847

<a name="l01823"></a>01823 }

1848

<a name="l01824"></a>01824 return false;

1849

<a name="l01825"></a>01825 }

1850

<a name="l01826"></a>01826

1851

<a name="l01827"></a>01827 // -----------------------------------------------------------------------

1852

<a name="l01828"></a>01828

1853

<a name="l01829"></a>01829 template<typename Alloc, typename MS>

1854

<a name="l01830"></a><a class="code" href="a00036.html#bd522c13e26c2b8f84636fe8b6648dcb">01830</a> void <a class="code" href="a00036.html#bd522c13e26c2b8f84636fe8b6648dcb" title="Optimize memory bitvector&#39;s memory allocation.">bvector<Alloc, MS>::optimize</a>(<a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* temp_block,

1855

<a name="l01831"></a>01831 <a class="code" href="a00036.html#05f1e977cb5e6208838afc7e7b69e5f0" title="Optimization mode Every next level means additional checks (better compression vs...">optmode</a> opt_mode,

1856

<a name="l01832"></a>01832 <a class="code" href="a00067.html" title="Statistical information about bitset&#39;s memory allocation details.">statistics</a>* stat)

1857

<a name="l01833"></a>01833 {

1858

<a name="l01834"></a>01834 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">word_t</a>*** blk_root = blockman_.blocks_root();

1859

<a name="l01835"></a>01835

1860

<a name="l01836"></a>01836 if (!temp_block)

1861

<a name="l01837"></a>01837 temp_block = blockman_.check_allocate_tempblock();

1862

<a name="l01838"></a>01838

1863

<a name="l01839"></a>01839 typename

1864

<a name="l01840"></a>01840 blocks_manager_type::block_opt_func opt_func(blockman_,

1865

<a name="l01841"></a>01841 temp_block,

1866

<a name="l01842"></a>01842 (int)opt_mode,

1867

<a name="l01843"></a>01843 stat);

1868

<a name="l01844"></a>01844 if (stat)

1869

<a name="l01845"></a>01845 {

1870

<a name="l01846"></a>01846 stat-><a class="code" href="a00035.html#4ec8ba190b4ba31c431c008402881c62" title="Number of bit blocks.">bit_blocks</a> = stat-><a class="code" href="a00035.html#4dcfd64e9ab0be5472e3c2b04e551f81" title="Number of GAP blocks.">gap_blocks</a>

1871

<a name="l01847"></a>01847 = stat-><a class="code" href="a00035.html#92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a>

1872

<a name="l01848"></a>01848 = stat-><a class="code" href="a00035.html#d3b2190eb4afe24ecd56323cbc0a7666" title="Memory used by bitvector including temp and service blocks.">memory_used</a>

1873

<a name="l01849"></a>01849 = 0;

1874

<a name="l01850"></a>01850 ::memcpy(stat-><a class="code" href="a00035.html#cc08d9637cc25d02d3a50c061ba221e1" title="GAP lengths used by bvector.">gap_levels</a>,

1875

<a name="l01851"></a>01851 blockman_.glen(), sizeof(<a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>) * <a class="code" href="a00088.html#773e9f5341919d58000bd54d50038733">bm::gap_levels</a>);

1876

<a name="l01852"></a>01852 stat-><a class="code" href="a00035.html#92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> = sizeof(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">id_t</a>) * 4;

1877

<a name="l01853"></a>01853

1878

<a name="l01854"></a>01854 }

1879

<a name="l01855"></a>01855

1880

<a name="l01856"></a>01856 <a class="code" href="a00088.html#e8b342c25dc22d6cd26cb96d7ae796db">for_each_nzblock</a>(blk_root, blockman_.effective_top_block_size(),

1881

<a name="l01857"></a>01857 <a class="code" href="a00088.html#40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>, opt_func);

1882

<a name="l01858"></a>01858

1883

<a name="l01859"></a>01859 if (stat)

1884

<a name="l01860"></a>01860 {

1885

<a name="l01861"></a>01861 unsigned safe_inc = stat-><a class="code" href="a00035.html#92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> / 10; // 10% increment

1886

<a name="l01862"></a>01862 if (!safe_inc) safe_inc = 256;

1887

<a name="l01863"></a>01863 stat-><a class="code" href="a00035.html#92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> += safe_inc;

1888

<a name="l01864"></a>01864 stat-><a class="code" href="a00035.html#d3b2190eb4afe24ecd56323cbc0a7666" title="Memory used by bitvector including temp and service blocks.">memory_used</a> += sizeof(*this) - sizeof(blockman_);

1889

<a name="l01865"></a>01865 stat-><a class="code" href="a00035.html#d3b2190eb4afe24ecd56323cbc0a7666" title="Memory used by bitvector including temp and service blocks.">memory_used</a> += blockman_.mem_used();

1890

<a name="l01866"></a>01866 }

1891

<a name="l01867"></a>01867 }

1892

<a name="l01868"></a>01868

1893

<a name="l01869"></a>01869 // -----------------------------------------------------------------------

1894

<a name="l01870"></a>01870

1895

<a name="l01871"></a>01871 template<typename Alloc, typename MS>

1896

<a name="l01872"></a><a class="code" href="a00036.html#3942e3f6ea9fa54fcdb78a35a85008e5">01872</a> void <a class="code" href="a00036.html#3942e3f6ea9fa54fcdb78a35a85008e5" title="Optimize sizes of GAP blocks.">bvector<Alloc, MS>::optimize_gap_size</a>()

1897

<a name="l01873"></a>01873 {

1898

<a name="l01874"></a>01874 struct <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector</a><Alloc, MS>::<a class="code" href="a00067.html" title="Statistical information about bitset&#39;s memory allocation details.">statistics</a> st;

1899

<a name="l01875"></a>01875 <a class="code" href="a00036.html#1eaaac76a97b9eb1d3c11f21cf9385ac" title="Calculates bitvector statistics.">calc_stat</a>(&st);

1900

<a name="l01876"></a>01876

1901

<a name="l01877"></a>01877 if (!st.gap_blocks)

1902

<a name="l01878"></a>01878 return;

1903

<a name="l01879"></a>01879

1904

<a name="l01880"></a>01880 <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a> opt_glen[bm::<a class="code" href="a00088.html#773e9f5341919d58000bd54d50038733">gap_levels</a>];

1905

<a name="l01881"></a>01881 ::memcpy(opt_glen, st.gap_levels, bm::gap_levels * sizeof(*opt_glen));

1906

<a name="l01882"></a>01882

1907

<a name="l01883"></a>01883 <a class="code" href="a00092.html#g2daff3a0ceda6fef87d3b0e892da5813" title="Finds optimal gap blocks lengths.">improve_gap_levels</a>(st.gap_length,

1908

<a name="l01884"></a>01884 st.gap_length + st.gap_blocks,

1909

<a name="l01885"></a>01885 opt_glen);

1910

<a name="l01886"></a>01886

1911

<a name="l01887"></a>01887 <a class="code" href="a00036.html#40d82dec62efe90b0810ccd06b62163e" title="Sets new GAP lengths table. All GAP blocks will be reallocated to match the new scheme...">set_gap_levels</a>(opt_glen);

1912

<a name="l01888"></a>01888 }

1913

<a name="l01889"></a>01889

1914

<a name="l01890"></a>01890 // -----------------------------------------------------------------------

1915

<a name="l01891"></a>01891

1916

<a name="l01892"></a>01892 template<typename Alloc, typename MS>

1917

<a name="l01893"></a><a class="code" href="a00036.html#40d82dec62efe90b0810ccd06b62163e">01893</a> void <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector</a><Alloc, MS>::<a class="code" href="a00036.html#40d82dec62efe90b0810ccd06b62163e" 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)

1918

<a name="l01894"></a>01894 {

1919

<a name="l01895"></a>01895 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">word_t</a>*** blk_root = blockman_.blocks_root();

1920

<a name="l01896"></a>01896

1921

<a name="l01897"></a>01897 typename

1922

<a name="l01898"></a>01898 blocks_manager_type::gap_level_func gl_func(blockman_, glevel_len);

1923

<a name="l01899"></a>01899

1924

<a name="l01900"></a>01900 <a class="code" href="a00088.html#e8b342c25dc22d6cd26cb96d7ae796db">for_each_nzblock</a>(blk_root, blockman_.top_block_size(),

1925

<a name="l01901"></a>01901 <a class="code" href="a00088.html#40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>, gl_func);

1926

<a name="l01902"></a>01902

1927

<a name="l01903"></a>01903 blockman_.set_glen(glevel_len);

1928

<a name="l01904"></a>01904 }

1929

<a name="l01905"></a>01905

1930

<a name="l01906"></a>01906 // -----------------------------------------------------------------------

1931

<a name="l01907"></a>01907

1932

<a name="l01908"></a>01908 template<typename Alloc, typename MS>

1933

<a name="l01909"></a><a class="code" href="a00036.html#a2294dbf9374fd906f74a796d147c255">01909</a> int <a class="code" href="a00036.html#a2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">bvector<Alloc, MS>::compare</a>(const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvect</a>) const

1934

<a name="l01910"></a>01910 {

1935

<a name="l01911"></a>01911 int res;

1936

<a name="l01912"></a>01912 unsigned bn = 0;

1937

<a name="l01913"></a>01913

1938

<a name="l01914"></a>01914 unsigned top_blocks = blockman_.effective_top_block_size();

1939

<a name="l01915"></a>01915 unsigned bvect_top_blocks = bvect.blockman_.effective_top_block_size();

1940

<a name="l01916"></a>01916

1941

<a name="l01917"></a>01917 if (bvect_top_blocks > top_blocks) top_blocks = bvect_top_blocks;

1942

<a name="l01918"></a>01918

1943

<a name="l01919"></a>01919 for (unsigned i = 0; i < top_blocks; ++i)

1944

<a name="l01920"></a>01920 {

1945

<a name="l01921"></a>01921 const <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* const* blk_blk = blockman_.get_topblock(i);

1946

<a name="l01922"></a>01922 const <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* const* arg_blk_blk =

1947

<a name="l01923"></a>01923 bvect.blockman_.get_topblock(i);

1948

<a name="l01924"></a>01924

1949

<a name="l01925"></a>01925 if (blk_blk == arg_blk_blk)

1950

<a name="l01926"></a>01926 {

1951

<a name="l01927"></a>01927 bn += <a class="code" href="a00088.html#40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>;

1952

<a name="l01928"></a>01928 continue;

1953

<a name="l01929"></a>01929 }

1954

<a name="l01930"></a>01930

1955

<a name="l01931"></a>01931 for (unsigned j = 0; j < <a class="code" href="a00088.html#40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>; ++j, ++bn)

1956

<a name="l01932"></a>01932 {

1957

<a name="l01933"></a>01933 const <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* arg_blk = arg_blk_blk ? arg_blk_blk[j] : 0;

1958

<a name="l01934"></a>01934 const <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk = blk_blk ? blk_blk[j] : 0;

1959

<a name="l01935"></a>01935

1960

<a name="l01936"></a>01936 if (blk == arg_blk) continue;

1961

<a name="l01937"></a>01937

1962

<a name="l01938"></a>01938 // If one block is zero we check if the other one has at least

1963

<a name="l01939"></a>01939 // one bit ON

1964

<a name="l01940"></a>01940

1965

<a name="l01941"></a>01941 if (!blk || !arg_blk)

1966

<a name="l01942"></a>01942 {

1967

<a name="l01943"></a>01943 const <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* pblk;

1968

<a name="l01944"></a>01944 bool is_gap;

1969

<a name="l01945"></a>01945

1970

<a name="l01946"></a>01946 if (blk)

1971

<a name="l01947"></a>01947 {

1972

<a name="l01948"></a>01948 pblk = blk;

1973

<a name="l01949"></a>01949 res = 1;

1974

<a name="l01950"></a>01950 is_gap = <a class="code" href="a00072.html#862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>((*this), blk, bn);

1975

<a name="l01951"></a>01951 }

1976

<a name="l01952"></a>01952 else

1977

<a name="l01953"></a>01953 {

1978

<a name="l01954"></a>01954 pblk = arg_blk;

1979

<a name="l01955"></a>01955 res = -1;

1980

<a name="l01956"></a>01956 is_gap = <a class="code" href="a00072.html#862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(bvect, arg_blk, bn);

1981

<a name="l01957"></a>01957 }

1982

<a name="l01958"></a>01958

1983

<a name="l01959"></a>01959 if (is_gap)

1984

<a name="l01960"></a>01960 {

1985

<a name="l01961"></a>01961 if (!<a class="code" href="a00092.html#g690ff7c8b16e1821a77663b7194267e7" title="Temporary inverts all bits in the GAP buffer.">gap_is_all_zero</a>(<a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(pblk), <a class="code" href="a00088.html#d0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a>))

1986

<a name="l01962"></a>01962 {

1987

<a name="l01963"></a>01963 return res;

1988

<a name="l01964"></a>01964 }

1989

<a name="l01965"></a>01965 }

1990

<a name="l01966"></a>01966 else

1991

<a name="l01967"></a>01967 {

1992

<a name="l01968"></a>01968 <a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">bm::wordop_t</a>* blk1 = (<a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">wordop_t</a>*)pblk;

1993

<a name="l01969"></a>01969 <a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">bm::wordop_t</a>* blk2 =

1994

<a name="l01970"></a>01970 (<a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">wordop_t</a>*)(pblk + bm::set_block_size);

1995

<a name="l01971"></a>01971 if (!<a class="code" href="a00093.html#gc6cfb9f92e4df6bb4c76f6efb2382860" title="Returns &quot;true&quot; if all bits in the block are 0.">bit_is_all_zero</a>(blk1, blk2))

1996

<a name="l01972"></a>01972 {

1997

<a name="l01973"></a>01973 return res;

1998

<a name="l01974"></a>01974 }

1999

<a name="l01975"></a>01975 }

2000

<a name="l01976"></a>01976

2001

<a name="l01977"></a>01977 continue;

2002

<a name="l01978"></a>01978 }

2003

<a name="l01979"></a>01979

2004

<a name="l01980"></a>01980 bool arg_gap = <a class="code" href="a00072.html#862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(bvect, arg_blk, bn);

2005

<a name="l01981"></a>01981 bool gap = <a class="code" href="a00072.html#862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>((*this), blk, bn);

2006

<a name="l01982"></a>01982

2007

<a name="l01983"></a>01983 if (arg_gap != gap)

2008

<a name="l01984"></a>01984 {

2009

<a name="l01985"></a>01985 <a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">bm::wordop_t</a> temp_blk[<a class="code" href="a00088.html#7049fd70220fc3a3072e9f82abf4ad66">bm::set_block_size_op</a>];

2010

<a name="l01986"></a>01986 <a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">bm::wordop_t</a>* blk1;

2011

<a name="l01987"></a>01987 <a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">bm::wordop_t</a>* blk2;

2012

<a name="l01988"></a>01988

2013

<a name="l01989"></a>01989 if (gap)

2014

<a name="l01990"></a>01990 {

2015

<a name="l01991"></a>01991 <a class="code" href="a00092.html#g4862f4dcdcb7c0575e2e2db9e5f2a849" title="GAP block to bitblock conversion.">gap_convert_to_bitset</a>((<a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*)temp_blk,

2016

<a name="l01992"></a>01992 <a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk));

2017

<a name="l01993"></a>01993

2018

<a name="l01994"></a>01994 blk1 = (<a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">bm::wordop_t</a>*)temp_blk;

2019

<a name="l01995"></a>01995 blk2 = (<a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">bm::wordop_t</a>*)arg_blk;

2020

<a name="l01996"></a>01996 }

2021

<a name="l01997"></a>01997 else

2022

<a name="l01998"></a>01998 {

2023

<a name="l01999"></a>01999 <a class="code" href="a00092.html#g4862f4dcdcb7c0575e2e2db9e5f2a849" title="GAP block to bitblock conversion.">gap_convert_to_bitset</a>((<a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*)temp_blk,

2024

<a name="l02000"></a>02000 <a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(arg_blk));

2025

<a name="l02001"></a>02001

2026

<a name="l02002"></a>02002 blk1 = (<a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">bm::wordop_t</a>*)blk;

2027

<a name="l02003"></a>02003 blk2 = (<a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">bm::wordop_t</a>*)temp_blk;

2028

<a name="l02004"></a>02004

2029

<a name="l02005"></a>02005 }

2030

<a name="l02006"></a>02006 res = <a class="code" href="a00093.html#g91fe9566575d9d66e1bb9d030b3d29a0" title="Lexicographical comparison of BIT buffers.">bitcmp</a>(blk1, blk2, <a class="code" href="a00088.html#7049fd70220fc3a3072e9f82abf4ad66">bm::set_block_size_op</a>);

2031

<a name="l02007"></a>02007

2032

<a name="l02008"></a>02008 }

2033

<a name="l02009"></a>02009 else

2034

<a name="l02010"></a>02010 {

2035

<a name="l02011"></a>02011 if (gap)

2036

<a name="l02012"></a>02012 {

2037

<a name="l02013"></a>02013 res = <a class="code" href="a00092.html#g406952734f1b05962941b32e37b3eb96" title="Lexicographical comparison of GAP buffers.">gapcmp</a>(<a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk), <a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(arg_blk));

2038

<a name="l02014"></a>02014 }

2039

<a name="l02015"></a>02015 else

2040

<a name="l02016"></a>02016 {

2041

<a name="l02017"></a>02017 res = <a class="code" href="a00093.html#g91fe9566575d9d66e1bb9d030b3d29a0" title="Lexicographical comparison of BIT buffers.">bitcmp</a>((<a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">bm::wordop_t</a>*)blk,

2042

<a name="l02018"></a>02018 (<a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">bm::wordop_t</a>*)arg_blk,

2043

<a name="l02019"></a>02019 <a class="code" href="a00088.html#7049fd70220fc3a3072e9f82abf4ad66">bm::set_block_size_op</a>);

2044

<a name="l02020"></a>02020 }

2045

<a name="l02021"></a>02021 }

2046

<a name="l02022"></a>02022

2047

<a name="l02023"></a>02023 if (res != 0)

2048

<a name="l02024"></a>02024 {

2049

<a name="l02025"></a>02025 return res;

2050

<a name="l02026"></a>02026 }

2051

<a name="l02027"></a>02027

2052

<a name="l02028"></a>02028

2053

<a name="l02029"></a>02029 } // for j

2054

<a name="l02030"></a>02030

2055

<a name="l02031"></a>02031 } // for i

2056

<a name="l02032"></a>02032

2057

<a name="l02033"></a>02033 return 0;

2058

<a name="l02034"></a>02034 }

2059

<a name="l02035"></a>02035

2060

<a name="l02036"></a>02036

2061

<a name="l02037"></a>02037 // -----------------------------------------------------------------------

2062

<a name="l02038"></a>02038

2063

<a name="l02039"></a>02039 template<typename Alloc, typename MS>

2064

<a name="l02040"></a><a class="code" href="a00036.html#1eaaac76a97b9eb1d3c11f21cf9385ac">02040</a> void <a class="code" href="a00036.html#1eaaac76a97b9eb1d3c11f21cf9385ac" title="Calculates bitvector statistics.">bvector<Alloc, MS>::calc_stat</a>(struct <a class="code" href="a00067.html" title="Statistical information about bitset&#39;s memory allocation details.">bvector<Alloc, MS>::statistics</a>* st) const

2065

<a name="l02041"></a>02041 {

2066

<a name="l02042"></a>02042 st-><a class="code" href="a00035.html#4ec8ba190b4ba31c431c008402881c62" title="Number of bit blocks.">bit_blocks</a> = st-><a class="code" href="a00035.html#4dcfd64e9ab0be5472e3c2b04e551f81" title="Number of GAP blocks.">gap_blocks</a>

2067

<a name="l02043"></a>02043 = st-><a class="code" href="a00035.html#92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a>

2068

<a name="l02044"></a>02044 = st-><a class="code" href="a00035.html#d3b2190eb4afe24ecd56323cbc0a7666" title="Memory used by bitvector including temp and service blocks.">memory_used</a> = 0;

2069

<a name="l02045"></a>02045

2070

<a name="l02046"></a>02046 ::memcpy(st-><a class="code" href="a00035.html#cc08d9637cc25d02d3a50c061ba221e1" title="GAP lengths used by bvector.">gap_levels</a>,

2071

<a name="l02047"></a>02047 blockman_.glen(), sizeof(<a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>) * <a class="code" href="a00088.html#773e9f5341919d58000bd54d50038733">bm::gap_levels</a>);

2072

<a name="l02048"></a>02048

2073

<a name="l02049"></a>02049 unsigned empty_blocks = 0;

2074

<a name="l02050"></a>02050 unsigned blocks_memory = 0;

2075

<a name="l02051"></a>02051 <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>* gapl_ptr = st-><a class="code" href="a00035.html#824dd18d515305d159c48a697696cbb6" title="Array of all GAP block lengths in the bvector.">gap_length</a>;

2076

<a name="l02052"></a>02052

2077

<a name="l02053"></a>02053 st-><a class="code" href="a00035.html#92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> = sizeof(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">id_t</a>) * 4;

2078

<a name="l02054"></a>02054

2079

<a name="l02055"></a>02055 unsigned block_idx = 0;

2080

<a name="l02056"></a>02056

2081

<a name="l02057"></a>02057 unsigned top_size = blockman_.effective_top_block_size();

2082

<a name="l02058"></a>02058 // Walk the blocks, calculate statistics.

2083

<a name="l02059"></a>02059 for (unsigned i = 0; i < top_size; ++i)

2084

<a name="l02060"></a>02060 {

2085

<a name="l02061"></a>02061 const <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* const* blk_blk = blockman_.get_topblock(i);

2086

<a name="l02062"></a>02062

2087

<a name="l02063"></a>02063 if (!blk_blk)

2088

<a name="l02064"></a>02064 {

2089

<a name="l02065"></a>02065 block_idx += <a class="code" href="a00088.html#40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>;

2090

<a name="l02066"></a>02066 st-><a class="code" href="a00035.html#92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> += sizeof(unsigned) + 1;

2091

<a name="l02067"></a>02067 continue;

2092

<a name="l02068"></a>02068 }

2093

<a name="l02069"></a>02069

2094

<a name="l02070"></a>02070 for (unsigned j = 0;j < <a class="code" href="a00088.html#40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>; ++j, ++block_idx)

2095

<a name="l02071"></a>02071 {

2096

<a name="l02072"></a>02072 const <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk = blk_blk[j];

2097

<a name="l02073"></a>02073 if (<a class="code" href="a00072.html#13ba598909515339ceede09e3b9b0198">IS_VALID_ADDR</a>(blk))

2098

<a name="l02074"></a>02074 {

2099

<a name="l02075"></a>02075 st-><a class="code" href="a00035.html#92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> += empty_blocks << 2;

2100

<a name="l02076"></a>02076 empty_blocks = 0;

2101

<a name="l02077"></a>02077

2102

<a name="l02078"></a>02078 if (<a class="code" href="a00072.html#862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, blk, block_idx)) // gap block

2103

<a name="l02079"></a>02079 {

2104

<a name="l02080"></a>02080 ++(st-><a class="code" href="a00035.html#4dcfd64e9ab0be5472e3c2b04e551f81" title="Number of GAP blocks.">gap_blocks</a>);

2105

<a name="l02081"></a>02081

2106

<a name="l02082"></a>02082 <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">bm::gap_word_t</a>* gap_blk = <a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk);

2107

<a name="l02083"></a>02083

2108

<a name="l02084"></a>02084 unsigned mem_used =

2109

<a name="l02085"></a>02085 <a class="code" href="a00092.html#g0419ed06e2f0b7891e7d721546f5fb45" title="Returs GAP block capacity.">bm::gap_capacity</a>(gap_blk, blockman_.glen())

2110

<a name="l02086"></a>02086 * sizeof(<a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>);

2111

<a name="l02087"></a>02087

2112

<a name="l02088"></a>02088 *gapl_ptr = <a class="code" href="a00092.html#gd6bfb9da9950b0df8983a9faf9db5042" title="Returs GAP block length.">gap_length</a>(gap_blk);

2113

<a name="l02089"></a>02089

2114

<a name="l02090"></a>02090 st-><a class="code" href="a00035.html#92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> += *gapl_ptr * sizeof(<a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>);

2115

<a name="l02091"></a>02091 blocks_memory += mem_used;

2116

<a name="l02092"></a>02092

2117

<a name="l02093"></a>02093 ++gapl_ptr;

2118

<a name="l02094"></a>02094 }

2119

<a name="l02095"></a>02095 else // bit block

2120

<a name="l02096"></a>02096 {

2121

<a name="l02097"></a>02097 ++(st-><a class="code" href="a00035.html#4ec8ba190b4ba31c431c008402881c62" title="Number of bit blocks.">bit_blocks</a>);

2122

<a name="l02098"></a>02098 unsigned mem_used = sizeof(<a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>) * bm::set_block_size;

2123

<a name="l02099"></a>02099 st-><a class="code" href="a00035.html#92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> += mem_used;

2124

<a name="l02100"></a>02100 blocks_memory += mem_used;

2125

<a name="l02101"></a>02101 }

2126

<a name="l02102"></a>02102 }

2127

<a name="l02103"></a>02103 else

2128

<a name="l02104"></a>02104 {

2129

<a name="l02105"></a>02105 ++empty_blocks;

2130

<a name="l02106"></a>02106 }

2131

<a name="l02107"></a>02107 }

2132

<a name="l02108"></a>02108 }

2133

<a name="l02109"></a>02109

2134

<a name="l02110"></a>02110 unsigned safe_inc = st-><a class="code" href="a00035.html#92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> / 10; // 10% increment

2135

<a name="l02111"></a>02111 if (!safe_inc) safe_inc = 256;

2136

<a name="l02112"></a>02112 st-><a class="code" href="a00035.html#92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> += safe_inc;

2137

<a name="l02113"></a>02113

2138

<a name="l02114"></a>02114 // Calc size of different odd and temporary things.

2139

<a name="l02115"></a>02115

2140

<a name="l02116"></a>02116 st-><a class="code" href="a00035.html#d3b2190eb4afe24ecd56323cbc0a7666" title="Memory used by bitvector including temp and service blocks.">memory_used</a> += sizeof(*this) - sizeof(blockman_);

2141

<a name="l02117"></a>02117 st-><a class="code" href="a00035.html#d3b2190eb4afe24ecd56323cbc0a7666" title="Memory used by bitvector including temp and service blocks.">memory_used</a> += blockman_.mem_used();

2142

<a name="l02118"></a>02118 st-><a class="code" href="a00035.html#d3b2190eb4afe24ecd56323cbc0a7666" title="Memory used by bitvector including temp and service blocks.">memory_used</a> += blocks_memory;

2143

<a name="l02119"></a>02119 }

2144

<a name="l02120"></a>02120

2145

<a name="l02121"></a>02121

2146

<a name="l02122"></a>02122 // -----------------------------------------------------------------------

2147

<a name="l02123"></a>02123

2148

<a name="l02124"></a>02124

2149

<a name="l02125"></a>02125 template<class Alloc, class MS>

2150

<a name="l02126"></a>02126 bool <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS>::set_bit_no_check</a>(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val)

2151

<a name="l02127"></a>02127 {

2152

<a name="l02128"></a>02128 // calculate logical block number

2153

<a name="l02129"></a>02129 unsigned nblock = unsigned(n >> <a class="code" href="a00088.html#d8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

2154

<a name="l02130"></a>02130

2155

<a name="l02131"></a>02131 int block_type;

2156

<a name="l02132"></a>02132

2157

<a name="l02133"></a>02133 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk =

2158

<a name="l02134"></a>02134 blockman_.check_allocate_block(nblock,

2159

<a name="l02135"></a>02135 val,

2160

<a name="l02136"></a>02136 <a class="code" href="a00036.html#d971c541fa259278e9dcf541b2d128c9" title="Returns blocks allocation strategy.">get_new_blocks_strat</a>(),

2161

<a name="l02137"></a>02137 &block_type);

2162

<a name="l02138"></a>02138

2163

<a name="l02139"></a>02139 if (!blk) return false;

2164

<a name="l02140"></a>02140

2165

<a name="l02141"></a>02141 // calculate word number in block and bit

2166

<a name="l02142"></a>02142 unsigned nbit = unsigned(n & <a class="code" href="a00088.html#201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2167

<a name="l02143"></a>02143

2168

<a name="l02144"></a>02144 if (block_type == 1) // gap

2169

<a name="l02145"></a>02145 {

2170

<a name="l02146"></a>02146 unsigned is_set;

2171

<a name="l02147"></a>02147 unsigned new_block_len;

2172

<a name="l02148"></a>02148

2173

<a name="l02149"></a>02149 new_block_len =

2174

<a name="l02150"></a>02150 <a class="code" href="a00092.html#g69186bd13bda27e04b3e33683ff884c2" title="Abstract distance(similarity) operation for GAP buffers. Receives functor F as a...">gap_set_value</a>(val, <a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk), nbit, &is_set);

2175

<a name="l02151"></a>02151 if (is_set)

2176

<a name="l02152"></a>02152 {

2177

<a name="l02153"></a>02153 <a class="code" href="a00068.html#ef4146eb86de042a6c34717f87b16c10">BMCOUNT_ADJ</a>(val)

2178

<a name="l02154"></a>02154

2179

<a name="l02155"></a>02155 unsigned threshold =

2180

<a name="l02156"></a>02156 bm::<a class="code" href="a00092.html#g94a5371b5dc6a1560d95d7c2dde88815" title="Returs GAP block capacity limit.">gap_limit</a>(<a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk), blockman_.glen());

2181

<a name="l02157"></a>02157

2182

<a name="l02158"></a>02158 if (new_block_len > threshold)

2183

<a name="l02159"></a>02159 {

2184

<a name="l02160"></a>02160 extend_gap_block(nblock, <a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk));

2185

<a name="l02161"></a>02161 }

2186

<a name="l02162"></a>02162 return true;

2187

<a name="l02163"></a>02163 }

2188

<a name="l02164"></a>02164 }

2189

<a name="l02165"></a>02165 else // bit block

2190

<a name="l02166"></a>02166 {

2191

<a name="l02167"></a>02167 unsigned nword = unsigned(nbit >> <a class="code" href="a00088.html#83d76bccf6fe3770f32d5ba11d2a37ad">bm::set_word_shift</a>);

2192

<a name="l02168"></a>02168 nbit &= <a class="code" href="a00088.html#ddbf345be3733d5e4575d71733ed1da8">bm::set_word_mask</a>;

2193

<a name="l02169"></a>02169

2194

<a name="l02170"></a>02170 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* word = blk + nword;

2195

<a name="l02171"></a>02171 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a> mask = (((<a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>)1) << nbit);

2196

<a name="l02172"></a>02172

2197

<a name="l02173"></a>02173 if (val)

2198

<a name="l02174"></a>02174 {

2199

<a name="l02175"></a>02175 if ( ((*word) & mask) == 0 )

2200

<a name="l02176"></a>02176 {

2201

<a name="l02177"></a>02177 *word |= mask; // set bit

2202

<a name="l02178"></a>02178 <a class="code" href="a00068.html#911e3d9e9a293cafab1396a8700288e9">BMCOUNT_INC</a>;

2203

<a name="l02179"></a>02179 return true;

2204

<a name="l02180"></a>02180 }

2205

<a name="l02181"></a>02181 }

2206

<a name="l02182"></a>02182 else

2207

<a name="l02183"></a>02183 {

2208

<a name="l02184"></a>02184 if ((*word) & mask)

2209

<a name="l02185"></a>02185 {

2210

<a name="l02186"></a>02186 *word &= ~mask; // clear bit

2211

<a name="l02187"></a>02187 <a class="code" href="a00068.html#809c66152f5967c1a1eb51e006206630">BMCOUNT_DEC</a>;

2212

<a name="l02188"></a>02188 return true;

2213

<a name="l02189"></a>02189 }

2214

<a name="l02190"></a>02190 }

2215

<a name="l02191"></a>02191 }

2216

<a name="l02192"></a>02192 return false;

2217

<a name="l02193"></a>02193 }

2218

<a name="l02194"></a>02194

2219

<a name="l02195"></a>02195 // -----------------------------------------------------------------------

2220

<a name="l02196"></a>02196

2221

<a name="l02197"></a>02197 template<class Alloc, class MS>

2222

<a name="l02198"></a>02198 bool bvector<Alloc, MS>::set_bit_conditional_impl(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n,

2223

<a name="l02199"></a>02199 bool val,

2224

<a name="l02200"></a>02200 bool condition)

2225

<a name="l02201"></a>02201 {

2226

<a name="l02202"></a>02202 // calculate logical block number

2227

<a name="l02203"></a>02203 unsigned nblock = unsigned(n >> <a class="code" href="a00088.html#d8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

2228

<a name="l02204"></a>02204

2229

<a name="l02205"></a>02205 int block_type;

2230

<a name="l02206"></a>02206 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk =

2231

<a name="l02207"></a>02207 blockman_.check_allocate_block(nblock,

2232

<a name="l02208"></a>02208 val,

2233

<a name="l02209"></a>02209 <a class="code" href="a00036.html#d971c541fa259278e9dcf541b2d128c9" title="Returns blocks allocation strategy.">get_new_blocks_strat</a>(),

2234

<a name="l02210"></a>02210 &block_type);

2235

<a name="l02211"></a>02211 if (!blk)

2236

<a name="l02212"></a>02212 return false;

2237

<a name="l02213"></a>02213

2238

<a name="l02214"></a>02214 // calculate word number in block and bit

2239

<a name="l02215"></a>02215 unsigned nbit = unsigned(n & <a class="code" href="a00088.html#201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2240

<a name="l02216"></a>02216

2241

<a name="l02217"></a>02217 if (block_type == 1) // gap

2242

<a name="l02218"></a>02218 {

2243

<a name="l02219"></a>02219 <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">bm::gap_word_t</a>* gap_blk = <a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk);

2244

<a name="l02220"></a>02220 bool old_val = (<a class="code" href="a00092.html#g866352ef5986a7d2b709795d127b666b" title="Tests if bit = pos is true.">gap_test</a>(gap_blk, nbit) != 0);

2245

<a name="l02221"></a>02221

2246

<a name="l02222"></a>02222 if (old_val != condition)

2247

<a name="l02223"></a>02223 {

2248

<a name="l02224"></a>02224 return false;

2249

<a name="l02225"></a>02225 }

2250

<a name="l02226"></a>02226

2251

<a name="l02227"></a>02227 if (val != old_val)

2252

<a name="l02228"></a>02228 {

2253

<a name="l02229"></a>02229 unsigned is_set;

2254

<a name="l02230"></a>02230 unsigned new_block_len =

2255

<a name="l02231"></a>02231 <a class="code" href="a00092.html#g69186bd13bda27e04b3e33683ff884c2" title="Abstract distance(similarity) operation for GAP buffers. Receives functor F as a...">gap_set_value</a>(val, gap_blk, nbit, &is_set);

2256

<a name="l02232"></a>02232 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(is_set);

2257

<a name="l02233"></a>02233 <a class="code" href="a00068.html#ef4146eb86de042a6c34717f87b16c10">BMCOUNT_ADJ</a>(val)

2258

<a name="l02234"></a>02234

2259

<a name="l02235"></a>02235 unsigned threshold =

2260

<a name="l02236"></a>02236 bm::<a class="code" href="a00092.html#g94a5371b5dc6a1560d95d7c2dde88815" title="Returs GAP block capacity limit.">gap_limit</a>(gap_blk, blockman_.glen());

2261

<a name="l02237"></a>02237 if (new_block_len > threshold)

2262

<a name="l02238"></a>02238 {

2263

<a name="l02239"></a>02239 extend_gap_block(nblock, gap_blk);

2264

<a name="l02240"></a>02240 }

2265

<a name="l02241"></a>02241 return true;

2266

<a name="l02242"></a>02242 }

2267

<a name="l02243"></a>02243 }

2268

<a name="l02244"></a>02244 else // bit block

2269

<a name="l02245"></a>02245 {

2270

<a name="l02246"></a>02246 unsigned nword = unsigned(nbit >> <a class="code" href="a00088.html#83d76bccf6fe3770f32d5ba11d2a37ad">bm::set_word_shift</a>);

2271

<a name="l02247"></a>02247 nbit &= <a class="code" href="a00088.html#ddbf345be3733d5e4575d71733ed1da8">bm::set_word_mask</a>;

2272

<a name="l02248"></a>02248

2273

<a name="l02249"></a>02249 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* word = blk + nword;

2274

<a name="l02250"></a>02250 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a> mask = (((<a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>)1) << nbit);

2275

<a name="l02251"></a>02251 bool is_set = ((*word) & mask) != 0;

2276

<a name="l02252"></a>02252

2277

<a name="l02253"></a>02253 if (is_set != condition)

2278

<a name="l02254"></a>02254 {

2279

<a name="l02255"></a>02255 return false;

2280

<a name="l02256"></a>02256 }

2281

<a name="l02257"></a>02257 if (is_set != val) // need to change bit

2282

<a name="l02258"></a>02258 {

2283

<a name="l02259"></a>02259 if (val) // set bit

2284

<a name="l02260"></a>02260 {

2285

<a name="l02261"></a>02261 *word |= mask;

2286

<a name="l02262"></a>02262 <a class="code" href="a00068.html#911e3d9e9a293cafab1396a8700288e9">BMCOUNT_INC</a>;

2287

<a name="l02263"></a>02263 }

2288

<a name="l02264"></a>02264 else // clear bit

2289

<a name="l02265"></a>02265 {

2290

<a name="l02266"></a>02266 *word &= ~mask;

2291

<a name="l02267"></a>02267 <a class="code" href="a00068.html#809c66152f5967c1a1eb51e006206630">BMCOUNT_DEC</a>;

2292

<a name="l02268"></a>02268 }

2293

<a name="l02269"></a>02269 return true;

2294

<a name="l02270"></a>02270 }

2295

<a name="l02271"></a>02271 }

2296

<a name="l02272"></a>02272 return false;

2297

<a name="l02273"></a>02273

2298

<a name="l02274"></a>02274 }

2299

<a name="l02275"></a>02275

2300

<a name="l02276"></a>02276 // -----------------------------------------------------------------------

2301

<a name="l02277"></a>02277

2302

<a name="l02278"></a>02278

2303

<a name="l02279"></a>02279 template<class Alloc, class MS>

2304

<a name="l02280"></a>02280 bool bvector<Alloc, MS>::and_bit_no_check(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val)

2305

<a name="l02281"></a>02281 {

2306

<a name="l02282"></a>02282 // calculate logical block number

2307

<a name="l02283"></a>02283 unsigned nblock = unsigned(n >> <a class="code" href="a00088.html#d8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

2308

<a name="l02284"></a>02284

2309

<a name="l02285"></a>02285 int block_type;

2310

<a name="l02286"></a>02286 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk =

2311

<a name="l02287"></a>02287 blockman_.check_allocate_block(nblock,

2312

<a name="l02288"></a>02288 val,

2313

<a name="l02289"></a>02289 <a class="code" href="a00036.html#d971c541fa259278e9dcf541b2d128c9" title="Returns blocks allocation strategy.">get_new_blocks_strat</a>(),

2314

<a name="l02290"></a>02290 &block_type);

2315

<a name="l02291"></a>02291 if (!blk) return false;

2316

<a name="l02292"></a>02292

2317

<a name="l02293"></a>02293 // calculate word number in block and bit

2318

<a name="l02294"></a>02294 unsigned nbit = unsigned(n & <a class="code" href="a00088.html#201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2319

<a name="l02295"></a>02295

2320

<a name="l02296"></a>02296 if (block_type == 1) // gap

2321

<a name="l02297"></a>02297 {

2322

<a name="l02298"></a>02298 <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">bm::gap_word_t</a>* gap_blk = <a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk);

2323

<a name="l02299"></a>02299 bool old_val = (<a class="code" href="a00092.html#g866352ef5986a7d2b709795d127b666b" title="Tests if bit = pos is true.">gap_test</a>(gap_blk, nbit) != 0);

2324

<a name="l02300"></a>02300

2325

<a name="l02301"></a>02301 bool new_val = val & old_val;

2326

<a name="l02302"></a>02302 if (new_val != old_val)

2327

<a name="l02303"></a>02303 {

2328

<a name="l02304"></a>02304 unsigned is_set;

2329

<a name="l02305"></a>02305 unsigned new_block_len =

2330

<a name="l02306"></a>02306 <a class="code" href="a00092.html#g69186bd13bda27e04b3e33683ff884c2" title="Abstract distance(similarity) operation for GAP buffers. Receives functor F as a...">gap_set_value</a>(new_val, gap_blk, nbit, &is_set);

2331

<a name="l02307"></a>02307 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(is_set);

2332

<a name="l02308"></a>02308 <a class="code" href="a00068.html#ef4146eb86de042a6c34717f87b16c10">BMCOUNT_ADJ</a>(val)

2333

<a name="l02309"></a>02309

2334

<a name="l02310"></a>02310 unsigned threshold =

2335

<a name="l02311"></a>02311 bm::<a class="code" href="a00092.html#g94a5371b5dc6a1560d95d7c2dde88815" title="Returs GAP block capacity limit.">gap_limit</a>(gap_blk, blockman_.glen());

2336

<a name="l02312"></a>02312 if (new_block_len > threshold)

2337

<a name="l02313"></a>02313 {

2338

<a name="l02314"></a>02314 extend_gap_block(nblock, gap_blk);

2339

<a name="l02315"></a>02315 }

2340

<a name="l02316"></a>02316 return true;

2341

<a name="l02317"></a>02317 }

2342

<a name="l02318"></a>02318 }

2343

<a name="l02319"></a>02319 else // bit block

2344

<a name="l02320"></a>02320 {

2345

<a name="l02321"></a>02321 unsigned nword = unsigned(nbit >> <a class="code" href="a00088.html#83d76bccf6fe3770f32d5ba11d2a37ad">bm::set_word_shift</a>);

2346

<a name="l02322"></a>02322 nbit &= <a class="code" href="a00088.html#ddbf345be3733d5e4575d71733ed1da8">bm::set_word_mask</a>;

2347

<a name="l02323"></a>02323

2348

<a name="l02324"></a>02324 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* word = blk + nword;

2349

<a name="l02325"></a>02325 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a> mask = (((<a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>)1) << nbit);

2350

<a name="l02326"></a>02326 bool is_set = ((*word) & mask) != 0;

2351

<a name="l02327"></a>02327

2352

<a name="l02328"></a>02328 bool new_val = is_set & val;

2353

<a name="l02329"></a>02329 if (new_val != val) // need to change bit

2354

<a name="l02330"></a>02330 {

2355

<a name="l02331"></a>02331 if (new_val) // set bit

2356

<a name="l02332"></a>02332 {

2357

<a name="l02333"></a>02333 *word |= mask;

2358

<a name="l02334"></a>02334 <a class="code" href="a00068.html#911e3d9e9a293cafab1396a8700288e9">BMCOUNT_INC</a>;

2359

<a name="l02335"></a>02335 }

2360

<a name="l02336"></a>02336 else // clear bit

2361

<a name="l02337"></a>02337 {

2362

<a name="l02338"></a>02338 *word &= ~mask;

2363

<a name="l02339"></a>02339 <a class="code" href="a00068.html#809c66152f5967c1a1eb51e006206630">BMCOUNT_DEC</a>;

2364

<a name="l02340"></a>02340 }

2365

<a name="l02341"></a>02341 return true;

2366

<a name="l02342"></a>02342 }

2367

<a name="l02343"></a>02343 }

2368

<a name="l02344"></a>02344 return false;

2369

<a name="l02345"></a>02345 }

2370

<a name="l02346"></a>02346

2371

<a name="l02347"></a>02347

2372

<a name="l02348"></a>02348 // -----------------------------------------------------------------------

2373

<a name="l02349"></a>02349

2374

<a name="l02350"></a>02350 template<class Alloc, class MS>

2375

<a name="l02351"></a><a class="code" href="a00036.html#38b22b8b4063ffa46beb8e04a972c4bd">02351</a> void <a class="code" href="a00036.html#38b22b8b4063ffa46beb8e04a972c4bd">bvector<Alloc, MS>::stat</a>(unsigned blocks) const

2376

<a name="l02352"></a>02352 {

2377

<a name="l02353"></a>02353 register <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00036.html#71077c1315555301532e24d4d2b95ea2" title="Returns count of bits which are 1.">count</a> = 0;

2378

<a name="l02354"></a>02354 int printed = 0;

2379

<a name="l02355"></a>02355

2380

<a name="l02356"></a>02356 int total_gap_eff = 0;

2381

<a name="l02357"></a>02357

2382

<a name="l02358"></a>02358 if (!blocks)

2383

<a name="l02359"></a>02359 {

2384

<a name="l02360"></a>02360 blocks = <a class="code" href="a00088.html#505011007f54598794e0b9477c0b0b11">bm::set_total_blocks</a>;

2385

<a name="l02361"></a>02361 }

2386

<a name="l02362"></a>02362

2387

<a name="l02363"></a>02363 unsigned nb;

2388

<a name="l02364"></a>02364 for (nb = 0; nb < blocks; ++nb)

2389

<a name="l02365"></a>02365 {

2390

<a name="l02366"></a>02366 register const <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk = blockman_.get_block(nb);

2391

<a name="l02367"></a>02367

2392

<a name="l02368"></a>02368 if (blk == 0)

2393

<a name="l02369"></a>02369 {

2394

<a name="l02370"></a>02370 continue;

2395

<a name="l02371"></a>02371 }

2396

<a name="l02372"></a>02372

2397

<a name="l02373"></a>02373 if (<a class="code" href="a00072.html#074acb37afea68caaffe3832d326eb44">IS_FULL_BLOCK</a>(blk))

2398

<a name="l02374"></a>02374 {

2399

<a name="l02375"></a>02375 if (blockman_.is_block_gap(nb)) // gap block

2400

<a name="l02376"></a>02376 {

2401

<a name="l02377"></a>02377 printf("[Alert!%i]", nb);

2402

<a name="l02378"></a>02378 assert(0);

2403

<a name="l02379"></a>02379 }

2404

<a name="l02380"></a>02380

2405

<a name="l02381"></a>02381 unsigned start = nb;

2406

<a name="l02382"></a>02382 for(unsigned i = nb+1; i < <a class="code" href="a00088.html#505011007f54598794e0b9477c0b0b11">bm::set_total_blocks</a>; ++i, ++nb)

2407

<a name="l02383"></a>02383 {

2408

<a name="l02384"></a>02384 blk = blockman_.get_block(nb);

2409

<a name="l02385"></a>02385 if (<a class="code" href="a00072.html#074acb37afea68caaffe3832d326eb44">IS_FULL_BLOCK</a>(blk))

2410

<a name="l02386"></a>02386 {

2411

<a name="l02387"></a>02387 if (blockman_.is_block_gap(nb)) // gap block

2412

<a name="l02388"></a>02388 {

2413

<a name="l02389"></a>02389 printf("[Alert!%i]", nb);

2414

<a name="l02390"></a>02390 assert(0);

2415

<a name="l02391"></a>02391 --nb;

2416

<a name="l02392"></a>02392 break;

2417

<a name="l02393"></a>02393 }

2418

<a name="l02394"></a>02394

2419

<a name="l02395"></a>02395 }

2420

<a name="l02396"></a>02396 else

2421

<a name="l02397"></a>02397 {

2422

<a name="l02398"></a>02398 --nb;

2423

<a name="l02399"></a>02399 break;

2424

<a name="l02400"></a>02400 }

2425

<a name="l02401"></a>02401 }

2426

<a name="l02402"></a>02402

2427

<a name="l02403"></a>02403 printf("{F.%i:%i}",start, nb);

2428

<a name="l02404"></a>02404 ++printed;

2429

<a name="l02405"></a>02405 }

2430

<a name="l02406"></a>02406 else

2431

<a name="l02407"></a>02407 {

2432

<a name="l02408"></a>02408 if (blockman_.is_block_gap(nb)) // gap block

2433

<a name="l02409"></a>02409 {

2434

<a name="l02410"></a>02410 unsigned bc = <a class="code" href="a00092.html#g226273a798a07069564e73eb98d06838" title="Calculates number of bits ON in GAP buffer.">gap_bit_count</a>(<a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk));

2435

<a name="l02411"></a>02411 /*unsigned sum = */<a class="code" href="a00092.html#g14d29338ffd1387758810b3f9e3a72c6" title="Calculates sum of all words in GAP block. (For debugging purposes).">gap_control_sum</a>(<a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk));

2436

<a name="l02412"></a>02412 unsigned level = <a class="code" href="a00092.html#g1defe73aa4227a0e7204363ac6bb1ac1" title="Returs GAP blocks capacity level.">gap_level</a>(<a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk));

2437

<a name="l02413"></a>02413 count += bc;

2438

<a name="l02414"></a>02414 unsigned len = <a class="code" href="a00092.html#gd6bfb9da9950b0df8983a9faf9db5042" title="Returs GAP block length.">gap_length</a>(<a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk))-1;

2439

<a name="l02415"></a>02415 unsigned raw_size=bc*2;

2440

<a name="l02416"></a>02416 unsigned cmr_len=len*2;

2441

<a name="l02417"></a>02417 int mem_eff = raw_size - cmr_len;

2442

<a name="l02418"></a>02418 total_gap_eff += mem_eff;

2443

<a name="l02419"></a>02419

2444

<a name="l02420"></a>02420 unsigned i,j;

2445

<a name="l02421"></a>02421 blockman_.get_block_coord(nb, &i, &j);

2446

<a name="l02422"></a>02422 printf("[ GAP %i(%i,%i)=%i:%i-%i(%i) ]", nb, i, j, bc, level, len, mem_eff);

2447

<a name="l02423"></a>02423 ++printed;

2448

<a name="l02424"></a>02424 }

2449

<a name="l02425"></a>02425 else // bitset

2450

<a name="l02426"></a>02426 {

2451

<a name="l02427"></a>02427 const <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk_end = blk + bm::set_block_size;

2452

<a name="l02428"></a>02428 unsigned bc = <a class="code" href="a00093.html#gb30df14a61f036d690c091878feaff1c" title="Bitcount for bit string.">bit_block_calc_count</a>(blk, blk_end);

2453

<a name="l02429"></a>02429

2454

<a name="l02430"></a>02430 unsigned zw = 0;

2455

<a name="l02431"></a>02431 for (unsigned i = 0; i < bm::set_block_size; ++i)

2456

<a name="l02432"></a>02432 {

2457

<a name="l02433"></a>02433 zw += (blk[i] == 0);

2458

<a name="l02434"></a>02434 }

2459

<a name="l02435"></a>02435

2460

<a name="l02436"></a>02436 count += bc;

2461

<a name="l02437"></a>02437 printf("( BIT %i=%i[%i] )", nb, bc, zw);

2462

<a name="l02438"></a>02438 ++printed;

2463

<a name="l02439"></a>02439

2464

<a name="l02440"></a>02440 }

2465

<a name="l02441"></a>02441 }

2466

<a name="l02442"></a>02442 if (printed == 10)

2467

<a name="l02443"></a>02443 {

2468

<a name="l02444"></a>02444 printed = 0;

2469

<a name="l02445"></a>02445 printf("\n");

2470

<a name="l02446"></a>02446 }

2471

<a name="l02447"></a>02447 } // for nb

2472

<a name="l02448"></a>02448 printf("\n");

2473

<a name="l02449"></a>02449 printf("gap_efficiency=%i\n", total_gap_eff);

2474

<a name="l02450"></a>02450

2475

<a name="l02451"></a>02451 }

2476

<a name="l02452"></a>02452

2477

<a name="l02453"></a>02453 //---------------------------------------------------------------------

2478

<a name="l02454"></a>02454

2479

<a name="l02455"></a>02455 template<class Alloc, class MS>

2480

<a name="l02456"></a>02456 <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS>::check_or_next</a>(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> prev) const

2481

<a name="l02457"></a>02457 {

2482

<a name="l02458"></a>02458 for (;;)

2483

<a name="l02459"></a>02459 {

2484

<a name="l02460"></a>02460 unsigned nblock = unsigned(prev >> <a class="code" href="a00088.html#d8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

2485

<a name="l02461"></a>02461 if (nblock >= <a class="code" href="a00088.html#505011007f54598794e0b9477c0b0b11">bm::set_total_blocks</a>)

2486

<a name="l02462"></a>02462 break;

2487

<a name="l02463"></a>02463

2488

<a name="l02464"></a>02464 if (blockman_.is_subblock_null(nblock >> <a class="code" href="a00088.html#c1ff8647a089c751ec330cecee01907e">bm::set_array_shift</a>))

2489

<a name="l02465"></a>02465 {

2490

<a name="l02466"></a>02466 prev += (<a class="code" href="a00088.html#2d1bf97ae342a7759943e62090fcf5d3">bm::set_blkblk_mask</a> + 1) -

2491

<a name="l02467"></a>02467 (prev & <a class="code" href="a00088.html#2d1bf97ae342a7759943e62090fcf5d3">bm::set_blkblk_mask</a>);

2492

<a name="l02468"></a>02468 }

2493

<a name="l02469"></a>02469 else

2494

<a name="l02470"></a>02470 {

2495

<a name="l02471"></a>02471 unsigned nbit = unsigned(prev & <a class="code" href="a00088.html#201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2496

<a name="l02472"></a>02472 int no_more_blocks;

2497

<a name="l02473"></a>02473 const <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* block =

2498

<a name="l02474"></a>02474 blockman_.get_block(nblock, &no_more_blocks);

2499

<a name="l02475"></a>02475

2500

<a name="l02476"></a>02476 if (no_more_blocks)

2501

<a name="l02477"></a>02477 {

2502

<a name="l02478"></a>02478 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(block == 0);

2503

<a name="l02479"></a>02479 break;

2504

<a name="l02480"></a>02480 }

2505

<a name="l02481"></a>02481

2506

<a name="l02482"></a>02482 if (block)

2507

<a name="l02483"></a>02483 {

2508

<a name="l02484"></a>02484 if (<a class="code" href="a00072.html#074acb37afea68caaffe3832d326eb44">IS_FULL_BLOCK</a>(block)) return prev;

2509

<a name="l02485"></a>02485 if (<a class="code" href="a00072.html#862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nblock))

2510

<a name="l02486"></a>02486 {

2511

<a name="l02487"></a>02487 if (<a class="code" href="a00092.html#ga7df7193094353ea24b8519debf745be" title="Searches for the next 1 bit in the GAP block.">bm::gap_find_in_block</a>(<a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block),

2512

<a name="l02488"></a>02488 nbit,

2513

<a name="l02489"></a>02489 &prev))

2514

<a name="l02490"></a>02490 {

2515

<a name="l02491"></a>02491 return prev;

2516

<a name="l02492"></a>02492 }

2517

<a name="l02493"></a>02493 }

2518

<a name="l02494"></a>02494 else

2519

<a name="l02495"></a>02495 {

2520

<a name="l02496"></a>02496 if (<a class="code" href="a00093.html#gd6a7c549a625df7aa7d68d43a57238c7" title="Searches for the next 1 bit in the BIT block.">bm::bit_find_in_block</a>(block, nbit, &prev))

2521

<a name="l02497"></a>02497 {

2522

<a name="l02498"></a>02498 return prev;

2523

<a name="l02499"></a>02499 }

2524

<a name="l02500"></a>02500 }

2525

<a name="l02501"></a>02501 }

2526

<a name="l02502"></a>02502 else

2527

<a name="l02503"></a>02503 {

2528

<a name="l02504"></a>02504 prev += (<a class="code" href="a00088.html#201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a> + 1) -

2529

<a name="l02505"></a>02505 (prev & <a class="code" href="a00088.html#201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2530

<a name="l02506"></a>02506 }

2531

<a name="l02507"></a>02507

2532

<a name="l02508"></a>02508 }

2533

<a name="l02509"></a>02509 if (!prev) break;

2534

<a name="l02510"></a>02510 }

2535

<a name="l02511"></a>02511

2536

<a name="l02512"></a>02512 return 0;

2537

<a name="l02513"></a>02513 }

2538

<a name="l02514"></a>02514

2539

<a name="l02515"></a>02515

2540

<a name="l02516"></a>02516 //---------------------------------------------------------------------

2541

<a name="l02517"></a>02517

2542

<a name="l02518"></a>02518 template<class Alloc, class MS>

2543

<a name="l02519"></a>02519 <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> bvector<Alloc, MS>::check_or_next_extract(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> prev)

2544

<a name="l02520"></a>02520 {

2545

<a name="l02521"></a>02521 for (;;)

2546

<a name="l02522"></a>02522 {

2547

<a name="l02523"></a>02523 unsigned nblock = unsigned(prev >> <a class="code" href="a00088.html#d8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

2548

<a name="l02524"></a>02524 if (nblock >= <a class="code" href="a00088.html#505011007f54598794e0b9477c0b0b11">bm::set_total_blocks</a>) break;

2549

<a name="l02525"></a>02525

2550

<a name="l02526"></a>02526 if (blockman_.is_subblock_null(nblock >> <a class="code" href="a00088.html#c1ff8647a089c751ec330cecee01907e">bm::set_array_shift</a>))

2551

<a name="l02527"></a>02527 {

2552

<a name="l02528"></a>02528 prev += (<a class="code" href="a00088.html#2d1bf97ae342a7759943e62090fcf5d3">bm::set_blkblk_mask</a> + 1) -

2553

<a name="l02529"></a>02529 (prev & <a class="code" href="a00088.html#2d1bf97ae342a7759943e62090fcf5d3">bm::set_blkblk_mask</a>);

2554

<a name="l02530"></a>02530 }

2555

<a name="l02531"></a>02531 else

2556

<a name="l02532"></a>02532 {

2557

<a name="l02533"></a>02533 unsigned nbit = unsigned(prev & <a class="code" href="a00088.html#201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2558

<a name="l02534"></a>02534

2559

<a name="l02535"></a>02535 int no_more_blocks;

2560

<a name="l02536"></a>02536 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* block =

2561

<a name="l02537"></a>02537 blockman_.get_block(nblock, &no_more_blocks);

2562

<a name="l02538"></a>02538

2563

<a name="l02539"></a>02539 if (no_more_blocks)

2564

<a name="l02540"></a>02540 {

2565

<a name="l02541"></a>02541 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(block == 0);

2566

<a name="l02542"></a>02542 break;

2567

<a name="l02543"></a>02543 }

2568

<a name="l02544"></a>02544

2569

<a name="l02545"></a>02545

2570

<a name="l02546"></a>02546 if (block)

2571

<a name="l02547"></a>02547 {

2572

<a name="l02548"></a>02548 if (<a class="code" href="a00072.html#074acb37afea68caaffe3832d326eb44">IS_FULL_BLOCK</a>(block))

2573

<a name="l02549"></a>02549 {

2574

<a name="l02550"></a>02550 set(prev, false);

2575

<a name="l02551"></a>02551 return prev;

2576

<a name="l02552"></a>02552 }

2577

<a name="l02553"></a>02553 if (<a class="code" href="a00072.html#862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nblock))

2578

<a name="l02554"></a>02554 {

2579

<a name="l02555"></a>02555 unsigned is_set;

2580

<a name="l02556"></a>02556 unsigned new_block_len =

2581

<a name="l02557"></a>02557 <a class="code" href="a00092.html#g69186bd13bda27e04b3e33683ff884c2" title="Abstract distance(similarity) operation for GAP buffers. Receives functor F as a...">gap_set_value</a>(0, <a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block), nbit, &is_set);

2582

<a name="l02558"></a>02558 if (is_set) {

2583

<a name="l02559"></a>02559 <a class="code" href="a00068.html#809c66152f5967c1a1eb51e006206630">BMCOUNT_DEC</a>

2584

<a name="l02560"></a>02560 unsigned threshold =

2585

<a name="l02561"></a>02561 <a class="code" href="a00092.html#g94a5371b5dc6a1560d95d7c2dde88815" title="Returs GAP block capacity limit.">bm::gap_limit</a>(<a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block), blockman_.glen());

2586

<a name="l02562"></a>02562 if (new_block_len > threshold)

2587

<a name="l02563"></a>02563 {

2588

<a name="l02564"></a>02564 extend_gap_block(nblock, <a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block));

2589

<a name="l02565"></a>02565 }

2590

<a name="l02566"></a>02566 return prev;

2591

<a name="l02567"></a>02567 } else {

2592

<a name="l02568"></a>02568 if (<a class="code" href="a00092.html#ga7df7193094353ea24b8519debf745be" title="Searches for the next 1 bit in the GAP block.">bm::gap_find_in_block</a>(<a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block),

2593

<a name="l02569"></a>02569 nbit,

2594

<a name="l02570"></a>02570 &prev))

2595

<a name="l02571"></a>02571 {

2596

<a name="l02572"></a>02572 set(prev, false);

2597

<a name="l02573"></a>02573 return prev;

2598

<a name="l02574"></a>02574 }

2599

<a name="l02575"></a>02575 }

2600

<a name="l02576"></a>02576 }

2601

<a name="l02577"></a>02577 else // bit block

2602

<a name="l02578"></a>02578 {

2603

<a name="l02579"></a>02579 if (<a class="code" href="a00093.html#gd6a7c549a625df7aa7d68d43a57238c7" title="Searches for the next 1 bit in the BIT block.">bm::bit_find_in_block</a>(block, nbit, &prev))

2604

<a name="l02580"></a>02580 {

2605

<a name="l02581"></a>02581 <a class="code" href="a00068.html#809c66152f5967c1a1eb51e006206630">BMCOUNT_DEC</a>

2606

<a name="l02582"></a>02582

2607

<a name="l02583"></a>02583 unsigned nbit =

2608

<a name="l02584"></a>02584 unsigned(prev & <a class="code" href="a00088.html#201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2609

<a name="l02585"></a>02585 unsigned nword =

2610

<a name="l02586"></a>02586 unsigned(nbit >> <a class="code" href="a00088.html#83d76bccf6fe3770f32d5ba11d2a37ad">bm::set_word_shift</a>);

2611

<a name="l02587"></a>02587 nbit &= <a class="code" href="a00088.html#ddbf345be3733d5e4575d71733ed1da8">bm::set_word_mask</a>;

2612

<a name="l02588"></a>02588 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* word = block + nword;

2613

<a name="l02589"></a>02589 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a> mask = ((<a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>)1) << nbit;

2614

<a name="l02590"></a>02590 *word &= ~mask;

2615

<a name="l02591"></a>02591

2616

<a name="l02592"></a>02592 return prev;

2617

<a name="l02593"></a>02593 }

2618

<a name="l02594"></a>02594 }

2619

<a name="l02595"></a>02595 }

2620

<a name="l02596"></a>02596 else

2621

<a name="l02597"></a>02597 {

2622

<a name="l02598"></a>02598 prev += (<a class="code" href="a00088.html#201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a> + 1) -

2623

<a name="l02599"></a>02599 (prev & <a class="code" href="a00088.html#201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2624

<a name="l02600"></a>02600 }

2625

<a name="l02601"></a>02601

2626

<a name="l02602"></a>02602 }

2627

<a name="l02603"></a>02603 if (!prev) break;

2628

<a name="l02604"></a>02604 }

2629

<a name="l02605"></a>02605

2630

<a name="l02606"></a>02606 return 0;

2631

<a name="l02607"></a>02607 }

2632

<a name="l02608"></a>02608

2633

<a name="l02609"></a>02609 //---------------------------------------------------------------------

2634

<a name="l02610"></a>02610

2635

<a name="l02611"></a>02611 template<class Alloc, class MS>

2636

<a name="l02612"></a><a class="code" href="a00036.html#f2c137de958a038f96e1149c51ea8a8f">02612</a> void <a class="code" href="a00036.html#f2c137de958a038f96e1149c51ea8a8f">bvector<Alloc, MS>::combine_operation</a>(

2637

<a name="l02613"></a>02613 const <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvect</a>,

2638

<a name="l02614"></a>02614 <a class="code" href="a00088.html#42405343976ec931388381cea4092bf1" title="Bit operations enumeration.">bm::operation</a> opcode)

2639

<a name="l02615"></a>02615 {

2640

<a name="l02616"></a>02616 typedef void (*block_bit_op)(<a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*, const bm::word_t*);

2641

<a name="l02617"></a>02617 typedef void (*block_bit_op_next)(bm::word_t*,

2642

<a name="l02618"></a>02618 const bm::word_t*,

2643

<a name="l02619"></a>02619 bm::word_t*,

2644

<a name="l02620"></a>02620 const bm::word_t*);

2645

<a name="l02621"></a>02621

2646

<a name="l02622"></a>02622 unsigned top_blocks = blockman_.top_block_size();

2647

<a name="l02623"></a>02623 unsigned bvect_top_blocks = bvect.blockman_.top_block_size();

2648

<a name="l02624"></a>02624

2649

<a name="l02625"></a>02625 if (size_ == bvect.size_)

2650

<a name="l02626"></a>02626 {

2651

<a name="l02627"></a>02627 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(top_blocks >= bvect_top_blocks);

2652

<a name="l02628"></a>02628 }

2653

<a name="l02629"></a>02629 else

2654

<a name="l02630"></a>02630 if (size_ < bvect.size_) // this vect shorter than the arg.

2655

<a name="l02631"></a>02631 {

2656

<a name="l02632"></a>02632 size_ = bvect.size_;

2657

<a name="l02633"></a>02633 // stretch our capacity

2658

<a name="l02634"></a>02634 blockman_.reserve_top_blocks(bvect_top_blocks);

2659

<a name="l02635"></a>02635 top_blocks = blockman_.top_block_size();

2660

<a name="l02636"></a>02636 }

2661

<a name="l02637"></a>02637 else

2662

<a name="l02638"></a>02638 if (size_ > bvect.size_) // this vector larger

2663

<a name="l02639"></a>02639 {

2664

<a name="l02640"></a>02640 if (opcode == <a class="code" href="a00088.html#42405343976ec931388381cea4092bf1546fdf33b301e5b9bee0591522ed9250">BM_AND</a>) // clear the tail with zeros

2665

<a name="l02641"></a>02641 {

2666

<a name="l02642"></a>02642 <a class="code" href="a00036.html#14bc35b9b022018f10787b07a5b2af04" title="Sets all bits in the specified closed interval [left,right] Interval must be inside...">set_range</a>(bvect.size_, size_ - 1, false);

2667

<a name="l02643"></a>02643 if (bvect_top_blocks < top_blocks)

2668

<a name="l02644"></a>02644 {

2669

<a name="l02645"></a>02645 // not to scan blocks we already swiped

2670

<a name="l02646"></a>02646 top_blocks = bvect_top_blocks;

2671

<a name="l02647"></a>02647 }

2672

<a name="l02648"></a>02648 }

2673

<a name="l02649"></a>02649 }

2674

<a name="l02650"></a>02650

2675

<a name="l02651"></a>02651 bm::word_t*** blk_root = blockman_.blocks_root();

2676

<a name="l02652"></a>02652 unsigned block_idx = 0;

2677

<a name="l02653"></a>02653 unsigned i, j;

2678

<a name="l02654"></a>02654

2679

<a name="l02655"></a>02655 <a class="code" href="a00072.html#7e6f87ba3230dece2125af5c32e84b05">BM_SET_MMX_GUARD</a>

2680

<a name="l02656"></a>02656

2681

<a name="l02657"></a>02657 // calculate effective top size to avoid overscan

2682

<a name="l02658"></a>02658 top_blocks = blockman_.effective_top_block_size();

2683

<a name="l02659"></a>02659 if (top_blocks < bvect.blockman_.effective_top_block_size())

2684

<a name="l02660"></a>02660 {

2685

<a name="l02661"></a>02661 if (opcode != <a class="code" href="a00088.html#42405343976ec931388381cea4092bf1546fdf33b301e5b9bee0591522ed9250">BM_AND</a>)

2686

<a name="l02662"></a>02662 {

2687

<a name="l02663"></a>02663 top_blocks = bvect.blockman_.effective_top_block_size();

2688

<a name="l02664"></a>02664 }

2689

<a name="l02665"></a>02665 }

2690

<a name="l02666"></a>02666

2691

<a name="l02667"></a>02667 for (i = 0; i < top_blocks; ++i)

2692

<a name="l02668"></a>02668 {

2693

<a name="l02669"></a>02669 bm::word_t** blk_blk = blk_root[i];

2694

<a name="l02670"></a>02670

2695

<a name="l02671"></a>02671 if (blk_blk == 0) // not allocated

2696

<a name="l02672"></a>02672 {

2697

<a name="l02673"></a>02673 if (opcode == <a class="code" href="a00088.html#42405343976ec931388381cea4092bf1546fdf33b301e5b9bee0591522ed9250">BM_AND</a>) // 0 AND anything == 0

2698

<a name="l02674"></a>02674 {

2699

<a name="l02675"></a>02675 block_idx += <a class="code" href="a00088.html#40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>;

2700

<a name="l02676"></a>02676 continue;

2701

<a name="l02677"></a>02677 }

2702

<a name="l02678"></a>02678 const bm::word_t* const* bvbb = bvect.blockman_.get_topblock(i);

2703

<a name="l02679"></a>02679 if (bvbb == 0) // skip it because 0 OP 0 == 0

2704

<a name="l02680"></a>02680 {

2705

<a name="l02681"></a>02681 block_idx += <a class="code" href="a00088.html#40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>;

2706

<a name="l02682"></a>02682 continue;

2707

<a name="l02683"></a>02683 }

2708

<a name="l02684"></a>02684 // 0 - self, non-zero argument

2709

<a name="l02685"></a>02685 for (j = 0; j < <a class="code" href="a00088.html#40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>; ++j,++block_idx)

2710

<a name="l02686"></a>02686 {

2711

<a name="l02687"></a>02687 const bm::word_t* arg_blk =

2712

<a name="l02688"></a>02688 bvect.blockman_.get_block(i, j);

2713

<a name="l02689"></a>02689 if (arg_blk != 0)

2714

<a name="l02690"></a>02690 {

2715

<a name="l02691"></a>02691 bool arg_gap =

2716

<a name="l02692"></a>02692 <a class="code" href="a00072.html#862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(bvect.blockman_, arg_blk, block_idx);

2717

<a name="l02693"></a>02693 combine_operation_with_block(block_idx, 0, 0,

2718

<a name="l02694"></a>02694 arg_blk, arg_gap,

2719

<a name="l02695"></a>02695 opcode);

2720

<a name="l02696"></a>02696 }

2721

<a name="l02697"></a>02697

2722

<a name="l02698"></a>02698 } // for j

2723

<a name="l02699"></a>02699 continue;

2724

<a name="l02700"></a>02700 }

2725

<a name="l02701"></a>02701

2726

<a name="l02702"></a>02702 for (j = 0; j < <a class="code" href="a00088.html#40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>; ++j, ++block_idx)

2727

<a name="l02703"></a>02703 {

2728

<a name="l02704"></a>02704 bm::word_t* blk = blk_blk[j];

2729

<a name="l02705"></a>02705 const bm::word_t* arg_blk = bvect.blockman_.get_block(i, j);

2730

<a name="l02706"></a>02706

2731

<a name="l02707"></a>02707 if (arg_blk || blk)

2732

<a name="l02708"></a>02708 {

2733

<a name="l02709"></a>02709 if (opcode == <a class="code" href="a00088.html#42405343976ec931388381cea4092bf1546fdf33b301e5b9bee0591522ed9250">BM_AND</a>)

2734

<a name="l02710"></a>02710 {

2735

<a name="l02711"></a>02711 if (!blk) continue;

2736

<a name="l02712"></a>02712 if (!arg_blk)

2737

<a name="l02713"></a>02713 {

2738

<a name="l02714"></a>02714 if (blk) blockman_.zero_block(block_idx);

2739

<a name="l02715"></a>02715 continue;

2740

<a name="l02716"></a>02716 }

2741

<a name="l02717"></a>02717 }

2742

<a name="l02718"></a>02718

2743

<a name="l02719"></a>02719 bool arg_gap = <a class="code" href="a00072.html#862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(bvect.blockman_, arg_blk, block_idx);

2744

<a name="l02720"></a>02720 bool gap = <a class="code" href="a00072.html#862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>((*this).blockman_, blk, block_idx);

2745

<a name="l02721"></a>02721

2746

<a name="l02722"></a>02722 combine_operation_with_block(block_idx, gap, blk,

2747

<a name="l02723"></a>02723 arg_blk, arg_gap,

2748

<a name="l02724"></a>02724 opcode);

2749

<a name="l02725"></a>02725 }

2750

<a name="l02726"></a>02726

2751

<a name="l02727"></a>02727 } // for j

2752

<a name="l02728"></a>02728

2753

<a name="l02729"></a>02729 } // for i

2754

<a name="l02730"></a>02730

2755

<a name="l02731"></a>02731 }

2756

<a name="l02732"></a>02732

2757

<a name="l02733"></a>02733

2758

<a name="l02734"></a>02734 //---------------------------------------------------------------------

2759

<a name="l02735"></a>02735

2760

<a name="l02736"></a>02736

2761

<a name="l02737"></a>02737 template<class Alloc, class MS>

2762

<a name="l02738"></a>02738 void

2763

<a name="l02739"></a>02739 <a class="code" href="a00036.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS>::combine_operation_with_block</a>(unsigned nb,

2764

<a name="l02740"></a>02740 unsigned gap,

2765

<a name="l02741"></a>02741 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk,

2766

<a name="l02742"></a>02742 const <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* arg_blk,

2767

<a name="l02743"></a>02743 int arg_gap,

2768

<a name="l02744"></a>02744 <a class="code" href="a00088.html#42405343976ec931388381cea4092bf1" title="Bit operations enumeration.">bm::operation</a> opcode)

2769

<a name="l02745"></a>02745 {

2770

<a name="l02746"></a>02746 if (!blk && arg_gap && <a class="code" href="a00036.html#d971c541fa259278e9dcf541b2d128c9" title="Returns blocks allocation strategy.">get_new_blocks_strat</a>() == <a class="code" href="a00091.html#ggd0b87b3b7292383a864d27feaf1c9eff7fe09d1d7c62a813db922c396c0cbc9c" title="GAP compression is ON.">BM_GAP</a>) {

2771

<a name="l02747"></a>02747 blk =

2772

<a name="l02748"></a>02748 blockman_.check_allocate_block(nb,

2773

<a name="l02749"></a>02749 0,

2774

<a name="l02750"></a>02750 <a class="code" href="a00091.html#ggd0b87b3b7292383a864d27feaf1c9eff7fe09d1d7c62a813db922c396c0cbc9c" title="GAP compression is ON.">BM_GAP</a>,

2775

<a name="l02751"></a>02751 (int*)&gap,

2776

<a name="l02752"></a>02752 false /*no null return*/);

2777

<a name="l02753"></a>02753 }

2778

<a name="l02754"></a>02754

2779

<a name="l02755"></a>02755 if (gap) // our block GAP-type

2780

<a name="l02756"></a>02756 {

2781

<a name="l02757"></a>02757 if (arg_gap) // both blocks GAP-type

2782

<a name="l02758"></a>02758 {

2783

<a name="l02759"></a>02759 <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a> tmp_buf[<a class="code" href="a00088.html#a5e01dfb650d168f9be0525e042af647">bm::gap_max_buff_len</a> * 3]; // temporary result

2784

<a name="l02760"></a>02760 <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>* res;

2785

<a name="l02761"></a>02761

2786

<a name="l02762"></a>02762 <a class="code" href="a00088.html#9a7bc970eaa1179eb83bd14e21643da2">gap_operation_func_type</a> gfunc =

2787

<a name="l02763"></a>02763 operation_functions<true>::gap_operation(opcode);

2788

<a name="l02764"></a>02764 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(gfunc);

2789

<a name="l02765"></a>02765 res = (*gfunc)(<a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk),

2790

<a name="l02766"></a>02766 <a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(arg_blk),

2791

<a name="l02767"></a>02767 tmp_buf);

2792

<a name="l02768"></a>02768 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(res == tmp_buf);

2793

<a name="l02769"></a>02769 unsigned res_len = <a class="code" href="a00092.html#gd6bfb9da9950b0df8983a9faf9db5042" title="Returs GAP block length.">bm::gap_length</a>(res);

2794

<a name="l02770"></a>02770

2795

<a name="l02771"></a>02771 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(!(res == tmp_buf && res_len == 0));

2796

<a name="l02772"></a>02772

2797

<a name="l02773"></a>02773 // if as a result of the operation gap block turned to zero

2798

<a name="l02774"></a>02774 // we can now replace it with NULL

2799

<a name="l02775"></a>02775 if (<a class="code" href="a00092.html#g690ff7c8b16e1821a77663b7194267e7" title="Temporary inverts all bits in the GAP buffer.">gap_is_all_zero</a>(res, <a class="code" href="a00088.html#d0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a>))

2800

<a name="l02776"></a>02776 {

2801

<a name="l02777"></a>02777 blockman_.zero_block(nb);

2802

<a name="l02778"></a>02778 return;

2803

<a name="l02779"></a>02779 }

2804

<a name="l02780"></a>02780

2805

<a name="l02781"></a>02781 // mutation check

2806

<a name="l02782"></a>02782

2807

<a name="l02783"></a>02783 int level = <a class="code" href="a00092.html#g1defe73aa4227a0e7204363ac6bb1ac1" title="Returs GAP blocks capacity level.">gap_level</a>(<a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk));

2808

<a name="l02784"></a>02784 unsigned threshold = blockman_.glen(level)-4;

2809

<a name="l02785"></a>02785 int new_level = <a class="code" href="a00092.html#g3bfaebeeb4b2d479c5a9ac9d57607165" title="Calculates GAP block capacity level.">gap_calc_level</a>(res_len, blockman_.glen());

2810

<a name="l02786"></a>02786

2811

<a name="l02787"></a>02787 if (new_level == -1)

2812

<a name="l02788"></a>02788 {

2813

<a name="l02789"></a>02789 blockman_.convert_gap2bitset(nb, res);

2814

<a name="l02790"></a>02790 return;

2815

<a name="l02791"></a>02791 }

2816

<a name="l02792"></a>02792

2817

<a name="l02793"></a>02793 if (res_len > threshold)

2818

<a name="l02794"></a>02794 {

2819

<a name="l02795"></a>02795 <a class="code" href="a00092.html#g501aa9bf029e7f9ea9518e7003fe5549" title="Sets GAP block capacity level.">set_gap_level</a>(res, new_level);

2820

<a name="l02796"></a>02796 <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>* new_blk =

2821

<a name="l02797"></a>02797 blockman_.allocate_gap_block(new_level, res);

2822

<a name="l02798"></a>02798

2823

<a name="l02799"></a>02799 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* p = (<a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*)new_blk;

2824

<a name="l02800"></a>02800 <a class="code" href="a00072.html#93dbdb1a62ca0ce33149d3249dbf386e">BMSET_PTRGAP</a>(p);

2825

<a name="l02801"></a>02801

2826

<a name="l02802"></a>02802 blockman_.set_block_ptr(nb, p);

2827

<a name="l02803"></a>02803 blockman_.get_allocator().free_gap_block(<a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk),

2828

<a name="l02804"></a>02804 blockman_.glen());

2829

<a name="l02805"></a>02805 return;

2830

<a name="l02806"></a>02806 }

2831

<a name="l02807"></a>02807

2832

<a name="l02808"></a>02808 // gap opeartion result is in the temporary buffer

2833

<a name="l02809"></a>02809 // we copy it back to the gap_block

2834

<a name="l02810"></a>02810

2835

<a name="l02811"></a>02811 <a class="code" href="a00092.html#g501aa9bf029e7f9ea9518e7003fe5549" title="Sets GAP block capacity level.">set_gap_level</a>(tmp_buf, level);

2836

<a name="l02812"></a>02812 ::memcpy(<a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk), tmp_buf, res_len * sizeof(<a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>));

2837

<a name="l02813"></a>02813 return;

2838

<a name="l02814"></a>02814 }

2839

<a name="l02815"></a>02815 else // argument is BITSET-type (own block is GAP)

2840

<a name="l02816"></a>02816 {

2841

<a name="l02817"></a>02817 // since we can not combine blocks of mixed type

2842

<a name="l02818"></a>02818 // we need to convert our block to bitset

2843

<a name="l02819"></a>02819

2844

<a name="l02820"></a>02820 if (arg_blk == 0) // Combining against an empty block

2845

<a name="l02821"></a>02821 {

2846

<a name="l02822"></a>02822 switch (opcode)

2847

<a name="l02823"></a>02823 {

2848

<a name="l02824"></a>02824 case <a class="code" href="a00088.html#42405343976ec931388381cea4092bf1546fdf33b301e5b9bee0591522ed9250">BM_AND</a>: // ("Value" AND 0) == 0

2849

<a name="l02825"></a>02825 blockman_.zero_block(nb);

2850

<a name="l02826"></a>02826 return;

2851

<a name="l02827"></a>02827 case <a class="code" href="a00088.html#42405343976ec931388381cea4092bf10c8cf0197857d0bd73a63037e2f2c5c5">BM_OR</a>: case <a class="code" href="a00088.html#42405343976ec931388381cea4092bf11df0f4de7126bb2f7ce69d7a005affb5">BM_SUB</a>: case <a class="code" href="a00088.html#42405343976ec931388381cea4092bf145c2fe36efb72dc03f03a842d253f64c">BM_XOR</a>:

2852

<a name="l02828"></a>02828 return; // nothing to do

2853

<a name="l02829"></a>02829 }

2854

<a name="l02830"></a>02830 }

2855

<a name="l02831"></a>02831 <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>* gap_blk = <a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk);

2856

<a name="l02832"></a>02832 if (opcode == <a class="code" href="a00088.html#42405343976ec931388381cea4092bf1546fdf33b301e5b9bee0591522ed9250">BM_AND</a>)

2857

<a name="l02833"></a>02833 {

2858

<a name="l02834"></a>02834 unsigned gap_cnt = <a class="code" href="a00092.html#g226273a798a07069564e73eb98d06838" title="Calculates number of bits ON in GAP buffer.">gap_bit_count</a>(gap_blk);

2859

<a name="l02835"></a>02835 if (gap_cnt < 128)

2860

<a name="l02836"></a>02836 {

2861

<a name="l02837"></a>02837 <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a> tmp_buf[<a class="code" href="a00088.html#a5e01dfb650d168f9be0525e042af647">bm::gap_max_buff_len</a> * 3];

2862

<a name="l02838"></a>02838 <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a> arr_len =

2863

<a name="l02839"></a>02839 <a class="code" href="a00092.html#g3cc68fe9724e63403d15899bc17da3a1" title="Convert gap block into array of ints corresponding to 1 bits.">gap_convert_to_arr</a>(tmp_buf, gap_blk,

2864

<a name="l02840"></a>02840 <a class="code" href="a00088.html#9b1715d6d9164d56172e75bbbd0e3000">bm::gap_equiv_len</a>-10);

2865

<a name="l02841"></a>02841 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(gap_cnt == arr_len);

2866

<a name="l02842"></a>02842 blockman_.zero_block(nb);

2867

<a name="l02843"></a>02843 unsigned arr_i = 0;

2868

<a name="l02844"></a>02844 int block_type;

2869

<a name="l02845"></a>02845 blk =

2870

<a name="l02846"></a>02846 blockman_.check_allocate_block(nb,

2871

<a name="l02847"></a>02847 true,

2872

<a name="l02848"></a>02848 <a class="code" href="a00091.html#ggd0b87b3b7292383a864d27feaf1c9eff7fe09d1d7c62a813db922c396c0cbc9c" title="GAP compression is ON.">BM_GAP</a>,

2873

<a name="l02849"></a>02849 &block_type,

2874

<a name="l02850"></a>02850 false /* no null return*/);

2875

<a name="l02851"></a>02851 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(block_type==1); // GAP

2876

<a name="l02852"></a>02852 gap_blk = <a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk);

2877

<a name="l02853"></a>02853 unsigned threshold = <a class="code" href="a00092.html#g94a5371b5dc6a1560d95d7c2dde88815" title="Returs GAP block capacity limit.">bm::gap_limit</a>(gap_blk, blockman_.glen());

2878

<a name="l02854"></a>02854 for (; arr_i < arr_len; ++arr_i)

2879

<a name="l02855"></a>02855 {

2880

<a name="l02856"></a>02856 <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a> bit_idx = tmp_buf[arr_i];

2881

<a name="l02857"></a>02857 if (<a class="code" href="a00093.html#g9bccc586aa791f98f1bec284b799102c" title="Test 1 bit in a block.">bm::test_bit</a>(arg_blk, bit_idx))

2882

<a name="l02858"></a>02858 {

2883

<a name="l02859"></a>02859 unsigned is_set;

2884

<a name="l02860"></a>02860 unsigned new_block_len =

2885

<a name="l02861"></a>02861 <a class="code" href="a00092.html#g69186bd13bda27e04b3e33683ff884c2" title="Abstract distance(similarity) operation for GAP buffers. Receives functor F as a...">gap_set_value</a>(true, gap_blk, bit_idx, &is_set);

2886

<a name="l02862"></a>02862 if (new_block_len > threshold)

2887

<a name="l02863"></a>02863 {

2888

<a name="l02864"></a>02864 gap_blk =

2889

<a name="l02865"></a>02865 blockman_.extend_gap_block(nb, gap_blk);

2890

<a name="l02866"></a>02866 if (gap_blk == 0) // mutated into bit-block

2891

<a name="l02867"></a>02867 {

2892

<a name="l02868"></a>02868 blk = blockman_.check_allocate_block(

2893

<a name="l02869"></a>02869 nb,

2894

<a name="l02870"></a>02870 true,

2895

<a name="l02871"></a>02871 this-><a class="code" href="a00036.html#d971c541fa259278e9dcf541b2d128c9" title="Returns blocks allocation strategy.">get_new_blocks_strat</a>(),

2896

<a name="l02872"></a>02872 &block_type,

2897

<a name="l02873"></a>02873 false /* no null return*/);

2898

<a name="l02874"></a>02874 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(block_type == 0); // BIT

2899

<a name="l02875"></a>02875 for (++arr_i; arr_i < arr_len; ++arr_i)

2900

<a name="l02876"></a>02876 {

2901

<a name="l02877"></a>02877 bit_idx = tmp_buf[arr_i];

2902

<a name="l02878"></a>02878 <a class="code" href="a00093.html#gd698b5242f5b629aa28e7338b7150497" title="Sets bits to 1 in the bitblock.">or_bit_block</a>(blk, bit_idx, 1);

2903

<a name="l02879"></a>02879 } // for arr_i

2904

<a name="l02880"></a>02880 return;

2905

<a name="l02881"></a>02881 } // if gap mutated

2906

<a name="l02882"></a>02882 }

2907

<a name="l02883"></a>02883 } // for arr_i

2908

<a name="l02884"></a>02884 }

2909

<a name="l02885"></a>02885

2910

<a name="l02886"></a>02886 return;

2911

<a name="l02887"></a>02887 }

2912

<a name="l02888"></a>02888

2913

<a name="l02889"></a>02889 } // BM_AND

2914

<a name="l02890"></a>02890

2915

<a name="l02891"></a>02891 blk = blockman_.convert_gap2bitset(nb, gap_blk);

2916

<a name="l02892"></a>02892 }

2917

<a name="l02893"></a>02893 }

2918

<a name="l02894"></a>02894 else // our block is BITSET-type

2919

<a name="l02895"></a>02895 {

2920

<a name="l02896"></a>02896 if (arg_gap) // argument block is GAP-type

2921

<a name="l02897"></a>02897 {

2922

<a name="l02898"></a>02898 if (<a class="code" href="a00072.html#13ba598909515339ceede09e3b9b0198">IS_VALID_ADDR</a>(blk))

2923

<a name="l02899"></a>02899 {

2924

<a name="l02900"></a>02900 // special case, maybe we can do the job without

2925

<a name="l02901"></a>02901 // converting the GAP argument to bitblock

2926

<a name="l02902"></a>02902 <a class="code" href="a00088.html#18a8f03b151ca3a6d5e39e7709fb6c7c">gap_operation_to_bitset_func_type</a> gfunc =

2927

<a name="l02903"></a>02903 operation_functions<true>::gap_op_to_bit(opcode);

2928

<a name="l02904"></a>02904 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(gfunc);

2929

<a name="l02905"></a>02905 (*gfunc)(blk, <a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(arg_blk));

2930

<a name="l02906"></a>02906 return;

2931

<a name="l02907"></a>02907 }

2932

<a name="l02908"></a>02908

2933

<a name="l02909"></a>02909 // the worst case we need to convert argument block to

2934

<a name="l02910"></a>02910 // bitset type.

2935

<a name="l02911"></a>02911

2936

<a name="l02912"></a>02912 <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>* temp_blk = (<a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">gap_word_t</a>*) blockman_.check_allocate_tempblock();

2937

<a name="l02913"></a>02913 arg_blk =

2938

<a name="l02914"></a>02914 <a class="code" href="a00092.html#g3f01bb7c1ae7983aa8c4ba82e1e3f54c" title="Smart GAP block to bitblock conversion.">gap_convert_to_bitset_smart</a>((<a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*)temp_blk,

2939

<a name="l02915"></a>02915 <a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(arg_blk),

2940

<a name="l02916"></a>02916 <a class="code" href="a00088.html#d0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a>);

2941

<a name="l02917"></a>02917

2942

<a name="l02918"></a>02918 }

2943

<a name="l02919"></a>02919 }

2944

<a name="l02920"></a>02920

2945

<a name="l02921"></a>02921 // Now here we combine two plain bitblocks using supplied bit function.

2946

<a name="l02922"></a>02922 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* dst = blk;

2947

<a name="l02923"></a>02923

2948

<a name="l02924"></a>02924 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* ret;

2949

<a name="l02925"></a>02925 if (dst == 0 && arg_blk == 0)

2950

<a name="l02926"></a>02926 {

2951

<a name="l02927"></a>02927 return;

2952

<a name="l02928"></a>02928 }

2953

<a name="l02929"></a>02929

2954

<a name="l02930"></a>02930 switch (opcode)

2955

<a name="l02931"></a>02931 {

2956

<a name="l02932"></a>02932 case <a class="code" href="a00088.html#42405343976ec931388381cea4092bf1546fdf33b301e5b9bee0591522ed9250">BM_AND</a>:

2957

<a name="l02933"></a>02933 ret = <a class="code" href="a00093.html#g869fce5348076d4c7b92adcc2f1a49ab" title="bitblock AND operation.">bit_operation_and</a>(dst, arg_blk);

2958

<a name="l02934"></a>02934 goto copy_block;

2959

<a name="l02935"></a>02935 case <a class="code" href="a00088.html#42405343976ec931388381cea4092bf145c2fe36efb72dc03f03a842d253f64c">BM_XOR</a>:

2960

<a name="l02936"></a>02936 ret = <a class="code" href="a00093.html#g179de722e87ccf8189d975ca6beed025" title="bitblock XOR operation.">bit_operation_xor</a>(dst, arg_blk);

2961

<a name="l02937"></a>02937 if (ret && (ret == arg_blk) && <a class="code" href="a00072.html#074acb37afea68caaffe3832d326eb44">IS_FULL_BLOCK</a>(dst))

2962

<a name="l02938"></a>02938 {

2963

<a name="l02939"></a>02939 ret = blockman_.get_allocator().alloc_bit_block();

2964

<a name="l02940"></a>02940 #ifdef BMVECTOPT

2965

<a name="l02941"></a>02941 <a class="code" href="a00075.html#9b8caa31ab90cbfbc99b5728352e5456">VECT_XOR_ARR_2_MASK</a>(ret,

2966

<a name="l02942"></a>02942 arg_blk,

2967

<a name="l02943"></a>02943 arg_blk + bm::set_block_size,

2968

<a name="l02944"></a>02944 <a class="code" href="a00088.html#095e72da3086d98dac9724b11b478235">bm::all_bits_mask</a>);

2969

<a name="l02945"></a>02945 #else

2970

<a name="l02946"></a>02946 <a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">bm::wordop_t</a>* dst_ptr = (<a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">wordop_t</a>*)ret;

2971

<a name="l02947"></a>02947 const <a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">bm::wordop_t</a>* wrd_ptr = (<a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">wordop_t</a>*) arg_blk;

2972

<a name="l02948"></a>02948 const <a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">bm::wordop_t</a>* wrd_end =

2973

<a name="l02949"></a>02949 (<a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">wordop_t</a>*) (arg_blk + bm::set_block_size);

2974

<a name="l02950"></a>02950

2975

<a name="l02951"></a>02951 do

2976

<a name="l02952"></a>02952 {

2977

<a name="l02953"></a>02953 dst_ptr[0] = <a class="code" href="a00088.html#095e72da3086d98dac9724b11b478235">bm::all_bits_mask</a> ^ wrd_ptr[0];

2978

<a name="l02954"></a>02954 dst_ptr[1] = <a class="code" href="a00088.html#095e72da3086d98dac9724b11b478235">bm::all_bits_mask</a> ^ wrd_ptr[1];

2979

<a name="l02955"></a>02955 dst_ptr[2] = <a class="code" href="a00088.html#095e72da3086d98dac9724b11b478235">bm::all_bits_mask</a> ^ wrd_ptr[2];

2980

<a name="l02956"></a>02956 dst_ptr[3] = <a class="code" href="a00088.html#095e72da3086d98dac9724b11b478235">bm::all_bits_mask</a> ^ wrd_ptr[3];

2981

<a name="l02957"></a>02957

2982

<a name="l02958"></a>02958 dst_ptr+=4;

2983

<a name="l02959"></a>02959 wrd_ptr+=4;

2984

<a name="l02960"></a>02960

2985

<a name="l02961"></a>02961 } while (wrd_ptr < wrd_end);

2986

<a name="l02962"></a>02962 #endif

2987

<a name="l02963"></a>02963 break;

2988

<a name="l02964"></a>02964 }

2989

<a name="l02965"></a>02965 goto copy_block;

2990

<a name="l02966"></a>02966 case <a class="code" href="a00088.html#42405343976ec931388381cea4092bf10c8cf0197857d0bd73a63037e2f2c5c5">BM_OR</a>:

2991

<a name="l02967"></a>02967 ret = <a class="code" href="a00093.html#g0e945a9eaae699ad40f63b3f0632e6f9" title="Block OR operation. Makes analysis if block is 0 or FULL.">bit_operation_or</a>(dst, arg_blk);

2992

<a name="l02968"></a>02968 copy_block:

2993

<a name="l02969"></a>02969 if (ret && (ret == arg_blk) && !<a class="code" href="a00072.html#074acb37afea68caaffe3832d326eb44">IS_FULL_BLOCK</a>(ret))

2994

<a name="l02970"></a>02970 {

2995

<a name="l02971"></a>02971 ret = blockman_.get_allocator().alloc_bit_block();

2996

<a name="l02972"></a>02972 <a class="code" href="a00093.html#g9090de87d53e7f25eff96c8259b3485c" title="Bitblock copy operation.">bit_block_copy</a>(ret, arg_blk);

2997

<a name="l02973"></a>02973 }

2998

<a name="l02974"></a>02974 break;

2999

<a name="l02975"></a>02975

3000

<a name="l02976"></a>02976 case <a class="code" href="a00088.html#42405343976ec931388381cea4092bf11df0f4de7126bb2f7ce69d7a005affb5">BM_SUB</a>:

3001

<a name="l02977"></a>02977 ret = <a class="code" href="a00093.html#gd7afa9bce28a376360ca4826960d669f" title="bitblock SUB operation.">bit_operation_sub</a>(dst, arg_blk);

3002

<a name="l02978"></a>02978 if (ret && ret == arg_blk)

3003

<a name="l02979"></a>02979 {

3004

<a name="l02980"></a>02980 ret = blockman_.get_allocator().alloc_bit_block();

3005

<a name="l02981"></a>02981 #ifdef BMVECTOPT

3006

<a name="l02982"></a>02982 <a class="code" href="a00075.html#7d425b68d8217dc37d33c660e39a61e1">VECT_ANDNOT_ARR_2_MASK</a>(ret,

3007

<a name="l02983"></a>02983 arg_blk,

3008

<a name="l02984"></a>02984 arg_blk + bm::set_block_size,

3009

<a name="l02985"></a>02985 <a class="code" href="a00088.html#095e72da3086d98dac9724b11b478235">bm::all_bits_mask</a>);

3010

<a name="l02986"></a>02986 #else

3011

<a name="l02987"></a>02987

3012

<a name="l02988"></a>02988 <a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">bm::wordop_t</a>* dst_ptr = (<a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">wordop_t</a>*)ret;

3013

<a name="l02989"></a>02989 const <a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">bm::wordop_t</a>* wrd_ptr = (<a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">wordop_t</a>*) arg_blk;

3014

<a name="l02990"></a>02990 const <a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">bm::wordop_t</a>* wrd_end =

3015

<a name="l02991"></a>02991 (<a class="code" href="a00088.html#ee4bc8730c4b53977ccc8ac18be42784">wordop_t</a>*) (arg_blk + bm::set_block_size);

3016

<a name="l02992"></a>02992

3017

<a name="l02993"></a>02993 do

3018

<a name="l02994"></a>02994 {

3019

<a name="l02995"></a>02995 dst_ptr[0] = <a class="code" href="a00088.html#095e72da3086d98dac9724b11b478235">bm::all_bits_mask</a> & ~wrd_ptr[0];

3020

<a name="l02996"></a>02996 dst_ptr[1] = <a class="code" href="a00088.html#095e72da3086d98dac9724b11b478235">bm::all_bits_mask</a> & ~wrd_ptr[1];

3021

<a name="l02997"></a>02997 dst_ptr[2] = <a class="code" href="a00088.html#095e72da3086d98dac9724b11b478235">bm::all_bits_mask</a> & ~wrd_ptr[2];

3022

<a name="l02998"></a>02998 dst_ptr[3] = <a class="code" href="a00088.html#095e72da3086d98dac9724b11b478235">bm::all_bits_mask</a> & ~wrd_ptr[3];

3023

<a name="l02999"></a>02999

3024

<a name="l03000"></a>03000 dst_ptr+=4;

3025

<a name="l03001"></a>03001 wrd_ptr+=4;

3026

<a name="l03002"></a>03002

3027

<a name="l03003"></a>03003 } while (wrd_ptr < wrd_end);

3028

<a name="l03004"></a>03004 #endif

3029

<a name="l03005"></a>03005 }

3030

<a name="l03006"></a>03006 break;

3031

<a name="l03007"></a>03007 default:

3032

<a name="l03008"></a>03008 <a class="code" href="a00072.html#a44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(0);

3033

<a name="l03009"></a>03009 ret = 0;

3034

<a name="l03010"></a>03010 }

3035

<a name="l03011"></a>03011

3036

<a name="l03012"></a>03012 if (ret != dst) // block mutation

3037

<a name="l03013"></a>03013 {

3038

<a name="l03014"></a>03014 blockman_.set_block(nb, ret);

3039

<a name="l03015"></a>03015 blockman_.get_allocator().free_bit_block(dst);

3040

<a name="l03016"></a>03016 }

3041

<a name="l03017"></a>03017 }

3042

<a name="l03018"></a>03018

3043

<a name="l03019"></a>03019 //---------------------------------------------------------------------

3044

<a name="l03020"></a>03020

3045

<a name="l03021"></a>03021 template<class Alloc, class MS>

3046

<a name="l03022"></a>03022 void bvector<Alloc, MS>::set_range_no_check(<a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> left,

3047

<a name="l03023"></a>03023 <a class="code" href="a00088.html#a3824d882a037396370b16f2f0a8bf37">bm::id_t</a> right,

3048

<a name="l03024"></a>03024 bool value)

3049

<a name="l03025"></a>03025 {

3050

<a name="l03026"></a>03026 // calculate logical number of start and destination blocks

3051

<a name="l03027"></a>03027 unsigned nblock_left = unsigned(left >> <a class="code" href="a00088.html#d8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

3052

<a name="l03028"></a>03028 unsigned nblock_right = unsigned(right >> <a class="code" href="a00088.html#d8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

3053

<a name="l03029"></a>03029

3054

<a name="l03030"></a>03030 <a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* block = blockman_.get_block(nblock_left);

3055

<a name="l03031"></a>03031 bool left_gap = <a class="code" href="a00072.html#862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nblock_left);

3056

<a name="l03032"></a>03032

3057

<a name="l03033"></a>03033 unsigned nbit_left = unsigned(left & <a class="code" href="a00088.html#201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

3058

<a name="l03034"></a>03034 unsigned nbit_right = unsigned(right & <a class="code" href="a00088.html#201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

3059

<a name="l03035"></a>03035

3060

<a name="l03036"></a>03036 unsigned r =

3061

<a name="l03037"></a>03037 (nblock_left == nblock_right) ? nbit_right :(<a class="code" href="a00088.html#e9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a>-1);

3062

<a name="l03038"></a>03038

3063

<a name="l03039"></a>03039 <a class="code" href="a00088.html#c654d6319039a86546d235a236fc7cf6">bm::gap_word_t</a> tmp_gap_blk[5] = {0,};

3064

<a name="l03040"></a>03040

3065

<a name="l03041"></a>03041 // Set bits in the starting block

3066

<a name="l03042"></a>03042

3067

<a name="l03043"></a>03043 unsigned nb;

3068

<a name="l03044"></a>03044 if ((nbit_left == 0) && (r == <a class="code" href="a00088.html#e9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a> - 1)) // full block

3069

<a name="l03045"></a>03045 {

3070

<a name="l03046"></a>03046 nb = nblock_left;

3071

<a name="l03047"></a>03047 }

3072

<a name="l03048"></a>03048 else

3073

<a name="l03049"></a>03049 {

3074

<a name="l03050"></a>03050 <a class="code" href="a00092.html#g5d49355eb9dd7947699e20f3a2a75ef5" title="Init gap block so it has block in it (can be whole block).">gap_init_range_block</a>(tmp_gap_blk,

3075

<a name="l03051"></a>03051 nbit_left, r, value, <a class="code" href="a00088.html#e9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a>);

3076

<a name="l03052"></a>03052

3077

<a name="l03053"></a>03053 combine_operation_with_block(nblock_left,

3078

<a name="l03054"></a>03054 left_gap,

3079

<a name="l03055"></a>03055 block,

3080

<a name="l03056"></a>03056 (<a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*) tmp_gap_blk,

3081

<a name="l03057"></a>03057 1,

3082

<a name="l03058"></a>03058 value ? <a class="code" href="a00088.html#42405343976ec931388381cea4092bf10c8cf0197857d0bd73a63037e2f2c5c5">BM_OR</a> : <a class="code" href="a00088.html#42405343976ec931388381cea4092bf1546fdf33b301e5b9bee0591522ed9250">BM_AND</a>);

3083

<a name="l03059"></a>03059

3084

<a name="l03060"></a>03060 if (nblock_left == nblock_right) // in one block

3085

<a name="l03061"></a>03061 return;

3086

<a name="l03062"></a>03062 nb = nblock_left+1;

3087

<a name="l03063"></a>03063 }

3088

<a name="l03064"></a>03064

3089

<a name="l03065"></a>03065 // Set (or clear) all full blocks between left and right

3090

<a name="l03066"></a>03066

3091

<a name="l03067"></a>03067 unsigned nb_to = nblock_right + (nbit_right ==(<a class="code" href="a00088.html#e9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a>-1));

3092

<a name="l03068"></a>03068

3093

<a name="l03069"></a>03069 if (value)

3094

<a name="l03070"></a>03070 {

3095

<a name="l03071"></a>03071 for (; nb < nb_to; ++nb)

3096

<a name="l03072"></a>03072 {

3097

<a name="l03073"></a>03073 block = blockman_.get_block(nb);

3098

<a name="l03074"></a>03074 if (<a class="code" href="a00072.html#074acb37afea68caaffe3832d326eb44">IS_FULL_BLOCK</a>(block))

3099

<a name="l03075"></a>03075 continue;

3100

<a name="l03076"></a>03076

3101

<a name="l03077"></a>03077 bool is_gap = <a class="code" href="a00072.html#862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nb);

3102

<a name="l03078"></a>03078

3103

<a name="l03079"></a>03079 blockman_.set_block(nb, <a class="code" href="a00072.html#1365569f85f442c4914a3579f55df99b">FULL_BLOCK_ADDR</a>);

3104

<a name="l03080"></a>03080 blockman_.set_block_bit(nb);

3105

<a name="l03081"></a>03081

3106

<a name="l03082"></a>03082 if (is_gap)

3107

<a name="l03083"></a>03083 {

3108

<a name="l03084"></a>03084 blockman_.get_allocator().free_gap_block(<a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block),

3109

<a name="l03085"></a>03085 blockman_.glen());

3110

<a name="l03086"></a>03086 }

3111

<a name="l03087"></a>03087 else

3112

<a name="l03088"></a>03088 {

3113

<a name="l03089"></a>03089 blockman_.get_allocator().free_bit_block(block);

3114

<a name="l03090"></a>03090 }

3115

<a name="l03091"></a>03091

3116

<a name="l03092"></a>03092 } // for

3117

<a name="l03093"></a>03093 }

3118

<a name="l03094"></a>03094 else // value == 0

3119

<a name="l03095"></a>03095 {

3120

<a name="l03096"></a>03096 for (; nb < nb_to; ++nb)

3121

<a name="l03097"></a>03097 {

3122

<a name="l03098"></a>03098 block = blockman_.get_block(nb);

3123

<a name="l03099"></a>03099 if (block == 0) // nothing to do

3124

<a name="l03100"></a>03100 continue;

3125

<a name="l03101"></a>03101 bool is_gap = <a class="code" href="a00072.html#862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nb);

3126

<a name="l03102"></a>03102 blockman_.set_block(nb, 0, false /*bit*/);

3127

<a name="l03103"></a>03103 //blockman_.set_block_bit(nb);

3128

<a name="l03104"></a>03104

3129

<a name="l03105"></a>03105 if (is_gap)

3130

<a name="l03106"></a>03106 {

3131

<a name="l03107"></a>03107 blockman_.get_allocator().free_gap_block(<a class="code" href="a00072.html#6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block),

3132

<a name="l03108"></a>03108 blockman_.glen());

3133

<a name="l03109"></a>03109 }

3134

<a name="l03110"></a>03110 else

3135

<a name="l03111"></a>03111 {

3136

<a name="l03112"></a>03112 blockman_.get_allocator().free_bit_block(block);

3137

<a name="l03113"></a>03113 }

3138

<a name="l03114"></a>03114

3139

<a name="l03115"></a>03115 } // for

3140

<a name="l03116"></a>03116 } // if value else

3141

<a name="l03117"></a>03117

3142

<a name="l03118"></a>03118 if (nb_to > nblock_right)

3143

<a name="l03119"></a>03119 return;

3144

<a name="l03120"></a>03120

3145

<a name="l03121"></a>03121 block = blockman_.get_block(nblock_right);

3146

<a name="l03122"></a>03122 bool right_gap = <a class="code" href="a00072.html#862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nblock_right);

3147

<a name="l03123"></a>03123

3148

<a name="l03124"></a>03124 <a class="code" href="a00092.html#g5d49355eb9dd7947699e20f3a2a75ef5" title="Init gap block so it has block in it (can be whole block).">gap_init_range_block</a>(tmp_gap_blk,

3149

<a name="l03125"></a>03125 0, nbit_right, value, <a class="code" href="a00088.html#e9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a>);

3150

<a name="l03126"></a>03126

3151

<a name="l03127"></a>03127 combine_operation_with_block(nblock_right,

3152

<a name="l03128"></a>03128 right_gap,

3153

<a name="l03129"></a>03129 block,

3154

<a name="l03130"></a>03130 (<a class="code" href="a00088.html#17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*) tmp_gap_blk,

3155

<a name="l03131"></a>03131 1,

3156

<a name="l03132"></a>03132 value ? <a class="code" href="a00088.html#42405343976ec931388381cea4092bf10c8cf0197857d0bd73a63037e2f2c5c5">BM_OR</a> : <a class="code" href="a00088.html#42405343976ec931388381cea4092bf1546fdf33b301e5b9bee0591522ed9250">BM_AND</a>);

3157

<a name="l03133"></a>03133

3158

<a name="l03134"></a>03134 }

3159

<a name="l03135"></a>03135

3160

<a name="l03136"></a>03136 //---------------------------------------------------------------------

3161

<a name="l03137"></a>03137

3162

<a name="l03138"></a>03138

3163

<a name="l03139"></a>03139 } // namespace

3164

<a name="l03140"></a>03140

3165

<a name="l03141"></a>03141 #include "<a class="code" href="a00076.html">bmundef.h</a>"

3166

<a name="l03142"></a>03142

3167

<a name="l03143"></a>03143 #ifdef _MSC_VER

3168

<a name="l03144"></a>03144 #pragma warning( default : 4311 4312)

3169

<a name="l03145"></a>03145 #endif

3170

<a name="l03146"></a>03146

3171

<a name="l03147"></a>03147

3172

<a name="l03148"></a>03148 #endif

3173

<a name="l03149"></a>03149

3174

<a name="l03150"></a>03150

3175

</pre></div></div>

3176

<hr size="1"><address style="text-align: right;">Generated on Sat Aug 8 12:21:27 2009 for BitMagic by

3177

3178

3179

</body>

3180

</html>

Older »