• Main Page
  • Data Structures
  • Files
  • File List

record.h

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

Generated on Wed Dec 8 2010 18:13:31 for dballe++ by  doxygen 1.7.2