00001 //File: $Id$ 00002 // Author: John Wu <John.Wu at ACM.org> 00003 // Lawrence Berkeley National Laboratory 00004 // Copyright 2000-2012 the Regents of the University of California 00005 #ifndef IBIS_IRELIC_H 00006 #define IBIS_IRELIC_H 00007 00008 00009 00010 00011 00012 00013 00014 #if defined(_WIN32) && defined(_MSC_VER) 00015 #pragma warning(disable:4786) // some identifier longer than 256 characters 00016 #endif 00017 #include "index.h" 00018 00021 class ibis::relic : public ibis::index { 00022 public: 00023 virtual ~relic() {clear();}; 00024 relic(const ibis::column* c, const char* f = 0); 00025 relic(const ibis::column* c, uint32_t popu, uint32_t ntpl=0); 00026 relic(const ibis::column* c, uint32_t card, array_t<uint32_t>& ints); 00027 relic(const ibis::column* c, ibis::fileManager::storage* st, 00028 size_t start = 8); 00029 00030 virtual void print(std::ostream& out) const; 00031 virtual int write(const char* dt) const; 00032 virtual int read(const char* idxfile); 00033 virtual int read(ibis::fileManager::storage* st); 00034 virtual long append(const char* dt, const char* df, uint32_t nnew); 00035 00036 virtual long select(const ibis::qContinuousRange&, void*) const; 00037 virtual long select(const ibis::qContinuousRange&, void*, 00038 ibis::bitvector&) const; 00039 00040 using ibis::index::estimate; 00041 using ibis::index::estimateCost; 00042 virtual long evaluate(const ibis::qContinuousRange& expr, 00043 ibis::bitvector& hits) const; 00044 virtual long evaluate(const ibis::qDiscreteRange& expr, 00045 ibis::bitvector& hits) const; 00046 00047 virtual void estimate(const ibis::qContinuousRange& expr, 00048 ibis::bitvector& lower, 00049 ibis::bitvector& upper) const { 00050 (void) evaluate(expr, lower); 00051 upper.clear(); 00052 } 00053 virtual uint32_t estimate(const ibis::qContinuousRange& expr) const; 00056 virtual float undecidable(const ibis::qContinuousRange&, 00057 ibis::bitvector& iffy) const { 00058 iffy.clear(); 00059 return 0.0; 00060 } 00061 virtual void estimate(const ibis::qDiscreteRange& expr, 00062 ibis::bitvector& lower, 00063 ibis::bitvector& upper) const { 00064 evaluate(expr, lower); 00065 upper.clear(); 00066 } 00067 virtual uint32_t estimate(const ibis::qDiscreteRange&) const; 00068 virtual float undecidable(const ibis::qDiscreteRange&, 00069 ibis::bitvector& iffy) const { 00070 iffy.clear(); 00071 return 0.0; 00072 } 00073 00074 virtual double estimateCost(const ibis::qContinuousRange& expr) const; 00075 virtual double estimateCost(const ibis::qDiscreteRange& expr) const; 00076 00079 virtual void estimate(const ibis::relic& idx2, 00080 const ibis::deprecatedJoin& expr, 00081 const ibis::bitvector& mask, 00082 ibis::bitvector64& lower, 00083 ibis::bitvector64& upper) const; 00084 virtual void estimate(const ibis::relic& idx2, 00085 const ibis::deprecatedJoin& expr, 00086 const ibis::bitvector& mask, 00087 const ibis::qRange* const range1, 00088 const ibis::qRange* const range2, 00089 ibis::bitvector64& lower, 00090 ibis::bitvector64& upper) const; 00093 virtual int64_t estimate(const ibis::relic& idx2, 00094 const ibis::deprecatedJoin& expr, 00095 const ibis::bitvector& mask) const; 00096 virtual int64_t estimate(const ibis::relic& idx2, 00097 const ibis::deprecatedJoin& expr, 00098 const ibis::bitvector& mask, 00099 const ibis::qRange* const range1, 00100 const ibis::qRange* const range2) const; 00101 00102 virtual INDEX_TYPE type() const {return RELIC;} 00103 virtual const char* name() const {return "basic";} 00104 // bin boundaries and counts of each bin 00105 virtual void binBoundaries(std::vector<double>& b) const; 00106 virtual void binWeights(std::vector<uint32_t>& b) const; 00107 00108 virtual long getCumulativeDistribution(std::vector<double>& bds, 00109 std::vector<uint32_t>& cts) const; 00110 virtual long getDistribution(std::vector<double>& bds, 00111 std::vector<uint32_t>& cts) const; 00112 virtual double getMin() const {return (vals.empty()?DBL_MAX:vals[0]);} 00113 virtual double getMax() const {return (vals.empty()?-DBL_MAX:vals.back());} 00114 virtual double getSum() const; 00115 00116 virtual void speedTest(std::ostream& out) const; 00117 long append(const ibis::relic& tail); 00118 long append(const array_t<uint32_t>& ind); 00119 array_t<uint32_t>* keys(const ibis::bitvector& mask) const; 00120 00122 template <typename T> 00123 struct valpos { 00125 T val; 00127 bitvector::indexSet ind; 00131 bitvector::word_t j; 00132 00134 valpos<T>() : val(0), j(0) {} 00136 valpos<T>(const T v, const bitvector& b) 00137 : val(v), ind(b.firstIndexSet()), j(0) { 00138 if (ind.nIndices() > 0 && ind.isRange()) 00139 j = *(ind.indices()); 00140 } 00141 00143 bitvector::word_t position() const { 00144 if (ind.isRange()) 00145 return j; 00146 else 00147 return ind.indices()[j]; 00148 } 00149 00151 void next() { 00152 ++ j; 00153 if (ind.isRange()) { 00154 if (j >= ind.indices()[1]) { 00155 ++ ind; 00156 if (ind.nIndices() > 0 && ind.isRange()) 00157 j = ind.indices()[0]; 00158 else 00159 j = 0; 00160 } 00161 } 00162 else if (j >= ind.nIndices()) { 00163 ++ ind; 00164 if (ind.nIndices() > 0 && ind.isRange()) 00165 j = ind.indices()[0]; 00166 else 00167 j = 0; 00168 } 00169 } 00170 }; // valpos 00171 00173 template<typename T> 00174 struct comparevalpos { 00175 bool operator()(const valpos<T>* x, const valpos<T>* y) { 00176 return (x->position() > y->position()); 00177 } 00178 }; // comparevalpos 00179 00180 protected: 00181 // protected member variables 00182 array_t<double> vals; 00183 00184 int write32(int fdes) const; 00185 int write64(int fdes) const; 00186 // protected member functions 00187 uint32_t locate(const double& val) const; 00188 void locate(const ibis::qContinuousRange& expr, 00189 uint32_t& hit0, uint32_t& hit1) const; 00190 00191 // a dummy constructor 00192 relic() : ibis::index() {} 00193 // free current resources, re-initialized all member variables 00194 virtual void clear(); 00195 virtual double computeSum() const; 00196 virtual size_t getSerialSize() const throw(); 00197 00200 template <typename E> 00201 void construct(const array_t<E>& arr); 00203 void construct(const char* f = 0); 00204 00205 long mergeValues(uint32_t, uint32_t, void*) const; 00206 template <typename T> static long 00207 mergeValuesT(const array_t<T>& vs, 00208 const array_t<const bitvector*>& ps, 00209 array_t<T>& res); 00210 00211 template <typename T> struct mappedValues; 00212 00213 private: 00214 // private member functions 00215 int64_t equiJoin(const ibis::relic& idx2, const ibis::bitvector& mask, 00216 ibis::bitvector64& hits) const; 00217 int64_t deprecatedJoin(const ibis::relic& idx2, const ibis::bitvector& mask, 00218 const double& delta, ibis::bitvector64& hits) const; 00219 int64_t compJoin(const ibis::relic& idx2, const ibis::bitvector& mask, 00220 const ibis::math::term& delta, 00221 ibis::bitvector64& hits) const; 00222 00223 int64_t equiJoin(const ibis::relic& idx2, 00224 const ibis::bitvector& mask) const; 00225 int64_t deprecatedJoin(const ibis::relic& idx2, const ibis::bitvector& mask, 00226 const double& delta) const; 00227 int64_t compJoin(const ibis::relic& idx2, const ibis::bitvector& mask, 00228 const ibis::math::term& delta) const; 00229 00230 int64_t equiJoin(const ibis::relic& idx2, const ibis::bitvector& mask, 00231 const ibis::qRange* const range1, 00232 const ibis::qRange* const range2, 00233 ibis::bitvector64& hits) const; 00234 int64_t deprecatedJoin(const ibis::relic& idx2, const ibis::bitvector& mask, 00235 const ibis::qRange* const range1, 00236 const ibis::qRange* const range2, 00237 const double& delta, ibis::bitvector64& hits) const; 00240 int64_t compJoin(const ibis::relic& idx2, const ibis::bitvector& mask, 00241 const ibis::qRange* const range1, 00242 const ibis::qRange* const range2, 00243 const ibis::math::term& delta, 00244 ibis::bitvector64& hits) const { 00245 return compJoin(idx2, mask, delta, hits); 00246 } 00247 00248 int64_t equiJoin(const ibis::relic& idx2, 00249 const ibis::bitvector& mask, 00250 const ibis::qRange* const range1, 00251 const ibis::qRange* const range2) const; 00252 int64_t deprecatedJoin(const ibis::relic& idx2, const ibis::bitvector& mask, 00253 const ibis::qRange* const range1, 00254 const ibis::qRange* const range2, 00255 const double& delta) const; 00258 int64_t compJoin(const ibis::relic& idx2, const ibis::bitvector& mask, 00259 const ibis::qRange* const range1, 00260 const ibis::qRange* const range2, 00261 const ibis::math::term& delta) const { 00262 return compJoin(idx2, mask, delta); 00263 } 00264 00265 relic(const relic&); 00266 relic& operator=(const relic&); 00267 }; // ibis::relic 00268 00270 class ibis::slice : public ibis::relic { 00271 public: 00272 virtual ~slice() {clear();}; 00273 slice(const ibis::column* c = 0, const char* f = 0); 00274 slice(const ibis::column* c, ibis::fileManager::storage* st, 00275 size_t start = 8); 00276 00277 virtual int write(const char* dt) const; 00278 virtual void print(std::ostream& out) const; 00279 virtual int read(const char* idxfile); 00280 virtual int read(ibis::fileManager::storage* st); 00281 00282 virtual long append(const char* dt, const char* df, uint32_t nnew); 00283 00284 virtual long select(const ibis::qContinuousRange&, void*) const { 00285 return -1;} 00286 virtual long select(const ibis::qContinuousRange&, void*, 00287 ibis::bitvector&) const { 00288 return -1;} 00289 00290 using ibis::relic::estimate; 00291 using ibis::relic::estimateCost; 00292 virtual long evaluate(const ibis::qContinuousRange& expr, 00293 ibis::bitvector& hits) const; 00294 virtual long evaluate(const ibis::qDiscreteRange& expr, 00295 ibis::bitvector& hits) const; 00296 00297 virtual void estimate(const ibis::qContinuousRange& expr, 00298 ibis::bitvector& lower, 00299 ibis::bitvector& upper) const; 00300 virtual uint32_t estimate(const ibis::qContinuousRange& expr) const; 00301 virtual INDEX_TYPE type() const {return SLICE;} 00302 virtual const char* name() const {return "bit-sliced";} 00303 // number of records in each bin 00304 virtual void binWeights(std::vector<uint32_t>& b) const; 00305 virtual double getSum() const; 00306 00307 virtual void speedTest(std::ostream& out) const; 00308 virtual double estimateCost(const ibis::qContinuousRange&) const { 00309 double ret; 00310 if (offset64.size() > bits.size()) 00311 ret = offset64.back(); 00312 else if (offset32.size() > bits.size()) 00313 ret = offset32.back(); 00314 else 00315 ret = 0.0; 00316 return ret; 00317 } 00318 virtual double estimateCost(const ibis::qDiscreteRange& expr) const { 00319 double ret; 00320 if (offset64.size() > bits.size()) 00321 ret = offset64.back(); 00322 else if (offset32.size() > bits.size()) 00323 ret = offset32.back(); 00324 else 00325 ret = 0.0; 00326 return ret; 00327 } 00328 00329 protected: 00330 virtual void clear(); 00331 virtual size_t getSerialSize() const throw(); 00332 00333 private: 00334 // private member variables 00335 array_t<uint32_t> cnts; // the counts for each distinct value 00336 00337 // private member functions 00338 void construct1(const char* f = 0); // uses more temporary storage 00339 void construct2(const char* f = 0); // passes through data twice 00340 void setBit(const uint32_t i, const double val); 00341 00342 int write32(int fdes) const; 00343 int write64(int fdes) const; 00344 void evalGE(ibis::bitvector& res, uint32_t b) const; 00345 void evalEQ(ibis::bitvector& res, uint32_t b) const; 00346 00347 slice(const slice&); 00348 slice& operator=(const slice&); 00349 }; // ibis::slice 00350 00353 class ibis::fade : public ibis::relic { 00354 public: 00355 virtual ~fade() {clear();}; 00356 fade(const ibis::column* c = 0, const char* f = 0, 00357 const uint32_t nbase = 2); 00358 fade(const ibis::column* c, ibis::fileManager::storage* st, 00359 size_t start = 8); 00360 00361 virtual int write(const char* dt) const; 00362 virtual void print(std::ostream& out) const; 00363 virtual int read(const char* idxfile); 00364 virtual int read(ibis::fileManager::storage* st); 00365 00366 virtual long append(const char* dt, const char* df, uint32_t nnew); 00367 00368 virtual long select(const ibis::qContinuousRange&, void*) const { 00369 return -1;} 00370 virtual long select(const ibis::qContinuousRange&, void*, 00371 ibis::bitvector&) const { 00372 return -1;} 00373 00374 using ibis::relic::estimate; 00375 using ibis::relic::estimateCost; 00376 virtual long evaluate(const ibis::qContinuousRange& expr, 00377 ibis::bitvector& hits) const; 00378 virtual long evaluate(const ibis::qDiscreteRange& expr, 00379 ibis::bitvector& hits) const; 00380 00381 virtual uint32_t estimate(const ibis::qContinuousRange& expr) const; 00382 virtual INDEX_TYPE type() const {return FADE;} 00383 virtual const char* name() const {return "multi-level range";} 00384 00385 virtual void speedTest(std::ostream& out) const; 00386 // number of records in each bin 00387 virtual void binWeights(std::vector<uint32_t>& b) const; 00388 virtual double getSum() const; 00389 virtual double estimateCost(const ibis::qContinuousRange& expr) const; 00390 //virtual double estimateCost(const ibis::qDiscreteRange& expr) const; 00391 00392 protected: 00393 // protected member variables 00394 array_t<uint32_t> cnts; // the counts for each distinct value 00395 array_t<uint32_t> bases;// the values of the bases used 00396 00397 // protected member functions to be used by derived classes 00398 int write32(int fdes) const; 00399 int write64(int fdes) const; 00400 virtual void clear(); 00401 virtual size_t getSerialSize() const throw(); 00402 00403 private: 00404 // private member functions 00405 void setBit(const uint32_t i, const double val); 00406 void construct1(const char* f = 0, const uint32_t nbase = 2); 00407 void construct2(const char* f = 0, const uint32_t nbase = 2); 00408 00409 void evalEQ(ibis::bitvector& res, uint32_t b) const; 00410 void evalLE(ibis::bitvector& res, uint32_t b) const; 00411 void evalLL(ibis::bitvector& res, uint32_t b0, uint32_t b1) const; 00412 00413 fade(const fade&); 00414 fade& operator=(const fade&); 00415 }; // ibis::fade 00416 00419 class ibis::sbiad : public ibis::fade { 00420 public: 00421 virtual ~sbiad() {clear();}; 00422 sbiad(const ibis::column* c = 0, const char* f = 0, 00423 const uint32_t nbase = 2); 00424 sbiad(const ibis::column* c, ibis::fileManager::storage* st, 00425 size_t start = 8); 00426 00427 virtual int write(const char* dt) const; 00428 virtual void print(std::ostream& out) const; 00429 virtual long append(const char* dt, const char* df, uint32_t nnew); 00430 00431 virtual long evaluate(const ibis::qContinuousRange& expr, 00432 ibis::bitvector& hits) const; 00433 virtual long evaluate(const ibis::qDiscreteRange& expr, 00434 ibis::bitvector& hits) const; 00435 00436 virtual INDEX_TYPE type() const {return SBIAD;} 00437 virtual const char* name() const {return "multi-level interval";} 00438 00439 virtual void speedTest(std::ostream& out) const; 00440 //virtual double estimateCost(const ibis::qContinuousRange& expr) const; 00441 //virtual double estimateCost(const ibis::qDiscreteRange& expr) const; 00442 00443 private: 00444 // private member functions 00445 void setBit(const uint32_t i, const double val); 00446 void construct1(const char* f = 0, const uint32_t nbase = 2); 00447 void construct2(const char* f = 0, const uint32_t nbase = 2); 00448 00449 void evalEQ(ibis::bitvector& res, uint32_t b) const; 00450 void evalLE(ibis::bitvector& res, uint32_t b) const; 00451 void evalLL(ibis::bitvector& res, uint32_t b0, uint32_t b1) const; 00452 00453 sbiad(const sbiad&); 00454 sbiad& operator=(const sbiad&); 00455 }; // ibis::sbiad 00456 00458 class ibis::sapid : public ibis::fade { 00459 public: 00460 virtual ~sapid() {clear();}; 00461 sapid(const ibis::column* c = 0, const char* f = 0, 00462 const uint32_t nbase = 2); 00463 sapid(const ibis::column* c, ibis::fileManager::storage* st, 00464 size_t start = 8); 00465 00466 virtual int write(const char* dt) const; 00467 virtual void print(std::ostream& out) const; 00468 virtual long append(const char* dt, const char* df, uint32_t nnew); 00469 00470 virtual long evaluate(const ibis::qContinuousRange& expr, 00471 ibis::bitvector& hits) const; 00472 virtual long evaluate(const ibis::qDiscreteRange& expr, 00473 ibis::bitvector& hits) const; 00474 00475 virtual INDEX_TYPE type() const {return SAPID;} 00476 virtual const char* name() const {return "multi-level equality";} 00477 00478 virtual void speedTest(std::ostream& out) const; 00479 //virtual double estimateCost(const ibis::qContinuousRange& expr) const; 00480 //virtual double estimateCost(const ibis::qDiscreteRange& expr) const; 00481 00482 private: 00483 // private member functions 00484 void setBit(const uint32_t i, const double val); 00485 void construct1(const char* f = 0, const uint32_t nbase = 2); 00486 void construct2(const char* f = 0, const uint32_t nbase = 2); 00487 00488 void addBits_(uint32_t ib, uint32_t ie, ibis::bitvector& res) const; 00489 void evalEQ(ibis::bitvector& res, uint32_t b) const; 00490 void evalLE(ibis::bitvector& res, uint32_t b) const; 00491 void evalLL(ibis::bitvector& res, uint32_t b0, uint32_t b1) const; 00492 00493 sapid(const sapid&); 00494 sapid& operator=(const sapid&); 00495 }; // ibis::sapid 00496 00501 class ibis::fuzz : public ibis::relic { 00502 public: 00503 virtual ~fuzz() {clear();}; 00504 fuzz(const ibis::column* c = 0, const char* f = 0); 00505 fuzz(const ibis::column* c, ibis::fileManager::storage* st, 00506 size_t start = 8); 00507 00508 virtual int write(const char* dt) const; 00509 virtual void print(std::ostream& out) const; 00510 virtual int read(const char* idxfile); 00511 virtual int read(ibis::fileManager::storage* st); 00512 00513 virtual long append(const char* dt, const char* df, uint32_t nnew); 00514 00515 using ibis::relic::evaluate; 00516 using ibis::relic::estimate; 00517 using ibis::relic::estimateCost; 00518 virtual long evaluate(const ibis::qContinuousRange& expr, 00519 ibis::bitvector& hits) const; 00520 virtual uint32_t estimate(const ibis::qContinuousRange& expr) const; 00521 virtual double estimateCost(const ibis::qContinuousRange& expr) const; 00522 00523 virtual INDEX_TYPE type() const {return FUZZ;} 00524 virtual const char* name() const {return "interval-equality";} 00525 00526 protected: 00527 virtual void clear(); 00528 virtual size_t getSerialSize() const throw(); 00529 00530 private: 00534 mutable array_t<bitvector*> cbits; 00535 array_t<uint32_t> cbounds; 00536 mutable array_t<int32_t> coffset32; 00537 mutable array_t<int64_t> coffset64; 00538 00539 void coarsen(); // given fine level, add coarse level 00540 void activateCoarse() const; // activate all coarse level bitmaps 00541 void activateCoarse(uint32_t i) const; // activate one bitmap 00542 void activateCoarse(uint32_t i, uint32_t j) const; 00543 00544 int writeCoarse32(int fdes) const; 00545 int writeCoarse64(int fdes) const; 00546 int readCoarse(const char *fn); 00547 void clearCoarse(); 00548 00550 long coarseEstimate(uint32_t lo, uint32_t hi) const; 00552 long coarseEvaluate(uint32_t lo, uint32_t hi, ibis::bitvector& res) const; 00553 00554 fuzz(const fuzz&); 00555 fuzz& operator=(const fuzz&); 00556 }; // ibis::fuzz 00557 00562 class ibis::bylt : public ibis::relic { 00563 public: 00564 virtual ~bylt() {clear();}; 00565 bylt(const ibis::column* c = 0, const char* f = 0); 00566 bylt(const ibis::column* c, ibis::fileManager::storage* st, 00567 size_t start = 8); 00568 00569 virtual int write(const char* dt) const; 00570 virtual void print(std::ostream& out) const; 00571 virtual int read(const char* idxfile); 00572 virtual int read(ibis::fileManager::storage* st); 00573 00574 virtual long append(const char* dt, const char* df, uint32_t nnew); 00575 00576 using ibis::relic::evaluate; 00577 using ibis::relic::estimate; 00578 using ibis::relic::estimateCost; 00579 virtual long evaluate(const ibis::qContinuousRange& expr, 00580 ibis::bitvector& hits) const; 00581 virtual uint32_t estimate(const ibis::qContinuousRange& expr) const; 00582 virtual double estimateCost(const ibis::qContinuousRange& expr) const; 00583 00584 virtual INDEX_TYPE type() const {return BYLT;} 00585 virtual const char* name() const {return "range-equality";} 00586 00587 protected: 00588 virtual void clear(); 00589 virtual size_t getSerialSize() const throw(); 00590 00591 private: 00592 // the fine level is stored in ibis::relic, the parent class, only the 00593 // coarse bins are stored here. The coarse bins use integer bin 00594 // boundaries; these integers are indices to the array vals and bits. 00595 mutable array_t<bitvector*> cbits; 00596 array_t<uint32_t> cbounds; 00597 mutable array_t<int32_t> coffset32; 00598 mutable array_t<int64_t> coffset64; 00599 00600 void coarsen(); // given fine level, add coarse level 00601 void activateCoarse() const; // activate all coarse level bitmaps 00602 void activateCoarse(uint32_t i) const; // activate one bitmap 00603 void activateCoarse(uint32_t i, uint32_t j) const; 00604 00605 int writeCoarse32(int fdes) const; 00606 int writeCoarse64(int fdes) const; 00607 int readCoarse(const char *fn); 00608 00609 bylt(const bylt&); 00610 bylt& operator=(const bylt&); 00611 }; // ibis::bylt 00612 00617 class ibis::zona : public ibis::relic { 00618 public: 00619 virtual ~zona() {clear();}; 00620 zona(const ibis::column* c = 0, const char* f = 0); 00621 zona(const ibis::column* c, ibis::fileManager::storage* st, 00622 size_t start = 8); 00623 00624 virtual int write(const char* dt) const; 00625 virtual void print(std::ostream& out) const; 00626 virtual int read(const char* idxfile); 00627 virtual int read(ibis::fileManager::storage* st); 00628 00629 virtual long append(const char* dt, const char* df, uint32_t nnew); 00630 00631 using ibis::relic::evaluate; 00632 using ibis::relic::estimate; 00633 using ibis::relic::estimateCost; 00634 virtual long evaluate(const ibis::qContinuousRange& expr, 00635 ibis::bitvector& hits) const; 00636 virtual uint32_t estimate(const ibis::qContinuousRange& expr) const; 00637 virtual double estimateCost(const ibis::qContinuousRange& expr) const; 00638 00639 virtual INDEX_TYPE type() const {return ZONA;} 00640 virtual const char* name() const {return "equality-equality";} 00641 00642 protected: 00643 virtual void clear(); 00644 virtual size_t getSerialSize() const throw(); 00645 00646 private: 00647 // the fine level is stored in ibis::relic, the parent class, only the 00648 // coarse bins are stored here. The coarse bins use integer bin 00649 // boundaries; these integers are indices to the array vals and bits. 00650 mutable array_t<bitvector*> cbits; 00651 array_t<uint32_t> cbounds; 00652 mutable array_t<int32_t> coffset32; 00653 mutable array_t<int64_t> coffset64; 00654 00655 void coarsen(); // given fine level, add coarse level 00656 void activateCoarse() const; // activate all coarse level bitmaps 00657 void activateCoarse(uint32_t i) const; // activate one bitmap 00658 void activateCoarse(uint32_t i, uint32_t j) const; 00659 00660 int writeCoarse32(int fdes) const; 00661 int writeCoarse64(int fdes) const; 00662 int readCoarse(const char *fn); 00663 00664 zona(const zona&); 00665 zona& operator=(const zona&); 00666 }; // ibis::zona 00667 00670 template <typename T> 00671 struct ibis::relic::mappedValues { 00672 }; // ibis::relic::mappedValues 00673 #endif // IBIS_IRELIC_H
![]() |