snow/dockapps
1
0
Fork 0
Code Issues Releases Activity
dockapps/wmweather+/forecast.c
Carlos R. Mafra eea379d833 Strip off version numbers from dir name
2012-02-12 22:50:31 +00:00

312 lines
7.9 KiB
C
Raw Blame History

#include "config.h"
/* Copyright (C) 2002 Brad Jorsch <anomie@users.sourceforge.net>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <stdio.h>
#include <stdlib.h>
#if TM_IN_SYS_TIME
# if TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
# else
# if HAVE_SYS_TIME_H
# include <sys/time.h>
# else
# include <time.h>
# endif
# endif
#else
#include <time.h>
#endif
#include <string.h>
#include <limits.h>
#include <math.h>
#include <pcre.h>
#include "forecast.h"
#include "convert.h"
#include "getLine.h"
#include "die.h"
/* Important variables */
static struct forecast **forecasts=NULL;
static int num_forecasts=0;
static pcre *date=NULL;
static int ovecsize=1;
static int changed=0;
/* functions */
time_t find_next_time(char *file, char *pat, int minutes){
FILE *fp;
char *s;
time_t t, mintime;
mintime=time(NULL)/60+15;
if((fp=fopen(file, "r"))==NULL) return mintime;
s=NULL;
while(!feof(fp)){
getLine(&s, fp);
if(strstr(s, pat)!=NULL) break;
free(s);
s=NULL;
}
fclose(fp);
if(s==NULL) return mintime;
t=parse_time_string(s)/60+minutes;
free(s);
return (t>mintime)?t:mintime;
}
time_t parse_time_string(char *s){
struct tm tm;
int ovector[ovecsize];
int ovalue;
char *e;
int i;
if(date==NULL){
date=pcre_compile("\\b(\\d+)/(\\d+)/(\\d+)\\s+(\\d\\d)(\\d\\d)\\s*UTC\\b", 0, (const char **)&e, &i, NULL);
if(date==NULL){
warn("find_next PCRE error: %s at %i", e, i);
return -1;
}
pcre_fullinfo(date, NULL, PCRE_INFO_CAPTURECOUNT, &ovecsize);
ovecsize=(ovecsize+1)*3;
return parse_time_string(s);
}
ovalue=pcre_exec(date, NULL, s, strlen(s), 0, 0, ovector, ovecsize);
if(ovalue<=0) return -1;
if(pcre_get_substring(s, ovector, ovalue, 1, (const char **)&e)<0) return 0;
tm.tm_mon=atoi(e)-1;
pcre_free_substring(e);
if(pcre_get_substring(s, ovector, ovalue, 2, (const char **)&e)<0) return 0;
tm.tm_mday=atoi(e);
pcre_free_substring(e);
if(pcre_get_substring(s, ovector, ovalue, 3, (const char **)&e)<0) return 0;
tm.tm_year=atoi(e)-1900;
pcre_free_substring(e);
if(pcre_get_substring(s, ovector, ovalue, 4, (const char **)&e)<0) return 0;
tm.tm_hour=atoi(e);
pcre_free_substring(e);
if(pcre_get_substring(s, ovector, ovalue, 5, (const char **)&e)<0) return 0;
tm.tm_min=atoi(e);
pcre_free_substring(e);
tm.tm_sec=0;
return mkgmtime(&tm);
}
void add_forecast(struct forecast *f, char *ID, char *station){
if((forecasts=realloc(forecasts, ++num_forecasts*sizeof(*forecasts)))==NULL)
die("realloc in add_forecast");
if(ID==NULL){
memset(f->ID, '\0', 4);
} else {
strncpy(f->ID, ID, 3);
f->ID[3]='\0';
}
f->station=station;
forecasts[num_forecasts-1]=f;
changed=1;
}
void reset_forecast(struct forecast *f){
f->last_update=time(NULL);
f->month=0;
f->day=-1;
f->year=SHRT_MIN;
f->wday=-1;
f->hour=-1;
f->low=999;
f->high=999;
f->temp=999;
f->dewpt=999;
f->rh=-1;
f->winddir=-1;
f->windspeed=-1;
f->heatindex=999;
f->windchill=999;
f->precipamt=-1;
f->snowamt=-1;
f->sky=-1;
f->vis=7;
f->obs=0;
f->pcp_total=0;
f->frz=0;
f->snow=0;
f->rain=0;
f->tstorm=0;
f->svtstorm=0;
f->moon=NAN;
f->time=-1;
changed=1;
}
static int is_forecast_valid(const struct forecast *a){
return (a->ID[0]!='\0' &&
a->month>0 && a->month<=12 &&
a->day>0 && a->day<=31 &&
a->year!=SHRT_MIN);
}
static int is_forecast_current(struct forecast *f, time_t now){
time_t t;
t=forecast_time(f);
t+=(f->hour<0)?86399:3599;
return t>now;
}
static int compar(const void *aa, const void *bb){
struct forecast *a=*(struct forecast **)aa;
struct forecast *b=*(struct forecast **)bb;
int i, j;
/* First, any undefined forecast is greater than any defined forecast */
i=is_forecast_valid(a);
j=is_forecast_valid(b);
if(!i && !j) return 0; /* all undef forecasts are equal */
if(!i) return 1;
if(!j) return -1;
/* Any whole-day forecast is greater than any partial forecast */
if(a->hour<0 && b->hour>=0) return 1;
if(a->hour>=0 && b->hour<0) return -1;
/* Ok, compare dates now */
if(a->year>b->year) return 1;
if(a->year<b->year) return -1;
if(a->month>b->month) return 1;
if(a->month<b->month) return -1;
if(a->day>b->day) return 1;
if(a->day<b->day) return -1;
if(a->hour>b->hour) return 1;
if(a->hour<b->hour) return -1;
/* Last resort, sort in alphabetical order by ID */
return strcasecmp(a->ID, b->ID);
}
static void sort_forecasts(void){
if(forecasts==NULL) return;
qsort(forecasts, num_forecasts, sizeof(struct forecast *), compar);
changed=0;
}
time_t forecast_time(struct forecast *f){
struct tm tm;
if(f->time!=-1) return f->time;
tm.tm_year=f->year;
tm.tm_mon=f->month-1;
tm.tm_mday=f->day;
tm.tm_hour=(f->hour<0)?0:f->hour;
tm.tm_min=tm.tm_sec=0;
return (f->time=mktime(&tm));
}
static char current_ID[4]={ '\0', '\0', '\0', '\0' };
static int current_index=-1;
static struct forecast *current=NULL;
static time_t current_time=0;
static int current_hour=0;
static void set_current(int i){
current_index=i;
if(i<0 || i>num_forecasts){
current=NULL;
memset(current_ID, 0, 4);
current_time=0;
current_hour=0;
} else {
current=forecasts[i];
memcpy(current_ID, current->ID, 4);
current_time=forecast_time(current);
current_hour=current->hour;
}
}
static void locate_current(void){
int i;
time_t now, target;
int target_hour;
long curdiff=0;
long tmpdiff;
char target_ID[4];
now=time(NULL);
if(!changed && current!=NULL && is_forecast_current(current, now)) return;
sort_forecasts();
target=current_time;
target_hour=current_hour;
memcpy(target_ID, current_ID, 4);
set_current(-1);
for(i=0; i<num_forecasts; i++){
if(!is_forecast_valid(forecasts[i])) continue;
if(!is_forecast_current(forecasts[i], now)) continue;
tmpdiff=abs(forecast_time(forecasts[i])-target);
if((target_hour<0 && forecasts[i]->hour>=0) ||
(target_hour>=0 && forecasts[i]->hour<0))
tmpdiff+=31556926;
if(memcmp(forecasts[i]->ID, target_ID, 4)) tmpdiff++;
if(current==NULL || tmpdiff<curdiff){
set_current(i);
curdiff=tmpdiff;
}
}
}
struct forecast *current_forecast_get(void){
locate_current();
return current;
}
static inline int mod(int i, int n){
i=i%n; if(i<0) i+=n;
return i;
}
void current_forecast_next(int dir){
int i;
time_t now;
if(num_forecasts==0) return;
locate_current();
now=time(NULL);
if(current_index<0 || current_index>num_forecasts) current_index=0;
for(i=mod(current_index+dir, num_forecasts); ; i=mod(i+dir, num_forecasts)){
if(is_forecast_valid(forecasts[i]) && is_forecast_current(forecasts[i], now)){
set_current(i);
return;
}
if(i==current_index){
set_current(-1);
return;
}
}
}
Reference in a new issue View git blame Copy permalink