csbtree.h

CSLIB, a C++ database library.

    /////////////////////// Connecting blocks //////////////////////////////
      void  connect(void *l,void *r)   { DRNR(l)=BTR(r); DLNR(r)=BTR(l); }
      void  connect(BPOINT l,void *r);
      void  connect(void *l,BPOINT p);
      void  connect(BPOINT l,BPOINT p);

    /////////////////////// Splitting blocks ////////////////////////////////
      void  calc_split_info(int ig,int dg);
      void  split_data(void *lb,csCHAR *&hb);
      void  split_index(void *b,csCHAR *&c);

    /////////////////////// Removing key from block /////////////////////////
      int   rkajib(void *b,void *KeyPos,int KeyNr);
      void  rkajdb(void *b,void *KeyPos,int KeyNr);
      void  rkfib(void *block,void *KeyPos,int KeyNr);
      void  rkfdb(void *block,void *KeyPos,int KeyNr);

    /////////////////////// Insert key in block ////////////////////////////////
      void  ikasdb(void *b,csCHAR *kp,int nr,void *key,void *data);
      void  ikiib(void *b,csCHAR *kp,int nr,void *key,BPOINT dat);
      void  ikidb(void *b,csCHAR *kp,int nr,void *key,void *data);
      void  insert_index(void *key,BPOINT dow);

    /////////////////////// Searching for a key ////////////////////////////////
      csCHAR *ski2ib(void *b,void *key,int &nr);
      csCHAR *skiib(void *b,void *key,int &nr);
      csCHAR *ski2ib(void *b,void *key) { int nr; return ski2ib(b,key,nr); }
      csCHAR *skiib(void *b,void *key)	{ int nr; return skiib(b,key,nr);  }
      csCHAR *skidb(void *b,void *key)	{ int nr; return skidb(b,key,nr);  }
      csCHAR *skidb(void *b,void *key,int &nr);

    /////////////////////// Reading from file //////////////////////////////////
      csCHAR *p2cpd(BPOINT p)	      { return (csCHAR *)locate_rec_d(p); }
      csCHAR *p2cp(BPOINT p)	      { return (csCHAR *)locate_rec(p); }
      csCHAR *p2cpl(BPOINT p)	      { return (csCHAR *)locate_rec_l(p); }

    /////////////////////// Comparing keys /////////////////////////////////////////////
      virtual int t_key(void *a,void *b)=0;
      int  t_dat(void *a,void *b) { return memcmp(a,b,datlen); }

    /////////////////////// Dirty /////////////////////////////////////////////
      void  block_dirty(void *block) { BBASE::dirty(block); }

    /////////////////////// Miscellaneous /////////////////////////////////////
      void   reporter(FILE *fp,BPOINT p,int lev);
      void   expand(void *key,void *data);

      int    oiib(int n)	 { return a_oiib+n*b_oiib; }
      int    oidb(int n)	 { return a_oidb+n*b_oidb; }

      int    nill(BPOINT &p)	 { return !p; }
      int    index_full(void *p) { return (DNR(p)==imnk); }
      int    data_full(void *p)  { return (DNR(p)==dmnk); }
      int    data_low(void *p)	 { return (DNR(p)<=donr); }
      int    index_low(void *p)  { return (DNR(p)<=ionr); }
      BPOINT set_nill(BPOINT &p) { return (p=0); }
      BPOINT sdb(void *key);

      void   nill_mk(void *kp)	 { if(multiple_keys()) set_nill(*s2fidb(kp)); }

      int    search_gt(void *key,void *&kp);
      int    search_ge(void *key,void *&kp);
      int    search_le_u(void *key,void *&kp,void *&da);
      int    search_lt_u(void *key,void *&kp,void *&da);



////////////////////////////////////////////////////////////////////////
////////////////////// PUBLIC FUNCTIONS ////////////////////////////////
////////////////////////////////////////////////////////////////////////

    public:


      BTREE(void );
      virtual
     ~BTREE(void );


//////////////////////// Definition //////////////////////////////////////////
      int   define(csCHAR *name, int key_l,int dat_l);

//////////////////////// Open & Close ////////////////////////////////////////
      int   open(csCHAR *name, int kb_buff=32);
      int   open(void)	  { return already_open(); }
      int   close(void);

////////////////////////// Deleting ////////////////////////////////////////////
      int   delet(void *key);
      int   delet(void *key,void *data);

////////////////////////// Inserting ///////////////////////////////////////////
      int   insert(void *key,void *data);

////////////////////////  Testing Begin & End /////////////////////////////////
      int   tBOF(void);    // test Begin Of BTREE
      int   tEOF(void);    // test End	 Of BTREE

////////////////////////  First and Last entries //////////////////////////////
      int   csmin(void);
      int   csmin(void *Key,void *Data);
      int   min_dat(void *Data);
      int   min_key(void *Key);

      int   first(void) 		 { return csmin(); }
      int   first(void *Key,void *Data)  { return csmin(Key,Data); }
      int   first_dat(void *Data)	 { return min_dat(Data);  }
      int   first_key(void *Key)	 { return min_key(Key);   }

      int   csmax(void);
      int   csmax(void *Key,void *Data);
      int   max_dat(void *Data);
      int   max_key(void *Key);

      int   last(void)		       { return csmax(); }
      int   last(void *Key,void *Data) { return csmax(Key,Data); }
      int   last_dat(void *Data)       { return max_dat(Data); }
      int   last_key(void *Key)        { return max_key(Key);  }

