home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / cslio205.zip / INCLUDE / CSDLAY.H < prev    next >
C/C++ Source or Header  |  1997-01-21  |  9KB  |  306 lines
  1. /***********************************************************************
  2.  
  3.                       CSDB Library, Free Evaluation Version 2.0.5 
  4.                                        Release: January 22th 1997 
  5.  
  6.        Header file of the DLAY class.
  7.  
  8.                                            Copyright(c) 1994-1997 
  9.                                                           ComBits 
  10.                                                   The Netherlands 
  11. ***********************************************************************/
  12.  
  13. #ifndef __CSDLAY_H
  14. #define __CSDLAY_H
  15.  
  16. #include "cspage.h"
  17. #include "csdli.h"
  18.  
  19. #ifdef feof
  20.   #undef feof
  21. #endif
  22.  
  23.  
  24.  
  25. #ifdef _CP_002
  26.   #pragma warning(disable: 4270 4067 4018)
  27. #endif
  28.  
  29.    struct olpo_ds
  30.      {
  31.         U32  pos;
  32.         U32  page;
  33.         S16  offset;
  34.      };   // OLay-POs
  35.  
  36.  
  37.  
  38. class DLAY: public DLAYI
  39. {
  40.  
  41.  protected:
  42.  
  43.      typedef struct
  44.      {
  45.         U32  p_page;
  46.         U32  n_page;
  47.         S16  used;      // number of bytes in use on this page
  48.      } olhe;            // OLay HEad
  49.  
  50.        typedef struct olpo_ds olpo;
  51.  
  52. protected:
  53.  
  54.      olpo current;
  55.      U32  last_page;
  56.      U32  last_pos;
  57.      U32  first_page;
  58.      U16  per_page;
  59.  
  60.   protected:
  61.  
  62.  
  63.      void init_vars(void);
  64.      void init_defaults(void) {}
  65.  
  66.      void prev_page_a(olpo &olp);
  67.      void next_page_a(olpo &olp);
  68.      void next_page_a(olhe *hp,olpo &olp);
  69.      void start_page(olpo &olp);
  70.  
  71. //////////////////////// Page manipulation ///////////////////////////////
  72.  
  73.      olpo insert_page(olpo &olp);
  74.      void unchain_page(olpo &pos);
  75.      void append_page(void);
  76.      U32  new_page(void);
  77.      void free_page(U32 p);
  78.  
  79. //////////////////////// Skip  //////////////////////////////////////////
  80.  
  81.      void skip_plus(olpo &olp,U32  delta);
  82.      void skip_min(olpo &olp ,U32  delta);
  83.      void skip_t(olpo &pos   ,S32 delta);
  84.      void skip_plus_t(olpo &pos,U32 delta);
  85.      void skip_min_t(olpo &pos ,U32 delta);
  86.  
  87. /////////////////////////// DB Header ///////////////////////////////////
  88.      virtual int read_header(void);
  89.      virtual int write_header(void);
  90.  
  91.  
  92.  
  93. //////////////////////// Disk access ////////////////////////////////////
  94.  
  95.      olhe *HP(U32 page)  { return (olhe *)load_page_h(page); }
  96.      olhe *HPd(U32 page) { return (olhe *)load_page_hd(page); }
  97.  
  98.  
  99. /////////////////////////  Modifying page header //////////////////////////////////
  100.      void modify_head(U32 page,U32 p_page,U32 n_page);
  101.      void modify_head(U32 page,U32 p_page,U32 n_page,U16 used);
  102.      void modify_p_page(U32 page,U32 p_page);
  103.      void modify_n_page(U32 page,U32 n_page);
  104.  
  105.  
  106. /////////////////////////  Prev/Next page number //////////////////////////////////
  107.      U32  prev_page_num(olpo& olp);
  108.      U32  prev_page_num(U32 page);
  109.  
  110.      U32  next_page_num(olpo& olp);
  111.      U32  next_page_num(U32  page);
  112.      U32  next_page_num(olhe *hp);
  113.  
  114.  
  115. /////////////////////////  Pointers ///////////////////////////////////////////////
  116.  
  117.      csCHAR *pos_po(olpo &olp);
  118.      csCHAR *pos_pod(olpo &olp);
  119.      csCHAR *pos_pod_last(void);
  120.  
  121. /////////////////////////  Amount of data on a page ///////////////////////////////
  122.  
  123.      U16  is_used(olpo &olp)  { return is_used(olp.page); }
  124.      U16  is_used(U32  page)  { return HP(page)->used; }
  125.  
  126.      void modify_used(olpo &pos,U16 use);
  127.      void modify_used(U32 page,U16 use);
  128.      void modify_used_delta(olpo &pos,S16 delta);
  129.      void modify_used_delta(U32 page,S16 delta);
  130.  
  131. // Can become negative!
  132.      S16  left_used(olpo &olp);
  133.      S16  left_used(olhe *hp,U16 offset);
  134.  
  135.      U16  space_free(olpo &olp);
  136.      U16  space_free(U32 page);
  137.  
  138. /////////////////////////  Locating //////////////////////////////////////////////
  139.  
  140.      void go_to(olpo &pos,U32 new_pos);
  141.      olpo go_to(U32  pos);
  142.      void last(olpo &pos);
  143.  
  144. /////////////////////////  Auxiliary //////////////////////////////////////////////
  145.  
  146.      U16  mini_off(void)   { return sizeof(olhe); }
  147.      U16  max_free(void)   { return per_page; }
  148.      void ola_copy(olpo &p2,olpo &p1,U16 len);
  149.  
  150.      virtual void set_id(void);
  151.      virtual int check_id(U32 id);
  152.  
  153.  
  154.  
  155. /////////////////////////  Support for public functions ////////////////////////////
  156.  
  157.      void del_mod_use(olpo &pos,U16 new_used);
  158.      int  replace(olpo &pos,U32 old_len,void *p_new,U32 new_len);
  159.      U16  stil_fit(olpo &pos);
  160.      U16  stil_fit(U16 used );
  161.  
  162.  
  163. /////////////////////////  Table functions ////////////////////////////////////////
  164.  
  165.      int  table_look(U32 pos,olpo& op);
  166.      int  table_insert(olpo& op);
  167.      void table_insert(U32 pa,U32 po);
  168.      void table_delete_update(olpo& op,U32 len);
  169.      void table_insert_update(olpo& op,U32 len);
  170.      void table_unchain_update(olpo &pos);
  171.  
  172.  
  173. ////////////////////////////////////////////////////////////////////////
  174. ////////////////////////////////////////////////////////////////////////
  175. ////////////////////// PUBLIC FUNCTIONS ////////////////////////////////
  176. ////////////////////////////////////////////////////////////////////////
  177. ////////////////////////////////////////////////////////////////////////
  178.  
  179.  
  180.   public:
  181.  
  182.      DLAY(void);
  183.      virtual
  184.     ~DLAY(void);
  185.  
  186.  
  187. //////////////////////// Definition //////////////////////////////////////////
  188.      int  define(csCHAR *name)               { return define(name,page_size()); }
  189.      int  define(csCHAR *name,U16 page_length);
  190.  
  191. //////////////////////// Open & Close ////////////////////////////////////////
  192.      int  open(csCHAR *name,S16 kb_buf=30);
  193.      void save(void)                         { BUFFER::save(); }
  194.      int  close();
  195.  
  196. //////////////////////// Read & Write ////////////////////////////////////////
  197.      U32  read(U32  pos,void *p,U32 len)
  198.           { olpo op=go_to(pos); return read(op,p,len); }
  199.      U32  read(olpo &pos, void *p,U32 len);
  200.  
  201.      int  write(U32  pos,void *p,U32 len)
  202.           { olpo op=go_to(pos); return write(op,p,len); }
  203.      int  write(olpo &pos,void *p,U32 len); //Pos will change!
  204.  
  205. //////////////////////// Append  /////////////////////////////////////////////
  206.      int  append(void *p,U32 len);
  207.      int  append(olpo &pos,void *p,U32 len);
  208.  
  209. //////////////////////// Replace /////////////////////////////////////////////
  210.      int  replace(U32 pos,U32 old_len,void *p_new,U32 new_len)
  211.           { olpo op=go_to(pos); return replace(op,old_len,p_new,new_len); }
  212.  
  213. //////////////////////// Delete //////////////////////////////////////////////
  214.      S32  delet(U32  pos,S32 len)
  215.           { olpo op=go_to(pos); return delet(op,len); }
  216.      S32  delet(olpo &pos,S32 len);
  217.  
  218. //////////////////////// Insert //////////////////////////////////////////////
  219.      int  insert(U32 pos,void *p,U32 len)
  220.           { olpo op=go_to(pos); return insert(op,p,len); }
  221.      int  insert(olpo &pos,void *p,U32 len);
  222.  
  223. //////////////////////// Import & Export //////////////////////////////////////
  224.      int  import_bin(csCHAR *name)  { return import(name,TRUE);  }
  225.      int  import_asc(csCHAR *name)  { return import(name,FALSE); }
  226.      int  import(csCHAR *name,int bin_mode=TRUE);
  227.  
  228.      int  export_bin(csCHAR *name)  { return export(name,TRUE);  }
  229.      int  export_asc(csCHAR *name)  { return export(name,FALSE); }
  230.      int  export(csCHAR *name,int bin_mode=TRUE);
  231.  
  232. //////////////////////// Number of bytes in File ///////////////////////////////
  233.      U32  filesize(void)      { return bottom()-1; }
  234.  
  235.  
  236. ////////////////////////// Reports /////////////////////////////////////////////
  237.      int  report(csCHAR *name,int sub=1);
  238.      void report(FILE *fp,int sub=1);
  239.  
  240.  
  241. ////////////////////////// Working at the edge /////////////////////////////////
  242.  
  243.  
  244.      int insapp(U32  pos,void *p,U32 len)
  245.      {
  246.         if (pos==bottom()) return append(p,len);
  247.         else               return insert(pos,p,len);
  248.      }
  249.  
  250.      int insapp(olpo &pos,void *p,U32 len)
  251.      {
  252.         if (pos.pos==bottom()) return append(pos,p,len);
  253.         else                   return insert(pos,p,len);
  254.      }
  255.  
  256.      int wriapp(olpo &pos,void *p,U32 len);
  257.  
  258.  
  259. ////////////////////////// Sequential IO ///////////////////////////////////////
  260.  
  261.     int   fseek(long offset,int origin=SEEK_SET);
  262.     long  ftell(void)  { return current.pos-1; }
  263.     int   feof(void)   { return (current.pos==bottom()); }
  264.     int   fgetc(void);
  265.     int   fputc(int csCHARacter);
  266.     int   fread( void *buf,int size,int count);
  267.     int   fwrite(void *buf,int size,int count);
  268.   csCHAR *fgets(csCHAR *str,int num);
  269.     int   fputs(csCHAR *str) { return !fwrite(str,strlen(str),1); }
  270.  
  271.     long  fdelete(long amount);
  272.     int   finsert(void *buf,long amount);
  273.  
  274.  
  275. //////////////////////// Data in Header Page /////////////////////////////////
  276.   /* Inherited
  277.      int  data_2_header(void * ptr,U16 length);
  278.      int  header_2_data(void * ptr,U16 length);
  279.      U16  max_data_in_header(void);
  280.   */
  281.  
  282.  
  283. ////////////////////////// Miscellaneous ///////////////////////////////////////
  284. /* Inherited
  285.      int  background(void)
  286. */
  287.      int  pack(void);
  288.      int  empty(void);
  289.      U32  bottom(void)           { return last_pos; }
  290.      void info(void);
  291.      void fflush(void)           { BUFFER::save(); }
  292.  
  293.      virtual int class_ID(void)  { return CS_CLID_DLAY; }
  294.  
  295. };
  296.  
  297.  
  298.  
  299.  
  300. #ifdef _CP_002
  301.   #pragma warning(default: 4270 4067 4018)
  302. #endif
  303.  
  304.  
  305. #endif
  306.