source: XMLIO_V2/dev/dev_rv/src/XMLIO/date.hpp @ 116

#ifndef __XMLIO_DATE__
#define __XMLIO_DATE__

namespace XMLIOSERVER
{
   class AbstractCalendar;

   typedef long long int Time;

   typedef struct _duration
   {
      /// Méthodes associées à la structure Duration.
      friend std::ostream& operator<<(std::ostream& out, const struct _duration& d)
      {
         out << d.year  << "y. " << d.month  << "mo. "   <<  d.day   << "d. "
             << d.hour  << "h. " << d.minute << "min. " << d.second << "sec. ";
         return (out);
      }

      struct _duration& resolve(void)
      {
         // Simplification de l'écriture des minutes.
         second += modf(minute, &minute) * 60.;
         minute += int(second)/60; second = int(second)%60;
         // Simplification de l'écriture des heures.
         minute += modf(hour  , &hour  ) * 60.;
         hour   += int(minute)/60; minute = int(minute)%60;
         // Simplification de l'écriture des jours.
         hour   += modf(day   , &day   ) * 24.;
         day    += int(hour)  /24; hour   = int(hour)  %24;
         // > Aucune équivalence jour - mois fixée par avance. //
         // Simplification de l'écriture des années.
         month  += modf(year , &year   ) * 12.;
         year   += int(month) /12; month  = int(month) %12;
         return (*this);
      }

      /// Propriétés associées à la structure.
      double year, month, day, hour, minute, second;

   } Duration;

   /// Opérateurs associés à la structure Duration.
   Duration operator*(const Duration& ddr, const double& scal)
   {
      Duration dur(ddr);
      dur.year *= scal;  dur.month  *= scal; dur.day    *= scal;
      dur.hour *= scal;  dur.minute *= scal; dur.second *= scal;
      return (dur.resolve());
   }

   Duration operator*(const double& scal, const Duration& ddr)
   { return (ddr * scal); }

   Duration operator-(const Duration& ddr, const Duration& dr)
   {
      Duration dur(ddr);
      dur.year -= dr.year;  dur.month  -= dr.month ; dur.day    -= dr.day;
      dur.hour -= dr.hour;  dur.minute -= dr.minute; dur.second -= dr.second;
      return (dur.resolve());
   }

   Duration operator+(const Duration& ddr, const Duration& dr)
   {
      Duration dur(ddr);
      dur.year += dr.year;  dur.month  += dr.month ; dur.day    += dr.day;
      dur.hour += dr.hour;  dur.minute += dr.minute; dur.second += dr.second;
      return (dur.resolve());
   }

   // Les principales durées constantes : année, mois, jour, ...
   static const Duration Year   = {1.0, 0.0, 0.0, 0.0, 0.0, 0.0},
                         Month  = {0.0, 1.0, 0.0, 0.0, 0.0, 0.0},
                         Day    = {0.0, 0.0, 1.0, 0.0, 0.0, 0.0},
                         Hour   = {0.0, 0.0, 0.0, 1.0, 0.0, 0.0},
                         Minute = {0.0, 0.0, 0.0, 0.0, 1.0, 0.0},
                         Second = {0.0, 0.0, 0.0, 0.0, 0.0, 1.0};

   ///////////////////////////////////////////////////

   class Date
   {
      public :

         Date(const AbstractCalendar& cal, int yr = 0, int mth = 0, int d = 0, int hr = 0, int min = 0 , int sec = 0) : relCalendar(cal)
            , year(yr), month(mth), day(d), hour(hr), minute(min), second(sec)
         {/* Ne rien faire de plus */}

         Date(const Date& d) : relCalendar(d.relCalendar)
            , year(d.year), month(d.month), day(d.day), hour(d.hour), minute(d.minute), second(d.second)
         {/* Ne rien faire de plus */}

         operator Time(void); // Retourne le nombre de secondes écoulées depuis la date initiale définie dans le calendrier.

