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

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

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

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

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

<a name="l00006"></a>00006 Permission is hereby granted, free of charge, to any person

<a name="l00007"></a>00007 obtaining a copy of this software and associated documentation

<a name="l00008"></a>00008 files (the "Software"), to deal in the Software without restriction,

<a name="l00009"></a>00009 including without limitation the rights to use, copy, modify, merge,

<a name="l00010"></a>00010 publish, distribute, sublicense, and/or sell copies of the Software,

<a name="l00011"></a>00011 and to permit persons to whom the Software is furnished to do so,

<a name="l00012"></a>00012 subject to the following conditions:

<a name="l00013"></a>00013

<a name="l00014"></a>00014 The above copyright notice and this permission notice shall be included

<a name="l00015"></a>00015 in all copies or substantial portions of the Software.

<a name="l00016"></a>00016

<a name="l00017"></a>00017 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

<a name="l00018"></a>00018 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

<a name="l00019"></a>00019 OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

<a name="l00020"></a>00020 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

<a name="l00021"></a>00021 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

<a name="l00022"></a>00022 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

<a name="l00023"></a>00023 OTHER DEALINGS IN THE SOFTWARE.

<a name="l00024"></a>00024

<a name="l00025"></a>00025 For more information please visit: http://bmagic.sourceforge.net

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<a name="l00042"></a>00042 #include "<a class="code" href="a00088.html">bmconst.h</a>"

<a name="l00043"></a>00043 #include "<a class="code" href="a00089.html">bmdef.h</a>"

<a name="l00044"></a>00044

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

<a name="l00046"></a>00046 // Vector based optimizations are incompatible with 64-bit optimization

<a name="l00047"></a>00047 // which is considered a form of vectorization

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

<a name="l00049"></a>00049 #ifdef BMSSE42OPT

<a name="l00050"></a>00050 # undef BMSSE2OPT

<a name="l00051"></a>00051 # undef BM64OPT

<a name="l00052"></a>00052 # define BMVECTOPT

<a name="l00053"></a>00053 # include "<a class="code" href="a00094.html">bmsse4.h</a>"

<a name="l00054"></a>00054 #endif

<a name="l00055"></a>00055

<a name="l00056"></a>00056 #ifdef BMSSE2OPT

<a name="l00057"></a>00057 # undef BM64OPT

<a name="l00058"></a><a class="code" href="a00084.html#aa2c8ca7e259c278f3a9605205679de03">00058</a> # define BMVECTOPT

<a name="l00059"></a>00059 # include "<a class="code" href="a00093.html">bmsse2.h</a>"

<a name="l00060"></a>00060 #endif

<a name="l00061"></a>00061

<a name="l00062"></a>00062 #include "bmfwd.h"

<a name="l00063"></a>00063 #include "<a class="code" href="a00090.html">bmfunc.h</a>"

<a name="l00064"></a>00064 #include "<a class="code" href="a00099.html">bmvmin.h</a>"

<a name="l00065"></a>00065 #include "<a class="code" href="a00100.html">encoding.h</a>"

<a name="l00066"></a>00066 #include "<a class="code" href="a00087.html">bmalloc.h</a>"

<a name="l00067"></a>00067 #include "bmblocks.h"

<a name="l00068"></a>00068

<a name="l00069"></a><a class="code" href="a00110.html">00069</a> namespace bm

