dballe++ 4.0.18
|
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 // Iterator methods 00025 // operator->() is missing for simplicity's sake 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 // Bindings-friendly methods 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 // Iterator methods 00059 // operator->() is missing for simplicity's sake 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 // Bindings-friendly methods 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