home *** CD-ROM | disk | FTP | other *** search
/ PC Media 22 / PC MEDIA CD22.iso / share / prog / datalib2 / database.hpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-08-16  |  9.7 KB  |  268 lines
  1. // This is the header file for the database analysis package
  2. // Robin Abbott, 6/9/91, 16/8/95
  3. // Class for a database
  4.  
  5. #ifndef DBH        // Prevent multiple includes
  6.  
  7. #define DBH 1
  8.  
  9. #define VERSIONMAJOR 2
  10. #define VERSIONMINOR 3
  11.  
  12. #ifdef _Windows                // Windows Specials
  13.  #ifndef WINDOWS_H
  14.   #include <windows.h>
  15.  #endif
  16.  #ifdef __DLL__                // DLL
  17.   #define EXPORT _export
  18.   #define FD _export
  19.  #else                    // Bog Standard Windows
  20.   #define FD far
  21.   #define EXPORT huge
  22.  #endif
  23. #else                    // Nope, it's DOS
  24.  #define FD far
  25.  #define EXPORT
  26. #endif
  27.  
  28. #ifndef FILE        // stdio
  29.  #include <stdio.h>
  30. #endif
  31.  
  32. // #ifndef streambuf    // Stream
  33. // #include <stream.hpp>
  34. // #endif
  35.  
  36. #ifndef time_t        // Time
  37.  #include <time.h>
  38. #endif
  39.  
  40. #ifndef strcmp        // String
  41.  #include <string.h>
  42.  #ifndef strncmpl                // Different Compilers !
  43.   #define strcmpl(a,b) stricmp(a,b)
  44.   #define strncmpl(a,b,n) strnicmp(a,b,n)
  45.  #endif
  46. #endif
  47.  
  48. // The following define is the number of index cluster nodes stored
  49. // in memory for each index. Each cluster uses 550 bytes in memory
  50. // so the default value (20) uses up to 11k for each index. Reduce
  51. // this if using a  large number of indexes & running out of memory
  52. // at the expense of speed in adding or modifying records
  53.  
  54. #define MAXCLUSM    20
  55.  
  56.  
  57. // Here are the selection types
  58.  
  59. enum seltype {FIRST=-100, LAST, NEXT, PREVIOUS};    // Selection types
  60. enum errors  {NOFILE=1, NOINDEX, NOMEM, CANTSEL,
  61.           NOWRUNR, WRFAIL, RECNOTSET, MEMOERR,
  62.           EXPRERR,NOKEY,NOKEYHIGHER,INVIND,DUPFIELD,
  63.           INVFIELD,INCOMP,OORD,RECNOTFND,ERRINTREE};     // Errors
  64. enum rectype {NOTDEL=0,DEL,ALL,READIND};            // Record Types
  65. enum wrtype  {OVER,NEW};
  66. enum errors2 {DELREC,FLDOOR,DBINV,NODELKEY,NORECSP,
  67.           NODBSP,INVDB,ERINDW,INVFILE,ERONW,INVSEEK,
  68.           NOMEMSP,ERONR,INVMEMO};            // User errors
  69. enum dates   {USDATE,UKDATE};
  70.  
  71. // Operator type substitutions
  72.  
  73. #define OPINT        1        // Operand type integer
  74. #define OPSTR        2        // Operand type string
  75. #define OPDATE        4
  76. #define OPLOG        8
  77.  
  78. #define MAXFLD     255    // Maximum number of fields
  79. #define NOIND    ""    // No index for record
  80.  
  81. // Here are the classes
  82.  
  83. class EXPORT database
  84. {
  85.  int valid;         // Status of database
  86.  FILE *dbfp;             // file pointer to database
  87.  FILE *dbtp;         // file pointer to memo file
  88.  long nrec;              // No. of records
  89.  unsigned int reclen;    // Length of a record
  90.  unsigned int recstart;       // Offset of first record
  91.  class EXPORT field ** fielda;     // Points to 1st field in array of fields
  92.  int nfield;                  // Number of fields in database
  93.  int maxfieldl;         // Maximum field length in database
  94.  int change;         // Database has changed flag
  95.  char *exwork;         // Holds tokenised expression
  96.  char *memow;         // Points to memo work space, 0 if no memo fields
  97.  int memowl;         // Memo work space length in blocks of 512
  98.  struct index *findex;          // Points to 1st index structure
  99.  class  EXPORT record *firstrec; // Points to 1st record using this database
  100.  
  101.  struct index *getindex(char *name);       // Get pointer to index by name
  102.  void indsort(FILE *,int,int,int,long,int,void (*progress)(int,long),int order);
  103.  void database::buildtree(FILE *fp,int,int,int,long,long &);
  104.  
  105.  public:
  106.  
  107.  char ers[81];         // Reports the error in an expression
  108.  dates dateformat;     // Date format in use by database
  109.  
  110.  class expval *ex;
  111.  
  112.  database();                // Construct new database
  113.  database(char *name,char *index=0);    // Construct with file+index
  114.  ~database(void);
  115.  
  116.  int  addindex(char *fname);
  117.  int  addfield(char *name,int type,
  118.            int ln=1,int rdp=0);    // Add field to new database
  119.  int  addfield(class field *fp);    // Duplicate field to new database
  120.  int  buildindex(char *expr,char *fn,void (*progress)(int,long)=0,int order=250);
  121.                     // Build an index
  122.  field *getfield(int n)
  123.        {return(fielda[n-1]);}           // Return field n, 1<=n<=nfield
  124.  field *getfield(char *name);        // Get a pointer to a field by name
  125.  char *getindkey(char *name);        // Get index key
  126.  int getindtype(char *name);        // Get index type, OPINT or OPSTR
  127.  long getnrec(void) {return(nrec);}     // Number of records
  128.  int  getreclen(void) {return(reclen);} // Total record length
  129.  int  getnfield(void) {return(nfield);} // Number of fields
  130.  void getversion(int &j,int &n)
  131.               {j=VERSIONMAJOR; n=VERSIONMINOR;}        // Version
  132.  int  isvalid(void) {return(valid);}    // Return valid flag
  133.  void setdateformat(dates f) {dateformat=f;}    // Set date format
  134.  int  subindex(char *iname);                // Subtract an index
  135.  int  verifyindex(char *iname,int depth=1,
  136.           void (*progress)(int test,long recnum)=0,
  137.           int order=100);            // Verify an index
  138.  int  write(char *name);                // Write new database
  139.  
  140.  friend class record;            // Let record get at our privates
  141. };
  142.  
  143. // Class for a field
  144.  
  145. class EXPORT field
  146. {
  147.  int number;        // Number of this field in the record
  148.  char name[11];         // Name of this field
  149.  char namecop[11];    // Copy for accessor function
  150.  char type;             // Type of field
  151.  unsigned char len;     // Length of field on screen
  152.  int rdp;               // digits to the right of the dp
  153.  int recpos;        // Position of field in record
  154.  
  155. public:
  156.  field(int number,char *name,char type,int length,int rdp,
  157.        int recpos);
  158.  ~field(void);
  159.                                        // Functions to get privates
  160.  int getnumber(void) {return(number);} // Get number of this field in record
  161.  char *getname(void) {strcpy(namecop,name);
  162.                       return(namecop);}   // Get name of field
  163.  char gettype(void) {return(type);}    // Get type of field
  164.  int getlen(void) {return(len);}       // Get length of field
  165.  int getrdp(void) {return(rdp);}       // Get right of dp of field
  166.  
  167.  friend class database;                // Let database get at our members
  168.  friend class record;
  169.  friend class expval;
  170. };
  171.  
  172. // Class for a record
  173.  
  174. class EXPORT record
  175. {
  176.  char *recbuf;            // Buffer which holds record
  177.  char *recbufo;            // Buffer holding unmodified record
  178.  char *rbp;            // Points to buffer to be used in eval
  179.  char *fieldwork;        // Buffer holds text of last accessed field
  180.  class database *db;        // Points to data base owning this record
  181.  int delstate;            // Holds delete state of record
  182.  long rn;            // Holds record number in dbf file
  183.  index *oi;            // Owning index if one exists
  184.  struct indpt *curind;        // Current index pointer if in use
  185.  int indflg;            // Flag to show checking an index expression
  186.  char lkey[128];        // Last key check expression
  187.  int ltype;            // Last type of key check expression
  188.  int lseltype;            // Last select type, OPINT or OPSTR
  189.  record *nextind;        // Next record using same index as this
  190.  record *next;            // Next record using this database
  191.  record *prev;            // Previous record using this database
  192.  
  193.  int doset(char *v,field *fld);    // Actually set a field to a string
  194.  long getind(long n);         // Find record in index file
  195.  void killind();        // Kill all indclus records in current record
  196.  void delkey(char *o,index *i);    // Delete key value from index
  197.  void inskey(char *n,index *i); // Insert new key value
  198.  void wmemo(int type);        // Write a memo when writing a record
  199.  
  200. public:
  201.  
  202.  record(class database &db,char *indname=0);
  203.  ~record(void);
  204.  void operator=(record &s);        // Copy record entirely
  205.  
  206.  int eval(char *expr,void *result,int &rtype);    // Evaluate expression
  207.  int eval(void *result,int &rtype);        // Evaluate prev. expression
  208.  int indchk(char *exp,int &rtype);         // check an index expression
  209.  char *indname();                // Return index name
  210.  int seldbf(long n);                // Select record in dbf
  211.  int select(long n,int type=NOTDEL,int df=0);   // Select rec number
  212.  int select(int field,int val,long n,
  213.                  int type=NOTDEL); // Select when fn==val
  214.  int select(int field,char *s,long n,
  215.                  int type=NOTDEL); // Select when field==s
  216.  int select(int field,void *s,
  217.         int (*comp)(void *,void *),
  218.         long n,int type=NOTDEL);    // User def sel-> comp()==0
  219.  int select(char *expr,long n,
  220.                  int type=NOTDEL); // Select when expr is true
  221.  char *getfield(int n,int tf=1);    // Get field by number
  222.  char *getfield(char *name,int tf=1);    // Get field by name
  223.  long getrecnum() {return(rn);}    // Current record number
  224.  int  getdelstate() {return(delstate);} // Delete state of record
  225.  void setdelstate(int sval);
  226.  int  selkey(char *value,int type=NOTDEL,int num=OPSTR);   // Select by key
  227.  int  selkey(double value,int type=NOTDEL);
  228.  int  selkey();                // Find other records with key
  229.  int  setfield(char *name,char *value);    // Set new value for field
  230.  int  setfield(char *name,double value);
  231.  int  setfield(int number,char *value);    // Set new value for field
  232.  int  setfield(int number,double value);
  233.  int  write(int type=OVER);        // Write rec to dbf
  234.  
  235.  friend class expval;    // Let expval get at our privates
  236.  friend class database;    // Let database get at our privates
  237. };
  238.  
  239.  
  240. // Miscellaneous routines
  241.  
  242. void   FD dber(int ern);              // Print error
  243. void   FD dbfer(int ern);              // Print fatal error
  244. time_t FD gettime(char *string);            // ANSI time from dbase date
  245. char*  FD getdate(time_t time);                // dbase date from ANSI time
  246. void   FD gnums(char *date,int &d,int &m,int &y); // Date to day,month,year
  247. char*  FD ltrim(char *string);                // Trim lead spaces
  248. char*  FD rtrim(char *string);                // Trim trailing spaces
  249. char*  FD soundex(char *d,char *s);              // Soundex of s to d
  250. int    FD strcmpdb(char *s1,char *s2,int len=-1); // dBase compare
  251. char*  FD swapdata(char *s,int c='~');           // Swap data in a string
  252. char*  FD trim(char *string);                   // Trim trailing spaces
  253.  
  254. // The following functions are error checking versions of the standard
  255. // file handling functions
  256.  
  257. int Fwrite(void *,int,int,FILE*);
  258. int Fread(void *,int,int,FILE*);
  259. int Fgetc(FILE *);
  260. int Fputc(int,FILE *);
  261. int Fseek(FILE *,long,int);
  262.  
  263. // Global variables
  264.  
  265. extern int eroff;                  // error off flag
  266.  
  267. #endif
  268.