home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / cslio205.zip / EXAMPLES / 3 / CSADDIO.H < prev    next >
C/C++ Source or Header  |  1997-01-06  |  9KB  |  251 lines
  1. #ifndef CLASS__NAMio_h
  2. #define CLASS__NAMio_h
  3.  
  4.  
  5. #include "csdate.h" 
  6. #include "cstbase.h" 
  7. #include "csbtree.h" 
  8.  
  9. #define NAMio_NAME_LENGTH     40 
  10. #define NAMio_NAME_TOK_LENGTH     NAMio_NAME_LENGTH/2
  11. #define NAMio_ADRE_LENGTH     32 
  12. #define NAMio_CITY_LENGTH     23 
  13. #define NAMio_COUNT_LENGTH     32 
  14. #define NAMio_ZIP_LENGTH     9 
  15. #define NAMio_TEL_LENGTH     17 
  16. #define NAMio_RELATION_LENGTH     10 
  17. #define NAMio_INFO_LENGTH     70 
  18.  
  19. ////////// Indexes to be used with the 'order()' function./////////////
  20.  
  21. #define UNSORTED     0
  22. #define NAMIO_NAME_INDEX     1 
  23. #define NAMIO_CITY_INDEX     2 
  24. #define NAMIO_BIRTH_INDEX     3 
  25. #define NAMIO_RELATION_INDEX     4 
  26.  
  27.  
  28.  
  29. typedef struct 
  30. {
  31.    char   _name[NAMio_NAME_LENGTH+1]; 
  32.    char   _adre[NAMio_ADRE_LENGTH+1]; 
  33.    char   _city[NAMio_CITY_LENGTH+1]; 
  34.    char   _count[NAMio_COUNT_LENGTH+1]; 
  35.    char   _zip[NAMio_ZIP_LENGTH+1]; 
  36.    char   _tel[NAMio_TEL_LENGTH+1]; 
  37.    long   __update; 
  38.    long   __birth; 
  39.    char   _relation[NAMio_RELATION_LENGTH+1]; 
  40.    char   _info[NAMio_INFO_LENGTH+1]; 
  41. } record;
  42.  
  43.  
  44. ///////////////////////////////////////////////////////////////////////
  45. //////////////////////////// The New Class ////////////////////////////
  46. ///////////////////////////////////////////////////////////////////////
  47.  
  48.  
  49. class NAMio
  50. {
  51.  protected:
  52.  
  53.    record *static_rec;
  54.  
  55.    csSTR   e_name; // Used in error messages.
  56.    long    current;
  57.    int     dirty;
  58.    int     is_open;
  59.    int     iOrder;
  60.    int     NeedSync;
  61.    int     errnr;
  62.    csDATE _update;
  63.    csDATE _birth;
  64.  
  65.  
  66.    int  (NAMio::*bof_fun)(void);
  67.    int  (NAMio::*eof_fun)(void);
  68.    int  (NAMio::*skip_fun)(int delta);
  69.    void (NAMio::*top_fun)(void);
  70.    void (NAMio::*bottom_fun)(void);
  71.    int  (NAMio::*search_fun)(void *k);
  72.  
  73.    TBASE  db;
  74.    BTREEa in1;        //Index on field name  
  75.    BTREEa in2;        //Index on field city  
  76.    BTREEl in3;        //Index on field birth  
  77.    BTREEa in4;        //Index on field relation  
  78.  
  79.    int bof0(void)        { return (current==1); }
  80.    int bof1(void)        { return in1.tBOF(); }
  81.    int bof2(void)        { return in2.tBOF(); }
  82.    int bof3(void)        { return in3.tBOF(); }
  83.    int bof4(void)        { return in4.tBOF(); }
  84.  
  85.    int eof0(void)        { return (current==db.numrec()); }
  86.    int eof1(void)        { return in1.tEOF(); }
  87.    int eof2(void)        { return in2.tEOF(); }
  88.    int eof3(void)        { return in3.tEOF(); }
  89.    int eof4(void)        { return in4.tEOF(); }
  90.  
  91.    void top0(void)        { current=1; }
  92.    void top1(void)        { in1.min_dat(¤t); }
  93.    void top2(void)        { in2.min_dat(¤t); }
  94.    void top3(void)        { in3.min_dat(¤t); }
  95.    void top4(void)        { in4.min_dat(¤t); }
  96.  
  97.    void bottom0(void)        { current=db.numrec(); }
  98.    void bottom1(void)        { in1.max_dat(¤t); }
  99.    void bottom2(void)        { in2.max_dat(¤t); }
  100.    void bottom3(void)        { in3.max_dat(¤t); }
  101.    void bottom4(void)        { in4.max_dat(¤t); }
  102.  
  103.    void find1(void *k)        { in1.find(k,¤t); }
  104.    void find2(void *k)        { in2.find(k,¤t); }
  105.    void find3(void *k)        { in3.find(k,¤t); }
  106.    void find4(void *k)        { in4.find(k,¤t); }
  107.  
  108.    int  search0(void * )    { return TRUE; } 
  109.    int  search1(void *k)    { return in1.search_dat_ge(k,¤t); }
  110.    int  search2(void *k)    { return in2.search_dat_ge(k,¤t); }
  111.    int  search3(void *k)    { return in3.search_dat_ge(k,¤t); }
  112.    int  search4(void *k)    { return in4.search_dat_ge(k,¤t); }
  113.  
  114.    int  skip0(int delta); 
  115.    int  skip1(int delta)    { return in1.skip_dat(delta,¤t); }
  116.    int  skip2(int delta)    { return in2.skip_dat(delta,¤t); }
  117.    int  skip3(int delta)    { return in3.skip_dat(delta,¤t); }
  118.    int  skip4(int delta)    { return in4.skip_dat(delta,¤t); }
  119.  
  120.    void in1_ins_tok(void *s)    { in1.insert(s,¤t); }
  121.    void in1_del_tok(void *s)    { in1.delet(s,¤t); }
  122.  
  123.    record *locate_curr(void) { return (record *)db.locate_rec(current); } 
  124.    void write_rec2(void);
  125.    void write_rec(void) { if(dirty) write_rec2(); }
  126.    void read_rec(void);
  127.  
  128.  
  129.    void tokenize(int once,char *s,const char *delim,int len,void(NAMio::*fun)(void *));
  130.    void synch_index(void);
  131.    void visible_error(int ErrorNr,char *Parm=""); 
  132.    void te(void);  
  133.  
  134.  public:
  135.  
  136.  //////////////////////////////// class constructor ////////////////////////////
  137.    NAMio(void); 
  138.  
  139.  //////////////////////////////// class destructor /////////////////////////////
  140.    ~NAMio(void);
  141.  
  142.  //////////////////////////////// current record number ////////////////////////
  143.    long curr_rec(void)   { return current; }
  144.  
  145.  //////////////////////////////// messages & errors ////////////////////////////
  146.    U16  display_error(void); 
  147.  
  148.    int  error_nr(void); 
  149.    void error_nr(int ErrorNr) { errnr=ErrorNr; } 
  150.  
  151.  
  152.  //////////////////////////////// read-only ////////////////////////////////////
  153.    int  read_only(int TrueOrFalse);
  154.    int  read_only(void) { return db.read_only(); }
  155.  
  156.  //////////////////////////////// lock files ///////////////////////////////////
  157.    int  use_lock_file(int TrueOrFalse);
  158.    int  use_lock_file(void) { return db.use_lock_file(); } 
  159.  
  160.    int  lock_file_exist(void);  
  161.    int  remove_lock_file(void); 
  162.  
  163.  //////////////////////////////// define ///////////////////////////////////////
  164.    int  define(void);  
  165.  
  166.  //////////////////////////////// open & close ////////////////////////////////
  167.    int  open(int kB=100); // Use 100 kB ram for buffering.   
  168.    int  close(void);  
  169.  
  170.    int  close2(void);  
  171.  
  172.    int  already_open(void)  { return is_open; }  
  173.  
  174.  //////////////////////////////// delete //////////////////////////////////////
  175.    int  is_delet(void)   { te(); return db.is_delet(current); } 
  176.    void undelet(void)    { te(); db.undelet(current); }         
  177.    void delet(void)      { te(); db.delet(current); }           
  178.  
  179.    int  is_delet(long n) { te(); return db.is_delet(n); } 
  180.    void undelet(long n)  { te(); db.undelet(n);         } 
  181.    void delet(long n)    { te(); db.delet(n);           } 
  182.  
  183.  //////////////////////////////// number of records ///////////////////////////
  184.    long numrec(void)     { return db.numrec(); } 
  185.  
  186.  //////////////////////////////// import/export ///////////////////////////////
  187.    int  import(char *s);
  188.    int  export(char *s);
  189.    int  to_DBASE(char *s);
  190.  
  191.  //////////////////////////////// reindexing //////////////////////////////////
  192.    int  reindex(void); 
  193.  
  194.  //////////////////////////////// append //////////////////////////////////////
  195.    void append(void);        //Indexes are NOT updated.
  196.    void append_blank(void);  //Indexes ARE updated.
  197.  
  198.  //////////////////////////////// data in header //////////////////////////////
  199.    int data_2_header(void *p,U16 size) { return db.data_2_header(p,size); } 
  200.    int header_2_data(void *p,U16 size) { return db.header_2_data(p,size); } 
  201.    U16 max_data_in_header(void)        { return db.max_data_in_header();  } 
  202.  
  203.  //////////////////////////////// pack ////////////////////////////////////////
  204.    int  pack(void);
  205.  
  206.  //////////////////////////////// (change) active index ///////////////////////
  207.    int  order(int nr);    
  208.    int  order(void)      { return iOrder; } 
  209.  
  210.  //////////////////////////////// testing begin/end ///////////////////////////
  211.    int  tBOF(void);
  212.    int  tEOF(void);
  213.  
  214.  //////////////////////////////// relocating //////////////////////////////////
  215.    int  skip(int delta=1);
  216.    int  prev(int delta=1) { return -skip(-delta); }
  217.    int  next(int delta=1) { return  skip( delta); }
  218.    int  bottom(void);
  219.    int  top(void);
  220.    int  search(void *k);
  221.    int  go_to(long n);
  222.  
  223.  /////////////////////////reading fields //////////////////////////////////////
  224.    char * name(void)           { te(); return static_rec->_name; } 
  225.    char * adre(void)           { te(); return static_rec->_adre; } 
  226.    char * city(void)           { te(); return static_rec->_city; } 
  227.    char * count(void)          { te(); return static_rec->_count; } 
  228.    char * zip(void)            { te(); return static_rec->_zip; } 
  229.    char * tel(void)            { te(); return static_rec->_tel; } 
  230.    char * update(void)         { te(); return (char *)_update; } 
  231.    char * birth(void)          { te(); return (char *)_birth; } 
  232.    char * relation(void)       { te(); return static_rec->_relation; } 
  233.    char * info(void)           { te(); return static_rec->_info; } 
  234.  
  235.  /////////////////////////writing fields //////////////////////////////////////
  236.    void   name(char *s)        { te(); strncpy(static_rec->_name,s,NAMio_NAME_LENGTH); dirty=TRUE; } 
  237.    void   adre(char *s)        { te(); strncpy(static_rec->_adre,s,NAMio_ADRE_LENGTH); dirty=TRUE; } 
  238.    void   city(char *s)        { te(); strncpy(static_rec->_city,s,NAMio_CITY_LENGTH); dirty=TRUE; } 
  239.    void   count(char *s)       { te(); strncpy(static_rec->_count,s,NAMio_COUNT_LENGTH); dirty=TRUE; } 
  240.    void   zip(char *s)         { te(); strncpy(static_rec->_zip,s,NAMio_ZIP_LENGTH); dirty=TRUE; } 
  241.    void   tel(char *s)         { te(); strncpy(static_rec->_tel,s,NAMio_TEL_LENGTH); dirty=TRUE; } 
  242.    void   update(char *s)      { te(); _update=s; dirty=TRUE; } 
  243.    void   birth(char *s)       { te(); _birth=s; dirty=TRUE; } 
  244.    void   relation(char *s)    { te(); strncpy(static_rec->_relation,s,NAMio_RELATION_LENGTH); dirty=TRUE; } 
  245.    void   info(char *s)        { te(); strncpy(static_rec->_info,s,NAMio_INFO_LENGTH); dirty=TRUE; } 
  246.  
  247. };
  248.  
  249.  
  250. #endif
  251.