home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / cslio205.zip / INCLUDE / CSBTREE.H < prev    next >
C/C++ Source or Header  |  1997-01-21  |  21KB  |  595 lines
  1. /***********************************************************************
  2.  
  3.                       CSDB Library, Free Evaluation Version 2.0.5 
  4.                                        Release: January 22th 1997 
  5.  
  6.        BTREE classes.
  7.  
  8.                                            Copyright(c) 1994-1997 
  9.                                                           ComBits 
  10.                                                   The Netherlands 
  11. ***********************************************************************/
  12.  
  13. #ifndef __CSBTREE_H
  14. #define __CSBTREE_H
  15.  
  16. #include "cstbase.h"
  17.  
  18.  
  19.  
  20. #ifdef _CP_001
  21. #pragma warn -sig
  22. #endif
  23.  
  24. #ifdef _CP_002
  25. #pragma warning(disable : 4051 4135)
  26. #endif
  27.  
  28.  
  29. ////////////////////////////////////////////////////////////////////////////
  30. // The Class used by the BTREE to store its data.
  31. // We can use RBASE or RBASE.
  32. //
  33.  
  34. class BBASE: public TBASE {};
  35. //#define BBASE TBASE
  36.  
  37. /////////////////////////////////////////////////////////////////////////////////
  38. /////////////////////////// Btree POINTER. //////////////////////////////////////
  39. /////////////////////////////////////////////////////////////////////////////////
  40.  
  41.  
  42. typedef U32 BPOINT;
  43.  
  44.  
  45. /////////////////////////////////////////////////////////////////////////////////
  46. /////////////////////////// Functions for comparing keys. //////////////////////////
  47. /////////////////////////////////////////////////////////////////////////////////
  48.  
  49.  
  50. inline int cs_comp_bin(void *a,void *b,int len)
  51. {
  52.    return memcmp(a,b,len);
  53. }
  54.  
  55. inline int cs_comp_int(void *a,void *b)
  56. {
  57.   if(*(int *)a < *(int *)b) return -1;
  58.   if(*(int *)a > *(int *)b) return  1;
  59.   return 0;
  60. }
  61.  
  62. inline int cs_comp_cha(void *a,void *b)
  63. {
  64.   return ((int)*(S8 *)a)-((int)*(S8 *)b);
  65. }
  66.  
  67. inline int cs_comp_lon(void *a,void *b)
  68. {
  69.   if(*(long *)a < *(long *)b) return -1;
  70.   if(*(long *)a > *(long *)b) return  1;
  71.   return 0;
  72. }
  73.  
  74. inline int cs_comp_flo(void *a,void *b)
  75. {
  76.   if(*(float *)a < *(float *)b) return -1;
  77.   if(*(float *)a > *(float *)b) return    1;
  78.   return 0;
  79. }
  80.  
  81.  
  82. inline int cs_comp_dou(void *a,void *b)
  83. {
  84.   if(*(double *)a < *(double *)b) return -1;
  85.   if(*(double *)a > *(double *)b) return  1;
  86.   return 0;
  87. }
  88.  
  89. inline int cs_comp_asc(void *a,void *b,int len)
  90. {
  91.    return pStrnicmp((csCHAR *)a,(csCHAR *)b,len);
  92. }
  93.  
  94.  
  95.  
  96.  
  97. /////////////////////////////////////////////////////////////////////////////////
  98. /////////////////////////// Current Pointer structure. //////////////////////////
  99. /////////////////////////////////////////////////////////////////////////////////
  100.  
  101.  
  102. typedef struct
  103. {
  104.    int      nr;     // The current number in the block
  105.    int      mk_n;  // The current number in the frame
  106.    BPOINT block; // The current block
  107.    BPOINT mk_f;  // The current frame
  108. } BTCP;      // BTree Current Pointer
  109.  
  110.  
  111.  
  112. /////////////////////////////////////////////////////////////////////////////////
  113. /////////////////////////// Generic BTREE class. ////////////////////////////////
  114. /////////////////////////////////////////////////////////////////////////////////
  115.  
  116.  
  117. class BTREE: public BBASE
  118. {
  119.  
  120.    protected:
  121.  
  122.        typedef struct
  123.        {
  124.       BPOINT rnr;    // .................right .........
  125.       BPOINT tr;    // This Record
  126.       BPOINT up;    // Up pointer
  127.       BPOINT lnr;    // Record number of left neighbour
  128.       U8     nr;    // Number of keys
  129.        } d_block;
  130.  
  131.        typedef struct
  132.        {
  133.       BPOINT lnr;    // Record number of left neighbour (Previous)
  134.       BPOINT rnr;    // .................right ......... (Next)
  135.       U8     nr;    // Number of data elements
  136.        } m_block;
  137.  
  138.  
  139.  
  140.     protected:
  141.  
  142.       BPOINT root;     // Root of the btree.
  143.       BPOINT empt;     // Empty block chain.
  144.       BPOINT *paal;     // PAth ALlocation.
  145.       BPOINT *path;     // Path from the root to the leave.
  146.       BPOINT mk_empt;     // mk_ Empty data frames.
  147.       int    levels;     // Number of levels in the btree, including DATA layer
  148.       int    datlen;     // Length of data field.
  149.       int    keylen;     // Length of key field.
  150.       int    kdlen;     // Length of key- and data field combined.
  151.       int    kdmklen;     // Length of key- + data field + mk.
  152.       int    kplen;     // Length of keyfield and BPOINT combined.
  153.       int    pml;     // Path Max Length.
  154.       int    mulkey;     // Multiple keys allowed.
  155.       void   *tmp_key;     // Storage for temporary keys.
  156.       long   num_key;     // Number of Keys in Btree.
  157.       BPOINT curr_block; // The current block.
  158.       int    curr_nr;     // The current number in the block.
  159.       BPOINT curr_mk_f;  // The current frame.
  160.       int    curr_mk_n;  // The current number in the frame.
  161.  
  162.  
  163.     protected:
  164.  
  165.     /////////////////////// Multiple Key Support //////////////////////
  166.     //    mdf:    Multiple Data Frame
  167.  
  168.       int   nimdf;     // Number of data elements In a mdf.
  169.       int   mkop;      // Number of Multiple data frames on a page.
  170.       int   somdf;     // Size Of a mdf. (Number of bytes in a mdf.)
  171.       int   mk_shift;
  172.       int   mk_and;
  173.  
  174.       int   mk_oib_a;
  175.       int   mk_oimdf_a;
  176.  
  177.       int   mk_oib(int n)       { return mk_oib_a+n*somdf; }
  178.       int   mk_oimdf(int n)       { return mk_oimdf_a+n*datlen; }
  179.  
  180.       csCHAR *mk_p2cp(void *p,int n) { return (csCHAR *)p+mk_oib(n); }
  181.  
  182.       BPOINT &mk_n_mdf(void *p)   { return (((m_block *)p)->rnr); }
  183.       BPOINT  mk_n_mdf(BPOINT b)  { return mk_n_mdf(mk_p2mdf(b)); }
  184.       BPOINT &mk_n_mdfd(BPOINT b) { return mk_n_mdf(mk_p2mdfd(b)); }
  185.       BPOINT &mk_p_mdf(void *p)   { return (((m_block *)p)->lnr); }
  186.       BPOINT  mk_p_mdf(BPOINT b)  { return mk_p_mdf(mk_p2mdf(b)); }
  187.       BPOINT &mk_p_mdfd(BPOINT b) { return mk_p_mdf(mk_p2mdfd(b)); }
  188.  
  189.       void   mk_connect(BPOINT l,BPOINT r)
  190.            { if(l) mk_n_mdfd(l)=r; if(r) mk_p_mdfd(r)=l; }
  191.       void   mk_empty(BPOINT b);
  192.       void   mk_new_page(void);
  193.  
  194.       BPOINT  mk_new_frame(void);
  195.       BPOINT  mk_2mkp(BPOINT b,int i)    { return ((b<<mk_shift)|i); }
  196.  
  197.       csCHAR  *mk_p2mdf(BPOINT b)  { return p2cp(b>>mk_shift)+mk_oib(b&mk_and);  }
  198.       csCHAR  *mk_p2mdfd(BPOINT b) { return p2cpd(b>>mk_shift)+mk_oib(b&mk_and); }
  199.  
  200.       csCHAR  *mk_dataif(void *p,int i) { return (csCHAR *)p+mk_oimdf(i); }
  201.       csCHAR  *mk_data_l(void *p)    { return mk_dataif(p,mk_nr(p)); }
  202.       csCHAR  *mk_search(BPOINT &b,void *dat, int &nr);
  203.       csCHAR  *mk_insert(BPOINT &b,void *dat);
  204.  
  205.       int   mk_delet(BPOINT &b,void *dat);
  206.  
  207.       void  mk_free_chain(BPOINT b);
  208.       void  mk_zap(void);
  209.       void  mk_define(void);
  210.       void  mk_close(void);
  211.       void  mk_open(void);
  212.       void  mk_last(BPOINT b)     { curr_mk_n=mk_nr(mk_p2mdf(curr_mk_f=mk_p_mdf(b))); }
  213.       void *mk_last_p(BPOINT b);
  214.  
  215.       U8    &mk_nr(void *p)     { return (((m_block *)p)->nr); }
  216.  
  217.  
  218.     /////////////////////// Accessing Header Block ////////////////////
  219.  
  220.      U8 &DNR(void *p)  { return (((d_block *)(p))->nr);  }
  221.      BPOINT &DLNR(void *p) { return (((d_block *)(p))->lnr); }
  222.      BPOINT &DRNR(void *p) { return (((d_block *)(p))->rnr); }
  223.      BPOINT &BTR(void *p)  { return (((d_block *)(p))->tr);  }
  224.  
  225.     /////////////////////// Splitting Data Block //////////////////////
  226.  
  227.       int   dmnk;      // Data Max Number of Keys
  228.       int   dnbc;      // Data Number of Bytes Copied
  229.       int   dsco;      // Data Source Copy Offset
  230.       int   ddco;      // Data Destination Copy Offset
  231.       U8    dnnr;      // Data New NumbeR; the higher keys
  232.       U8    donr;      // Data Old NumbeR; the lower keys
  233.  
  234.     /////////////////////// Splitting Index Block //////////////////////
  235.  
  236.       int   imnk;      // Index Max Number of Keys
  237.       int   inbc;      // Index Number of Bytes Copied
  238.       int   isco;      // Index Source Copy Offset
  239.       int   idco;      // Index Destination Copy Offset
  240.       U8    innr;      // Index New NumbeR; the higher keys
  241.       U8    ionr;      // Index Old NumbeR; the lower keys
  242.  
  243.       int a_oiib;      // Offset in indexblock calculation
  244.       int b_oiib;
  245.  
  246.       int a_oidb;      // Offset in datablock calculation
  247.       int b_oidb;
  248.  
  249.  protected:
  250.  
  251.      int  moving_min(BPOINT &b,int &n,int delta,void *&bp);
  252.      int  moving_plus(BPOINT &b,int &n,int delta,void *&bp);
  253.  
  254.      int  moving_plus(void *&bp,int &n);
  255.      int  moving_min(void *&bp,int &n);
  256.  
  257.      int  prev_u(int n,void *&key,void *&data);
  258.      int  prev(int n,void *&bp);
  259.      int  next(int n,void *&bp);
  260.      int  next_u(int n,void *&key,void *&data);
  261.  
  262.     /////////////////////// Skipping fields  within a Block //////////////////
  263.       csCHAR   *skfidb(void *p)      { return (((csCHAR *)p)+keylen); }
  264.       BPOINT   *s2fidb(void *p)      { return (BPOINT *)(((csCHAR *)p)+kdlen); }
  265.       csCHAR   *skfiib(void *p)      { return (((csCHAR *)p)+keylen); }
  266.       csCHAR   *spfiib(void *p)      { return (((csCHAR *)p)+sizeof(BPOINT));  }
  267.       csCHAR   *fkiib(void *p)         { return (((csCHAR *)p)+sizeof(d_block)); }
  268.       csCHAR   *lkiib(void *p)         { return (((csCHAR *)p)+oiib(DNR(p)));    }
  269.       csCHAR   *nkiib(void *p,int n) { return (csCHAR *)p+oiib(n); }
  270.  
  271.       csCHAR   *lkidb(void *p)         { return (csCHAR *)p+oidb(DNR(p)); }
  272.       csCHAR   *nkidb(void *p,int n) { return (csCHAR *)p+oidb(n);}
  273.       csCHAR   *fkidb(void *p)         { return (csCHAR *)p+sizeof(d_block); }
  274.  
  275.     ///////////////////////// DB Header ///////////////////////////////////
  276.       virtual int read_header(void);
  277.       virtual int write_header(void);
  278.  
  279.  
  280.     /////////////////////// type of database ////////////////////////////////
  281.       virtual int check_id(U32 id);
  282.       virtual void set_id(void);
  283.  
  284.     /////////////////////// Copying /////////////////////////////////////////
  285.       void  copy_dat(void *d,void *s)          { memcpy(d,s,datlen); }
  286.       void  copy_poi(void *d,BPOINT &s)       { *(BPOINT *)d=s; }
  287.       virtual void copy_key(void *d,void *s)  { memcpy(d,s,keylen); }
  288.  
  289.     /////////////////////// Delete Aid //////////////////////////////////////
  290.       void  delet(void *b,void *KeyPos,int KeyNr);
  291.  
  292.     /////////////////////// Create/Free Block //////////////////////////////////
  293.       void  c_root(void *keyl,BPOINT l,void *keyr,BPOINT r);
  294.       void  c_root(void *keyl,BPOINT l);
  295.     csCHAR *c_block(void);
  296.       void  f_block(void *p);
  297.  
  298.     /////////////////////// Connecting blocks //////////////////////////////
  299.       void  connect(void *l,void *r)   { DRNR(l)=BTR(r); DLNR(r)=BTR(l); }
  300.       void  connect(BPOINT l,void *r);
  301.       void  connect(void *l,BPOINT p);
  302.       void  connect(BPOINT l,BPOINT p);
  303.  
  304.     /////////////////////// Splitting blocks ////////////////////////////////
  305.       void  calc_split_info(int ig,int dg);
  306.       void  split_data(void *lb,csCHAR *&hb);
  307.       void  split_index(void *b,csCHAR *&c);
  308.  
  309.     /////////////////////// Removing key from block /////////////////////////
  310.       int   rkajib(void *b,void *KeyPos,int KeyNr);
  311.       void  rkajdb(void *b,void *KeyPos,int KeyNr);
  312.       void  rkfib(void *block,void *KeyPos,int KeyNr);
  313.       void  rkfdb(void *block,void *KeyPos,int KeyNr);
  314.  
  315.     /////////////////////// Insert key in block ////////////////////////////////
  316.       void  ikasdb(void *b,csCHAR *kp,int nr,void *key,void *data);
  317.       void  ikiib(void *b,csCHAR *kp,int nr,void *key,BPOINT dat);
  318.       void  ikidb(void *b,csCHAR *kp,int nr,void *key,void *data);
  319.       void  insert_index(void *key,BPOINT dow);
  320.  
  321.     /////////////////////// Searching for a key ////////////////////////////////
  322.       csCHAR *ski2ib(void *b,void *key,int &nr);
  323.       csCHAR *skiib(void *b,void *key,int &nr);
  324.       csCHAR *ski2ib(void *b,void *key) { int nr; return ski2ib(b,key,nr); }
  325.       csCHAR *skiib(void *b,void *key)    { int nr; return skiib(b,key,nr);  }
  326.       csCHAR *skidb(void *b,void *key)    { int nr; return skidb(b,key,nr);  }
  327.       csCHAR *skidb(void *b,void *key,int &nr);
  328.  
  329.     /////////////////////// Reading from file //////////////////////////////////
  330.       csCHAR *p2cpd(BPOINT p)          { return (csCHAR *)locate_rec_d(p); }
  331.       csCHAR *p2cp(BPOINT p)          { return (csCHAR *)locate_rec(p); }
  332.       csCHAR *p2cpl(BPOINT p)          { return (csCHAR *)locate_rec_l(p); }
  333.  
  334.     /////////////////////// Comparing keys /////////////////////////////////////////////
  335.       virtual int t_key(void *a,void *b)=0;
  336.       int  t_dat(void *a,void *b) { return memcmp(a,b,datlen); }
  337.  
  338.     /////////////////////// Dirty /////////////////////////////////////////////
  339.       void  block_dirty(void *block) { BBASE::dirty(block); }
  340.  
  341.     /////////////////////// Miscellaneous /////////////////////////////////////
  342.       void   reporter(FILE *fp,BPOINT p,int lev);
  343.       void   expand(void *key,void *data);
  344.  
  345.       int    oiib(int n)     { return a_oiib+n*b_oiib; }
  346.       int    oidb(int n)     { return a_oidb+n*b_oidb; }
  347.  
  348.       int    nill(BPOINT &p)     { return !p; }
  349.       int    index_full(void *p) { return (DNR(p)==imnk); }
  350.       int    data_full(void *p)  { return (DNR(p)==dmnk); }
  351.       int    data_low(void *p)     { return (DNR(p)<=donr); }
  352.       int    index_low(void *p)  { return (DNR(p)<=ionr); }
  353.       BPOINT set_nill(BPOINT &p) { return (p=0); }
  354.       BPOINT sdb(void *key);
  355.  
  356.       void   nill_mk(void *kp)     { if(multiple_keys()) set_nill(*s2fidb(kp)); }
  357.  
  358.       int    search_gt(void *key,void *&kp);
  359.       int    search_ge(void *key,void *&kp);
  360.       int    search_le_u(void *key,void *&kp,void *&da);
  361.       int    search_lt_u(void *key,void *&kp,void *&da);
  362.  
  363.  
  364.  
  365. ////////////////////////////////////////////////////////////////////////
  366. ////////////////////// PUBLIC FUNCTIONS ////////////////////////////////
  367. ////////////////////////////////////////////////////////////////////////
  368.  
  369.     public:
  370.  
  371.  
  372.       BTREE(void );
  373.       virtual
  374.      ~BTREE(void );
  375.  
  376.  
  377. //////////////////////// Definition //////////////////////////////////////////
  378.       int   define(csCHAR *name, int key_l,int dat_l);
  379.  
  380. //////////////////////// Open & Close ////////////////////////////////////////
  381.       int   open(csCHAR *name, int kb_buff=32);
  382.       int   open(void)      { return already_open(); }
  383.       int   close(void);
  384.  
  385. ////////////////////////// Deleting ////////////////////////////////////////////
  386.       int   delet(void *key);
  387.       int   delet(void *key,void *data);
  388.  
  389. ////////////////////////// Inserting ///////////////////////////////////////////
  390.       int   insert(void *key,void *data);
  391.  
  392. ////////////////////////  Testing Begin & End /////////////////////////////////
  393.       int   tBOF(void);    // test Begin Of BTREE
  394.       int   tEOF(void);    // test End     Of BTREE
  395.  
  396. ////////////////////////  First and Last entries //////////////////////////////
  397.       int   csmin(void);
  398.       int   csmin(void *Key,void *Data);
  399.       int   min_dat(void *Data);
  400.       int   min_key(void *Key);
  401.  
  402.       int   first(void)          { return csmin(); }
  403.       int   first(void *Key,void *Data)  { return csmin(Key,Data); }
  404.       int   first_dat(void *Data)     { return min_dat(Data);  }
  405.       int   first_key(void *Key)     { return min_key(Key);   }
  406.  
  407.       int   csmax(void);
  408.       int   csmax(void *Key,void *Data);
  409.       int   max_dat(void *Data);
  410.       int   max_key(void *Key);
  411.  
  412.       int   last(void)               { return csmax(); }
  413.       int   last(void *Key,void *Data) { return csmax(Key,Data); }
  414.       int   last_dat(void *Data)       { return max_dat(Data); }
  415.       int   last_key(void *Key)        { return max_key(Key);  }
  416.  
  417. //////////////////////// Checking for Existence //////////////////////////////
  418.       int   find(void *key,void *data);
  419.       int   find(void *key);
  420.  
  421. //////////////////////// Searching ////////////////////////////////////////////
  422.  
  423.       int   search(void *key,void *Data);
  424.  
  425.       int   search_gt(void *key,void *Key,void *Data);
  426.       int   search_ge(void *key,void *Key,void *Data);
  427.       int   search_lt(void *key,void *Key,void *Data);
  428.       int   search_le(void *key,void *Key,void *Data);
  429.  
  430.       int   search_dat_gt(void *key,void *Data);
  431.       int   search_dat_ge(void *key,void *Data);
  432.       int   search_dat_lt(void *key,void *Data);
  433.       int   search_dat_le(void *key,void *Data);
  434.  
  435.       int   search_key_gt(void *key,void *Key);
  436.       int   search_key_ge(void *key,void *Key);
  437.       int   search_key_lt(void *key,void *Key);
  438.       int   search_key_le(void *key,void *Key);
  439.  
  440.  
  441. //////////////////////// Skipping /////////////////////////////////////////////
  442.  
  443.       int   prev(void);
  444.       int   prev(int n);
  445.       int   prev_key(int n,void *Key);
  446.       int   prev_dat(int n,void *Data);
  447.       int   prev(int n,void *Key,void *Data);
  448.  
  449.       int   next(void);
  450.       int   next(int n);
  451.       int   next_key(int n,void *Key);
  452.       int   next_dat(int n,void *Data);
  453.       int   next(int n,void *Key,void *Data);
  454.  
  455.       int   skip(int n) { return ((n>0) ? next(n): -prev(-n)); }
  456.  
  457.       int   skip(int n,void *Key,void *Data)
  458.         {  if(n>0) return  next( n,Key,Data);
  459.            else    return -prev(-n,Key,Data); }
  460.       int   skip_key(int n,void *Key)
  461.         {  if(n>0) return  next_key( n,Key);
  462.            else    return -prev_key(-n,Key); }
  463.       int   skip_dat(int n,void *Dat)
  464.         {  if(n>0) return  next_dat( n,Dat);
  465.            else    return -prev_dat(-n,Dat); }
  466.  
  467. //////////////////////// Current location /////////////////////////////////////
  468.       int   current(void *Key,void *Data);
  469.       int   current_key(void *Key);
  470.       int   current_dat(void *Data);
  471.  
  472.       int   save_current(BTCP &b);
  473.       void  restore_current(BTCP &b);
  474.  
  475. //////////////////////// Report Writing //////////////////////////////////////
  476.       void  report(csCHAR *rname,int sub=1);
  477.       void  report(FILE *fp,int sub=1);
  478.  
  479. //////////////////////// Number of Keys //////////////////////////////////////
  480.       long  numkey(void)  { return num_key; }
  481.  
  482. ////////////////////////// Miscellaneous ///////////////////////////////////////
  483.       int   pack(void);
  484.       void  zap(void);
  485.       void  info(void );
  486.       void  empty(void);
  487.       int   key_length(void)           { return keylen; }
  488.       int   data_length(void)           { return datlen; }
  489.       void  multiple_keys(int TrueOrFalse);
  490.       void  multiple_keys_YES(void)       { multiple_keys(TRUE);  }
  491.       void  multiple_keys_NO(void)       { multiple_keys(FALSE); }
  492.       int   multiple_keys(void    )       { return mulkey; }
  493.       virtual int class_ID(void)       { return CS_CLID_BTREE; }
  494.  
  495.  
  496. };
  497.  
  498.  
  499.  
  500.  
  501.  
  502.  
  503. /////////////////////////////////////////////////////////////////////////////////
  504. /////////////////////////// 'Specialised' BTREEs. ////////////////////////////
  505. /////////////////////////////////////////////////////////////////////////////////
  506. //
  507. //   Mainly, these BTREE's differ only in the function used to
  508. //   compare keys: t_key().
  509. //
  510. //
  511. //
  512. //
  513.  
  514. /////////////////////////////////////////////////////////////////////////////////
  515. /////////////////////////// BTREE for binary data ///////////////////////////////
  516.  
  517. class BTREEb: public BTREE
  518. {
  519.     virtual int t_key(void *a,void *b) { return cs_comp_bin(a,b,keylen); }
  520.     virtual int class_ID(void)           { return CS_CLID_BTREEb; }
  521. };
  522.  
  523. /////////////////////////////////////////////////////////////////////////////////
  524. /////////////////////////// BTREE for integers //////////////////////////////////
  525.  
  526. class BTREEi: public BTREE
  527. {
  528.    virtual int t_key(void *a,void *b) { return cs_comp_int(a,b); }
  529.    virtual int class_ID(void)          { return CS_CLID_BTREEi; }
  530. };
  531.  
  532. /////////////////////////////////////////////////////////////////////////////////
  533. /////////////////////////// BTREE for characters ////////////////////////////////
  534.  
  535. class BTREEc: public BTREE
  536. {
  537.     virtual int t_key(void *a,void *b) { return cs_comp_cha(a,b); }
  538.     virtual int class_ID(void)           { return CS_CLID_BTREEc; }
  539. };
  540.  
  541. /////////////////////////////////////////////////////////////////////////////////
  542. /////////////////////////// BTREE for longs /////////////////////////////////////
  543.  
  544. class BTREEl: public BTREE
  545. {
  546.    virtual int t_key(void *a,void *b) { return cs_comp_lon(a,b); }
  547.    virtual int class_ID(void)          { return CS_CLID_BTREEl; }
  548.  
  549. };
  550.  
  551. /////////////////////////////////////////////////////////////////////////////////
  552. /////////////////////////// BTREE for floating points ///////////////////////////
  553.  
  554. class BTREEf: public BTREE
  555. {
  556.     virtual int t_key(void *a,void *b) { return cs_comp_flo(a,b); }
  557.     virtual int class_ID(void)           { return CS_CLID_BTREEf; }
  558. };
  559.  
  560. /////////////////////////////////////////////////////////////////////////////////
  561. /////////////////////////// BTREE for doubles ///////////////////////////////////
  562.  
  563. class BTREEd: public BTREE
  564. {
  565.     virtual int t_key(void *a,void *b) { return cs_comp_dou(a,b); }
  566.     virtual int class_ID(void)           { return CS_CLID_BTREEd; }
  567. };
  568.  
  569. /////////////////////////////////////////////////////////////////////////////////
  570. /////////////////////////// BTREE for strings ///////////////////////////////////
  571.  
  572. class BTREEa: public BTREE
  573. {
  574.     virtual void copy_key(void *d,void *s);
  575.     virtual int t_key(void *a,void *b) { return cs_comp_asc(a,b,keylen-1); }
  576.     virtual int class_ID(void)           { return CS_CLID_BTREEa; }
  577. };
  578.  
  579.  
  580.  
  581.  
  582. #ifdef _CP_001
  583. #pragma warn .sig
  584. #endif
  585.  
  586.  
  587. #ifdef _CP_002
  588. #pragma warning(default : 4051 4135)
  589. #endif
  590.  
  591.  
  592.  
  593.  
  594. #endif
  595.