home *** CD-ROM | disk | FTP | other *** search
/ Borland Programmer's Resource / Borland_Programmers_Resource_CD_1995.iso / code / kdbf / example / demo.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-19  |  11.3 KB  |  376 lines
  1. /****************************************************************************
  2. *                                                                           
  3. * FILE: DEMO.H
  4. *
  5. * DESCRIPTION:  This file contains the class definitions for the Restaurant
  6. *               sample program.  
  7. *
  8. *  NOTES:    The sample program provides basic functions that are
  9. *            relevant to most applications. The program provides 
  10. *            functions for searching, retrieving and copying data. It 
  11. *            also provides basic database operations such as opening,   
  12. *            and closing database tables, and using cursors.
  13. * 
  14. *            The Restaurant application uses a single database 
  15. *            consisting of two tables. The first table, EATS, contains 
  16. *            data on individual restaurants; name, address, how they 
  17. *            are rated, a review, and a menu for each restaurant. The 
  18. *            EATS table acts as a glossary for all restaurants. The
  19. *            second table, FAVEATS, provides a list of favorite 
  20. *            restaurants that have been copied from the EATS table and 
  21. *            used as a reference for those restaurants that the user
  22. *            has patronized. 
  23. *
  24. *            The database is initialized by user-defined types provided
  25. *            by C++ classes. A list of these types are BEngine, BDatabase,
  26. *            Main Restaurant, and FavoriteRestaurant. Each table in the 
  27. *            database is opened and closed by member functions provided 
  28. *            by the MainRestaurant and FavoriteRestaurant instances. These
  29. *            two types of instances are the two objects in the application
  30. *            corresponding to the two tables in the database. The user 
  31. *            manipulates the tables in the database through member
  32. *            functions (for example, open and close) provided by each 
  33. *            object.
  34. *
  35. *            Movement between records in the tables are provide by
  36. *            member functions Home, End, Up and Down. The cursor acts as
  37. *            a pointer to records in each table. Through the cursor, a
  38. *            user can access data in a particular record. Home sets 
  39. *            the cursor to the first record in the table and End sets 
  40. *            the cursor to the last record in the table. Up sets the
  41. *            cursor to the previous record and Down sets the cursor to
  42. *            the next record in the table.
  43. *
  44. *            Access of data in a record is provided by member functions
  45. *            getRecord, getQuickReview, getReview, and getMenu. Except
  46. *            for getRecord, the other data access functions deal with
  47. *            with retrieving data from BLOB fields. getRecord accesses
  48. *            the current record and retrieve all field values except 
  49. *            BLOBs, and assign variables within the object for the
  50. *            field values retrieved. The user can then reference 
  51. *            these variables. getQuickReview, getReview, and getMenu 
  52. *            retrieve the current records individual BLOB fields. 
  53. *            The EATS table contains two BLOB fields , Review and
  54. *            Menu. The FAVEATS tables contains one BLOB field named
  55. *            Menu. sizeOfMenuBlob and sizeOfReviewBlob are additional 
  56. *            functions provide for accessing these BLOB fields. 
  57. *
  58. *            Two member functions provide searching methods for the
  59. *            EATS table.  findRatingType and findCityType define
  60. *            two searches to locate a restaurant, the first searching 
  61. *            restaurants by rating and type. The second function searches 
  62. *            based on city and type. Each search function can declare its
  63. *            search method to search for the first occurrence of specified
  64. *            field values or search for the next occurrence after a
  65. *            successful search has occurred.
  66. *
  67. *            To copy all relevant data from the EATS table to the
  68. *            FAVREST table, a user can call the copyToFavorite member
  69. *            function. This function provides all record locking, handles
  70. *            concurrency issues and access to both tables to perform a 
  71. *            copy of the current record from the EATS table to the 
  72. *            FAVREST table.
  73. *
  74. *
  75. ****************************************************************************/
  76. //
  77. // include files
  78. //
  79. #include <bengine.h>
  80. #include <bdatabas.h>
  81. #include <bcursor.h>
  82. #include <brecord.h>
  83.  
  84. #ifdef _MSC_VER
  85. #include <memory.h>
  86. #else
  87. #include <mem.h>
  88. #endif
  89.  
  90. //
  91. // Defines for field lengths.
  92. //
  93. #define MAX_NAME_LEN      50
  94. #define MAX_TYPE_LEN      15
  95. #define MAX_STREET_LEN    50
  96. #define MAX_CITY_LEN      50
  97. #define MAX_STATE_LEN     20
  98. #define MAX_ZIP_LEN       10
  99. #define MAX_TELEPHONE_LEN 14
  100.  
  101. //
  102. // Define a buffer size to copy BLOBs.
  103. //
  104. #define BLOB_COPY_LEN 255
  105.  
  106. //
  107. // Defines for field handles to the main table.
  108. //
  109. #define MAIN_NAME_FIELD       1
  110. #define MAIN_STREET_FIELD     2
  111. #define MAIN_CITY_FIELD       3
  112. #define MAIN_STATE_FIELD      4
  113. #define MAIN_ZIP_FIELD        5
  114. #define MAIN_TELEPHONE_FIELD  6
  115. #define MAIN_TYPE_FIELD       7
  116. #define MAIN_RATING_FIELD     8
  117. #define MAIN_REVIEW_FIELD     9
  118. #define MAIN_MENU_FIELD       10
  119.  
  120. //
  121. // Defines for field handles to the Favorite table.
  122. //
  123. #define FAV_NAME_FIELD    1
  124. #define FAV_TYPE_FIELD    2
  125. #define FAV_MENU_FIELD    3
  126.  
  127. //
  128. // Quick review data size.
  129. //
  130. #define MAX_REVIEW_SIZE 80
  131.  
  132. //
  133. // Some special errors returned by the restaurant classes.
  134. //
  135. #define ERROR_TABLENOTOPEN   -1
  136.  
  137. //
  138. // Define the name of the composite indexes for the main table.
  139. //
  140. #define RATING_TYPE_INDEX "rating/type"
  141. #define CITY_TYPE_INDEX   "city/type"
  142.  
  143. //
  144. // Define the number of fields in the secondary indexes.
  145. //
  146. #define RATING_TYPE_FLDCOUNT  2
  147. #define CITY_TYPE_FLDCOUNT    2
  148.  
  149.  
  150. /****************************************************************************
  151. *
  152. * This is the base class for the different restaurant tables that will be
  153. * used in the program.
  154. *
  155. ****************************************************************************/
  156.  
  157. class AbstractRestaurant {
  158.  
  159. protected:
  160.  
  161.   //
  162.   // Flag to identify if the table is open.
  163.   // 
  164.   int isOpen;
  165.   //
  166.   // Pointer to the table's BCursor class instance.
  167.   //
  168.   BCursor *cursorPtr;
  169.  
  170.   //
  171.   // Pointer to the active database.
  172.   //
  173.   BDatabase *dataBase;
  174.  
  175.   //
  176.   // Fix the length to read from the memo field (so user does not pass EOF).
  177.   //
  178.   virtual Retcode fixReadLength(FIELDNUMBER blobField, 
  179.     unsigned int sizeOfBuffer, long offset, unsigned int& readLength);
  180.  
  181.   //
  182.   // Get the BLOB field but also null terminate the string
  183.   // and adjust the size so the user will not read past the EOF.
  184.   //
  185.   virtual Retcode getBlobField(FIELDNUMBER blobField,char *buffer,
  186.     unsigned int sizeOfBuffer, long offset, unsigned int &bytesRead); 
  187.  
  188.   //
  189.   // Get only the BLOB header.
  190.   //
  191.   virtual Retcode getQuickBlob(FIELDNUMBER blobField, char *buffer, 
  192.     int length, int &bytesRead);
  193.   //
  194.   // Find the length of a BLOB field.
  195.   //
  196.   virtual long getBlobSize(FIELDNUMBER blobField);
  197.  
  198. public:
  199.   //
  200.   // Last error that member functions returned.
  201.   //
  202.   Retcode lastError;
  203.  
  204.   //
  205.   // Constructor and destructor.
  206.   //
  207.   AbstractRestaurant(BDatabase *db);
  208.   virtual ~AbstractRestaurant();
  209.  
  210.   //
  211.   // Opens the table and allocates cursorPtr if successful.
  212.   //
  213.   virtual Retcode open(char *tableName);
  214.   virtual Retcode close();
  215.  
  216.   //
  217.   // Some basic browse functions.
  218.   //
  219.   virtual Retcode up();
  220.   virtual Retcode down();
  221.   virtual Retcode home();
  222.   virtual Retcode end();
  223.  
  224.   //
  225.   // Retrieves parts of the MEMO field menu.
  226.   //
  227.   virtual Retcode getMenu(char *buffer, unsigned length, long offset, 
  228.     unsigned int &bytesRead) = 0;
  229.   //
  230.   // Get the size of the BLOB fields.
  231.   //
  232.   virtual long sizeOfMenuBlob() = 0;
  233.   //
  234.   // This function retrieves the current record from the database and 
  235.   // assigns the field values to BCursor's generic record buffer.
  236.   //
  237.   virtual Retcode getRecord();
  238.  
  239. };
  240.  
  241. /****************************************************************************
  242. *
  243. * This class encapsulates the master restaurant database.
  244. *
  245. ****************************************************************************/
  246.  
  247. class MainRestaurant : public AbstractRestaurant {
  248.  
  249.   friend class FavoriteRestaurant;
  250.  
  251.   //
  252.   // Since the Database Framework does not provide a function like 
  253.   // PXSrchFld(), you must open up secondary indexes for the particular 
  254.   // fields you want to search. Use the member function setToCursor() to 
  255.   // sync the match found in a secondary index with the primary index view. 
  256.  
  257. private:
  258.  
  259.   BCursor *ratingTypeIndex;
  260.   BCursor *cityTypeIndex;
  261.  
  262. public:
  263.  
  264.   //
  265.   // Specific variables used to store column values for this table.
  266.   //
  267.   char  name[MAX_NAME_LEN + 1];
  268.   char  type[MAX_TYPE_LEN + 1];
  269.   char  street[MAX_STREET_LEN + 1];
  270.   char  city[MAX_CITY_LEN + 1];
  271.   char  state[MAX_STATE_LEN + 1];
  272.   char  zip[MAX_ZIP_LEN + 1];
  273.   char  telephone[MAX_TELEPHONE_LEN + 1];
  274.   INT16 rating;
  275.  
  276.   //
  277.   // Constructor.
  278.   //
  279.   MainRestaurant(BDatabase *db);
  280.   //
  281.   // Destructor.
  282.   //
  283.   virtual ~MainRestaurant();
  284.   //
  285.   // Redefine the open and close functions for this class.
  286.   //
  287.   virtual Retcode open(char *tableName);
  288.   virtual Retcode close();
  289.  
  290.   //
  291.   // BLOB retrieval functions.
  292.   //
  293.   Retcode getQuickReview(char *buffer, int sizeOfBuffer, 
  294.     int &bytesRead);
  295.  
  296.   Retcode getReview(char *buffer, unsigned int length, long offset, 
  297.     unsigned int &bytesRead);
  298.  
  299.   virtual Retcode getMenu(char *buffer, unsigned int length, long offset, 
  300.     unsigned int &bytesRead);
  301.   //
  302.   // BLOB size functions.
  303.   //
  304.   long sizeOfReviewBlob();
  305.   virtual long sizeOfMenuBlob();
  306.   //
  307.   // This function copies the current record in the main database to the
  308.   // favorite restuarant database.
  309.   //
  310.   Retcode copyToFavorite(FavoriteRestaurant &placeHere);
  311.  
  312.   //
  313.   // This function locates a restaurant by rating and type using a composite
  314.   // index.
  315.   //
  316.   Retcode findRatingType(int ratingToFind, char *typeToFind, 
  317.     PXSearchMode searchMode);
  318.   //
  319.   // This function uses a composite index to locate a restaurant by city 
  320.   // and type.
  321.   //
  322.   Retcode findCityType(char *cityToFind, char *typeToFind, 
  323.     PXSearchMode searchMode);
  324.   //
  325.   // Get the current record from the table.
  326.   //
  327.   virtual Retcode getRecord();
  328.  
  329. };
  330.  
  331. /****************************************************************************
  332. *
  333. * This class encapsulates the favorite restaurant database.
  334. *
  335. ****************************************************************************/
  336.  
  337. class FavoriteRestaurant : public AbstractRestaurant {
  338.  
  339.   friend class MainRestaurant;
  340.  
  341. public:
  342.   //
  343.   // Specific variables used to store column values for this table.
  344.   //
  345.   char name[MAX_NAME_LEN + 1];
  346.   char type[MAX_TYPE_LEN + 1];
  347.   //
  348.   // Constructor.
  349.   //
  350.   FavoriteRestaurant(BDatabase *db) : AbstractRestaurant(db)
  351.   {
  352.           memset(name,0, MAX_NAME_LEN + 1);
  353.           memset(type,0, MAX_TYPE_LEN + 1);
  354.   }
  355.  
  356.   //
  357.   // BLOB retrieval functions.
  358.   //
  359.   virtual Retcode getMenu(char *buffer, unsigned int length, long offset, 
  360.     unsigned int &bytesRead);
  361.   //
  362.   // BLOB size functions.
  363.   //
  364.   virtual long sizeOfMenuBlob();
  365.   //
  366.   // Get the current record from the table.
  367.   //
  368.   virtual Retcode getRecord();
  369.      
  370. };
  371.  
  372.  
  373.  
  374.  
  375.  
  376.