Changeset 118


Ignore:
Timestamp:
07/20/10 10:09:45 (14 years ago)
Author:
hozdoba
Message:

Réorganisation du code gérant le calendrier.

Location:
XMLIO_V2/dev/dev_rv/src/XMLIO
Files:
3 added
4 edited

Legend:

Unmodified
Added
Removed

  • XMLIO_V2/dev/dev_rv/src/XMLIO/c_interface.cpp

    r117 r118  
    2828      Date ddd(*calendar, 2030, 11, 02, 10, 33, 40) ; 
    2929 
     30      Date d1 (*calendar, 2007, 11, 12, 00, 00, 00) ; 
     31      Date d2 (*calendar, 2008, 11, 12, 00, 00, 00) ; 
     32 
     33      string sttr("12/07/2005 - 10:11:30"); 
     34      Date d3 = Date::FromString(sttr, *calendar); 
     35 
    3036      // Les mois sont considérés comme des entiers mais stockés comme des flottants. 
    3137      Duration sc0 = Second * -65.3 + Minute * 117.5   + Hour * 65.9  + Day * 417.8 + Month * 16.0  - Year * 17.5; 
    … …  
    3844      std::cout << boolalpha << (calendar->getInitDate() != calendar->getCurrentDate()) << std::endl; 
    3945 
    40       std::cout << sc0 << std::endl; 
    41       std::cout << sc1 << std::endl; 
    42       std::cout << sc1 - sc0 << std::endl; 
     46      std::cout << (Time)d2 - (Time)(d1 + 365 * Day) << std::endl; 
     47      std::cout << sc0 << std::endl << sc1 << std::endl << sc1 - sc0 << std::endl; 
    4348      std::cout << ddd - dd << std::endl; 
    4449      std::cout << dd << std::endl; 
    … …  
    4752 
    4853      std::cout << (dd+sc2) << std::endl; 
     54      std::cout << (d3) << std::endl; 
    4955 
    5056      delete calendar; 

  • XMLIO_V2/dev/dev_rv/src/XMLIO/calendar.hpp

    r117 r118  
    22#define __XMLIO_CALENDAR__ 
    33 
    4 #include "date.hpp" 
    5  
    64namespace XMLIOSERVER 
    75{ 
    8  
    9    typedef enum _monthEnum 
    10    {  JAN = 1, FEB = 2, MAR = 3, APR = 4 , MAY = 5 , JUN = 6 , 
    11       JUL = 7, AUG = 8, SEP = 9, OCT = 10, NOV = 11, DEC = 12  } MonthEnum; 
    12  
    13    class AbstractCalendar : public AbstractObject 
    14    { 
    15       public : 
    16  
    17          virtual int getMonthLength(const Date& d) const 
    18          { // Retourne la durée du mois en jour. 
    19             static const int NoLeapMonthLength[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; 
    20             return (NoLeapMonthLength[d.getMonth()-1]); 
    21          } 
    22  
    23          virtual int getYearTotalLength(const Date& d) const { return (365 * 86400); } // Retourne la durée d'une année en seconde. 
    24  
    25          virtual int getYearLength(void)   const { return (12); } // Retourne la durée d'une année en mois. 
    26          virtual int getDayLength(void)    const { return (24); } // Retourne la durée d'un jour en heures. 
    27          virtual int getHourLength(void)   const { return (60); } // Retourne la durée d'une heure en minute. 
    28          virtual int getMinuteLength(void) const { return (60); } // Retourne la durée d'une minute en secondes. 
    29  
    30          virtual int getNbSecond(const Date& d) const 
    31          { // Retourne le nombre de secondes écoulées depuis le début de l'année. 
    32             Date _d0(d); int  nbday = 0; 
    33  
    34             for(_d0.setMonth(1); _d0.getMonth() < d.getMonth(); _d0.setMonth(_d0.getMonth()+1)) 
    35                nbday += getMonthLength(_d0); 
    36             //std::cout << "nombre de jours : " << nbday << std::endl; 
    37             return ((((nbday + d.getDay()) * getDayLength() + d.getHour()) 
    38                      * getHourLength() + d.getMinute()) * getMinuteLength() + d.getSecond()); 
    39          } 
    40  
    41          virtual string getMonthName(int _mi) const 
    42          { 
    43             static const string Monthname_str[] = 
    44                { "january", "february", "march"    , "april"  , "may"     , "june"    , 
    45                  "july"   , "august"  , "september", "october", "november", "december" }; 
    46             return(Monthname_str[_mi-1]); 
    47          } 
    48  
    49          virtual const string getMonthShortName(int _mi) const 
    50          { string value = getMonthName(_mi); value.resize(3); return (value); } 
    51  
    52          const Date& getInitDate(void) const { return(initDate); } 
    53          Date& getCurrentDate(void) { return(currentDate); } 
    54  
    55          virtual ~AbstractCalendar() 
    56          {/* Ne rien faire de plus */} 
    57  
    58       protected : 
    59  
    60          AbstractCalendar() : AbstractObject(), initDate(*this), currentDate(initDate) 
    61          {/* Ne rien faire de plus */} 
    62          AbstractCalendar(const string& _id) : AbstractObject(_id), initDate(*this), currentDate(initDate) 
    63          {/* Ne rien faire de plus */} 
    64  
    65       private : 
    66  
    67          const Date initDate; 
    68          Date currentDate; 
    69  
    70    }; // class AbstractCalendar 
    71  
    726   class JulianCalendar : public AbstractCalendar 
    737   { 
    … …  
    14175         { if (d.getMonth() == 2) return (29); return AbstractCalendar::getMonthLength(d); } 
    14276 
    143          virtual int getYearTotalLength(const Date& d) const { return (366 * 86400); } // Retourne la durée d'une année en seconde. 
     77         virtual int getYearTotalLength(const Date& d) const { return (366 * 86400); } 
    14478 
    14579         virtual ~AllLeapCalendar() 
    … …  
    15488         {/* Ne rien faire de plus */} 
    15589 
    156          virtual int getYearTotalLength(const Date& d) const { return (360 * 86400); } // Retourne la durée d'une année en seconde. 
     90         virtual int getYearTotalLength(const Date& d) const { return (360 * 86400); } 
    15791         virtual int getMonthLength(const Date& d) const { return (30); } 
    15892 
    … …  
    16296   }; // class D360Calendar 
    16397 
    164  
    165    //////////////////////////////////////// 
    166  
    167    Duration& Duration::resolve(const AbstractCalendar& c) 
    168    { 
    169       // Simplification de l'écriture des minutes. 
    170       second += modf(minute, &minute) * (float)c.getMinuteLength(); 
    171       minute += int(second)/c.getMinuteLength(); second = int(second)%c.getMinuteLength(); 
    172  
    173       // Simplification de l'écriture des heures. 
    174       minute += modf(hour , &hour) * (float)c.getHourLength(); 
    175       hour   += int(minute)/c.getHourLength(); minute = int(minute)%c.getHourLength(); 
    176  
    177       // Simplification de l'écriture des jours. 
    178       hour   += modf(day, &day) * (float)c.getDayLength(); 
    179       day    += int(hour)  /c.getDayLength(); hour   = int(hour)%c.getDayLength(); 
    180  
    181       // > Aucune équivalence jour - mois fixée par avance. // 
    182  
    183       // Simplification de l'écriture des années. 
    184       month  += modf(year, &year) * (float)c.getYearLength(); 
    185       year   += int(month) /c.getYearLength(); month  = int(month)%c.getYearLength(); 
    186       return (*this); 
    187    } 
    188  
    189    Date::operator Time(void) // Non vérifiée, pas optimisée ... 
    190    { 
    191       // Todo : Tester si la date courante est supérieure à la date initiale. 
    192       Time retvalue = - relCalendar.getNbSecond(relCalendar.getInitDate()) 
    193                       + relCalendar.getNbSecond(*this); 
    194  
    195       if ((relCalendar.getId().compare("D360")    == 0) || 
    196           (relCalendar.getId().compare("AllLeap") == 0) || 
    197           (relCalendar.getId().compare("NoLeap")  == 0)) 
    198       return (retvalue + (getYear() - relCalendar.getInitDate().getYear()) * relCalendar.getYearTotalLength(*this)); 
    199  
    200       for(Date _d(relCalendar.getInitDate()); _d.getYear() < getYear(); _d.setYear(_d.getYear()+1)) 
    201          retvalue += relCalendar.getYearTotalLength(_d); 
    202       return (retvalue); 
    203    } 
    204  
    205    Date operator+(const Date& dt, const Duration& dr) // Non testée. 
    206    { 
    207       Duration drr (dr); 
    208       int year = 0, month = 0, day = 0, hour = 0, minute = 0, second = 0; 
    209       const AbstractCalendar& c = dt.getRelCalendar(); 
    210  
    211       drr.resolve(dt.getRelCalendar()); 
    212  
    213       // Ajustement des minutes par rapport aux secondes. 
    214       second += dt.getSecond() + drr.second; 
    215       if (second <  0) { minute --; second += c.getMinuteLength(); } 
    216       if (second >= c.getMinuteLength()) { minute ++; second -= c.getMinuteLength(); } 
    217  
    218       // Ajustement des heures en fonction des minutes. 
    219       minute += dt.getMinute() + drr.minute; 
    220       if (minute < 0) { hour --; minute += c.getHourLength(); } 
    221       if (minute >= c.getHourLength()) { hour ++; minute -= c.getHourLength(); } 
    222  
    223       // Ajustement des jours en fonction des heures. 
    224       hour += dt.getHour() + drr.hour; 
    225       if (hour <  0) { drr.day --; hour += c.getDayLength(); } 
    226       if (hour >= c.getDayLength()) { drr.day ++; hour -= c.getDayLength(); } 
    227  
    228       // Ajustement des mois en fonction des jours. 
    229       int signVal = drr.day/fabs(drr.day); 
    230       Date dtt(dt); dtt.addMonth (signVal); 
    231  
    232       for(; c.getMonthLength(dtt) < fabs(drr.day); dtt.addMonth (signVal)) 
    233       { drr.day -= signVal * c.getMonthLength(dtt); drr.month += signVal; } 
    234  
    235       day += dt.getDay() + drr.day; 
    236       if (day <  0) { drr.month --; day += c.getMonthLength(dtt); } 
    237       if (day >= c.getMonthLength(dtt)) { drr.month ++; day -= c.getMonthLength(dtt); } // << ProblÚme ici 
    238       if (day == 0) day = c.getMonthLength(dtt); 
    239  
    240       drr.resolve(dt.getRelCalendar()); 
    241  
    242       // Ajustement des années en fonction des mois. 
    243       month += dt.getMonth() + drr.month; 
    244       if (month <  0) { year --; month += c.getYearLength(); } 
    245       if (month >= c.getYearLength()) { year ++; month -= c.getYearLength(); } 
    246       if (month == 0) month = c.getYearLength(); 
    247  
    248       year += dt.getYear() + drr.year; 
    249  
    250       return (Date(dt.getRelCalendar(), year, month, day, hour, minute, second)); 
    251    } 
    252  
    253    Date operator-(const Date& dt, const Duration& dr) { return (dt + (-dr)); } 
    254  
    255  
    25698} // namespace XMLIOSERVER 
    25799 

  • XMLIO_V2/dev/dev_rv/src/XMLIO/date.hpp

    r117 r118  
    44namespace XMLIOSERVER 
    55{ 
    6    class AbstractCalendar; 
    7  
    8    typedef long long int Time; 
    9  
    10    typedef struct _duration 
    11    { 
    12       /// Méthodes associées à la structure Duration. 
    13       friend std::ostream& operator<<(std::ostream& out, const struct _duration& d) 
    14       { 
    15          out << d.year  << "y. " << d.month  << "mo. "   <<  d.day   << "d. " 
    16              << d.hour  << "h. " << d.minute << "min. " << d.second << "sec. "; 
    17          return (out); 
    18       } 
    19  
    20       struct _duration& resolve(const AbstractCalendar&); 
    21  
    22       /// Propriétés associées à la structure. 
    23       double year, month, day, hour, minute, second; 
    24  
    25    } Duration; 
    26  
    27    /// Opérateurs associés à la structure Duration. 
    28    Duration operator*(const Duration& ddr, const double& scal) 
    29    { 
    30       Duration dur(ddr); 
    31       dur.year *= scal;  dur.month  *= scal; dur.day    *= scal; 
    32       dur.hour *= scal;  dur.minute *= scal; dur.second *= scal; 
    33       return (dur); 
    34    } 
    35  
    36    Duration operator*(const double& scal, const Duration& ddr) 
    37    { return (ddr * scal); } 
    38  
    39    Duration operator-(const Duration& ddr, const Duration& dr) 
    40    { 
    41       Duration dur(ddr); 
    42       dur.year -= dr.year;  dur.month  -= dr.month ; dur.day    -= dr.day; 
    43       dur.hour -= dr.hour;  dur.minute -= dr.minute; dur.second -= dr.second; 
    44       return (dur); 
    45    } 
    46  
    47    Duration operator-(const Duration& ddr) 
    48    { 
    49       Duration dur(ddr); 
    50       dur.year = -dur.year;  dur.month  = -dur.month ; dur.day    = -dur.day; 
    51       dur.hour = -dur.hour;  dur.minute = -dur.minute; dur.second = -dur.second; 
    52       return (dur); 
    53    } 
    54  
    55    Duration operator+(const Duration& ddr, const Duration& dr) 
    56    { 
    57       Duration dur(ddr); 
    58       dur.year += dr.year;  dur.month  += dr.month ; dur.day    += dr.day; 
    59       dur.hour += dr.hour;  dur.minute += dr.minute; dur.second += dr.second; 
    60       return (dur); 
    61    } 
    62  
    63    // Les principales durées constantes : année, mois, jour, ... 
    64    static const Duration Year   = {1.0, 0.0, 0.0, 0.0, 0.0, 0.0}, 
    65                          Month  = {0.0, 1.0, 0.0, 0.0, 0.0, 0.0}, 
    66                          Day    = {0.0, 0.0, 1.0, 0.0, 0.0, 0.0}, 
    67                          Hour   = {0.0, 0.0, 0.0, 1.0, 0.0, 0.0}, 
    68                          Minute = {0.0, 0.0, 0.0, 0.0, 1.0, 0.0}, 
    69                          Second = {0.0, 0.0, 0.0, 0.0, 0.0, 1.0}; 
    70  
    71    /////////////////////////////////////////////////// 
    72  
    736   class Date 
    747   { 
    … …  
    8720         friend std::ostream& operator<<(std::ostream& out, const Date& d) 
    8821         { 
    89             out << d.month << "/"   << d.day    << "/"     << d.year   << " - " 
    90                 << d.hour  << "h. " << d.minute << "min. " << d.second << "sec. "; 
     22            out << d.day  << "/" << d.month  << "/" << d.year   << "-" 
     23                << d.hour << ":" << d.minute << ":" << d.second; 
    9124            return (out); 
    9225         } 
    … …  
    9427         friend std::istream& operator>>(std::istream& in, Date& d) // Non testée. 
    9528         { 
    96             char c = '/'; // Le caractÚre c est utilisé pour "recueillir" le séparateur "/". 
    97             in >> d.month >> c >> d.day >> c  >> d.year; 
    98             in.seekg(3, std::ios_base::cur); // On passe la lecture de la chaîne " - " 
    99             in >> d.hour;   in.seekg(3, std::ios_base::cur); // On passe la lecture de la chaîne "h. " 
    100             in >> d.minute; in.seekg(5, std::ios_base::cur); // On passe la lecture de la chaîne "min. " 
    101             in >> d.second; in.seekg(5, std::ios_base::cur); // On passe la lecture de la chaîne "sec. " 
     29            char c = '/'; // Le caractÚre c est utilisé pour "recueillir" les séparateurs "/" et ":". 
     30            in >> d.day  >> c >> d.month  >> c >> d.year   >> c; 
     31            in >> d.hour >> c >> d.minute >> c >> d.second; 
    10232            return (in); 
    10333         } 
     34 
     35         static Date FromString(const string& str, const AbstractCalendar& cal); 
    10436 
    10537         /// Divers accesseurs. 
    … …  
    13365   }; // class Date 
    13466 
    135    Duration operator-(const Date& dt0, const Date& dt1) 
    136    { 
    137       // TODO :: Vérifier que les deux dates (dt0 et dt1) ont une référence vers le même calendrier. 
    138       Duration dur = 
    139       { dt0.getYear() - dt1.getYear(), dt0.getMonth()  - dt1.getMonth() , dt0.getDay()    - dt1.getDay(), 
    140         dt0.getHour() - dt1.getHour(), dt0.getMinute() - dt1.getMinute(), dt0.getSecond() - dt1.getSecond() }; 
    141       return (dur.resolve(dt0.getRelCalendar())); 
    142    } 
    143  
    144    /// Les opérateurs de comparaison. (Non testés pour le moment) 
    145    bool operator==(const Date& dt0, const Date& dt1) 
    146    { 
    147       // TODO :: Vérifier que les deux dates (dt0 et dt1) ont une référence vers le même calendrier. 
    148       return ((dt0.getYear() == dt1.getYear()) && (dt0.getMonth()  == dt1.getMonth())  && (dt1.getDay()    == dt0.getDay()) && 
    149               (dt0.getHour() == dt1.getHour()) && (dt0.getMinute() == dt1.getMinute()) && (dt1.getSecond() == dt0.getSecond())); 
    150    } 
    151  
    152    bool operator<(const Date& dt0, const Date& dt1) 
    153    { 
    154       // TODO :: Vérifier que les deux dates (dt0 et dt1) ont une référence vers le même calendrier. 
    155       if (dt0.getYear()   < dt1.getYear())   return true; if (dt0.getMonth()  < dt1.getMonth())  return true; 
    156       if (dt0.getDay()    < dt1.getDay())    return true; if (dt0.getHour()   < dt1.getHour())   return true; 
    157       if (dt0.getMinute() < dt1.getMinute()) return true; if (dt0.getSecond() < dt1.getSecond()) return true; 
    158       return false; 
    159    } 
    160  
    161    bool operator!=(const Date& dt0, const Date& dt1) { return !(dt1 == dt0); } 
    162    bool operator> (const Date& dt0, const Date& dt1) { return (dt1 < dt0); } 
    163    bool operator>=(const Date& dt0, const Date& dt1) { return ((dt1 > dt0) || (dt1 == dt0)); } 
    164    bool operator<=(const Date& dt0, const Date& dt1) { return ((dt1 < dt0) || (dt1 == dt0)); } 
    165  
    16667} // namespace XMLIOSERVER 
    16768 

  • XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio.hpp

    r115 r118  
    2727#include "abstract_object.hpp" 
    2828 
     29// Gestion du calendrier 
     30#include "duration.hpp" 
     31#include "date.hpp" 
     32#include "abstract_calendar.hpp" 
    2933#include "calendar.hpp" 
     34#include "calendar_utils.hpp" 
    3035 
    3136#include "xml_node.hpp" 
Note: See TracChangeset for help on using the changeset viewer.