//////////////////////// Checking for Existence //////////////////////////////
      int   find(void *key,void *data);
      int   find(void *key);

//////////////////////// Searching ////////////////////////////////////////////

      int   search(void *key,void *Data);

      int   search_gt(void *key,void *Key,void *Data);
      int   search_ge(void *key,void *Key,void *Data);
      int   search_lt(void *key,void *Key,void *Data);
      int   search_le(void *key,void *Key,void *Data);

      int   search_dat_gt(void *key,void *Data);
      int   search_dat_ge(void *key,void *Data);
      int   search_dat_lt(void *key,void *Data);
      int   search_dat_le(void *key,void *Data);

      int   search_key_gt(void *key,void *Key);
      int   search_key_ge(void *key,void *Key);
      int   search_key_lt(void *key,void *Key);
      int   search_key_le(void *key,void *Key);


//////////////////////// Skipping /////////////////////////////////////////////

      int   prev(void);
      int   prev(int n);
      int   prev_key(int n,void *Key);
      int   prev_dat(int n,void *Data);
      int   prev(int n,void *Key,void *Data);

      int   next(void);
      int   next(int n);
      int   next_key(int n,void *Key);
      int   next_dat(int n,void *Data);
      int   next(int n,void *Key,void *Data);

      int   skip(int n) { return ((n>0) ? next(n): -prev(-n)); }

      int   skip(int n,void *Key,void *Data)
	    {  if(n>0) return  next( n,Key,Data);
	       else    return -prev(-n,Key,Data); }
      int   skip_key(int n,void *Key)
	    {  if(n>0) return  next_key( n,Key);
	       else    return -prev_key(-n,Key); }
      int   skip_dat(int n,void *Dat)
	    {  if(n>0) return  next_dat( n,Dat);
	       else    return -prev_dat(-n,Dat); }

//////////////////////// Current location /////////////////////////////////////
      int   current(void *Key,void *Data);
      int   current_key(void *Key);
      int   current_dat(void *Data);

      int   save_current(BTCP &b);
      void  restore_current(BTCP &b);

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

//////////////////////// Number of Keys //////////////////////////////////////
      long  numkey(void)  { return num_key; }

////////////////////////// Miscellaneous ///////////////////////////////////////
      int   pack(void);
      void  zap(void);
      void  info(void );
      void  empty(void);
      int   key_length(void)		   { return keylen; }
      int   data_length(void)		   { return datlen; }
      void  multiple_keys(int TrueOrFalse);
      void  multiple_keys_YES(void)	   { multiple_keys(TRUE);  }
      void  multiple_keys_NO(void)	   { multiple_keys(FALSE); }
      int   multiple_keys(void	)	   { return mulkey; }
      virtual int class_ID(void)	   { return CS_CLID_BTREE; }


};






/////////////////////////////////////////////////////////////////////////////////
/////////////////////////// 'Specialised' BTREEs. ////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
//
//   Mainly, these BTREE's differ only in the function used to
//   compare keys: t_key().
//
//
//
//

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////// BTREE for binary data ///////////////////////////////

class BTREEb: public BTREE
{
    virtual int t_key(void *a,void *b) { return cs_comp_bin(a,b,keylen); }
    virtual int class_ID(void)	       { return CS_CLID_BTREEb; }
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////// BTREE for integers //////////////////////////////////

class BTREEi: public BTREE
{
   virtual int t_key(void *a,void *b) { return cs_comp_int(a,b); }
   virtual int class_ID(void)	      { return CS_CLID_BTREEi; }
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////// BTREE for characters ////////////////////////////////

class BTREEc: public BTREE
{
    virtual int t_key(void *a,void *b) { return cs_comp_cha(a,b); }
    virtual int class_ID(void)	       { return CS_CLID_BTREEc; }
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////// BTREE for longs /////////////////////////////////////

class BTREEl: public BTREE
{
   virtual int t_key(void *a,void *b) { return cs_comp_lon(a,b); }
   virtual int class_ID(void)	      { return CS_CLID_BTREEl; }

};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////// BTREE for floating points ///////////////////////////

class BTREEf: public BTREE
{
    virtual int t_key(void *a,void *b) { return cs_comp_flo(a,b); }
    virtual int class_ID(void)	       { return CS_CLID_BTREEf; }
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////// BTREE for doubles ///////////////////////////////////

class BTREEd: public BTREE
{
    virtual int t_key(void *a,void *b) { return cs_comp_dou(a,b); }
    virtual int class_ID(void)	       { return CS_CLID_BTREEd; }
};

/////////////////////////////////////////////////////////////////////////////////
/////////////////////////// BTREE for strings ///////////////////////////////////

class BTREEa: public BTREE
{
    virtual void copy_key(void *d,void *s);
    virtual int t_key(void *a,void *b) { return cs_comp_asc(a,b,keylen-1); }
    virtual int class_ID(void)	       { return CS_CLID_BTREEa; }
};




#include "cscoptof.h"

#endif