OS/2 Shareware BBS: 10 Tools/10-Tools.zip/cslio205.zip/INCLUDE/CSPAGE.H

C/C++ Source or Header | 1997-01-21 | 6KB | 195 lines

/***********************************************************************

                      CSDB Library, Free Evaluation Version 2.0.5
                                       Release: January 22th 1997

       Foundation class.
       Supplies buffered disk IO on a page-by-page
       bases.

                                           Copyright(c) 1994-1997
                                                          ComBits
                                                  The Netherlands
***********************************************************************/

#ifndef __CSPAGE_H
#define __CSPAGE_H

#include "csbuff.h"
#include "csbase.h"


////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////


class PAGE: public BUFFER, public BASE
{


protected:
   U32    pc_empty;   // Page Chain Empty
   U32    pn_empty;   // Number of pages empty.
   U16    ilock;        // Ignore lock bit.
   void *sbp;        // SetvBuf Pointer.


protected:

   int    hread(void *buf,int size);
   int    hwrite(void *buf,int size);
   int    close2(void);
   int    user_2_data(void *buf,U32 amount);
   int    data_2_user(void *buf,U32 amount);
   void init_vars(void);
   void init_defaults(void);
   void init_allocs(void);
   int    zap(void);
   void emergency_exit(void);
   U32    unfree_page(void);
   void check_pq14(void);
   virtual int check_id(U32 id);
   virtual void set_id(void);



protected:

///////////////////////// Compatibility ////////////////////////////////////



public:

// void name(csCHAR *s)       { BUFFER::name(s); BASE::name(s); }


////////////////////////////////////////////////////////////////////////////////
////////////////////////                ////////////////////////////
////////////////////////     P U B L I C        ////////////////////////////
////////////////////////                ////////////////////////////
////////////////////////////////////////////////////////////////////////////////


public:
   PAGE(void);
   virtual
  ~PAGE(void);



///////////////////////// Error & Messages ///////////////////////////

   void    e_name(csCHAR *s)   { BUFFER::e_name(s); BASE::e_name(s); }
   csCHAR *e_name(void)        { return BASE::e_name(); }


//////////////////////// Definition //////////////////////////////////////////
/* Inherited

   void page_size(U16 t)
   U16    page_size(void)
   U16    foot_size(void)
   void foot_size(int size)   */

   int    define(csCHAR *name,U16 pagesize);
   int    define(csCHAR *name)   { return define(name,lenpage); }


//////////////////////// Buffering ///////////////////////////////////////////
/* INHERITED
   void number_buff_min(uint nr)
   void number_buff_max(uint nr)
   void number_buff(uint mini,uint maxi);
*/


//////////////////////// Open & Close ////////////////////////////////////////

   int    read_only(void)     { return read_only(TRUE);  }
   int    read_only(int ToF);

   int    is_read_only(void)  { return BASE::is_read_only(); }

   int    open(csCHAR *name,S16 kB=32);
   int    close();


   int    IsOpen(void)        { return BASE::IsOpen(); }
   void IsOpen(int ToF)     { BASE::IsOpen(ToF);     }


   int    setvbuf(U16 size);
   int    save(void);
   int    save_as(csCHAR *s);


//////////////////////// Locate & Load Pages /////////////////////////////////

   csCHAR *locate_page_d(U32 page)  { return (csCHAR *)locate_buff_d(page); }
   csCHAR *locate_page(U32 key,int prior,int rwl) { return (csCHAR *)locate_buff(key,prior,rwl); }
   csCHAR *load_page(U32 page)        { return (csCHAR *)load_buff(page); }
   csCHAR *load_page_d(U32 page)    { return (csCHAR *)load_buff_d(page); }
   csCHAR *load_page_l(U32 page)    { return (csCHAR *)load_buff_l(page); }
   csCHAR *load_page_ld(U32 page)   { return (csCHAR *)load_buff_ld(page); }
   void *load_page(U32 key,int prior,int rwl)     { return (csCHAR *)load_buff(key,prior,rwl);  }
   void locate_double(U32 r1,csCHAR* &p1,U32 r2,csCHAR* &p2);
   void locate_double_d(U32 r1,csCHAR* &p1,U32 r2,csCHAR* &p2);


//////////////////////// Read & Write Pages //////////////////////////////////

   void read_page( U32 l,void *p)  { memcpy(p,load_page(l),lenpage); }
   void write_page( U32 l,void *p) { memcpy(locate_page_d(l),p,lenpage); }


//////////////////////// New Pages ///////////////////////////////////////////

   U32    new_page(void)            { return ((pc_empty) ? unfree_page(): add_page()); }
   U32    add_page(void);
   void free_page(U32 num);
   U32    nr_empty(void)            { return pn_empty; }


//////////////////////// Number of Pages /////////////////////////////////////
/* Inherited
   U32 num_page(void) */
   void set_num_page(U32 n)  { BASE::set_num_page(n); BUFFER::set_num_page(n); }

//////////////////////// Pages Status ////////////////////////////////////////

   int    is_dirty_page( U32 page)    { return BUFFER::is_dirty(page); }
   void set_dirty_page(void *p    )   { BUFFER::dirty(p);    }
   void set_dirty_page(U32 page)    { BUFFER::dirty(page); }
   void reset_dirty_page(void *p)   { BUFFER::clean(p);    }
   void reset_dirty_page(U32 page)  { BUFFER::clean(page); }

/* Inherited
   void change_stat(void *page,int prior,int stat);
   void change_stat(void *page,int prior);
   int    priority(void *page);                          */

//////////////////////// Data in Header Page /////////////////////////////////
   int    data_2_header(void * ptr,U16 length);
   int    header_2_data(void * ptr,U16 length);
   U16    max_data_in_header(void);

//////////////////////// Report Writing //////////////////////////////////////
   int    report(csCHAR *name,int sub=1);
   void report(FILE *f,int sub);

////////////////////////// Miscellaneous ///////////////////////////////////////
/* Inherited
   U16    page_free(void)
   int    background(void)
   int    in_ram(U32 key);                      */
   int    empty(void);

   virtual int class_ID(void)  { return 11; }


};


#endif