ptime.h

Go to the documentation of this file.

/*
 * ptime.h
 *
 * Time and date class.
 *
 * Portable Windows Library
 *
 * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Portable Windows Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
 * All Rights Reserved.
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 19008 $
 * $Author: rjongbloed $
 * $Date: 2007-11-29 09:17:41 +0000 (Thu, 29 Nov 2007) $
 */

#ifndef _PTIME
#define _PTIME

#ifdef P_USE_PRAGMA
#pragma interface
#endif


#include <time.h>


// System time and date class

class PTimeInterval;


class PTime : public PObject
{
  PCLASSINFO(PTime, PObject);

  public:
    enum {
      UTC   = 0,
      GMT   = UTC,
      Local = 9999
    };

    PTime();

    PTime(
      time_t tsecs,          
      long usecs = 0
    ) { theTime = tsecs; microseconds = usecs; }

    PTime(
      const PString & str   
    );

    PTime(
      int second,           
      int minute,           
      int hour,             
      int day,              
      int month,            
      int year,             
      int tz = Local        
    );

    PObject * Clone() const;

    virtual Comparison Compare(
      const PObject & obj   
    ) const;

    virtual void PrintOn(
      ostream & strm    
    ) const;

    virtual void ReadFrom(
      istream & strm    
    );

    PBoolean IsValid() const;

    PInt64 GetTimestamp() const;

    time_t GetTimeInSeconds() const;

    long GetMicrosecond() const;

    int GetSecond() const;

    int GetMinute() const;

    int GetHour() const;

    int GetDay() const;

    enum Months {
      January = 1,
      February,
      March,
      April,
      May,
      June,
      July,
      August,
      September,
      October,
      November,
      December
    };

    Months GetMonth() const;

    int GetYear() const;

    enum Weekdays {
      Sunday,
      Monday,
      Tuesday,
      Wednesday,
      Thursday,
      Friday,
      Saturday
    };

    Weekdays GetDayOfWeek() const;

    int GetDayOfYear() const;

    PBoolean IsPast() const;

    PBoolean IsFuture() const;

    static PBoolean IsDaylightSavings();

    enum TimeZoneType {
      StandardTime,
      DaylightSavings
    };

    static int GetTimeZone();
    static int GetTimeZone(
       TimeZoneType type  
    );

    static PString GetTimeZoneString(
       TimeZoneType type = StandardTime 
    );

    PTime operator+(
      const PTimeInterval & time   
    ) const;

    PTime & operator+=(
      const PTimeInterval & time   
    );

    PTimeInterval operator-(
      const PTime & time   
    ) const;

    PTime operator-(
      const PTimeInterval & time   
    ) const;

    PTime & operator-=(
      const PTimeInterval & time   
    );


    enum TimeFormat {
      RFC1123,
      ShortISO8601,
      LongISO8601,
      LongDateTime,
      LongDate,
      LongTime,
      MediumDateTime,
      MediumDate,
      ShortDateTime,
      ShortDate,
      ShortTime,
      NumTimeStrings
    };

    PString AsString(
      TimeFormat formatCode = RFC1123,  
      int zone = Local                  
    ) const;

    PString AsString(
      const PString & formatStr, 
      int zone = Local           
    ) const;
    /* Convert the time to a string using the format code or string as a
       formatting template. The special characters in the formatting string
       are:
\begin{description}
       \item[h]         hour without leading zero
       \item[hh]        hour with leading zero
       \item[m]         minute without leading zero
       \item[mm]        minute with leading zero
       \item[s]         second without leading zero
       \item[ss]        second with leading zero
       \item[u]         tenths of second
       \item[uu]        hundedths of second with leading zero
       \item[uuu]       millisecond with leading zeros
       \item[uuuu]      microsecond with leading zeros
       \item[a]         the am/pm string
       \item[w/ww/www]  abbreviated day of week name
       \item[wwww]      full day of week name
       \item[d]         day of month without leading zero
       \item[dd]        day of month with leading zero
       \item[M]         month of year without leading zero
       \item[MM]        month of year with leading zero
       \item[MMM]       month of year as abbreviated text
       \item[MMMM]      month of year as full text
       \item[y/yy]      year without century
       \item[yyy/yyyy]  year with century
       \item[z]         the time zone description
\end{description}

       All other characters are copied to the output string unchanged.
       
       Note if there is an 'a' character in the string, the hour will be in 12
       hour format, otherwise in 24 hour format.
     */
    PString AsString(
      const char * formatPtr,    
      int zone = Local           
    ) const;

    static PString GetTimeSeparator();

    static PBoolean GetTimeAMPM();

    static PString GetTimeAM();

    static PString GetTimePM();

    enum NameType {
      FullName,
      Abbreviated
    };

    static PString GetDayName(
      Weekdays dayOfWeek,       
      NameType type = FullName  
    );

    static PString GetDateSeparator();

    static PString GetMonthName(
      Months month,             
      NameType type = FullName  
    );

    enum DateOrder {
      MonthDayYear,   
      DayMonthYear,   
      YearMonthDay    
    };

    static DateOrder GetDateOrder();

    static struct tm * os_localtime(const time_t * clock, struct tm * t);
    static struct tm * os_gmtime(const time_t * clock, struct tm * t);
    /*
      Threadsafe version of localtime library call.
      We could make these calls non-static if we could put the struct tm inside the
      instance. But these calls are usually made with const objects so that's not possible,
      and we would require per-thread storage otherwise. Sigh...
    */

  protected:
    // Member variables
    time_t theTime;
    long   microseconds;


// Include platform dependent part of class
#ifdef _WIN32
#include "msos/ptlib/ptime.h"
#else
#include "unix/ptlib/ptime.h"
#endif
};

#endif

// End Of File ///////////////////////////////////////////////////////////////

---