         friend std::ostream& operator<<(std::ostream& out, const Date& d)
         {
            out << d.month << "/"   << d.day    << "/"     << d.year   << " - "
                << d.hour  << "h. " << d.minute << "min. " << d.second << "sec. ";
            return (out);
         }

         friend std::istream& operator>>(std::istream& in, Date& d) // Non testée.
         {
            char c = '/'; // Le caractÚre c est utilisé pour "recueillir" le séparateur "/".
            in >> d.month >> c >> d.day >> c  >> d.year;
            in.seekg(3, std::ios_base::cur); // On passe la lecture de la chaîne " - "
            in >> d.hour;   in.seekg(3, std::ios_base::cur); // On passe la lecture de la chaîne "h. "
            in >> d.minute; in.seekg(5, std::ios_base::cur); // On passe la lecture de la chaîne "min. "
            in >> d.second; in.seekg(5, std::ios_base::cur); // On passe la lecture de la chaîne "sec. "
            return (in);
         }

         /// Divers accesseurs.
         int getYear  (void) const { return (year); }
         int getMonth (void) const { return (month); }
         int getDay   (void) const { return (day); }
         int getHour  (void) const { return (hour); }
         int getMinute(void) const { return (minute); }
         int getSecond(void) const { return (second); }

         void setMonth (int newmonth) { month = newmonth; }
         void setYear  (int newyear)  { year  = newyear; }

         const AbstractCalendar& getRelCalendar(void) const { return (relCalendar); }

         ~Date()
         {/* Ne rien faire de plus */}

      protected :

      private :

         const AbstractCalendar& relCalendar; // Calendrier lié à la Date.
         int year, month, day, hour, minute, second; // Année, mois, ...

   }; // class Date

   Duration operator-(const Date& dt0, const Date& dt1)
   {
      // TODO :: Vérifier que les deux dates (dt0 et dt1) ont une référence vers le même calendrier.
      Duration dur =
      { dt0.getYear() - dt1.getYear(), dt0.getMonth()  - dt1.getMonth() , dt0.getDay()    - dt1.getDay(),
        dt0.getHour() - dt1.getHour(), dt0.getMinute() - dt1.getMinute(), dt0.getSecond() - dt1.getSecond() };
      return (dur.resolve());
   }

   /// Les opérateurs de comparaison. (Non testés pour le moment)
   bool operator==(const Date& dt0, const Date& dt1)
   {
      // TODO :: Vérifier que les deux dates (dt0 et dt1) ont une référence vers le même calendrier.
      return ((dt0.getYear() == dt1.getYear()) && (dt0.getMonth()  == dt1.getMonth())  && (dt1.getDay()    == dt0.getDay()) &&
              (dt0.getHour() == dt1.getHour()) && (dt0.getMinute() == dt1.getMinute()) && (dt1.getSecond() == dt0.getSecond()));
   }

   bool operator<(const Date& dt0, const Date& dt1)
   {
      // TODO :: Vérifier que les deux dates (dt0 et dt1) ont une référence vers le même calendrier.
      if (dt0.getYear()   < dt1.getYear())   return true; if (dt0.getMonth()  < dt1.getMonth())  return true;
      if (dt0.getDay()    < dt1.getDay())    return true; if (dt0.getHour()   < dt1.getHour())   return true;
      if (dt0.getMinute() < dt1.getMinute()) return true; if (dt0.getSecond() < dt1.getSecond()) return true;
      return false;
   }

   bool operator!=(const Date& dt0, const Date& dt1) { return !(dt1 == dt0); }
   bool operator> (const Date& dt0, const Date& dt1) { return (dt1 < dt0); }
   bool operator>=(const Date& dt0, const Date& dt1) { return ((dt1 > dt0) || (dt1 == dt0)); }
   bool operator<=(const Date& dt0, const Date& dt1) { return ((dt1 < dt0) || (dt1 == dt0)); }

} // namespace XMLIOSERVER

#endif // __XMLIO_DATE__