00001
00002
00003
00004
00005 #ifndef IBIS_BORD_H
00006 #define IBIS_BORD_H
00007 #include "table.h"
00008 #include "util.h"
00009 #include "part.h"
00010
00014 namespace ibis {
00015 class bord;
00016 }
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
00158 class cursor;
00160 virtual ibis::table::cursor* createCursor() const;
00161
00162
00163 class column;
00164
00165 protected:
00167 void clear();
00169 int64_t computeHits(const char* cond) const;
00170
00171 private:
00172
00173 bord(const bord&);
00174 bord& operator=(const bord&);
00175
00176 friend class cursor;
00177 };
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&);
00264 };
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 };
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;
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 };
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 }
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 }
00474
00475 inline int ibis::bord::cursor::fetch() {
00476 ++ curRow;
00477 return (0 - (curRow >= (int64_t) tab.nRows()));
00478 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
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 }
00702 #endif // IBIS_BORD_H
