Exemplo n.º 1
0
int Date::getTimeZoneOffset()
{
	if (INT_MIN == s_timeZoneOffset)
	{
		Date utc(1970, 1, 1);
		s_timeZoneOffset = utc.stamp();
	}
	return s_timeZoneOffset;
}
Exemplo n.º 2
0
	LEMON_UNITTEST_CASE(DateTimeUnittest,datetimeTest)
	{
		time_t t = time_t::now();

		localtime_t local(t);

		utctime_t utc(t);

		LEMON_CHECK(local.time() == utc.time());
	}
Exemplo n.º 3
0
// CLASS METHODS
DatetimeTz CurrentTime::asDatetimeTz()
{
    Datetime now = utc();
    bsls::TimeInterval offset = LocalTimeOffset::localTimeOffset(now);
    now.addSeconds(offset.totalSeconds());

    BSLS_ASSERT((-1440                 < offset.totalMinutes()) && 
                (offset.totalMinutes() < 1440));
    return DatetimeTz(now, static_cast<int>(offset.totalMinutes()));
}
Exemplo n.º 4
0
Creature::Creature(const Common::UString &resRef) :
		Object(kObjectTypeCreature),
		_commandable(true),
		_walkRate(0.0f),
		_runRate(0.0f) {

	init();

	Common::ScopedPtr<Aurora::GFF3File> utc(loadOptionalGFF3(resRef, Aurora::kFileTypeUTC));
	if (!utc)
		throw Common::Exception("Creature \"%s\" has no blueprint", resRef.c_str());

	load(utc->getTopLevel());
}
Exemplo n.º 5
0
void show_times() {
    char buffer[100];

    const int year = 2013;
    const int month = 4;
    int day = 7;
    
    //  Set timezone (POSIX extension)

    setenv("TZ", "EST-10EST-9:03:00,M10,1.0,M4.1.0/3", 1);

    //  Shows times for each hour in the selected day

    for ( int hour = 0; hour < 24; ++hour ) {

        utctime::UTCTime utc(year, month, day, hour, 0, 0);

        time_t ts = utc.timestamp();

        //  Output local time of returned timestamp

        tm* ptm = localtime(&ts);
        if ( ptm == 0 ) {
            std::cerr << "Couldn't get time!" << std::endl;
            return;
        }

        tm local_tm = *ptm;
        strftime(buffer, 100, "%b %d, %y %H:%M loc", &local_tm);
        std::cout << buffer << " : ";

        //  Output GMT time of returned timestamp

        ptm = gmtime(&ts);
        if ( ptm == 0 ) {
            std::cerr << "Couldn't get time!" << std::endl;
            return;
        }

        tm gm_tm = *ptm;
        strftime(buffer, 100, "%b %d, %y %H:%M loc", &gm_tm);
        std::cout << buffer << " : ";

        //  Output what UTCTime class says UTC time is

        std::cout << utc.time_string_inet()
                  << std::endl;
    }
}
Exemplo n.º 6
0
int main(void) {
    try {
        utctime::UTCTime utc(1, 12, 31, 6, 6, 6);
    } catch(utctime::UTCTimeException& e) {
        std::cerr << e.what() << std::endl;
        return 1;
    }

    utctime::UTCTime utc;
    std::cout << "Current UTC time is: " << utc.time_string()
              << std::endl << std::endl;

    astro::show_planet_positions(std::cout);
    return 0;
}
Exemplo n.º 7
0
/*
QDateTime Wpp::makeDateTime(const QString& ianaId, qint64 msecsSinceEpoch)
{
	if ( ianaId.isEmpty() )
		return QDateTime::fromMSecsSinceEpoch(msecsSinceEpoch, QTimeZone(getSystemTimezoneId()) );
	else
		return QDateTime::fromMSecsSinceEpoch(msecsSinceEpoch, QTimeZone(ianaId.toLatin1()) );
}

QDateTime Wpp::currentDateTime(const QString& ianaId)
{
	return makeDateTime(ianaId, QDateTime::currentMSecsSinceEpoch());
}
*/
QString Wpp::formatDateTime(qint64 msecsSinceEpoch, const QString& format, const QString& ianaId)
{
	//QDateTime dateTime = makeDateTime(ianaId, msecsSinceEpoch);
	QDateTime dateTime = QDateTime::fromMSecsSinceEpoch(msecsSinceEpoch);
	QDateTime utc(dateTime.toTimeSpec(Qt::UTC));
	QDateTime tzDateTime = utc.toTimeZone( QTimeZone(ianaId.toLatin1()) );// createTimeZone(ianaId) );
	qDebug() << __FUNCTION__ << ":ianaId=" << ianaId;
	qDebug() << __FUNCTION__ << ":msecsSinceEpoch=" << msecsSinceEpoch;
	qDebug() << __FUNCTION__ << ":format=" << format;
	qDebug() << __FUNCTION__ << ":dateTime=" << dateTime;
	qDebug() << __FUNCTION__ << ":utc=" << utc;
	qDebug() << __FUNCTION__ << ":tzDateTime=" << tzDateTime;
	qDebug() << __FUNCTION__ << ":tzDateTime.toString(format)=" << tzDateTime.toString(format);

	return tzDateTime.toString(format);
}
Exemplo n.º 8
0
const Common::UString PartySelectionGUI::getPortrait(const Common::UString &templ) {
	Common::ScopedPtr<Aurora::GFF3File> utc(loadOptionalGFF3(templ,
	                                                         Aurora::kFileTypeUTC,
	                                                         MKTAG('U', 'T', 'C', ' ')));

	if (!utc)
		throw Common::Exception("Invalid creature template: %s", templ.c_str());

	const Aurora::GFF3Struct &gff = utc->getTopLevel();
	Common::UString portrait;

	uint32 portraitId = gff.getUint("PortraitId");
	if (portraitId != 0) {
		const Aurora::TwoDAFile &twoda = TwoDAReg.get2DA("portraits");
		portrait = twoda.getRow(portraitId).getString("BaseResRef");
	}

	return gff.getString("Portrait", portrait);
}
static jobjectArray TimeZones_getZoneStringsImpl(JNIEnv* env, jclass, jstring localeName, jobjectArray timeZoneIds) {
    Locale locale = getLocale(env, localeName);

    // We could use TimeZone::getDisplayName, but that's even slower
    // because it creates a new SimpleDateFormat each time.
    // We're better off using SimpleDateFormat directly.

    // We can't use DateFormatSymbols::getZoneStrings because that
    // uses its own set of time zone ids and contains empty strings
    // instead of GMT offsets (a pity, because it's a bit faster than this code).

    UErrorCode status = U_ZERO_ERROR;
    UnicodeString longPattern("zzzz", 4, US_INV);
    SimpleDateFormat longFormat(longPattern, locale, status);
    // 'z' only uses "common" abbreviations. 'V' allows all known abbreviations.
    // For example, "PST" is in common use in en_US, but "CET" isn't.
    UnicodeString commonShortPattern("z", 1, US_INV);
    SimpleDateFormat shortFormat(commonShortPattern, locale, status);
    UnicodeString allShortPattern("V", 1, US_INV);
    SimpleDateFormat allShortFormat(allShortPattern, locale, status);

    UnicodeString utc("UTC", 3, US_INV);

    // TODO: use of fixed dates prevents us from using the correct historical name when formatting dates.
    // TODO: use of dates not in the current year could cause us to output obsoleted names.
    // 15th January 2008
    UDate date1 = 1203105600000.0;
    // 15th July 2008
    UDate date2 = 1218826800000.0;

    // In the first pass, we get the long names for the time zone.
    // We also get any commonly-used abbreviations.
    std::vector<TimeZoneNames> table;
    typedef std::map<UnicodeString, UnicodeString*> AbbreviationMap;
    AbbreviationMap usedAbbreviations;
    size_t idCount = env->GetArrayLength(timeZoneIds);
    for (size_t i = 0; i < idCount; ++i) {
        ScopedLocalRef<jstring> javaZoneId(env,
                reinterpret_cast<jstring>(env->GetObjectArrayElement(timeZoneIds, i)));
        ScopedJavaUnicodeString zoneId(env, javaZoneId.get());
        UnicodeString id(zoneId.unicodeString());

        TimeZoneNames row;
        if (isUtc(id)) {
            // ICU doesn't have names for the UTC zones; it just says "GMT+00:00" for both
            // long and short names. We don't want this. The best we can do is use "UTC"
            // for everything (since we don't know how to say "Universal Coordinated Time").
            row.tz = NULL;
            row.longStd = row.shortStd = row.longDst = row.shortDst = utc;
            table.push_back(row);
            usedAbbreviations[utc] = &utc;
            continue;
        }

        row.tz = TimeZone::createTimeZone(id);
        longFormat.setTimeZone(*row.tz);
        shortFormat.setTimeZone(*row.tz);

        int32_t daylightOffset;
        int32_t rawOffset;
        row.tz->getOffset(date1, false, rawOffset, daylightOffset, status);
        if (daylightOffset != 0) {
            // The TimeZone is reporting that we are in daylight time for the winter date.
            // The dates are for the wrong hemisphere, so swap them.
            row.standardDate = date2;
            row.daylightSavingDate = date1;
        } else {
            row.standardDate = date1;
            row.daylightSavingDate = date2;
        }

        longFormat.format(row.standardDate, row.longStd);
        shortFormat.format(row.standardDate, row.shortStd);
        if (row.tz->useDaylightTime()) {
            longFormat.format(row.daylightSavingDate, row.longDst);
            shortFormat.format(row.daylightSavingDate, row.shortDst);
        } else {
            row.longDst = row.longStd;
            row.shortDst = row.shortStd;
        }

        table.push_back(row);
        usedAbbreviations[row.shortStd] = &row.longStd;
        usedAbbreviations[row.shortDst] = &row.longDst;
    }

    // In the second pass, we create the Java String[][].
    // We also look for any uncommon abbreviations that don't conflict with ones we've already seen.
    jobjectArray result = env->NewObjectArray(idCount, JniConstants::stringArrayClass, NULL);
    UnicodeString gmt("GMT", 3, US_INV);
    for (size_t i = 0; i < table.size(); ++i) {
        TimeZoneNames& row(table[i]);
        // Did we get a GMT offset instead of an abbreviation?
        if (row.shortStd.length() > 3 && row.shortStd.startsWith(gmt)) {
            // See if we can do better...
            UnicodeString uncommonStd, uncommonDst;
            allShortFormat.setTimeZone(*row.tz);
            allShortFormat.format(row.standardDate, uncommonStd);
            if (row.tz->useDaylightTime()) {
                allShortFormat.format(row.daylightSavingDate, uncommonDst);
            } else {
                uncommonDst = uncommonStd;
            }

            // If this abbreviation isn't already in use, we can use it.
            AbbreviationMap::iterator it = usedAbbreviations.find(uncommonStd);
            if (it == usedAbbreviations.end() || *(it->second) == row.longStd) {
                row.shortStd = uncommonStd;
                usedAbbreviations[row.shortStd] = &row.longStd;
            }
            it = usedAbbreviations.find(uncommonDst);
            if (it == usedAbbreviations.end() || *(it->second) == row.longDst) {
                row.shortDst = uncommonDst;
                usedAbbreviations[row.shortDst] = &row.longDst;
            }
        }
        // Fill in whatever we got.
        ScopedLocalRef<jobjectArray> javaRow(env, env->NewObjectArray(5, JniConstants::stringClass, NULL));
        ScopedLocalRef<jstring> id(env, reinterpret_cast<jstring>(env->GetObjectArrayElement(timeZoneIds, i)));
        env->SetObjectArrayElement(javaRow.get(), 0, id.get());
        setStringArrayElement(env, javaRow.get(), 1, row.longStd);
        setStringArrayElement(env, javaRow.get(), 2, row.shortStd);
        setStringArrayElement(env, javaRow.get(), 3, row.longDst);
        setStringArrayElement(env, javaRow.get(), 4, row.shortDst);
        env->SetObjectArrayElement(result, i, javaRow.get());
        delete row.tz;
    }

    return result;
}
Exemplo n.º 10
0
void TimeKeeper::PPS_ISR_I(void) {

  drift_est.sample_prev = drift_est.sample;
  drift_est.sample = utc();
  ppstimesync_sem.signalI();
}
Exemplo n.º 11
0
// seti_time::ut1() returns UT1 in hours past midnight.  Warning, can return
// numbers less than 0 and greater than 24.
hours seti_time::ut1() const {
  hours h(utc()+ut1_utc_diff());
  return h;
}
Exemplo n.º 12
0
//------------------------------------------------------------------------------
// Parse a time string read from the EM file and convert it to
// a Real (A1Mjd) epoch
//------------------------------------------------------------------------------
Real CCSDSEMSegment::ParseEpoch(const std::string &epochString)
{
   #ifdef DEBUG_PARSE_EPOCH
      MessageInterface::ShowMessage("ParseEpoch -- epochString = \"%s\"\n",
            epochString.c_str());
   #endif
   // The epochs can be in either of two formats:
   // YYYY-MM-DDThh:mm:ss.mmm
   // YYYY-DOYThh:mm:ss
   std::string yyyymmdd, hhmmss, YYstr, MMstr, DDstr, hhstr, mmstr, ssmmmstr;
   Integer year, month = 0, day, hour, minute;
   Real    seconds;
   bool    doyUsed = false;

   std::size_t tPos = epochString.find_first_of("Tt");
   if (tPos == std::string::npos)
   {
      std::string errmsg = "Error reading ephemeris message file segment.  ";
      errmsg += "Missing or incorrectly formatted data Epoch.\n";
      throw UtilityException(errmsg);
   }
   yyyymmdd   = epochString.substr(0,tPos);
   hhmmss     = epochString.substr(tPos+1);
   if ((hhmmss.length() < 8) ||
       (GmatStringUtil::NumberOfOccurrences(hhmmss, ':') != 2))
   {
      std::string errmsg = "Error reading ephemeris message file segment.  ";
      errmsg += "hhmmss.sss part of Time \"" + epochString;
      errmsg += "\" is not formatted correctly.\n";
      throw UtilityException(errmsg);
   }

   hhstr     = hhmmss.substr(0,2);
   mmstr     = hhmmss.substr(3,2);
   ssmmmstr  = hhmmss.substr(6);
   if ((!GmatStringUtil::ToInteger(hhstr, hour))     ||
       (!GmatStringUtil::ToInteger(mmstr, minute))   ||
       (!GmatStringUtil::ToReal(ssmmmstr, seconds)))
   {
      std::string errmsg = "Error reading ephemeris message file segment.  ";
      errmsg += "hhmmss.sss part of Time \"" + epochString;
      errmsg += "\" is not formatted correctly.\n";
      throw UtilityException(errmsg);
   }

   Integer numDashes     = GmatStringUtil::NumberOfOccurrences(yyyymmdd, '-');
   if (numDashes == 1)  // YYYY-DOYThh:mm:ss
   {
      doyUsed   = true;
      YYstr     = yyyymmdd.substr(0,4);
      DDstr     = yyyymmdd.substr(5,3);
      if ((!GmatStringUtil::ToInteger(YYstr, year))     ||
          (!GmatStringUtil::ToInteger(DDstr, day)))
      {
         std::string errmsg = "Error reading ephemeris message file segment.  ";
         errmsg += "YYYY-DOY part of Time \"" + epochString;
         errmsg += "\" is not formatted correctly.\n";
         throw UtilityException(errmsg);
      }
   }
   else if (numDashes == 2)  // YYYY-MM-DDThh:mm:ss.mmm
   {
      doyUsed   = false;
      YYstr     = yyyymmdd.substr(0,4);
      MMstr     = yyyymmdd.substr(5,2);
      DDstr     = yyyymmdd.substr(8,2);
      if ((!GmatStringUtil::ToInteger(YYstr, year))     ||
          (!GmatStringUtil::ToInteger(MMstr, month))    ||
          (!GmatStringUtil::ToInteger(DDstr, day)))
      {
         std::string errmsg = "Error reading ephemeris message file segment.  ";
         errmsg += "YYYY-MM-DD part of Time \"" + epochString;
         errmsg += "\" is not formatted correctly.\n";
         throw UtilityException(errmsg);
      }
   }
   else
   {
      std::string errmsg = "Error reading ephemeris message file segment.  ";
      errmsg += "Time \"" + epochString;
      errmsg += "\" is not formatted correctly.\n";
      throw UtilityException(errmsg);
   }

   #ifdef DEBUG_PARSE_EPOCH
      MessageInterface::ShowMessage("epochString = %s, yyyymmdd = %s, hhmmss = %s\n",
            epochString.c_str(), yyyymmdd.c_str(), hhmmss.c_str());
      MessageInterface::ShowMessage("year = %d, month = %d, day = %d\n",
            year, month, day);
      MessageInterface::ShowMessage("hour = %d, minute = %d, seconds = %lf\n",
            hour, minute, seconds);
   #endif

   if (doyUsed)
   {
      try
      {
         UtcDate utc(year, day, hour, minute, seconds);
         #ifdef DEBUG_PARSE_EPOCH
            MessageInterface::ShowMessage(" --- UTC data to packed calendar string = %s\n",
                  utc.ToPackedCalendarString().c_str());
         #endif
         return utc.ToA1Mjd();
      }
      catch (Date::LeapYearError &lye)
      {
         std::ostringstream errmsg;

         errmsg << "Cannot read CCSDS file.  File contains time \"";
         errmsg << epochString << "\", which specifies day number ";
         errmsg << day << " for a non-leap year.\n";
         throw UtilityException(errmsg.str());
      }
   }
   else
   {
      UtcDate utc(year, month, day, hour, minute, seconds);
      #ifdef DEBUG_PARSE_EPOCH
         MessageInterface::ShowMessage(" --- UTC data to packed calendar string = %s\n",
               utc.ToPackedCalendarString().c_str());
      #endif
      return utc.ToA1Mjd();
   }

}