date.cpp

Go to the documentation of this file.

/*
 * date.cpp
 *
 * Copyright (c) 2003-2010 Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Implementation of basic date functions (see date.h)
 */

// includes --------------------------------------------------------------------
#include "date.h"               // always include our own header first

#include <sstream>

#include <time.h>
#include <math.h>



static const long s_secondsPerDay       = 24 * 3600;
static const long s_secondsPerWeek      = 7 * s_secondsPerDay;

static const long s_firstSunday         = 3 * s_secondsPerDay;  // I think ???



/*
 * typedefs
 */

struct month_entry_t {
        const char     *name;
        int             month;
};



/*
 * structs (local only)
 */

#define MONTH_ENTRY(name, month) { #name , month },

static const month_entry_t s_Months[] = {
        MONTH_ENTRY(1,                  1)
        MONTH_ENTRY(01,                 1)
        MONTH_ENTRY(jan,                1)
        MONTH_ENTRY(january,            1)

        MONTH_ENTRY(2,                  2)
        MONTH_ENTRY(02,                 2)
        MONTH_ENTRY(feb,                2)
        MONTH_ENTRY(february,           2)

        MONTH_ENTRY(3,                  3)
        MONTH_ENTRY(03,                 3)
        MONTH_ENTRY(mar,                3)
        MONTH_ENTRY(march,              3)

        MONTH_ENTRY(4,                  4)
        MONTH_ENTRY(04,                 4)
        MONTH_ENTRY(apr,                4)
        MONTH_ENTRY(april,              4)

        MONTH_ENTRY(5,                  5)
        MONTH_ENTRY(05,                 5)
        MONTH_ENTRY(may,                5)

        MONTH_ENTRY(6,                  6)
        MONTH_ENTRY(06,                 6)
        MONTH_ENTRY(jun,                6)
        MONTH_ENTRY(june,               6)

        MONTH_ENTRY(7,                  7)
        MONTH_ENTRY(07,                 7)
        MONTH_ENTRY(jul,                7)
        MONTH_ENTRY(july,               7)

        MONTH_ENTRY(8,                  8)
        MONTH_ENTRY(08,                 8)
        MONTH_ENTRY(aug,                8)
        MONTH_ENTRY(august,             8)

        MONTH_ENTRY(9,                  9)
        MONTH_ENTRY(09,                 9)
        MONTH_ENTRY(sep,                9)
        MONTH_ENTRY(september,          9)

        MONTH_ENTRY(10,                 10)
        MONTH_ENTRY(oct,                10)
        MONTH_ENTRY(october,            10)

        MONTH_ENTRY(11,                 11)
        MONTH_ENTRY(nov,                11)
        MONTH_ENTRY(november,           11)

        MONTH_ENTRY(12,                 12)
        MONTH_ENTRY(dec,                12)
        MONTH_ENTRY(december,           12)

        // must be last!
        { NULL, 0 }
};


// 0-11 display
static const char * s_MonthsDisplay[] = {
        "jan",
        "feb",
        "mar",
        "apr",
        "may",
        "jun",
        "jul",
        "aug",
        "sep",
        "oct",
        "nov",
        "dec"
};


// 0-6 display
static const char * s_Weekdays[] = {
        "sun",
        "mon",
        "tue",
        "wed",
        "thu",
        "fri",
        "sat"
};



////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

static const char *
get_month_display
(
IN int month
)
throw()
{
        ASSERT(month >= 0, "invalid month index");
        ASSERT(month < 12, "invalid month index");

        return s_MonthsDisplay[month];
}



static double
my_trunc
(
IN double x
)
throw()
{
        ASSERT(x < 2.0e9, "x too big");
        ASSERT(x > -2.0e9, "x too small");

        double t;
        
        if (x >= 0.0) {
                long l = (long) x;
                double frac = x - l;
                t = x - frac;
        } else {
                t = -my_trunc(-x);
        }

        // DPRINTF("   trunc(%lf) = %lf", x, t);
        
        return t;
}


////////////////////////////////////////////////////////////////////////////////
//
//      Public API
//
////////////////////////////////////////////////////////////////////////////////


int
GetMonthFromString
(
IN const char * month
)
throw()
{
        ASSERT(month, "NULL month");

        for (const month_entry_t * p = s_Months; p->name; ++p) {
                if (!strcasecmp(p->name, month))
                        return p->month;
        }

        // not found!
        return 0;
}



void
getDisplayableDateFromNetTime
(
IN long time,
OUT std::string& display
)
{
        ASSERT(time > 0, "Bad time: %ld", time);

        char buffer[32];

#ifdef WIN32
        // TODO: get a threadsafe version?
        time_t ttTime;
        strncpy(buffer, ctime(&ttTime), 26);
#else   // WIN32
        ctime_r(&time, buffer);
#endif  // WIN32

        buffer[24] = 0;

        display = buffer;
}


const char *
getDateString
(
IN long timestamp
)
{
        time_t ttTime = timestamp;
        struct tm * t = localtime(&ttTime);
        ASSERT(t, "null");

        static const int s_bufSize = 32;
        static char s_buffer[s_bufSize];
        sprintf(s_buffer, "%02d-%s-%04d %02d:%02d:%02d",
            t->tm_mday, get_month_display(t->tm_mon), t->tm_year + 1900,
            t->tm_hour, t->tm_min, t->tm_sec);

        return s_buffer;
}



void
getDateStringFromNetTime
(
IN long time,
OUT std::string& display
)
{
        ASSERT(time > 0, "Bad time: %ld", time);

        display = getDateString(time);
}



