bord.h
Go to the documentation of this file.
00001 // File: $Id$
00002 // Author: John Wu <John.Wu at acm.org>
00003 //      Lawrence Berkeley National Laboratory
00004 // Copyright 2007-2011 the Regents of the University of California
00005 #ifndef IBIS_BORD_H
00006 #define IBIS_BORD_H
00007 #include "table.h"      // ibis::table
00008 #include "util.h"       // ibis::partList
00009 #include "part.h"       // ibis::part
00010 
00014 namespace ibis {
00015     class bord;
00016 } // namespace ibis
00017 
00028 class FASTBIT_CXX_DLLSPEC ibis::bord : public ibis::table, public ibis::part {
00029 public:
00030     bord(const char *tn, const char *td, uint64_t nr,
00031          ibis::table::bufferList &buf,
00032          const ibis::table::typeList &ct,
00033          const ibis::table::stringList &cn,
00034          const ibis::table::stringList *cdesc=0);
00035     bord(const char *tn, const char *td,
00036          const ibis::selectClause &sc, const ibis::part &ref);
00037     virtual ~bord() {clear();}
00038 
00039     virtual uint64_t nRows() const {return nEvents;}
00040     virtual uint32_t nColumns() const {return ibis::part::nColumns();}
00041 
00042     virtual ibis::table::stringList columnNames() const;
00043     virtual ibis::table::typeList columnTypes() const;
00044 
00045     virtual void describe(std::ostream&) const;
00046     virtual void dumpNames(std::ostream&, const char*) const;
00047     virtual int dump(std::ostream&, const char*) const;
00048     virtual int dump(std::ostream&, uint64_t, const char*) const;
00049     virtual int dump(std::ostream&, uint64_t, uint64_t, const char*) const;
00050     virtual int backup(const char* dir, const char* tname=0,
00051                        const char* tdesc=0) const;
00052 
00053     virtual int64_t
00054         getColumnAsBytes(const char*, char*, uint64_t =0, uint64_t =0) const;
00055     virtual int64_t
00056         getColumnAsUBytes(const char*, unsigned char*, uint64_t =0,
00057                           uint64_t =0) const;
00058     virtual int64_t
00059         getColumnAsShorts(const char*, int16_t*, uint64_t =0, uint64_t =0) const;
00060     virtual int64_t
00061         getColumnAsUShorts(const char*, uint16_t*, uint64_t =0, uint64_t =0) const;
00062     virtual int64_t
00063         getColumnAsInts(const char*, int32_t*, uint64_t =0, uint64_t =0) const;
00064     virtual int64_t
00065         getColumnAsUInts(const char*, uint32_t*, uint64_t =0, uint64_t =0) const;
00066     virtual int64_t
00067         getColumnAsLongs(const char*, int64_t*, uint64_t =0, uint64_t =0) const;
00068     virtual int64_t
00069         getColumnAsULongs(const char*, uint64_t*, uint64_t =0, uint64_t =0) const;
00070     virtual int64_t
00071         getColumnAsFloats(const char*, float*, uint64_t =0, uint64_t =0) const;
00072     virtual int64_t
00073         getColumnAsDoubles(const char*, double*, uint64_t =0, uint64_t =0) const;
00074     virtual int64_t
00075         getColumnAsDoubles(const char*, std::vector<double>&,
00076                            uint64_t =0, uint64_t =0) const;
00077     virtual int64_t
00078         getColumnAsStrings(const char*, std::vector<std::string>&,
00079                            uint64_t =0, uint64_t =0) const;
00080     virtual double getColumnMin(const char*) const;
00081     virtual double getColumnMax(const char*) const;
00082 
00083     virtual long getHistogram(const char*, const char*,
00084                               double, double, double,
00085                               std::vector<uint32_t>&) const;
00086     virtual long getHistogram2D(const char*, const char*,
00087                                 double, double, double,
00088                                 const char*,
00089                                 double, double, double,
00090                                 std::vector<uint32_t>&) const;
00091     virtual long getHistogram3D(const char*, const char*,
00092                                 double, double, double,
00093                                 const char*,
00094                                 double, double, double,
00095                                 const char*,
00096                                 double, double, double,
00097                                 std::vector<uint32_t>&) const;
00098 
00099     virtual void estimate(const char* cond,
00100                           uint64_t& nmin, uint64_t& nmax) const;
00101     virtual void estimate(const ibis::qExpr* cond,
00102                           uint64_t& nmin, uint64_t& nmax) const;
00103     using table::select;
00104     virtual table* select(const char* sel, const char* cond) const;
00105     virtual table* groupby(const ibis::table::stringList&) const;
00106     virtual table* groupby(const char* str) const;
00107     virtual void orderby(const ibis::table::stringList&);
00108     virtual void orderby(const ibis::table::stringList&,
00109                          const std::vector<bool>&);
00110     virtual void reverseRows();
00111 
00112     virtual int buildIndex(const char*, const char*) {return -1;}
00113     virtual int buildIndexes(const char*) {return -1;}
00114     virtual int buildIndexes(const char*, int) {return -1;}
00115     virtual const char* indexSpec(const char*) const {return 0;}
00116     virtual void indexSpec(const char*, const char*) {return;}
00117     virtual int getPartitions(std::vector<const ibis::part*> &) const;
00118 
00119     int restoreCategoriesAsStrings(const char*);
00120     ibis::table* groupby(const ibis::selectClause&) const;
00121     ibis::table* evaluateTerms(const ibis::selectClause&,
00122                                const char*) const;
00123 
00124     virtual long reorder();
00125     virtual long reorder(const ibis::table::stringList&);
00126     virtual long reorder(const ibis::table::stringList&,
00127                          const std::vector<bool>&);
00128 
00129     int append(const ibis::selectClause&, const ibis::part&,
00130                const ibis::bitvector&);
00131     int renameColumns(const ibis::selectClause&);
00132     int limit(uint32_t);
00133 
00134     template <typename T>
00135         long sortValues(array_t<T>& vals,
00136                         array_t<uint32_t>& starts,
00137                         array_t<uint32_t>& indout,
00138                         const array_t<uint32_t>& indin,
00139                         bool ascending) const;
00140     template <typename T>
00141         long reorderValues(array_t<T>& vals,
00142                            const array_t<uint32_t>& ind) const;
00143     long sortStrings(std::vector<std::string>& vals,
00144                      array_t<uint32_t>& starts,
00145                      array_t<uint32_t>& idxout,
00146                      const array_t<uint32_t>& idxin,
00147                      bool ascending) const;
00148     long reorderStrings(std::vector<std::string>& vals,
00149                         const array_t<uint32_t>& ind) const;
00150 
00151 
00152     void copyColumn(const char*, ibis::TYPE_T&, void*&) const;
00153     static void copyValue(ibis::TYPE_T type,
00154                           void* outbuf, size_t outpos,
00155                           const void* inbuf, size_t inpos);
00156 
00157     // Cursor class for row-wise data accesses.
00158     class cursor;
00160     virtual ibis::table::cursor* createCursor() const;
00161 
00162     // forward declarations
00163     class column;
00164 
00165 protected:
00167     void clear();
00169     int64_t computeHits(const char* cond) const;
00170 
00171 private:
00172     // disallow copying.
00173     bord(const bord&);
00174     bord& operator=(const bord&);
00175 
00176     friend class cursor;
00177 }; // ibis::bord
00178 
00188 class ibis::bord::column : public ibis::column {
00189 public:
00190     column(const ibis::bord* tbl, ibis::TYPE_T t, const char* name, void *buf=0,
00191            const char* desc="", double low=DBL_MAX, double high=-DBL_MAX);
00192     column(const ibis::bord*, const ibis::column&, void *buf);
00193     column(const column& rhs);
00194     virtual ~column();
00195 
00196     virtual ibis::fileManager::storage* getRawData() const;
00197 
00198     using ibis::column::evaluateRange;
00199     virtual long evaluateRange(const ibis::qContinuousRange& cmp,
00200                                const ibis::bitvector& mask,
00201                                ibis::bitvector& res) const;
00202     virtual long evaluateRange(const ibis::qDiscreteRange& cmp,
00203                                const ibis::bitvector& mask,
00204                                ibis::bitvector& res) const;
00205     virtual long stringSearch(const char*, ibis::bitvector&) const;
00206     virtual long stringSearch(const std::vector<std::string>&,
00207                               ibis::bitvector&) const;
00208     virtual long stringSearch(const char*) const;
00209     virtual long stringSearch(const std::vector<std::string>&) const;
00210     virtual long keywordSearch(const char*, ibis::bitvector&) const;
00211     virtual long keywordSearch(const char*) const;
00212     virtual long patternSearch(const char*) const;
00213     virtual long patternSearch(const char*, ibis::bitvector &) const;
00214 
00215     virtual array_t<signed char>*   selectBytes(const ibis::bitvector&) const;
00216     virtual array_t<unsigned char>* selectUBytes(const ibis::bitvector&) const;
00217     virtual array_t<int16_t>*       selectShorts(const ibis::bitvector&) const;
00218     virtual array_t<uint16_t>*      selectUShorts(const ibis::bitvector&) const;
00219     virtual array_t<int32_t>*       selectInts(const ibis::bitvector&) const;
00220     virtual array_t<uint32_t>*      selectUInts(const ibis::bitvector&) const;
00221     virtual array_t<int64_t>*       selectLongs(const ibis::bitvector&) const;
00222     virtual array_t<uint64_t>*      selectULongs(const ibis::bitvector&) const;
00223     virtual array_t<float>*         selectFloats(const ibis::bitvector&) const;
00224     virtual array_t<double>*        selectDoubles(const ibis::bitvector&) const;
00225     virtual std::vector<std::string>*
00226         selectStrings(const bitvector& mask) const;
00227 
00228     virtual long append(const char* dt, const char* df, const uint32_t nold,
00229                         const uint32_t nnew, uint32_t nbuf, char* buf);
00230     virtual long append(const void* vals, const ibis::bitvector& msk);
00231     virtual long append(const ibis::column& scol, const ibis::bitvector& msk);
00232 
00233     virtual void computeMinMax() {
00234         computeMinMax(thePart->currentDataDir(), lower, upper);}
00235     virtual void computeMinMax(const char *dir) {
00236         computeMinMax(dir, lower, upper);}
00237     virtual void computeMinMax(const char *, double &min, double &max) const;
00238     virtual void getString(uint32_t i, std::string &val) const;
00239     virtual int  getValuesArray(void* vals) const;
00240 
00241     void reverseRows();
00242     int  limit(uint32_t nr);
00243 
00244     void*& getArray() {return buffer;}
00245     void*  getArray() const {return buffer;}
00246     int dump(std::ostream& out, uint32_t i) const;
00247 
00248     int restoreCategoriesAsStrings(const ibis::part&);
00251     template <typename T> static void 
00252         addIncoreData(array_t<T>*& to, uint32_t nold, const array_t<T>& from,
00253                       const T special);
00254     static void addStrings(std::vector<std::string>*&, uint32_t,
00255                            const std::vector<std::string>&);
00256 
00257 
00258 protected:
00261     void *buffer;
00262 
00263     column& operator=(const column&); // no assignment
00264 }; // ibis::bord::column
00265 
00266 class FASTBIT_CXX_DLLSPEC ibis::bord::cursor : public ibis::table::cursor {
00267 public:
00268     cursor(const ibis::bord& t);
00269     virtual ~cursor() {};
00270 
00271     virtual uint64_t nRows() const {return tab.nRows();}
00272     virtual uint32_t nColumns() const {return tab.nColumns();}
00273     virtual ibis::table::stringList columnNames() const {
00274         return tab.columnNames();}
00275     virtual ibis::table::typeList columnTypes() const {
00276         return tab.columnTypes();}
00277     virtual int fetch();
00278     virtual int fetch(uint64_t);
00279     virtual int fetch(ibis::table::row&);
00280     virtual int fetch(uint64_t, ibis::table::row&);
00281     virtual uint64_t getCurrentRowNumber() const {return curRow;}
00282     virtual int dump(std::ostream& out, const char* del) const;
00283 
00284     virtual int getColumnAsByte(const char*, char&) const;
00285     virtual int getColumnAsUByte(const char*, unsigned char&) const;
00286     virtual int getColumnAsShort(const char*, int16_t&) const;
00287     virtual int getColumnAsUShort(const char*, uint16_t&) const;
00288     virtual int getColumnAsInt(const char*, int32_t&) const;
00289     virtual int getColumnAsUInt(const char*, uint32_t&) const;
00290     virtual int getColumnAsLong(const char*, int64_t&) const;
00291     virtual int getColumnAsULong(const char*, uint64_t&) const;
00292     virtual int getColumnAsFloat(const char*, float&) const;
00293     virtual int getColumnAsDouble(const char*, double&) const;
00294     virtual int getColumnAsString(const char*, std::string&) const;
00295 
00296     virtual int getColumnAsByte(uint32_t, char&) const;
00297     virtual int getColumnAsUByte(uint32_t, unsigned char&) const;
00298     virtual int getColumnAsShort(uint32_t, int16_t&) const;
00299     virtual int getColumnAsUShort(uint32_t, uint16_t&) const;
00300     virtual int getColumnAsInt(uint32_t, int32_t&) const;
00301     virtual int getColumnAsUInt(uint32_t, uint32_t&) const;
00302     virtual int getColumnAsLong(uint32_t, int64_t&) const;
00303     virtual int getColumnAsULong(uint32_t, uint64_t&) const;
00304     virtual int getColumnAsFloat(uint32_t, float&) const;
00305     virtual int getColumnAsDouble(uint32_t, double&) const;
00306     virtual int getColumnAsString(uint32_t, std::string&) const;
00307 
00308 protected:
00309     struct bufferElement {
00310         const char* cname;
00311         ibis::TYPE_T ctype;
00312         void* cval;
00313 
00314         bufferElement() : cname(0), ctype(ibis::UNKNOWN_TYPE), cval(0) {}
00315     }; // bufferElement
00316     typedef std::map<const char*, uint32_t, ibis::lessi> bufferMap;
00317     std::vector<bufferElement> buffer;
00318     bufferMap bufmap;
00319     const ibis::bord& tab;
00320     int64_t curRow; // the current row number
00321 
00322     void fillRow(ibis::table::row& res) const;
00323     int dumpIJ(std::ostream&, uint32_t, uint32_t) const;
00324 
00325 private:
00326     cursor();
00327     cursor(const cursor&);
00328     cursor& operator=(const cursor&);
00329 }; // ibis::bord::cursor
00330 
00334 inline void ibis::bord::copyValue(ibis::TYPE_T type,
00335                                   void* outbuf, size_t outpos,
00336                                   const void* inbuf, size_t inpos) {
00337     switch (type) {
00338     default:
00339         break;
00340     case ibis::BYTE: {
00341         (*static_cast<array_t<signed char>*>(outbuf))[outpos]
00342             = (*static_cast<const array_t<signed char>*>(inbuf))[inpos];
00343         break;}
00344     case ibis::UBYTE: {
00345         (*static_cast<array_t<unsigned char>*>(outbuf))[outpos]
00346             = (*static_cast<const array_t<unsigned char>*>(inbuf))[inpos];
00347         break;}
00348     case ibis::SHORT: {
00349         (*static_cast<array_t<int16_t>*>(outbuf))[outpos]
00350             = (*static_cast<const array_t<int16_t>*>(inbuf))[inpos];
00351         break;}
00352     case ibis::USHORT: {
00353         (*static_cast<array_t<uint16_t>*>(outbuf))[outpos]
00354             = (*static_cast<const array_t<uint16_t>*>(inbuf))[inpos];
00355         LOGGER(ibis::gVerbose > 5)
00356             << "DEBUG -- copied inbuf[" << inpos << "] (="
00357             << (*static_cast<const array_t<uint16_t>*>(inbuf))[inpos]
00358             << ") to outbuf[" << outpos << "] (="
00359             << (*static_cast<array_t<uint16_t>*>(outbuf))[outpos] << ')';
00360         break;}
00361     case ibis::INT: {
00362         (*static_cast<array_t<int32_t>*>(outbuf))[outpos]
00363             = (*static_cast<const array_t<int32_t>*>(inbuf))[inpos];
00364         break;}
00365     case ibis::UINT: {
00366         (*static_cast<array_t<uint32_t>*>(outbuf))[outpos]
00367             = (*static_cast<const array_t<uint32_t>*>(inbuf))[inpos];
00368         break;}
00369     case ibis::LONG: {
00370         (*static_cast<array_t<int64_t>*>(outbuf))[outpos]
00371             = (*static_cast<const array_t<int64_t>*>(inbuf))[inpos];
00372         break;}
00373     case ibis::ULONG: {
00374         (*static_cast<array_t<uint64_t>*>(outbuf))[outpos]
00375             = (*static_cast<const array_t<uint64_t>*>(inbuf))[inpos];
00376         break;}
00377     case ibis::FLOAT: {
00378         (*static_cast<array_t<float>*>(outbuf))[outpos]
00379             = (*static_cast<const array_t<float>*>(inbuf))[inpos];
00380         break;}
00381     case ibis::DOUBLE: {
00382         (*static_cast<array_t<double>*>(outbuf))[outpos]
00383             = (*static_cast<const array_t<double>*>(inbuf))[inpos];
00384         break;}
00385     case ibis::TEXT:
00386     case ibis::CATEGORY: {
00387         (*static_cast<std::vector<std::string>*>(outbuf))[outpos]
00388         = (*static_cast<const std::vector<std::string>*>(inbuf))[inpos];
00389         break;}
00390     }
00391 } //ibis::bord::copyValue
00392 
00393 inline int ibis::bord::column::dump(std::ostream& out, uint32_t i) const {
00394     int ierr = -1;
00395     if (buffer == 0) {
00396         out << "(no data in memory)";
00397         return ierr;
00398     }
00399 
00400     switch (m_type) {
00401     case ibis::BYTE: {
00402         const array_t<signed char>* vals =
00403             static_cast<const array_t<signed char>*>(buffer);
00404         out << (int)((*vals)[i]);
00405         ierr = 0;
00406         break;}
00407     case ibis::UBYTE: {
00408         const array_t<unsigned char>* vals =
00409             static_cast<const array_t<unsigned char>*>(buffer);
00410         out << (unsigned)((*vals)[i]);
00411         ierr = 0;
00412         break;}
00413     case ibis::SHORT: {
00414         const array_t<int16_t>* vals =
00415             static_cast<const array_t<int16_t>*>(buffer);
00416         out << (*vals)[i];
00417         ierr = 0;
00418         break;}
00419     case ibis::USHORT: {
00420         const array_t<uint16_t>* vals =
00421             static_cast<const array_t<uint16_t>*>(buffer);
00422         out << (*vals)[i];
00423         ierr = 0;
00424         break;}
00425     case ibis::INT: {
00426         const array_t<int32_t>* vals =
00427             static_cast<const array_t<int32_t>*>(buffer);
00428         out << (*vals)[i];
00429         ierr = 0;
00430         break;}
00431     case ibis::UINT: {
00432         const array_t<uint32_t>* vals =
00433             static_cast<const array_t<uint32_t>*>(buffer);
00434         out << (*vals)[i];
00435         ierr = 0;
00436         break;}
00437     case ibis::LONG: {
00438         const array_t<int64_t>* vals =
00439             static_cast<const array_t<int64_t>*>(buffer);
00440         out << (*vals)[i];
00441         ierr = 0;
00442         break;}
00443     case ibis::ULONG: {
00444         const array_t<uint64_t>* vals =
00445             static_cast<const array_t<uint64_t>*>(buffer);
00446         out << (*vals)[i];
00447         ierr = 0;
00448         break;}
00449     case ibis::FLOAT: {
00450         const array_t<float>* vals =
00451             static_cast<const array_t<float>*>(buffer);
00452         out << std::setprecision(7) << (*vals)[i];
00453         ierr = 0;
00454         break;}
00455     case ibis::DOUBLE: {
00456         const array_t<double>* vals =
00457             static_cast<const array_t<double>*>(buffer);
00458         out << std::setprecision(15) << (*vals)[i];
00459         ierr = 0;
00460         break;}
00461     case ibis::TEXT:
00462     case ibis::CATEGORY: {
00463         std::string tmp;
00464         getString(i, tmp);
00465         out << '"' << tmp << '"';
00466         ierr = 0;
00467         break;}
00468     default: {
00469         ierr = -2;
00470         break;}
00471     }
00472     return ierr;
00473 } // ibis::bord::column::dump
00474 
00475 inline int ibis::bord::cursor::fetch() {
00476     ++ curRow;
00477     return (0 - (curRow >= (int64_t) tab.nRows()));
00478 } // ibis::bord::cursor::fetch
00479 
00480 inline int ibis::bord::cursor::fetch(uint64_t irow) {
00481     if (irow < tab.nRows()) {
00482         curRow = static_cast<int64_t>(irow);
00483         return 0;
00484     }
00485     else {
00486         return -1;
00487     }
00488 } // ibis::bord::cursor::fetch
00489 
00490 inline int ibis::bord::cursor::fetch(ibis::table::row& res) {
00491     ++ curRow;
00492     if ((uint64_t) curRow < tab.nRows()) {
00493         fillRow(res);
00494         return 0;
00495     }
00496     else {
00497         return -1;
00498     }
00499 } // ibis::bord::cursor::fetch
00500 
00501 inline int ibis::bord::cursor::fetch(uint64_t irow, ibis::table::row& res) {
00502     if (irow < tab.nRows()) {
00503         curRow = static_cast<int64_t>(irow);
00504         fillRow(res);
00505         return 0;
00506     }
00507     else {
00508         return -1;
00509     }
00510 } // ibis::bord::cursor::fetch
00511 
00512 inline int
00513 ibis::bord::cursor::dumpIJ(std::ostream& out, uint32_t i,
00514                            uint32_t j) const {
00515     if (buffer[j].cval == 0) return -1;
00516 
00517     switch (buffer[j].ctype) {
00518     case ibis::BYTE: {
00519         const array_t<const signed char>* vals =
00520             static_cast<const array_t<const signed char>*>(buffer[j].cval);
00521         out << (int) ((*vals)[i]);
00522         break;}
00523     case ibis::UBYTE: {
00524         const array_t<const unsigned char>* vals =
00525             static_cast<const array_t<const unsigned char>*>(buffer[j].cval);
00526         out << (unsigned int) ((*vals)[i]);
00527         break;}
00528     case ibis::SHORT: {
00529         const array_t<const int16_t>* vals =
00530             static_cast<const array_t<const int16_t>*>(buffer[j].cval);
00531         out << (*vals)[i];
00532         break;}
00533     case ibis::USHORT: {
00534         const array_t<const uint16_t>* vals =
00535             static_cast<const array_t<const uint16_t>*>(buffer[j].cval);
00536         out << (*vals)[i];
00537         break;}
00538     case ibis::INT: {
00539         const array_t<const int32_t>* vals =
00540             static_cast<const array_t<const int32_t>*>(buffer[j].cval);
00541         out << (*vals)[i];
00542         break;}
00543     case ibis::UINT: {
00544         const array_t<const uint32_t>* vals =
00545             static_cast<const array_t<const uint32_t>*>(buffer[j].cval);
00546         out << (*vals)[i];
00547         break;}
00548     case ibis::LONG: {
00549         const array_t<const int64_t>* vals =
00550             static_cast<const array_t<const int64_t>*>(buffer[j].cval);
00551         out << (*vals)[i];
00552         break;}
00553     case ibis::ULONG: {
00554         const array_t<const uint64_t>* vals =
00555             static_cast<const array_t<const uint64_t>*>(buffer[j].cval);
00556         out << (*vals)[i];
00557         break;}
00558     case ibis::FLOAT: {
00559         const array_t<const float>* vals =
00560             static_cast<const array_t<const float>*>(buffer[j].cval);
00561         out << (*vals)[i];
00562         break;}
00563     case ibis::DOUBLE: {
00564         const array_t<const double>* vals =
00565             static_cast<const array_t<const double>*>(buffer[j].cval);
00566         out << (*vals)[i];
00567         break;}
00568     case ibis::TEXT:
00569     case ibis::CATEGORY: {
00570         const std::vector<std::string>* vals =
00571             static_cast<const std::vector<std::string>*>(buffer[j].cval);
00572         out << '"' << (*vals)[i] << '"';
00573         break;}
00574     default: {
00575         return -2;}
00576     }
00577     return 0;
00578 } // ibis::bord::cursor::dumpIJ
00579 
00580 inline int
00581 ibis::bord::cursor::getColumnAsByte(const char* cn, char& val) const {
00582     if (curRow < 0 || curRow >= (int64_t) tab.nRows() || cn == 0 || *cn == 0)
00583         return -1;
00584     bufferMap::const_iterator it = bufmap.find(cn);
00585     if (it != bufmap.end())
00586         return getColumnAsByte((*it).second, val);
00587     else
00588         return -2;
00589 } // ibis::bord::cursor::getColumnAsByte
00590 
00591 inline int
00592 ibis::bord::cursor::getColumnAsUByte(const char* cn,
00593                                      unsigned char& val) const {
00594     if (curRow < 0 || curRow >= (int64_t) tab.nRows() || cn == 0 || *cn == 0)
00595         return -1;
00596     bufferMap::const_iterator it = bufmap.find(cn);
00597     if (it != bufmap.end())
00598         return getColumnAsUByte((*it).second, val);
00599     else
00600         return -2;
00601 } // ibis::bord::cursor::getColumnAsUByte
00602 
00603 inline int
00604 ibis::bord::cursor::getColumnAsShort(const char* cn, int16_t& val) const {
00605     if (curRow < 0 || curRow >= (int64_t) tab.nRows() || cn == 0 || *cn == 0)
00606         return -1;
00607     bufferMap::const_iterator it = bufmap.find(cn);
00608     if (it != bufmap.end())
00609         return getColumnAsShort((*it).second, val);
00610     else
00611         return -2;
00612 } // ibis::bord::cursor::getColumnAsShort
00613 
00614 inline int
00615 ibis::bord::cursor::getColumnAsUShort(const char* cn, uint16_t& val) const {
00616     if (curRow < 0 || curRow >= (int64_t) tab.nRows() || cn == 0 || *cn == 0)
00617         return -1;
00618     bufferMap::const_iterator it = bufmap.find(cn);
00619     if (it != bufmap.end())
00620         return getColumnAsUShort((*it).second, val);
00621     else
00622         return -2;
00623 } // ibis::bord::cursor::getColumnAsUShort
00624 
00625 inline int
00626 ibis::bord::cursor::getColumnAsInt(const char* cn, int32_t& val) const {
00627     if (curRow < 0 || curRow >= (int64_t) tab.nRows() || cn == 0 || *cn == 0)
00628         return -1;
00629     bufferMap::const_iterator it = bufmap.find(cn);
00630     if (it != bufmap.end())
00631         return getColumnAsInt((*it).second, val);
00632     else
00633         return -2;
00634 } // ibis::bord::cursor::getColumnAsInt
00635 
00636 inline int
00637 ibis::bord::cursor::getColumnAsUInt(const char* cn, uint32_t& val) const {
00638     if (curRow < 0 || curRow >= (int64_t) tab.nRows() || cn == 0 || *cn == 0)
00639         return -1;
00640     bufferMap::const_iterator it = bufmap.find(cn);
00641     if (it != bufmap.end())
00642         return getColumnAsUInt((*it).second, val);
00643     else
00644         return -2;
00645 } // ibis::bord::cursor::getColumnAsUInt
00646 
00647 inline int
00648 ibis::bord::cursor::getColumnAsLong(const char* cn, int64_t& val) const {
00649     if (curRow < 0 || curRow >= (int64_t) tab.nRows() || cn == 0 || *cn == 0)
00650         return -1;
00651     bufferMap::const_iterator it = bufmap.find(cn);
00652     if (it != bufmap.end())
00653         return getColumnAsLong((*it).second, val);
00654     else
00655         return -2;
00656 } // ibis::bord::cursor::getColumnAsLong
00657 
00658 inline int
00659 ibis::bord::cursor::getColumnAsULong(const char* cn, uint64_t& val) const {
00660     if (curRow < 0 || curRow >= (int64_t) tab.nRows() || cn == 0 || *cn == 0)
00661         return -1;
00662     bufferMap::const_iterator it = bufmap.find(cn);
00663     if (it != bufmap.end())
00664         return getColumnAsULong((*it).second, val);
00665     else
00666         return -2;
00667 } // ibis::bord::cursor::getColumnAsULong
00668 
00669 inline int
00670 ibis::bord::cursor::getColumnAsFloat(const char* cn, float& val) const {
00671     if (curRow < 0 || curRow >= (int64_t) tab.nRows() || cn == 0 || *cn == 0)
00672         return -1;
00673     bufferMap::const_iterator it = bufmap.find(cn);
00674     if (it != bufmap.end())
00675         return getColumnAsFloat((*it).second, val);
00676     else
00677         return -2;
00678 } // ibis::bord::cursor::getColumnAsFloat
00679 
00680 inline int
00681 ibis::bord::cursor::getColumnAsDouble(const char* cn, double& val) const {
00682     if (curRow < 0 || curRow >= (int64_t) tab.nRows() || cn == 0 || *cn == 0)
00683         return -1;
00684     bufferMap::const_iterator it = bufmap.find(cn);
00685     if (it != bufmap.end())
00686         return getColumnAsDouble((*it).second, val);
00687     else
00688         return -2;
00689 } // ibis::bord::cursor::getColumnAsDouble
00690 
00691 inline int
00692 ibis::bord::cursor::getColumnAsString(const char* cn,
00693                                       std::string& val) const {
00694     if (curRow < 0 || curRow >= (int64_t) tab.nRows() || cn == 0 || *cn == 0)
00695         return -1;
00696     bufferMap::const_iterator it = bufmap.find(cn);
00697     if (it != bufmap.end())
00698         return getColumnAsString((*it).second, val);
00699     else
00700         return -2;
00701 } // ibis::bord::cursor::getColumnAsString
00702 #endif // IBIS_BORD_H

Make It A Bit Faster
Contact us
Disclaimers
FastBit source code
FastBit mailing list archive