← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/mapserver/jaunty-updates

« back to all changes in this revision

Viewing changes to maptime.c

  • Committer: Bazaar Package Importer
  • Author(s): Fabio Tranchitella
  • Date: 2006-11-02 11:44:17 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20061102114417-pnutjb20kqzl23ua
Tags: 4.10.0-3
http://bugs.debian.org/396565
debian/control: build-depends on libpq-dev. (Closes: #396565)

Show diffs side-by-side

added added

removed removed

Lines of Context:
maptime.c
27
27
 ******************************************************************************
28
28
 *
29
29
 * $Log: maptime.c,v $
 
30
 * Revision 1.19  2006/03/14 03:43:30  assefa
 
31
 * Move msValidateTimeValue to maptime so it can be used by WMS and SOS.
 
32
 * (Bug 1710)
 
33
 *
30
34
 * Revision 1.18  2005/09/26 14:51:40  assefa
31
35
 * Correct typo in  ms_timeFormats (Bug 1478).
32
36
 *
55
59
#include "maptime.h"
56
60
#include "maperror.h"
57
61
 
58
 
MS_CVSID("$Id: maptime.c,v 1.18 2005/09/26 14:51:40 assefa Exp $")
 
62
MS_CVSID("$Id: maptime.c,v 1.19 2006/03/14 03:43:30 assefa Exp $")
59
63
 
60
64
typedef struct {
61
65
  char pattern[64];
326
330
      
327
331
     return -1;
328
332
}
 
333
 
 
334
 
 
335
int _msValidateTime(char *timestring,  const char *timeextent)
 
336
{
 
337
    int numelements, numextents, i, numranges;
 
338
    struct tm  tmtimestart, tmtimeend, tmstart, tmend;
 
339
    char **atimerange = NULL, **atimeelements= NULL, **atimeextents=NULL;
 
340
 
 
341
    if (!timestring || !timeextent)
 
342
      return MS_FALSE;
 
343
 
 
344
    if (strlen(timestring) <= 0 || 
 
345
        strlen(timeextent) <= 0)
 
346
       return MS_FALSE;
 
347
  
 
348
 
 
349
    /* we first need to parse the timesting that is passed
 
350
       so that we can determine if it is a descrete time
 
351
       or a range */
 
352
    
 
353
    numelements = 0;
 
354
    atimeelements = split (timestring, '/', &numelements);
 
355
    msTimeInit(&tmtimestart);
 
356
    msTimeInit(&tmtimeend);
 
357
 
 
358
    if (numelements == 1) /*descrete time*/
 
359
    {
 
360
        /*start end end times are the same*/
 
361
        if (msParseTime(timestring, &tmtimestart) != MS_TRUE)
 
362
        {       
 
363
            msFreeCharArray(atimeelements, numelements);
 
364
            return  MS_FALSE;
 
365
        }
 
366
        if (msParseTime(timestring, &tmtimeend) != MS_TRUE)
 
367
        {
 
368
            msFreeCharArray(atimeelements, numelements);
 
369
            return  MS_FALSE;
 
370
        }
 
371
    }
 
372
    else if (numelements >=2)/*range */
 
373
    {
 
374
        if (msParseTime(atimeelements[0], &tmtimestart) != MS_TRUE)
 
375
        {
 
376
            msFreeCharArray(atimeelements, numelements);
 
377
            return  MS_FALSE;
 
378
        }
 
379
        if (msParseTime(atimeelements[1], &tmtimeend) != MS_TRUE)
 
380
        {
 
381
            msFreeCharArray(atimeelements, numelements);
 
382
            return  MS_FALSE;
 
383
        }
 
384
    }
 
385
 
 
386
    msFreeCharArray(atimeelements, numelements);
 
387
    
 
388
 
 
389
    /* Now parse the time extent. Extents can be 
 
390
      -  one range (2004-09-21/2004-09-25/resolution) 
 
391
      -  multiple rages 2004-09-21/2004-09-25/res1,2004-09-21/2004-09-25/res2
 
392
      - one value 2004-09-21
 
393
      - mutiple values 2004-09-21,2004-09-22,2004-09-23
 
394
    */
 
395
    
 
396
    numextents = 0;
 
397
    atimeextents = split (timeextent, ',', &numextents);
 
398
    if (atimeextents == NULL || numextents <= 0)
 
399
      return MS_FALSE;
 
400
    
 
401
    /*the time timestring should at be valid in one of the extents
 
402
      defined */
 
403
 
 
404
    for (i=0; i<numextents; i++)
 
405
    {
 
406
        /* build time structure for the extents */
 
407
        msTimeInit(&tmstart);
 
408
        msTimeInit(&tmend);
 
409
        
 
410
        numranges = 0;
 
411
        atimerange = split (atimeextents[i], '/', &numranges);
 
412
        /* - one value 2004-09-21 */
 
413
        if (numranges == 1)
 
414
        {
 
415
            /*time tested can either be descrete or a range */
 
416
            
 
417
            if (msParseTime(atimerange[0], &tmstart) == MS_TRUE &&
 
418
                msParseTime(atimerange[0], &tmend) == MS_TRUE &&
 
419
                msTimeCompare(&tmstart, &tmtimestart) <= 0 &&
 
420
                msTimeCompare(&tmend, &tmtimeend) >= 0)
 
421
            {
 
422
                msFreeCharArray(atimerange, numranges);
 
423
                return MS_TRUE;
 
424
            }
 
425
        }
 
426
        /*2004-09-21/2004-09-25/res1*/
 
427
        else if (numranges >= 2)
 
428
        {
 
429
            if (msParseTime(atimerange[0], &tmstart) == MS_TRUE &&
 
430
                msParseTime(atimerange[1], &tmend) == MS_TRUE &&
 
431
                msTimeCompare(&tmstart, &tmtimestart) <= 0 &&
 
432
                msTimeCompare(&tmend, &tmtimeend) >= 0)
 
433
            {
 
434
                 msFreeCharArray(atimerange, numranges);
 
435
                return MS_TRUE;
 
436
            }
 
437
        }
 
438
        msFreeCharArray(atimerange, numranges);
 
439
        
 
440
 
 
441
    }
 
442
    msFreeCharArray(atimeextents, numextents);
 
443
    return MS_FALSE;
 
444
 
 
445
}
 
446
 
 
447
 
 
448
 
 
449
int msValidateTimeValue(char *timestring, const char *timeextent)
 
450
{
 
451
    char **atimes, **tokens =  NULL;
 
452
    int i, numtimes, ntmp = 0;
 
453
 
 
454
    /* we need to validate the time passsed in the request */
 
455
    /* against the time extent defined */
 
456
 
 
457
    if (!timestring || !timeextent)
 
458
      return MS_FALSE;
 
459
 
 
460
   
 
461
    /* parse the time string. We support descrete times (eg 2004-09-21), */
 
462
    /* multiple times (2004-09-21, 2004-09-22, ...) */
 
463
    /* and range(s) (2004-09-21/2004-09-25, 2004-09-27/2004-09-29) */
 
464
    if (strstr(timestring, ",") == NULL &&
 
465
        strstr(timestring, "/") == NULL) /* discrete time */
 
466
    {
 
467
        return _msValidateTime(timestring,  timeextent);
 
468
        
 
469
    }
 
470
    else
 
471
    {
 
472
        atimes = split (timestring, ',', &numtimes);
 
473
        if (numtimes >=1) /* multiple times */
 
474
        {
 
475
            tokens = split(atimes[0],  '/', &ntmp);
 
476
            if (ntmp == 1) /* multiple descrete times */
 
477
            {
 
478
              /*msFreeCharArray(tokens, ntmp);*/
 
479
                for (i=0; i<numtimes; i++)
 
480
                {
 
481
                    if (_msValidateTime(atimes[i], timeextent) == MS_FALSE)
 
482
                    {
 
483
                        msFreeCharArray(atimes, numtimes);
 
484
                        return MS_FALSE;
 
485
                    }
 
486
                }
 
487
                msFreeCharArray(atimes, numtimes);
 
488
                return MS_TRUE;
 
489
            }
 
490
            else if (ntmp >= 2)/* multiple ranges */
 
491
            {
 
492
                for (i=0; i<numtimes; i++)
 
493
                {
 
494
                  /*msFreeCharArray(tokens, ntmp);*/
 
495
                    if (_msValidateTime(atimes[i], timeextent) == MS_FALSE)
 
496
                    {
 
497
                        msFreeCharArray(atimes, numtimes);
 
498
                        return MS_FALSE;
 
499
                    }
 
500
                     
 
501
                 }
 
502
                 msFreeCharArray(atimes, numtimes);
 
503
                 return MS_TRUE;
 
504
            }
 
505
            
 
506
        }
 
507
 
 
508
    }
 
509
    return MS_FALSE;
 
510
}
 
511