DateTime.hpp

Go to the documentation of this file.

/*******************************************************************************
* Copyright (C) 2005, Vintela, Inc. All rights reserved.
* Copyright (C) 2006, Novell, Inc. 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 
*       Vintela, Inc., 
*       nor Novell, Inc., 
*       nor the names of its contributors or employees may be used to 
*       endorse or promote products derived from this software without 
*       specific prior written permission.
* 
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER OR CONTRIBUTORS 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.
*******************************************************************************/
 
 
#ifndef BLOCXX_DATETIME_HPP_INCLUDE_GUARD_
#define BLOCXX_DATETIME_HPP_INCLUDE_GUARD_
#include "blocxx/BLOCXX_config.h"
#include "blocxx/Exception.hpp"
#include "blocxx/Types.hpp"
#include "blocxx/CommonFwd.hpp"
 
extern "C"
{
#include <time.h>
}
 
namespace BLOCXX_NAMESPACE
{
 
BLOCXX_DECLARE_APIEXCEPTION(DateTime, BLOCXX_COMMON_API)
 
 
class BLOCXX_COMMON_API DateTime
{
public:
   enum ETimeOffset
   {
      E_LOCAL_TIME,
      E_UTC_TIME
   };
 
   DateTime();
   explicit DateTime(const String& str);
   explicit DateTime(time_t t, UInt32 microseconds=0);
   DateTime(
         int year, 
         int month, 
         int day, 
         int hour=0, 
         int minute=0,
         int second=0, 
         UInt32 microsecond=0, 
         ETimeOffset timeOffset = E_LOCAL_TIME);
   ~DateTime();
   int getHour(ETimeOffset timeOffset = E_LOCAL_TIME) const;
   int getMinute(ETimeOffset timeOffset = E_LOCAL_TIME) const;
   int getSecond(ETimeOffset timeOffset = E_LOCAL_TIME) const;
   UInt32 getMicrosecond() const;
   int getDay(ETimeOffset timeOffset = E_LOCAL_TIME) const;
   int getDow(ETimeOffset timeOffset = E_LOCAL_TIME) const;
   int getMonth(ETimeOffset timeOffset = E_LOCAL_TIME) const;
   int getYear(ETimeOffset timeOffset = E_LOCAL_TIME) const;
   time_t get() const;
   void setHour(int hour, ETimeOffset timeOffset = E_LOCAL_TIME);
   void setMinute(int minute, ETimeOffset timeOffset = E_LOCAL_TIME);
   void setSecond(int second, ETimeOffset timeOffset = E_LOCAL_TIME);
   void setMicrosecond(UInt32 microsecond);
   void setTime(
         int hour, 
         int minute, 
         int second, 
         ETimeOffset timeOffset = E_LOCAL_TIME);
   void setDay(int day, ETimeOffset timeOffset = E_LOCAL_TIME);
   void setMonth(int month, ETimeOffset timeOffset = E_LOCAL_TIME);
   void setYear(int year, ETimeOffset timeOffset = E_LOCAL_TIME);
   void set(time_t t, UInt32 microseconds=0);
   void set(
         int year, 
         int month, 
         int day, 
         int hour, 
         int minute, 
         int second, 
         UInt32 microseconds, 
         ETimeOffset timeOffset = E_LOCAL_TIME);
   void setToCurrent();
   void addDays(int days);
   void addWeeks(int weeks)
   {
      addDays(weeks * 7);
   }
   void addMonths(int months);
   void addYears(int years);
   void addSeconds(long seconds)
   {
      m_time += seconds;
   }
   void addMinutes(long minutes)
   {
      m_time += minutes * 60;
   }
   void addMicroseconds(long microseconds)
   {
      m_microseconds += microseconds;
      m_time += m_microseconds / 1000000;
      m_microseconds %= 1000000;
   }
   void addMilliseconds(long milliseconds)
   {
      this->addMicroseconds(milliseconds * 1000);
   }
   void addHours(long hours) {  m_time += hours * 60 * 60; }
   bool operator< ( const DateTime& tm ) const
   {
      if (m_time == tm.m_time)
      {
         return m_microseconds < tm.m_microseconds;
      }
      return m_time < tm.m_time;
   }
   bool operator> ( const DateTime& tm ) const
   {
      return tm < *this;
   }
   bool operator== ( const DateTime& tm ) const
   {
      return m_time == tm.m_time && m_microseconds == tm.m_microseconds;
   }
   bool operator!= ( const DateTime& tm ) const
   {
      return !(*this == tm);
   }
   bool operator<= ( const DateTime& tm ) const
   {
      return !(tm < *this);
   }
   bool operator>= ( const DateTime& tm ) const
   {
      return !(*this < tm);
   }
   DateTime& operator+= (long seconds)
   {
      addSeconds(seconds);
      return *this;
   }
   DateTime& operator-= (long seconds)
   {
      addSeconds(-seconds);
      return *this;
   }
 
   String toString(ETimeOffset timeOffset = E_LOCAL_TIME) const;
 
   String toString(
      char const * format, ETimeOffset timeOffset = E_LOCAL_TIME) const;
 
   static char const DEFAULT_FORMAT[];
 
   String toStringGMT() const BLOCXX_DEPRECATED; // in 3.0.0
 
#if 0
   static Int16 getGMTOffset();
   // Removed due to the above problems.  Use toLocal() or
   // getGMTOffsetMinutesNow() instead.
#endif
 
   static Int16 getGMTOffsetMinutesNow()
   {
      time_t t = time(0);
      struct tm tt;
      return DateTime::localTimeAndOffset(t, tt);
   }
 
   Int16 toLocal(struct tm & tt) const
   {
      return  DateTime::localTimeAndOffset(m_time, tt);
   }
 
   static DateTime getCurrent();
 
private:
   time_t   m_time;
   UInt32   m_microseconds;
   tm getTm(ETimeOffset timeOffset) const;
   void setTime(tm& tmarg, ETimeOffset timeOffset);
   static Int16 localTimeAndOffset(time_t t, struct tm & tt);
};
 
BLOCXX_COMMON_API DateTime operator-(DateTime const & x, DateTime const & y);
 
} // end namespace BLOCXX_NAMESPACE
 
#endif