Esempio n. 1
0
long Date::getHours(long y,long m,long d, long hh) const
{
	long g = getDays(y,m,d);
	int hfd = hh/24;
	hh = hh%24;
	return (g+hfd)*24 + hh;
}
Esempio n. 2
0
Period *Period::normalizedStandard(const PeriodType *type) {
    type = DateTimeUtils::getPeriodType(type);
    int64_t millis = getMillis();  // no overflow can happen, even with Integer.MAX_VALUEs
    millis += (((int64_t) getSeconds()) * ((int64_t) DateTimeConstants::MILLIS_PER_SECOND));
    millis += (((int64_t) getMinutes()) * ((int64_t) DateTimeConstants::MILLIS_PER_MINUTE));
    millis += (((int64_t) getHours()) * ((int64_t) DateTimeConstants::MILLIS_PER_HOUR));
    millis += (((int64_t) getDays()) * ((int64_t) DateTimeConstants::MILLIS_PER_DAY));
    millis += (((int64_t) getWeeks()) * ((int64_t) DateTimeConstants::MILLIS_PER_WEEK));
    Period *result = new Period(millis, type, ISOChronology::getInstanceUTC());
    int years = getYears();
    int months = getMonths();
    if (years != 0 || months != 0) {
        int64_t totalMonths = years * 12L + months;
        if (type->isSupported(DurationFieldType::YEARS_TYPE)) {
            int normalizedYears = FieldUtils::safeToInt(totalMonths / 12);
            result = result->withYears(normalizedYears);
            totalMonths = totalMonths - (normalizedYears * 12);
        }
        if (type->isSupported(DurationFieldType::MONTHS_TYPE)) {
            int normalizedMonths = FieldUtils::safeToInt(totalMonths);
            result = result->withMonths(normalizedMonths);
            totalMonths = totalMonths - normalizedMonths;
        }
        if (totalMonths != 0) {
            string err("Unable to normalize as PeriodType is missing either years or months but period has a month/year amount: ");
            err.append(toString());
            throw UnsupportedOperationException(err);
        }
    }
    return result;
}
Esempio n. 3
0
int Date::test()
{
	unsigned long long gg = getDays(2008,12,31);
	getDateFromDays(gg);
	gg = getHours(2008,12,31,12);
	getDateFromHours(gg);
	gg = getMinutes(2008,12,31,12,56);
	getDateFromMinutes(gg);
	gg = getSeconds(2008,12,31,12,56,56);
	getDateFromSeconds(gg);
	Date d;
	//logger << d.toString() << endl;
	Date d1 = addYearsGet(1);
	//logger << d1.toString() << endl;
	Date d2 = addMonthsGet(23);
	//logger << d2.toString() << endl;
	Date d3 = addDaysGet(17);
	//logger << d3.toString() << endl;
	Date d4 = addHoursGet(25);
	//logger << d4.toString() << endl;
	Date d5 = addMinutesGet(61);
	//logger << d5.toString() << endl;
	Date d6 = addSecondsGet(61);
	//logger << d6.toString() << endl;
	return 0;
}
Esempio n. 4
0
int main(){
    // save the frequency that the 13th of each month lands on 
    // Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, and Saturday
    int frequency[7] = { 0, 0, 0, 0, 0, 0, 0 };
    int days = 13;
    int years = 0;  // N
    
    int i = 0;
    int j = 0;

    FILE *fin = fopen( "friday.in", "r" );
    FILE *fout = fopen( "friday.out", "w" );
    assert( fin != NULL && fout != NULL );

    // get N
    fscanf( fin, "%d", &years );

    // start: 1900,01,01, Monday
    for( i = 0; i < years; i++ ){
        for( j = 1; j <= 12; j++){ 
            frequency[ days % 7 ]++;
            days += getDays( i, j );
        }
    }

    // result
    fprintf( fout, "%d", frequency[6] );
    for( i = 0; i < 6; i++ ){
        fprintf( fout, " %d", frequency[i] );
    }
    fprintf( fout, "\n");

    exit(0);
}
Esempio n. 5
0
Date Date::addYearsGet(const long& years)
{
	long g = getDays(year+years,month,day);
	Date d = getDateFromDays(g);
	d.epochTime = getSecondsI(d.year, d.month, d.day, d.hours, d.minutes, d.seconds);
	return d;
}
Esempio n. 6
0
/*------------------------------------------------------------------------*/
static char *ASCIItime(const struct tm *timeptr)
{
    char **wday_name = getDays();
    char **mon_name = getMonths();
    char *result = NULL;

    if ((wday_name) && (mon_name))
    {
#define FORMAT_TIME "%s %s%3d %.2d:%.2d:%.2d %d"
        int len_result = (int)strlen(wday_name[timeptr->tm_wday]) + (int)strlen(mon_name[timeptr->tm_mon]) + (int)strlen(FORMAT_TIME);

        result = (char *)MALLOC(sizeof(char) * (len_result + 1));
        if (result)
        {
            sprintf(result, FORMAT_TIME,
                    wday_name[timeptr->tm_wday],
                    mon_name[timeptr->tm_mon], timeptr->tm_mday, timeptr->tm_hour, timeptr->tm_min, timeptr->tm_sec, 1900 + timeptr->tm_year);
        }
    }
    else
    {
        strcpy(result, "");
    }

    /* free pointers */
    freeArrayOfString(wday_name, MAX_wday);
    freeArrayOfString(mon_name, MAX_mon);

    return result;
}
Esempio n. 7
0
std::string CCopasiTimeVariable::isoFormat() const
  {
    std::stringstream Iso;
    bool first = true;

    if (mTime < LLONG_CONST(0))
      {
        CCopasiTimeVariable Tmp(-mTime);
        Iso << "-";
        Iso << Tmp.isoFormat();

        return Iso.str();
      }

    if (mTime >= LLONG_CONST(86400000000))
      {
        Iso << LL2String(getDays()) << ":";
        first = false;
      }

    if (mTime >= LLONG_CONST(3600000000))
      Iso << LL2String(getHours(true), first ? 0 : 2) << ":";
    if (mTime >= LLONG_CONST(60000000))
      Iso << LL2String(getMinutes(true), first ? 0 : 2) << ":";
    if (mTime >= LLONG_CONST(1000000))
      Iso << LL2String(getSeconds(true), first ? 0 : 2) << ".";
    else
      Iso << "0.";

    Iso << LL2String(getMilliSeconds(true), 3) << LL2String(getMicroSeconds(true), 3);

    return Iso.str();
  }