<a name="l00070"></a>00070 {

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

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

100

<a name="l00073"></a>00073 #ifdef BMCOUNTOPT

101

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

102

<a name="l00075"></a>00075 # define BMCOUNT_INC ++count_;

103

<a name="l00076"></a>00076 # define BMCOUNT_DEC --count_;

104

<a name="l00077"></a>00077 # define BMCOUNT_VALID(x) count_is_valid_ = x;

105

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

106

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

107

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

108

<a name="l00081"></a>00081 #else

109

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

110

<a name="l00083"></a><a class="code" href="a00084.html#a911e3d9e9a293cafab1396a8700288e9">00083</a> # define BMCOUNT_INC

111

<a name="l00084"></a><a class="code" href="a00084.html#a809c66152f5967c1a1eb51e006206630">00084</a> # define BMCOUNT_DEC

112

<a name="l00085"></a><a class="code" href="a00084.html#a835c3ed1c5956735e59744cff81244dc">00085</a> # define BMCOUNT_VALID(x)

113

<a name="l00086"></a><a class="code" href="a00084.html#a1fbebc7fe3c22d768ff6e240437ee8f4">00086</a> # define BMCOUNT_SET(x)

114

<a name="l00087"></a><a class="code" href="a00084.html#aef4146eb86de042a6c34717f87b16c10">00087</a> # define BMCOUNT_ADJ(x)

115

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

116

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

117

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

118

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

119

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

120

<a name="l00093"></a><a class="code" href="a00110.html#ac77813f2c2dfe40575830ba6a8373bcc">00093</a> typedef <a class="code" href="a00074.html" title="Template class implements memory saving set functionality.">bm::miniset<bm::block_allocator, bm::set_total_blocks></a> <a class="code" href="a00074.html" title="Template class implements memory saving set functionality.">mem_save_set</a>;

121

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

122

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

123

<a name="l00096"></a>00096 /** @defgroup bmagic BitMagic C++ Library

124

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

125

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

126

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

127

<a name="l00100"></a>00100

128

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

129

<a name="l00102"></a>00102 /** @defgroup bvector The Main bvector<> Group

130

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

131

<a name="l00104"></a>00104 * @ingroup bmagic

132

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

133

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

134

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

135

<a name="l00108"></a>00108

136

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

137

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

138

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

139

<a name="l00112"></a>00112 @ingroup bvector

140

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

141

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

142

<a name="l00115"></a>00115 template<class Alloc, class MS>

143

<a name="l00116"></a><a class="code" href="a00043.html">00116</a> class <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector</a>

144

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

145

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

146

<a name="l00119"></a>00119

147

<a name="l00120"></a><a class="code" href="a00043.html#a0da32cb546602fa6874a5a4804192b6e">00120</a> typedef Alloc <a class="code" href="a00043.html#a0da32cb546602fa6874a5a4804192b6e">allocator_type</a>;

148

<a name="l00121"></a><a class="code" href="a00043.html#a1c89beac7542674fdc09cbcf024ab390">00121</a> typedef blocks_manager<Alloc, MS> <a class="code" href="a00043.html#a1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>;

149

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

150

<a name="l00123"></a><a class="code" href="a00043.html#aba038b54cc8d548bb1c058dee0325884">00123</a> typedef <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00043.html#aba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a>;

151

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

152

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

153

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

154

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

155

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

156

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

157

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

158

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

159

<a name="l00132"></a>00132 operations we have to emulate it.

160

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

161

<a name="l00134"></a>00134 @ingroup bvector

162

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

163

<a name="l00136"></a><a class="code" href="a00078.html">00136</a> class <a class="code" href="a00078.html" title="Class reference implements an object for bit assignment.">reference</a>

164

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

165

<a name="l00138"></a>00138 public:

166

<a name="l00139"></a><a class="code" href="a00078.html#ace927b54c909478e30a5dd38ccb0c0d6">00139</a> <a class="code" href="a00078.html#ace927b54c909478e30a5dd38ccb0c0d6">reference</a>(<a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& bv, <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> position)

167

<a name="l00140"></a>00140 : bv_(bv),

168

<a name="l00141"></a>00141 position_(position)

169

<a name="l00142"></a>00142 {}

170

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

171

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

172

<a name="l00145"></a>00145 : bv_(ref.bv_),

173

<a name="l00146"></a>00146 position_(ref.position_)

174

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

175

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

176

<a name="l00149"></a>00149 }

177

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

178

<a name="l00151"></a><a class="code" href="a00078.html#a4d531a670ed0e8cfca01342fe02f030e">00151</a> <a class="code" href="a00078.html#a4d531a670ed0e8cfca01342fe02f030e">operator bool</a>() const

179

<a name="l00152"></a>00152 {

180

<a name="l00153"></a>00153 return bv_.get_bit(position_);

181

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

182

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

183

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

184

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

185

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

186

<a name="l00159"></a>00159 return *this;

187

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

188

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

189

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

190

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

191

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

192

<a name="l00165"></a>00165 return *this;

193

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

194

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

195

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

196

<a name="l00169"></a>00169 {

197

<a name="l00170"></a>00170 return bool(*this) == bool(ref);

198

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

199

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

200

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

201

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

202

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

203

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

204

<a name="l00177"></a>00177 return *this;

205

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

206

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

207

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

208

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

209

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

210

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

211

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

212

<a name="l00185"></a>00185 bv_.set_bit(position_);

213

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

214

<a name="l00187"></a>00187 return *this;

215

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

216

<a name="l00189"></a>00189

217

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

218

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

219

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

220

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

221

<a name="l00194"></a>00194 return *this;

222

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

223

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

224

<a name="l00197"></a>00197 /*! Logical Not operator */

225

<a name="l00198"></a><a class="code" href="a00078.html#aa214fa361c24c57c9fd4d26441ff6c12">00198</a> bool <a class="code" href="a00078.html#aa214fa361c24c57c9fd4d26441ff6c12">operator!</a>() const

226

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

227

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

228

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

229

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

230

<a name="l00203"></a>00203 /*! Bit Not operator */

231

<a name="l00204"></a><a class="code" href="a00078.html#a70357e67d8022147971ad970a80108d0">00204</a> bool <a class="code" href="a00078.html#a70357e67d8022147971ad970a80108d0">operator~</a>() const

232

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

233

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

234

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

235

<a name="l00208"></a>00208

236

<a name="l00209"></a>00209 /*! Negates the bit value */

237

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

238

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

239

<a name="l00212"></a>00212 bv_.flip(position_);

240

<a name="l00213"></a>00213 return *this;

241

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

242

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

243

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

244

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

245

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

246

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

247

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

248

<a name="l00221"></a><a class="code" href="a00043.html#abd935c7ebeb4d3c65caf3d236d24708a">00221</a> typedef bool <a class="code" href="a00043.html#abd935c7ebeb4d3c65caf3d236d24708a">const_reference</a>;

249

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

250

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

251

<a name="l00224"></a>00224 @brief Base class for all iterators.

252

<a name="l00225"></a>00225 @ingroup bvector

253

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

254

<a name="l00227"></a><a class="code" href="a00071.html">00227</a> class <a class="code" href="a00071.html" title="Base class for all iterators.">iterator_base</a>

255

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

256

<a name="l00229"></a><a class="code" href="a00071.html#a5bb8687c5e87638689649a12c54187cb">00229</a> friend class <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector</a>;

257

<a name="l00230"></a>00230 public:

258

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

259

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

260

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

261

<a name="l00234"></a>00234 {

262

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

263

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

264

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

265

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

266

<a name="l00239"></a>00239 {

267

<a name="l00240"></a>00240 return ! <a class="code" href="a00071.html#ab3312a717f0f899c8349c257d85d30a6">operator==</a>(it);

268

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

269

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

270

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

271

<a name="l00244"></a>00244 {

272

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

273

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

274

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

275

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

276

<a name="l00249"></a>00249 {

277

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

278

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

279

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

280

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

281

<a name="l00254"></a>00254 {

282

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

283

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

284

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

285

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

286

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

287

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

288

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

289

<a name="l00262"></a>00262

290

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

291

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

292

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

293

<a name="l00266"></a>00266 \returns true if iterator is valid.

294

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

295

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

296

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

297

<a name="l00270"></a>00270 return <a class="code" href="a00071.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> != <a class="code" href="a00110.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>;

298

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

299

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

300

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

301

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

302

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

303

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

304

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

305

<a name="l00278"></a>00278 {

306

<a name="l00279"></a>00279 <a class="code" href="a00071.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> = <a class="code" href="a00110.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>;

307

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

308

<a name="l00281"></a>00281

309

<a name="l00282"></a>00282 public:

310

<a name="l00283"></a>00283

311

<a name="l00284"></a>00284 /** Information about current bitblock. */

312

<a name="l00285"></a><a class="code" href="a00034.html">00285</a> struct <a class="code" href="a00034.html" title="Information about current bitblock.">bitblock_descr</a>

313

<a name="l00286"></a>00286 {

314

<a name="l00287"></a><a class="code" href="a00034.html#a1493d1dde691bc56ac4fdd31ad8206b6">00287</a> const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* <a class="code" href="a00034.html#a1493d1dde691bc56ac4fdd31ad8206b6" title="Word pointer.">ptr</a>; //!< Word pointer.

315

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

316

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

317

<a name="l00290"></a><a class="code" href="a00034.html#a8f005df34342398c3ec65aa3f6f57db0">00290</a> unsigned <a class="code" href="a00034.html#a8f005df34342398c3ec65aa3f6f57db0" title="Number of ON bits.">cnt</a>; //!< Number of ON bits

318

<a name="l00291"></a><a class="code" href="a00034.html#ab83089689e5235239ebc50731e3d3c84">00291</a> <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00034.html#ab83089689e5235239ebc50731e3d3c84" title="Last bit position before.">pos</a>; //!< Last bit position before

319

<a name="l00292"></a>00292 };

320

<a name="l00293"></a>00293

321

<a name="l00294"></a>00294 /** Information about current DGAP block. */

322

<a name="l00295"></a><a class="code" href="a00059.html">00295</a> struct <a class="code" href="a00059.html" title="Information about current DGAP block.">dgap_descr</a>

323

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

324

<a name="l00297"></a><a class="code" href="a00059.html#a06ab78e3b3b9c52de9b491dc2ad3a72f">00297</a> const <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* <a class="code" href="a00059.html#a06ab78e3b3b9c52de9b491dc2ad3a72f" title="Word pointer.">ptr</a>; //!< Word pointer.

325

<a name="l00298"></a><a class="code" href="a00059.html#af7766714caa1c9cb00750cd8b91314c2">00298</a> <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a> <a class="code" href="a00059.html#af7766714caa1c9cb00750cd8b91314c2" title="Current dgap length.">gap_len</a>; //!< Current dgap length.

326

<a name="l00299"></a>00299 };

327

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

328

<a name="l00301"></a>00301 protected:

329

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

330

<a name="l00303"></a><a class="code" href="a00071.html#a9f8b2774e7f16176cd0071550173fee9">00303</a> <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00071.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a>; //!< Bit position (bit idx)

331

<a name="l00304"></a><a class="code" href="a00071.html#a6d92e5c216b76dfbccbc2ebab1dd7b8d">00304</a> const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* <a class="code" href="a00071.html#a6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a>; //!< Block pointer.(NULL-invalid)

332

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

333

<a name="l00306"></a><a class="code" href="a00071.html#a07908a3bcc023120e8bbf4e81ba62139">00306</a> unsigned <a class="code" href="a00071.html#a07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a>; //!< Block index

334

<a name="l00307"></a>00307

335

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

336

<a name="l00309"></a><a class="code" href="a00039.html">00309</a> union <a class="code" href="a00039.html">block_descr</a>

337

<a name="l00310"></a>00310 {

338

<a name="l00311"></a><a class="code" href="a00039.html#a9e021a3ef144c7b26fa295ad4b64e164">00311</a> <a class="code" href="a00034.html" title="Information about current bitblock.">bitblock_descr</a> <a class="code" href="a00039.html#a9e021a3ef144c7b26fa295ad4b64e164" title="BitBlock related info.">bit_</a>; //!< BitBlock related info.

339

<a name="l00312"></a><a class="code" href="a00039.html#a00fd9ec3340550372d0d06865ce96e43">00312</a> <a class="code" href="a00059.html" title="Information about current DGAP block.">dgap_descr</a> <a class="code" href="a00039.html#a00fd9ec3340550372d0d06865ce96e43" title="DGAP block related info.">gap_</a>; //!< DGAP block related info.

340

<a name="l00313"></a>00313 } <a class="code" href="a00071.html#a47ba31f695597a948e7e18971f5c6236">bdescr_</a>;

341

<a name="l00314"></a>00314 };

342

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

343

<a name="l00316"></a>00316 /*!

344

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

345

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

346

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

347

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

348

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

349

<a name="l00322"></a>00322 (set_bit does not do that).

350

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

351

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

352

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

353

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

354

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

355

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

356

<a name="l00329"></a>00329 @ingroup bvector

357

<a name="l00330"></a>00330 */

358

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

359

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

360

<a name="l00333"></a>00333 public:

361

<a name="l00334"></a>00334 #ifndef BM_NO_STL

362

<a name="l00335"></a><a class="code" href="a00070.html#a05191a66ec380649000b9b6ea14c06b7">00335</a> typedef std::output_iterator_tag <a class="code" href="a00070.html#a05191a66ec380649000b9b6ea14c06b7">iterator_category</a>;

363

<a name="l00336"></a>00336 #endif

364

<a name="l00337"></a><a class="code" href="a00070.html#ac4e9f9614f7075703835fb78b4898c9b">00337</a> typedef unsigned <a class="code" href="a00070.html#ac4e9f9614f7075703835fb78b4898c9b">value_type</a>;

365

<a name="l00338"></a><a class="code" href="a00070.html#a77f5e1410a06a9c0b8800c8dc9a8e7fa">00338</a> typedef void <a class="code" href="a00070.html#a77f5e1410a06a9c0b8800c8dc9a8e7fa">difference_type</a>;

366

<a name="l00339"></a><a class="code" href="a00070.html#a0751c5e25531fac92a3b8be471ae2ffc">00339</a> typedef void <a class="code" href="a00070.html#a0751c5e25531fac92a3b8be471ae2ffc">pointer</a>;

367

<a name="l00340"></a><a class="code" href="a00070.html#a7b51421d9465b502e0fade68b788bb04">00340</a> typedef void <a class="code" href="a00078.html" title="Class reference implements an object for bit assignment.">reference</a>;

368

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

369

<a name="l00342"></a><a class="code" href="a00070.html#ad0a9fbadaeac7315d837d180f09dc737">00342</a> <a class="code" href="a00070.html#ad0a9fbadaeac7315d837d180f09dc737">insert_iterator</a>(<a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvect</a>)

370

<a name="l00343"></a>00343 : <a class="code" href="a00070.html#ad6d883a5f4e66f397cc0ef2a71255032">bvect_</a>(bvect),

371

<a name="l00344"></a>00344 <a class="code" href="a00070.html#a2a3cb7001d4469b6b0491105dfd443c0">max_bit_</a>(bvect.<a class="code" href="a00043.html#a1b021e7217f530390511e16b9b25f631" title="return current size of the vector (bits)">size</a>())

372

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

373

<a name="l00346"></a>00346 }

374

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

375

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

376

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

377

<a name="l00350"></a>00350 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(n < <a class="code" href="a00110.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>);

378

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

379

<a name="l00352"></a>00352 if (n >= <a class="code" href="a00070.html#a2a3cb7001d4469b6b0491105dfd443c0">max_bit_</a>)

380

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

381

<a name="l00354"></a>00354 <a class="code" href="a00070.html#a2a3cb7001d4469b6b0491105dfd443c0">max_bit_</a> = n;

382

<a name="l00355"></a>00355 if (n >= <a class="code" href="a00070.html#ad6d883a5f4e66f397cc0ef2a71255032">bvect_</a>.size())

383

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

384

<a name="l00357"></a>00357 <a class="code" href="a00070.html#ad6d883a5f4e66f397cc0ef2a71255032">bvect_</a>.resize(n + 1);

385

<a name="l00358"></a>00358 }

386

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

387

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

388

<a name="l00361"></a>00361 <a class="code" href="a00070.html#ad6d883a5f4e66f397cc0ef2a71255032">bvect_</a>.set(n);

389

<a name="l00362"></a>00362 return *this;

390

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

391

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

392

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

393

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

394

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

395

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

396

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

397

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

398

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

399

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

400

<a name="l00373"></a><a class="code" href="a00070.html#ad6d883a5f4e66f397cc0ef2a71255032">00373</a> <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00070.html#ad6d883a5f4e66f397cc0ef2a71255032">bvect_</a>;

401

<a name="l00374"></a><a class="code" href="a00070.html#a2a3cb7001d4469b6b0491105dfd443c0">00374</a> <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00070.html#a2a3cb7001d4469b6b0491105dfd443c0">max_bit_</a>;

402

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

403

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

404

<a name="l00377"></a>00377 /*!

405

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

406

<a name="l00379"></a>00379 @ingroup bvector

407

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

408

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

409

<a name="l00382"></a>00382 {

410

<a name="l00383"></a>00383 public:

411

<a name="l00384"></a>00384 #ifndef BM_NO_STL

412

<a name="l00385"></a><a class="code" href="a00062.html#a0af72b4644bc1148f549d21a00330210">00385</a> typedef std::input_iterator_tag <a class="code" href="a00062.html#a0af72b4644bc1148f549d21a00330210">iterator_category</a>;

413

<a name="l00386"></a>00386 #endif

414

<a name="l00387"></a><a class="code" href="a00062.html#add1a3fd37bf2915c5689733969d9ce78">00387</a> typedef unsigned <a class="code" href="a00062.html#add1a3fd37bf2915c5689733969d9ce78">value_type</a>;

415

<a name="l00388"></a><a class="code" href="a00062.html#a46bd8935b22e5a83be62e9e8e00785e1">00388</a> typedef unsigned <a class="code" href="a00062.html#a46bd8935b22e5a83be62e9e8e00785e1">difference_type</a>;

416

<a name="l00389"></a><a class="code" href="a00062.html#ada062866d44923ecab233a51f4daf26e">00389</a> typedef unsigned* <a class="code" href="a00062.html#ada062866d44923ecab233a51f4daf26e">pointer</a>;

417

<a name="l00390"></a><a class="code" href="a00062.html#a827edd466230259a8047f2c26baf830f">00390</a> typedef unsigned& <a class="code" href="a00078.html" title="Class reference implements an object for bit assignment.">reference</a>;

418

<a name="l00391"></a>00391

419

<a name="l00392"></a>00392 public:

420

<a name="l00393"></a><a class="code" href="a00062.html#a4389008f0affee77ef761cab3e5d0f5d">00393</a> <a class="code" href="a00062.html#a4389008f0affee77ef761cab3e5d0f5d">enumerator</a>() : <a class="code" href="a00071.html" title="Base class for all iterators.">iterator_base</a>() {}

421

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

422

<a name="l00395"></a>00395 : <a class="code" href="a00071.html" title="Base class for all iterators.">iterator_base</a>()

423

<a name="l00396"></a>00396 {

424

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

425

<a name="l00398"></a>00398 if (position == 0)

426

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

427

<a name="l00400"></a>00400 <a class="code" href="a00062.html#a7443e66e31258638cdee4ed3bc2d368c">go_first</a>();

428

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

429

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

430

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

431

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

432

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

433

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

434

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

435

<a name="l00408"></a><a class="code" href="a00062.html#adc85b4fca8577fa3ab643fd087948f1b">00408</a> <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00062.html#adc85b4fca8577fa3ab643fd087948f1b">operator*</a>() const

436

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

437

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

438

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

439

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

440

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

441

<a name="l00414"></a>00414 {

442

<a name="l00415"></a>00415 return this-><a class="code" href="a00062.html#a58b4ee025ba7b6545eacad79e7031069">go_up</a>();

443

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

444

<a name="l00417"></a>00417

445

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

446

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

447

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

448

<a name="l00421"></a>00421 this-><a class="code" href="a00062.html#a58b4ee025ba7b6545eacad79e7031069">go_up</a>();

449

<a name="l00422"></a>00422 return tmp;

450

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

451

<a name="l00424"></a>00424

452

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

453

<a name="l00426"></a><a class="code" href="a00062.html#a7443e66e31258638cdee4ed3bc2d368c">00426</a> void <a class="code" href="a00062.html#a7443e66e31258638cdee4ed3bc2d368c">go_first</a>()

454

<a name="l00427"></a>00427 {

455

<a name="l00428"></a>00428 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(this-><a class="code" href="a00071.html#ad341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a>);

456

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

457

<a name="l00430"></a>00430 #ifdef BMCOUNTOPT

458

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

459

<a name="l00432"></a>00432 this->bv_->count_ == 0)

460

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

461

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

462

<a name="l00435"></a>00435 return;

463

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

464

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

465

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

466

<a name="l00439"></a>00439 <a class="code" href="a00043.html#a1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>* bman = &(this-><a class="code" href="a00071.html#ad341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a>->blockman_);

467

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

468

<a name="l00441"></a>00441

469

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

470

<a name="l00443"></a>00443 unsigned i, j;

471

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

472

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

473

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

474

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

475

<a name="l00448"></a>00448

476

<a name="l00449"></a>00449 if (blk_blk == 0) // not allocated

477

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

478

<a name="l00451"></a>00451 this-><a class="code" href="a00071.html#a07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a> += <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>;

479

<a name="l00452"></a>00452 this-><a class="code" href="a00071.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += <a class="code" href="a00110.html#a4dedd13a7b8a27c5067b20118002f025">bm::bits_in_array</a>;

480

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

481

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

482

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

483

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

484

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

485

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

486

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

487

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

488

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

489

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

490

<a name="l00463"></a>00463 this-><a class="code" href="a00071.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += <a class="code" href="a00110.html#ae9916f69ced0347d94472d7944ea0e45">bits_in_block</a>;

491

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

492

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

493

<a name="l00466"></a>00466

494

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

495

<a name="l00468"></a>00468 {

496

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

497

<a name="l00470"></a>00470 if (search_in_gapblock())

498

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

499

<a name="l00472"></a>00472 return;

500

<a name="l00473"></a>00473 }

501

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

502

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

503

<a name="l00476"></a>00476 {

504

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

505

<a name="l00478"></a>00478 if (search_in_bitblock())

506

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

507

<a name="l00480"></a>00480 return;

508

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

509

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

510

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

511

<a name="l00484"></a>00484 } // for j

512

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

513

<a name="l00486"></a>00486 } // for i

514

<a name="l00487"></a>00487

515

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

516

<a name="l00489"></a>00489 }

517

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

518

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

519

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

520

<a name="l00493"></a>00493 // Current block search.

521

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

522

<a name="l00495"></a>00495 typedef typename <a class="code" href="a00039.html">iterator_base::block_descr</a> block_descr_type;

523

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

524

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

525

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

526

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

527

<a name="l00500"></a>00500 {

528

<a name="l00501"></a>00501 case 0: // BitBlock

529

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

530

<a name="l00503"></a>00503

531

<a name="l00504"></a>00504 // check if we can get the value from the

532

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

533

<a name="l00506"></a>00506

534

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

535

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

536

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

537

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

538

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

539

<a name="l00512"></a>00512 return *this;

540

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

541

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

542

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

543

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

544

<a name="l00517"></a>00517

545

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

546

<a name="l00519"></a>00519 {

547

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

548

<a name="l00521"></a>00521 if (w)

549

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

550

<a name="l00523"></a>00523 bdescr->bit_.idx = 0;

551

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

552

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

553

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

554

<a name="l00527"></a>00527 return *this;

555

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

556

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

557

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

558

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

559

<a name="l00532"></a>00532 }

560

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

561

<a name="l00534"></a>00534

562

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

563

<a name="l00536"></a>00536 break;

564

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

565

<a name="l00538"></a>00538 case 1: // DGAP Block

566

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

567

<a name="l00540"></a>00540 if (--(bdescr->gap_.gap_len))

568

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

569

<a name="l00542"></a>00542 return *this;

570

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

571

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

572

<a name="l00545"></a>00545 // next gap is "OFF" by definition.

573

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

574

<a name="l00547"></a>00547 {

575

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

576

<a name="l00549"></a>00549 }

577

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

578

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

579

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

580

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

581

<a name="l00554"></a>00554 // next gap is now "ON"

582

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

583

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

584

<a name="l00557"></a>00557 {

585

<a name="l00558"></a>00558 break;

586

<a name="l00559"></a>00559 }

587

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

588

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

589

<a name="l00562"></a>00562 bdescr->gap_.gap_len = val - prev;

590

<a name="l00563"></a>00563 return *this; // next "ON" found;

591

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

592

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

593

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

594

<a name="l00567"></a>00567 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(0);

595

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

596

<a name="l00569"></a>00569 } // switch

597

<a name="l00570"></a>00570

598

<a name="l00571"></a>00571

599

<a name="l00572"></a>00572 // next bit not present in the current block

600

<a name="l00573"></a>00573 // keep looking in the next blocks.

601

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

602

<a name="l00575"></a>00575 unsigned i = this-><a class="code" href="a00071.html#a07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a> >> <a class="code" href="a00110.html#ac1ff8647a089c751ec330cecee01907e">bm::set_array_shift</a>;

603

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

604

<a name="l00577"></a>00577 for (; i < top_block_size; ++i)

605

<a name="l00578"></a>00578 {

606

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

607

<a name="l00580"></a>00580 if (blk_blk == 0)

608

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

609

<a name="l00582"></a>00582 this-><a class="code" href="a00071.html#a07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a> += <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>;

610

<a name="l00583"></a>00583 this-><a class="code" href="a00071.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += <a class="code" href="a00110.html#a4dedd13a7b8a27c5067b20118002f025">bm::bits_in_array</a>;

611

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

612

<a name="l00585"></a>00585 }

613

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

614

<a name="l00587"></a>00587 unsigned j = this-><a class="code" href="a00071.html#a07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a> & <a class="code" href="a00110.html#a00ffa7b38d7fcc7e522d864991a6de68">bm::set_array_mask</a>;

615

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

616

<a name="l00589"></a>00589 for(; j < <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>; ++j, ++(this-><a class="code" href="a00071.html#a07908a3bcc023120e8bbf4e81ba62139" title="Block index.">block_idx_</a>))

617

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

618

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

619

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

620

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

621

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

622

<a name="l00595"></a>00595 this-><a class="code" href="a00071.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += <a class="code" href="a00110.html#ae9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a>;

623

<a name="l00596"></a>00596 continue;

624

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

625

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

626

<a name="l00599"></a>00599 if (<a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>((this-><a class="code" href="a00071.html#ad341d73f3dc97bb5e70befcae7cbf014" title="Pointer on parent bitvector.">bv_</a>->blockman_),

627

<a name="l00600"></a>00600 this->block_,

628

<a name="l00601"></a>00601 this->block_idx_))

629

<a name="l00602"></a>00602 {

630

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

631

<a name="l00604"></a>00604 if (search_in_gapblock())

632

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

633

<a name="l00606"></a>00606 return *this;

634

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

635

<a name="l00608"></a>00608 }

636

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

637

<a name="l00610"></a>00610 {

638

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

639

<a name="l00612"></a>00612 if (search_in_bitblock())

640

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

641

<a name="l00614"></a>00614 return *this;

642

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

643

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

644

<a name="l00617"></a>00617

645

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

646

<a name="l00619"></a>00619 } // for j

647

<a name="l00620"></a>00620

648

<a name="l00621"></a>00621 } // for i

649

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

650

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

651

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

652

<a name="l00625"></a>00625 return *this;

653

<a name="l00626"></a>00626 }

654

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

655

<a name="l00628"></a>00628

656

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

657

<a name="l00630"></a>00630 bool search_in_bitblock()

658

<a name="l00631"></a>00631 {

659

<a name="l00632"></a>00632 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(this-><a class="code" href="a00071.html#a8a9a7fa7ba70eb1aa10180e40239fe7f" title="Type of block. 0-Bit, 1-GAP.">block_type_</a> == 0);

660

<a name="l00633"></a>00633

661

<a name="l00634"></a>00634 typedef typename <a class="code" href="a00039.html">iterator_base::block_descr</a> block_descr_type;

662

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

663

<a name="l00636"></a>00636

664

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

665

<a name="l00638"></a>00638 bdescr->bit_.ptr = this-><a class="code" href="a00071.html#a6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a>;

666

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

667

<a name="l00640"></a>00640 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">word_t</a>* ptr_end = this-><a class="code" href="a00071.html#a6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a> + <a class="code" href="a00110.html#a91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a>;

668

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

669

<a name="l00642"></a>00642 do

670

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

671

<a name="l00644"></a>00644 register <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a> w = *(bdescr->bit_.ptr);

672

<a name="l00645"></a>00645

673

<a name="l00646"></a>00646 if (w)

674

<a name="l00647"></a>00647 {

675

<a name="l00648"></a>00648 bdescr->bit_.idx = 0;

676

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

677

<a name="l00650"></a>00650 bdescr->bit_.cnt =

678

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

679

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

680

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

681

<a name="l00654"></a>00654 return true;

682

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

683

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

684

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

685

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

686

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

687

<a name="l00660"></a>00660

688

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

689

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

690

<a name="l00663"></a>00663

691

<a name="l00664"></a>00664 return false;

692

<a name="l00665"></a>00665 }

693

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

694

<a name="l00667"></a>00667 bool search_in_gapblock()

695

<a name="l00668"></a>00668 {

696

<a name="l00669"></a>00669 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(this-><a class="code" href="a00071.html#a8a9a7fa7ba70eb1aa10180e40239fe7f" title="Type of block. 0-Bit, 1-GAP.">block_type_</a> == 1);

697

<a name="l00670"></a>00670

698

<a name="l00671"></a>00671 typedef typename iterator_base::block_descr block_descr_type;

699

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

700

<a name="l00673"></a>00673

701

<a name="l00674"></a>00674 bdescr->gap_.ptr = <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(this-><a class="code" href="a00071.html#a6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a>);

702

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

703

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

704

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

705

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

706

<a name="l00679"></a>00679 do

707

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

708

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

709

<a name="l00682"></a>00682

710

<a name="l00683"></a>00683 if (bitval)

711

<a name="l00684"></a>00684 {

712

<a name="l00685"></a>00685 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* <a class="code" href="a00043.html#aad48c661f843e32c9893438a6f27a8f0" title="Returns enumerator pointing on the first non-zero bit.">first</a> = <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(this-><a class="code" href="a00071.html#a6d92e5c216b76dfbccbc2ebab1dd7b8d" title="Block pointer.(NULL-invalid).">block_</a>) + 1;

713

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

714

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

715

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

716

<a name="l00689"></a>00689 }

717

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

718

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

719

<a name="l00692"></a>00692 bdescr->gap_.gap_len =

720

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

721

<a name="l00694"></a>00694 }

722

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

723

<a name="l00696"></a>00696 return true;

724

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

725

<a name="l00698"></a>00698 this-><a class="code" href="a00071.html#a9f8b2774e7f16176cd0071550173fee9" title="Bit position (bit idx).">position_</a> += val + 1;

726

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

727

<a name="l00700"></a>00700 if (val == <a class="code" href="a00110.html#ad0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a> - 1)

728

<a name="l00701"></a>00701 {

729

<a name="l00702"></a>00702 break;

730

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

731

<a name="l00704"></a>00704

732

<a name="l00705"></a>00705 bitval ^= 1;

733

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

734

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

735

<a name="l00708"></a>00708 } while (1);

736

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

737

<a name="l00710"></a>00710 return false;

738

<a name="l00711"></a>00711 }

739

<a name="l00712"></a>00712

740

<a name="l00713"></a>00713 };

741

<a name="l00714"></a>00714

742

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

743

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

744

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

745

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

746

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

747

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

748

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

749

<a name="l00722"></a>00722 @ingroup bvector

750

<a name="l00723"></a>00723 */

751

<a name="l00724"></a><a class="code" href="a00048.html">00724</a> class <a class="code" href="a00048.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits counted_enumerator...">counted_enumerator</a> : public <a class="code" href="a00062.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a>

752

<a name="l00725"></a>00725 {

753

<a name="l00726"></a>00726 public:

754

<a name="l00727"></a>00727 #ifndef BM_NO_STL

755

<a name="l00728"></a><a class="code" href="a00048.html#a171919f2a88ab74fcea53f9f75225712">00728</a> typedef std::input_iterator_tag <a class="code" href="a00048.html#a171919f2a88ab74fcea53f9f75225712">iterator_category</a>;

756

<a name="l00729"></a>00729 #endif

757

<a name="l00730"></a><a class="code" href="a00048.html#a0a6f5329ef42122de9fcc754c0318cb6">00730</a> <a class="code" href="a00048.html#a0a6f5329ef42122de9fcc754c0318cb6">counted_enumerator</a>() : bit_count_(0){}

758

<a name="l00731"></a>00731

759

<a name="l00732"></a><a class="code" href="a00048.html#a4b0d8b4e7b7268707355b813434bcfcb">00732</a> <a class="code" href="a00048.html#a0a6f5329ef42122de9fcc754c0318cb6">counted_enumerator</a>(const <a class="code" href="a00062.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a>& en)

760

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

761

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

762

<a name="l00735"></a>00735 if (this-><a class="code" href="a00071.html#aa06eb362d550d37b214591a113be4e7b" title="Checks if iterator is still valid.">valid</a>())

763

<a name="l00736"></a>00736 bit_count_ = 1;

764

<a name="l00737"></a>00737 }

765

<a name="l00738"></a>00738

766

<a name="l00739"></a><a class="code" href="a00048.html#a9e2badd4602a744f1df04de7d9249314">00739</a> <a class="code" href="a00048.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits counted_enumerator...">counted_enumerator</a>& <a class="code" href="a00048.html#a9e2badd4602a744f1df04de7d9249314">operator=</a>(const <a class="code" href="a00062.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a>& en)

767

<a name="l00740"></a>00740 {

768

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

769

<a name="l00742"></a>00742 *me = en;

770

<a name="l00743"></a>00743 if (this-><a class="code" href="a00071.html#aa06eb362d550d37b214591a113be4e7b" title="Checks if iterator is still valid.">valid</a>())

771

<a name="l00744"></a>00744 this->bit_count_ = 1;

772

<a name="l00745"></a>00745 return *this;

773

<a name="l00746"></a>00746 }

774

<a name="l00747"></a>00747

775

<a name="l00748"></a><a class="code" href="a00048.html#a65e58d9cb5ad45c89502c50e346c0f70">00748</a> <a class="code" href="a00048.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits counted_enumerator...">counted_enumerator</a>& <a class="code" href="a00048.html#a65e58d9cb5ad45c89502c50e346c0f70">operator++</a>()

776

<a name="l00749"></a>00749 {

777

<a name="l00750"></a>00750 this-><a class="code" href="a00062.html#a58b4ee025ba7b6545eacad79e7031069">go_up</a>();

778

<a name="l00751"></a>00751 if (this-><a class="code" href="a00071.html#aa06eb362d550d37b214591a113be4e7b" title="Checks if iterator is still valid.">valid</a>())

779

<a name="l00752"></a>00752 ++(this->bit_count_);

780

<a name="l00753"></a>00753 return *this;

781

<a name="l00754"></a>00754 }

782

<a name="l00755"></a>00755

783

<a name="l00756"></a><a class="code" href="a00048.html#a91b38c1ed0a8c913684ad02bcfd67b84">00756</a> <a class="code" href="a00048.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits counted_enumerator...">counted_enumerator</a> <a class="code" href="a00048.html#a65e58d9cb5ad45c89502c50e346c0f70">operator++</a>(int)

784

<a name="l00757"></a>00757 {

785

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

786

<a name="l00759"></a>00759 this-><a class="code" href="a00062.html#a58b4ee025ba7b6545eacad79e7031069">go_up</a>();

787

<a name="l00760"></a>00760 if (this-><a class="code" href="a00071.html#aa06eb362d550d37b214591a113be4e7b" title="Checks if iterator is still valid.">valid</a>())

788

<a name="l00761"></a>00761 ++bit_count_;

789

<a name="l00762"></a>00762 return tmp;

790

<a name="l00763"></a>00763 }

791

<a name="l00764"></a>00764

792

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

793

<a name="l00766"></a>00766

794

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

795

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

796

<a name="l00769"></a>00769 */

797

<a name="l00770"></a><a class="code" href="a00048.html#a61abf2ecf53823d347ea53adb3a8be4a">00770</a> <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00048.html#a61abf2ecf53823d347ea53adb3a8be4a" title="Number of bits ON starting from the .">count</a>() const { return bit_count_; }

798

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

799

<a name="l00772"></a>00772 private:

800

<a name="l00773"></a>00773 <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> bit_count_;

801

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

802

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

803

<a name="l00776"></a><a class="code" href="a00043.html#aeec1461fca400b5b4313765eb9e94c73">00776</a> friend class <a class="code" href="a00071.html" title="Base class for all iterators.">iterator_base</a>;

804

<a name="l00777"></a><a class="code" href="a00043.html#a71cabca9670588878381f72d16e059b8">00777</a> friend class <a class="code" href="a00062.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a>;

805

<a name="l00778"></a>00778

806

<a name="l00779"></a>00779 public:

807

<a name="l00780"></a>00780

808

<a name="l00781"></a>00781 #ifdef BMCOUNTOPT

809

<a name="l00782"></a>00782 <a class="code" href="a00043.html#aa2813ce4ce80ab8c6532e8b478b6d934" title="Constructs bvector class.">bvector</a>(<a class="code" href="a00113.html#gad0b87b3b7292383a864d27feaf1c9eff" title="Block allocation strategies.">strategy</a> strat = <a class="code" href="a00113.html#ggad0b87b3b7292383a864d27feaf1c9effa40920ae0ef7b4411d60463d8f576b5ba" title="No GAP compression strategy. All new blocks are bit blocks.">BM_BIT</a>,

810

<a name="l00783"></a>00783 const <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* glevel_len = <a class="code" href="a00066.html" title="Default GAP lengths table.">bm::gap_len_table<true>::_len</a>,

811

<a name="l00784"></a>00784 <a class="code" href="a00043.html#aba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> bv_size = <a class="code" href="a00110.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>,

812

<a name="l00785"></a>00785 const Alloc& alloc = Alloc())

813

<a name="l00786"></a>00786 : count_(0),

814

<a name="l00787"></a>00787 count_is_valid_(true),

815

<a name="l00788"></a>00788 blockman_(glevel_len, bv_size, alloc),

816

<a name="l00789"></a>00789 new_blocks_strat_(strat),

817

<a name="l00790"></a>00790 size_(bv_size)

818

<a name="l00791"></a>00791 {}

819

<a name="l00792"></a>00792

820

<a name="l00793"></a>00793 <a class="code" href="a00043.html#aa2813ce4ce80ab8c6532e8b478b6d934" title="Constructs bvector class.">bvector</a>(<a class="code" href="a00043.html#aba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> bv_size,

821

<a name="l00794"></a>00794 <a class="code" href="a00113.html#gad0b87b3b7292383a864d27feaf1c9eff" title="Block allocation strategies.">bm::strategy</a> strat = <a class="code" href="a00113.html#ggad0b87b3b7292383a864d27feaf1c9effa40920ae0ef7b4411d60463d8f576b5ba" title="No GAP compression strategy. All new blocks are bit blocks.">BM_BIT</a>,

822

<a name="l00795"></a>00795 const <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* glevel_len = <a class="code" href="a00066.html" title="Default GAP lengths table.">bm::gap_len_table<true>::_len</a>,

823

<a name="l00796"></a>00796 const Alloc& alloc = Alloc())

824

<a name="l00797"></a>00797 : count_(0),

825

<a name="l00798"></a>00798 count_is_valid_(true),

826

<a name="l00799"></a>00799 blockman_(glevel_len, bv_size, alloc),

827

<a name="l00800"></a>00800 new_blocks_strat_(strat),

828

<a name="l00801"></a>00801 size_(bv_size)

829

<a name="l00802"></a>00802 {}

830

<a name="l00803"></a>00803

831

<a name="l00804"></a>00804

832

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

833

<a name="l00806"></a>00806 : count_(bvect.count_),

834

<a name="l00807"></a>00807 count_is_valid_(bvect.count_is_valid_),

835

<a name="l00808"></a>00808 blockman_(bvect.blockman_),

836

<a name="l00809"></a>00809 new_blocks_strat_(bvect.new_blocks_strat_),

837

<a name="l00810"></a>00810 size_(bvect.size_)

838

<a name="l00811"></a>00811 {}

839

<a name="l00812"></a>00812

840

<a name="l00813"></a>00813 #else

841

<a name="l00814"></a>00814 /*!

842

<a name="l00815"></a>00815 \brief Constructs bvector class

843

<a name="l00816"></a>00816 \param strat - operation mode strategy,

844

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

845

<a name="l00818"></a>00818 blocks, (performance oriented strategy).

846

<a name="l00819"></a>00819 BM_GAP - memory effitent strategy, bvector allocates

847

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

848

<a name="l00821"></a>00821 into plain bitsets only when enthropy grows.

849

<a name="l00822"></a>00822 \param glevel_len

850

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

851

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

852

<a name="l00825"></a>00825 \param bv_size

853

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

854

<a name="l00827"></a>00827 "no limits" (recommended).

855

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

856

<a name="l00829"></a>00829

857

<a name="l00830"></a>00830 \sa bm::gap_len_table bm::gap_len_table_min set_new_blocks_strat

858

<a name="l00831"></a>00831 */

859

<a name="l00832"></a><a class="code" href="a00043.html#aa2813ce4ce80ab8c6532e8b478b6d934">00832</a> <a class="code" href="a00043.html#aa2813ce4ce80ab8c6532e8b478b6d934" title="Constructs bvector class.">bvector</a>(<a class="code" href="a00113.html#gad0b87b3b7292383a864d27feaf1c9eff" title="Block allocation strategies.">strategy</a> strat = <a class="code" href="a00113.html#ggad0b87b3b7292383a864d27feaf1c9effa40920ae0ef7b4411d60463d8f576b5ba" title="No GAP compression strategy. All new blocks are bit blocks.">BM_BIT</a>,

860

<a name="l00833"></a>00833 const <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* glevel_len = <a class="code" href="a00066.html" title="Default GAP lengths table.">bm::gap_len_table<true>::_len</a>,

861

<a name="l00834"></a>00834 <a class="code" href="a00043.html#aba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> bv_size = <a class="code" href="a00110.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>,

862

<a name="l00835"></a>00835 const Alloc& alloc = Alloc())

863

<a name="l00836"></a>00836 : blockman_(glevel_len, bv_size, alloc),

864

<a name="l00837"></a>00837 new_blocks_strat_(strat),

865

<a name="l00838"></a>00838 size_(bv_size)

866

<a name="l00839"></a>00839 {}

867

<a name="l00840"></a>00840

868

<a name="l00841"></a>00841 /*!

869

<a name="l00842"></a>00842 \brief Constructs bvector class

870

<a name="l00843"></a>00843 */

871

<a name="l00844"></a><a class="code" href="a00043.html#a3b95b73a26160b2b364e6e1e86167994">00844</a> <a class="code" href="a00043.html#aa2813ce4ce80ab8c6532e8b478b6d934" title="Constructs bvector class.">bvector</a>(<a class="code" href="a00043.html#aba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> bv_size,

872

<a name="l00845"></a>00845 <a class="code" href="a00113.html#gad0b87b3b7292383a864d27feaf1c9eff" title="Block allocation strategies.">strategy</a> strat = <a class="code" href="a00113.html#ggad0b87b3b7292383a864d27feaf1c9effa40920ae0ef7b4411d60463d8f576b5ba" title="No GAP compression strategy. All new blocks are bit blocks.">BM_BIT</a>,

873

<a name="l00846"></a>00846 const <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* glevel_len = <a class="code" href="a00066.html" title="Default GAP lengths table.">bm::gap_len_table<true>::_len</a>,

874

<a name="l00847"></a>00847 const Alloc& alloc = Alloc())

875

<a name="l00848"></a>00848 : blockman_(glevel_len, bv_size, alloc),

876

<a name="l00849"></a>00849 new_blocks_strat_(strat),

877

<a name="l00850"></a>00850 size_(bv_size)

878

<a name="l00851"></a>00851 {}

879

<a name="l00852"></a>00852

880

<a name="l00853"></a>00853

881

<a name="l00854"></a><a class="code" href="a00043.html#a95752bab343fd1b5483043dbbec98a96">00854</a> <a class="code" href="a00043.html#aa2813ce4ce80ab8c6532e8b478b6d934" title="Constructs bvector class.">bvector</a>(const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvect</a>)

882

<a name="l00855"></a>00855 : blockman_(bvect.blockman_),

883

<a name="l00856"></a>00856 new_blocks_strat_(bvect.new_blocks_strat_),

884

<a name="l00857"></a>00857 size_(bvect.size_)

885

<a name="l00858"></a>00858 {}

886

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

887

<a name="l00860"></a>00860 #endif

888

<a name="l00861"></a>00861

889

<a name="l00862"></a><a class="code" href="a00043.html#ad6d691215d7945d1eab58f55055f32ad">00862</a> <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector</a>& <a class="code" href="a00043.html#ad6d691215d7945d1eab58f55055f32ad">operator=</a>(const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvect</a>)

890

<a name="l00863"></a>00863 {

891

<a name="l00864"></a>00864 <a class="code" href="a00043.html#afe98c658c4ee54155e61f9bdfa7b9019" title="Clears every bit in the bitvector.">clear</a>(true); // memory free cleaning

892

<a name="l00865"></a>00865 <a class="code" href="a00043.html#a7be4f9e0741f43869f4dcd9607736c0e" title="Change size of the bvector.">resize</a>(bvect.<a class="code" href="a00043.html#a1b021e7217f530390511e16b9b25f631" title="return current size of the vector (bits)">size</a>());

893

<a name="l00866"></a>00866 <a class="code" href="a00043.html#a0eacd87603f41a9aea2126810183f83a" title="Logical OR operation.">bit_or</a>(bvect);

894

<a name="l00867"></a>00867 return *this;

895

<a name="l00868"></a>00868 }

896

<a name="l00869"></a>00869

897

<a name="l00870"></a><a class="code" href="a00043.html#a98a1223891cbd4e87245defb4e3f165e">00870</a> <a class="code" href="a00078.html" title="Class reference implements an object for bit assignment.">reference</a> <a class="code" href="a00043.html#a98a1223891cbd4e87245defb4e3f165e">operator[]</a>(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n)

898

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

899

<a name="l00872"></a>00872 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(n < size_);

900

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

901

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

902

<a name="l00875"></a>00875

903

<a name="l00876"></a>00876

904

<a name="l00877"></a><a class="code" href="a00043.html#a3d71b08005a276991b031151e423760e">00877</a> bool <a class="code" href="a00043.html#a98a1223891cbd4e87245defb4e3f165e">operator[]</a>(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n) const

905

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

906

<a name="l00879"></a>00879 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(n < size_);

907

<a name="l00880"></a>00880 return <a class="code" href="a00043.html#a11458ca2e3570838da7b94a1e4563d97" title="returns true if bit n is set and false is bit n is 0.">get_bit</a>(n);

908

<a name="l00881"></a>00881 }

909

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

910

<a name="l00883"></a><a class="code" href="a00043.html#a1259c399b970e6fa3715d74387e682c6">00883</a> void <a class="code" href="a00043.html#a1259c399b970e6fa3715d74387e682c6">operator &= </a>(const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvect</a>)

911

<a name="l00884"></a>00884 {

912

<a name="l00885"></a>00885 <a class="code" href="a00043.html#a051a39027c3b12751f172c20f2d03a0f" title="Logical AND operation.">bit_and</a>(bvect);

913

<a name="l00886"></a>00886 }

914

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

915

<a name="l00888"></a><a class="code" href="a00043.html#a3db27387f92cdfa4d883074d7bd525a6">00888</a> void <a class="code" href="a00043.html#a3db27387f92cdfa4d883074d7bd525a6">operator ^= </a>(const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvect</a>)

916

<a name="l00889"></a>00889 {

917

<a name="l00890"></a>00890 <a class="code" href="a00043.html#a997a62ec2effcd60246fb9b72f30ccfa" title="Logical XOR operation.">bit_xor</a>(bvect);

918

<a name="l00891"></a>00891 }

919

<a name="l00892"></a>00892

920

<a name="l00893"></a><a class="code" href="a00043.html#a0a708b4c4c0ac810bd5c4d1280200b10">00893</a> void <a class="code" href="a00043.html#a0a708b4c4c0ac810bd5c4d1280200b10">operator |= </a>(const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvect</a>)

921

<a name="l00894"></a>00894 {

922

<a name="l00895"></a>00895 <a class="code" href="a00043.html#a0eacd87603f41a9aea2126810183f83a" title="Logical OR operation.">bit_or</a>(bvect);

923

<a name="l00896"></a>00896 }

924

<a name="l00897"></a>00897

925

<a name="l00898"></a><a class="code" href="a00043.html#aef8c3032b194d7c127f1a14ef9506fb8">00898</a> void <a class="code" href="a00043.html#aef8c3032b194d7c127f1a14ef9506fb8">operator -= </a>(const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvect</a>)

926

<a name="l00899"></a>00899 {

927

<a name="l00900"></a>00900 <a class="code" href="a00043.html#a6a8e699f9c0571f904d7cbaa2e3ed1f1" title="Logical SUB operation.">bit_sub</a>(bvect);

928

<a name="l00901"></a>00901 }

929

<a name="l00902"></a>00902

930

<a name="l00903"></a><a class="code" href="a00043.html#a278768eb0518183740f172628fe57976">00903</a> bool operator < (const bvector<Alloc, MS>& <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvect</a>) const

931

<a name="l00904"></a>00904 {

932

<a name="l00905"></a>00905 return <a class="code" href="a00043.html#aa2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">compare</a>(<a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvect</a>) < 0;

933

<a name="l00906"></a>00906 }

934

<a name="l00907"></a>00907

935

<a name="l00908"></a><a class="code" href="a00043.html#ad8ca63ae760dd647ad1dbdc9e489a046">00908</a> bool operator <= (const bvector<Alloc, MS>& <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvect</a>) const

936

<a name="l00909"></a>00909 {

937

<a name="l00910"></a>00910 return <a class="code" href="a00043.html#aa2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">compare</a>(<a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvect</a>) <= 0;

938

<a name="l00911"></a>00911 }

939

<a name="l00912"></a>00912

940

<a name="l00913"></a><a class="code" href="a00043.html#a3cf8dfe14ae27d78cb3c0bb90c2b6f19">00913</a> bool <a class="code" href="a00043.html#a3cf8dfe14ae27d78cb3c0bb90c2b6f19">operator > </a>(const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvect</a>) const

941

<a name="l00914"></a>00914 {

942

<a name="l00915"></a>00915 return <a class="code" href="a00043.html#aa2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">compare</a>(bvect) > 0;

943

<a name="l00916"></a>00916 }

944

<a name="l00917"></a>00917

945

<a name="l00918"></a><a class="code" href="a00043.html#ac1946edc275e405998e986d210c6c829">00918</a> bool <a class="code" href="a00043.html#ac1946edc275e405998e986d210c6c829">operator >= </a>(const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvect</a>) const

946

<a name="l00919"></a>00919 {

947

<a name="l00920"></a>00920 return <a class="code" href="a00043.html#aa2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">compare</a>(bvect) >= 0;

948

<a name="l00921"></a>00921 }

949

<a name="l00922"></a>00922

950

<a name="l00923"></a><a class="code" href="a00043.html#a7eae868e8565f4412cce23ff1f82fc4c">00923</a> bool <a class="code" href="a00043.html#a7eae868e8565f4412cce23ff1f82fc4c">operator == </a>(const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvect</a>) const

951

<a name="l00924"></a>00924 {

952

<a name="l00925"></a>00925 return <a class="code" href="a00043.html#aa2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">compare</a>(bvect) == 0;

953

<a name="l00926"></a>00926 }

954

<a name="l00927"></a>00927

955

<a name="l00928"></a><a class="code" href="a00043.html#a0d82c126fe741d082b17a60c8617865f">00928</a> bool <a class="code" href="a00043.html#a0d82c126fe741d082b17a60c8617865f">operator != </a>(const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvect</a>) const

956

<a name="l00929"></a>00929 {

957

<a name="l00930"></a>00930 return <a class="code" href="a00043.html#aa2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">compare</a>(bvect) != 0;

958

<a name="l00931"></a>00931 }

959

<a name="l00932"></a>00932

960

<a name="l00933"></a><a class="code" href="a00043.html#a281157317851c62d91d5ba6d32d33ec7">00933</a> <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> <a class="code" href="a00043.html#a281157317851c62d91d5ba6d32d33ec7">operator~</a>() const

961

<a name="l00934"></a>00934 {

962

<a name="l00935"></a>00935 return <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>(*this).invert();

963

<a name="l00936"></a>00936 }

964

<a name="l00937"></a>00937

965

<a name="l00938"></a><a class="code" href="a00043.html#a9af5dca8d808990b92bdf20b10b63198">00938</a> Alloc <a class="code" href="a00043.html#a9af5dca8d808990b92bdf20b10b63198">get_allocator</a>() const

966

<a name="l00939"></a>00939 {

967

<a name="l00940"></a>00940 return blockman_.get_allocator();

968

<a name="l00941"></a>00941 }

969

<a name="l00942"></a>00942

970

<a name="l00943"></a>00943

971

<a name="l00944"></a>00944 /*!

972

<a name="l00945"></a>00945 \brief Sets bit n.

973

<a name="l00946"></a>00946 \param n - index of the bit to be set.

974

<a name="l00947"></a>00947 \param val - new bit value

975

<a name="l00948"></a>00948 \return TRUE if bit was changed

976

<a name="l00949"></a>00949 */

977

<a name="l00950"></a><a class="code" href="a00043.html#a1769d9ed3a4ee41b03fc3ca4a0e5a58e">00950</a> bool <a class="code" href="a00043.html#a1769d9ed3a4ee41b03fc3ca4a0e5a58e" title="Sets bit n.">set_bit</a>(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val = true)

978

<a name="l00951"></a>00951 {

979

<a name="l00952"></a>00952 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(n < size_);

980

<a name="l00953"></a>00953 return set_bit_no_check(n, val);

981

<a name="l00954"></a>00954 }

982

<a name="l00955"></a>00955

983

<a name="l00956"></a>00956 /*!

984

<a name="l00957"></a>00957 \brief Sets bit n using bit AND with the provided value.

985

<a name="l00958"></a>00958 \param n - index of the bit to be set.

986

<a name="l00959"></a>00959 \param val - new bit value

987

<a name="l00960"></a>00960 \return TRUE if bit was changed

988

<a name="l00961"></a>00961 */

989

<a name="l00962"></a><a class="code" href="a00043.html#a432ac93e2bcd428f659810bb0e6cc9e8">00962</a> bool <a class="code" href="a00043.html#a432ac93e2bcd428f659810bb0e6cc9e8" title="Sets bit n using bit AND with the provided value.">set_bit_and</a>(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val = true)

990

<a name="l00963"></a>00963 {

991

<a name="l00964"></a>00964 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(n < size_);

992

<a name="l00965"></a>00965 return and_bit_no_check(n, val);

993

<a name="l00966"></a>00966 }

994

<a name="l00967"></a>00967

995

<a name="l00968"></a>00968 /*!

996

<a name="l00969"></a>00969 \brief Sets bit n only if current value is equal to the condition

997

<a name="l00970"></a>00970 \param n - index of the bit to be set.

998

<a name="l00971"></a>00971 \param val - new bit value

999

<a name="l00972"></a>00972 \param condition - expected current value

1000

<a name="l00973"></a>00973 \return TRUE if bit was changed

1001

<a name="l00974"></a>00974 */

1002

<a name="l00975"></a><a class="code" href="a00043.html#ab769dc46d71c5df276d8403b20ed5eb0">00975</a> bool <a class="code" href="a00043.html#ab769dc46d71c5df276d8403b20ed5eb0" title="Sets bit n only if current value is equal to the condition.">set_bit_conditional</a>(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val, bool condition)

1003

<a name="l00976"></a>00976 {

1004

<a name="l00977"></a>00977 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(n < size_);

1005

<a name="l00978"></a>00978 if (val == condition) return false;

1006

<a name="l00979"></a>00979 return set_bit_conditional_impl(n, val, condition);

1007

<a name="l00980"></a>00980 }

1008

<a name="l00981"></a>00981

1009

<a name="l00982"></a>00982

1010

<a name="l00983"></a>00983 /*!

1011

<a name="l00984"></a>00984 \brief Sets bit n if val is true, clears bit n if val is false

1012

<a name="l00985"></a>00985 \param n - index of the bit to be set

1013

<a name="l00986"></a>00986 \param val - new bit value

1014

<a name="l00987"></a>00987 \return *this

1015

<a name="l00988"></a>00988 */

1016

<a name="l00989"></a><a class="code" href="a00043.html#abc85ec9da74de03ff7e2a6c836656dd8">00989</a> <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& set(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val = true)

1017

<a name="l00990"></a>00990 {

1018

<a name="l00991"></a>00991 <a class="code" href="a00043.html#a1769d9ed3a4ee41b03fc3ca4a0e5a58e" title="Sets bit n.">set_bit</a>(n, val);

1019

<a name="l00992"></a>00992 return *this;

1020

<a name="l00993"></a>00993 }

1021

<a name="l00994"></a>00994

1022

<a name="l00995"></a>00995

1023

<a name="l00996"></a>00996

1024

<a name="l00997"></a>00997 /*!

1025

<a name="l00998"></a>00998 \brief Sets every bit in this bitset to 1.

1026

<a name="l00999"></a>00999 \return *this

1027

<a name="l01000"></a>01000 */

1028

<a name="l01001"></a><a class="code" href="a00043.html#aa745480d136c8b0e6bc41afe951577c5">01001</a> <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& set()

1029

<a name="l01002"></a>01002 {

1030

<a name="l01003"></a>01003 <a class="code" href="a00084.html#a835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false)

1031

<a name="l01004"></a>01004 <a class="code" href="a00043.html#a14bc35b9b022018f10787b07a5b2af04" title="Sets all bits in the specified closed interval [left,right] Interval must be inside...">set_range</a>(0, size_ - 1, true);

1032

<a name="l01005"></a>01005 return *this;

1033

<a name="l01006"></a>01006 }

1034

<a name="l01007"></a>01007

1035

<a name="l01008"></a>01008

1036

<a name="l01009"></a>01009 /*!

1037

<a name="l01010"></a>01010 \brief Sets all bits in the specified closed interval [left,right]

1038

<a name="l01011"></a>01011 Interval must be inside the bvector's size.

1039

<a name="l01012"></a>01012 This method DOES NOT resize vector.

1040

<a name="l01013"></a>01013

1041

<a name="l01014"></a>01014 \param left - interval start

1042

<a name="l01015"></a>01015 \param right - interval end (closed interval)

1043

<a name="l01016"></a>01016 \param value - value to set interval in

1044

<a name="l01017"></a>01017

1045

<a name="l01018"></a>01018 \return *this

1046

<a name="l01019"></a>01019 */

1047

<a name="l01020"></a>01020 <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00043.html#a14bc35b9b022018f10787b07a5b2af04" title="Sets all bits in the specified closed interval [left,right] Interval must be inside...">set_range</a>(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> left,

1048

<a name="l01021"></a>01021 <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> right,

1049

<a name="l01022"></a>01022 bool value = true);

1050

<a name="l01023"></a>01023

1051

<a name="l01024"></a>01024

1052

<a name="l01025"></a>01025 /*! Function erturns insert iterator for this bitvector */

1053

<a name="l01026"></a><a class="code" href="a00043.html#ada0d32bbd1a135722a7790b13d866451">01026</a> <a class="code" href="a00070.html" title="Output iterator iterator designed to set &quot;ON&quot; bits based on input sequence...">insert_iterator</a> <a class="code" href="a00043.html#ada0d32bbd1a135722a7790b13d866451">inserter</a>()

1054

<a name="l01027"></a>01027 {

1055

<a name="l01028"></a>01028 return <a class="code" href="a00070.html" title="Output iterator iterator designed to set &quot;ON&quot; bits based on input sequence...">insert_iterator</a>(*this);

1056

<a name="l01029"></a>01029 }

1057

<a name="l01030"></a>01030

1058

<a name="l01031"></a>01031

1059

<a name="l01032"></a>01032 /*!

1060

<a name="l01033"></a>01033 \brief Clears bit n.

1061

<a name="l01034"></a>01034 \param n - bit's index to be cleaned.

1062

<a name="l01035"></a>01035 */

1063

<a name="l01036"></a><a class="code" href="a00043.html#a23106b542344f671ff5aff1887657a5d">01036</a> void <a class="code" href="a00043.html#a23106b542344f671ff5aff1887657a5d" title="Clears bit n.">clear_bit</a>(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n)

1064

<a name="l01037"></a>01037 {

1065

<a name="l01038"></a>01038 set(n, false);

1066

<a name="l01039"></a>01039 }

1067

<a name="l01040"></a>01040

1068

<a name="l01041"></a>01041

1069

<a name="l01042"></a>01042 /*!

1070

<a name="l01043"></a>01043 \brief Clears every bit in the bitvector.

1071

<a name="l01044"></a>01044

1072

<a name="l01045"></a>01045 \param free_mem if "true" (default) bvector frees the memory,

1073

<a name="l01046"></a>01046 otherwise sets blocks to 0.

1074

<a name="l01047"></a>01047 */

1075

<a name="l01048"></a><a class="code" href="a00043.html#afe98c658c4ee54155e61f9bdfa7b9019">01048</a> void <a class="code" href="a00043.html#afe98c658c4ee54155e61f9bdfa7b9019" title="Clears every bit in the bitvector.">clear</a>(bool free_mem = false)

1076

<a name="l01049"></a>01049 {

1077

<a name="l01050"></a>01050 blockman_.set_all_zero(free_mem);

1078

<a name="l01051"></a>01051 <a class="code" href="a00084.html#a1fbebc7fe3c22d768ff6e240437ee8f4">BMCOUNT_SET</a>(0);

1079

<a name="l01052"></a>01052 }

1080

<a name="l01053"></a>01053

1081

<a name="l01054"></a>01054 /*!

1082

<a name="l01055"></a>01055 \brief Clears every bit in the bitvector.

1083

<a name="l01056"></a>01056 \return *this;

1084

<a name="l01057"></a>01057 */

1085

<a name="l01058"></a><a class="code" href="a00043.html#a1b0d2eca7aa91d49374cf711407c9a43">01058</a> <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00043.html#a1b0d2eca7aa91d49374cf711407c9a43" title="Clears every bit in the bitvector.">reset</a>()

1086

<a name="l01059"></a>01059 {

1087

<a name="l01060"></a>01060 <a class="code" href="a00043.html#afe98c658c4ee54155e61f9bdfa7b9019" title="Clears every bit in the bitvector.">clear</a>();

1088

<a name="l01061"></a>01061 return *this;

1089

<a name="l01062"></a>01062 }

1090

<a name="l01063"></a>01063

1091

<a name="l01064"></a>01064

1092

<a name="l01065"></a>01065 /*!

1093

<a name="l01066"></a>01066 \brief Returns count of bits which are 1.

1094

<a name="l01067"></a>01067 \return Total number of bits ON.

1095

<a name="l01068"></a>01068 */

1096

<a name="l01069"></a>01069 <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00043.html#a71077c1315555301532e24d4d2b95ea2" title="Returns count of bits which are 1.">count</a>() const;

1097

<a name="l01070"></a>01070

1098

<a name="l01071"></a>01071 /**

1099

<a name="l01072"></a>01072 \brief Returns bvector's capacity (number of bits it can store)

1100

<a name="l01073"></a>01073 */

1101

<a name="l01074"></a><a class="code" href="a00043.html#ab3d054fafa5d361b7aafa3b36cadecc2">01074</a> <a class="code" href="a00043.html#aba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> <a class="code" href="a00043.html#ab3d054fafa5d361b7aafa3b36cadecc2" title="Returns bvector&#39;s capacity (number of bits it can store).">capacity</a>() const

1102

<a name="l01075"></a>01075 {

1103

<a name="l01076"></a>01076 return blockman_.capacity();

1104

<a name="l01077"></a>01077 }

1105

<a name="l01078"></a>01078

1106

<a name="l01079"></a>01079 /*!

1107

<a name="l01080"></a>01080 \brief return current size of the vector (bits)

1108

<a name="l01081"></a>01081 */

1109

<a name="l01082"></a><a class="code" href="a00043.html#a1b021e7217f530390511e16b9b25f631">01082</a> <a class="code" href="a00043.html#aba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> <a class="code" href="a00043.html#a1b021e7217f530390511e16b9b25f631" title="return current size of the vector (bits)">size</a>() const

1110

<a name="l01083"></a>01083 {

1111

<a name="l01084"></a>01084 return size_;

1112

<a name="l01085"></a>01085 }

1113

<a name="l01086"></a>01086

1114

<a name="l01087"></a>01087 /*!

1115

<a name="l01088"></a>01088 \brief Change size of the bvector

1116

<a name="l01089"></a>01089 \param new_size - new size in bits

1117

<a name="l01090"></a>01090 */

1118

<a name="l01091"></a>01091 void <a class="code" href="a00043.html#a7be4f9e0741f43869f4dcd9607736c0e" title="Change size of the bvector.">resize</a>(<a class="code" href="a00043.html#aba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> new_size);

1119

<a name="l01092"></a>01092

1120

<a name="l01093"></a>01093 /*! \brief Computes bitcount values for all bvector blocks

1121

<a name="l01094"></a>01094 \param arr - pointer on array of block bit counts

1122

<a name="l01095"></a>01095 \return Index of the last block counted.

1123

<a name="l01096"></a>01096 This number +1 gives you number of arr elements initialized during the

1124

<a name="l01097"></a>01097 function call.

1125

<a name="l01098"></a>01098 */

1126

<a name="l01099"></a><a class="code" href="a00043.html#a435752c1674607b625d5e9a54febaa5b">01099</a> unsigned <a class="code" href="a00043.html#a435752c1674607b625d5e9a54febaa5b" title="Computes bitcount values for all bvector blocks.">count_blocks</a>(unsigned* arr) const

1127

<a name="l01100"></a>01100 {

1128

<a name="l01101"></a>01101 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*** blk_root = blockman_.get_rootblock();

1129

<a name="l01102"></a>01102 typename blocks_manager_type::block_count_arr_func func(blockman_, &(arr[0]));

1130

<a name="l01103"></a>01103 <a class="code" href="a00110.html#ae8b342c25dc22d6cd26cb96d7ae796db">for_each_nzblock</a>(blk_root, blockman_.effective_top_block_size(),

1131

<a name="l01104"></a>01104 <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>, func);

1132

<a name="l01105"></a>01105 return func.last_block();

1133

<a name="l01106"></a>01106 }

1134

<a name="l01107"></a>01107

1135

<a name="l01108"></a>01108 /*!

1136

<a name="l01109"></a>01109 \brief Returns count of 1 bits in the given diapason.

1137

<a name="l01110"></a>01110 \param left - index of first bit start counting from

1138

<a name="l01111"></a>01111 \param right - index of last bit

1139

<a name="l01112"></a>01112 \param block_count_arr - optional parameter (bitcount by bvector blocks)

1140

<a name="l01113"></a>01113 calculated by count_blocks method. Used to improve performance of

1141

<a name="l01114"></a>01114 wide range searches

1142

<a name="l01115"></a>01115 \return Total number of bits ON.

1143

<a name="l01116"></a>01116 */

1144

<a name="l01117"></a>01117 <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00043.html#adbe1a2423ce166b88a0b57e435af2733" title="Returns count of 1 bits in the given diapason.">count_range</a>(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> left,

1145

<a name="l01118"></a>01118 <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> right,

1146

<a name="l01119"></a>01119 unsigned* block_count_arr=0) const;

1147

<a name="l01120"></a>01120

1148

<a name="l01121"></a>01121

1149

<a name="l01122"></a><a class="code" href="a00043.html#a91adb243bd37e4e9798ba3e4f87e6e1e">01122</a> <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00043.html#a91adb243bd37e4e9798ba3e4f87e6e1e">recalc_count</a>()

1150

<a name="l01123"></a>01123 {

1151

<a name="l01124"></a>01124 <a class="code" href="a00084.html#a835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false)

1152

<a name="l01125"></a>01125 return <a class="code" href="a00043.html#a71077c1315555301532e24d4d2b95ea2" title="Returns count of bits which are 1.">count</a>();

1153

<a name="l01126"></a>01126 }

1154

<a name="l01127"></a>01127

1155

<a name="l01128"></a>01128 /*!

1156

<a name="l01129"></a>01129 Disables count cache. Next call to count() or recalc_count()

1157

<a name="l01130"></a>01130 restores count caching.

1158

<a name="l01131"></a>01131

1159

<a name="l01132"></a>01132 @note Works only if BMCOUNTOPT enabled(defined).

1160

<a name="l01133"></a>01133 Othewise does nothing.

1161

<a name="l01134"></a>01134 */

1162

<a name="l01135"></a><a class="code" href="a00043.html#ad18b82c801a21eeaf5bb519921bd23d8">01135</a> void <a class="code" href="a00043.html#ad18b82c801a21eeaf5bb519921bd23d8">forget_count</a>()

1163

<a name="l01136"></a>01136 {

1164

<a name="l01137"></a>01137 <a class="code" href="a00084.html#a835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false)

1165

<a name="l01138"></a>01138 }

1166

<a name="l01139"></a>01139

1167

<a name="l01140"></a>01140 /*!

1168

<a name="l01141"></a>01141 \brief Inverts all bits.

1169

<a name="l01142"></a>01142 */

1170

<a name="l01143"></a>01143 <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00043.html#a49af36cc1ea632cd3a2217b53b69dafc" title="Inverts all bits.">invert</a>();

1171

<a name="l01144"></a>01144

1172

<a name="l01145"></a>01145

1173

<a name="l01146"></a>01146 /*!

1174

<a name="l01147"></a>01147 \brief returns true if bit n is set and false is bit n is 0.

1175

<a name="l01148"></a>01148 \param n - Index of the bit to check.

1176

<a name="l01149"></a>01149 \return Bit value (1 or 0)

1177

<a name="l01150"></a>01150 */

1178

<a name="l01151"></a>01151 bool <a class="code" href="a00043.html#a11458ca2e3570838da7b94a1e4563d97" title="returns true if bit n is set and false is bit n is 0.">get_bit</a>(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n) const;

1179

<a name="l01152"></a>01152

1180

<a name="l01153"></a>01153 /*!

1181

<a name="l01154"></a>01154 \brief returns true if bit n is set and false is bit n is 0.

1182

<a name="l01155"></a>01155 \param n - Index of the bit to check.

1183

<a name="l01156"></a>01156 \return Bit value (1 or 0)

1184

<a name="l01157"></a>01157 */

1185

<a name="l01158"></a><a class="code" href="a00043.html#a59ffa64959f92cc259eea2f6d7b597df">01158</a> bool <a class="code" href="a00043.html#a59ffa64959f92cc259eea2f6d7b597df" title="returns true if bit n is set and false is bit n is 0.">test</a>(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n) const

1186

<a name="l01159"></a>01159 {

1187

<a name="l01160"></a>01160 return <a class="code" href="a00043.html#a11458ca2e3570838da7b94a1e4563d97" title="returns true if bit n is set and false is bit n is 0.">get_bit</a>(n);

1188

<a name="l01161"></a>01161 }

1189

<a name="l01162"></a>01162

1190

<a name="l01163"></a>01163 /*!

1191

<a name="l01164"></a>01164 \brief Returns true if any bits in this bitset are set, and otherwise returns false.

1192

<a name="l01165"></a>01165 \return true if any bit is set

1193

<a name="l01166"></a>01166 */

1194

<a name="l01167"></a><a class="code" href="a00043.html#a3d08364f13c365bd831ab4f0a909035e">01167</a> bool <a class="code" href="a00043.html#a3d08364f13c365bd831ab4f0a909035e" title="Returns true if any bits in this bitset are set, and otherwise returns false.">any</a>() const

1195

<a name="l01168"></a>01168 {

1196

<a name="l01169"></a>01169 #ifdef BMCOUNTOPT

1197

<a name="l01170"></a>01170 if (count_is_valid_ && count_) return true;

1198

<a name="l01171"></a>01171 #endif

1199

<a name="l01172"></a>01172

1200

<a name="l01173"></a>01173 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">word_t</a>*** blk_root = blockman_.get_rootblock();

1201

<a name="l01174"></a>01174 if (!blk_root)

1202

<a name="l01175"></a>01175 return false;

1203

<a name="l01176"></a>01176 typename blocks_manager_type::block_any_func func(blockman_);

1204

<a name="l01177"></a>01177 return <a class="code" href="a00110.html#a6f5cb8cbb105eae84d4b0f8a3bc1230f">for_each_nzblock_if</a>(blk_root,

1205

<a name="l01178"></a>01178 blockman_.effective_top_block_size(),

1206

<a name="l01179"></a>01179 <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>,

1207

<a name="l01180"></a>01180 func);

1208

<a name="l01181"></a>01181 }

1209

<a name="l01182"></a>01182

1210

<a name="l01183"></a>01183 /*!

1211

<a name="l01184"></a>01184 \brief Returns true if no bits are set, otherwise returns false.

1212

<a name="l01185"></a>01185 */

1213

<a name="l01186"></a><a class="code" href="a00043.html#a1cb9799d8f1ae36f04527a14e9ff4784">01186</a> bool <a class="code" href="a00043.html#a1cb9799d8f1ae36f04527a14e9ff4784" title="Returns true if no bits are set, otherwise returns false.">none</a>() const

1214

<a name="l01187"></a>01187 {

1215

<a name="l01188"></a>01188 return !<a class="code" href="a00043.html#a3d08364f13c365bd831ab4f0a909035e" title="Returns true if any bits in this bitset are set, and otherwise returns false.">any</a>();

1216

<a name="l01189"></a>01189 }

1217

<a name="l01190"></a>01190

1218

<a name="l01191"></a>01191 /*!

1219

<a name="l01192"></a>01192 \brief Flips bit n

1220

<a name="l01193"></a>01193 \return *this

1221

<a name="l01194"></a>01194 */

1222

<a name="l01195"></a><a class="code" href="a00043.html#acf0fd4c4e19630fd02210f585c44491d">01195</a> <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00043.html#a73faf6a420061373a6c447ed94e18df2" title="Flips all bits.">flip</a>(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n)

1223

<a name="l01196"></a>01196 {

1224

<a name="l01197"></a>01197 set(n, !<a class="code" href="a00043.html#a11458ca2e3570838da7b94a1e4563d97" title="returns true if bit n is set and false is bit n is 0.">get_bit</a>(n));

1225

<a name="l01198"></a>01198 return *this;

1226

<a name="l01199"></a>01199 }

1227

<a name="l01200"></a>01200

1228

<a name="l01201"></a>01201 /*!

1229

<a name="l01202"></a>01202 \brief Flips all bits

1230

<a name="l01203"></a>01203 \return *this

1231

<a name="l01204"></a>01204 */

1232

<a name="l01205"></a><a class="code" href="a00043.html#a73faf6a420061373a6c447ed94e18df2">01205</a> <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00043.html#a73faf6a420061373a6c447ed94e18df2" title="Flips all bits.">flip</a>()

1233

<a name="l01206"></a>01206 {

1234

<a name="l01207"></a>01207 return <a class="code" href="a00043.html#a49af36cc1ea632cd3a2217b53b69dafc" title="Inverts all bits.">invert</a>();

1235

<a name="l01208"></a>01208 }

1236

<a name="l01209"></a>01209

1237

<a name="l01210"></a>01210 /*! \brief Exchanges content of bv and this bitvector.

1238

<a name="l01211"></a>01211 */

1239

<a name="l01212"></a><a class="code" href="a00043.html#ad7a4d5fb8a2418f45a366efd01cd3bcd">01212</a> void <a class="code" href="a00043.html#ad7a4d5fb8a2418f45a366efd01cd3bcd" title="Exchanges content of bv and this bitvector.">swap</a>(<a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& bv)

1240

<a name="l01213"></a>01213 {

1241

<a name="l01214"></a>01214 if (this != &bv)

1242

<a name="l01215"></a>01215 {

1243

<a name="l01216"></a>01216 blockman_.swap(bv.blockman_);

1244

<a name="l01217"></a>01217 <a class="code" href="a00110.html#afb2c1acc56270abb381741a709a2b17c" title="XOR swap two scalar variables.">bm::xor_swap</a>(size_,bv.size_);

1245

<a name="l01218"></a>01218 #ifdef BMCOUNTOPT

1246

<a name="l01219"></a>01219 <a class="code" href="a00084.html#a835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false)

1247

<a name="l01220"></a>01220 bv.<a class="code" href="a00043.html#a91adb243bd37e4e9798ba3e4f87e6e1e">recalc_count</a>();

1248

<a name="l01221"></a>01221 #endif

1249

<a name="l01222"></a>01222 }

1250

<a name="l01223"></a>01223 }

1251

<a name="l01224"></a>01224

1252

<a name="l01225"></a>01225

1253

<a name="l01226"></a>01226 /*!

1254

<a name="l01227"></a>01227 \fn bm::id_t bvector::get_first() const

1255

<a name="l01228"></a>01228 \brief Gets number of first bit which is ON.

1256

<a name="l01229"></a>01229 \return Index of the first 1 bit.

1257

<a name="l01230"></a>01230 \sa get_next, extract_next

1258

<a name="l01231"></a>01231 */

1259

<a name="l01232"></a><a class="code" href="a00043.html#af3129b35cabf0554d85711c085a8616d">01232</a> <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00043.html#af3129b35cabf0554d85711c085a8616d" title="Gets number of first bit which is ON.">get_first</a>() const { return check_or_next(0); }

1260

<a name="l01233"></a>01233

1261

<a name="l01234"></a>01234 /*!

1262

<a name="l01235"></a>01235 \fn bm::id_t bvector::get_next(bm::id_t prev) const

1263

<a name="l01236"></a>01236 \brief Finds the number of the next bit ON.

1264

<a name="l01237"></a>01237 \param prev - Index of the previously found bit.

1265

<a name="l01238"></a>01238 \return Index of the next bit which is ON or 0 if not found.

1266

<a name="l01239"></a>01239 \sa get_first, extract_next

1267

<a name="l01240"></a>01240 */

1268

<a name="l01241"></a><a class="code" href="a00043.html#adef9c095a682a9857068c280e37c8240">01241</a> <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00043.html#adef9c095a682a9857068c280e37c8240" title="Finds the number of the next bit ON.">get_next</a>(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> prev) const

1269

<a name="l01242"></a>01242 {

1270

<a name="l01243"></a>01243 return (++prev == <a class="code" href="a00110.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>) ? 0 : check_or_next(prev);

1271

<a name="l01244"></a>01244 }

1272

<a name="l01245"></a>01245

1273

<a name="l01246"></a>01246 /*!

1274

<a name="l01247"></a>01247 \fn bm::id_t bvector::extract_next(bm::id_t prev)

1275

<a name="l01248"></a>01248 \brief Finds the number of the next bit ON and sets it to 0.

1276

<a name="l01249"></a>01249 \param prev - Index of the previously found bit.

1277

<a name="l01250"></a>01250 \return Index of the next bit which is ON or 0 if not found.

1278

<a name="l01251"></a>01251 \sa get_first, get_next,

1279

<a name="l01252"></a>01252 */

1280

<a name="l01253"></a><a class="code" href="a00043.html#a0919f2a0499568605b380e5d5373948d">01253</a> <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00043.html#a0919f2a0499568605b380e5d5373948d" title="Finds the number of the next bit ON and sets it to 0.">extract_next</a>(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> prev)

1281

<a name="l01254"></a>01254 {

1282

<a name="l01255"></a>01255 return (++prev == <a class="code" href="a00110.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>) ? 0 : check_or_next_extract(prev);

1283

<a name="l01256"></a>01256 }

1284

<a name="l01257"></a>01257

1285

<a name="l01258"></a>01258

1286

<a name="l01259"></a>01259 /*!

1287

<a name="l01260"></a>01260 @brief Calculates bitvector statistics.

1288

<a name="l01261"></a>01261

1289

<a name="l01262"></a>01262 @param st - pointer on statistics structure to be filled in.

1290

<a name="l01263"></a>01263

1291

<a name="l01264"></a>01264 Function fills statistics structure containing information about how

1292

<a name="l01265"></a>01265 this vector uses memory and estimation of max. amount of memory

1293

<a name="l01266"></a>01266 bvector needs to serialize itself.

1294

<a name="l01267"></a>01267

1295

<a name="l01268"></a>01268 @sa statistics

1296

<a name="l01269"></a>01269 */

1297

<a name="l01270"></a>01270 void <a class="code" href="a00043.html#a1eaaac76a97b9eb1d3c11f21cf9385ac" title="Calculates bitvector statistics.">calc_stat</a>(struct <a class="code" href="a00082.html" title="Statistical information about bitset&#39;s memory allocation details.">bm::bvector<Alloc, MS>::statistics</a>* st) const;

1298

<a name="l01271"></a>01271

1299

<a name="l01272"></a>01272 /*!

1300

<a name="l01273"></a>01273 \brief Logical OR operation.

1301

<a name="l01274"></a>01274 \param vect - Argument vector.

1302

<a name="l01275"></a>01275 */

1303

<a name="l01276"></a><a class="code" href="a00043.html#a0eacd87603f41a9aea2126810183f83a">01276</a> <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00043.html#a0eacd87603f41a9aea2126810183f83a" title="Logical OR operation.">bit_or</a>(const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& vect)

1304

<a name="l01277"></a>01277 {

1305

<a name="l01278"></a>01278 <a class="code" href="a00084.html#a835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false);

1306

<a name="l01279"></a>01279 <a class="code" href="a00043.html#af2c137de958a038f96e1149c51ea8a8f">combine_operation</a>(vect, <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a0c8cf0197857d0bd73a63037e2f2c5c5">BM_OR</a>);

1307

<a name="l01280"></a>01280 return *this;

1308

<a name="l01281"></a>01281 }

1309

<a name="l01282"></a>01282

1310

<a name="l01283"></a>01283 /*!

1311

<a name="l01284"></a>01284 \brief Logical AND operation.

1312

<a name="l01285"></a>01285 \param vect - Argument vector.

1313

<a name="l01286"></a>01286 */

1314

<a name="l01287"></a><a class="code" href="a00043.html#a051a39027c3b12751f172c20f2d03a0f">01287</a> <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00043.html#a051a39027c3b12751f172c20f2d03a0f" title="Logical AND operation.">bit_and</a>(const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& vect)

1315

<a name="l01288"></a>01288 {

1316

<a name="l01289"></a>01289 <a class="code" href="a00084.html#a835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false);

1317

<a name="l01290"></a>01290 <a class="code" href="a00043.html#af2c137de958a038f96e1149c51ea8a8f">combine_operation</a>(vect, <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a546fdf33b301e5b9bee0591522ed9250">BM_AND</a>);

1318

<a name="l01291"></a>01291 return *this;

1319

<a name="l01292"></a>01292 }

1320

<a name="l01293"></a>01293

1321

<a name="l01294"></a>01294 /*!

1322

<a name="l01295"></a>01295 \brief Logical XOR operation.

1323

<a name="l01296"></a>01296 \param vect - Argument vector.

1324

<a name="l01297"></a>01297 */

1325

<a name="l01298"></a><a class="code" href="a00043.html#a997a62ec2effcd60246fb9b72f30ccfa">01298</a> <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00043.html#a997a62ec2effcd60246fb9b72f30ccfa" title="Logical XOR operation.">bit_xor</a>(const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& vect)

1326

<a name="l01299"></a>01299 {

1327

<a name="l01300"></a>01300 <a class="code" href="a00084.html#a835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false);

1328

<a name="l01301"></a>01301 <a class="code" href="a00043.html#af2c137de958a038f96e1149c51ea8a8f">combine_operation</a>(vect, <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a45c2fe36efb72dc03f03a842d253f64c">BM_XOR</a>);

1329

<a name="l01302"></a>01302 return *this;

1330

<a name="l01303"></a>01303 }

1331

<a name="l01304"></a>01304

1332

<a name="l01305"></a>01305 /*!

1333

<a name="l01306"></a>01306 \brief Logical SUB operation.

1334

<a name="l01307"></a>01307 \param vect - Argument vector.

1335

<a name="l01308"></a>01308 */

1336

<a name="l01309"></a><a class="code" href="a00043.html#a6a8e699f9c0571f904d7cbaa2e3ed1f1">01309</a> <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00043.html#a6a8e699f9c0571f904d7cbaa2e3ed1f1" title="Logical SUB operation.">bit_sub</a>(const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& vect)

1337

<a name="l01310"></a>01310 {

1338

<a name="l01311"></a>01311 <a class="code" href="a00084.html#a835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false);

1339

<a name="l01312"></a>01312 <a class="code" href="a00043.html#af2c137de958a038f96e1149c51ea8a8f">combine_operation</a>(vect, <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a1df0f4de7126bb2f7ce69d7a005affb5">BM_SUB</a>);

1340

<a name="l01313"></a>01313 return *this;

1341

<a name="l01314"></a>01314 }

1342

<a name="l01315"></a>01315

1343

<a name="l01316"></a>01316

1344

<a name="l01317"></a>01317 /*!

1345

<a name="l01318"></a>01318 \brief Sets new blocks allocation strategy.

1346

<a name="l01319"></a>01319 \param strat - Strategy code 0 - bitblocks allocation only.

1347

<a name="l01320"></a>01320 1 - Blocks mutation mode (adaptive algorithm)

1348

<a name="l01321"></a>01321 */

1349

<a name="l01322"></a><a class="code" href="a00043.html#ab1094180d03cbc961d62f0f453097452">01322</a> void <a class="code" href="a00043.html#ab1094180d03cbc961d62f0f453097452" title="Sets new blocks allocation strategy.">set_new_blocks_strat</a>(<a class="code" href="a00113.html#gad0b87b3b7292383a864d27feaf1c9eff" title="Block allocation strategies.">strategy</a> strat)

1350

<a name="l01323"></a>01323 {

1351

<a name="l01324"></a>01324 new_blocks_strat_ = strat;

1352

<a name="l01325"></a>01325 }

1353

<a name="l01326"></a>01326

1354

<a name="l01327"></a>01327 /*!

1355

<a name="l01328"></a>01328 \brief Returns blocks allocation strategy.

1356

<a name="l01329"></a>01329 \return - Strategy code 0 - bitblocks allocation only.

1357

<a name="l01330"></a>01330 1 - Blocks mutation mode (adaptive algorithm)

1358

<a name="l01331"></a>01331 \sa set_new_blocks_strat

1359

<a name="l01332"></a>01332 */

1360

<a name="l01333"></a><a class="code" href="a00043.html#ad971c541fa259278e9dcf541b2d128c9">01333</a> <a class="code" href="a00113.html#gad0b87b3b7292383a864d27feaf1c9eff" title="Block allocation strategies.">strategy</a> <a class="code" href="a00043.html#ad971c541fa259278e9dcf541b2d128c9" title="Returns blocks allocation strategy.">get_new_blocks_strat</a>() const

1361

<a name="l01334"></a>01334 {

1362

<a name="l01335"></a>01335 return new_blocks_strat_;

1363

<a name="l01336"></a>01336 }

1364

<a name="l01337"></a>01337

1365

<a name="l01338"></a>01338

1366

<a name="l01339"></a>01339 /*!

1367

<a name="l01340"></a>01340 \brief Optimization mode

1368

<a name="l01341"></a>01341 Every next level means additional checks (better compression vs time)

1369

<a name="l01342"></a>01342 \sa optimize

1370

<a name="l01343"></a>01343 */

1371

<a name="l01344"></a><a class="code" href="a00043.html#a05f1e977cb5e6208838afc7e7b69e5f0">01344</a> enum <a class="code" href="a00043.html#a05f1e977cb5e6208838afc7e7b69e5f0" title="Optimization mode Every next level means additional checks (better compression vs...">optmode</a>

1372

<a name="l01345"></a>01345 {

1373

<a name="l01346"></a><a class="code" href="a00043.html#a05f1e977cb5e6208838afc7e7b69e5f0ab9b4d2133014db3d5dbd9c2eda332d19">01346</a> <a class="code" href="a00043.html#a05f1e977cb5e6208838afc7e7b69e5f0ab9b4d2133014db3d5dbd9c2eda332d19" title="Free unused 0 blocks.">opt_free_0</a> = 1, ///< Free unused 0 blocks

1374

<a name="l01347"></a><a class="code" href="a00043.html#a05f1e977cb5e6208838afc7e7b69e5f0a9b54164042434a520ff7e7464e4b43b0">01347</a> <a class="code" href="a00043.html#a05f1e977cb5e6208838afc7e7b69e5f0a9b54164042434a520ff7e7464e4b43b0" title="Free unused 0 and 1 blocks.">opt_free_01</a> = 2, ///< Free unused 0 and 1 blocks

1375

<a name="l01348"></a><a class="code" href="a00043.html#a05f1e977cb5e6208838afc7e7b69e5f0a85f191ba55048d1c436e1e948e9be783">01348</a> <a class="code" href="a00043.html#a05f1e977cb5e6208838afc7e7b69e5f0a85f191ba55048d1c436e1e948e9be783" title="compress blocks when possible">opt_compress</a> = 3 ///< compress blocks when possible

1376

<a name="l01349"></a>01349 };

1377

<a name="l01350"></a>01350

1378

<a name="l01351"></a>01351 /*!

1379

<a name="l01352"></a>01352 \brief Optimize memory bitvector's memory allocation.

1380

<a name="l01353"></a>01353

1381

<a name="l01354"></a>01354 Function analyze all blocks in the bitvector, compresses blocks

1382

<a name="l01355"></a>01355 with a regular structure, frees some memory. This function is recommended

1383

<a name="l01356"></a>01356 after a bulk modification of the bitvector using set_bit, clear_bit or

1384

<a name="l01357"></a>01357 logical operations.

1385

<a name="l01358"></a>01358

1386

<a name="l01359"></a>01359 Optionally function can calculate vector post optimization statistics

1387

<a name="l01360"></a>01360

1388

<a name="l01361"></a>01361 @sa optmode, optimize_gap_size

1389

<a name="l01362"></a>01362 */

1390

<a name="l01363"></a>01363 void <a class="code" href="a00043.html#abd522c13e26c2b8f84636fe8b6648dcb" title="Optimize memory bitvector&#39;s memory allocation.">optimize</a>(<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* temp_block = 0,

1391

<a name="l01364"></a>01364 <a class="code" href="a00043.html#a05f1e977cb5e6208838afc7e7b69e5f0" title="Optimization mode Every next level means additional checks (better compression vs...">optmode</a> opt_mode = <a class="code" href="a00043.html#a05f1e977cb5e6208838afc7e7b69e5f0a85f191ba55048d1c436e1e948e9be783" title="compress blocks when possible">opt_compress</a>,

1392

<a name="l01365"></a>01365 statistics* stat = 0);

1393

<a name="l01366"></a>01366

1394

<a name="l01367"></a>01367 /*!

1395

<a name="l01368"></a>01368 \brief Optimize sizes of GAP blocks

1396

<a name="l01369"></a>01369

1397

<a name="l01370"></a>01370 This method runs an analysis to find optimal GAP levels for the

1398

<a name="l01371"></a>01371 specific vector. Current GAP compression algorithm uses several fixed

1399

<a name="l01372"></a>01372 GAP sizes. By default bvector uses some reasonable preset.

1400

<a name="l01373"></a>01373 */

1401

<a name="l01374"></a>01374 void <a class="code" href="a00043.html#a3942e3f6ea9fa54fcdb78a35a85008e5" title="Optimize sizes of GAP blocks.">optimize_gap_size</a>();

1402

<a name="l01375"></a>01375

1403

<a name="l01376"></a>01376

1404

<a name="l01377"></a>01377 /*!

1405

<a name="l01378"></a>01378 @brief Sets new GAP lengths table. All GAP blocks will be reallocated

1406

<a name="l01379"></a>01379 to match the new scheme.

1407

<a name="l01380"></a>01380

1408

<a name="l01381"></a>01381 @param glevel_len - pointer on C-style array keeping GAP block sizes.

1409

<a name="l01382"></a>01382 */

1410

<a name="l01383"></a>01383 void <a class="code" href="a00043.html#a40d82dec62efe90b0810ccd06b62163e" title="Sets new GAP lengths table. All GAP blocks will be reallocated to match the new scheme...">set_gap_levels</a>(const <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* glevel_len);

1411

<a name="l01384"></a>01384

1412

<a name="l01385"></a>01385 /*!

1413

<a name="l01386"></a>01386 \brief Lexicographical comparison with a bitvector.

1414

<a name="l01387"></a>01387

1415

<a name="l01388"></a>01388 Function compares current bitvector with the provided argument

1416

<a name="l01389"></a>01389 bit by bit and returns -1 if our bitvector less than the argument,

1417

<a name="l01390"></a>01390 1 - greater, 0 - equal.

1418

<a name="l01391"></a>01391 */

1419

<a name="l01392"></a>01392 int <a class="code" href="a00043.html#aa2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">compare</a>(const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvect</a>) const;

1420

<a name="l01393"></a>01393

1421

<a name="l01394"></a>01394 /*! @brief Allocates temporary block of memory.

1422

<a name="l01395"></a>01395

1423

<a name="l01396"></a>01396 Temp block can be passed to bvector functions requiring some temp memory

1424

<a name="l01397"></a>01397 for their operation. (like serialize)

1425

<a name="l01398"></a>01398

1426

<a name="l01399"></a>01399 @note method is marked const, but it's not quite true, since

1427

<a name="l01400"></a>01400 it can in some cases modify the state of the block allocator

1428

<a name="l01401"></a>01401 (if it has a state). (Can be important in MT programs).

1429

<a name="l01402"></a>01402

1430

<a name="l01403"></a>01403 @sa free_tempblock

1431

<a name="l01404"></a>01404 */

1432

<a name="l01405"></a><a class="code" href="a00043.html#ab7d74cc7b7d6c6e77dd3634ecbb35e4f">01405</a> <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* <a class="code" href="a00043.html#ab7d74cc7b7d6c6e77dd3634ecbb35e4f" title="Allocates temporary block of memory.">allocate_tempblock</a>() const

1433

<a name="l01406"></a>01406 {

1434

<a name="l01407"></a>01407 <a class="code" href="a00043.html#a1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>* bm =

1435

<a name="l01408"></a>01408 const_cast<<a class="code" href="a00043.html#a1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>*>(&blockman_);

1436

<a name="l01409"></a>01409 return bm->get_allocator().alloc_bit_block();

1437

<a name="l01410"></a>01410 }

1438

<a name="l01411"></a>01411

1439

<a name="l01412"></a>01412 /*! @brief Frees temporary block of memory.

1440

<a name="l01413"></a>01413

1441

<a name="l01414"></a>01414 @note method is marked const, but it's not quite true, since

1442

<a name="l01415"></a>01415 it can in some cases modify the state of the block allocator

1443

<a name="l01416"></a>01416 (if it has a state). (Can be important in MT programs).

1444

<a name="l01417"></a>01417

1445

<a name="l01418"></a>01418 @sa allocate_tempblock

1446

<a name="l01419"></a>01419 */

1447

<a name="l01420"></a><a class="code" href="a00043.html#a311bbf4841d2a25a2e7f59f6861f1592">01420</a> void <a class="code" href="a00043.html#a311bbf4841d2a25a2e7f59f6861f1592" title="Frees temporary block of memory.">free_tempblock</a>(<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* block) const

1448

<a name="l01421"></a>01421 {

1449

<a name="l01422"></a>01422 <a class="code" href="a00043.html#a1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>* bm =

1450

<a name="l01423"></a>01423 const_cast<<a class="code" href="a00043.html#a1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>*>(&blockman_);

1451

<a name="l01424"></a>01424 bm->get_allocator().free_bit_block(block);

1452

<a name="l01425"></a>01425 }

1453

<a name="l01426"></a>01426

1454

<a name="l01427"></a>01427 /**

1455

<a name="l01428"></a>01428 \brief Returns enumerator pointing on the first non-zero bit.

1456

<a name="l01429"></a>01429 */

1457

<a name="l01430"></a><a class="code" href="a00043.html#aad48c661f843e32c9893438a6f27a8f0">01430</a> <a class="code" href="a00062.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a> <a class="code" href="a00043.html#aad48c661f843e32c9893438a6f27a8f0" title="Returns enumerator pointing on the first non-zero bit.">first</a>() const

1458

<a name="l01431"></a>01431 {

1459

<a name="l01432"></a>01432 typedef typename <a class="code" href="a00062.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">bvector<Alloc, MS>::enumerator</a> enumerator_type;

1460

<a name="l01433"></a>01433 return enumerator_type(this, 0);

1461

<a name="l01434"></a>01434 }

1462

<a name="l01435"></a>01435

1463

<a name="l01436"></a>01436 /**

1464

<a name="l01437"></a>01437 \fn bvector::enumerator bvector::end() const

1465

<a name="l01438"></a>01438 \brief Returns enumerator pointing on the next bit after the last.

1466

<a name="l01439"></a>01439 */

1467

<a name="l01440"></a><a class="code" href="a00043.html#a2c6e522f858fdc466765d2c0f269f590">01440</a> <a class="code" href="a00062.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">enumerator</a> <a class="code" href="a00043.html#a2c6e522f858fdc466765d2c0f269f590" title="Returns enumerator pointing on the next bit after the last.">end</a>() const

1468

<a name="l01441"></a>01441 {

1469

<a name="l01442"></a>01442 typedef typename <a class="code" href="a00062.html" title="Constant input iterator designed to enumerate &quot;ON&quot; bits.">bvector<Alloc, MS>::enumerator</a> enumerator_type;

1470

<a name="l01443"></a>01443 return enumerator_type(this, 1);

1471

<a name="l01444"></a>01444 }

1472

<a name="l01445"></a>01445

1473

<a name="l01446"></a>01446

1474

<a name="l01447"></a><a class="code" href="a00043.html#a68bb64dca7f60aa1828ddd4be63418dc">01447</a> const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* <a class="code" href="a00043.html#a68bb64dca7f60aa1828ddd4be63418dc">get_block</a>(unsigned nb) const

1475

<a name="l01448"></a>01448 {

1476

<a name="l01449"></a>01449 return blockman_.get_block(nb);

1477

<a name="l01450"></a>01450 }

1478

<a name="l01451"></a>01451

1479

<a name="l01452"></a>01452 void <a class="code" href="a00043.html#af2c137de958a038f96e1149c51ea8a8f">combine_operation</a>(const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvect</a>,

1480

<a name="l01453"></a>01453 <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1" title="Bit operations enumeration.">bm::operation</a> opcode);

1481

<a name="l01454"></a>01454

1482

<a name="l01455"></a>01455 private:

1483

<a name="l01456"></a>01456

1484

<a name="l01457"></a>01457 <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> check_or_next(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> prev) const;

1485

<a name="l01458"></a>01458

1486

<a name="l01459"></a>01459 /// check if specified bit is 1, and set it to 0

1487

<a name="l01460"></a>01460 /// if specified bit is 0, scan for the next 1 and returns it

1488

<a name="l01461"></a>01461 /// if no 1 found returns 0

1489

<a name="l01462"></a>01462 <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> check_or_next_extract(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> prev);

1490

<a name="l01463"></a>01463

1491

<a name="l01464"></a>01464 /**

1492

<a name="l01465"></a>01465 \brief Set specified bit without checking preconditions (size, etc)

1493

<a name="l01466"></a>01466 */

1494

<a name="l01467"></a>01467 bool set_bit_no_check(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val);

1495

<a name="l01468"></a>01468

1496

<a name="l01469"></a>01469 /**

1497

<a name="l01470"></a>01470 \brief AND specified bit without checking preconditions (size, etc)

1498

<a name="l01471"></a>01471 */

1499

<a name="l01472"></a>01472 bool and_bit_no_check(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val);

1500

<a name="l01473"></a>01473

1501

<a name="l01474"></a>01474 bool set_bit_conditional_impl(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val, bool condition);

1502

<a name="l01475"></a>01475

1503

<a name="l01476"></a>01476

1504

<a name="l01477"></a>01477 void combine_operation_with_block(unsigned nb,

1505

<a name="l01478"></a>01478 unsigned gap,

1506

<a name="l01479"></a>01479 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk,

1507

<a name="l01480"></a>01480 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* arg_blk,

1508

<a name="l01481"></a>01481 int arg_gap,

1509

<a name="l01482"></a>01482 <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1" title="Bit operations enumeration.">bm::operation</a> opcode);

1510

<a name="l01483"></a>01483 public:

1511

<a name="l01484"></a><a class="code" href="a00043.html#a894bfd0e43484e819694c6560cd4207c">01484</a> void combine_operation_with_block(unsigned nb,

1512

<a name="l01485"></a>01485 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* arg_blk,

1513

<a name="l01486"></a>01486 int arg_gap,

1514

<a name="l01487"></a>01487 <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1" title="Bit operations enumeration.">bm::operation</a> opcode)

1515

<a name="l01488"></a>01488 {

1516

<a name="l01489"></a>01489 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk = const_cast<<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*>(<a class="code" href="a00043.html#a68bb64dca7f60aa1828ddd4be63418dc">get_block</a>(nb));

1517

<a name="l01490"></a>01490 bool gap = <a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>((*this), blk, nb);

1518

<a name="l01491"></a>01491 combine_operation_with_block(nb, gap, blk, arg_blk, arg_gap, opcode);

1519

<a name="l01492"></a>01492 }

1520

<a name="l01493"></a>01493 private:

1521

<a name="l01494"></a>01494 void <a class="code" href="a00110.html#abecd5b24d5e394fd46a9db514cfa659a" title="Internal function computes different distance metrics.">combine_count_operation_with_block</a>(unsigned nb,

1522

<a name="l01495"></a>01495 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* arg_blk,

1523

<a name="l01496"></a>01496 int arg_gap,

1524

<a name="l01497"></a>01497 <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1" title="Bit operations enumeration.">bm::operation</a> opcode)

1525

<a name="l01498"></a>01498 {

1526

<a name="l01499"></a>01499 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk = <a class="code" href="a00043.html#a68bb64dca7f60aa1828ddd4be63418dc">get_block</a>(nb);

1527

<a name="l01500"></a>01500 bool gap = <a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>((*this), blk, nb);

1528

<a name="l01501"></a>01501 <a class="code" href="a00110.html#abecd5b24d5e394fd46a9db514cfa659a" title="Internal function computes different distance metrics.">combine_count_operation_with_block</a>(nb, gap, blk, arg_blk, arg_gap, opcode);

1529

<a name="l01502"></a>01502 }

1530

<a name="l01503"></a>01503

1531

<a name="l01504"></a>01504

1532

<a name="l01505"></a>01505 /**

1533

<a name="l01506"></a>01506 \brief Extends GAP block to the next level or converts it to bit block.

1534

<a name="l01507"></a>01507 \param nb - Block's linear index.

1535

<a name="l01508"></a>01508 \param blk - Blocks's pointer

1536

<a name="l01509"></a>01509 */

1537

<a name="l01510"></a>01510 void extend_gap_block(unsigned nb, <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* blk)

1538

<a name="l01511"></a>01511 {

1539

<a name="l01512"></a>01512 blockman_.extend_gap_block(nb, blk);

1540

<a name="l01513"></a>01513 }

1541

<a name="l01514"></a>01514

1542

<a name="l01515"></a>01515 /**

1543

<a name="l01516"></a>01516 \brief Set range without validity checking

1544

<a name="l01517"></a>01517 */

1545

<a name="l01518"></a>01518 void set_range_no_check(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> left,

1546

<a name="l01519"></a>01519 <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> right,

1547

<a name="l01520"></a>01520 bool value);

1548

<a name="l01521"></a>01521 public:

1549

<a name="l01522"></a>01522

1550

<a name="l01523"></a><a class="code" href="a00043.html#a9599df0386dfc7e6bad95fde7e4b3ee8">01523</a> const <a class="code" href="a00043.html#a1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>& <a class="code" href="a00043.html#a9599df0386dfc7e6bad95fde7e4b3ee8">get_blocks_manager</a>() const

1551

<a name="l01524"></a>01524 {

1552

<a name="l01525"></a>01525 return blockman_;

1553

<a name="l01526"></a>01526 }

1554

<a name="l01527"></a>01527

1555

<a name="l01528"></a><a class="code" href="a00043.html#aa531c7278812888bca2d1617bb19e0b0">01528</a> <a class="code" href="a00043.html#a1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a>& <a class="code" href="a00043.html#a9599df0386dfc7e6bad95fde7e4b3ee8">get_blocks_manager</a>()

1556

<a name="l01529"></a>01529 {

1557

<a name="l01530"></a>01530 return blockman_;

1558

<a name="l01531"></a>01531 }

1559

<a name="l01532"></a>01532

1560

<a name="l01533"></a>01533

1561

<a name="l01534"></a>01534 private:

1562

<a name="l01535"></a>01535

1563

<a name="l01536"></a>01536 // This block defines two additional hidden variables used for bitcount

1564

<a name="l01537"></a>01537 // optimization, in rare cases can make bitvector thread unsafe.

1565

<a name="l01538"></a>01538 #ifdef BMCOUNTOPT

1566

<a name="l01539"></a>01539 mutable <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">id_t</a> count_; //!< number of 1 bits in the vector

1567

<a name="l01540"></a>01540 mutable bool count_is_valid_; //!< actualization flag

1568

<a name="l01541"></a>01541 #endif

1569

<a name="l01542"></a>01542

1570

<a name="l01543"></a>01543 <a class="code" href="a00043.html#a1c89beac7542674fdc09cbcf024ab390">blocks_manager_type</a> blockman_; //!< bitblocks manager

1571

<a name="l01544"></a>01544 <a class="code" href="a00113.html#gad0b87b3b7292383a864d27feaf1c9eff" title="Block allocation strategies.">strategy</a> new_blocks_strat_; //!< block allocation strategy

1572

<a name="l01545"></a>01545 <a class="code" href="a00043.html#aba038b54cc8d548bb1c058dee0325884" title="Type used to count bits in the bit vector.">size_type</a> size_; //!< size in bits

1573

<a name="l01546"></a>01546 };

1574

<a name="l01547"></a>01547

1575

<a name="l01548"></a>01548

1576

<a name="l01549"></a>01549

1577

<a name="l01550"></a>01550

1578

<a name="l01551"></a>01551

1579

<a name="l01552"></a>01552 //---------------------------------------------------------------------

1580

<a name="l01553"></a>01553

1581

<a name="l01554"></a>01554 template<class Alloc, class MS>

1582

<a name="l01555"></a><a class="code" href="a00110.html#ac766cc15ae8feca9e21a36c49bf3b557">01555</a> inline <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> <a class="code" href="a00110.html#ac766cc15ae8feca9e21a36c49bf3b557">operator& </a>(const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& v1,

1583

<a name="l01556"></a>01556 const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& v2)

1584

<a name="l01557"></a>01557 {

1585

<a name="l01558"></a>01558 #ifdef BM_USE_EXPLICIT_TEMP

1586

<a name="l01559"></a>01559 <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> ret(v1);

1587

<a name="l01560"></a>01560 ret.<a class="code" href="a00043.html#a051a39027c3b12751f172c20f2d03a0f" title="Logical AND operation.">bit_and</a>(v2);

1588

<a name="l01561"></a>01561 return ret;

1589

<a name="l01562"></a>01562 #else

1590

<a name="l01563"></a>01563 return <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>(v1).bit_and(v2);

1591

<a name="l01564"></a>01564 #endif

1592

<a name="l01565"></a>01565 }

1593

<a name="l01566"></a>01566

1594

<a name="l01567"></a>01567 //---------------------------------------------------------------------

1595

<a name="l01568"></a>01568

1596

<a name="l01569"></a>01569 template<class Alloc, class MS>

1597

<a name="l01570"></a><a class="code" href="a00110.html#a5cc9411c5170df52c1c4ea436ef32745">01570</a> inline <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> <a class="code" href="a00110.html#a5cc9411c5170df52c1c4ea436ef32745">operator| </a>(const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& v1,

1598

<a name="l01571"></a>01571 const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc></a>& v2)

1599

<a name="l01572"></a>01572 {

1600

<a name="l01573"></a>01573 #ifdef BM_USE_EXPLICIT_TEMP

1601

<a name="l01574"></a>01574 <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> ret(v1);

1602

<a name="l01575"></a>01575 ret.<a class="code" href="a00043.html#a0eacd87603f41a9aea2126810183f83a" title="Logical OR operation.">bit_or</a>(v2);

1603

<a name="l01576"></a>01576 return ret;

1604

<a name="l01577"></a>01577 #else

1605

<a name="l01578"></a>01578 return <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>(v1).bit_or(v2);

1606

<a name="l01579"></a>01579 #endif

1607

<a name="l01580"></a>01580 }

1608

<a name="l01581"></a>01581

1609

<a name="l01582"></a>01582 //---------------------------------------------------------------------

1610

<a name="l01583"></a>01583

1611

<a name="l01584"></a>01584 template<class Alloc, class MS>

1612

<a name="l01585"></a><a class="code" href="a00110.html#a7042429992aec5891a3df1b0bddea05f">01585</a> inline <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> <a class="code" href="a00110.html#a7042429992aec5891a3df1b0bddea05f">operator^ </a>(const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& v1,

1613

<a name="l01586"></a>01586 const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& v2)

1614

<a name="l01587"></a>01587 {

1615

<a name="l01588"></a>01588 #ifdef BM_USE_EXPLICIT_TEMP

1616

<a name="l01589"></a>01589 <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> ret(v1);

1617

<a name="l01590"></a>01590 ret.<a class="code" href="a00043.html#a997a62ec2effcd60246fb9b72f30ccfa" title="Logical XOR operation.">bit_xor</a>(v2);

1618

<a name="l01591"></a>01591 return ret;

1619

<a name="l01592"></a>01592 #else

1620

<a name="l01593"></a>01593 return <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>(v1).bit_xor(v2);

1621

<a name="l01594"></a>01594 #endif

1622

<a name="l01595"></a>01595 }

1623

<a name="l01596"></a>01596

1624

<a name="l01597"></a>01597 //---------------------------------------------------------------------

1625

<a name="l01598"></a>01598

1626

<a name="l01599"></a>01599 template<class Alloc, class MS>

1627

<a name="l01600"></a><a class="code" href="a00110.html#afe23d0ced66b48b9c4214e0b00dcc5ac">01600</a> inline <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> <a class="code" href="a00110.html#afe23d0ced66b48b9c4214e0b00dcc5ac">operator- </a>(const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& v1,

1628

<a name="l01601"></a>01601 const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& v2)

1629

<a name="l01602"></a>01602 {

1630

<a name="l01603"></a>01603 #ifdef BM_USE_EXPLICIT_TEMP

1631

<a name="l01604"></a>01604 <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a> ret(v1);

1632

<a name="l01605"></a>01605 ret.<a class="code" href="a00043.html#a6a8e699f9c0571f904d7cbaa2e3ed1f1" title="Logical SUB operation.">bit_sub</a>(v2);

1633

<a name="l01606"></a>01606 return ret;

1634

<a name="l01607"></a>01607 #else

1635

<a name="l01608"></a>01608 return <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>(v1).bit_sub(v2);

1636

<a name="l01609"></a>01609 #endif

1637

<a name="l01610"></a>01610 }

1638

<a name="l01611"></a>01611

1639

<a name="l01612"></a>01612

1640

<a name="l01613"></a>01613

1641

<a name="l01614"></a>01614

1642

<a name="l01615"></a>01615 // -----------------------------------------------------------------------

1643

<a name="l01616"></a>01616

1644

<a name="l01617"></a>01617 template<typename Alloc, typename MS>

1645

<a name="l01618"></a><a class="code" href="a00043.html#a14bc35b9b022018f10787b07a5b2af04">01618</a> <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00043.html#a14bc35b9b022018f10787b07a5b2af04" title="Sets all bits in the specified closed interval [left,right] Interval must be inside...">bvector<Alloc, MS>::set_range</a>(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> left,

1646

<a name="l01619"></a>01619 <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> right,

1647

<a name="l01620"></a>01620 bool value)

1648

<a name="l01621"></a>01621 {

1649

<a name="l01622"></a>01622 if (right < left)

1650

<a name="l01623"></a>01623 {

1651

<a name="l01624"></a>01624 return <a class="code" href="a00043.html#a14bc35b9b022018f10787b07a5b2af04" title="Sets all bits in the specified closed interval [left,right] Interval must be inside...">set_range</a>(right, left, value);

1652

<a name="l01625"></a>01625 }

1653

<a name="l01626"></a>01626

1654

<a name="l01627"></a>01627 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(left < size_);

1655

<a name="l01628"></a>01628 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(right < size_);

1656

<a name="l01629"></a>01629

1657

<a name="l01630"></a>01630 <a class="code" href="a00084.html#a835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false)

1658

<a name="l01631"></a>01631 <a class="code" href="a00089.html#a7e6f87ba3230dece2125af5c32e84b05">BM_SET_MMX_GUARD</a>

1659

<a name="l01632"></a>01632

1660

<a name="l01633"></a>01633 set_range_no_check(left, right, value);

1661

<a name="l01634"></a>01634

1662

<a name="l01635"></a>01635 return *this;

1663

<a name="l01636"></a>01636 }

1664

<a name="l01637"></a>01637

1665

<a name="l01638"></a>01638 // -----------------------------------------------------------------------

1666

<a name="l01639"></a>01639

1667

<a name="l01640"></a>01640 template<typename Alloc, typename MS>

1668

<a name="l01641"></a><a class="code" href="a00043.html#a71077c1315555301532e24d4d2b95ea2">01641</a> <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00043.html#a71077c1315555301532e24d4d2b95ea2" title="Returns count of bits which are 1.">bvector<Alloc, MS>::count</a>() const

1669

<a name="l01642"></a>01642 {

1670

<a name="l01643"></a>01643 #ifdef BMCOUNTOPT

1671

<a name="l01644"></a>01644 if (count_is_valid_) return count_;

1672

<a name="l01645"></a>01645 #endif

1673

<a name="l01646"></a>01646 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">word_t</a>*** blk_root = blockman_.get_rootblock();

1674

<a name="l01647"></a>01647 if (!blk_root)

1675

<a name="l01648"></a>01648 {

1676

<a name="l01649"></a>01649 <a class="code" href="a00084.html#a1fbebc7fe3c22d768ff6e240437ee8f4">BMCOUNT_SET</a>(0);

1677

<a name="l01650"></a>01650 return 0;

1678

<a name="l01651"></a>01651 }

1679

<a name="l01652"></a>01652 typename blocks_manager_type::block_count_func func(blockman_);

1680

<a name="l01653"></a>01653 <a class="code" href="a00110.html#ae8b342c25dc22d6cd26cb96d7ae796db">for_each_nzblock</a>(blk_root, blockman_.effective_top_block_size(),

1681

<a name="l01654"></a>01654 <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>, func);

1682

<a name="l01655"></a>01655

1683

<a name="l01656"></a>01656 <a class="code" href="a00084.html#a1fbebc7fe3c22d768ff6e240437ee8f4">BMCOUNT_SET</a>(func.count());

1684

<a name="l01657"></a>01657 return func.count();

1685

<a name="l01658"></a>01658 }

1686

<a name="l01659"></a>01659

1687

<a name="l01660"></a>01660 // -----------------------------------------------------------------------

1688

<a name="l01661"></a>01661

1689

<a name="l01662"></a>01662 template<typename Alloc, typename MS>

1690

<a name="l01663"></a><a class="code" href="a00043.html#a7be4f9e0741f43869f4dcd9607736c0e">01663</a> void <a class="code" href="a00043.html#a7be4f9e0741f43869f4dcd9607736c0e" title="Change size of the bvector.">bvector<Alloc, MS>::resize</a>(size_type new_size)

1691

<a name="l01664"></a>01664 {

1692

<a name="l01665"></a>01665 if (size_ == new_size) return; // nothing to do

1693

<a name="l01666"></a>01666 if (size_ < new_size) // size grows

1694

<a name="l01667"></a>01667 {

1695

<a name="l01668"></a>01668 blockman_.reserve(new_size);

1696

<a name="l01669"></a>01669 size_ = new_size;

1697

<a name="l01670"></a>01670 }

1698

<a name="l01671"></a>01671 else // shrink

1699

<a name="l01672"></a>01672 {

1700

<a name="l01673"></a>01673 <a class="code" href="a00043.html#a14bc35b9b022018f10787b07a5b2af04" title="Sets all bits in the specified closed interval [left,right] Interval must be inside...">set_range</a>(new_size, size_ - 1, false); // clear the tail

1701

<a name="l01674"></a>01674 size_ = new_size;

1702

<a name="l01675"></a>01675 }

1703

<a name="l01676"></a>01676 }

1704

<a name="l01677"></a>01677

1705

<a name="l01678"></a>01678 // -----------------------------------------------------------------------

1706

<a name="l01679"></a>01679

1707

<a name="l01680"></a>01680 template<typename Alloc, typename MS>

1708

<a name="l01681"></a><a class="code" href="a00043.html#adbe1a2423ce166b88a0b57e435af2733">01681</a> <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00043.html#adbe1a2423ce166b88a0b57e435af2733" title="Returns count of 1 bits in the given diapason.">bvector<Alloc, MS>::count_range</a>(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> left,

1709

<a name="l01682"></a>01682 <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> right,

1710

<a name="l01683"></a>01683 unsigned* block_count_arr) const

1711

<a name="l01684"></a>01684 {

1712

<a name="l01685"></a>01685 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(left <= right);

1713

<a name="l01686"></a>01686

1714

<a name="l01687"></a>01687 unsigned <a class="code" href="a00043.html#a71077c1315555301532e24d4d2b95ea2" title="Returns count of bits which are 1.">count</a> = 0;

1715

<a name="l01688"></a>01688

1716

<a name="l01689"></a>01689 // calculate logical number of start and destination blocks

1717

<a name="l01690"></a>01690 unsigned nblock_left = unsigned(left >> <a class="code" href="a00110.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

1718

<a name="l01691"></a>01691 unsigned nblock_right = unsigned(right >> <a class="code" href="a00110.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

1719

<a name="l01692"></a>01692

1720

<a name="l01693"></a>01693 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* block = blockman_.get_block(nblock_left);

1721

<a name="l01694"></a>01694 bool left_gap = <a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nblock_left);

1722

<a name="l01695"></a>01695

1723

<a name="l01696"></a>01696 unsigned nbit_left = unsigned(left & <a class="code" href="a00110.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

1724

<a name="l01697"></a>01697 unsigned nbit_right = unsigned(right & bm::set_block_mask);

1725

<a name="l01698"></a>01698

1726

<a name="l01699"></a>01699 unsigned r =

1727

<a name="l01700"></a>01700 (nblock_left == nblock_right) ? nbit_right : (<a class="code" href="a00110.html#ae9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a>-1);

1728

<a name="l01701"></a>01701

1729

<a name="l01702"></a>01702 typename blocks_manager_type::block_count_func func(blockman_);

1730

<a name="l01703"></a>01703

1731

<a name="l01704"></a>01704 if (block)

1732

<a name="l01705"></a>01705 {

1733

<a name="l01706"></a>01706 if ((nbit_left == 0) && (r == (<a class="code" href="a00110.html#ae9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a>-1))) // whole block

1734

<a name="l01707"></a>01707 {

1735

<a name="l01708"></a>01708 if (block_count_arr)

1736

<a name="l01709"></a>01709 {

1737

<a name="l01710"></a>01710 count += block_count_arr[nblock_left];

1738

<a name="l01711"></a>01711 }

1739

<a name="l01712"></a>01712 else

1740

<a name="l01713"></a>01713 {

1741

<a name="l01714"></a>01714 func(block, nblock_left);

1742

<a name="l01715"></a>01715 }

1743

<a name="l01716"></a>01716 }

1744

<a name="l01717"></a>01717 else

1745

<a name="l01718"></a>01718 {

1746

<a name="l01719"></a>01719 if (left_gap)

1747

<a name="l01720"></a>01720 {

1748

<a name="l01721"></a>01721 count += <a class="code" href="a00110.html#a7324ebded429e15361f62117a2ff18d1" title="Counts 1 bits in GAP buffer in the closed [left, right] diapason.">gap_bit_count_range</a>(<a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block),

1749

<a name="l01722"></a>01722 (<a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>)nbit_left,

1750

<a name="l01723"></a>01723 (<a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>)r);

1751

<a name="l01724"></a>01724 }

1752

<a name="l01725"></a>01725 else

1753

<a name="l01726"></a>01726 {

1754

<a name="l01727"></a>01727 count += <a class="code" href="a00115.html#ga2485f707b2629c5ce7681cf9fe385b91">bit_block_calc_count_range</a>(block, nbit_left, r);

1755

<a name="l01728"></a>01728 }

1756

<a name="l01729"></a>01729 }

1757

<a name="l01730"></a>01730 }

1758

<a name="l01731"></a>01731

1759

<a name="l01732"></a>01732 if (nblock_left == nblock_right) // in one block

1760

<a name="l01733"></a>01733 {

1761

<a name="l01734"></a>01734 return count + func.count();

1762

<a name="l01735"></a>01735 }

1763

<a name="l01736"></a>01736

1764

<a name="l01737"></a>01737 for (unsigned nb = nblock_left+1; nb < nblock_right; ++nb)

1765

<a name="l01738"></a>01738 {

1766

<a name="l01739"></a>01739 block = blockman_.get_block(nb);

1767

<a name="l01740"></a>01740 if (block_count_arr)

1768

<a name="l01741"></a>01741 {

1769

<a name="l01742"></a>01742 count += block_count_arr[nb];

1770

<a name="l01743"></a>01743 }

1771

<a name="l01744"></a>01744 else

1772

<a name="l01745"></a>01745 {

1773

<a name="l01746"></a>01746 if (block)

1774

<a name="l01747"></a>01747 func(block, nb);

1775

<a name="l01748"></a>01748 }

1776

<a name="l01749"></a>01749 }

1777

<a name="l01750"></a>01750 count += func.count();

1778

<a name="l01751"></a>01751

1779

<a name="l01752"></a>01752 block = blockman_.get_block(nblock_right);

1780

<a name="l01753"></a>01753 bool right_gap = <a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nblock_right);

1781

<a name="l01754"></a>01754

1782

<a name="l01755"></a>01755 if (block)

1783

<a name="l01756"></a>01756 {

1784

<a name="l01757"></a>01757 if (right_gap)

1785

<a name="l01758"></a>01758 {

1786

<a name="l01759"></a>01759 count += <a class="code" href="a00110.html#a7324ebded429e15361f62117a2ff18d1" title="Counts 1 bits in GAP buffer in the closed [left, right] diapason.">gap_bit_count_range</a>(<a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block),

1787

<a name="l01760"></a>01760 (<a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>)0,

1788

<a name="l01761"></a>01761 (<a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>)nbit_right);

1789

<a name="l01762"></a>01762 }

1790

<a name="l01763"></a>01763 else

1791

<a name="l01764"></a>01764 {

1792

<a name="l01765"></a>01765 count += <a class="code" href="a00115.html#ga2485f707b2629c5ce7681cf9fe385b91">bit_block_calc_count_range</a>(block, 0, nbit_right);

1793

<a name="l01766"></a>01766 }

1794

<a name="l01767"></a>01767 }

1795

<a name="l01768"></a>01768

1796

<a name="l01769"></a>01769 return count;

1797

<a name="l01770"></a>01770 }

1798

<a name="l01771"></a>01771

1799

<a name="l01772"></a>01772 // -----------------------------------------------------------------------

1800

<a name="l01773"></a>01773

1801

<a name="l01774"></a>01774 template<typename Alloc, typename MS>

1802

<a name="l01775"></a><a class="code" href="a00043.html#a49af36cc1ea632cd3a2217b53b69dafc">01775</a> <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00043.html#a49af36cc1ea632cd3a2217b53b69dafc" title="Inverts all bits.">bvector<Alloc, MS>::invert</a>()

1803

<a name="l01776"></a>01776 {

1804

<a name="l01777"></a>01777 <a class="code" href="a00084.html#a835c3ed1c5956735e59744cff81244dc">BMCOUNT_VALID</a>(false)

1805

<a name="l01778"></a>01778 <a class="code" href="a00089.html#a7e6f87ba3230dece2125af5c32e84b05">BM_SET_MMX_GUARD</a>

1806

<a name="l01779"></a>01779

1807

<a name="l01780"></a>01780 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*** blk_root = blockman_.get_rootblock();

1808

<a name="l01781"></a>01781 typename blocks_manager_type::block_invert_func func(blockman_);

1809

<a name="l01782"></a>01782 <a class="code" href="a00110.html#a86742a3e17527be5a9743f26b36a7691">for_each_block</a>(blk_root, blockman_.top_block_size(),

1810

<a name="l01783"></a>01783 <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>, func);

1811

<a name="l01784"></a>01784 if (size_ == <a class="code" href="a00110.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>)

1812

<a name="l01785"></a>01785 {

1813

<a name="l01786"></a>01786 set_bit_no_check(<a class="code" href="a00110.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>, false);

1814

<a name="l01787"></a>01787 }

1815

<a name="l01788"></a>01788 else

1816

<a name="l01789"></a>01789 {

1817

<a name="l01790"></a>01790 set_range_no_check(size_, <a class="code" href="a00110.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>, false);

1818

<a name="l01791"></a>01791 }

1819

<a name="l01792"></a>01792

1820

<a name="l01793"></a>01793 return *this;

1821

<a name="l01794"></a>01794 }

1822

<a name="l01795"></a>01795

1823

<a name="l01796"></a>01796 // -----------------------------------------------------------------------

1824

<a name="l01797"></a>01797

1825

<a name="l01798"></a>01798 template<typename Alloc, typename MS>

1826

<a name="l01799"></a><a class="code" href="a00043.html#a11458ca2e3570838da7b94a1e4563d97">01799</a> bool <a class="code" href="a00043.html#a11458ca2e3570838da7b94a1e4563d97" title="returns true if bit n is set and false is bit n is 0.">bvector<Alloc, MS>::get_bit</a>(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n) const

1827

<a name="l01800"></a>01800 {

1828

<a name="l01801"></a>01801 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(n < size_);

1829

<a name="l01802"></a>01802

1830

<a name="l01803"></a>01803 // calculate logical block number

1831

<a name="l01804"></a>01804 unsigned nblock = unsigned(n >> <a class="code" href="a00110.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

1832

<a name="l01805"></a>01805

1833

<a name="l01806"></a>01806 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* block = blockman_.get_block(nblock);

1834

<a name="l01807"></a>01807

1835

<a name="l01808"></a>01808 if (block)

1836

<a name="l01809"></a>01809 {

1837

<a name="l01810"></a>01810 // calculate word number in block and bit

1838

<a name="l01811"></a>01811 unsigned nbit = unsigned(n & <a class="code" href="a00110.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

1839

<a name="l01812"></a>01812 unsigned is_set;

1840

<a name="l01813"></a>01813

1841

<a name="l01814"></a>01814 if (<a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nblock))

1842

<a name="l01815"></a>01815 {

1843

<a name="l01816"></a>01816 is_set = <a class="code" href="a00114.html#ga866352ef5986a7d2b709795d127b666b" title="Tests if bit = pos is true.">gap_test</a>(<a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block), nbit);

1844

<a name="l01817"></a>01817 }

1845

<a name="l01818"></a>01818 else

1846

<a name="l01819"></a>01819 {

1847

<a name="l01820"></a>01820 unsigned nword = unsigned(nbit >> <a class="code" href="a00110.html#a83d76bccf6fe3770f32d5ba11d2a37ad">bm::set_word_shift</a>);

1848

<a name="l01821"></a>01821 nbit &= <a class="code" href="a00110.html#addbf345be3733d5e4575d71733ed1da8">bm::set_word_mask</a>;

1849

<a name="l01822"></a>01822

1850

<a name="l01823"></a>01823 is_set = (block[nword] & (((<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>)1) << nbit));

1851

<a name="l01824"></a>01824 }

1852

<a name="l01825"></a>01825 return is_set != 0;

1853

<a name="l01826"></a>01826 }

1854

<a name="l01827"></a>01827 return false;

1855

<a name="l01828"></a>01828 }

1856

<a name="l01829"></a>01829

1857

<a name="l01830"></a>01830 // -----------------------------------------------------------------------

1858

<a name="l01831"></a>01831

1859

<a name="l01832"></a>01832 template<typename Alloc, typename MS>

1860

<a name="l01833"></a><a class="code" href="a00043.html#abd522c13e26c2b8f84636fe8b6648dcb">01833</a> void <a class="code" href="a00043.html#abd522c13e26c2b8f84636fe8b6648dcb" title="Optimize memory bitvector&#39;s memory allocation.">bvector<Alloc, MS>::optimize</a>(<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* temp_block,

1861

<a name="l01834"></a>01834 <a class="code" href="a00043.html#a05f1e977cb5e6208838afc7e7b69e5f0" title="Optimization mode Every next level means additional checks (better compression vs...">optmode</a> opt_mode,

1862

<a name="l01835"></a>01835 <a class="code" href="a00082.html" title="Statistical information about bitset&#39;s memory allocation details.">statistics</a>* stat)

1863

<a name="l01836"></a>01836 {

1864

<a name="l01837"></a>01837 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">word_t</a>*** blk_root = blockman_.blocks_root();

1865

<a name="l01838"></a>01838

1866

<a name="l01839"></a>01839 if (!temp_block)

1867

<a name="l01840"></a>01840 temp_block = blockman_.check_allocate_tempblock();

1868

<a name="l01841"></a>01841

1869

<a name="l01842"></a>01842 typename

1870

<a name="l01843"></a>01843 blocks_manager_type::block_opt_func opt_func(blockman_,

1871

<a name="l01844"></a>01844 temp_block,

1872

<a name="l01845"></a>01845 (int)opt_mode,

1873

<a name="l01846"></a>01846 stat);

1874

<a name="l01847"></a>01847 if (stat)

1875

<a name="l01848"></a>01848 {

1876

<a name="l01849"></a>01849 stat-><a class="code" href="a00042.html#a4ec8ba190b4ba31c431c008402881c62" title="Number of bit blocks.">bit_blocks</a> = stat-><a class="code" href="a00042.html#a4dcfd64e9ab0be5472e3c2b04e551f81" title="Number of GAP blocks.">gap_blocks</a>

1877

<a name="l01850"></a>01850 = stat-><a class="code" href="a00042.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a>

1878

<a name="l01851"></a>01851 = stat-><a class="code" href="a00042.html#ad3b2190eb4afe24ecd56323cbc0a7666" title="Memory used by bitvector including temp and service blocks.">memory_used</a>

1879

<a name="l01852"></a>01852 = 0;

1880

<a name="l01853"></a>01853 ::memcpy(stat-><a class="code" href="a00042.html#acc08d9637cc25d02d3a50c061ba221e1" title="GAP lengths used by bvector.">gap_levels</a>,

1881

<a name="l01854"></a>01854 blockman_.glen(), sizeof(<a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>) * <a class="code" href="a00110.html#a773e9f5341919d58000bd54d50038733">bm::gap_levels</a>);

1882

<a name="l01855"></a>01855 stat-><a class="code" href="a00042.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> = sizeof(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">id_t</a>) * 4;

1883

<a name="l01856"></a>01856

1884

<a name="l01857"></a>01857 }

1885

<a name="l01858"></a>01858

1886

<a name="l01859"></a>01859 <a class="code" href="a00110.html#ae8b342c25dc22d6cd26cb96d7ae796db">for_each_nzblock</a>(blk_root, blockman_.effective_top_block_size(),

1887

<a name="l01860"></a>01860 <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>, opt_func);

1888

<a name="l01861"></a>01861

1889

<a name="l01862"></a>01862 if (stat)

1890

<a name="l01863"></a>01863 {

1891

<a name="l01864"></a>01864 unsigned safe_inc = stat-><a class="code" href="a00042.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> / 10; // 10% increment

1892

<a name="l01865"></a>01865 if (!safe_inc) safe_inc = 256;

1893

<a name="l01866"></a>01866 stat-><a class="code" href="a00042.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> += safe_inc;

1894

<a name="l01867"></a>01867 stat-><a class="code" href="a00042.html#ad3b2190eb4afe24ecd56323cbc0a7666" title="Memory used by bitvector including temp and service blocks.">memory_used</a> += sizeof(*this) - sizeof(blockman_);

1895

<a name="l01868"></a>01868 stat-><a class="code" href="a00042.html#ad3b2190eb4afe24ecd56323cbc0a7666" title="Memory used by bitvector including temp and service blocks.">memory_used</a> += blockman_.mem_used();

1896

<a name="l01869"></a>01869 }

1897

<a name="l01870"></a>01870 }

1898

<a name="l01871"></a>01871

1899

<a name="l01872"></a>01872 // -----------------------------------------------------------------------

1900

<a name="l01873"></a>01873

1901

<a name="l01874"></a>01874 template<typename Alloc, typename MS>

1902

<a name="l01875"></a><a class="code" href="a00043.html#a3942e3f6ea9fa54fcdb78a35a85008e5">01875</a> void <a class="code" href="a00043.html#a3942e3f6ea9fa54fcdb78a35a85008e5" title="Optimize sizes of GAP blocks.">bvector<Alloc, MS>::optimize_gap_size</a>()

1903

<a name="l01876"></a>01876 {

1904

<a name="l01877"></a>01877 struct <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector</a><Alloc, MS>::<a class="code" href="a00082.html" title="Statistical information about bitset&#39;s memory allocation details.">statistics</a> st;

1905

<a name="l01878"></a>01878 <a class="code" href="a00043.html#a1eaaac76a97b9eb1d3c11f21cf9385ac" title="Calculates bitvector statistics.">calc_stat</a>(&st);

1906

<a name="l01879"></a>01879

1907

<a name="l01880"></a>01880 if (!st.gap_blocks)

1908

<a name="l01881"></a>01881 return;

1909

<a name="l01882"></a>01882

1910

<a name="l01883"></a>01883 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a> opt_glen[bm::<a class="code" href="a00110.html#a773e9f5341919d58000bd54d50038733">gap_levels</a>];

1911

<a name="l01884"></a>01884 ::memcpy(opt_glen, st.gap_levels, bm::gap_levels * sizeof(*opt_glen));

1912

<a name="l01885"></a>01885

1913

<a name="l01886"></a>01886 <a class="code" href="a00114.html#ga2daff3a0ceda6fef87d3b0e892da5813" title="Finds optimal gap blocks lengths.">improve_gap_levels</a>(st.gap_length,

1914

<a name="l01887"></a>01887 st.gap_length + st.gap_blocks,

1915

<a name="l01888"></a>01888 opt_glen);

1916

<a name="l01889"></a>01889

1917

<a name="l01890"></a>01890 <a class="code" href="a00043.html#a40d82dec62efe90b0810ccd06b62163e" title="Sets new GAP lengths table. All GAP blocks will be reallocated to match the new scheme...">set_gap_levels</a>(opt_glen);

1918

<a name="l01891"></a>01891 }

1919

<a name="l01892"></a>01892

1920

<a name="l01893"></a>01893 // -----------------------------------------------------------------------

1921

<a name="l01894"></a>01894

1922

<a name="l01895"></a>01895 template<typename Alloc, typename MS>

1923

<a name="l01896"></a><a class="code" href="a00043.html#a40d82dec62efe90b0810ccd06b62163e">01896</a> void <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector</a><Alloc, MS>::<a class="code" href="a00043.html#a40d82dec62efe90b0810ccd06b62163e" title="Sets new GAP lengths table. All GAP blocks will be reallocated to match the new scheme...">set_gap_levels</a>(const gap_word_t* glevel_len)

1924

<a name="l01897"></a>01897 {

1925

<a name="l01898"></a>01898 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">word_t</a>*** blk_root = blockman_.blocks_root();

1926

<a name="l01899"></a>01899

1927

<a name="l01900"></a>01900 typename

1928

<a name="l01901"></a>01901 blocks_manager_type::gap_level_func gl_func(blockman_, glevel_len);

1929

<a name="l01902"></a>01902

1930

<a name="l01903"></a>01903 <a class="code" href="a00110.html#ae8b342c25dc22d6cd26cb96d7ae796db">for_each_nzblock</a>(blk_root, blockman_.top_block_size(),

1931

<a name="l01904"></a>01904 <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>, gl_func);

1932

<a name="l01905"></a>01905

1933

<a name="l01906"></a>01906 blockman_.set_glen(glevel_len);

1934

<a name="l01907"></a>01907 }

1935

<a name="l01908"></a>01908

1936

<a name="l01909"></a>01909 // -----------------------------------------------------------------------

1937

<a name="l01910"></a>01910

1938

<a name="l01911"></a>01911 template<typename Alloc, typename MS>

1939

<a name="l01912"></a><a class="code" href="a00043.html#aa2294dbf9374fd906f74a796d147c255">01912</a> int <a class="code" href="a00043.html#aa2294dbf9374fd906f74a796d147c255" title="Lexicographical comparison with a bitvector.">bvector<Alloc, MS>::compare</a>(const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS></a>& <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvect</a>) const

1940

<a name="l01913"></a>01913 {

1941

<a name="l01914"></a>01914 int res;

1942

<a name="l01915"></a>01915 unsigned bn = 0;

1943

<a name="l01916"></a>01916

1944

<a name="l01917"></a>01917 unsigned top_blocks = blockman_.effective_top_block_size();

1945

<a name="l01918"></a>01918 unsigned bvect_top_blocks = bvect.blockman_.effective_top_block_size();

1946

<a name="l01919"></a>01919

1947

<a name="l01920"></a>01920 if (bvect_top_blocks > top_blocks) top_blocks = bvect_top_blocks;

1948

<a name="l01921"></a>01921

1949

<a name="l01922"></a>01922 for (unsigned i = 0; i < top_blocks; ++i)

1950

<a name="l01923"></a>01923 {

1951

<a name="l01924"></a>01924 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* const* blk_blk = blockman_.get_topblock(i);

1952

<a name="l01925"></a>01925 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* const* arg_blk_blk =

1953

<a name="l01926"></a>01926 bvect.blockman_.get_topblock(i);

1954

<a name="l01927"></a>01927

1955

<a name="l01928"></a>01928 if (blk_blk == arg_blk_blk)

1956

<a name="l01929"></a>01929 {

1957

<a name="l01930"></a>01930 bn += <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>;

1958

<a name="l01931"></a>01931 continue;

1959

<a name="l01932"></a>01932 }

1960

<a name="l01933"></a>01933

1961

<a name="l01934"></a>01934 for (unsigned j = 0; j < <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>; ++j, ++bn)

1962

<a name="l01935"></a>01935 {

1963

<a name="l01936"></a>01936 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* arg_blk = arg_blk_blk ? arg_blk_blk[j] : 0;

1964

<a name="l01937"></a>01937 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk = blk_blk ? blk_blk[j] : 0;

1965

<a name="l01938"></a>01938 if (blk == arg_blk) continue;

1966

<a name="l01939"></a>01939

1967

<a name="l01940"></a>01940 // If one block is zero we check if the other one has at least

1968

<a name="l01941"></a>01941 // one bit ON

1969

<a name="l01942"></a>01942

1970

<a name="l01943"></a>01943 if (!blk || !arg_blk)

1971

<a name="l01944"></a>01944 {

1972

<a name="l01945"></a>01945 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* pblk;

1973

<a name="l01946"></a>01946 bool is_gap;

1974

<a name="l01947"></a>01947

1975

<a name="l01948"></a>01948 if (blk)

1976

<a name="l01949"></a>01949 {

1977

<a name="l01950"></a>01950 pblk = blk;

1978

<a name="l01951"></a>01951 res = 1;

1979

<a name="l01952"></a>01952 is_gap = <a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>((*this), blk, bn);

1980

<a name="l01953"></a>01953 }

1981

<a name="l01954"></a>01954 else

1982

<a name="l01955"></a>01955 {

1983

<a name="l01956"></a>01956 pblk = arg_blk;

1984

<a name="l01957"></a>01957 res = -1;

1985

<a name="l01958"></a>01958 is_gap = <a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(bvect, arg_blk, bn);

1986

<a name="l01959"></a>01959 }

1987

<a name="l01960"></a>01960

1988

<a name="l01961"></a>01961 if (is_gap)

1989

<a name="l01962"></a>01962 {

1990

<a name="l01963"></a>01963 if (!<a class="code" href="a00114.html#ga690ff7c8b16e1821a77663b7194267e7" title="Temporary inverts all bits in the GAP buffer.">gap_is_all_zero</a>(<a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(pblk), <a class="code" href="a00110.html#ad0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a>))

1991

<a name="l01964"></a>01964 {

1992

<a name="l01965"></a>01965 return res;

1993

<a name="l01966"></a>01966 }

1994

<a name="l01967"></a>01967 }

1995

<a name="l01968"></a>01968 else

1996

<a name="l01969"></a>01969 {

1997

<a name="l01970"></a>01970 <a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>* blk1 = (<a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">wordop_t</a>*)pblk;

1998

<a name="l01971"></a>01971 <a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>* blk2 =

1999

<a name="l01972"></a>01972 (<a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">wordop_t</a>*)(pblk + bm::set_block_size);

2000

<a name="l01973"></a>01973 if (!<a class="code" href="a00115.html#gac6cfb9f92e4df6bb4c76f6efb2382860" title="Returns &quot;true&quot; if all bits in the block are 0.">bit_is_all_zero</a>(blk1, blk2))

2001

<a name="l01974"></a>01974 {

2002

<a name="l01975"></a>01975 return res;

2003

<a name="l01976"></a>01976 }

2004

<a name="l01977"></a>01977 }

2005

<a name="l01978"></a>01978

2006

<a name="l01979"></a>01979 continue;

2007

<a name="l01980"></a>01980 }

2008

<a name="l01981"></a>01981

2009

<a name="l01982"></a>01982 bool arg_gap = <a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(bvect, arg_blk, bn);

2010

<a name="l01983"></a>01983 bool gap = <a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>((*this), blk, bn);

2011

<a name="l01984"></a>01984

2012

<a name="l01985"></a>01985 if (arg_gap != gap)

2013

<a name="l01986"></a>01986 {

2014

<a name="l01987"></a>01987 <a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a> temp_blk[<a class="code" href="a00110.html#a7049fd70220fc3a3072e9f82abf4ad66">bm::set_block_size_op</a>];

2015

<a name="l01988"></a>01988 <a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>* blk1;

2016

<a name="l01989"></a>01989 <a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>* blk2;

2017

<a name="l01990"></a>01990

2018

<a name="l01991"></a>01991 if (gap)

2019

<a name="l01992"></a>01992 {

2020

<a name="l01993"></a>01993 <a class="code" href="a00114.html#ga4862f4dcdcb7c0575e2e2db9e5f2a849" title="GAP block to bitblock conversion.">gap_convert_to_bitset</a>((<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*)temp_blk,

2021

<a name="l01994"></a>01994 <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk));

2022

<a name="l01995"></a>01995

2023

<a name="l01996"></a>01996 blk1 = (<a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>*)temp_blk;

2024

<a name="l01997"></a>01997 blk2 = (<a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>*)arg_blk;

2025

<a name="l01998"></a>01998 }

2026

<a name="l01999"></a>01999 else

2027

<a name="l02000"></a>02000 {

2028

<a name="l02001"></a>02001 <a class="code" href="a00114.html#ga4862f4dcdcb7c0575e2e2db9e5f2a849" title="GAP block to bitblock conversion.">gap_convert_to_bitset</a>((<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*)temp_blk,

2029

<a name="l02002"></a>02002 <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(arg_blk));

2030

<a name="l02003"></a>02003

2031

<a name="l02004"></a>02004 blk1 = (<a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>*)blk;

2032

<a name="l02005"></a>02005 blk2 = (<a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>*)temp_blk;

2033

<a name="l02006"></a>02006

2034

<a name="l02007"></a>02007 }

2035

<a name="l02008"></a>02008 res = <a class="code" href="a00115.html#ga91fe9566575d9d66e1bb9d030b3d29a0" title="Lexicographical comparison of BIT buffers.">bitcmp</a>(blk1, blk2, <a class="code" href="a00110.html#a7049fd70220fc3a3072e9f82abf4ad66">bm::set_block_size_op</a>);

2036

<a name="l02009"></a>02009

2037

<a name="l02010"></a>02010 }

2038

<a name="l02011"></a>02011 else

2039

<a name="l02012"></a>02012 {

2040

<a name="l02013"></a>02013 if (gap)

2041

<a name="l02014"></a>02014 {

2042

<a name="l02015"></a>02015 res = <a class="code" href="a00114.html#ga406952734f1b05962941b32e37b3eb96" title="Lexicographical comparison of GAP buffers.">gapcmp</a>(<a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk), <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(arg_blk));

2043

<a name="l02016"></a>02016 }

2044

<a name="l02017"></a>02017 else

2045

<a name="l02018"></a>02018 {

2046

<a name="l02019"></a>02019 res = <a class="code" href="a00115.html#ga91fe9566575d9d66e1bb9d030b3d29a0" title="Lexicographical comparison of BIT buffers.">bitcmp</a>((<a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>*)blk,

2047

<a name="l02020"></a>02020 (<a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>*)arg_blk,

2048

<a name="l02021"></a>02021 <a class="code" href="a00110.html#a7049fd70220fc3a3072e9f82abf4ad66">bm::set_block_size_op</a>);

2049

<a name="l02022"></a>02022 }

2050

<a name="l02023"></a>02023 }

2051

<a name="l02024"></a>02024

2052

<a name="l02025"></a>02025 if (res != 0)

2053

<a name="l02026"></a>02026 {

2054

<a name="l02027"></a>02027 return res;

2055

<a name="l02028"></a>02028 }

2056

<a name="l02029"></a>02029

2057

<a name="l02030"></a>02030

2058

<a name="l02031"></a>02031 } // for j

2059

<a name="l02032"></a>02032

2060

<a name="l02033"></a>02033 } // for i

2061

<a name="l02034"></a>02034

2062

<a name="l02035"></a>02035 return 0;

2063

<a name="l02036"></a>02036 }

2064

<a name="l02037"></a>02037

2065

<a name="l02038"></a>02038

2066

<a name="l02039"></a>02039 // -----------------------------------------------------------------------

2067

<a name="l02040"></a>02040

2068

<a name="l02041"></a>02041 template<typename Alloc, typename MS>

2069

<a name="l02042"></a><a class="code" href="a00043.html#a1eaaac76a97b9eb1d3c11f21cf9385ac">02042</a> void <a class="code" href="a00043.html#a1eaaac76a97b9eb1d3c11f21cf9385ac" title="Calculates bitvector statistics.">bvector<Alloc, MS>::calc_stat</a>(struct <a class="code" href="a00082.html" title="Statistical information about bitset&#39;s memory allocation details.">bvector<Alloc, MS>::statistics</a>* st) const

2070

<a name="l02043"></a>02043 {

2071

<a name="l02044"></a>02044 st-><a class="code" href="a00042.html#a4ec8ba190b4ba31c431c008402881c62" title="Number of bit blocks.">bit_blocks</a> = st-><a class="code" href="a00042.html#a4dcfd64e9ab0be5472e3c2b04e551f81" title="Number of GAP blocks.">gap_blocks</a>

2072

<a name="l02045"></a>02045 = st-><a class="code" href="a00042.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a>

2073

<a name="l02046"></a>02046 = st-><a class="code" href="a00042.html#ad3b2190eb4afe24ecd56323cbc0a7666" title="Memory used by bitvector including temp and service blocks.">memory_used</a> = 0;

2074

<a name="l02047"></a>02047

2075

<a name="l02048"></a>02048 ::memcpy(st-><a class="code" href="a00042.html#acc08d9637cc25d02d3a50c061ba221e1" title="GAP lengths used by bvector.">gap_levels</a>,

2076

<a name="l02049"></a>02049 blockman_.glen(), sizeof(<a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>) * <a class="code" href="a00110.html#a773e9f5341919d58000bd54d50038733">bm::gap_levels</a>);

2077

<a name="l02050"></a>02050

2078

<a name="l02051"></a>02051 unsigned empty_blocks = 0;

2079

<a name="l02052"></a>02052 unsigned blocks_memory = 0;

2080

<a name="l02053"></a>02053 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* gapl_ptr = st-><a class="code" href="a00042.html#a824dd18d515305d159c48a697696cbb6" title="Array of all GAP block lengths in the bvector.">gap_length</a>;

2081

<a name="l02054"></a>02054

2082

<a name="l02055"></a>02055 st-><a class="code" href="a00042.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> = sizeof(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">id_t</a>) * 4;

2083

<a name="l02056"></a>02056

2084

<a name="l02057"></a>02057 unsigned block_idx = 0;

2085

<a name="l02058"></a>02058

2086

<a name="l02059"></a>02059 unsigned top_size = blockman_.effective_top_block_size();

2087

<a name="l02060"></a>02060 // Walk the blocks, calculate statistics.

2088

<a name="l02061"></a>02061 for (unsigned i = 0; i < top_size; ++i)

2089

<a name="l02062"></a>02062 {

2090

<a name="l02063"></a>02063 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* const* blk_blk = blockman_.get_topblock(i);

2091

<a name="l02064"></a>02064

2092

<a name="l02065"></a>02065 if (!blk_blk)

2093

<a name="l02066"></a>02066 {

2094

<a name="l02067"></a>02067 block_idx += <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>;

2095

<a name="l02068"></a>02068 st-><a class="code" href="a00042.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> += sizeof(unsigned) + 1;

2096

<a name="l02069"></a>02069 continue;

2097

<a name="l02070"></a>02070 }

2098

<a name="l02071"></a>02071

2099

<a name="l02072"></a>02072 for (unsigned j = 0;j < <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>; ++j, ++block_idx)

2100

<a name="l02073"></a>02073 {

2101

<a name="l02074"></a>02074 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk = blk_blk[j];

2102

<a name="l02075"></a>02075 if (<a class="code" href="a00089.html#a13ba598909515339ceede09e3b9b0198">IS_VALID_ADDR</a>(blk))

2103

<a name="l02076"></a>02076 {

2104

<a name="l02077"></a>02077 st-><a class="code" href="a00042.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> += empty_blocks << 2;

2105

<a name="l02078"></a>02078 empty_blocks = 0;

2106

<a name="l02079"></a>02079

2107

<a name="l02080"></a>02080 if (<a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, blk, block_idx)) // gap block

2108

<a name="l02081"></a>02081 {

2109

<a name="l02082"></a>02082 ++(st-><a class="code" href="a00042.html#a4dcfd64e9ab0be5472e3c2b04e551f81" title="Number of GAP blocks.">gap_blocks</a>);

2110

<a name="l02083"></a>02083

2111

<a name="l02084"></a>02084 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">bm::gap_word_t</a>* gap_blk = <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk);

2112

<a name="l02085"></a>02085

2113

<a name="l02086"></a>02086 unsigned mem_used =

2114

<a name="l02087"></a>02087 <a class="code" href="a00114.html#ga0419ed06e2f0b7891e7d721546f5fb45" title="Returs GAP block capacity.">bm::gap_capacity</a>(gap_blk, blockman_.glen())

2115

<a name="l02088"></a>02088 * sizeof(<a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>);

2116

<a name="l02089"></a>02089

2117

<a name="l02090"></a>02090 *gapl_ptr = <a class="code" href="a00114.html#gad6bfb9da9950b0df8983a9faf9db5042" title="Returs GAP block length.">gap_length</a>(gap_blk);

2118

<a name="l02091"></a>02091

2119

<a name="l02092"></a>02092 st-><a class="code" href="a00042.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> += *gapl_ptr * sizeof(<a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>);

2120

<a name="l02093"></a>02093 blocks_memory += mem_used;

2121

<a name="l02094"></a>02094

2122

<a name="l02095"></a>02095 ++gapl_ptr;

2123

<a name="l02096"></a>02096 }

2124

<a name="l02097"></a>02097 else // bit block

2125

<a name="l02098"></a>02098 {

2126

<a name="l02099"></a>02099 ++(st-><a class="code" href="a00042.html#a4ec8ba190b4ba31c431c008402881c62" title="Number of bit blocks.">bit_blocks</a>);

2127

<a name="l02100"></a>02100 unsigned mem_used = sizeof(<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>) * bm::set_block_size;

2128

<a name="l02101"></a>02101 st-><a class="code" href="a00042.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> += mem_used;

2129

<a name="l02102"></a>02102 blocks_memory += mem_used;

2130

<a name="l02103"></a>02103 }

2131

<a name="l02104"></a>02104 }

2132

<a name="l02105"></a>02105 else

2133

<a name="l02106"></a>02106 {

2134

<a name="l02107"></a>02107 ++empty_blocks;

2135

<a name="l02108"></a>02108 }

2136

<a name="l02109"></a>02109 }

2137

<a name="l02110"></a>02110 }

2138

<a name="l02111"></a>02111

2139

<a name="l02112"></a>02112 unsigned safe_inc = st-><a class="code" href="a00042.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> / 10; // 10% increment

2140

<a name="l02113"></a>02113 if (!safe_inc) safe_inc = 256;

2141

<a name="l02114"></a>02114 st-><a class="code" href="a00042.html#a92f800e8649a1455c17019c8ec882b4b" title="Estimated maximum of memory required for serialization.">max_serialize_mem</a> += safe_inc;

2142

<a name="l02115"></a>02115

2143

<a name="l02116"></a>02116 // Calc size of different odd and temporary things.

2144

<a name="l02117"></a>02117

2145

<a name="l02118"></a>02118 st-><a class="code" href="a00042.html#ad3b2190eb4afe24ecd56323cbc0a7666" title="Memory used by bitvector including temp and service blocks.">memory_used</a> += sizeof(*this) - sizeof(blockman_);

2146

<a name="l02119"></a>02119 st-><a class="code" href="a00042.html#ad3b2190eb4afe24ecd56323cbc0a7666" title="Memory used by bitvector including temp and service blocks.">memory_used</a> += blockman_.mem_used();

2147

<a name="l02120"></a>02120 st-><a class="code" href="a00042.html#ad3b2190eb4afe24ecd56323cbc0a7666" title="Memory used by bitvector including temp and service blocks.">memory_used</a> += blocks_memory;

2148

<a name="l02121"></a>02121 }

2149

<a name="l02122"></a>02122

2150

<a name="l02123"></a>02123

2151

<a name="l02124"></a>02124 // -----------------------------------------------------------------------

2152

<a name="l02125"></a>02125

2153

<a name="l02126"></a>02126

2154

<a name="l02127"></a>02127 template<class Alloc, class MS>

2155

<a name="l02128"></a>02128 bool <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS>::set_bit_no_check</a>(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val)

2156

<a name="l02129"></a>02129 {

2157

<a name="l02130"></a>02130 // calculate logical block number

2158

<a name="l02131"></a>02131 unsigned nblock = unsigned(n >> <a class="code" href="a00110.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

2159

<a name="l02132"></a>02132

2160

<a name="l02133"></a>02133 int block_type;

2161

<a name="l02134"></a>02134

2162

<a name="l02135"></a>02135 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk =

2163

<a name="l02136"></a>02136 blockman_.check_allocate_block(nblock,

2164

<a name="l02137"></a>02137 val,

2165

<a name="l02138"></a>02138 <a class="code" href="a00043.html#ad971c541fa259278e9dcf541b2d128c9" title="Returns blocks allocation strategy.">get_new_blocks_strat</a>(),

2166

<a name="l02139"></a>02139 &block_type);

2167

<a name="l02140"></a>02140

2168

<a name="l02141"></a>02141 if (!blk) return false;

2169

<a name="l02142"></a>02142

2170

<a name="l02143"></a>02143 // calculate word number in block and bit

2171

<a name="l02144"></a>02144 unsigned nbit = unsigned(n & <a class="code" href="a00110.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2172

<a name="l02145"></a>02145

2173

<a name="l02146"></a>02146 if (block_type == 1) // gap

2174

<a name="l02147"></a>02147 {

2175

<a name="l02148"></a>02148 unsigned is_set;

2176

<a name="l02149"></a>02149 unsigned new_block_len;

2177

<a name="l02150"></a>02150

2178

<a name="l02151"></a>02151 new_block_len =

2179

<a name="l02152"></a>02152 <a class="code" href="a00114.html#ga69186bd13bda27e04b3e33683ff884c2" title="Abstract distance(similarity) operation for GAP buffers. Receives functor F as a...">gap_set_value</a>(val, <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk), nbit, &is_set);

2180

<a name="l02153"></a>02153 if (is_set)

2181

<a name="l02154"></a>02154 {

2182

<a name="l02155"></a>02155 <a class="code" href="a00084.html#aef4146eb86de042a6c34717f87b16c10">BMCOUNT_ADJ</a>(val)

2183

<a name="l02156"></a>02156

2184

<a name="l02157"></a>02157 unsigned threshold =

2185

<a name="l02158"></a>02158 bm::<a class="code" href="a00114.html#ga94a5371b5dc6a1560d95d7c2dde88815" title="Returs GAP block capacity limit.">gap_limit</a>(<a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk), blockman_.glen());

2186

<a name="l02159"></a>02159

2187

<a name="l02160"></a>02160 if (new_block_len > threshold)

2188

<a name="l02161"></a>02161 {

2189

<a name="l02162"></a>02162 extend_gap_block(nblock, <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk));

2190

<a name="l02163"></a>02163 }

2191

<a name="l02164"></a>02164 return true;

2192

<a name="l02165"></a>02165 }

2193

<a name="l02166"></a>02166 }

2194

<a name="l02167"></a>02167 else // bit block

2195

<a name="l02168"></a>02168 {

2196

<a name="l02169"></a>02169 unsigned nword = unsigned(nbit >> <a class="code" href="a00110.html#a83d76bccf6fe3770f32d5ba11d2a37ad">bm::set_word_shift</a>);

2197

<a name="l02170"></a>02170 nbit &= <a class="code" href="a00110.html#addbf345be3733d5e4575d71733ed1da8">bm::set_word_mask</a>;

2198

<a name="l02171"></a>02171

2199

<a name="l02172"></a>02172 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* word = blk + nword;

2200

<a name="l02173"></a>02173 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a> mask = (((<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>)1) << nbit);

2201

<a name="l02174"></a>02174

2202

<a name="l02175"></a>02175 if (val)

2203

<a name="l02176"></a>02176 {

2204

<a name="l02177"></a>02177 if ( ((*word) & mask) == 0 )

2205

<a name="l02178"></a>02178 {

2206

<a name="l02179"></a>02179 *word |= mask; // set bit

2207

<a name="l02180"></a>02180 <a class="code" href="a00084.html#a911e3d9e9a293cafab1396a8700288e9">BMCOUNT_INC</a>;

2208

<a name="l02181"></a>02181 return true;

2209

<a name="l02182"></a>02182 }

2210

<a name="l02183"></a>02183 }

2211

<a name="l02184"></a>02184 else

2212

<a name="l02185"></a>02185 {

2213

<a name="l02186"></a>02186 if ((*word) & mask)

2214

<a name="l02187"></a>02187 {

2215

<a name="l02188"></a>02188 *word &= ~mask; // clear bit

2216

<a name="l02189"></a>02189 <a class="code" href="a00084.html#a809c66152f5967c1a1eb51e006206630">BMCOUNT_DEC</a>;

2217

<a name="l02190"></a>02190 return true;

2218

<a name="l02191"></a>02191 }

2219

<a name="l02192"></a>02192 }

2220

<a name="l02193"></a>02193 }

2221

<a name="l02194"></a>02194 return false;

2222

<a name="l02195"></a>02195 }

2223

<a name="l02196"></a>02196

2224

<a name="l02197"></a>02197 // -----------------------------------------------------------------------

2225

<a name="l02198"></a>02198

2226

<a name="l02199"></a>02199 template<class Alloc, class MS>

2227

<a name="l02200"></a>02200 bool bvector<Alloc, MS>::set_bit_conditional_impl(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n,

2228

<a name="l02201"></a>02201 bool val,

2229

<a name="l02202"></a>02202 bool condition)

2230

<a name="l02203"></a>02203 {

2231

<a name="l02204"></a>02204 // calculate logical block number

2232

<a name="l02205"></a>02205 unsigned nblock = unsigned(n >> <a class="code" href="a00110.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

2233

<a name="l02206"></a>02206

2234

<a name="l02207"></a>02207 int block_type;

2235

<a name="l02208"></a>02208 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk =

2236

<a name="l02209"></a>02209 blockman_.check_allocate_block(nblock,

2237

<a name="l02210"></a>02210 val,

2238

<a name="l02211"></a>02211 <a class="code" href="a00043.html#ad971c541fa259278e9dcf541b2d128c9" title="Returns blocks allocation strategy.">get_new_blocks_strat</a>(),

2239

<a name="l02212"></a>02212 &block_type);

2240

<a name="l02213"></a>02213 if (!blk)

2241

<a name="l02214"></a>02214 return false;

2242

<a name="l02215"></a>02215

2243

<a name="l02216"></a>02216 // calculate word number in block and bit

2244

<a name="l02217"></a>02217 unsigned nbit = unsigned(n & <a class="code" href="a00110.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2245

<a name="l02218"></a>02218

2246

<a name="l02219"></a>02219 if (block_type == 1) // gap

2247

<a name="l02220"></a>02220 {

2248

<a name="l02221"></a>02221 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">bm::gap_word_t</a>* gap_blk = <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk);

2249

<a name="l02222"></a>02222 bool old_val = (<a class="code" href="a00114.html#ga866352ef5986a7d2b709795d127b666b" title="Tests if bit = pos is true.">gap_test</a>(gap_blk, nbit) != 0);

2250

<a name="l02223"></a>02223

2251

<a name="l02224"></a>02224 if (old_val != condition)

2252

<a name="l02225"></a>02225 {

2253

<a name="l02226"></a>02226 return false;

2254

<a name="l02227"></a>02227 }

2255

<a name="l02228"></a>02228

2256

<a name="l02229"></a>02229 if (val != old_val)

2257

<a name="l02230"></a>02230 {

2258

<a name="l02231"></a>02231 unsigned is_set;

2259

<a name="l02232"></a>02232 unsigned new_block_len =

2260

<a name="l02233"></a>02233 <a class="code" href="a00114.html#ga69186bd13bda27e04b3e33683ff884c2" title="Abstract distance(similarity) operation for GAP buffers. Receives functor F as a...">gap_set_value</a>(val, gap_blk, nbit, &is_set);

2261

<a name="l02234"></a>02234 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(is_set);

2262

<a name="l02235"></a>02235 <a class="code" href="a00084.html#aef4146eb86de042a6c34717f87b16c10">BMCOUNT_ADJ</a>(val)

2263

<a name="l02236"></a>02236

2264

<a name="l02237"></a>02237 unsigned threshold =

2265

<a name="l02238"></a>02238 bm::<a class="code" href="a00114.html#ga94a5371b5dc6a1560d95d7c2dde88815" title="Returs GAP block capacity limit.">gap_limit</a>(gap_blk, blockman_.glen());

2266

<a name="l02239"></a>02239 if (new_block_len > threshold)

2267

<a name="l02240"></a>02240 {

2268

<a name="l02241"></a>02241 extend_gap_block(nblock, gap_blk);

2269

<a name="l02242"></a>02242 }

2270

<a name="l02243"></a>02243 return true;

2271

<a name="l02244"></a>02244 }

2272

<a name="l02245"></a>02245 }

2273

<a name="l02246"></a>02246 else // bit block

2274

<a name="l02247"></a>02247 {

2275

<a name="l02248"></a>02248 unsigned nword = unsigned(nbit >> <a class="code" href="a00110.html#a83d76bccf6fe3770f32d5ba11d2a37ad">bm::set_word_shift</a>);

2276

<a name="l02249"></a>02249 nbit &= <a class="code" href="a00110.html#addbf345be3733d5e4575d71733ed1da8">bm::set_word_mask</a>;

2277

<a name="l02250"></a>02250

2278

<a name="l02251"></a>02251 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* word = blk + nword;

2279

<a name="l02252"></a>02252 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a> mask = (((<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>)1) << nbit);

2280

<a name="l02253"></a>02253 bool is_set = ((*word) & mask) != 0;

2281

<a name="l02254"></a>02254

2282

<a name="l02255"></a>02255 if (is_set != condition)

2283

<a name="l02256"></a>02256 {

2284

<a name="l02257"></a>02257 return false;

2285

<a name="l02258"></a>02258 }

2286

<a name="l02259"></a>02259 if (is_set != val) // need to change bit

2287

<a name="l02260"></a>02260 {

2288

<a name="l02261"></a>02261 if (val) // set bit

2289

<a name="l02262"></a>02262 {

2290

<a name="l02263"></a>02263 *word |= mask;

2291

<a name="l02264"></a>02264 <a class="code" href="a00084.html#a911e3d9e9a293cafab1396a8700288e9">BMCOUNT_INC</a>;

2292

<a name="l02265"></a>02265 }

2293

<a name="l02266"></a>02266 else // clear bit

2294

<a name="l02267"></a>02267 {

2295

<a name="l02268"></a>02268 *word &= ~mask;

2296

<a name="l02269"></a>02269 <a class="code" href="a00084.html#a809c66152f5967c1a1eb51e006206630">BMCOUNT_DEC</a>;

2297

<a name="l02270"></a>02270 }

2298

<a name="l02271"></a>02271 return true;

2299

<a name="l02272"></a>02272 }

2300

<a name="l02273"></a>02273 }

2301

<a name="l02274"></a>02274 return false;

2302

<a name="l02275"></a>02275

2303

<a name="l02276"></a>02276 }

2304

<a name="l02277"></a>02277

2305

<a name="l02278"></a>02278 // -----------------------------------------------------------------------

2306

<a name="l02279"></a>02279

2307

<a name="l02280"></a>02280

2308

<a name="l02281"></a>02281 template<class Alloc, class MS>

2309

<a name="l02282"></a>02282 bool bvector<Alloc, MS>::and_bit_no_check(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> n, bool val)

2310

<a name="l02283"></a>02283 {

2311

<a name="l02284"></a>02284 // calculate logical block number

2312

<a name="l02285"></a>02285 unsigned nblock = unsigned(n >> <a class="code" href="a00110.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

2313

<a name="l02286"></a>02286

2314

<a name="l02287"></a>02287 int block_type;

2315

<a name="l02288"></a>02288 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk =

2316

<a name="l02289"></a>02289 blockman_.check_allocate_block(nblock,

2317

<a name="l02290"></a>02290 val,

2318

<a name="l02291"></a>02291 <a class="code" href="a00043.html#ad971c541fa259278e9dcf541b2d128c9" title="Returns blocks allocation strategy.">get_new_blocks_strat</a>(),

2319

<a name="l02292"></a>02292 &block_type);

2320

<a name="l02293"></a>02293 if (!blk) return false;

2321

<a name="l02294"></a>02294

2322

<a name="l02295"></a>02295 // calculate word number in block and bit

2323

<a name="l02296"></a>02296 unsigned nbit = unsigned(n & <a class="code" href="a00110.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2324

<a name="l02297"></a>02297

2325

<a name="l02298"></a>02298 if (block_type == 1) // gap

2326

<a name="l02299"></a>02299 {

2327

<a name="l02300"></a>02300 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">bm::gap_word_t</a>* gap_blk = <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk);

2328

<a name="l02301"></a>02301 bool old_val = (<a class="code" href="a00114.html#ga866352ef5986a7d2b709795d127b666b" title="Tests if bit = pos is true.">gap_test</a>(gap_blk, nbit) != 0);

2329

<a name="l02302"></a>02302

2330

<a name="l02303"></a>02303 bool new_val = val & old_val;

2331

<a name="l02304"></a>02304 if (new_val != old_val)

2332

<a name="l02305"></a>02305 {

2333

<a name="l02306"></a>02306 unsigned is_set;

2334

<a name="l02307"></a>02307 unsigned new_block_len =

2335

<a name="l02308"></a>02308 <a class="code" href="a00114.html#ga69186bd13bda27e04b3e33683ff884c2" title="Abstract distance(similarity) operation for GAP buffers. Receives functor F as a...">gap_set_value</a>(new_val, gap_blk, nbit, &is_set);

2336

<a name="l02309"></a>02309 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(is_set);

2337

<a name="l02310"></a>02310 <a class="code" href="a00084.html#aef4146eb86de042a6c34717f87b16c10">BMCOUNT_ADJ</a>(val)

2338

<a name="l02311"></a>02311

2339

<a name="l02312"></a>02312 unsigned threshold =

2340

<a name="l02313"></a>02313 bm::<a class="code" href="a00114.html#ga94a5371b5dc6a1560d95d7c2dde88815" title="Returs GAP block capacity limit.">gap_limit</a>(gap_blk, blockman_.glen());

2341

<a name="l02314"></a>02314 if (new_block_len > threshold)

2342

<a name="l02315"></a>02315 {

2343

<a name="l02316"></a>02316 extend_gap_block(nblock, gap_blk);

2344

<a name="l02317"></a>02317 }

2345

<a name="l02318"></a>02318 return true;

2346

<a name="l02319"></a>02319 }

2347

<a name="l02320"></a>02320 }

2348

<a name="l02321"></a>02321 else // bit block

2349

<a name="l02322"></a>02322 {

2350

<a name="l02323"></a>02323 unsigned nword = unsigned(nbit >> <a class="code" href="a00110.html#a83d76bccf6fe3770f32d5ba11d2a37ad">bm::set_word_shift</a>);

2351

<a name="l02324"></a>02324 nbit &= <a class="code" href="a00110.html#addbf345be3733d5e4575d71733ed1da8">bm::set_word_mask</a>;

2352

<a name="l02325"></a>02325

2353

<a name="l02326"></a>02326 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* word = blk + nword;

2354

<a name="l02327"></a>02327 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a> mask = (((<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>)1) << nbit);

2355

<a name="l02328"></a>02328 bool is_set = ((*word) & mask) != 0;

2356

<a name="l02329"></a>02329

2357

<a name="l02330"></a>02330 bool new_val = is_set & val;

2358

<a name="l02331"></a>02331 if (new_val != val) // need to change bit

2359

<a name="l02332"></a>02332 {

2360

<a name="l02333"></a>02333 if (new_val) // set bit

2361

<a name="l02334"></a>02334 {

2362

<a name="l02335"></a>02335 *word |= mask;

2363

<a name="l02336"></a>02336 <a class="code" href="a00084.html#a911e3d9e9a293cafab1396a8700288e9">BMCOUNT_INC</a>;

2364

<a name="l02337"></a>02337 }

2365

<a name="l02338"></a>02338 else // clear bit

2366

<a name="l02339"></a>02339 {

2367

<a name="l02340"></a>02340 *word &= ~mask;

2368

<a name="l02341"></a>02341 <a class="code" href="a00084.html#a809c66152f5967c1a1eb51e006206630">BMCOUNT_DEC</a>;

2369

<a name="l02342"></a>02342 }

2370

<a name="l02343"></a>02343 return true;

2371

<a name="l02344"></a>02344 }

2372

<a name="l02345"></a>02345 }

2373

<a name="l02346"></a>02346 return false;

2374

<a name="l02347"></a>02347 }

2375

<a name="l02348"></a>02348

2376

<a name="l02349"></a>02349

2377

<a name="l02350"></a>02350 //---------------------------------------------------------------------

2378

<a name="l02351"></a>02351

2379

<a name="l02352"></a>02352 template<class Alloc, class MS>

2380

<a name="l02353"></a>02353 <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> bvector<Alloc, MS>::check_or_next(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> prev) const

2381

<a name="l02354"></a>02354 {

2382

<a name="l02355"></a>02355 for (;;)

2383

<a name="l02356"></a>02356 {

2384

<a name="l02357"></a>02357 unsigned nblock = unsigned(prev >> <a class="code" href="a00110.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

2385

<a name="l02358"></a>02358 if (nblock >= <a class="code" href="a00110.html#a505011007f54598794e0b9477c0b0b11">bm::set_total_blocks</a>)

2386

<a name="l02359"></a>02359 break;

2387

<a name="l02360"></a>02360

2388

<a name="l02361"></a>02361 if (blockman_.is_subblock_null(nblock >> <a class="code" href="a00110.html#ac1ff8647a089c751ec330cecee01907e">bm::set_array_shift</a>))

2389

<a name="l02362"></a>02362 {

2390

<a name="l02363"></a>02363 prev += (<a class="code" href="a00110.html#a2d1bf97ae342a7759943e62090fcf5d3">bm::set_blkblk_mask</a> + 1) -

2391

<a name="l02364"></a>02364 (prev & <a class="code" href="a00110.html#a2d1bf97ae342a7759943e62090fcf5d3">bm::set_blkblk_mask</a>);

2392

<a name="l02365"></a>02365 }

2393

<a name="l02366"></a>02366 else

2394

<a name="l02367"></a>02367 {

2395

<a name="l02368"></a>02368 unsigned nbit = unsigned(prev & <a class="code" href="a00110.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2396

<a name="l02369"></a>02369 int no_more_blocks;

2397

<a name="l02370"></a>02370 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* block =

2398

<a name="l02371"></a>02371 blockman_.get_block(nblock, &no_more_blocks);

2399

<a name="l02372"></a>02372

2400

<a name="l02373"></a>02373 if (no_more_blocks)

2401

<a name="l02374"></a>02374 {

2402

<a name="l02375"></a>02375 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(block == 0);

2403

<a name="l02376"></a>02376 break;

2404

<a name="l02377"></a>02377 }

2405

<a name="l02378"></a>02378

2406

<a name="l02379"></a>02379 if (block)

2407

<a name="l02380"></a>02380 {

2408

<a name="l02381"></a>02381 if (<a class="code" href="a00089.html#a074acb37afea68caaffe3832d326eb44">IS_FULL_BLOCK</a>(block)) return prev;

2409

<a name="l02382"></a>02382 if (<a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nblock))

2410

<a name="l02383"></a>02383 {

2411

<a name="l02384"></a>02384 if (<a class="code" href="a00114.html#gaa7df7193094353ea24b8519debf745be" title="Searches for the next 1 bit in the GAP block.">bm::gap_find_in_block</a>(<a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block),

2412

<a name="l02385"></a>02385 nbit,

2413

<a name="l02386"></a>02386 &prev))

2414

<a name="l02387"></a>02387 {

2415

<a name="l02388"></a>02388 return prev;

2416

<a name="l02389"></a>02389 }

2417

<a name="l02390"></a>02390 }

2418

<a name="l02391"></a>02391 else

2419

<a name="l02392"></a>02392 {

2420

<a name="l02393"></a>02393 if (<a class="code" href="a00115.html#gad6a7c549a625df7aa7d68d43a57238c7" title="Searches for the next 1 bit in the BIT block.">bm::bit_find_in_block</a>(block, nbit, &prev))

2421

<a name="l02394"></a>02394 {

2422

<a name="l02395"></a>02395 return prev;

2423

<a name="l02396"></a>02396 }

2424

<a name="l02397"></a>02397 }

2425

<a name="l02398"></a>02398 }

2426

<a name="l02399"></a>02399 else

2427

<a name="l02400"></a>02400 {

2428

<a name="l02401"></a>02401 prev += (<a class="code" href="a00110.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a> + 1) -

2429

<a name="l02402"></a>02402 (prev & <a class="code" href="a00110.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2430

<a name="l02403"></a>02403 }

2431

<a name="l02404"></a>02404

2432

<a name="l02405"></a>02405 }

2433

<a name="l02406"></a>02406 if (!prev) break;

2434

<a name="l02407"></a>02407 }

2435

<a name="l02408"></a>02408

2436

<a name="l02409"></a>02409 return 0;

2437

<a name="l02410"></a>02410 }

2438

<a name="l02411"></a>02411

2439

<a name="l02412"></a>02412

2440

<a name="l02413"></a>02413 //---------------------------------------------------------------------

2441

<a name="l02414"></a>02414

2442

<a name="l02415"></a>02415 template<class Alloc, class MS>

2443

<a name="l02416"></a>02416 <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> bvector<Alloc, MS>::check_or_next_extract(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> prev)

2444

<a name="l02417"></a>02417 {

2445

<a name="l02418"></a>02418 for (;;)

2446

<a name="l02419"></a>02419 {

2447

<a name="l02420"></a>02420 unsigned nblock = unsigned(prev >> <a class="code" href="a00110.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

2448

<a name="l02421"></a>02421 if (nblock >= <a class="code" href="a00110.html#a505011007f54598794e0b9477c0b0b11">bm::set_total_blocks</a>) break;

2449

<a name="l02422"></a>02422

2450

<a name="l02423"></a>02423 if (blockman_.is_subblock_null(nblock >> <a class="code" href="a00110.html#ac1ff8647a089c751ec330cecee01907e">bm::set_array_shift</a>))

2451

<a name="l02424"></a>02424 {

2452

<a name="l02425"></a>02425 prev += (<a class="code" href="a00110.html#a2d1bf97ae342a7759943e62090fcf5d3">bm::set_blkblk_mask</a> + 1) -

2453

<a name="l02426"></a>02426 (prev & <a class="code" href="a00110.html#a2d1bf97ae342a7759943e62090fcf5d3">bm::set_blkblk_mask</a>);

2454

<a name="l02427"></a>02427 }

2455

<a name="l02428"></a>02428 else

2456

<a name="l02429"></a>02429 {

2457

<a name="l02430"></a>02430 unsigned nbit = unsigned(prev & <a class="code" href="a00110.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2458

<a name="l02431"></a>02431

2459

<a name="l02432"></a>02432 int no_more_blocks;

2460

<a name="l02433"></a>02433 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* block =

2461

<a name="l02434"></a>02434 blockman_.get_block(nblock, &no_more_blocks);

2462

<a name="l02435"></a>02435

2463

<a name="l02436"></a>02436 if (no_more_blocks)

2464

<a name="l02437"></a>02437 {

2465

<a name="l02438"></a>02438 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(block == 0);

2466

<a name="l02439"></a>02439 break;

2467

<a name="l02440"></a>02440 }

2468

<a name="l02441"></a>02441

2469

<a name="l02442"></a>02442

2470

<a name="l02443"></a>02443 if (block)

2471

<a name="l02444"></a>02444 {

2472

<a name="l02445"></a>02445 if (<a class="code" href="a00089.html#a074acb37afea68caaffe3832d326eb44">IS_FULL_BLOCK</a>(block))

2473

<a name="l02446"></a>02446 {

2474

<a name="l02447"></a>02447 set(prev, false);

2475

<a name="l02448"></a>02448 return prev;

2476

<a name="l02449"></a>02449 }

2477

<a name="l02450"></a>02450 if (<a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nblock))

2478

<a name="l02451"></a>02451 {

2479

<a name="l02452"></a>02452 unsigned is_set;

2480

<a name="l02453"></a>02453 unsigned new_block_len =

2481

<a name="l02454"></a>02454 <a class="code" href="a00114.html#ga69186bd13bda27e04b3e33683ff884c2" title="Abstract distance(similarity) operation for GAP buffers. Receives functor F as a...">gap_set_value</a>(0, <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block), nbit, &is_set);

2482

<a name="l02455"></a>02455 if (is_set) {

2483

<a name="l02456"></a>02456 <a class="code" href="a00084.html#a809c66152f5967c1a1eb51e006206630">BMCOUNT_DEC</a>

2484

<a name="l02457"></a>02457 unsigned threshold =

2485

<a name="l02458"></a>02458 <a class="code" href="a00114.html#ga94a5371b5dc6a1560d95d7c2dde88815" title="Returs GAP block capacity limit.">bm::gap_limit</a>(<a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block), blockman_.glen());

2486

<a name="l02459"></a>02459 if (new_block_len > threshold)

2487

<a name="l02460"></a>02460 {

2488

<a name="l02461"></a>02461 extend_gap_block(nblock, <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block));

2489

<a name="l02462"></a>02462 }

2490

<a name="l02463"></a>02463 return prev;

2491

<a name="l02464"></a>02464 } else {

2492

<a name="l02465"></a>02465 if (<a class="code" href="a00114.html#gaa7df7193094353ea24b8519debf745be" title="Searches for the next 1 bit in the GAP block.">bm::gap_find_in_block</a>(<a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block),

2493

<a name="l02466"></a>02466 nbit,

2494

<a name="l02467"></a>02467 &prev))

2495

<a name="l02468"></a>02468 {

2496

<a name="l02469"></a>02469 set(prev, false);

2497

<a name="l02470"></a>02470 return prev;

2498

<a name="l02471"></a>02471 }

2499

<a name="l02472"></a>02472 }

2500

<a name="l02473"></a>02473 }

2501

<a name="l02474"></a>02474 else // bit block

2502

<a name="l02475"></a>02475 {

2503

<a name="l02476"></a>02476 if (<a class="code" href="a00115.html#gad6a7c549a625df7aa7d68d43a57238c7" title="Searches for the next 1 bit in the BIT block.">bm::bit_find_in_block</a>(block, nbit, &prev))

2504

<a name="l02477"></a>02477 {

2505

<a name="l02478"></a>02478 <a class="code" href="a00084.html#a809c66152f5967c1a1eb51e006206630">BMCOUNT_DEC</a>

2506

<a name="l02479"></a>02479

2507

<a name="l02480"></a>02480 unsigned nbit =

2508

<a name="l02481"></a>02481 unsigned(prev & <a class="code" href="a00110.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2509

<a name="l02482"></a>02482 unsigned nword =

2510

<a name="l02483"></a>02483 unsigned(nbit >> <a class="code" href="a00110.html#a83d76bccf6fe3770f32d5ba11d2a37ad">bm::set_word_shift</a>);

2511

<a name="l02484"></a>02484 nbit &= <a class="code" href="a00110.html#addbf345be3733d5e4575d71733ed1da8">bm::set_word_mask</a>;

2512

<a name="l02485"></a>02485 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* word = block + nword;

2513

<a name="l02486"></a>02486 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a> mask = ((<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>)1) << nbit;

2514

<a name="l02487"></a>02487 *word &= ~mask;

2515

<a name="l02488"></a>02488

2516

<a name="l02489"></a>02489 return prev;

2517

<a name="l02490"></a>02490 }

2518

<a name="l02491"></a>02491 }

2519

<a name="l02492"></a>02492 }

2520

<a name="l02493"></a>02493 else

2521

<a name="l02494"></a>02494 {

2522

<a name="l02495"></a>02495 prev += (<a class="code" href="a00110.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a> + 1) -

2523

<a name="l02496"></a>02496 (prev & <a class="code" href="a00110.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2524

<a name="l02497"></a>02497 }

2525

<a name="l02498"></a>02498

2526

<a name="l02499"></a>02499 }

2527

<a name="l02500"></a>02500 if (!prev) break;

2528

<a name="l02501"></a>02501 }

2529

<a name="l02502"></a>02502

2530

<a name="l02503"></a>02503 return 0;

2531

<a name="l02504"></a>02504 }

2532

<a name="l02505"></a>02505

2533

<a name="l02506"></a>02506 //---------------------------------------------------------------------

2534

<a name="l02507"></a>02507

2535

<a name="l02508"></a>02508 template<class Alloc, class MS>

2536

<a name="l02509"></a><a class="code" href="a00043.html#af2c137de958a038f96e1149c51ea8a8f">02509</a> void <a class="code" href="a00043.html#af2c137de958a038f96e1149c51ea8a8f">bvector<Alloc, MS>::combine_operation</a>(

2537

<a name="l02510"></a>02510 const <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bm::bvector<Alloc, MS></a>& <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvect</a>,

2538

<a name="l02511"></a>02511 <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1" title="Bit operations enumeration.">bm::operation</a> opcode)

2539

<a name="l02512"></a>02512 {

2540

<a name="l02513"></a>02513 typedef void (*block_bit_op)(<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*, const bm::word_t*);

2541

<a name="l02514"></a>02514 typedef void (*block_bit_op_next)(bm::word_t*,

2542

<a name="l02515"></a>02515 const bm::word_t*,

2543

<a name="l02516"></a>02516 bm::word_t*,

2544

<a name="l02517"></a>02517 const bm::word_t*);

2545

<a name="l02518"></a>02518

2546

<a name="l02519"></a>02519 unsigned top_blocks = blockman_.top_block_size();

2547

<a name="l02520"></a>02520 unsigned bvect_top_blocks = bvect.blockman_.top_block_size();

2548

<a name="l02521"></a>02521

2549

<a name="l02522"></a>02522 if (size_ == bvect.size_)

2550

<a name="l02523"></a>02523 {

2551

<a name="l02524"></a>02524 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(top_blocks >= bvect_top_blocks);

2552

<a name="l02525"></a>02525 }

2553

<a name="l02526"></a>02526 else

2554

<a name="l02527"></a>02527 if (size_ < bvect.size_) // this vect shorter than the arg.

2555

<a name="l02528"></a>02528 {

2556

<a name="l02529"></a>02529 size_ = bvect.size_;

2557

<a name="l02530"></a>02530 // stretch our capacity

2558

<a name="l02531"></a>02531 blockman_.reserve_top_blocks(bvect_top_blocks);

2559

<a name="l02532"></a>02532 top_blocks = blockman_.top_block_size();

2560

<a name="l02533"></a>02533 }

2561

<a name="l02534"></a>02534 else

2562

<a name="l02535"></a>02535 if (size_ > bvect.size_) // this vector larger

2563

<a name="l02536"></a>02536 {

2564

<a name="l02537"></a>02537 if (opcode == <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a546fdf33b301e5b9bee0591522ed9250">BM_AND</a>) // clear the tail with zeros

2565

<a name="l02538"></a>02538 {

2566

<a name="l02539"></a>02539 <a class="code" href="a00043.html#a14bc35b9b022018f10787b07a5b2af04" title="Sets all bits in the specified closed interval [left,right] Interval must be inside...">set_range</a>(bvect.size_, size_ - 1, false);

2567

<a name="l02540"></a>02540 if (bvect_top_blocks < top_blocks)

2568

<a name="l02541"></a>02541 {

2569

<a name="l02542"></a>02542 // not to scan blocks we already swiped

2570

<a name="l02543"></a>02543 top_blocks = bvect_top_blocks;

2571

<a name="l02544"></a>02544 }

2572

<a name="l02545"></a>02545 }

2573

<a name="l02546"></a>02546 }

2574

<a name="l02547"></a>02547

2575

<a name="l02548"></a>02548 bm::word_t*** blk_root = blockman_.blocks_root();

2576

<a name="l02549"></a>02549 unsigned block_idx = 0;

2577

<a name="l02550"></a>02550 unsigned i, j;

2578

<a name="l02551"></a>02551

2579

<a name="l02552"></a>02552 <a class="code" href="a00089.html#a7e6f87ba3230dece2125af5c32e84b05">BM_SET_MMX_GUARD</a>

2580

<a name="l02553"></a>02553

2581

<a name="l02554"></a>02554 // calculate effective top size to avoid overscan

2582

<a name="l02555"></a>02555 top_blocks = blockman_.effective_top_block_size();

2583

<a name="l02556"></a>02556 if (top_blocks < bvect.blockman_.effective_top_block_size())

2584

<a name="l02557"></a>02557 {

2585

<a name="l02558"></a>02558 if (opcode != <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a546fdf33b301e5b9bee0591522ed9250">BM_AND</a>)

2586

<a name="l02559"></a>02559 {

2587

<a name="l02560"></a>02560 top_blocks = bvect.blockman_.effective_top_block_size();

2588

<a name="l02561"></a>02561 }

2589

<a name="l02562"></a>02562 }

2590

<a name="l02563"></a>02563

2591

<a name="l02564"></a>02564 for (i = 0; i < top_blocks; ++i)

2592

<a name="l02565"></a>02565 {

2593

<a name="l02566"></a>02566 bm::word_t** blk_blk = blk_root[i];

2594

<a name="l02567"></a>02567

2595

<a name="l02568"></a>02568 if (blk_blk == 0) // not allocated

2596

<a name="l02569"></a>02569 {

2597

<a name="l02570"></a>02570 if (opcode == <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a546fdf33b301e5b9bee0591522ed9250">BM_AND</a>) // 0 AND anything == 0

2598

<a name="l02571"></a>02571 {

2599

<a name="l02572"></a>02572 block_idx += <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>;

2600

<a name="l02573"></a>02573 continue;

2601

<a name="l02574"></a>02574 }

2602

<a name="l02575"></a>02575 const bm::word_t* const* bvbb = bvect.blockman_.get_topblock(i);

2603

<a name="l02576"></a>02576 if (bvbb == 0) // skip it because 0 OP 0 == 0

2604

<a name="l02577"></a>02577 {

2605

<a name="l02578"></a>02578 block_idx += <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>;

2606

<a name="l02579"></a>02579 continue;

2607

<a name="l02580"></a>02580 }

2608

<a name="l02581"></a>02581 // 0 - self, non-zero argument

2609

<a name="l02582"></a>02582 for (j = 0; j < <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>; ++j,++block_idx)

2610

<a name="l02583"></a>02583 {

2611

<a name="l02584"></a>02584 const bm::word_t* arg_blk =

2612

<a name="l02585"></a>02585 bvect.blockman_.get_block(i, j);

2613

<a name="l02586"></a>02586 if (arg_blk != 0)

2614

<a name="l02587"></a>02587 {

2615

<a name="l02588"></a>02588 bool arg_gap =

2616

<a name="l02589"></a>02589 <a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(bvect.blockman_, arg_blk, block_idx);

2617

<a name="l02590"></a>02590 combine_operation_with_block(block_idx, 0, 0,

2618

<a name="l02591"></a>02591 arg_blk, arg_gap,

2619

<a name="l02592"></a>02592 opcode);

2620

<a name="l02593"></a>02593 }

2621

<a name="l02594"></a>02594

2622

<a name="l02595"></a>02595 } // for j

2623

<a name="l02596"></a>02596 continue;

2624

<a name="l02597"></a>02597 }

2625

<a name="l02598"></a>02598

2626

<a name="l02599"></a>02599 for (j = 0; j < <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>; ++j, ++block_idx)

2627

<a name="l02600"></a>02600 {

2628

<a name="l02601"></a>02601 bm::word_t* blk = blk_blk[j];

2629

<a name="l02602"></a>02602 const bm::word_t* arg_blk = bvect.blockman_.get_block(i, j);

2630

<a name="l02603"></a>02603

2631

<a name="l02604"></a>02604 if (arg_blk || blk)

2632

<a name="l02605"></a>02605 {

2633

<a name="l02606"></a>02606 if (opcode == <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a546fdf33b301e5b9bee0591522ed9250">BM_AND</a>)

2634

<a name="l02607"></a>02607 {

2635

<a name="l02608"></a>02608 if (!blk) continue;

2636

<a name="l02609"></a>02609 if (!arg_blk)

2637

<a name="l02610"></a>02610 {

2638

<a name="l02611"></a>02611 if (blk) blockman_.zero_block(block_idx);

2639

<a name="l02612"></a>02612 continue;

2640

<a name="l02613"></a>02613 }

2641

<a name="l02614"></a>02614 }

2642

<a name="l02615"></a>02615

2643

<a name="l02616"></a>02616 bool arg_gap = <a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(bvect.blockman_, arg_blk, block_idx);

2644

<a name="l02617"></a>02617 bool gap = <a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>((*this).blockman_, blk, block_idx);

2645

<a name="l02618"></a>02618 combine_operation_with_block(block_idx, gap, blk,

2646

<a name="l02619"></a>02619 arg_blk, arg_gap,

2647

<a name="l02620"></a>02620 opcode);

2648

<a name="l02621"></a>02621 }

2649

<a name="l02622"></a>02622

2650

<a name="l02623"></a>02623 } // for j

2651

<a name="l02624"></a>02624

2652

<a name="l02625"></a>02625 } // for i

2653

<a name="l02626"></a>02626

2654

<a name="l02627"></a>02627 }

2655

<a name="l02628"></a>02628

2656

<a name="l02629"></a>02629

2657

<a name="l02630"></a>02630 //---------------------------------------------------------------------

2658

<a name="l02631"></a>02631

2659

<a name="l02632"></a>02632

2660

<a name="l02633"></a>02633 template<class Alloc, class MS>

2661

<a name="l02634"></a>02634 void

2662

<a name="l02635"></a>02635 <a class="code" href="a00043.html" title="bitvector with runtime compression of bits.">bvector<Alloc, MS>::combine_operation_with_block</a>(unsigned nb,

2663

<a name="l02636"></a>02636 unsigned gap,

2664

<a name="l02637"></a>02637 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk,

2665

<a name="l02638"></a>02638 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* arg_blk,

2666

<a name="l02639"></a>02639 int arg_gap,

2667

<a name="l02640"></a>02640 <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1" title="Bit operations enumeration.">bm::operation</a> opcode)

2668

<a name="l02641"></a>02641 {

2669

<a name="l02642"></a>02642 if (!blk && arg_gap && (opcode == <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a0c8cf0197857d0bd73a63037e2f2c5c5">BM_OR</a> || opcode == <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a45c2fe36efb72dc03f03a842d253f64c">BM_XOR</a>))

2670

<a name="l02643"></a>02643 {

2671

<a name="l02644"></a>02644 blk =

2672

<a name="l02645"></a>02645 blockman_.check_allocate_block(nb,

2673

<a name="l02646"></a>02646 0,

2674

<a name="l02647"></a>02647 <a class="code" href="a00113.html#ggad0b87b3b7292383a864d27feaf1c9effa7fe09d1d7c62a813db922c396c0cbc9c" title="GAP compression is ON.">BM_GAP</a>,

2675

<a name="l02648"></a>02648 (int*)&gap,

2676

<a name="l02649"></a>02649 false /*no null return*/);

2677

<a name="l02650"></a>02650 }

2678

<a name="l02651"></a>02651

2679

<a name="l02652"></a>02652 if (gap) // our block GAP-type

2680

<a name="l02653"></a>02653 {

2681

<a name="l02654"></a>02654 if (arg_gap) // both blocks GAP-type

2682

<a name="l02655"></a>02655 {

2683

<a name="l02656"></a>02656 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a> tmp_buf[<a class="code" href="a00110.html#a9b1715d6d9164d56172e75bbbd0e3000">bm::gap_equiv_len</a> * 3]; // temporary result

2684

<a name="l02657"></a>02657 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* res;

2685

<a name="l02658"></a>02658 unsigned res_len;

2686

<a name="l02659"></a>02659

2687

<a name="l02660"></a>02660 <a class="code" href="a00110.html#a8402de852093e5b23b5825f1974b9c12">gap_operation_func_type</a> gfunc =

2688

<a name="l02661"></a>02661 operation_functions<true>::gap_operation(opcode);

2689

<a name="l02662"></a>02662 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(gfunc);

2690

<a name="l02663"></a>02663 res = (*gfunc)(<a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk),

2691

<a name="l02664"></a>02664 <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(arg_blk),

2692

<a name="l02665"></a>02665 tmp_buf,

2693

<a name="l02666"></a>02666 res_len);

2694

<a name="l02667"></a>02667 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(res == tmp_buf);

2695

<a name="l02668"></a>02668 ++res_len;// = bm::gap_length(res);

2696

<a name="l02669"></a>02669

2697

<a name="l02670"></a>02670 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(!(res == tmp_buf && res_len == 0));

2698

<a name="l02671"></a>02671

2699

<a name="l02672"></a>02672 // if as a result of the operation gap block turned to zero

2700

<a name="l02673"></a>02673 // we can now replace it with NULL

2701

<a name="l02674"></a>02674 if (<a class="code" href="a00114.html#ga690ff7c8b16e1821a77663b7194267e7" title="Temporary inverts all bits in the GAP buffer.">gap_is_all_zero</a>(res, <a class="code" href="a00110.html#ad0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a>))

2702

<a name="l02675"></a>02675 {

2703

<a name="l02676"></a>02676 blockman_.zero_block(nb);

2704

<a name="l02677"></a>02677 return;

2705

<a name="l02678"></a>02678 }

2706

<a name="l02679"></a>02679

2707

<a name="l02680"></a>02680 // mutation check

2708

<a name="l02681"></a>02681

2709

<a name="l02682"></a>02682 int level = <a class="code" href="a00114.html#ga1defe73aa4227a0e7204363ac6bb1ac1" title="Returs GAP blocks capacity level.">gap_level</a>(<a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk));

2710

<a name="l02683"></a>02683 unsigned threshold = blockman_.glen(level)-4;

2711

<a name="l02684"></a>02684 int new_level = <a class="code" href="a00114.html#ga3bfaebeeb4b2d479c5a9ac9d57607165" title="Calculates GAP block capacity level.">gap_calc_level</a>(res_len, blockman_.glen());

2712

<a name="l02685"></a>02685

2713

<a name="l02686"></a>02686 if (new_level == -1)

2714

<a name="l02687"></a>02687 {

2715

<a name="l02688"></a>02688 blockman_.convert_gap2bitset(nb, res);

2716

<a name="l02689"></a>02689 return;

2717

<a name="l02690"></a>02690 }

2718

<a name="l02691"></a>02691

2719

<a name="l02692"></a>02692 if (res_len > threshold)

2720

<a name="l02693"></a>02693 {

2721

<a name="l02694"></a>02694 <a class="code" href="a00114.html#ga501aa9bf029e7f9ea9518e7003fe5549" title="Sets GAP block capacity level.">set_gap_level</a>(res, new_level);

2722

<a name="l02695"></a>02695 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* new_blk =

2723

<a name="l02696"></a>02696 blockman_.allocate_gap_block(new_level, res);

2724

<a name="l02697"></a>02697

2725

<a name="l02698"></a>02698 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* p = (<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*)new_blk;

2726

<a name="l02699"></a>02699 <a class="code" href="a00089.html#a93dbdb1a62ca0ce33149d3249dbf386e">BMSET_PTRGAP</a>(p);

2727

<a name="l02700"></a>02700

2728

<a name="l02701"></a>02701 blockman_.set_block_ptr(nb, p);

2729

<a name="l02702"></a>02702 blockman_.get_allocator().free_gap_block(<a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk),

2730

<a name="l02703"></a>02703 blockman_.glen());

2731

<a name="l02704"></a>02704 return;

2732

<a name="l02705"></a>02705 }

2733

<a name="l02706"></a>02706

2734

<a name="l02707"></a>02707 // gap opeartion result is in the temporary buffer

2735

<a name="l02708"></a>02708 // we copy it back to the gap_block

2736

<a name="l02709"></a>02709

2737

<a name="l02710"></a>02710 <a class="code" href="a00114.html#ga501aa9bf029e7f9ea9518e7003fe5549" title="Sets GAP block capacity level.">set_gap_level</a>(tmp_buf, level);

2738

<a name="l02711"></a>02711 ::memcpy(<a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk), tmp_buf, res_len * sizeof(<a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>));

2739

<a name="l02712"></a>02712 return;

2740

<a name="l02713"></a>02713 }

2741

<a name="l02714"></a>02714 else // argument is BITSET-type (own block is GAP)

2742

<a name="l02715"></a>02715 {

2743

<a name="l02716"></a>02716 // since we can not combine blocks of mixed type

2744

<a name="l02717"></a>02717 // we need to convert our block to bitset

2745

<a name="l02718"></a>02718

2746

<a name="l02719"></a>02719 if (arg_blk == 0) // Combining against an empty block

2747

<a name="l02720"></a>02720 {

2748

<a name="l02721"></a>02721 switch (opcode)

2749

<a name="l02722"></a>02722 {

2750

<a name="l02723"></a>02723 case <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a546fdf33b301e5b9bee0591522ed9250">BM_AND</a>: // ("Value" AND 0) == 0

2751

<a name="l02724"></a>02724 blockman_.zero_block(nb);

2752

<a name="l02725"></a>02725 return;

2753

<a name="l02726"></a>02726 case <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a0c8cf0197857d0bd73a63037e2f2c5c5">BM_OR</a>: case <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a1df0f4de7126bb2f7ce69d7a005affb5">BM_SUB</a>: case <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a45c2fe36efb72dc03f03a842d253f64c">BM_XOR</a>:

2754

<a name="l02727"></a>02727 return; // nothing to do

2755

<a name="l02728"></a>02728 }

2756

<a name="l02729"></a>02729 }

2757

<a name="l02730"></a>02730 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* gap_blk = <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk);

2758

<a name="l02731"></a>02731 if (opcode == <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a546fdf33b301e5b9bee0591522ed9250">BM_AND</a>)

2759

<a name="l02732"></a>02732 {

2760

<a name="l02733"></a>02733 unsigned gap_cnt = <a class="code" href="a00114.html#ga570a6f573ffb9ac9e41a688d2bdc6004" title="Calculates number of bits ON in GAP buffer.">gap_bit_count</a>(gap_blk);

2761

<a name="l02734"></a>02734 if (gap_cnt < 128)

2762

<a name="l02735"></a>02735 {

2763

<a name="l02736"></a>02736 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a> tmp_buf[<a class="code" href="a00110.html#a9b1715d6d9164d56172e75bbbd0e3000">bm::gap_equiv_len</a> * 3];

2764

<a name="l02737"></a>02737 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a> arr_len =

2765

<a name="l02738"></a>02738 <a class="code" href="a00114.html#ga5cd7e0cfee401da1b8f702151c083b27" title="Convert gap block into array of ints corresponding to 1 bits.">gap_convert_to_arr</a>(tmp_buf, gap_blk,

2766

<a name="l02739"></a>02739 <a class="code" href="a00110.html#a9b1715d6d9164d56172e75bbbd0e3000">bm::gap_equiv_len</a>-10);

2767

<a name="l02740"></a>02740 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(gap_cnt == arr_len);

2768

<a name="l02741"></a>02741 blockman_.zero_block(nb);

2769

<a name="l02742"></a>02742 unsigned arr_i = 0;

2770

<a name="l02743"></a>02743 int block_type;

2771

<a name="l02744"></a>02744 blk =

2772

<a name="l02745"></a>02745 blockman_.check_allocate_block(nb,

2773

<a name="l02746"></a>02746 true,

2774

<a name="l02747"></a>02747 <a class="code" href="a00113.html#ggad0b87b3b7292383a864d27feaf1c9effa7fe09d1d7c62a813db922c396c0cbc9c" title="GAP compression is ON.">BM_GAP</a>,

2775

<a name="l02748"></a>02748 &block_type,

2776

<a name="l02749"></a>02749 false //no null return

2777

<a name="l02750"></a>02750 );

2778

<a name="l02751"></a>02751 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(block_type==1); // GAP

2779

<a name="l02752"></a>02752 gap_blk = <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk);

2780

<a name="l02753"></a>02753 unsigned threshold = <a class="code" href="a00114.html#ga94a5371b5dc6a1560d95d7c2dde88815" title="Returs GAP block capacity limit.">bm::gap_limit</a>(gap_blk, blockman_.glen());

2781

<a name="l02754"></a>02754 for (; arr_i < arr_len; ++arr_i)

2782

<a name="l02755"></a>02755 {

2783

<a name="l02756"></a>02756 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a> bit_idx = tmp_buf[arr_i];

2784

<a name="l02757"></a>02757 if (<a class="code" href="a00115.html#ga9bccc586aa791f98f1bec284b799102c" title="Test 1 bit in a block.">bm::test_bit</a>(arg_blk, bit_idx))

2785

<a name="l02758"></a>02758 {

2786

<a name="l02759"></a>02759 unsigned is_set;

2787

<a name="l02760"></a>02760 unsigned new_block_len =

2788

<a name="l02761"></a>02761 <a class="code" href="a00114.html#ga69186bd13bda27e04b3e33683ff884c2" title="Abstract distance(similarity) operation for GAP buffers. Receives functor F as a...">gap_set_value</a>(true, gap_blk, bit_idx, &is_set);

2789

<a name="l02762"></a>02762 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(is_set);

2790

<a name="l02763"></a>02763 if (new_block_len > threshold)

2791

<a name="l02764"></a>02764 {

2792

<a name="l02765"></a>02765 gap_blk =

2793

<a name="l02766"></a>02766 blockman_.extend_gap_block(nb, gap_blk);

2794

<a name="l02767"></a>02767 if (gap_blk == 0) // mutated into bit-block

2795

<a name="l02768"></a>02768 {

2796

<a name="l02769"></a>02769 blk = blockman_.check_allocate_block(

2797

<a name="l02770"></a>02770 nb,

2798

<a name="l02771"></a>02771 true,

2799

<a name="l02772"></a>02772 this-><a class="code" href="a00043.html#ad971c541fa259278e9dcf541b2d128c9" title="Returns blocks allocation strategy.">get_new_blocks_strat</a>(),

2800

<a name="l02773"></a>02773 &block_type,

2801

<a name="l02774"></a>02774 false // no null return

2802

<a name="l02775"></a>02775 );

2803

<a name="l02776"></a>02776 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(block_type == 0); // BIT

2804

<a name="l02777"></a>02777 // target block degraded into plain bit-block

2805

<a name="l02778"></a>02778 for (++arr_i; arr_i < arr_len; ++arr_i)

2806

<a name="l02779"></a>02779 {

2807

<a name="l02780"></a>02780 bit_idx = tmp_buf[arr_i];

2808

<a name="l02781"></a>02781 if (<a class="code" href="a00115.html#ga9bccc586aa791f98f1bec284b799102c" title="Test 1 bit in a block.">bm::test_bit</a>(arg_blk, bit_idx))

2809

<a name="l02782"></a>02782 {

2810

<a name="l02783"></a>02783 <a class="code" href="a00115.html#gad698b5242f5b629aa28e7338b7150497" title="Sets bits to 1 in the bitblock.">or_bit_block</a>(blk, bit_idx, 1);

2811

<a name="l02784"></a>02784 }

2812

<a name="l02785"></a>02785 } // for arr_i

2813

<a name="l02786"></a>02786 return;

2814

<a name="l02787"></a>02787 } // if gap mutated

2815

<a name="l02788"></a>02788 }

2816

<a name="l02789"></a>02789 } // for arr_i

2817

<a name="l02790"></a>02790 }

2818

<a name="l02791"></a>02791

2819

<a name="l02792"></a>02792 return;

2820

<a name="l02793"></a>02793 }

2821

<a name="l02794"></a>02794 } // BM_AND

2822

<a name="l02795"></a>02795

2823

<a name="l02796"></a>02796 blk = blockman_.convert_gap2bitset(nb, gap_blk);

2824

<a name="l02797"></a>02797 }

2825

<a name="l02798"></a>02798 }

2826

<a name="l02799"></a>02799 else // our block is BITSET-type

2827

<a name="l02800"></a>02800 {

2828

<a name="l02801"></a>02801 if (arg_gap) // argument block is GAP-type

2829

<a name="l02802"></a>02802 {

2830

<a name="l02803"></a>02803 if (<a class="code" href="a00089.html#a13ba598909515339ceede09e3b9b0198">IS_VALID_ADDR</a>(blk))

2831

<a name="l02804"></a>02804 {

2832

<a name="l02805"></a>02805 // special case, maybe we can do the job without

2833

<a name="l02806"></a>02806 // converting the GAP argument to bitblock

2834

<a name="l02807"></a>02807 <a class="code" href="a00110.html#a18a8f03b151ca3a6d5e39e7709fb6c7c">gap_operation_to_bitset_func_type</a> gfunc =

2835

<a name="l02808"></a>02808 operation_functions<true>::gap_op_to_bit(opcode);

2836

<a name="l02809"></a>02809 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(gfunc);

2837

<a name="l02810"></a>02810 (*gfunc)(blk, <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(arg_blk));

2838

<a name="l02811"></a>02811 return;

2839

<a name="l02812"></a>02812 }

2840

<a name="l02813"></a>02813

2841

<a name="l02814"></a>02814 // the worst case we need to convert argument block to

2842

<a name="l02815"></a>02815 // bitset type.

2843

<a name="l02816"></a>02816 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* temp_blk = (<a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>*) blockman_.check_allocate_tempblock();

2844

<a name="l02817"></a>02817 arg_blk =

2845

<a name="l02818"></a>02818 <a class="code" href="a00114.html#ga3f01bb7c1ae7983aa8c4ba82e1e3f54c" title="Smart GAP block to bitblock conversion.">gap_convert_to_bitset_smart</a>((<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*)temp_blk,

2846

<a name="l02819"></a>02819 <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(arg_blk),

2847

<a name="l02820"></a>02820 <a class="code" href="a00110.html#ad0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a>);

2848

<a name="l02821"></a>02821

2849

<a name="l02822"></a>02822 }

2850

<a name="l02823"></a>02823 }

2851

<a name="l02824"></a>02824

2852

<a name="l02825"></a>02825 // Now here we combine two plain bitblocks using supplied bit function.

2853

<a name="l02826"></a>02826 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* dst = blk;

2854

<a name="l02827"></a>02827

2855

<a name="l02828"></a>02828 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* ret;

2856

<a name="l02829"></a>02829 if (dst == 0 && arg_blk == 0)

2857

<a name="l02830"></a>02830 {

2858

<a name="l02831"></a>02831 return;

2859

<a name="l02832"></a>02832 }

2860

<a name="l02833"></a>02833

2861

<a name="l02834"></a>02834 switch (opcode)

2862

<a name="l02835"></a>02835 {

2863

<a name="l02836"></a>02836 case <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a546fdf33b301e5b9bee0591522ed9250">BM_AND</a>:

2864

<a name="l02837"></a>02837 ret = <a class="code" href="a00115.html#ga869fce5348076d4c7b92adcc2f1a49ab" title="bitblock AND operation.">bit_operation_and</a>(dst, arg_blk);

2865

<a name="l02838"></a>02838 goto copy_block;

2866

<a name="l02839"></a>02839 case <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a45c2fe36efb72dc03f03a842d253f64c">BM_XOR</a>:

2867

<a name="l02840"></a>02840 ret = <a class="code" href="a00115.html#ga179de722e87ccf8189d975ca6beed025" title="bitblock XOR operation.">bit_operation_xor</a>(dst, arg_blk);

2868

<a name="l02841"></a>02841 if (ret && (ret == arg_blk) && <a class="code" href="a00089.html#a074acb37afea68caaffe3832d326eb44">IS_FULL_BLOCK</a>(dst))

2869

<a name="l02842"></a>02842 {

2870

<a name="l02843"></a>02843 ret = blockman_.get_allocator().alloc_bit_block();

2871

<a name="l02844"></a>02844 #ifdef BMVECTOPT

2872

<a name="l02845"></a>02845 <a class="code" href="a00094.html#a9b8caa31ab90cbfbc99b5728352e5456">VECT_XOR_ARR_2_MASK</a>(ret,

2873

<a name="l02846"></a>02846 arg_blk,

2874

<a name="l02847"></a>02847 arg_blk + bm::set_block_size,

2875

<a name="l02848"></a>02848 <a class="code" href="a00110.html#ad81dea46a256b93b2af3568ce409d40b">bm::all_bits_mask</a>);

2876

<a name="l02849"></a>02849 #else

2877

<a name="l02850"></a>02850 <a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>* dst_ptr = (<a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">wordop_t</a>*)ret;

2878

<a name="l02851"></a>02851 const <a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>* wrd_ptr = (<a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">wordop_t</a>*) arg_blk;

2879

<a name="l02852"></a>02852 const <a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>* wrd_end =

2880

<a name="l02853"></a>02853 (<a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">wordop_t</a>*) (arg_blk + bm::set_block_size);

2881

<a name="l02854"></a>02854

2882

<a name="l02855"></a>02855 do

2883

<a name="l02856"></a>02856 {

2884

<a name="l02857"></a>02857 dst_ptr[0] = <a class="code" href="a00110.html#ad81dea46a256b93b2af3568ce409d40b">bm::all_bits_mask</a> ^ wrd_ptr[0];

2885

<a name="l02858"></a>02858 dst_ptr[1] = <a class="code" href="a00110.html#ad81dea46a256b93b2af3568ce409d40b">bm::all_bits_mask</a> ^ wrd_ptr[1];

2886

<a name="l02859"></a>02859 dst_ptr[2] = <a class="code" href="a00110.html#ad81dea46a256b93b2af3568ce409d40b">bm::all_bits_mask</a> ^ wrd_ptr[2];

2887

<a name="l02860"></a>02860 dst_ptr[3] = <a class="code" href="a00110.html#ad81dea46a256b93b2af3568ce409d40b">bm::all_bits_mask</a> ^ wrd_ptr[3];

2888

<a name="l02861"></a>02861

2889

<a name="l02862"></a>02862 dst_ptr+=4;

2890

<a name="l02863"></a>02863 wrd_ptr+=4;

2891

<a name="l02864"></a>02864

2892

<a name="l02865"></a>02865 } while (wrd_ptr < wrd_end);

2893

<a name="l02866"></a>02866 #endif

2894

<a name="l02867"></a>02867 break;

2895

<a name="l02868"></a>02868 }

2896

<a name="l02869"></a>02869 goto copy_block;

2897

<a name="l02870"></a>02870 case <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a0c8cf0197857d0bd73a63037e2f2c5c5">BM_OR</a>:

2898

<a name="l02871"></a>02871 ret = <a class="code" href="a00115.html#ga0e945a9eaae699ad40f63b3f0632e6f9" title="Block OR operation. Makes analysis if block is 0 or FULL.">bit_operation_or</a>(dst, arg_blk);

2899

<a name="l02872"></a>02872 copy_block:

2900

<a name="l02873"></a>02873 if (ret && (ret == arg_blk) && !<a class="code" href="a00089.html#a074acb37afea68caaffe3832d326eb44">IS_FULL_BLOCK</a>(ret))

2901

<a name="l02874"></a>02874 {

2902

<a name="l02875"></a>02875 ret = blockman_.get_allocator().alloc_bit_block();

2903

<a name="l02876"></a>02876 <a class="code" href="a00115.html#ga9090de87d53e7f25eff96c8259b3485c" title="Bitblock copy operation.">bit_block_copy</a>(ret, arg_blk);

2904

<a name="l02877"></a>02877 }

2905

<a name="l02878"></a>02878 break;

2906

<a name="l02879"></a>02879

2907

<a name="l02880"></a>02880 case <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a1df0f4de7126bb2f7ce69d7a005affb5">BM_SUB</a>:

2908

<a name="l02881"></a>02881 ret = <a class="code" href="a00115.html#gad7afa9bce28a376360ca4826960d669f" title="bitblock SUB operation.">bit_operation_sub</a>(dst, arg_blk);

2909

<a name="l02882"></a>02882 if (ret && ret == arg_blk)

2910

<a name="l02883"></a>02883 {

2911

<a name="l02884"></a>02884 ret = blockman_.get_allocator().alloc_bit_block();

2912

<a name="l02885"></a>02885 #ifdef BMVECTOPT

2913

<a name="l02886"></a>02886 <a class="code" href="a00094.html#a7d425b68d8217dc37d33c660e39a61e1">VECT_ANDNOT_ARR_2_MASK</a>(ret,

2914

<a name="l02887"></a>02887 arg_blk,

2915

<a name="l02888"></a>02888 arg_blk + bm::set_block_size,

2916

<a name="l02889"></a>02889 <a class="code" href="a00110.html#ad81dea46a256b93b2af3568ce409d40b">bm::all_bits_mask</a>);

2917

<a name="l02890"></a>02890 #else

2918

<a name="l02891"></a>02891

2919

<a name="l02892"></a>02892 <a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>* dst_ptr = (<a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">wordop_t</a>*)ret;

2920

<a name="l02893"></a>02893 const <a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>* wrd_ptr = (<a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">wordop_t</a>*) arg_blk;

2921

<a name="l02894"></a>02894 const <a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>* wrd_end =

2922

<a name="l02895"></a>02895 (<a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">wordop_t</a>*) (arg_blk + bm::set_block_size);

2923

<a name="l02896"></a>02896

2924

<a name="l02897"></a>02897 do

2925

<a name="l02898"></a>02898 {

2926

<a name="l02899"></a>02899 dst_ptr[0] = <a class="code" href="a00110.html#ad81dea46a256b93b2af3568ce409d40b">bm::all_bits_mask</a> & ~wrd_ptr[0];

2927

<a name="l02900"></a>02900 dst_ptr[1] = <a class="code" href="a00110.html#ad81dea46a256b93b2af3568ce409d40b">bm::all_bits_mask</a> & ~wrd_ptr[1];

2928

<a name="l02901"></a>02901 dst_ptr[2] = <a class="code" href="a00110.html#ad81dea46a256b93b2af3568ce409d40b">bm::all_bits_mask</a> & ~wrd_ptr[2];

2929

<a name="l02902"></a>02902 dst_ptr[3] = <a class="code" href="a00110.html#ad81dea46a256b93b2af3568ce409d40b">bm::all_bits_mask</a> & ~wrd_ptr[3];

2930

<a name="l02903"></a>02903

2931

<a name="l02904"></a>02904 dst_ptr+=4;

2932

<a name="l02905"></a>02905 wrd_ptr+=4;

2933

<a name="l02906"></a>02906

2934

<a name="l02907"></a>02907 } while (wrd_ptr < wrd_end);

2935

<a name="l02908"></a>02908 #endif

2936

<a name="l02909"></a>02909 }

2937

<a name="l02910"></a>02910 break;

2938

<a name="l02911"></a>02911 default:

2939

<a name="l02912"></a>02912 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(0);

2940

<a name="l02913"></a>02913 ret = 0;

2941

<a name="l02914"></a>02914 }

2942

<a name="l02915"></a>02915

2943

<a name="l02916"></a>02916 if (ret != dst) // block mutation

2944

<a name="l02917"></a>02917 {

2945

<a name="l02918"></a>02918 blockman_.set_block(nb, ret);

2946

<a name="l02919"></a>02919 blockman_.get_allocator().free_bit_block(dst);

2947

<a name="l02920"></a>02920 }

2948

<a name="l02921"></a>02921 }

2949

<a name="l02922"></a>02922

2950

<a name="l02923"></a>02923 //---------------------------------------------------------------------

2951

<a name="l02924"></a>02924

2952

<a name="l02925"></a>02925 template<class Alloc, class MS>

2953

<a name="l02926"></a>02926 void bvector<Alloc, MS>::set_range_no_check(<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> left,

2954

<a name="l02927"></a>02927 <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> right,

2955

<a name="l02928"></a>02928 bool value)

2956

<a name="l02929"></a>02929 {

2957

<a name="l02930"></a>02930 // calculate logical number of start and destination blocks

2958

<a name="l02931"></a>02931 unsigned nblock_left = unsigned(left >> <a class="code" href="a00110.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

2959

<a name="l02932"></a>02932 unsigned nblock_right = unsigned(right >> <a class="code" href="a00110.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

2960

<a name="l02933"></a>02933

2961

<a name="l02934"></a>02934 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* block = blockman_.get_block(nblock_left);

2962

<a name="l02935"></a>02935 bool left_gap = <a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nblock_left);

2963

<a name="l02936"></a>02936

2964

<a name="l02937"></a>02937 unsigned nbit_left = unsigned(left & <a class="code" href="a00110.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2965

<a name="l02938"></a>02938 unsigned nbit_right = unsigned(right & <a class="code" href="a00110.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

2966

<a name="l02939"></a>02939

2967

<a name="l02940"></a>02940 unsigned r =

2968

<a name="l02941"></a>02941 (nblock_left == nblock_right) ? nbit_right :(<a class="code" href="a00110.html#ae9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a>-1);

2969

<a name="l02942"></a>02942

2970

<a name="l02943"></a>02943 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">bm::gap_word_t</a> tmp_gap_blk[5] = {0,};

2971

<a name="l02944"></a>02944

2972

<a name="l02945"></a>02945 // Set bits in the starting block

2973

<a name="l02946"></a>02946

2974

<a name="l02947"></a>02947 unsigned nb;

2975

<a name="l02948"></a>02948 if ((nbit_left == 0) && (r == <a class="code" href="a00110.html#ae9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a> - 1)) // full block

2976

<a name="l02949"></a>02949 {

2977

<a name="l02950"></a>02950 nb = nblock_left;

2978

<a name="l02951"></a>02951 }

2979

<a name="l02952"></a>02952 else

2980

<a name="l02953"></a>02953 {

2981

<a name="l02954"></a>02954 <a class="code" href="a00114.html#ga5d49355eb9dd7947699e20f3a2a75ef5" title="Init gap block so it has block in it (can be whole block).">gap_init_range_block</a>(tmp_gap_blk,

2982

<a name="l02955"></a>02955 nbit_left, r, value, <a class="code" href="a00110.html#ae9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a>);

2983

<a name="l02956"></a>02956

2984

<a name="l02957"></a>02957 combine_operation_with_block(nblock_left,

2985

<a name="l02958"></a>02958 left_gap,

2986

<a name="l02959"></a>02959 block,

2987

<a name="l02960"></a>02960 (<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*) tmp_gap_blk,

2988

<a name="l02961"></a>02961 1,

2989

<a name="l02962"></a>02962 value ? <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a0c8cf0197857d0bd73a63037e2f2c5c5">BM_OR</a> : <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a546fdf33b301e5b9bee0591522ed9250">BM_AND</a>);

2990

<a name="l02963"></a>02963

2991

<a name="l02964"></a>02964 if (nblock_left == nblock_right) // in one block

2992

<a name="l02965"></a>02965 return;

2993

<a name="l02966"></a>02966 nb = nblock_left+1;

2994

<a name="l02967"></a>02967 }

2995

<a name="l02968"></a>02968

2996

<a name="l02969"></a>02969 // Set (or clear) all full blocks between left and right

2997

<a name="l02970"></a>02970

2998

<a name="l02971"></a>02971 unsigned nb_to = nblock_right + (nbit_right ==(<a class="code" href="a00110.html#ae9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a>-1));

2999

<a name="l02972"></a>02972

3000

<a name="l02973"></a>02973 if (value)

3001

<a name="l02974"></a>02974 {

3002

<a name="l02975"></a>02975 for (; nb < nb_to; ++nb)

3003

<a name="l02976"></a>02976 {

3004

<a name="l02977"></a>02977 block = blockman_.get_block(nb);

3005

<a name="l02978"></a>02978 if (<a class="code" href="a00089.html#a074acb37afea68caaffe3832d326eb44">IS_FULL_BLOCK</a>(block))

3006

<a name="l02979"></a>02979 continue;

3007

<a name="l02980"></a>02980

3008

<a name="l02981"></a>02981 bool is_gap = <a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nb);

3009

<a name="l02982"></a>02982

3010

<a name="l02983"></a>02983 blockman_.set_block(nb, <a class="code" href="a00089.html#a1365569f85f442c4914a3579f55df99b">FULL_BLOCK_ADDR</a>);

3011

<a name="l02984"></a>02984 blockman_.set_block_bit(nb);

3012

<a name="l02985"></a>02985

3013

<a name="l02986"></a>02986 if (is_gap)

3014

<a name="l02987"></a>02987 {

3015

<a name="l02988"></a>02988 blockman_.get_allocator().free_gap_block(<a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block),

3016

<a name="l02989"></a>02989 blockman_.glen());

3017

<a name="l02990"></a>02990 }

3018

<a name="l02991"></a>02991 else

3019

<a name="l02992"></a>02992 {

3020

<a name="l02993"></a>02993 blockman_.get_allocator().free_bit_block(block);

3021

<a name="l02994"></a>02994 }

3022

<a name="l02995"></a>02995

3023

<a name="l02996"></a>02996 } // for

3024

<a name="l02997"></a>02997 }

3025

<a name="l02998"></a>02998 else // value == 0

3026

<a name="l02999"></a>02999 {

3027

<a name="l03000"></a>03000 for (; nb < nb_to; ++nb)

3028

<a name="l03001"></a>03001 {

3029

<a name="l03002"></a>03002 block = blockman_.get_block(nb);

3030

<a name="l03003"></a>03003 if (block == 0) // nothing to do

3031

<a name="l03004"></a>03004 continue;

3032

<a name="l03005"></a>03005 bool is_gap = <a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nb);

3033

<a name="l03006"></a>03006 blockman_.set_block(nb, 0, false /*bit*/);

3034

<a name="l03007"></a>03007 //blockman_.set_block_bit(nb);

3035

<a name="l03008"></a>03008

3036

<a name="l03009"></a>03009 if (is_gap)

3037

<a name="l03010"></a>03010 {

3038

<a name="l03011"></a>03011 blockman_.get_allocator().free_gap_block(<a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(block),

3039

<a name="l03012"></a>03012 blockman_.glen());

3040

<a name="l03013"></a>03013 }

3041

<a name="l03014"></a>03014 else

3042

<a name="l03015"></a>03015 {

3043

<a name="l03016"></a>03016 blockman_.get_allocator().free_bit_block(block);

3044

<a name="l03017"></a>03017 }

3045

<a name="l03018"></a>03018

3046

<a name="l03019"></a>03019 } // for

3047

<a name="l03020"></a>03020 } // if value else

3048

<a name="l03021"></a>03021

3049

<a name="l03022"></a>03022 if (nb_to > nblock_right)

3050

<a name="l03023"></a>03023 return;

3051

<a name="l03024"></a>03024

3052

<a name="l03025"></a>03025 block = blockman_.get_block(nblock_right);

3053

<a name="l03026"></a>03026 bool right_gap = <a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(blockman_, block, nblock_right);

3054

<a name="l03027"></a>03027

3055

<a name="l03028"></a>03028 <a class="code" href="a00114.html#ga5d49355eb9dd7947699e20f3a2a75ef5" title="Init gap block so it has block in it (can be whole block).">gap_init_range_block</a>(tmp_gap_blk,

3056

<a name="l03029"></a>03029 0, nbit_right, value, <a class="code" href="a00110.html#ae9916f69ced0347d94472d7944ea0e45">bm::bits_in_block</a>);

3057

<a name="l03030"></a>03030

3058

<a name="l03031"></a>03031 combine_operation_with_block(nblock_right,

3059

<a name="l03032"></a>03032 right_gap,

3060

<a name="l03033"></a>03033 block,

3061

<a name="l03034"></a>03034 (<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*) tmp_gap_blk,

3062

<a name="l03035"></a>03035 1,

3063

<a name="l03036"></a>03036 value ? <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a0c8cf0197857d0bd73a63037e2f2c5c5">BM_OR</a> : <a class="code" href="a00110.html#a42405343976ec931388381cea4092bf1a546fdf33b301e5b9bee0591522ed9250">BM_AND</a>);

3064

<a name="l03037"></a>03037

3065

<a name="l03038"></a>03038 }

3066

<a name="l03039"></a>03039

3067

<a name="l03040"></a>03040 //---------------------------------------------------------------------

3068

<a name="l03041"></a>03041

3069

<a name="l03042"></a>03042

3070

<a name="l03043"></a>03043 } // namespace

3071

<a name="l03044"></a>03044

3072

<a name="l03045"></a>03045 #include "<a class="code" href="a00097.html">bmundef.h</a>"

3073

<a name="l03046"></a>03046

3074

<a name="l03047"></a>03047 #ifdef _MSC_VER

3075

<a name="l03048"></a>03048 #pragma warning( default : 4311 4312)

3076

<a name="l03049"></a>03049 #endif

3077

<a name="l03050"></a>03050

3078

<a name="l03051"></a>03051

3079

<a name="l03052"></a>03052 #endif

3080

</pre></div></div>

3081

<hr size="1"/><address style="text-align: right;">Generated on Sun Nov 22 10:49:34 2009 for BitMagic by

3082

3083

3084

</body>

3085

</html>

Older »