Changeset 15655

Show
Ignore:
Timestamp:
22.05.2008 16:44:51 (11 years ago)
Author:
mdewsnip
Message:

(Adding new DB support) Created default implementations of getinfo() and setinfo() in dbclass so they don't necessarily be re-implemented for every subclass.

Location:
gsdl/trunk/lib
Files:
6 modified

Legend:

Unmodified
Added
Removed
  • gsdl/trunk/lib/dbclass.cpp

    r15652 r15655  
    2626#include "dbclass.h" 
    2727#include "OIDtools.h" 
     28#include "unitool.h" 
    2829 
    2930 
     
    3637  text_t data; 
    3738  return getkeydata (key, data); 
     39} 
     40 
     41 
     42// May be overwritten by subclasses; returns true on success 
     43bool dbclass::getinfo (const text_t& key, infodbclass &info) 
     44{ 
     45  text_t data; 
     46  if (!getkeydata(key, data)) return false; 
     47 
     48  // Use getinfoline() to parse the data value into the infodbclass object 
     49  text_t::iterator data_iterator = data.begin(); 
     50  text_t ikey, ivalue; 
     51  info.clear(); 
     52  while (getinfoline(data_iterator, data.end(), ikey, ivalue)) 
     53  { 
     54    info.addinfo(ikey, ivalue); 
     55  } 
     56 
     57  return true; 
     58} 
     59 
     60 
     61// returns true on success 
     62bool dbclass::getinfoline (text_t::iterator &here, text_t::iterator end,  
     63               text_t &key, text_t &value) 
     64{ 
     65  key.clear(); 
     66  value.clear(); 
     67 
     68  // ignore white space 
     69  while (here != end && is_unicode_space (*here)) ++here; 
     70 
     71  // get the '<' 
     72  if (here == end || *here != '<') return false; 
     73  ++here; 
     74   
     75  // get the key 
     76  while (here != end && *here != '>') { 
     77    key.push_back(*here); 
     78    ++here; 
     79  } 
     80   
     81  // get the '>' 
     82  if (here == end || *here != '>') return false; 
     83  ++here; 
     84   
     85  // get the value 
     86  while (here != end && *here != '\n') { 
     87    if (*here == '\\') {  
     88      // found escape character 
     89      ++here; 
     90      if (here != end) { 
     91    if (*here == 'n') value.push_back ('\n'); 
     92    else if (*here == 'r') value.push_back ('\r'); 
     93    else value.push_back(*here); 
     94      } 
     95 
     96    } else { 
     97      // a normal character 
     98      value.push_back(*here); 
     99    } 
     100 
     101    ++here; 
     102  } 
     103 
     104  return true; 
     105} 
     106 
     107 
     108// returns true on success 
     109bool dbclass::setinfo (const text_t &key, const infodbclass &info) 
     110{ 
     111  text_t subkey; 
     112  text_t data; 
     113 
     114  // get all the keys and values 
     115  infodbclass::const_iterator info_here = info.begin(); 
     116  infodbclass::const_iterator info_end = info.end(); 
     117  while (info_here != info_end) { 
     118    // add the key 
     119    subkey.clear(); 
     120    subkey.push_back('<'); 
     121    text_t::const_iterator subkey_here = (*info_here).first.begin(); 
     122    text_t::const_iterator subkey_end = (*info_here).first.end(); 
     123    while (subkey_here != subkey_end) { 
     124      if (*subkey_here == '>') { 
     125    subkey.push_back('\\'); subkey.push_back('>'); 
     126      } else if (*subkey_here == '\n') { 
     127    subkey.push_back('\\'); subkey.push_back('n'); 
     128      } else if (*subkey_here == '\r') { 
     129    subkey.push_back('\\'); subkey.push_back('r'); 
     130      } else if (*subkey_here == '\\') { 
     131    subkey.push_back('\\'); subkey.push_back('\\'); 
     132      } else { 
     133    subkey.push_back (*subkey_here); 
     134      } 
     135      ++subkey_here; 
     136    } 
     137    subkey.push_back('>'); 
     138 
     139    // add the values 
     140    text_tarray::const_iterator subvalue_here = (*info_here).second.begin(); 
     141    text_tarray::const_iterator subvalue_end = (*info_here).second.end(); 
     142    while (subvalue_here != subvalue_end) { 
     143      data += subkey; 
     144       
     145      text_t::const_iterator thissubvalue_here = (*subvalue_here).begin(); 
     146      text_t::const_iterator thissubvalue_end = (*subvalue_here).end(); 
     147      while (thissubvalue_here != thissubvalue_end) { 
     148    if (*thissubvalue_here == '>') { 
     149      data.push_back('\\'); data.push_back('>'); 
     150    } else if (*thissubvalue_here == '\n') { 
     151      data.push_back('\\'); data.push_back('n'); 
     152    } else if (*thissubvalue_here == '\r') { 
     153      data.push_back('\\'); data.push_back('r'); 
     154    } else if (*thissubvalue_here == '\\') { 
     155      data.push_back('\\'); data.push_back('\\'); 
     156    } else { 
     157      data.push_back (*thissubvalue_here); 
     158    } 
     159     
     160    ++thissubvalue_here; 
     161      } 
     162       
     163      data.push_back('\n'); 
     164      ++subvalue_here; 
     165    } 
     166 
     167    ++info_here; 
     168  } 
     169 
     170  return setkeydata(key, data); 
    38171} 
    39172 
  • gsdl/trunk/lib/dbclass.h

    r15652 r15655  
    5454  virtual ~dbclass(); 
    5555 
    56   // MUST be implemented by subclasses; returns true if opened 
     56  void setlogout (ostream *logout_arg) { logout = logout_arg; } 
     57 
     58 
     59  // ----------------------------------------------------------------------------------------------- 
     60  // These functions MUST be implemented by subclasses, as they are database-specific 
     61 
     62  // returns true if opened 
    5763  virtual bool opendatabase (const text_t &filename, int mode, int num_retrys, bool need_filelock) = 0; 
    5864 
    59   // MUST be implemented by subclasses 
    6065  virtual void closedatabase () = 0; 
    6166 
    62   // MUST be implemented by subclasses 
    6367  virtual void deletekey (const text_t &key) = 0; 
    6468 
    65   // May be overwritten by subclasses; returns true if exists 
    66   virtual bool exists (const text_t& key); 
    67  
    68   // Must be implemented by subclasses; returns true on success 
    69   virtual bool getinfo (const text_t& key, infodbclass &info) = 0; 
    70  
    71   // MUST be implemented by subclasses; returns true on success 
     69  // returns true on success 
    7270  virtual bool getkeydata (const text_t& key, text_t &data) = 0; 
    7371 
    74   // MUST be implemented by subclasses; returns array of keys 
     72  // returns array of keys 
    7573  virtual text_tarray getkeys () = 0; 
    7674 
    77   // Must be implemented by subclasses; returns true on success 
    78   virtual bool setinfo (const text_t &key, const infodbclass &info) = 0; 
    79  
    80   // MUST be implemented by subclasses; returns true on success 
     75  // returns true on success 
    8176  virtual bool setkeydata (const text_t &key, const text_t &data) = 0; 
    8277 
    8378 
    84   void setlogout (ostream *logout_arg) { logout = logout_arg; } 
     79  // ----------------------------------------------------------------------------------------------- 
     80  // These functions may be overwritten by subclasses, but a default implementation is provided 
     81 
     82  // returns true if exists 
     83  virtual bool exists (const text_t& key); 
     84 
     85  // returns true on success 
     86  virtual bool getinfo (const text_t& key, infodbclass &info); 
     87 
     88  // returns true on success 
     89  virtual bool setinfo (const text_t &key, const infodbclass &info); 
     90 
    8591 
    8692  // replaces the .c, .p, .n, .l syntax (child, parent, next, previous)  
     
    9298  ostream *logout; 
    9399 
     100  // returns true on success 
     101  bool getinfoline (text_t::iterator &here, text_t::iterator end, text_t &key, text_t &value); 
     102 
    94103  void get_first_child (text_t &OID, infodbclass &info); 
    95104  void get_last_child (text_t &OID, infodbclass &info); 
  • gsdl/trunk/lib/gdbmclass.cpp

    r15652 r15655  
    116116 
    117117// returns true on success 
    118 bool gdbmclass::getinfo (const text_t& key, infodbclass &info) 
    119 { 
    120   text_t data; 
    121   if (!getkeydata(key, data)) return false; 
    122  
    123   // Use getinfoline() to parse the data value into the infodbclass object 
    124   text_t::iterator data_iterator = data.begin(); 
    125   text_t ikey, ivalue; 
    126   info.clear(); 
    127   while (getinfoline(data_iterator, data.end(), ikey, ivalue)) 
    128   { 
    129     info.addinfo(ikey, ivalue); 
    130   } 
    131  
    132   return true; 
    133 } 
    134  
    135  
    136 // returns true on success 
    137118bool gdbmclass::getkeydata (const text_t& key, text_t &data) 
    138119{ 
     
    181162 
    182163// returns true on success 
    183 bool gdbmclass::setinfo (const text_t &key, const infodbclass &info) 
    184 { 
    185   if (gdbmfile == NULL) return false; 
    186  
    187   text_t subkey; 
    188   text_t data; 
    189  
    190   // get all the keys and values 
    191   infodbclass::const_iterator info_here = info.begin(); 
    192   infodbclass::const_iterator info_end = info.end(); 
    193   while (info_here != info_end) { 
    194     // add the key 
    195     subkey.clear(); 
    196     subkey.push_back('<'); 
    197     text_t::const_iterator subkey_here = (*info_here).first.begin(); 
    198     text_t::const_iterator subkey_end = (*info_here).first.end(); 
    199     while (subkey_here != subkey_end) { 
    200       if (*subkey_here == '>') { 
    201     subkey.push_back('\\'); subkey.push_back('>'); 
    202       } else if (*subkey_here == '\n') { 
    203     subkey.push_back('\\'); subkey.push_back('n'); 
    204       } else if (*subkey_here == '\r') { 
    205     subkey.push_back('\\'); subkey.push_back('r'); 
    206       } else if (*subkey_here == '\\') { 
    207     subkey.push_back('\\'); subkey.push_back('\\'); 
    208       } else { 
    209     subkey.push_back (*subkey_here); 
    210       } 
    211       ++subkey_here; 
    212     } 
    213     subkey.push_back('>'); 
    214  
    215     // add the values 
    216     text_tarray::const_iterator subvalue_here = (*info_here).second.begin(); 
    217     text_tarray::const_iterator subvalue_end = (*info_here).second.end(); 
    218     while (subvalue_here != subvalue_end) { 
    219       data += subkey; 
    220        
    221       text_t::const_iterator thissubvalue_here = (*subvalue_here).begin(); 
    222       text_t::const_iterator thissubvalue_end = (*subvalue_here).end(); 
    223       while (thissubvalue_here != thissubvalue_end) { 
    224     if (*thissubvalue_here == '>') { 
    225       data.push_back('\\'); data.push_back('>'); 
    226     } else if (*thissubvalue_here == '\n') { 
    227       data.push_back('\\'); data.push_back('n'); 
    228     } else if (*thissubvalue_here == '\r') { 
    229       data.push_back('\\'); data.push_back('r'); 
    230     } else if (*thissubvalue_here == '\\') { 
    231       data.push_back('\\'); data.push_back('\\'); 
    232     } else { 
    233       data.push_back (*thissubvalue_here); 
    234     } 
    235      
    236     ++thissubvalue_here; 
    237       } 
    238        
    239       data.push_back('\n'); 
    240       ++subvalue_here; 
    241     } 
    242  
    243     ++info_here; 
    244   } 
    245  
    246   return setkeydata(key, data); 
    247 } 
    248  
    249  
    250 // returns true on success 
    251164bool gdbmclass::setkeydata (const text_t &key, const text_t &data) 
    252165{ 
     
    329242  return to_uni(nextkey);  // convert to unicode 
    330243} 
    331  
    332  
    333 // returns true on success 
    334 bool gdbmclass::getinfoline (text_t::iterator &here, text_t::iterator end,  
    335                  text_t &key, text_t &value) 
    336 { 
    337   key.clear(); 
    338   value.clear(); 
    339  
    340   // ignore white space 
    341   while (here != end && is_unicode_space (*here)) ++here; 
    342  
    343   // get the '<' 
    344   if (here == end || *here != '<') return false; 
    345   ++here; 
    346    
    347   // get the key 
    348   while (here != end && *here != '>') { 
    349     key.push_back(*here); 
    350     ++here; 
    351   } 
    352    
    353   // get the '>' 
    354   if (here == end || *here != '>') return false; 
    355   ++here; 
    356    
    357   // get the value 
    358   while (here != end && *here != '\n') { 
    359     if (*here == '\\') {  
    360       // found escape character 
    361       ++here; 
    362       if (here != end) { 
    363     if (*here == 'n') value.push_back ('\n'); 
    364     else if (*here == 'r') value.push_back ('\r'); 
    365     else value.push_back(*here); 
    366       } 
    367  
    368     } else { 
    369       // a normal character 
    370       value.push_back(*here); 
    371     } 
    372  
    373     ++here; 
    374   } 
    375  
    376   return true; 
    377 } 
  • gsdl/trunk/lib/gdbmclass.h

    r15652 r15655  
    6363 
    6464  // returns true on success 
    65   bool getinfo (const text_t& key, infodbclass &info); 
    66  
    67   // returns true on success 
    6865  bool getkeydata (const text_t& key, text_t &data); 
    6966 
    7067  // returns array of keys 
    7168  text_tarray getkeys (); 
    72  
    73   // returns true on success 
    74   bool setinfo (const text_t &key, const infodbclass &info); 
    7569 
    7670  // returns true on success 
     
    8781  text_t getfirstkey (); 
    8882  text_t getnextkey (const text_t &key); 
    89  
    90   // returns true on success 
    91   bool getinfoline (text_t::iterator &here, text_t::iterator end, text_t &key, text_t &value); 
    9283}; 
    9384 
  • gsdl/trunk/lib/sqlitedbclass.cpp

    r15652 r15655  
    9090 
    9191// returns true on success 
    92 bool sqlitedbclass::getinfo (const text_t& key, infodbclass &info) 
    93 { 
    94   text_t data; 
    95   if (!getkeydata(key, data)) return false; 
    96  
    97   // Use getinfoline() to parse the data value into the infodbclass object 
    98   text_t::iterator data_iterator = data.begin(); 
    99   text_t ikey, ivalue; 
    100   info.clear(); 
    101   while (getinfoline(data_iterator, data.end(), ikey, ivalue)) 
    102   { 
    103     info.addinfo(ikey, ivalue); 
    104   } 
    105  
    106   return true; 
    107 } 
    108  
    109  
    110 // returns true on success 
    11192bool sqlitedbclass::getkeydata (const text_t& key, text_t &data) 
    11293{ 
     
    151132 
    152133// returns true on success 
    153 bool sqlitedbclass::setinfo (const text_t &key, const infodbclass &info) 
    154 { 
    155   text_t subkey; 
    156   text_t data; 
    157  
    158   // get all the keys and values 
    159   infodbclass::const_iterator info_here = info.begin(); 
    160   infodbclass::const_iterator info_end = info.end(); 
    161   while (info_here != info_end) { 
    162     // add the key 
    163     subkey.clear(); 
    164     subkey.push_back('<'); 
    165     text_t::const_iterator subkey_here = (*info_here).first.begin(); 
    166     text_t::const_iterator subkey_end = (*info_here).first.end(); 
    167     while (subkey_here != subkey_end) { 
    168       if (*subkey_here == '>') { 
    169     subkey.push_back('\\'); subkey.push_back('>'); 
    170       } else if (*subkey_here == '\n') { 
    171     subkey.push_back('\\'); subkey.push_back('n'); 
    172       } else if (*subkey_here == '\r') { 
    173     subkey.push_back('\\'); subkey.push_back('r'); 
    174       } else if (*subkey_here == '\\') { 
    175     subkey.push_back('\\'); subkey.push_back('\\'); 
    176       } else { 
    177     subkey.push_back (*subkey_here); 
    178       } 
    179       ++subkey_here; 
    180     } 
    181     subkey.push_back('>'); 
    182  
    183     // add the values 
    184     text_tarray::const_iterator subvalue_here = (*info_here).second.begin(); 
    185     text_tarray::const_iterator subvalue_end = (*info_here).second.end(); 
    186     while (subvalue_here != subvalue_end) { 
    187       data += subkey; 
    188        
    189       text_t::const_iterator thissubvalue_here = (*subvalue_here).begin(); 
    190       text_t::const_iterator thissubvalue_end = (*subvalue_here).end(); 
    191       while (thissubvalue_here != thissubvalue_end) { 
    192     if (*thissubvalue_here == '>') { 
    193       data.push_back('\\'); data.push_back('>'); 
    194     } else if (*thissubvalue_here == '\n') { 
    195       data.push_back('\\'); data.push_back('n'); 
    196     } else if (*thissubvalue_here == '\r') { 
    197       data.push_back('\\'); data.push_back('r'); 
    198     } else if (*thissubvalue_here == '\\') { 
    199       data.push_back('\\'); data.push_back('\\'); 
    200     } else { 
    201       data.push_back (*thissubvalue_here); 
    202     } 
    203      
    204     ++thissubvalue_here; 
    205       } 
    206        
    207       data.push_back('\n'); 
    208       ++subvalue_here; 
    209     } 
    210  
    211     ++info_here; 
    212   } 
    213  
    214   return setkeydata(key, data); 
    215 } 
    216  
    217  
    218 // returns true on success 
    219134bool sqlitedbclass::setkeydata (const text_t &key, const text_t &data) 
    220135{ 
     
    233148 
    234149 
    235 // returns true on success 
    236 bool sqlitedbclass::getinfoline (text_t::iterator &here, text_t::iterator end,  
    237                  text_t &key, text_t &value) 
    238 { 
    239   key.clear(); 
    240   value.clear(); 
    241  
    242   // ignore white space 
    243   while (here != end && is_unicode_space (*here)) ++here; 
    244  
    245   // get the '<' 
    246   if (here == end || *here != '<') return false; 
    247   ++here; 
    248    
    249   // get the key 
    250   while (here != end && *here != '>') { 
    251     key.push_back(*here); 
    252     ++here; 
    253   } 
    254    
    255   // get the '>' 
    256   if (here == end || *here != '>') return false; 
    257   ++here; 
    258    
    259   // get the value 
    260   while (here != end && *here != '\n') { 
    261     if (*here == '\\') {  
    262       // found escape character 
    263       ++here; 
    264       if (here != end) { 
    265     if (*here == 'n') value.push_back ('\n'); 
    266     else if (*here == 'r') value.push_back ('\r'); 
    267     else value.push_back(*here); 
    268       } 
    269  
    270     } else { 
    271       // a normal character 
    272       value.push_back(*here); 
    273     } 
    274  
    275     ++here; 
    276   } 
    277  
    278   return true; 
    279 } 
    280  
    281  
    282150// ---------------------------------------------------------------------------------------- 
    283 //   CORE SQL FUNCTIONS 
     151//   SQLITE-ONLY FUNCTIONS 
    284152// ---------------------------------------------------------------------------------------- 
    285153 
  • gsdl/trunk/lib/sqlitedbclass.h

    r15652 r15655  
    4646 
    4747  // returns true on success 
    48   bool getinfo (const text_t& key, infodbclass &info); 
    49  
    50   // returns true on success 
    5148  bool getkeydata (const text_t& key, text_t &data); 
    5249 
    5350  // returns array of keys 
    5451  text_tarray getkeys (); 
    55  
    56   // returns true on success 
    57   bool setinfo (const text_t &key, const infodbclass &info); 
    5852 
    5953  // returns true on success 
     
    6458  sqlite3* sqlitefile; 
    6559 
    66   bool getinfoline (text_t::iterator &here, text_t::iterator end, text_t &key, text_t &value); 
    67  
    6860  bool sqlexec (const text_t &sql_cmd); 
    6961  bool sqlgetarray (const text_t &sql_cmd, vector<text_tmap> &sql_results);