home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / snip9707.zip / STRUCFIL.C < prev    next >
C/C++ Source or Header  |  1997-07-05  |  5KB  |  159 lines
  1. /* +++Date last modified: 05-Jul-1997 */
  2.  
  3. /*******************************************************************
  4.  * Generic structure <> disk file manipulations. These functions
  5.  * form a basic template for reading and writing structures to a 
  6.  * sequential file. This template is probably most useful for files
  7.  * with 500 or less records and eliminates the need for a more 
  8.  * elaborate file handler such as C-Tree, DB-Vista, Mix etc.
  9.  * Routines to put data in the struct is out of scope here.
  10.  * Written by Lynn Nash 8/28/91 and donated to the public domain.
  11.  */
  12. #include <io.h>
  13. #include <string.h>
  14. #include <stdlib.h>
  15. #include "sniptype.h"
  16. #include "strucfil.h"
  17.  
  18. /*-------------------- general globals ---------------------*/
  19.  
  20. static long cur_rec = 0;      /* the current record number */
  21. static FILE *fsptr = NULL;    /* fixed record data file pointer */
  22.  
  23. /* if file exists open in read/write mode else create file */
  24.  
  25. FILE * open_file(char *filename)
  26. {
  27.       if (access(filename, 0) == 0)
  28.             fsptr = fopen(filename, "rb+"); 
  29.       else  fsptr = fopen(filename, "wb+"); 
  30.       return fsptr;                       /* return the file pointer */
  31. } 
  32.  
  33. /* add new records to the data file */
  34.  
  35. int datadd(void)
  36. {
  37.       if (fsptr)
  38.       {
  39.             if (fseek(fsptr, 0L, SEEK_END) != 0)
  40.                   return Error_;  /* seek failure */
  41.             rec.delete_flag = 0; /* active record tag */
  42.             rec.recordnum = (int) (ftell(fsptr) / 
  43.                   (long) sizeof(struct blackbook));
  44.             if (fwrite(&rec, sizeof(struct blackbook), 1, fsptr) != 1)
  45.             {
  46.                   return Error_; /* write error */
  47.             }
  48.             else
  49.             {
  50.                   /* put your clean up code here */ 
  51.                   return Success_;
  52.             }
  53.       }
  54.       return Error_;
  55. }
  56.  
  57. /* tag the last record read in the file as deleted */
  58.  
  59. int data_delete(void)
  60. {
  61.       if (fsptr)
  62.       {
  63.             if (fseek(fsptr, (long) sizeof(struct blackbook) * -1L,
  64.                   SEEK_CUR) != 0)
  65.             {
  66.                   return Error_;
  67.             }
  68.             rec.delete_flag = -1;   /* tag the record as deleted */
  69.             if (fwrite(&rec, sizeof(struct blackbook), 1, fsptr) != 1)
  70.                   return Error_;
  71.             else  return Success_;
  72.       }
  73.       return Error_;
  74. }
  75.  
  76. /* read a random structure. If successful the global cur_rec will 
  77.  * contain the number of the last record read & it can be compared
  78.  * to the number in the struct as a double check (belt & suspenders)
  79.  */
  80.  
  81. int data_read(long recnum)
  82. {
  83.       if (fseek(fsptr, (long) sizeof(struct blackbook) * recnum,
  84.             SEEK_SET) != 0)
  85.       {
  86.             return Error_;
  87.       }
  88.       cur_rec = recnum; /* keep tabs on record pointer in global */  
  89.  
  90.       /* now read the record into save struct*/
  91.  
  92.       if (fread(&oldrec, sizeof(struct blackbook), 1, fsptr) != 1)
  93.       {
  94.             return Error_;
  95.       }
  96.       else                          /* copy save struct to edit struct */
  97.       {
  98.             memcpy(&rec, &oldrec, sizeof(struct blackbook));
  99.             return Success_;
  100.       }
  101. }
  102.  
  103. /* rewrite the last read record back to disk */
  104.  
  105. int data_update(void)
  106. {
  107.       if (memcmp(&rec, &oldrec, sizeof(struct blackbook)) == 0)
  108.             return True_;  /* no update needed */
  109.  
  110.       /* back up one record before writing */
  111.  
  112.       if (fseek(fsptr, (long) sizeof(struct blackbook) * -1L, 
  113.             SEEK_CUR) != 0)
  114.       {
  115.             return Error_; /* seek error */ 
  116.       }
  117.  
  118.       /* now write the record */
  119.  
  120.       if (fwrite(&rec, sizeof(struct blackbook), 1, fsptr) != 1)
  121.             return Error_; /* write error */
  122.       return Success_;
  123. }
  124.  
  125. /* get the next valid record in the file */
  126.  
  127. int read_forward(void)
  128. {
  129.       do
  130.       {
  131.             cur_rec++; /* upcount the record number */
  132.             if (data_read(cur_rec) != 0)
  133.             {
  134.                   cur_rec--; /* decrement the record number */
  135.                   return Error_;
  136.             }
  137.       } while (oldrec.delete_flag != 0); /* record read was deleted */
  138.       return Success_;
  139. }
  140.  
  141. /* get the previous valid record in the file */
  142.  
  143. int read_backward(void)
  144. {
  145.       do
  146.       {
  147.             cur_rec--;  /* decrement the record number */
  148.             if (cur_rec >= 0)
  149.             {
  150.                   if ( data_read(cur_rec) != 0 )
  151.                   {
  152.                         cur_rec++; /* increment the record number */
  153.                         return Error_;
  154.                   }
  155.             }  
  156.       } while (oldrec.delete_flag != 0); /* record read was deleted */
  157.       return Success_;
  158. }
  159.