static const char *
extractInteger
(
IN const char * s,
IN char separator,
OUT int& x,
IN int min,
IN int max,
IN int digits_required
)
throw()
{
        ASSERT(s, "null");
        // ASSERT(separator) -- can be zero
        ASSERT(max > min, "Bad range?");

        int digits_read = 0;
        x = 0;          // initialize
        while (*s && *s != separator) {
                int i = *s - '0';
                x = (10 * x) + i;
                ++digits_read;
                ++s;
        }
        if (*s)
                ++s;    // move past separator

        // DPRINTF("read x=%d", x);

        if (digits_read < digits_required)
                return NULL;
        if (x < min)
                return NULL;
        if (x > max)
                return NULL;

        return s;
}



static const char *
extractString
(
IN const char * s,
IN char separator,
IO char * buf,
IN int size
)
throw()
{
        ASSERT(s, "null");
        ASSERT(buf, "null");
        ASSERT(size > 0, "Bad buffer size: %d", size);

        int idx = 0;
        while (*s && *s != separator && idx < size - 1) {
                buf[idx] = *s;
                ++idx;
                ++s;
        }
        buf[idx] = 0;   // null-terminate
        if (*s)
                ++s;    // step past separator

        if (0 == idx)
                return 0;

        return s;
}



long
getNetTimeFromDateString
(
IN const char * s
)
throw()
{
        ASSERT(s, "null");

        struct tm t;

        // const char * date = s;       // save original pointer

        // extract fields
        s = extractInteger(s, '-', t.tm_mday, 1, 31, 1);
        if (!s)
                return -1;
        // DPRINTF("mday: %d", t.tm_mday);

        static const int s_bufSize = 4;
        char buffer[s_bufSize];
        s = extractString(s, '-', buffer, s_bufSize);
        if (!s)
                return -1;
        t.tm_mon = GetMonthFromString(buffer);
        if (t.tm_mon < 1)
                return -1;
        --t.tm_mon;
        //DPRINTF("mon: %d", t.tm_mon);

        s = extractInteger(s, ' ', t.tm_year, -10000, +10000, 4);
        if (!s)
                return -1;
        t.tm_year -= 1900;
        //DPRINTF("year: %d", t.tm_year);

        s = extractInteger(s, ':', t.tm_hour, 0, 23, 2);
        if (!s)
                return -1;
        //DPRINTF("hour: %d", t.tm_hour);

        s = extractInteger(s, ':', t.tm_min, 0, 59, 2);
        if (!s)
                return -1;
        //DPRINTF("min: %d", t.tm_min);

        s = extractInteger(s, 0, t.tm_sec, 0, 59, 2);
        if (!s)
                return -1;
        //DPRINTF("sec: %d", t.tm_sec);

/*
        DPRINTF("Extracted from '%s':", date);
        DPRINTF("  day/month/year %02d/%02d/%d", t.tm_mday, t.tm_mon + 1, t.tm_year + 1900);
        DPRINTF("  hh:mm:ss %02d:%02d:%02d", t.tm_hour, t.tm_min, t.tm_sec);
*/
        return mktime(&t);
}



int
getWeekdayFromNetTime
(
IN long time
)
throw()
{
        ASSERT(time > 0, "Bad net time");

        long day = time / (24 * 3600);  // divide seconds by seconds in a day

        // add 4 (Jan 1 1970 was a Thursday)
        return (day + 4) % 7;
}


const char *
GetWeekday
(
IN int weekday_index
)
throw()
{
        ASSERT(weekday_index >= 0, "Bad weekday index");
        ASSERT(weekday_index < 7, "Bad weekday index");

        return s_Weekdays[weekday_index];
}



const char *
GetMonth
(
IN int month_index
)
throw()
{
        return get_month_display(month_index);
}



/*
 * bucketing routines
 */

long
getDayBucket
(
IN long timestamp
)
throw()
{
        ASSERT(timestamp > 0, "bad timestamp: %ld", timestamp);

        // easy: just divide by seconds per day!
        return timestamp / s_secondsPerDay;
}


long
getWeekBucket
(
IN long timestamp
)
throw()
{
        ASSERT(timestamp > 0, "bad timestamp: %ld", timestamp);

        return (timestamp - s_firstSunday) / (s_secondsPerWeek);
}



long
getMonthBucket
(
IN long timestamp
)
throw()
{
        ASSERT(timestamp > 0, "bad timestamp: %ld", timestamp);

        time_t ttTime = timestamp;
        struct tm * tm = gmtime(&ttTime);
        return tm->tm_mon + (tm->tm_year * 12);
}



long
getYearBucket
(
IN long timestamp
)
throw()
{
        ASSERT(timestamp > 0, "bad timestamp: %ld", timestamp);

        time_t ttTime = timestamp;
        struct tm * tm = gmtime(&ttTime);
        return tm->tm_year;
}



std::string
getDayBucketName
(
IN long day_bucket
)
{
        return getDateString(day_bucket * s_secondsPerDay);
}



std::string
getWeekBucketName
(
IN long week_bucket
)
{
        return getDateString((week_bucket * s_secondsPerWeek) + s_firstSunday);
}


std::string
getMonthBucketName
(
IN long month_bucket
)
{
        std::ostringstream out;
        out << s_MonthsDisplay[month_bucket % 12] << " " << (1900 + (month_bucket / 12));
        return out.str();
}


std::string
getYearBucketName
(
IN long year_bucket
)
{
        std::ostringstream out;
        out << (1900 + year_bucket);
        return out.str();
}