colValues.h Source File (ibis1.3.0)

Go to the documentation of this file.
00001 // File: $Id$
00002 // Author: John Wu <John.Wu at nersc.gov> Lawrence Berkeley National Laboratory
00003 // Copyright 2000-2012 the Regents of the University of California
00004 #ifndef IBIS_COLVALUES_H
00005 #define IBIS_COLVALUES_H
00006 #include "column.h"
00007 #include "utilidor.h"   // ibis::util::reorder
00008 
00011 
00014 class FASTBIT_CXX_DLLSPEC ibis::colValues {
00015 public:
00016     virtual ~colValues() {}
00017 
00019     static colValues* create(const ibis::column* c,
00020                              const ibis::bitvector& hits);
00022     static colValues* create(const ibis::column* c,
00023                              ibis::fileManager::storage* store,
00024                              const uint32_t start, const uint32_t end);
00026     static colValues* create(const ibis::column* c);
00027 
00029     const ibis::column* operator->() const {return col;}
00030     const ibis::column* columnPointer() const {return col;}
00032     const char* name() const {return(col!=0?col->name():0);}
00033 
00034     virtual bool empty() const = 0;
00035     virtual void reduce(const array_t<uint32_t>& starts) = 0;
00036     virtual void reduce(const array_t<uint32_t>& starts,
00037                         ibis::selectClause::AGREGADO func) = 0;
00038     virtual void erase(uint32_t i, uint32_t j) = 0;
00039     virtual void swap(uint32_t i, uint32_t j) = 0;
00040     virtual uint32_t size() const = 0;
00041     virtual uint32_t elementSize() const = 0;
00043     virtual ibis::TYPE_T getType() const =0;
00045     virtual void* getArray() const =0;
00047     virtual void nosharing() =0;
00048 
00049     bool canSort() const
00050     {return (col ? col->type() != ibis::TEXT : false);}
00051 
00052     void swap(colValues& rhs) { // swap two colValues
00053         const ibis::column* c = rhs.col;
00054         rhs.col = col;
00055         col = c;
00056     }
00057 
00059     virtual uint32_t write(FILE* fptr) const  = 0;
00061     virtual void write(std::ostream& out, uint32_t i) const = 0;
00062 
00064     virtual void sort(uint32_t i, uint32_t j, bundle* bdl) = 0;
00067     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00068                       colList::iterator head, colList::iterator tail) = 0;
00071     virtual void sort(uint32_t i, uint32_t j,
00072                       array_t<uint32_t>& neworder) const = 0;
00075     virtual void reorder(const array_t<uint32_t>& ind) = 0;
00078     virtual array_t<uint32_t>*
00079     segment(const array_t<uint32_t>* old=0) const = 0;
00081     virtual long truncate(uint32_t keep) = 0;
00083     virtual long truncate(uint32_t keep, uint32_t start) = 0;
00085     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const = 0;
00087     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const = 0;
00088 
00089     virtual double getMin() const = 0;
00090     virtual double getMax() const = 0;
00091     virtual double getSum() const = 0;
00092     virtual int32_t getInt(uint32_t) const = 0;
00093     virtual uint32_t getUInt(uint32_t) const = 0;
00094     virtual int64_t getLong(uint32_t) const = 0;
00095     virtual uint64_t getULong(uint32_t) const = 0;
00096     virtual float getFloat(uint32_t) const = 0;
00097     virtual double getDouble(uint32_t) const = 0;
00098 
00099 protected:
00100     const ibis::column* col; 
00101 
00102     colValues() : col(0) {}
00103     colValues(const ibis::column* c) : col(c) {};
00104 
00105 private:
00106     colValues& operator=(const colValues&);
00107 }; // ibis::colValues
00108 
00110 class FASTBIT_CXX_DLLSPEC ibis::colInts : public ibis::colValues {
00111 public:
00112     colInts() : colValues(), array(0) {};
00113     colInts(const ibis::column* c, const ibis::bitvector& hits)
00114         : colValues(c), array(c->selectInts(hits)) {}
00115     colInts(const ibis::column* c, ibis::fileManager::storage* store,
00116             const uint32_t start, const uint32_t nelm)
00117         : colValues(c), array(new array_t<int32_t>(store, start, nelm)) {}
00118     colInts(const ibis::column* c);
00119     virtual ~colInts() {delete array;}
00120 
00121     virtual bool   empty() const {return (col==0 || array==0);}
00122     virtual uint32_t size() const {return (array ? array->size() : 0);}
00123     virtual uint32_t elementSize() const {return sizeof(int32_t);}
00124     virtual ibis::TYPE_T getType() const {return ibis::INT;}
00125     virtual void* getArray() const {return array;}
00126     virtual void nosharing() {array->nosharing();}
00127 
00128     virtual void   reduce(const array_t<uint32_t>& starts);
00129     virtual void   reduce(const array_t<uint32_t>& starts,
00130                           ibis::selectClause::AGREGADO func);
00131     virtual void   erase(uint32_t i, uint32_t j) {
00132         array->erase(array->begin()+i, array->begin()+j);}
00133     virtual void   swap(uint32_t i, uint32_t j) {
00134         int32_t tmp = (*array)[i];
00135         (*array)[i] = (*array)[j];
00136         (*array)[j] = tmp;}
00137 
00138     void swap(colInts& rhs) { // swap two colInts
00139         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00140         array_t<int32_t>* a = rhs.array; rhs.array = array; array = a;}
00141 
00142     // write out whole array as binary
00143     virtual uint32_t write(FILE* fptr) const {
00144         if (array) {
00145             uint32_t nelm = array->size();
00146             return nelm - fwrite(array->begin(), sizeof(int32_t), nelm, fptr);
00147         }
00148         else {
00149             return 0;
00150         }
00151     }
00152     // write ith element as text
00153     virtual void write(std::ostream& out, uint32_t i) const
00154     {out << (*array)[i];}
00155 
00156     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00157     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00158                       colList::iterator head, colList::iterator tail);
00159     virtual void sort(uint32_t i, uint32_t j,
00160                       array_t<uint32_t>& neworder) const;
00161     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00162     virtual void reorder(const array_t<uint32_t>& ind)
00163     {ibis::util::reorder(*array, ind);}
00164     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00165     {array->topk(k, ind);}
00166     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00167     {array->bottomk(k, ind);}
00168     virtual long truncate(uint32_t keep);
00169     virtual long truncate(uint32_t keep, uint32_t start);
00170 
00171     virtual double getMin() const;
00172     virtual double getMax() const;
00173     virtual double getSum() const;
00174     virtual int32_t getInt(uint32_t i) const {return (*array)[i];}
00175     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00176     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00177     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00178     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00179     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00180 
00181 private:
00182     array_t<int32_t>* array;
00183 
00184     colInts(const colInts&);
00185     colInts& operator=(const colInts&);
00186 }; // ibis::colInts
00187 
00189 class FASTBIT_CXX_DLLSPEC ibis::colUInts : public ibis::colValues {
00190 public:
00191     colUInts() : colValues(), array(0), dic(0) {};
00192     colUInts(const ibis::column* c, const ibis::bitvector& hits);
00193     colUInts(const ibis::column* c, ibis::fileManager::storage* store,
00194              const uint32_t start, const uint32_t nelm);
00195     colUInts(const ibis::column* c);
00196     virtual ~colUInts() {delete array;}
00197 
00198     virtual bool   empty() const {return (col==0 || array==0);}
00199     virtual uint32_t size() const {return (array ? array->size() : 0);}
00200     virtual uint32_t elementSize() const {return sizeof(uint32_t);}
00201     virtual ibis::TYPE_T getType() const {return ibis::UINT;}
00202     virtual void* getArray() const {return array;}
00203     virtual void nosharing() {array->nosharing();}
00204 
00205     virtual void   erase(uint32_t i, uint32_t j) {
00206         array->erase(array->begin()+i, array->begin()+j);}
00207     virtual void   swap(uint32_t i, uint32_t j) {
00208         uint32_t tmp = (*array)[i];
00209         (*array)[i] = (*array)[j];
00210         (*array)[j] = tmp;}
00211 
00212     virtual void   reduce(const array_t<uint32_t>& starts);
00213     virtual void   reduce(const array_t<uint32_t>& starts,
00214                           ibis::selectClause::AGREGADO func);
00215     void swap(colUInts& rhs) { // swap two colUInts
00216         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00217         array_t<uint32_t>* a = rhs.array; rhs.array = array; array = a;}
00218 
00219     virtual uint32_t write(FILE* fptr) const;
00220     virtual void write(std::ostream& out, uint32_t i) const;
00221 
00222     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00223     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00224                       colList::iterator head, colList::iterator tail);
00225     virtual void sort(uint32_t i, uint32_t j,
00226                       array_t<uint32_t>& neworder) const;
00227     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00228     virtual void reorder(const array_t<uint32_t>& ind)
00229     {ibis::util::reorder(*array, ind);}
00230     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00231     {array->topk(k, ind);}
00232     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00233     {array->bottomk(k, ind);}
00234     virtual long truncate(uint32_t keep);
00235     virtual long truncate(uint32_t keep, uint32_t start);
00236 
00237     virtual double getMin() const;
00238     virtual double getMax() const;
00239     virtual double getSum() const;
00240     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00241     virtual uint32_t getUInt(uint32_t i) const {return (*array)[i];}
00242     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00243     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00244     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00245     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00246 
00247 private:
00248     array_t<uint32_t>* array;
00249     const dictionary* dic;
00250 
00251     colUInts(const colUInts&);
00252     colUInts& operator=(const colUInts&);
00253 }; // ibis::colUInts
00254 
00256 class FASTBIT_CXX_DLLSPEC ibis::colLongs : public ibis::colValues {
00257 public:
00258     colLongs() : colValues(), array(0) {};
00259     colLongs(const ibis::column* c, const ibis::bitvector& hits)
00260         : colValues(c), array(c->selectLongs(hits)) {}
00261     colLongs(const ibis::column* c, ibis::fileManager::storage* store,
00262             const uint32_t start, const uint32_t nelm)
00263         : colValues(c), array(new array_t<int64_t>(store, start, nelm)) {}
00264     colLongs(const ibis::column* c);
00265     virtual ~colLongs() {delete array;}
00266 
00267     virtual bool   empty() const {return (col==0 || array==0);}
00268     virtual uint32_t size() const {return (array ? array->size() : 0);}
00269     virtual uint32_t elementSize() const {return sizeof(int64_t);}
00270     virtual ibis::TYPE_T getType() const {return ibis::LONG;}
00271     virtual void* getArray() const {return array;}
00272     virtual void nosharing() {array->nosharing();}
00273 
00274     virtual void   reduce(const array_t<uint32_t>& starts);
00275     virtual void   reduce(const array_t<uint32_t>& starts,
00276                           ibis::selectClause::AGREGADO func);
00277     virtual void   erase(uint32_t i, uint32_t j) {
00278         array->erase(array->begin()+i, array->begin()+j);}
00279     virtual void   swap(uint32_t i, uint32_t j) {
00280         int64_t tmp = (*array)[i];
00281         (*array)[i] = (*array)[j];
00282         (*array)[j] = tmp;}
00283 
00284     void swap(colLongs& rhs) { // swap two colLongs
00285         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00286         array_t<int64_t>* a = rhs.array; rhs.array = array; array = a;}
00287 
00288     // write out whole array as binary
00289     virtual uint32_t write(FILE* fptr) const {
00290         if (array) {
00291             uint32_t nelm = array->size();
00292             return nelm - fwrite(array->begin(), sizeof(int64_t), nelm, fptr);
00293         }
00294         else {
00295             return 0;
00296         }
00297     }
00298     // write ith element as text
00299     virtual void write(std::ostream& out, uint32_t i) const
00300     {out << (*array)[i];}
00301 
00302     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00303     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00304                       colList::iterator head, colList::iterator tail);
00305     virtual void sort(uint32_t i, uint32_t j,
00306                       array_t<uint32_t>& neworder) const;
00307     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00308     virtual void reorder(const array_t<uint32_t>& ind)
00309     {ibis::util::reorder(*array, ind);}
00310     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00311     {array->topk(k, ind);}
00312     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00313     {array->bottomk(k, ind);}
00314     virtual long truncate(uint32_t keep);
00315     virtual long truncate(uint32_t keep, uint32_t start);
00316 
00317     virtual double getMin() const;
00318     virtual double getMax() const;
00319     virtual double getSum() const;
00320     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00321     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00322     virtual int64_t getLong(uint32_t i) const {return (*array)[i];}
00323     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00324     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00325     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00326 
00327 private:
00328     array_t<int64_t>* array;
00329 
00330     colLongs(const colLongs&);
00331     colLongs& operator=(const colLongs&);
00332 }; // ibis::colLongs
00333 
00335 class FASTBIT_CXX_DLLSPEC ibis::colULongs : public ibis::colValues {
00336 public:
00337     colULongs() : colValues(), array(0) {};
00338     colULongs(const ibis::column* c, const ibis::bitvector& hits)
00339         : colValues(c), array(c->selectULongs(hits)) {}
00340     colULongs(const ibis::column* c, ibis::fileManager::storage* store,
00341             const uint32_t start, const uint32_t nelm)
00342         : colValues(c), array(new array_t<uint64_t>(store, start, nelm)) {}
00343     colULongs(const ibis::column* c);
00344     virtual ~colULongs() {delete array;}
00345 
00346     virtual bool   empty() const {return (col==0 || array==0);}
00347     virtual uint32_t size() const {return (array ? array->size() : 0);}
00348     virtual uint32_t elementSize() const {return sizeof(uint64_t);}
00349     virtual ibis::TYPE_T getType() const {return ibis::ULONG;}
00350     virtual void* getArray() const {return array;}
00351     virtual void nosharing() {array->nosharing();}
00352 
00353     virtual void   erase(uint32_t i, uint32_t j) {
00354         array->erase(array->begin()+i, array->begin()+j);}
00355     virtual void   swap(uint32_t i, uint32_t j) {
00356         uint64_t tmp = (*array)[i];
00357         (*array)[i] = (*array)[j];
00358         (*array)[j] = tmp;}
00359 
00360     virtual void   reduce(const array_t<uint32_t>& starts);
00361     virtual void   reduce(const array_t<uint32_t>& starts,
00362                           ibis::selectClause::AGREGADO func);
00363     void swap(colULongs& rhs) { // swap two colULongs
00364         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00365         array_t<uint64_t>* a = rhs.array; rhs.array = array; array = a;}
00366 
00368     virtual uint32_t write(FILE* fptr) const {
00369         if (array) {
00370             uint32_t nelm = array->size();
00371             return nelm - fwrite(array->begin(), sizeof(uint64_t), nelm, fptr);
00372         }
00373         else {
00374             return 0;
00375         }
00376     }
00378     virtual void write(std::ostream& out, uint32_t i) const {
00379         if (array != 0 && array->size() > i) {
00380             out << (*array)[i];
00381         }
00382     }
00383 
00384     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00385     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00386                       colList::iterator head, colList::iterator tail);
00387     virtual void sort(uint32_t i, uint32_t j,
00388                       array_t<uint32_t>& neworder) const;
00389     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00390     virtual void reorder(const array_t<uint32_t>& ind)
00391     {ibis::util::reorder(*array, ind);}
00392     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00393     {array->topk(k, ind);}
00394     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00395     {array->bottomk(k, ind);}
00396     virtual long truncate(uint32_t keep);
00397     virtual long truncate(uint32_t keep, uint32_t start);
00398 
00399     virtual double getMin() const;
00400     virtual double getMax() const;
00401     virtual double getSum() const;
00402     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00403     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00404     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00405     virtual uint64_t getULong(uint32_t i) const {return (*array)[i];}
00406     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00407     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00408 
00409 private:
00410     array_t<uint64_t>* array;
00411 
00412     colULongs(const colULongs&);
00413     colULongs& operator=(const colULongs&);
00414 }; // ibis::colULongs
00415 
00417 class FASTBIT_CXX_DLLSPEC ibis::colShorts : public ibis::colValues {
00418 public:
00419     colShorts() : colValues(), array(0) {};
00420     colShorts(const ibis::column* c, const ibis::bitvector& hits)
00421         : colValues(c), array(c->selectShorts(hits)) {}
00422     colShorts(const ibis::column* c, ibis::fileManager::storage* store,
00423               const uint32_t start, const uint32_t nelm)
00424         : colValues(c), array(new array_t<int16_t>(store, start, nelm)) {}
00425     colShorts(const ibis::column* c);
00426     virtual ~colShorts() {delete array;}
00427 
00428     virtual bool   empty() const {return (col==0 || array==0);}
00429     virtual uint32_t size() const {return (array ? array->size() : 0);}
00430     virtual uint32_t elementSize() const {return sizeof(int16_t);}
00431     virtual ibis::TYPE_T getType() const {return ibis::SHORT;}
00432     virtual void* getArray() const {return array;}
00433     virtual void nosharing() {array->nosharing();}
00434 
00435     virtual void   reduce(const array_t<uint32_t>& starts);
00436     virtual void   reduce(const array_t<uint32_t>& starts,
00437                           ibis::selectClause::AGREGADO func);
00438     virtual void   erase(uint32_t i, uint32_t j) {
00439         array->erase(array->begin()+i, array->begin()+j);}
00440     virtual void   swap(uint32_t i, uint32_t j) {
00441         int16_t tmp = (*array)[i];
00442         (*array)[i] = (*array)[j];
00443         (*array)[j] = tmp;}
00444 
00445     void swap(colShorts& rhs) { // swap two colShorts
00446         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00447         array_t<int16_t>* a = rhs.array; rhs.array = array; array = a;}
00448 
00449     // write out whole array as binary
00450     virtual uint32_t write(FILE* fptr) const {
00451         if (array) {
00452             uint32_t nelm = array->size();
00453             return nelm - fwrite(array->begin(), sizeof(int16_t), nelm, fptr);
00454         }
00455         else {
00456             return 0;
00457         }
00458     }
00459     // write ith element as text
00460     virtual void write(std::ostream& out, uint32_t i) const
00461     {out << (*array)[i];}
00462 
00463     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00464     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00465                       colList::iterator head, colList::iterator tail);
00466     virtual void sort(uint32_t i, uint32_t j,
00467                       array_t<uint32_t>& neworder) const;
00468     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00469     virtual void reorder(const array_t<uint32_t>& ind)
00470     {ibis::util::reorder(*array, ind);}
00471     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00472     {array->topk(k, ind);}
00473     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00474     {array->bottomk(k, ind);}
00475     virtual long truncate(uint32_t keep);
00476     virtual long truncate(uint32_t keep, uint32_t start);
00477 
00478     virtual double getMin() const;
00479     virtual double getMax() const;
00480     virtual double getSum() const;
00481     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00482     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00483     virtual int64_t getLong(uint32_t i) const {return (*array)[i];}
00484     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00485     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00486     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00487 
00488 private:
00489     array_t<int16_t>* array;
00490 
00491     colShorts(const colShorts&);
00492     colShorts& operator=(const colShorts&);
00493 }; // ibis::colShorts
00494 
00496 class FASTBIT_CXX_DLLSPEC ibis::colUShorts : public ibis::colValues {
00497 public:
00498     colUShorts() : colValues(), array(0) {};
00499     colUShorts(const ibis::column* c, const ibis::bitvector& hits)
00500         : colValues(c), array(c->selectUShorts(hits)) {}
00501     colUShorts(const ibis::column* c, ibis::fileManager::storage* store,
00502             const uint32_t start, const uint32_t nelm)
00503         : colValues(c), array(new array_t<uint16_t>(store, start, nelm)) {}
00504     colUShorts(const ibis::column* c);
00505     virtual ~colUShorts() {delete array;}
00506 
00507     virtual bool   empty() const {return (col==0 || array==0);}
00508     virtual uint32_t size() const {return (array ? array->size() : 0);}
00509     virtual uint32_t elementSize() const {return sizeof(uint16_t);}
00510     virtual ibis::TYPE_T getType() const {return ibis::USHORT;}
00511     virtual void* getArray() const {return array;}
00512     virtual void nosharing() {array->nosharing();}
00513 
00514     virtual void   erase(uint32_t i, uint32_t j) {
00515         array->erase(array->begin()+i, array->begin()+j);}
00516     virtual void   swap(uint32_t i, uint32_t j) {
00517         uint16_t tmp = (*array)[i];
00518         (*array)[i] = (*array)[j];
00519         (*array)[j] = tmp;}
00520 
00521     virtual void   reduce(const array_t<uint32_t>& starts);
00522     virtual void   reduce(const array_t<uint32_t>& starts,
00523                           ibis::selectClause::AGREGADO func);
00524     void swap(colUShorts& rhs) { // swap two colUShorts
00525         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00526         array_t<uint16_t>* a = rhs.array; rhs.array = array; array = a;}
00527 
00529     virtual uint32_t write(FILE* fptr) const {
00530         if (array) {
00531             uint32_t nelm = array->size();
00532             return nelm - fwrite(array->begin(), sizeof(uint16_t), nelm, fptr);
00533         }
00534         else {
00535             return 0;
00536         }
00537     }
00539     virtual void write(std::ostream& out, uint32_t i) const {
00540         out << (*array)[i];
00541     }
00542 
00543     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00544     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00545                       colList::iterator head, colList::iterator tail);
00546     virtual void sort(uint32_t i, uint32_t j,
00547                       array_t<uint32_t>& neworder) const;
00548     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00549     virtual void reorder(const array_t<uint32_t>& ind)
00550     {ibis::util::reorder(*array, ind);}
00551     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00552     {array->topk(k, ind);}
00553     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00554     {array->bottomk(k, ind);}
00555     virtual long truncate(uint32_t keep);
00556     virtual long truncate(uint32_t keep, uint32_t start);
00557 
00558     virtual double getMin() const;
00559     virtual double getMax() const;
00560     virtual double getSum() const;
00561     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00562     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00563     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00564     virtual uint64_t getULong(uint32_t i) const {return (*array)[i];}
00565     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00566     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00567 
00568 private:
00569     array_t<uint16_t>* array;
00570 
00571     colUShorts(const colUShorts&);
00572     colUShorts& operator=(const colUShorts&);
00573 }; // ibis::colUShorts
00574 
00576 class FASTBIT_CXX_DLLSPEC ibis::colBytes : public ibis::colValues {
00577 public:
00578     colBytes() : colValues(), array(0) {};
00579     colBytes(const ibis::column* c, const ibis::bitvector& hits)
00580         : colValues(c), array(c->selectBytes(hits)) {}
00581     colBytes(const ibis::column* c, ibis::fileManager::storage* store,
00582             const uint32_t start, const uint32_t nelm)
00583         : colValues(c), array(new array_t<signed char>(store, start, nelm)) {}
00584     colBytes(const ibis::column* c);
00585     virtual ~colBytes() {delete array;}
00586 
00587     virtual bool   empty() const {return (col==0 || array==0);}
00588     virtual uint32_t size() const {return (array ? array->size() : 0);}
00589     virtual uint32_t elementSize() const {return sizeof(char);}
00590     virtual ibis::TYPE_T getType() const {return ibis::BYTE;}
00591     virtual void* getArray() const {return array;}
00592     virtual void nosharing() {array->nosharing();}
00593 
00594     virtual void   reduce(const array_t<uint32_t>& starts);
00595     virtual void   reduce(const array_t<uint32_t>& starts,
00596                           ibis::selectClause::AGREGADO func);
00597     virtual void   erase(uint32_t i, uint32_t j) {
00598         array->erase(array->begin()+i, array->begin()+j);}
00599     virtual void   swap(uint32_t i, uint32_t j) {
00600         signed char tmp = (*array)[i];
00601         (*array)[i] = (*array)[j];
00602         (*array)[j] = tmp;}
00603 
00604     void swap(colBytes& rhs) { // swap two colBytes
00605         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00606         array_t<signed char>* a = rhs.array; rhs.array = array; array = a;}
00607 
00608     // write out whole array as binary
00609     virtual uint32_t write(FILE* fptr) const {
00610         if (array) {
00611             uint32_t nelm = array->size();
00612             return nelm - fwrite(array->begin(), sizeof(char), nelm, fptr);
00613         }
00614         else {
00615             return 0;
00616         }
00617     }
00618     // write ith element as text
00619     virtual void write(std::ostream& out, uint32_t i) const
00620     {out << (int16_t)(*array)[i];}
00621 
00622     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00623     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00624                       colList::iterator head, colList::iterator tail);
00625     virtual void sort(uint32_t i, uint32_t j,
00626                       array_t<uint32_t>& neworder) const;
00627     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00628     virtual void reorder(const array_t<uint32_t>& ind)
00629     {ibis::util::reorder(*array, ind);}
00630     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00631     {array->topk(k, ind);}
00632     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00633     {array->bottomk(k, ind);}
00634     virtual long truncate(uint32_t keep);
00635     virtual long truncate(uint32_t keep, uint32_t start);
00636 
00637     virtual double getMin() const;
00638     virtual double getMax() const;
00639     virtual double getSum() const;
00640     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00641     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00642     virtual int64_t getLong(uint32_t i) const {return (*array)[i];}
00643     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00644     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00645     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00646 
00647 private:
00648     array_t<signed char>* array;
00649 
00650     colBytes(const colBytes&);
00651     colBytes& operator=(const colBytes&);
00652 }; // ibis::colBytes
00653 
00655 class FASTBIT_CXX_DLLSPEC ibis::colUBytes : public ibis::colValues {
00656 public:
00657     colUBytes() : colValues(), array(0) {};
00658     colUBytes(const ibis::column* c, const ibis::bitvector& hits)
00659         : colValues(c), array(c->selectUBytes(hits)) {}
00660     colUBytes(const ibis::column* c, ibis::fileManager::storage* store,
00661             const uint32_t start, const uint32_t nelm)
00662         : colValues(c), array(new array_t<unsigned char>(store, start, nelm)) {}
00663     colUBytes(const ibis::column* c);
00664     virtual ~colUBytes() {delete array;}
00665 
00666     virtual bool   empty() const {return (col==0 || array==0);}
00667     virtual uint32_t size() const {return (array ? array->size() : 0);}
00668     virtual uint32_t elementSize() const {return sizeof(char);}
00669     virtual ibis::TYPE_T getType() const {return ibis::UBYTE;}
00670     virtual void* getArray() const {return array;}
00671     virtual void nosharing() {array->nosharing();}
00672 
00673     virtual void   erase(uint32_t i, uint32_t j) {
00674         array->erase(array->begin()+i, array->begin()+j);}
00675     virtual void   swap(uint32_t i, uint32_t j) {
00676         unsigned char tmp = (*array)[i];
00677         (*array)[i] = (*array)[j];
00678         (*array)[j] = tmp;}
00679 
00680     virtual void   reduce(const array_t<uint32_t>& starts);
00681     virtual void   reduce(const array_t<uint32_t>& starts,
00682                           ibis::selectClause::AGREGADO func);
00683     void swap(colUBytes& rhs) { // swap two colUBytes
00684         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00685         array_t<unsigned char>* a = rhs.array; rhs.array = array; array = a;}
00686 
00688     virtual uint32_t write(FILE* fptr) const {
00689         if (array) {
00690             uint32_t nelm = array->size();
00691             return nelm - fwrite(array->begin(), sizeof(char), nelm, fptr);
00692         }
00693         else {
00694             return 0;
00695         }
00696     }
00698     virtual void write(std::ostream& out, uint32_t i) const {
00699         out << (uint16_t)(*array)[i];
00700     }
00701 
00702     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00703     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00704                       colList::iterator head, colList::iterator tail);
00705     virtual void sort(uint32_t i, uint32_t j,
00706                       array_t<uint32_t>& neworder) const;
00707     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00708     virtual void reorder(const array_t<uint32_t>& ind)
00709     {ibis::util::reorder(*array, ind);}
00710     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00711     {array->topk(k, ind);}
00712     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00713     {array->bottomk(k, ind);}
00714     virtual long truncate(uint32_t keep);
00715     virtual long truncate(uint32_t keep, uint32_t start);
00716 
00717     virtual double getMin() const;
00718     virtual double getMax() const;
00719     virtual double getSum() const;
00720     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00721     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00722     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00723     virtual uint64_t getULong(uint32_t i) const {return (*array)[i];}
00724     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00725     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00726 
00727 private:
00728     array_t<unsigned char>* array;
00729 
00730     colUBytes(const colUBytes&);
00731     colUBytes& operator=(const colUBytes&);
00732 }; // ibis::colUBytes
00733 
00735 class FASTBIT_CXX_DLLSPEC ibis::colFloats : public ibis::colValues {
00736 public:
00737     colFloats() : colValues(), array(0) {};
00738     colFloats(const ibis::column* c, const ibis::bitvector& hits)
00739         : colValues(c), array(c->selectFloats(hits)) {}
00740     colFloats(const ibis::column* c, ibis::fileManager::storage* store,
00741               const uint32_t start, const uint32_t nelm)
00742         : colValues(c), array(new array_t<float>(store, start, nelm)) {}
00743     colFloats(const ibis::column* c);
00744     virtual ~colFloats() {delete array;}
00745 
00746     virtual bool   empty() const {return (col==0 || array==0);}
00747     virtual uint32_t size() const {return (array ? array->size() : 0);}
00748     virtual uint32_t elementSize() const {return sizeof(float);}
00749     virtual ibis::TYPE_T getType() const {return ibis::FLOAT;}
00750     virtual void* getArray() const {return array;}
00751     virtual void nosharing() {array->nosharing();}
00752 
00753     virtual void   erase(uint32_t i, uint32_t j) {
00754         array->erase(array->begin()+i, array->begin()+j);}
00755     virtual void   swap(uint32_t i, uint32_t j) {
00756         float tmp = (*array)[i];
00757         (*array)[i] = (*array)[j];
00758         (*array)[j] = tmp;}
00759 
00760     void swap(colFloats& rhs) { // swap two colFloats
00761         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00762         array_t<float>* a = rhs.array; rhs.array = array; array = a;}
00763     virtual void   reduce(const array_t<uint32_t>& starts);
00764     virtual void   reduce(const array_t<uint32_t>& starts,
00765                           ibis::selectClause::AGREGADO func);
00766 
00767     // write out whole array as binary
00768     virtual uint32_t write(FILE* fptr) const {
00769         if (array) {
00770             uint32_t nelm = array->size();
00771             return nelm - fwrite(array->begin(), sizeof(float), nelm, fptr);
00772         }
00773         else {
00774             return 0;
00775         }
00776     }
00777     // write ith element as text
00778     virtual void write(std::ostream& out, uint32_t i) const {
00779         out << (*array)[i];}
00780 
00781     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00782     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00783                       colList::iterator head, colList::iterator tail);
00784     virtual void sort(uint32_t i, uint32_t j,
00785                       array_t<uint32_t>& neworder) const;
00786     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00787     virtual void reorder(const array_t<uint32_t>& ind)
00788     {ibis::util::reorder(*array, ind);}
00789     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00790     {array->topk(k, ind);}
00791     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00792     {array->bottomk(k, ind);}
00793     virtual long truncate(uint32_t keep);
00794     virtual long truncate(uint32_t keep, uint32_t start);
00795 
00796     virtual double getMin() const;
00797     virtual double getMax() const;
00798     virtual double getSum() const;
00799     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00800     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00801     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00802     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00803     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00804     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00805 
00806 private:
00807     array_t<float>* array;
00808 
00809     colFloats(const colFloats&);
00810     colFloats& operator=(const colFloats&);
00811 }; // ibis::colFloats
00812 
00814 class FASTBIT_CXX_DLLSPEC ibis::colDoubles : public ibis::colValues {
00815 public:
00816     colDoubles() : colValues(), array(0) {};
00817     colDoubles(const ibis::column* c, const ibis::bitvector& hits)
00818         : colValues(c), array(c->selectDoubles(hits)) {}
00819     colDoubles(const ibis::column* c, ibis::fileManager::storage* store,
00820                const uint32_t start, const uint32_t end)
00821         : colValues(c), array(new array_t<double>(store, start, end)) {}
00822     colDoubles(const ibis::column* c);
00823     colDoubles(size_t n, double v) : array(new array_t<double>(n, v)) {}
00824     virtual ~colDoubles() {delete array;}
00825 
00826     virtual bool   empty() const {return (col==0 || array==0);}
00827     virtual uint32_t size() const {return (array ? array->size() : 0);}
00828     virtual uint32_t elementSize() const {return sizeof(double);}
00829     virtual ibis::TYPE_T getType() const {return ibis::DOUBLE;}
00830     virtual void* getArray() const {return array;}
00831     virtual void nosharing() {array->nosharing();}
00832 
00833     virtual void   erase(uint32_t i, uint32_t j) {
00834         array->erase(array->begin()+i, array->begin()+j);}
00835     virtual void   swap(uint32_t i, uint32_t j) {
00836         double tmp = (*array)[i];
00837         (*array)[i] = (*array)[j];
00838         (*array)[j] = tmp;}
00839 
00840     void swap(colDoubles& rhs) { // swap two colDoubles
00841         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00842         array_t<double>* a = rhs.array; rhs.array = array; array = a;}
00843     virtual void   reduce(const array_t<uint32_t>& starts);
00844     virtual void   reduce(const array_t<uint32_t>& starts,
00845                           ibis::selectClause::AGREGADO func);
00846 
00847     // write out whole array as binary
00848     virtual uint32_t write(FILE* fptr) const {
00849         if (array) {
00850             uint32_t nelm = array->size();
00851             return nelm - fwrite(array->begin(), sizeof(double), nelm, fptr);
00852         }
00853         else {
00854             return 0;
00855         }
00856     }
00857     // write ith element as text
00858     virtual void write(std::ostream& out, uint32_t i) const {
00859         out.precision(12); out << (*array)[i];}
00860 
00861     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00862     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00863                       colList::iterator head, colList::iterator tail);
00864     virtual void sort(uint32_t i, uint32_t j,
00865                       array_t<uint32_t>& neworder) const;
00866     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00867     virtual void reorder(const array_t<uint32_t>& ind)
00868     {ibis::util::reorder(*array, ind);}
00869     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const
00870     {array->topk(k, ind);}
00871     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const
00872     {array->bottomk(k, ind);}
00873     virtual long truncate(uint32_t keep);
00874     virtual long truncate(uint32_t keep, uint32_t start);
00875 
00876     virtual double getMin() const;
00877     virtual double getMax() const;
00878     virtual double getSum() const;
00879     virtual int32_t getInt(uint32_t i) const {return (int32_t)(*array)[i];}
00880     virtual uint32_t getUInt(uint32_t i) const {return (uint32_t)(*array)[i];}
00881     virtual int64_t getLong(uint32_t i) const {return (int64_t)(*array)[i];}
00882     virtual uint64_t getULong(uint32_t i) const {return (uint64_t)(*array)[i];}
00883     virtual float getFloat(uint32_t i) const {return (float)(*array)[i];};
00884     virtual double getDouble(uint32_t i) const {return (double)(*array)[i];};
00885 
00886 private:
00887     array_t<double>* array;
00888 
00889     colDoubles(const colDoubles&);
00890     colDoubles& operator=(const colDoubles&);
00891 }; // ibis::colDoubles
00892 
00894 class FASTBIT_CXX_DLLSPEC ibis::colStrings : public ibis::colValues {
00895 public:
00896     colStrings() : colValues(), array(0) {};
00897     colStrings(const ibis::column* c, const ibis::bitvector& hits)
00898         : colValues(c), array(c->selectStrings(hits)) {}
00899     colStrings(const ibis::column* c);
00900     colStrings(size_t n, const std::string& v)
00901         : array(new std::vector<std::string>(n, v)) {}
00902     virtual ~colStrings() {delete array;}
00903 
00904     virtual bool         empty() const {return (col==0 || array==0);}
00905     virtual uint32_t     size() const {return (array ? array->size() : 0);}
00906     virtual uint32_t     elementSize() const {return 0;}
00907     virtual ibis::TYPE_T getType() const {return col->type();}
00908     virtual void*        getArray() const {return array;}
00909     virtual void         nosharing() {/* neve shared */}
00910 
00911     virtual void erase(uint32_t i, uint32_t j) {
00912         array->erase(array->begin()+i, array->begin()+j);}
00913     virtual void swap(uint32_t i, uint32_t j) {(*array)[i].swap((*array)[j]);}
00914 
00915     void swap(colStrings& rhs) { // swap two colStrings
00916         const ibis::column* c = rhs.col; rhs.col = col; col = c;
00917         std::vector<std::string>* a = rhs.array; rhs.array = array; array = a;}
00918     virtual void reduce(const array_t<uint32_t>& starts);
00919     virtual void reduce(const array_t<uint32_t>& starts,
00920                         ibis::selectClause::AGREGADO func);
00921 
00922     virtual uint32_t write(FILE* fptr) const;
00923     virtual void write(std::ostream& out, uint32_t i) const;
00924 
00925     virtual void sort(uint32_t i, uint32_t j, bundle* bdl);
00926     virtual void sort(uint32_t i, uint32_t j, bundle* bdl,
00927                       colList::iterator head, colList::iterator tail);
00928     virtual void sort(uint32_t i, uint32_t j,
00929                       array_t<uint32_t>& neworder) const;
00930     virtual array_t<uint32_t>* segment(const array_t<uint32_t>* old=0) const;
00931     virtual void reorder(const array_t<uint32_t>& ind);
00932     virtual void topk(uint32_t k, array_t<uint32_t> &ind) const;
00933     virtual void bottomk(uint32_t k, array_t<uint32_t> &ind) const;
00934     virtual long truncate(uint32_t keep);
00935     virtual long truncate(uint32_t keep, uint32_t start);
00936 
00938     virtual double getMin() const {return FASTBIT_DOUBLE_NULL;}
00940     virtual double getMax() const {return FASTBIT_DOUBLE_NULL;}
00942     virtual double getSum() const {return FASTBIT_DOUBLE_NULL;}
00944     virtual int32_t getInt(uint32_t) const {return 0;}
00946     virtual uint32_t getUInt(uint32_t) const {return 0;}
00948     virtual int64_t getLong(uint32_t) const {return 0;}
00950     virtual uint64_t getULong(uint32_t) const {return 0;}
00952     virtual float getFloat(uint32_t) const {return  FASTBIT_FLOAT_NULL;}
00954     virtual double getDouble(uint32_t) const {return FASTBIT_DOUBLE_NULL;}
00955 
00956 private:
00958     std::vector<std::string>* array;
00959 
00960     colStrings(const colStrings&);
00961     colStrings& operator=(const colStrings&);
00962 
00963     void sortsub(uint32_t i, uint32_t j, array_t<uint32_t>& ind) const;
00964     uint32_t partitionsub(uint32_t, uint32_t, array_t<uint32_t>&) const;
00965 }; // ibis::colStrings
00966 #endif


	Contact us Disclaimers FastBit source code FastBit mailing list archive