home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / magazine / cmplangm / 1989_4 / object.h < prev    next >
Text File  |  1989-02-01  |  4KB  |  215 lines
  1. //  Module:     File
  2. //  Version:    1.00    18-Jan-1989
  3. //  Language:   C++
  4. //  Purpose:    Defines a generic "file" class
  5. //
  6. //  Written by Scott Robert Ladd. This file is released into the public domain.
  7.  
  8. #include "string.h"
  9. #include "file.hpp"
  10.  
  11. //**** CLASS: file ****
  12.  
  13. // constructor
  14. file::file(char * filename, ACCESS_MODE m, TRANSLATION t)
  15.     {
  16.     name  = strdup(filename);
  17.     mode  = m;
  18.     trans = t;
  19.     error = okay;
  20.  
  21.     if (trans == binary)
  22.         {
  23.         switch (mode)
  24.             {
  25.             case read_only :
  26.                 osdata = fopen(name,"rb");
  27.                 break;
  28.             case write_only :
  29.                 osdata = fopen(name,"wb");
  30.                 break;
  31.             case read_write :
  32.                 osdata = fopen(name,"w+b");
  33.                 break;
  34.             case append_mode :
  35.                 osdata = fopen(name,"a+b");
  36.                 break;
  37.             }
  38.         }
  39.     else
  40.         {
  41.         switch (mode)
  42.             {
  43.             case read_only :
  44.                 osdata = fopen(name,"r");
  45.                 break;
  46.             case write_only :
  47.                 osdata = fopen(name,"w");
  48.                 break;
  49.             case read_write :
  50.                 osdata = fopen(name,"w+");
  51.                 break;
  52.             case append_mode :
  53.                 osdata = fopen(name,"a+");
  54.                 break;
  55.             }
  56.         }
  57.  
  58.     if (osdata == NULL)
  59.         error = closed;
  60.     else
  61.         error = okay;
  62.     }
  63.  
  64. // destructor
  65. file::~file()
  66.     {
  67.     fclose(osdata);
  68.     }
  69.  
  70. // common i/o methods
  71. void file::read(void * rec, unsigned int len)
  72.     {
  73.     int res;
  74.  
  75.     if (mode == write_only)
  76.         {
  77.         error = access_violation;
  78.         return;
  79.         }
  80.  
  81.     res = fread(rec,len,1,osdata);
  82.  
  83.     if (ferror(osdata))
  84.         error = failed;
  85.     else
  86.         error = okay;
  87.     }
  88.  
  89. void file::write(void * rec, unsigned int len)
  90.     {
  91.     int res;
  92.  
  93.     if (mode == read_only)
  94.         {
  95.         error = access_violation;
  96.         return;
  97.         }
  98.  
  99.     res = fwrite(rec,len,1,osdata);
  100.  
  101.     if (ferror(osdata))
  102.         error = failed;
  103.     else
  104.         error = okay;
  105.     }
  106.  
  107. // file pointer movement methods
  108. void file::goto_end()
  109.     {
  110.     int res;
  111.  
  112.     res = fseek(osdata,0L,SEEK_END);
  113.  
  114.     if (res != 0)
  115.         error = failed;
  116.     else
  117.         error = okay;
  118.     }
  119.  
  120. void file::goto_begin()
  121.     {
  122.     int res;
  123.  
  124.     res = fseek(osdata,0L,SEEK_SET);
  125.  
  126.     if (res != 0)
  127.         error = failed;
  128.     else
  129.         error = okay;
  130.     }
  131.  
  132. void file::goto_pos(long loc)
  133.     {
  134.     int res;
  135.  
  136.     res = fseek(osdata,loc,SEEK_SET);
  137.  
  138.     if (res != 0)
  139.         error = failed;
  140.     else
  141.         error = okay;
  142.     }
  143.  
  144. // data retrieval methods
  145. void file::get_name(char *n)
  146.     {
  147.     strcpy(n,name);
  148.     }
  149.  
  150. ACCESS_MODE file::get_mode()
  151.     {
  152.     return mode;
  153.     }
  154.  
  155. TRANSLATION file::get_trans()
  156.     {
  157.     return trans;
  158.     }
  159.  
  160. // error checking routines
  161. int file::in_error()
  162.     {
  163.     if (error != okay)
  164.         return 1;
  165.     else
  166.         return 0;
  167.     }
  168.  
  169. ERROR_CODE file::get_error()
  170.     {
  171.     return error;
  172.     }
  173.  
  174. int file::at_end()
  175.     {
  176.     if (feof(osdata))
  177.         return 1;
  178.     else
  179.         return 0;
  180.     }
  181.  
  182. //**** CLASS: text_file ****
  183.  
  184. // reading & writing methods
  185. void text_file::read(char * s, unsigned int len)
  186.     {
  187.     if (mode == write_only)
  188.         {
  189.         error = access_violation;
  190.         return;
  191.         }
  192.  
  193.     if (NULL == fgets(s,len,osdata))
  194.         if (feof(osdata))
  195.             error = okay;
  196.         else
  197.             error = failed;
  198.     else
  199.         error = okay;
  200.     }
  201.  
  202. void text_file::write(char * s)
  203.     {
  204.     if (mode == read_only)
  205.         {
  206.         error = access_violation;
  207.         return;
  208.         }
  209.  
  210.     if (0 == fputs(s,osdata))
  211.         error = failed;
  212.     else
  213.         error = okay;
  214.     }
  215.