コード例 #1
0
ファイル: timeClass.cpp プロジェクト: 03050903/Torque3D
/**----------------------------------------------------------------------------
* PRIVATE Determine the number of days in any given month/year
*
* @param month Month to be tested
* @param year Year to be tested
* @return Number of days in month/year
*/
S32 Time::_daysInMonth(S32 month, S32 year) const
{
   if (_isLeapYear(year))
      return _DaysInMonthLeap[month];
   else
      return _DaysInMonth[month];
}
コード例 #2
0
ファイル: fxjs_v8.cpp プロジェクト: mcanthony/libpdf
double _TimeFromYearMonth(int y, int m)
{
	static int daysMonth[12] ={ 0,31,59,90,120,151,181,212,243,273,304,334};
	static int leapDaysMonth[12] = { 0,31,60,91,121,152,182,213,244,274,305,335};
	int* pMonth = daysMonth;
	if(_isLeapYear(y))
		pMonth = leapDaysMonth;
	return _TimeFromYear(y) + ((double)pMonth[m])*86400000;
}
コード例 #3
0
ファイル: timeClass.cpp プロジェクト: 03050903/Torque3D
bool Time::set(S32 year, S32 month, S32 day, S32 hour, S32 minute, S32 second, S32 microsecond)
{
   second += microsecond / 100000;
   microsecond %= 100000;
   minute += second / 60;
   second %= 60;
   hour += minute / 60;
   minute %= 60;
   S32 carryDays = hour / 24;
   hour %= 24;

   bool leapYear = _isLeapYear(year);

   year -= 1;     // all the next operations need (year-1) so do it ahead of time
   S32 gregorian = 365 * year             // number of days since the epoch
                   + (year/4)             // add Julian leap year days
                   - (year/100)           // subtract century leap years
                   + (year/400)           // add gregorian 400 year leap adjustment
                   + ((367*month-362)/12) // days in prior months
                   + day                  // add days
                   + carryDays;           // add days from time overflow/underflow

   // make days in this year adjustment if leap year
   if (leapYear)
   {
      if (month > 2)
         gregorian -= 1;
   }
   else
   {
      if (month > 2)
         gregorian -= 2;
   }

   _time  = S64(gregorian) * OneDay;
   _time += S64((hour * OneHour) +
                (minute * OneMinute) +
                (second * OneSecond) +
                microsecond);

   return true;
}
コード例 #4
0
ファイル: fxjs_v8.cpp プロジェクト: mcanthony/libpdf
int _DateFromTime(double t)
{
	int day = _DayWithinYear(t);
	int year = _YearFromTime(t);
	bool leap = _isLeapYear(year);
	int month = _MonthFromTime(t);
	switch (month)
	{
	case 0:	 
		return day+1;
	case 1:	 
		return day-30;
	case 2:	 
		return day-58-leap;
	case 3:	 
		return day-89-leap;
	case 4:	 
		return day-119-leap;
	case 5:	 
		return day-150-leap;
	case 6:	 
		return day-180-leap;
	case 7:	 
		return day-211-leap;
	case 8:	 
		return day-242-leap;
	case 9:	 
		return day-272-leap;
	case 10: 
		return day-303-leap;
	case 11: 
		return day-333-leap;
	default:
		return 0;
	}
}
コード例 #5
0
ファイル: fxjs_v8.cpp プロジェクト: mcanthony/libpdf
int _MonthFromTime(double t)
{
	int day = _DayWithinYear(t);
	int year = _YearFromTime(t);
	if(0<=day && day <31)
		return 0;
	if(31<=day && day< 59+_isLeapYear(year))
		return 1;
	if((59+_isLeapYear(year))<=day && day<(90+_isLeapYear(year)))
		return 2;
	if((90+_isLeapYear(year))<=day && day<(120+_isLeapYear(year)))
		return 3;
	if((120+_isLeapYear(year))<=day && day<(151+_isLeapYear(year)))
		return 4;
	if((151+_isLeapYear(year))<=day && day<(181+_isLeapYear(year)))
		return 5;
	if((181+_isLeapYear(year))<=day && day<(212+_isLeapYear(year)))
		return 6;
	if((212+_isLeapYear(year))<=day && day<(243+_isLeapYear(year)))
		return 7;
	if((243+_isLeapYear(year))<=day && day<(273+_isLeapYear(year)))
		return 8;
	if((273+_isLeapYear(year))<=day && day<(304+_isLeapYear(year)))
		return 9;
	if((304+_isLeapYear(year))<=day && day<(334+_isLeapYear(year)))
		return 10;
	if((334+_isLeapYear(year))<=day && day<(365+_isLeapYear(year)))
		return 11;

	return -1;
}
コード例 #6
0
ファイル: timeClass.cpp プロジェクト: 03050903/Torque3D
//-----------------------------------------------------------------------------
void Time::get(S32 *pyear, S32 *pmonth, S32 *pday, S32 *phour, S32 *pminute, S32 *psecond, S32 *pmicrosecond) const
{
   // extract date if requested
   if (pyear || pmonth || pday)
   {
      S32 gregorian = (S32)(_time / OneDay);

      S32 prior = gregorian - 1;           // prior days
      S32 years400 = prior / 146097L;      // number of 400 year cycles
      S32 days400 = prior % 146097L;       // days NOT in years400
      S32 years100 = days400 / 36524L;     // number 100 year cycles not checked
      S32 days100 =  days400 % 36524L;     // days NOT already included
      S32 years4 = days100 / 1461L;        // number 4 year cycles not checked
      S32 days4 = days100 % 1461L;         // days NOT already included
      S32 year1 = days4 / 365L;            // number years not already checked
      S32 day1  = days4 % 365L;            // days NOT already included
      S32 day;
      S32 year = (400 * years400) + (100 * years100) + (4 * years4) + year1;

      // December 31 of leap year
      if (years100 == 4 || year1 == 4)
      {
          day = 366;
      }
      else
      {
          year += 1;
          day = day1 + 1;
      }

      const S32 *dayNumber = _isLeapYear(year) ? _DayNumberLeap : _DayNumber;

      // find month and day in month given computed year and day number,
      S32 month = 1;
      while(day >= dayNumber[month])
         month++;

      day -= dayNumber[month-1];

      if(pyear)
         *pyear  = year;
      if(pmonth)
         *pmonth = month;
      if(pday)
         *pday   = day;
   }

   // extract time
   if (phour)
      *phour = (S32)((_time % OneDay) / OneHour);

   S32 time = (S32)(_time % OneHour);

   if (pminute)
      *pminute = time / (S32)OneMinute;
   time %= OneMinute;

   if (psecond)
      *psecond = time / (S32)OneSecond;
   if (pmicrosecond)
      *pmicrosecond = time % OneSecond;
}
コード例 #7
0
ファイル: TimeFunctions.cpp プロジェクト: bsletten/monarch
/**
 * Breaks the passed time_t struct (seconds since the epoch) into a broken-down
 * time representation in Coordinated Universal Time (UTC) (GMT time). The
 * passed tm struct will be populated.
 *
 * This function is re-entrant and therefore thread-safe.
 *
 * @param timep the time_t (seconds since the epoch) to break-down.
 * @param result the tm to populate with the broken-down date.
 *
 * @return a pointer to the result.
 */
