00001 #ifndef DBALLE_CPP_RECORD_H
00002 #define DBALLE_CPP_RECORD_H
00003
00004 #include <dballe/core/record.h>
00005
00006 #include <dballe++/var.h>
00007
00008 namespace dballe {
00009
00013 class RecordIterator
00014 {
00015 dba_record m_rec;
00016 dba_keyword m_kwd;
00017 dba_record_cursor m_cur;
00018
00019 public:
00020 RecordIterator(dba_record rec);
00021 RecordIterator(dba_record rec, bool)
00022 : m_rec(rec), m_kwd(DBA_KEY_COUNT), m_cur(0) {}
00023
00024
00025
00026
00027 bool operator==(const RecordIterator& rc);
00028 bool operator!=(const RecordIterator& rc);
00029 RecordIterator& operator++();
00030 RecordIterator operator++(int);
00031 Var operator*() const;
00032
00033 bool isKeyword() const;
00034 dba_keyword keyword() const { return m_kwd; }
00035 const char* keywordName() const;
00036
00037
00038
00039 bool valid() const { return m_kwd != DBA_KEY_COUNT || m_cur != NULL; }
00040 bool next() { ++(*this); return valid(); }
00041 Var var() const { return **this; }
00042 };
00043
00047 class RecordVarIterator
00048 {
00049 dba_record m_rec;
00050 dba_record_cursor m_cur;
00051
00052 public:
00053 RecordVarIterator(dba_record rec)
00054 : m_rec(rec), m_cur(dba_record_iterate_first(rec)) {}
00055 RecordVarIterator(dba_record rec, dba_record_cursor cur)
00056 : m_rec(rec), m_cur(cur) {}
00057
00058
00059
00060
00061 bool operator==(const RecordVarIterator& rc)
00062 {
00063 return m_cur == rc.m_cur;
00064 }
00065 bool operator!=(const RecordVarIterator& rc)
00066 {
00067 return m_cur != rc.m_cur;
00068 }
00069 RecordVarIterator& operator++()
00070 {
00071 m_cur = dba_record_iterate_next(m_rec, m_cur);
00072 return *this;
00073 }
00074 RecordVarIterator operator++(int)
00075 {
00076 RecordVarIterator res(*this);
00077 m_cur = dba_record_iterate_next(m_rec, m_cur);
00078 return res;
00079 }
00080 Var operator*() const
00081 {
00082 dba_var res;
00083 checked(dba_var_copy(dba_record_cursor_variable(m_cur), &res));
00084 return res;
00085 }
00086
00087
00088
00089 bool valid() const { return m_cur != NULL; }
00090 bool next() { ++(*this); return valid(); }
00091 Var var() const { return **this; }
00092 };
00093
00097 class Record
00098 {
00099 dba_record m_rec;
00100
00103 dba_varcode stringToVar(const std::string& str) const
00104 {
00105 const char* s = str.c_str();
00106 return DBA_STRING_TO_VAR(s + 1);
00107 }
00108
00109 void throw_notfound(const std::string& parm) const;
00110 void throw_notfound(dba_keyword parm) const;
00111 void throw_notfound(dba_varcode parm) const;
00112
00113 public:
00114 typedef Var value_type;
00115 typedef RecordIterator iterator;
00116 typedef RecordVarIterator var_iterator;
00117
00119 Record(dba_record rec) : m_rec(rec) {}
00120
00122 Record(const Record& rec)
00123 {
00124 checked(dba_record_create(&m_rec));
00125 checked(dba_record_copy(m_rec, rec.rec()));
00126 }
00128 Record()
00129 {
00130 checked(dba_record_create(&m_rec));
00131 }
00132 ~Record()
00133 {
00134 dba_record_delete(m_rec);
00135 }
00136
00138 Record& operator=(const Record& rec)
00139 {
00140 if (m_rec != rec.rec())
00141 checked(dba_record_copy(m_rec, rec.rec()));
00142 return *this;
00143 }
00144
00146 Record copy() const
00147 {
00148 return Record(*this);
00149 }
00150
00152 void add(const Record& rec)
00153 {
00154 checked(dba_record_add(m_rec, rec.rec()));
00155 }
00156
00159 Record difference(const Record& rec) const
00160 {
00161 Record res;
00162 checked(dba_record_difference(res.rec(), m_rec, rec.rec()));
00163 return res;
00164 }
00165
00167 bool equals(const Record& rec) const
00168 {
00169 return dba_record_equals(m_rec, rec.rec()) == 1;
00170 }
00171
00173 void clear() { dba_record_clear(m_rec); }
00176 void clearVars() { dba_record_clear_vars(m_rec); }
00177
00179 bool contains(const std::string& parm) const
00180 {
00181 int found;
00182 checked(dba_record_contains(m_rec, parm.c_str(), &found));
00183 return found != 0;
00184 }
00186 bool contains(dba_keyword parameter) const
00187 {
00188 int found;
00189 checked(dba_record_contains_key(m_rec, parameter, &found));
00190 return found != 0;
00191 }
00193 bool contains(dba_varcode code) const
00194 {
00195 int found;
00196 checked(dba_record_contains_var(m_rec, code, &found));
00197 return found != 0;
00198 }
00199
00201 Var enq(const std::string& parm) const
00202 {
00203 dba_var var;
00204 checked(dba_record_enq(m_rec, parm.c_str(), &var));
00205 return Var(var);
00206 }
00208 Var operator[](const std::string& parm) const { return enq(parm); }
00210 Var enq(dba_keyword parameter) const
00211 {
00212 dba_var var;
00213 checked(dba_record_key_enq(m_rec, parameter, &var));
00214 return Var(var);
00215 }
00217 Var operator[](dba_keyword parameter) const { return enq(parameter); }
00219 Var enq(dba_varcode code) const
00220 {
00221 dba_var var;
00222 checked(dba_record_var_enq(m_rec, code, &var));
00223 return Var(var);
00224 }
00226 Var operator[](dba_varcode code) const { return enq(code); }
00227
00229 int enqi(const std::string& parm) const
00230 {
00231 int res, ifound;
00232 checked(dba_record_enqi(m_rec, parm.c_str(), &res, &ifound));
00233 if (ifound == 0) throw_notfound(parm);
00234 return res;
00235 }
00237 int enqi(dba_keyword parameter) const
00238 {
00239 int res, ifound;
00240 checked(dba_record_key_enqi(m_rec, parameter, &res, &ifound));
00241 if (ifound == 0) throw_notfound(parameter);
00242 return res;
00243 }
00245 int enqi(dba_varcode code) const
00246 {
00247 int res, ifound;
00248 checked(dba_record_var_enqi(m_rec, code, &res, &ifound));
00249 if (ifound == 0) throw_notfound(code);
00250 return res;
00251 }
00253 int enqi_ifset(const std::string& parm, bool& found) const
00254 {
00255 int res, ifound;
00256 checked(dba_record_enqi(m_rec, parm.c_str(), &res, &ifound));
00257 found = ifound == 1;
00258 return res;
00259 }
00261 int enqi_ifset(dba_keyword parameter, bool& found) const
00262 {
00263 int res, ifound;
00264 checked(dba_record_key_enqi(m_rec, parameter, &res, &ifound));
00265 found = ifound == 1;
00266 return res;
00267 }
00269 int enqi_ifset(dba_varcode code, bool& found) const
00270 {
00271 int res, ifound;
00272 checked(dba_record_var_enqi(m_rec, code, &res, &ifound));
00273 found = ifound == 1;
00274 return res;
00275 }
00276
00278 double enqd(const std::string& parm) const
00279 {
00280 double res;
00281 int ifound;
00282 checked(dba_record_enqd(m_rec, parm.c_str(), &res, &ifound));
00283 if (ifound == 0) throw_notfound(parm);
00284 return res;
00285 }
00287 double enqd(dba_keyword parameter) const
00288 {
00289 double res;
00290 int ifound;
00291 checked(dba_record_key_enqd(m_rec, parameter, &res, &ifound));
00292 if (ifound == 0) throw_notfound(parameter);
00293 return res;
00294 }
00296 double enqd(dba_varcode code) const
00297 {
00298 double res;
00299 int ifound;
00300 checked(dba_record_var_enqd(m_rec, code, &res, &ifound));
00301 if (ifound == 0) throw_notfound(code);
00302 return res;
00303 }
00305 double enqd_ifset(const std::string& parm, bool& found) const
00306 {
00307 double res;
00308 int ifound;
00309 checked(dba_record_enqd(m_rec, parm.c_str(), &res, &ifound));
00310 found = ifound == 1;
00311 return res;
00312 }
00314 double enqd_ifset(dba_keyword parameter, bool& found) const
00315 {
00316 double res;
00317 int ifound;
00318 checked(dba_record_key_enqd(m_rec, parameter, &res, &ifound));
00319 found = ifound == 1;
00320 return res;
00321 }
00323 double enqd_ifset(dba_varcode code, bool& found) const
00324 {
00325 double res;
00326 int ifound;
00327 checked(dba_record_var_enqd(m_rec, code, &res, &ifound));
00328 found = ifound == 1;
00329 return res;
00330 }
00331
00333 const char* enqc(const std::string& parm) const
00334 {
00335 const char* res;
00336 checked(dba_record_enqc(m_rec, parm.c_str(), &res));
00337 if (res == NULL) throw_notfound(parm);
00338 return res;
00339 }
00341 const char* enqc(dba_keyword parameter) const
00342 {
00343 const char* res;
00344 checked(dba_record_key_enqc(m_rec, parameter, &res));
00345 if (res == NULL) throw_notfound(parameter);
00346 return res;
00347 }
00349 const char* enqc(dba_varcode code) const
00350 {
00351 const char* res;
00352 checked(dba_record_var_enqc(m_rec, code, &res));
00353 if (res == NULL) throw_notfound(code);
00354 return res;
00355 }
00357 const char* enqc_ifset(const std::string& parm) const
00358 {
00359 const char* res;
00360 checked(dba_record_enqc(m_rec, parm.c_str(), &res));
00361 return res;
00362 }
00364 const char* enqc_ifset(dba_keyword parameter) const
00365 {
00366 const char* res;
00367 checked(dba_record_key_enqc(m_rec, parameter, &res));
00368 return res;
00369 }
00371 const char* enqc_ifset(dba_varcode code) const
00372 {
00373 const char* res;
00374 checked(dba_record_var_enqc(m_rec, code, &res));
00375 return res;
00376 }
00377
00379 std::string enqs(const std::string& parm) const
00380 {
00381 const char* res;
00382 checked(dba_record_enqc(m_rec, parm.c_str(), &res));
00383 if (res == NULL) throw_notfound(parm);
00384 return res;
00385 }
00387 std::string enqs(dba_keyword parameter) const
00388 {
00389 const char* res;
00390 checked(dba_record_key_enqc(m_rec, parameter, &res));
00391 if (res == NULL) throw_notfound(parameter);
00392 return res;
00393 }
00395 std::string enqs(dba_varcode code) const
00396 {
00397 const char* res;
00398 checked(dba_record_var_enqc(m_rec, code, &res));
00399 if (res == NULL) throw_notfound(code);
00400 return res;
00401 }
00402
00404 std::string enqs_ifset(const std::string& parm, bool& found) const
00405 {
00406 const char* res;
00407 checked(dba_record_enqc(m_rec, parm.c_str(), &res));
00408 if (res == NULL)
00409 {
00410 found = false;
00411 return std::string();
00412 } else {
00413 found = true;
00414 return res;
00415 }
00416 }
00418 std::string enqs_ifset(dba_keyword parameter, bool& found) const
00419 {
00420 const char* res;
00421 checked(dba_record_key_enqc(m_rec, parameter, &res));
00422 if (res == NULL)
00423 {
00424 found = false;
00425 return std::string();
00426 } else {
00427 found = true;
00428 return res;
00429 }
00430 }
00432 std::string enqs_ifset(dba_varcode code, bool& found) const
00433 {
00434 const char* res;
00435 checked(dba_record_var_enqc(m_rec, code, &res));
00436 if (res == NULL)
00437 {
00438 found = false;
00439 return std::string();
00440 } else {
00441 found = true;
00442 return res;
00443 }
00444 }
00445
00447 void set(const std::string& parm, const Var& var);
00449 void keySet(dba_keyword parameter, const Var& var)
00450 {
00451 checked(dba_record_key_set(m_rec, parameter, var.var()));
00452 }
00454 void varSet(dba_varcode code, const Var& var)
00455 {
00456 checked(dba_record_var_set(m_rec, code, var.var()));
00457 }
00459 void set(const Var& var) { varSet(var); }
00461 void varSet(const Var& var)
00462 {
00463 checked(dba_record_var_set_direct(m_rec, var.var()));
00464 }
00465
00467 void set(const std::string& parm, int value) { seti(parm, value); }
00469 void seti(const std::string& parm, int value);
00471 void keySet(dba_keyword parameter, int value) { keySeti(parameter, value); }
00473 void keySeti(dba_keyword parameter, int value)
00474 {
00475 checked(dba_record_key_seti(m_rec, parameter, value));
00476 }
00478 void varSet(dba_varcode code, int value) { varSeti(code, value); }
00480 void varSeti(dba_varcode code, int value)
00481 {
00482 checked(dba_record_var_seti(m_rec, code, value));
00483 }
00485 void set(const std::string& parm, double value) { setd(parm, value); }
00487 void setd(const std::string& parm, double value);
00489 void keySet(dba_keyword parameter, double value) { keySetd(parameter, value); }
00491 void keySetd(dba_keyword parameter, double value)
00492 {
00493 checked(dba_record_key_setd(m_rec, parameter, value));
00494 }
00496 void varSet(dba_varcode code, double value) { varSetd(code, value); }
00498 void varSetd(dba_varcode code, double value)
00499 {
00500 checked(dba_record_var_setd(m_rec, code, value));
00501 }
00503 void set(const std::string& parm, const char* value) { setc(parm, value); }
00505 void setc(const std::string& parm, const char* value);
00507 void keySet(dba_keyword parameter, const char* value) { keySetc(parameter, value); }
00509 void keySetc(dba_keyword parameter, const char* value)
00510 {
00511 checked(dba_record_key_setc(m_rec, parameter, value));
00512 }
00514 void varSet(dba_varcode code, const char* value) { varSetc(code, value); }
00516 void varSetc(dba_varcode code, const char* value)
00517 {
00518 checked(dba_record_var_setc(m_rec, code, value));
00519 }
00521 void set(const std::string& parm, const std::string& value) { sets(parm, value); }
00523 void sets(const std::string& parm, const std::string& value);
00525 void keySet(dba_keyword parameter, const std::string& value) { keySets(parameter, value); }
00527 void keySets(dba_keyword parameter, const std::string& value)
00528 {
00529 checked(dba_record_key_setc(m_rec, parameter, value.c_str()));
00530 }
00532 void varSet(dba_varcode code, const std::string& value) { varSets(code, value); }
00534 void varSets(dba_varcode code, const std::string& value)
00535 {
00536 checked(dba_record_var_setc(m_rec, code, value.c_str()));
00537 }
00538
00541 void setFromString(const std::string& assignment)
00542 {
00543 checked(dba_record_set_from_string(m_rec, assignment.c_str()));
00544 }
00545
00547 void unset(const std::string& parm);
00549 void keyUnset(dba_keyword parameter)
00550 {
00551 checked(dba_record_key_unset(m_rec, parameter));
00552 }
00554 void varUnset(dba_varcode code)
00555 {
00556 checked(dba_record_var_unset(m_rec, code));
00557 }
00558
00560 void setAnaContext()
00561 {
00562 checked(dba_record_set_ana_context(m_rec));
00563 }
00564
00566 const dba_record rec() const
00567 {
00568 return m_rec;
00569 }
00571 dba_record rec()
00572 {
00573 return m_rec;
00574 }
00575
00580 iterator begin()
00581 {
00582 return RecordIterator(m_rec);
00583 }
00584 iterator end()
00585 {
00586 return RecordIterator(m_rec, false);
00587 }
00594 var_iterator varbegin()
00595 {
00596 return RecordVarIterator(m_rec);
00597 }
00598 var_iterator varend()
00599 {
00600 return RecordVarIterator(m_rec, 0);
00601 }
00604
00605 void dumpToStderr();
00606 };
00607
00608 }
00609
00610 #endif