home *** CD-ROM | disk | FTP | other *** search
/ Resource for Source: C/C++ / Resource for Source - C-C++.iso / misc_src / cslib16b / csdbgen / demo.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-01  |  18.1 KB  |  609 lines
  1. /////////////////////////////////////////////////////////
  2. //     Implementation file of database class: NAC.
  3. //                                                          
  4. //     Source generated by: CSDBGEN version 1.2.b.
  5. //     Date of generation:  Thursday, 2 March 1995.
  6. //     Time of generation:  12:02:10.
  7. //                                                          
  8. //                                                          
  9. //     The next lines represent the database definition     
  10. //     file used as input for CSDBGEN.                      
  11. //                                                          
  12. //                                                          
  13. ////////////// Start of the .def file //////////////////
  14. /*
  15. class: NAC
  16. record: nac_record
  17. file: dbfile
  18. field: name s 40 T
  19. field: address s 30 Y
  20. field: city s 20 Y
  21. field: birthday d Y4MD Y
  22. field: salary f
  23. */
  24. /////////////// End of .def file //////////////////////////////////////////////
  25. /*
  26.  
  27.  
  28.  
  29.                  █████     █                       █        
  30.                 ██   ██   ██                      ██        
  31.                 ███      ████     ███   ██ ███   ████       
  32.                   ███     ██        ██   ███ ██   ██        
  33.                     ███   ██     █████   ██       ██        
  34.                 ██   ██   ██ █  ██  ██   ██       ██ █      
  35.                  █████     ██    ███ ██  ██        ██       
  36.                                                             
  37.                                                             
  38.              ████     ████  ██  ██  ██ ███   █████   ████   
  39.             ██       ██  ██ ██  ██   ███ ██ ██   █  ██  ██  
  40.              ████    ██  ██ ██  ██   ██     ██      ██████  
  41.                 ██   ██  ██ ██  ██   ██     ██   █  ██      
  42.              ████     ████   ███ ██  ██      █████   █████  
  43.                                                             
  44.  
  45.  
  46. */
  47. //////////////////////////////////////////////////////////////////////////////
  48.  
  49. #include "demo.h"
  50.  
  51. extern unsigned _stklen=7000;  //A large stack is needed
  52.  
  53.  
  54. ///////////////////////////////// Constructor ////////////////////////////////
  55. NAC::NAC(void) 
  56. { 
  57.     is_open=FALSE; 
  58.     current=1; 
  59.     _birthday.format(Y4MD); 
  60. }
  61.  
  62. ///////////////////////////////// reindex ////////////////////////////////////
  63. void NAC::reindex(void) 
  64. {
  65.     U32 l=current;  
  66.     nac_record *rp;  
  67.     in1.empty(); 
  68.     in2.empty(); 
  69.     in3.empty(); 
  70.     in4.empty(); 
  71.     for(current=numrec(); current>0; current--)  
  72.     {                          
  73.        rp=(nac_record *)db.locate_rec(current);  
  74.        tokenize(rp->_name,&NAC::in1_ins_tok); 
  75.        in2.insert(rp->_address,¤t); 
  76.        in3.insert(rp->_city,¤t); 
  77.        in4.insert(&rp->__birthday,¤t); 
  78.     }                          
  79.     current=l;                 
  80. }
  81.  
  82. /////////////// go_to ////////////////////////////////////////////
  83. void NAC::go_to(long n) 
  84. {
  85.     if(order()!=UNSORTED) 
  86.     {
  87.       csmess_p(7110,"NAC"); 
  88.       return; 
  89.     }
  90.     write_rec(); 
  91.     current=max(min(n,db.numrec()),1); 
  92.     read_rec(); 
  93. }
  94.  
  95. /////////////// append blank//////////////////////////////////////
  96. void NAC::append_blank(void) 
  97. {
  98.        append();
  99.        tokenize(recp->_name,&NAC::in1_ins_tok); 
  100.        in2.insert(rec._address,¤t); 
  101.        in3.insert(rec._city,¤t); 
  102.        in4.insert(&rec.__birthday,¤t); 
  103. }
  104.  
  105. ///////////////////////////////// append /////////////////////////////////////
  106. // This function doesn't update the indexes, which can save some 
  107. // disk I/O because you are likely to alter the fields 
  108. // immediately after you have appended the record.
  109. // However, if you have an index on a field you don't update, this 
  110. // record will NOT appear in that particular index! 
  111. // The 'append_blank' function does update all indexes, which 
  112. // makes it a safer, but slower option. 
  113. //  
  114. void NAC::append(void) 
  115. {
  116.     write_rec();
  117.     memset(&rec,0,sizeof(nac_record)); 
  118.     current=db.append_rec(&rec); 
  119.     recp=(nac_record *)db.locate_rec(current); 
  120.     dirty=TRUE;    
  121.     _birthday.sem_jul(0L);
  122. }
  123.  
  124. ///////////////////////////////// open ///////////////////////////////////////
  125. void NAC::open(void) 
  126. {
  127.      if(is_open) return; 
  128.      int needs_reindex=FALSE;        
  129.      dirty=FALSE;        
  130.  
  131. #ifdef _Windows
  132.      int fre=300/9; //Use 300 Kb for buffers. You may increase this.
  133. #else
  134.      int fre=(int)(coreleft()-100000L)/9/1024;
  135.      fre=max(fre,0); 
  136. #endif
  137.  
  138.      if(!db.open("dbfile.dbf",fre)) 
  139.      {
  140.          csmess_disp("FATAL: Can't open database dbfile.dbf.");
  141.          exit(1);
  142.      }
  143.      if(db.lengthrec()!=sizeof(nac_record)) 
  144.      {
  145.          csmess_disp("FATAL: wrong record size.\n\rProbably wrong or old database file.");
  146.          db.close(); 
  147.          exit(1); 
  148.      }
  149.      if(!file_exist("dbfile01.idx"))
  150.      { 
  151.        in1.multiple_keys(TRUE);
  152.        in1.define("dbfile01.idx",NAME_LENGTH/2,sizeof(long));
  153.        needs_reindex=TRUE; 
  154.      } 
  155.      in1.open("dbfile01.idx",fre*2);
  156.   
  157.      if(!file_exist("dbfile02.idx"))
  158.      { 
  159.        in2.multiple_keys(TRUE);
  160.        in2.define("dbfile02.idx",ADDRESS_LENGTH+1,sizeof(long));
  161.        needs_reindex=TRUE; 
  162.      } 
  163.      in2.open("dbfile02.idx",fre*2);
  164.   
  165.      if(!file_exist("dbfile03.idx"))
  166.      { 
  167.        in3.multiple_keys(TRUE);
  168.        in3.define("dbfile03.idx",CITY_LENGTH+1,sizeof(long));
  169.        needs_reindex=TRUE; 
  170.      } 
  171.      in3.open("dbfile03.idx",fre*2);
  172.   
  173.      if(!file_exist("dbfile04.idx"))
  174.      { 
  175.        in4.multiple_keys(TRUE);
  176.        in4.define("dbfile04.idx",sizeof(long),sizeof(long));
  177.        needs_reindex=TRUE; 
  178.      } 
  179.      in4.open("dbfile04.idx",fre*2);
  180.   
  181.      if(needs_reindex) reindex(); 
  182.      is_open=TRUE; 
  183.      if(numrec()==0) append_blank();
  184.      else            read_rec(); 
  185.   
  186.      order(UNSORTED);  
  187. }
  188.  
  189. ///////////////////////////////// close //////////////////////////////////////
  190. void NAC::close(void) 
  191. {
  192.      if(!is_open) return; 
  193.      write_rec(); 
  194.      db.close(); 
  195.      in1.close();
  196.      in2.close();
  197.      in3.close();
  198.      in4.close();
  199.      is_open=FALSE; 
  200. }
  201.  
  202. ///////////////////////////////// define /////////////////////////////////////
  203. void NAC::define(void) 
  204. {
  205.      db.define("dbfile.dbf",sizeof(nac_record)); 
  206.      in1.multiple_keys(TRUE);
  207.      in1.define("dbfile01.idx",NAME_LENGTH/2,sizeof(long));
  208.      in2.multiple_keys(TRUE);
  209.      in2.define("dbfile02.idx",ADDRESS_LENGTH+1,sizeof(long));
  210.      in3.multiple_keys(TRUE);
  211.      in3.define("dbfile03.idx",CITY_LENGTH+1,sizeof(long));
  212.      in4.multiple_keys(TRUE);
  213.      in4.define("dbfile04.idx",sizeof(long),sizeof(long));
  214. }
  215.  
  216. ///////////////////////////////// pack ///////////////////////////////////////
  217. void NAC::pack(void) 
  218. {
  219.      write_rec(); 
  220.      db.pack();
  221.      reindex();
  222.      if(numrec()==0) append_blank();
  223.      top();
  224. }
  225.  
  226. ///////////////////////////////// skip ///////////////////////////////////////
  227. int  NAC::skip0(int delta) 
  228. {
  229.      long old_current=current; 
  230.      current=max(min(current+delta,db.numrec()),1); 
  231.      return current-old_current; 
  232. }
  233.  
  234. int  NAC::skip(int delta) 
  235. {
  236.      int rc; 
  237.      write_rec(); 
  238.      rc=(this->*skip_fun)(delta); 
  239.      read_rec(); 
  240.      return rc; 
  241. }
  242.  
  243. ///////////////////////////////// order //////////////////////////////////////
  244. void NAC::order(int nr) 
  245. {
  246.      switch(nr)
  247.      {
  248.          case 0:        //Unsorted 
  249.                   bof_fun   =&NAC::bof0;
  250.                   eof_fun   =&NAC::eof0;
  251.                   skip_fun  =&NAC::skip0;
  252.                   top_fun   =&NAC::top0;
  253.                   bottom_fun=&NAC::bottom0;
  254.                   search_fun=&NAC::search0;
  255.                   break; 
  256.          case 1:        //Index on field name
  257.                   bof_fun   =&NAC::bof1;
  258.                   eof_fun   =&NAC::eof1;
  259.                   skip_fun  =&NAC::skip1;
  260.                   top_fun   =&NAC::top1;
  261.                   bottom_fun=&NAC::bottom1;
  262.                   search_fun=&NAC::search1;
  263.                   break; 
  264.          case 2:        //Index on field address
  265.                   bof_fun   =&NAC::bof2;
  266.                   eof_fun   =&NAC::eof2;
  267.                   skip_fun  =&NAC::skip2;
  268.                   top_fun   =&NAC::top2;
  269.                   bottom_fun=&NAC::bottom2;
  270.                   search_fun=&NAC::search2;
  271.                   break; 
  272.          case 3:        //Index on field city
  273.                   bof_fun   =&NAC::bof3;
  274.                   eof_fun   =&NAC::eof3;
  275.                   skip_fun  =&NAC::skip3;
  276.                   top_fun   =&NAC::top3;
  277.                   bottom_fun=&NAC::bottom3;
  278.                   search_fun=&NAC::search3;
  279.                   break; 
  280.          case 4:        //Index on field birthday
  281.                   bof_fun   =&NAC::bof4;
  282.                   eof_fun   =&NAC::eof4;
  283.                   skip_fun  =&NAC::skip4;
  284.                   top_fun   =&NAC::top4;
  285.                   bottom_fun=&NAC::bottom4;
  286.                   search_fun=&NAC::search4;
  287.                   break; 
  288.          default: return; // Function called with wrong parameter.
  289.      }
  290.      iOrder=nr;
  291.      top();
  292. }
  293. /////////////////////////////writing record  ///////////////////////////////
  294. void NAC::write_rec2(void) 
  295. {
  296.     if(strcmp(recp->_name,rec._name)) 
  297.     { 
  298.       tokenize(recp->_name,&NAC::in1_del_tok); 
  299.       tokenize(rec._name,&NAC::in1_ins_tok); 
  300.     } 
  301.     if(strcmp(recp->_address,rec._address)) 
  302.     { 
  303.       in2.delet(recp->_address,¤t); 
  304.       in2.insert(rec._address,¤t); 
  305.     } 
  306.     if(strcmp(recp->_city,rec._city)) 
  307.     { 
  308.       in3.delet(recp->_city,¤t); 
  309.       in3.insert(rec._city,¤t); 
  310.     } 
  311.     rec.__birthday=_birthday.sem_jul(); 
  312.     if(recp->__birthday!=rec.__birthday) 
  313.     { 
  314.       in4.delet(&recp->__birthday,¤t); 
  315.       in4.insert(&rec.__birthday,¤t); 
  316.     } 
  317.     db.write_rec(current,&rec); 
  318.     dirty=FALSE;   
  319. }
  320.  
  321. ///////////////////////////////// export /////////////////////////////////////
  322. int  NAC::export(char *s) 
  323. {
  324.      FILE *fo=fopen(s,"w"); 
  325.      if(fo==NULL) return FALSE; 
  326.  
  327.      write_rec();
  328.      fprintf(fo,"class:  NAC");
  329.      fprintf(fo,"\nrecord: nac_record");
  330.      fprintf(fo,"\nfile:   dbfile");
  331.      fprintf(fo,"\nfield:  name s 40 Y");
  332.      fprintf(fo,"\nfield:  address s 30 Y");
  333.      fprintf(fo,"\nfield:  city s 20 Y");
  334.      fprintf(fo,"\nfield:  birthday d Y");
  335.      fprintf(fo,"\nfield:  salary f  ");
  336.  
  337.      if(ferror(fo)) { fclose(fo); return FALSE; } 
  338.  
  339.      nac_record *recp;
  340.      DATE conv;
  341.      conv.format(Y4MD);
  342.      for(long l=numrec();l>0;l--) 
  343.      {
  344.         recp=( nac_record * )db.locate_rec(l);
  345.         fprintf(fo,"\n%c",12);
  346.         fprintf(fo,"\n%s",recp->_name);
  347.         fprintf(fo,"\n%s",recp->_address);
  348.         fprintf(fo,"\n%s",recp->_city);
  349.         conv.sem_jul(recp->__birthday);
  350.         fprintf(fo,"\n%s",(char *)conv);
  351.         fprintf(fo,"\n%g",recp->_salary);
  352.         fprintf(fo,"\n"); //Additional linefeed, to avoid trouble!
  353.  
  354.         if(ferror(fo)) { fclose(fo); return FALSE; } 
  355.      }
  356.      return !fclose(fo);  
  357. }
  358.  
  359. ///////////////////////////////// import /////////////////////////////////////
  360. int NAC::import(char *s) 
  361. {   
  362.  
  363.       FILE *fr=fopen(s,"r"); 
  364.       if(fr==NULL) return FALSE;
  365.   
  366.   
  367. #define MAX_NUM_FIELDS  100   //Increase this to allow more fields    
  368. #define MAX_FIELD_LEN   500   //Increase this to allow longer fields  
  369.  
  370.       int *finu;
  371.       finu=(int *)malloc(MAX_NUM_FIELDS*sizeof(int));
  372.       if(finu==NULL) { fclose(fr); return FALSE; }   
  373.  
  374.       char *fibu;    
  375.       fibu=(char *)malloc(MAX_FIELD_LEN);
  376.       if(fibu==NULL) { fclose(fr); free(finu); return FALSE; } 
  377.       *fibu=0;  
  378.  
  379.       char *fipo=fibu+strlen("field:");  
  380.       char *cp; 
  381.       int  ifieldnr=0;    
  382.       int  ofieldnr; 
  383.       DATE conv;
  384.       conv.format(Y4MD);
  385.  
  386.       memset(finu,0,MAX_NUM_FIELDS*sizeof(int));
  387.  
  388.       fgets(fibu,MAX_FIELD_LEN,fr); 
  389.       while(!strchr(fibu,12))  
  390.       {    
  391.         strlwr(fibu);
  392.         notabs(fibu);
  393.         trim_string(fibu);
  394.         if(strstr(fibu,"field:"))   
  395.         {  
  396.            ifieldnr++;  
  397.            trim_string(fipo);    
  398.            if((cp=strchr(fipo,' '))!=NULL) *cp=0;
  399.            if     (!strcmp(fipo,"name"))    ofieldnr=1;
  400.            else if(!strcmp(fipo,"address"))    ofieldnr=2;
  401.            else if(!strcmp(fipo,"city"))    ofieldnr=3;
  402.            else if(!strcmp(fipo,"birthday"))    ofieldnr=4;
  403.            else if(!strcmp(fipo,"salary"))    ofieldnr=5;
  404.            else ofieldnr=0; 
  405.            finu[ifieldnr]=ofieldnr; 
  406.         }  
  407.         fgets(fibu,MAX_FIELD_LEN,fr);    
  408.       }    
  409.  
  410.  
  411.  
  412.       for(;;)   
  413.       {    
  414.         if(!strchr(fibu,12))   
  415.         {  
  416.            ifieldnr++; 
  417.            if(ifieldnr<MAX_NUM_FIELDS) 
  418.              switch(finu[ifieldnr])   
  419.              {  
  420.                 case 0:  break;
  421.                 case 1:
  422.                          fibu[NAME_LENGTH]=0;
  423.                          name(fibu);
  424.                          break;
  425.                 case 2:
  426.                          fibu[ADDRESS_LENGTH]=0;
  427.                          address(fibu);
  428.                          break;
  429.                 case 3:
  430.                          fibu[CITY_LENGTH]=0;
  431.                          city(fibu);
  432.                          break;
  433.                 case 4:
  434.                          conv=fibu;
  435.                          _birthday.sem_jul(conv.sem_jul());
  436.                          break;
  437.                 case 5:
  438.                          salary(atof(fibu));
  439.                          break;
  440.              }  
  441.         }  
  442.         else    
  443.         {  
  444.            ifieldnr=0; 
  445.            append_blank();
  446.         }  
  447.         if(feof(fr)) break;    
  448.         fgets(fibu,MAX_FIELD_LEN,fr);    
  449.         cp=fibu+(max(1,strlen(fibu))-1); 
  450.         if(*cp=='\n') *cp=0;  //removing the line feed 
  451.       }    
  452.  
  453.  
  454.       fclose(fr); 
  455.       free(fibu); 
  456.       free(finu); 
  457.  
  458. #undef MAX_NUM_FIELDS
  459. #undef MAX_FIELD_LEN 
  460.  
  461.  return TRUE; 
  462. }
  463.  
  464. ///////////////////////////////// export to dBASE compatible file. ///////////
  465. int NAC::to_DBASE(char *s) 
  466. {   
  467.  
  468.       char bufje[12];
  469.       if(!is_open) return FALSE;
  470.  
  471.       write_rec(); 
  472.       FILE *fo=fopen(s,"wb"); 
  473.       if(fo==NULL) return FALSE;
  474.   
  475.       int i;
  476.   
  477.       DATE d_upda;
  478.       d_upda.sem_jul(db.sj_updated());
  479.       fputc(03,fo);  
  480.       
  481.       fputc(d_upda.year()%100,fo);  
  482.       fputc(d_upda.month(),fo);  
  483.       fputc(d_upda.day(),fo);  
  484.  
  485.       long nr_record=numrec(); 
  486.       fwrite(&nr_record,sizeof(long),1,fo); 
  487.       putw(194,fo);        //Header length 
  488.       putw(113,fo);        //Length of data record 
  489.       for(i=0;i<20;i++) fputc(0,fo); // 20 dummy bytes 
  490.  
  491.  
  492. // Writing definition of field name to dbase file header.
  493.       memset(bufje,0,11);
  494.       strcpy(bufje,"NAME");
  495.       fwrite(bufje,11,1,fo);
  496.       fputc('C',fo); 
  497.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  498.       fputc(40,fo); 
  499.       fputc(0,fo); 
  500.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  501.  
  502. // Writing definition of field address to dbase file header.
  503.       memset(bufje,0,11);
  504.       strcpy(bufje,"ADDRESS");
  505.       fwrite(bufje,11,1,fo);
  506.       fputc('C',fo); 
  507.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  508.       fputc(30,fo); 
  509.       fputc(0,fo); 
  510.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  511.  
  512. // Writing definition of field city to dbase file header.
  513.       memset(bufje,0,11);
  514.       strcpy(bufje,"CITY");
  515.       fwrite(bufje,11,1,fo);
  516.       fputc('C',fo); 
  517.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  518.       fputc(20,fo); 
  519.       fputc(0,fo); 
  520.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  521.  
  522. // Writing definition of field birthday to dbase file header.
  523.       memset(bufje,0,11);
  524.       strcpy(bufje,"BIRTHDAY");
  525.       fwrite(bufje,11,1,fo);
  526.       fputc('D',fo); 
  527.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  528.       fputc(8,fo); 
  529.       fputc(0,fo); 
  530.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  531.  
  532. // Writing definition of field salary to dbase file header.
  533.       memset(bufje,0,11);
  534.       strcpy(bufje,"SALARY");
  535.       fwrite(bufje,11,1,fo);
  536.       fputc('N',fo); 
  537.       for(i=0;i<4;i++) fputc(0,fo); // 4 dummy bytes 
  538.       fputc(14,fo); 
  539.       fputc(7,fo); 
  540.       for(i=0;i<14;i++) fputc(0,fo); // 14 dummy bytes 
  541.  
  542.  
  543.       fputc(13,fo);  //Field terminator 
  544.       fputc(0,fo); 
  545.  
  546. // By now we have written the definition of the 
  547. // record structure to the file header. 
  548. // From here on we will export the records. 
  549.  
  550.      nac_record *recp;
  551.      for(long l=numrec();l>0;l--) 
  552.      {
  553.  
  554.         if(ferror(fo)) { fclose(fo); return FALSE; } 
  555.         recp=(nac_record *)db.locate_rec(l);
  556.  
  557.         if(db.is_delet(l)) fputc(42,fo); 
  558.         else               fputc(32,fo); 
  559.  
  560. /////////////////////// writing field name /////////////
  561.         fprintf(fo,"%-40s",recp->_name);
  562. /////////////////////// writing field address /////////////
  563.         fprintf(fo,"%-30s",recp->_address);
  564. /////////////////////// writing field city /////////////
  565.         fprintf(fo,"%-20s",recp->_city);
  566. /////////////////////// writing field birthday /////////////
  567.         if(recp->__birthday)
  568.         { 
  569.           d_upda.sem_jul(recp->__birthday);
  570.           fprintf(fo,"%4d",d_upda.year4());
  571.           fprintf(fo,"%02d",d_upda.month());
  572.           fprintf(fo,"%02d",d_upda.day());
  573.         } 
  574.         else 
  575.         { 
  576.           fprintf(fo,"        "); 
  577.         } 
  578. /////////////////////// writing field salary /////////////
  579.         fprintf(fo,"%14.7f",recp->_salary);
  580.      }
  581.      fputc(26,fo);  //End of File 
  582.      fclose(fo); 
  583.  
  584.  return TRUE; 
  585. }
  586.  
  587. ///////////////////////////////// tokenize field ///////////////////////
  588. void NAC::tokenize(char *s,void(NAC::*fun)(void *))
  589. {
  590.  
  591.      char delim[]="\t,()- "; //Token delimiters
  592.      const min_len=4;  //Minimum length for a token to be indexed.
  593.      char *p,*q=s;
  594.      char c;
  595.      int  insert=FALSE;
  596.  
  597.      p=strpbrk(q,delim);
  598.      while(p)
  599.      {
  600.         c=*p; *p=0;
  601.         if(strlen(q)>=min_len) { (this->*fun)(q); insert=TRUE; }
  602.         *p=c;
  603.         do{ p=strpbrk(q=p+1,delim); }while(q==p);
  604.      }
  605.  
  606.      if(strlen(q)>=min_len) { (this->*fun)(q); insert=TRUE; }
  607.      if(!insert) (this->*fun)(s);
  608.  
  609. }