Esempio n. 8
0
Date Date::addMonthsGet(long months)
{
	months = getMonth() + months;
	long year = getYear() + months/12;
	months = months%12;
	long g = getDays(year,months,getDay());
	return getDateFromDays(g);
}
Esempio n. 9
0
Date Date::addDaysGet(long days)
{
	long months = getMonth();
	long year = getYear() + months/12;
	months = months%12;
	long g = getDays(year,months,getDay()+days);
	return getDateFromDays(g);
}
Esempio n. 10
0
Date::Date(int yyyy,int mm,int dd)
{
	if(!validateDate(dd,mm,yyyy))throw "Invalid date";
	long g = getDays(yyyy,mm,dd);
	*this = getDateFromDays(g);
	this->nanoseconds = 0;
	this->timeZoneOffset = 0;
}
Esempio n. 11
0
void Date::updateYears(long years)
{
	long g = getDays(getYear()+years,getMonth(),getDay());
	Date d = getDateFromDays(g);
	setDay(d.getDay());
	setMonth(d.getMm());
	setYear(d.getYear());
	setDayw(d.getDayw());
}
Esempio n. 12
0
Date::Date(const int& yyyy, const int& mm, const int& dd)
{
	if(!validateDate(dd,mm,yyyy))throw std::runtime_error("Invalid date");
	long g = getDays(yyyy,mm,dd);
	*this = getDateFromDays(g);
	populateDay();
	populateMonth();
	populateEpochAndTimeZone(false);
}
Esempio n. 13
0
void Date::updateYears(const long& years)
{
	long g = getDays(year+years,month,day);
	Date d = getDateFromDays(g);
	this->day = d.day;
	this->month = d.month;
	this->year = d.year;
	populateDay();
	epochTime = getSecondsI(year, month, day, hours, minutes, seconds);
}
Esempio n. 14
0
Date Date::addMonthsGet(long months)
{
	months = month + months;
	long year = this->year + months/12;
	months = months%12;
	long g = getDays(year,months,day);
	Date d = getDateFromDays(g);
	d.epochTime = getSecondsI(d.year, d.month, d.day, d.hours, d.minutes, d.seconds);
	return d;
}
Esempio n. 15
0
Date Date::addDaysGet(const long& days)
{
	long months = month;
	long year = this->year + months/12;
	months = months%12;
	long g = getDays(year,months,day+days);
	Date d = getDateFromDays(g);
	d.epochTime += days*24*3600;
	return d;
}
Esempio n. 16
0
Date::Date(int yyyy,string mmm,int dd)
{
	string mm = getMon(mmm);
	if(mm=="-1")throw "Invalid month";
	if(!validateDate(dd,CastUtil::lexical_cast<int>(mm),yyyy))throw "Invalid date";
	long g = getDays(yyyy,CastUtil::lexical_cast<long>(mm),dd);
	*this = getDateFromDays(g);
	this->nanoseconds = 0;
	this->timeZoneOffset = 0;
}
Esempio n. 17
0
Duration *Period::toStandardDuration() {
    checkYearsAndMonths("Duration");
    int64_t millis = getMillis();  // no overflow can happen, even with Integer.MAX_VALUEs
    millis += (((int64_t) getSeconds()) * ((int64_t) DateTimeConstants::MILLIS_PER_SECOND));
    millis += (((int64_t) getMinutes()) * ((int64_t) DateTimeConstants::MILLIS_PER_MINUTE));
    millis += (((int64_t) getHours()) * ((int64_t) DateTimeConstants::MILLIS_PER_HOUR));
    millis += (((int64_t) getDays()) * ((int64_t) DateTimeConstants::MILLIS_PER_DAY));
    millis += (((int64_t) getWeeks()) * ((int64_t) DateTimeConstants::MILLIS_PER_WEEK));
    return new Duration(millis);
}
Esempio n. 18
0
Weeks *Period::toStandardWeeks() {
    checkYearsAndMonths("Weeks");
    int64_t millis = getMillis();  // assign to a int64_t
    millis += ((int64_t) getSeconds()) * DateTimeConstants::MILLIS_PER_SECOND;
    millis += ((int64_t) getMinutes()) * DateTimeConstants::MILLIS_PER_MINUTE;
    millis += ((int64_t) getHours()) * DateTimeConstants::MILLIS_PER_HOUR;
    millis += ((int64_t) getDays()) * DateTimeConstants::MILLIS_PER_DAY;
    int64_t weeks = ((int64_t) getWeeks()) + millis / DateTimeConstants::MILLIS_PER_WEEK;
    return Weeks::weeks(FieldUtils::safeToInt(weeks));
}
Esempio n. 19
0
Seconds *Period::toStandardSeconds() {
    checkYearsAndMonths("Seconds");
    int64_t seconds = getMillis() / DateTimeConstants::MILLIS_PER_SECOND;
    seconds = FieldUtils::safeAdd(seconds, (int64_t) getSeconds());
    seconds = FieldUtils::safeAdd(seconds, ((int64_t) getMinutes()) * ((int64_t) DateTimeConstants::SECONDS_PER_MINUTE));
    seconds = FieldUtils::safeAdd(seconds, ((int64_t) getHours()) * ((int64_t) DateTimeConstants::SECONDS_PER_HOUR));
    seconds = FieldUtils::safeAdd(seconds, ((int64_t) getDays()) * ((int64_t) DateTimeConstants::SECONDS_PER_DAY));
    seconds = FieldUtils::safeAdd(seconds, ((int64_t) getWeeks()) * ((int64_t) DateTimeConstants::SECONDS_PER_WEEK));
    return Seconds::seconds(FieldUtils::safeToInt(seconds));
}
Esempio n. 20
0
Date::Date(int yy,int mm,int dd,bool te)
{
	Date d;
	string syyyy = d.year.substr(0,2) + CastUtil::lexical_cast<string>(yy);
	int yyyy = CastUtil::lexical_cast<int>(syyyy);
	if(!validateDate(dd,mm,yyyy))throw "Invalid date";
	long g = getDays(yyyy,mm,dd);
	*this = getDateFromDays(g);
	this->nanoseconds = 0;
	this->timeZoneOffset = 0;
}
Esempio n. 21
0
Date::Date(const int& yyyy, const std::string& mmm, const int& dd)
{
	std::string mm = getMon(mmm);
	if(mm=="-1")throw std::runtime_error("Invalid month");
	if(!validateDate(dd,CastUtil::lexical_cast<int>(mm),yyyy))throw std::runtime_error("Invalid date");
	long g = getDays(yyyy,CastUtil::lexical_cast<long>(mm),dd);
	*this = getDateFromDays(g);
	populateDay();
	populateMonth();
	populateEpochAndTimeZone(false);
}
Esempio n. 22
0
Minutes *Period::toStandardMinutes() {
    checkYearsAndMonths("Minutes");
    int64_t millis = getMillis();  // assign to a int64_t
    millis += ((int64_t) getSeconds()) * DateTimeConstants::MILLIS_PER_SECOND;
    int64_t minutes = millis / DateTimeConstants::MILLIS_PER_MINUTE;
    minutes = FieldUtils::safeAdd(minutes, (int64_t) getMinutes());
    minutes = FieldUtils::safeAdd(minutes, ((int64_t) getHours()) * ((int64_t) DateTimeConstants::MINUTES_PER_HOUR));
    minutes = FieldUtils::safeAdd(minutes, ((int64_t) getDays()) * ((int64_t) DateTimeConstants::MINUTES_PER_DAY));
    minutes = FieldUtils::safeAdd(minutes, ((int64_t) getWeeks()) * ((int64_t) DateTimeConstants::MINUTES_PER_WEEK));
    return Minutes::minutes(FieldUtils::safeToInt(minutes));
}
Esempio n. 23
0
Days *Period::toStandardDays() {
    checkYearsAndMonths("Days");
    int64_t millis = getMillis();  // assign to a int64_t
    millis += ((int64_t) getSeconds()) * DateTimeConstants::MILLIS_PER_SECOND;
    millis += ((int64_t) getMinutes()) * DateTimeConstants::MILLIS_PER_MINUTE;
    millis += ((int64_t) getHours()) * DateTimeConstants::MILLIS_PER_HOUR;
    int64_t days = millis / DateTimeConstants::MILLIS_PER_DAY;
    days = FieldUtils::safeAdd(days, (int64_t) getDays());
    days = FieldUtils::safeAdd(days, ((int64_t) getWeeks()) * ((int64_t) DateTimeConstants::DAYS_PER_WEEK));
    return Days::days(FieldUtils::safeToInt(days));
}
Esempio n. 24
0
Date::Date(const int& yy, const int& mm, const int& dd, const bool& te)
{
	Date d;
	std::string syyyy = CastUtil::lexical_cast<std::string>(d.year).substr(0,2) + CastUtil::lexical_cast<std::string>(yy);
	int yyyy = CastUtil::lexical_cast<int>(syyyy);
	if(!validateDate(dd,mm,yyyy))throw std::runtime_error("Invalid date");
	long g = getDays(yyyy,mm,dd);
	*this = getDateFromDays(g);
	populateDay();
	populateMonth();
	populateEpochAndTimeZone(false);
}
Esempio n. 25
0
void Date::updateMonths(long months)
{
	months = getMonth() + months;
	long year = getYear() + months/12;
	months = months%12;
	long g = getDays(year,months,getDay());
	Date d = getDateFromDays(g);
	setDay(d.getDay());
	setMonth(d.getMm());
	setYear(d.getYear());
	setDayw(d.getDayw());
}
Esempio n. 26
0
void Date::updateDays(const long& days)
{
	long months = month;
	long year = this->year + months/12;
	months = months%12;
	long g = getDays(year,months,day+days);
	Date d = getDateFromDays(g);
	this->day = d.day;
	this->month = d.month;
	this->year = d.year;
	populateDay();
	epochTime += days*24*60*60;
}
Esempio n. 27
0
void Date::updateMonths(long months)
{
	months = month + months;
	long year = this->year + months/12;
	months = months%12;
	long g = getDays(year,months,day);
	Date d = getDateFromDays(g);
	this->day = d.day;
	this->month = d.month;
	this->year = d.year;
	populateDay();
	epochTime = getSecondsI(year, month, day, hours, minutes, seconds);
}
Esempio n. 28
0
Date::Date(int yy,string mmm,int dd,bool te)
{
	Date d;
	string syyyy = d.year.substr(0,2) + CastUtil::lexical_cast<string>(yy);
	int yyyy = CastUtil::lexical_cast<int>(syyyy);
	string mm = getMon(mmm);
	if(mm=="-1")throw "Invalid month";
	if(!validateDate(dd,CastUtil::lexical_cast<int>(mm),yyyy))throw "Invalid date";
	long g = getDays(yyyy,CastUtil::lexical_cast<long>(mm),dd);
	*this = getDateFromDays(g);
	this->nanoseconds = 0;
	this->timeZoneOffset = 0;
	setDayName();
}
Esempio n. 29
0
Date Date::addYearsGet(long years)
{
	long g = getDays(getYear()+years,getMonth(),getDay());
	return getDateFromDays(g);
}
Esempio n. 30
0
String DateInterval::format(CStrRef format_spec) {
  StringBuffer s;
  for(int i = 0; i < format_spec.length(); i++) {
    const int MAXLEN = 22; // 64bit signed int string length, plus terminating \0
    char buf[MAXLEN];
    int l;
    char c = format_spec.charAt(i);

    if (c != '%') {
      s.append(c);
      continue;
    }
    i++;
    if (i == format_spec.length()) {
      // End of format, use literal % and finish
      s.append(c);
      break;
    }
    c = format_spec.charAt(i);

    switch(c) {
      case 'Y': l = snprintf(buf, MAXLEN, "%02lld", getYears()); break;
      case 'y': l = snprintf(buf, MAXLEN, "%lld",   getYears()); break;

      case 'M': l = snprintf(buf, MAXLEN, "%02lld", getMonths()); break;
      case 'm': l = snprintf(buf, MAXLEN, "%lld",   getMonths()); break;

      case 'D': l = snprintf(buf, MAXLEN, "%02lld", getDays()); break;
      case 'd': l = snprintf(buf, MAXLEN, "%lld",   getDays()); break;

      case 'H': l = snprintf(buf, MAXLEN, "%02lld", getHours()); break;
      case 'h': l = snprintf(buf, MAXLEN, "%lld",   getHours()); break;

      case 'I': l = snprintf(buf, MAXLEN, "%02lld", getMinutes()); break;
      case 'i': l = snprintf(buf, MAXLEN, "%lld",   getMinutes()); break;

      case 'S': l = snprintf(buf, MAXLEN, "%02lld", getSeconds()); break;
      case 's': l = snprintf(buf, MAXLEN, "%lld",   getSeconds()); break;

      case 'a':
        if (haveTotalDays()) {
          l = snprintf(buf, MAXLEN, "%lld", getTotalDays());
        } else {
          l = snprintf(buf, MAXLEN, "(unknown)");
        }
        break;

      case 'R':
        l = snprintf(buf, MAXLEN, "%c", isInverted() ? '-' : '+'); break;
      case 'r':
        l = snprintf(buf, MAXLEN, "%s", isInverted() ? "-" : "");  break;

      case '%':
      default:
        l = 0;
        s.append('%');
        break;
    }

    if (l > 0) {
      s.append(buf, l);
    }
  }
  return s.detach();
}