home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / vbdatabs / pod.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1999-03-14  |  11.2 KB  |  387 lines
  1. // ------------------------------- //
  2. // -------- Start of File -------- //
  3. // ------------------------------- //
  4. // ----------------------------------------------------------- // 
  5. // C++ Source Code File Name: pod.cpp 
  6. // Compiler Used: MSVC40, DJGPP 2.7.2.1, GCC 2.7.2.1, HP CPP 10.24
  7. // Produced By: Doug Gaer  
  8. // File Creation Date: 09/18/1997 
  9. // Date Last Modified: 03/15/1999
  10. // Copyright (c) 1997 Douglas M. Gaer
  11. // ----------------------------------------------------------- // 
  12. // ------------- Program Description and Details ------------- // 
  13. // ----------------------------------------------------------- // 
  14. /*
  15. The VBD C++ classes are copyright (c) 1997, by Douglas M. Gaer.
  16. All those who put this code or its derivatives in a commercial
  17. product MUST mention this copyright in their documentation for
  18. users of the products in which this code or its derivative
  19. classes are used. Otherwise, you have the freedom to redistribute
  20. verbatim copies of this source code, adapt it to your specific
  21. needs, or improve the code and release your improvements to the
  22. public provided that the modified files carry prominent notices
  23. stating that you changed the files and the date of any change.
  24.  
  25. THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND.
  26. THE ENTIRE RISK OF THE QUALITY AND PERFORMANCE OF THIS SOFTWARE
  27. IS WITH YOU. SHOULD ANY ELEMENT OF THIS SOFTWARE PROVE DEFECTIVE,
  28. YOU WILL ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR, OR
  29. CORRECTION.
  30.  
  31. The (P)ersistent (O)bject (D)atabase manager is used to manage
  32. the file pointers to VBD files.
  33. */
  34. // ----------------------------------------------------------- // 
  35. #include "pod.h"
  36.  
  37. // File extensions for data and index files
  38. const char *data_ext = ".pod"; // Data file created with POD/Persist classes
  39. const char *idx_ext = ".btx";  // Index file created with the Btree class
  40.  
  41. // NOTE: The index file will always be created with the Btree class
  42. // The DTree class is provided for testing purposes.
  43. // const char *idx_ext = ".dtx";  // Index file created with the DTree class
  44.  
  45. POD::POD(UString &fname, VBDFile::AccessMode mode,
  46.      int use_index, int cache_size)
  47. {
  48.   // Do not use any file extensions when creating or opening file.
  49.   // Both data and index will share the same name with different
  50.   // file extensions. 
  51.   UString DataFile(fname+data_ext);
  52.   UString IndexFile(fname+idx_ext);
  53.  
  54.   using_index = use_index;
  55.   DBindex = new Btree(cache_size);
  56.   
  57.   if(!VBDFile::Exists(DataFile.c_str())) {
  58.     Create(fname);
  59.     exists = 0;
  60.     if(using_index) {
  61.       CreateIndex(fname);
  62.       rebuild_index = 0;
  63.       DBindex->Connect(openindexfile, 1);
  64.     }
  65.   }
  66.   else {
  67.     Open(fname, mode); // Open the data file
  68.     exists = 1;
  69.     if(using_index) { // Open the index file if it exist
  70.       if(!VBDFile::Exists(IndexFile.c_str())) {
  71.     CreateIndex(fname);
  72.     rebuild_index = 1;
  73.     DBindex->Connect(openindexfile, 1);
  74.       }
  75.       else {
  76.     OpenIndex(fname, mode);
  77.     rebuild_index = 0;
  78.     DBindex->Connect(openindexfile, 0);
  79.       }
  80.     }
  81.   }
  82. }
  83.  
  84. POD::POD(const char *fname, VBDFile::AccessMode mode,
  85.      int use_index, int cache_size)
  86. {
  87.   // Do not use any file extensions when creating or opening file.
  88.   // Both data and index will share the same name with different
  89.   // file extensions. 
  90.   UString DataFile(fname);
  91.   UString IndexFile(fname);
  92.  
  93.   // Append the file extensions
  94.   DataFile = DataFile + data_ext;
  95.   IndexFile = IndexFile + idx_ext;
  96.  
  97.   using_index = use_index;
  98.   DBindex = new Btree(cache_size);
  99.   
  100.   if(!VBDFile::Exists(DataFile.c_str())) {
  101.     Create(fname);
  102.     exists = 0;
  103.     if(using_index) {
  104.       CreateIndex(fname);
  105.       rebuild_index = 0;
  106.       DBindex->Connect(openindexfile, 1);
  107.     }
  108.   }
  109.   else {
  110.     Open(fname, mode); // Open the data file
  111.     exists = 1;
  112.     if(using_index) { // Open the index file if it exist
  113.       if(!VBDFile::Exists(IndexFile.c_str())) {
  114.     CreateIndex(fname);
  115.     rebuild_index = 1;
  116.     DBindex->Connect(openindexfile, 1);
  117.       }
  118.       else {
  119.     OpenIndex(fname, mode);
  120.     rebuild_index = 0;
  121.     DBindex->Connect(openindexfile, 0);
  122.       }
  123.     }
  124.   }
  125. }
  126.  
  127. POD::POD(UString &dfname, UString &ifname, VBDFile::AccessMode mode, 
  128.       int use_index, int cache_size)
  129. // 02/04/1998 This constructor was added to allow an application
  130. // to used different index and data files. No file extensions will
  131. // be added to the file names.
  132. {
  133.   using_index = use_index;
  134.   DBindex = new Btree(cache_size);
  135.   
  136.   if(!VBDFile::Exists(dfname.c_str())) {
  137.     Create(dfname, 0); // Do not add file extension
  138.     exists = 0;
  139.     if(using_index) {
  140.       if(!VBDFile::Exists(ifname.c_str())) {
  141.     // Do not overwrite the index file
  142.     CreateIndex(ifname, 0); // Do not add file extension 
  143.     rebuild_index = 0;
  144.     DBindex->Connect(openindexfile, 1);
  145.       }
  146.     }
  147.   }
  148.   else {
  149.     Open(dfname, mode, 0); // Open the data file
  150.     exists = 1;
  151.     if(using_index) { // Open the index file if it exist
  152.       if(!VBDFile::Exists(ifname.c_str())) {
  153.     CreateIndex(ifname, 0);
  154.     rebuild_index = 1;
  155.     DBindex->Connect(openindexfile, 1);
  156.       }
  157.       else {
  158.     OpenIndex(ifname, mode, 0);
  159.     rebuild_index = 0;
  160.     DBindex->Connect(openindexfile, 0);
  161.       }
  162.     }
  163.   }
  164. }
  165.  
  166. POD::POD(const char *dfname, const char *ifname, VBDFile::AccessMode mode,
  167.       int use_index, int cache_size)
  168. // 02/04/1998 This constructor was added to allow an application
  169. // to used different index and data files. No file extensions will
  170. // be added to the file names.
  171. {
  172.   using_index = use_index;
  173.   DBindex = new Btree(cache_size);
  174.   
  175.   if(!VBDFile::Exists(dfname)) {
  176.     Create(dfname, 0); // Do not add file extension
  177.     exists = 0;
  178.     if(using_index) {
  179.       if(!VBDFile::Exists(ifname)) {
  180.     // Do not overwrite the index file
  181.     CreateIndex(ifname, 0); // Do not add file extension 
  182.     rebuild_index = 0;
  183.     DBindex->Connect(openindexfile, 1);
  184.       }
  185.     }
  186.   }
  187.   else {
  188.     Open(dfname, mode, 0); // Open the data file
  189.     exists = 1;
  190.     if(using_index) { // Open the index file if it exist
  191.       if(!VBDFile::Exists(ifname)) {
  192.     CreateIndex(ifname, 0);
  193.     rebuild_index = 1;
  194.     DBindex->Connect(openindexfile, 1);
  195.       }
  196.       else {
  197.     OpenIndex(ifname, mode, 0);
  198.     rebuild_index = 0;
  199.     DBindex->Connect(openindexfile, 0);
  200.       }
  201.     }
  202.   }
  203. }
  204.  
  205. int POD::Connect(VBDFilePtr &fp)
  206. {
  207.   if(!fp) return 0;
  208.   opendatabase = fp; 
  209.   if(opendatabase->IsOK()) return 1; else return 0;
  210. }
  211.  
  212. int POD::ConnectIndex(VBDFilePtr &fp)
  213. {
  214.   if(!fp) return 0;
  215.   openindexfile = fp; 
  216.   if(openindexfile->IsOK()) return 1; else return 0;
  217. }
  218.  
  219. int POD::Create(const UString &fname, int add_ext)
  220. {
  221.   UString DataFile(fname);
  222.  
  223.   // Both data and index will share the same name with different
  224.   // file extensions if add_ext is true.
  225.   if(add_ext) DataFile = DataFile + data_ext;
  226.  
  227.   Disconnect();
  228.   VBDFilePtr tmp(new VBDFile);
  229.   VBDFilePtr nul = 0; // Used to satisfy overloaded == in RefCount class 
  230.   if (tmp == nul) return 0;
  231.   tmp->Create(DataFile.c_str());
  232.   if (!tmp->IsOK()) return 0;
  233.   return Connect(tmp);
  234. }
  235.  
  236. int POD::CreateIndex(const UString &fname, int add_ext)
  237. {
  238.   UString IndexFile(fname);
  239.   
  240.   // Both data and index will share the same name with different
  241.   // file extensions if add_ext is true.
  242.   if(add_ext) IndexFile = IndexFile + idx_ext;
  243.  
  244.   DisconnectIndex();
  245.   VBDFilePtr tmp(new VBDFile);
  246.   VBDFilePtr nul = 0; // Used to satisfy overloaded == in RefCount class 
  247.   if (tmp == nul) return 0;
  248.   tmp->Create(IndexFile.c_str(), sizeof(BtreeHeader));
  249.   if (!tmp->IsOK()) return 0;
  250.   return ConnectIndex(tmp);
  251. }
  252.  
  253. int POD::Create(const char *fname, int add_ext)
  254. {
  255.   UString DataFile(fname);
  256.  
  257.   // Both data and index will share the same name with different
  258.   // file extensions if add_ext is true.
  259.   if(add_ext) DataFile = DataFile + data_ext;
  260.   
  261.   Disconnect();
  262.   VBDFilePtr tmp(new VBDFile);
  263.   VBDFilePtr nul = 0; // Used to satisfy overloaded == in RefCount class 
  264.   if (tmp == nul) return 0;
  265.   tmp->Create(DataFile.c_str());
  266.   if (!tmp->IsOK()) return 0;
  267.   return Connect(tmp);
  268. }
  269.  
  270. int POD::CreateIndex(const char *fname, int add_ext)
  271. {
  272.   UString IndexFile(fname);
  273.   
  274.   // Both data and index will share the same name with different
  275.   // file extensions if add_ext is true.
  276.   if(add_ext) IndexFile = IndexFile + idx_ext;
  277.  
  278.   DisconnectIndex();
  279.   VBDFilePtr tmp(new VBDFile);
  280.   VBDFilePtr nul = 0; // Used to satisfy overloaded == in RefCount class 
  281.   if (tmp == nul) return 0;
  282.   tmp->Create(IndexFile.c_str(), sizeof(BtreeHeader));
  283.   if (!tmp->IsOK()) return 0;
  284.   return ConnectIndex(tmp);
  285. }
  286.  
  287. void POD::Disconnect()
  288. // Disconnects the database from the file.
  289. {
  290.   if(opendatabase) {
  291.     opendatabase->Close();
  292.   }
  293. }
  294.  
  295. void POD::DisconnectIndex()
  296. // Disconnects the database from the file.
  297. {
  298.   if(DBindex) {
  299.     DBindex->Disconnect();
  300.   }
  301.  
  302.   if(openindexfile) {
  303.     openindexfile->Close();
  304.   }
  305. }
  306.  
  307. void POD::Flush()
  308. {
  309.   if (opendatabase->IsOK()) {
  310.      if (opendatabase->ReadyForWriting()) {
  311.         opendatabase->Flush();
  312.      }
  313.   }
  314. }
  315.  
  316. int POD::Open(const UString &fname, VBDFile::AccessMode mode, int add_ext)
  317. {
  318.   UString DataFile(fname);
  319.  
  320.   // Both data and index will share the same name with different
  321.   // file extensions if add_ext is true.
  322.   if(add_ext) DataFile = DataFile + data_ext;
  323.  
  324.   Disconnect();
  325.   VBDFilePtr tmp(new VBDFile);
  326.   VBDFilePtr nul = 0; // Used to satisfy overloaded == in RefCount class 
  327.   if (tmp == nul) return 0;
  328.   tmp->Open(DataFile.c_str(), mode);
  329.   if (!tmp->IsOK()) return 0;
  330.   return Connect(tmp);
  331. }
  332.  
  333. int POD::Open(const char *fname, VBDFile::AccessMode mode, int add_ext)
  334. {
  335.   UString DataFile(fname);
  336.  
  337.   // Both data and index will share the same name with different
  338.   // file extensions if add_ext is true.
  339.   if(add_ext) DataFile = DataFile + data_ext;
  340.  
  341.   Disconnect();
  342.   VBDFilePtr tmp(new VBDFile);
  343.   VBDFilePtr nul = 0; // Used to satisfy overloaded == in RefCount class 
  344.   if (tmp == nul) return 0;
  345.   tmp->Open(DataFile.c_str(), mode);
  346.   if (!tmp->IsOK()) return 0;
  347.   return Connect(tmp);
  348. }
  349.  
  350. int POD::OpenIndex(const UString &fname, VBDFile::AccessMode mode, int add_ext)
  351. {
  352.   UString IndexFile(fname);
  353.   
  354.   // Both data and index will share the same name with different
  355.   // file extensions if add_ext is true.
  356.   if(add_ext) IndexFile = IndexFile + idx_ext;
  357.   
  358.   DisconnectIndex();
  359.   VBDFilePtr tmp(new VBDFile);
  360.   VBDFilePtr nul = 0; // Used to satisfy overloaded == in RefCount class 
  361.   if (tmp == nul) return 0;
  362.   tmp->Open(IndexFile.c_str(), mode);
  363.   if (!tmp->IsOK()) return 0;
  364.   return ConnectIndex(tmp);
  365. }
  366.  
  367. int POD::OpenIndex(const char *fname, VBDFile::AccessMode mode, int add_ext)
  368. {
  369.   UString IndexFile(fname);
  370.   
  371.   // Both data and index will share the same name with different
  372.   // file extensions if add_ext is true.
  373.   if(add_ext) IndexFile = IndexFile + idx_ext;
  374.   
  375.   DisconnectIndex();
  376.   VBDFilePtr tmp(new VBDFile);
  377.   VBDFilePtr nul = 0; // Used to satisfy overloaded == in RefCount class 
  378.   if (tmp == nul) return 0;
  379.   tmp->Open(IndexFile.c_str(), mode);
  380.   if (!tmp->IsOK()) return 0;
  381.   return ConnectIndex(tmp);
  382. }
  383. // ----------------------------------------------------------- //
  384. // ------------------------------- //
  385. // --------- End of File --------- //
  386. // ------------------------------- //
  387.