---

time.Time.h

/*----------------------------------------------------------------------------
  SWORD 2000 - Software With Objects for Rapid Development
  Copyright (C) 2003 Eric NICOLAS
  ----------------------------------------------------------------------------
  SWORD is free software; you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  SWORD 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 Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with SWORD; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  --------------------------------------------------------------------------*/
#ifndef _SWORD_TIME_TIME_
#define _SWORD_TIME_TIME_

#include "sword/time.TimeSpan.h"
#include "sword/base.Comparable.h"
#include "sword/streams.IStream.h"
#include "sword/streams.OStream.h"

#ifdef POSIX
#  include <time.h>
#  include <sys/timeb.h>
#endif


namespace sword {


        class SWORDDECL Time : public Comparable<Time> {
                public:

                        inline Time() throw();

                        inline Time(int64 value) throw();

                        inline int64 serial() const throw();

                        inline void serial(int64 value) throw();

                        inline int integer1900() const throw();

                        inline Time& integer1900(int value) throw();

                        inline double double1900() const throw();

                        inline Time& double1900(double value) throw();

                        inline bool valid() const throw();

                        inline void invalidate() throw();

                        inline void resetHour() throw();


                        inline static Time now();


                        static Time nowUTC();


                        static TimeSpan timeZone();

                        friend inline TimeSpan operator-(const Time &lhs, const Time &rhs);

                        friend inline Time operator+(const Time &lhs, const TimeSpan &rhs);

                        friend inline Time operator+(const TimeSpan &lhs, const Time &rhs);

                        inline static int compare(const Time &lhs, const Time &rhs);

                        // Round series:
                        // new_value = ((old_value + 0.5 * unit) / unit) * unit

                        inline Time& roundDay() throw();

                        inline Time& roundHour() throw();

                        inline Time& roundMinute() throw();

                        inline Time& roundSecond() throw();

                        // Trunc series:
                        // new_value = (old_value / unit) * unit

                        inline Time& truncDay() throw();

                        inline Time& truncHour() throw();

                        inline Time& truncMinute() throw();

                        inline Time& truncSecond() throw();

                        friend inline IStream& operator>>(IStream& lhs, Time &rhs);

                        friend inline OStream &operator<<(OStream &lhs, const Time &rhs);

                        // time conversion <-> C Library

                        time_t toC() const;

                        void fromC(time_t value) throw();

#ifdef POSIX

                        void fromC(struct timeb &value) throw();

#endif // POSIX

                        // time conversion <-> Win32 FILETIME data type

#ifdef WIN32

                        FILETIME toFILETIME() const;

                        void fromFILETIME(const FILETIME &valueFILETIME);

#endif // WIN32

                        class RangeException : public Exception {};

                private:
                        int64 value_;
        };

} // namespace sword

#include "sword.private/time.Time.inl"

#endif // _SWORD_TIME_TIME_

---