struct tm* gmtime_r(const time_t* timep, struct tm* result)
{
   // the number of seconds per day
   time_t secsPerDay = 86400;

   // the number of seconds today
   time_t secs = *timep % secsPerDay;

   // the number of whole minutes today
   time_t mins = secs / 60;

   // set the number of seconds after the current minute
   result->tm_sec = secs % 60;

   // set the number of minutes after the current hour
   result->tm_min = mins % 60;

   // set the number of hours past midnight
   result->tm_hour = mins / 60;

   // determine the year and the day in the year:

   // start with the number of whole days since the epoch
   time_t day = *timep / secsPerDay;
   time_t daysPerYear = 365;

   // determine the week day (Jan 1 1970 was a Thursday, so add 4)
   result->tm_wday = (day + 4) % 7;

   int* year = &result->tm_year;
   for(*year = 1970; ; ++(*year))
   {
      // check for leap year
      daysPerYear = _isLeapYear(*year) ? 366 : 365;
      if(day >= daysPerYear)
      {
         // remove year
         day -= daysPerYear;
      }
      else
      {
         // year should be years since 1900
         *year -= 1900;
         break;
      }
   }

   // set the day in the year (days do not begin on 0, so +1)
   ++day;
   result->tm_yday = day;

   // remove extra day from leap years (31 days in Jan + 28 in February = 59)
   if(_isLeapYear(1900 + *year) && day > 59)
   {
      --day;
   }

   // determine the month
   int* month = &result->tm_mon;
   for(*month = 11; day <= _daysInPreviousMonth[*month]; --(*month));

   // determine the day of the month
   result->tm_mday = day - _daysInPreviousMonth[*month];

   // daylight savings time information not available
   result->tm_isdst = -1;

   return result;
}