values_search.c

Go to the documentation of this file.

 
#include "prototypes.h"
 
int values_search(unsigned long index,struct database *dbase,
              int report_limit,struct stim btim,struct stim etim,
              char *qualifier,struct stn_values *stn_values)
 
{
 
    extern struct sensor_type *stype;
    int icnt,jcnt,kcnt,j,m,break_flag,restart,pstart,jtver,itver,lmer,kk,mer,ier;
    int wflag,aflag;
    float fdata,gdata[5];
    double dif,okdif[5];
    signed int  sdx_index,i,next,sloop,end;
    unsigned int rv;
    extern unsigned int sensortype;
    unsigned int rec_size, num_recs, db_slot,report_num;
    signed long offset;
    unsigned long first_overload;
    struct databank    dbk;
    char qu[10],sbuf[100],*p,dbuf[100],*q;
    FILE *fp;
    time_t told,tnew;
    struct tm tm;
    struct tm *gm;
    time_t secs;
    int is;
 
    tnew=ouptime(btim.year,btim.month,btim.day,btim.hour,btim.minute,0);
 
    told=ouptime(etim.year,etim.month,etim.day,etim.hour,etim.minute,0);
    
 
    tnew=tnew+7200;
 
   /* initialize variables */
 
    report_num = 0;
    strcpy(qu,qualifier);
 
    db_slot=index;
 
    for( sloop=0; sloop < 12; sloop++) {
 
    num_recs = 0x01;
    rec_size = sizeof(struct databank);
 
    if(sloop==0) {
 
                 /* read first record*/
 
                 offset   = (signed long)db_slot * rec_size;
                 rv=dbread(NDATABANK, offset, rec_size, num_recs, &dbk);
                 if(rv != rec_size * num_recs)
                                 return(-8);
             
                 
                 for(is=0;is<dbase->sensor_types;is++)
                     if(stype[is].number==dbk.stype)
                                      break;
 
                 if(is==dbase->sensor_types)
                           is=0;
                           
                 sensortype=is;
                 next = dbk.next;
                 end=365;
 
                 }
 
    else if(sloop==1) {
 
                 /* stop here if no more reports exist in primary data file */
 
                 if(dbk.prior == ONOT_USED)
                                    goto finish;
 
                 /* check remainder of reports in primary data block */ 
 
                 next=-1;
                 end=dbk.next + 1;
 
                 }
 
    else if(sloop==2) {
 
                 /*check non-redundant reports in first overload */
 
                 next = dbk.next;
                 first_overload = dbk.prior;
                 offset = (signed long)dbk.prior * rec_size;
                 rv=dbread(NOVERLOAD, offset, rec_size, num_recs, &dbk);
                 if(rv != rec_size * num_recs)
                                 return(-9);
                 end=365;
 
                        }
 
    else               {
            
       if( first_overload != dbk.prior && dbk.prior != ONOT_USED ){
 
                 offset = (signed long)dbk.prior * rec_size;
                 rv=dbread(NOVERLOAD, offset, rec_size, num_recs, &dbk);
                 if(rv != rec_size * num_recs)
                                 return(-10);
 
                 next=0;
                 end=365;
 
                                             }
        else
             goto finish;
 
                           }
                           
    for(i=next+1; i<end; i++) {
 
        /* if requesting a specific number of reports */
 
                if(dbk.rpt[i].data <= -9989.0)
                                           continue;
 
                /* no more reports */
 
        if(report_num == report_limit) 
                               goto finish;
                                           
                stn_values[report_num].value = dbk.rpt[i].data; 
                    
                /* same value as previous report */
                    
                if(report_num > 0 &&
                   stn_values[report_num-1].clock==dbk.rpt[i].clock)
                                         continue;
                    
        secs = dbk.rpt[i].clock;
                gm=gmtime(&secs);
                  
        stn_values[report_num].zdate=(gm->tm_year+1900)*10000+(gm->tm_mon+1)*100+gm->tm_mday;
        stn_values[report_num].ztime=gm->tm_hour*10000+gm->tm_min*100;  
        stn_values[report_num].qual = dbk.rpt[i].dqr;    
        stn_values[report_num].clock = secs;    
 
                /* just get a certain number of reports without time bounds*/
 
                if(tnew==0L && told==0L) {
 
                   if(qu[0]==0 || dbk.rpt[i].dqr==0 ||
                      strchr(qu,dbk.rpt[i].dqr)!=NULL)
                                         report_num++;
 
               continue;
 
                                        }
     
                /* check if report is within bounds */
 
        if((dbk.rpt[i].clock <= tnew) && (dbk.rpt[i].clock >= told)) {
 
                   if(qu[0]==0 || dbk.rpt[i].dqr==0 ||
                      strchr(qu,dbk.rpt[i].dqr)!=NULL)
                                         report_num++;
 
                    continue;
 
                                          }
 
        /* if report is newer than newest time */
 
                else if(dbk.rpt[i].clock > tnew)
                               continue;
                               
        else 
                   goto finish;
                          
              }
                
      }
 
finish:
return(report_num);
 
}