void PayoffBase::initialize(const TimeGrid& timeGrid, const Calendar& calendar){ Date today = Settings::instance().evaluationDate(); Date issueDate = Date(27,Sep,2012); payoffDatesPosition_ = calendar.businessDaysBetween(issueDate,payoffDate_,true,false); }
int32_t RelativeDateFormat::dayDifference(Calendar &cal, UErrorCode &status) { if(U_FAILURE(status)) { return 0; } // TODO: Cache the nowCal to avoid heap allocs? Would be difficult, don't know the calendar type Calendar *nowCal = cal.clone(); nowCal->setTime(Calendar::getNow(), status); // For the day difference, we are interested in the difference in the (modified) julian day number // which is midnight to midnight. Using fieldDifference() is NOT correct here, because // 6pm Jan 4th to 10am Jan 5th should be considered "tomorrow". int32_t dayDiff = cal.get(UCAL_JULIAN_DAY, status) - nowCal->get(UCAL_JULIAN_DAY, status); delete nowCal; return dayDiff; }
void IntlCalendarTest::TestTypes() { Calendar *c = NULL; UErrorCode status = U_ZERO_ERROR; int j; const char *locs [40] = { "en_US_VALLEYGIRL", "en_US_VALLEYGIRL@collation=phonebook;calendar=japanese", "en_US_VALLEYGIRL@collation=phonebook;calendar=gregorian", "ja_JP@calendar=japanese", "th_TH@calendar=buddhist", "ja_JP_TRADITIONAL", "th_TH_TRADITIONAL", "th_TH_TRADITIONAL@calendar=gregorian", "en_US", "th_TH", // Default calendar for th_TH is buddhist "th", // th's default region is TH and buddhist is used as default for TH "en_TH", // Default calendar for any locales with region TH is buddhist NULL }; const char *types[40] = { "gregorian", "japanese", "gregorian", "japanese", "buddhist", "japanese", "buddhist", "gregorian", "gregorian", "buddhist", "buddhist", "buddhist", NULL }; for(j=0;locs[j];j++) { logln(UnicodeString("Creating calendar of locale ") + locs[j]); status = U_ZERO_ERROR; c = Calendar::createInstance(locs[j], status); CHECK(status, "creating '" + UnicodeString(locs[j]) + "' calendar"); if(U_SUCCESS(status)) { logln(UnicodeString(" type is ") + c->getType()); if(strcmp(c->getType(), types[j])) { dataerrln(UnicodeString(locs[j]) + UnicodeString("Calendar type ") + c->getType() + " instead of " + types[j]); } } delete c; } }
Incidence *DndFactory::pasteIncidence( const QDate &newDate, const QTime *newTime ) { QClipboard *cb = QApplication::clipboard(); Calendar *cal = createDropCalendar( cb->mimeData() ); if ( !cal ) { kDebug() << "Can't parse clipboard"; return 0; } Incidence::List incList = cal->incidences(); Incidence *inc = incList.isEmpty() ? 0 : incList.first(); Incidence *newInc = d->pasteIncidence( inc, newDate, newTime ); newInc->setRelatedTo( 0 ); return newInc; }
void Cmd_AddMaster(const char* args, bool &) { const char *colon = strchr(args, ':'); std::string ip = GetIP(args); short port = GetPort(args, QW_DEFAULT_MASTER_SERVER_PORT); cal.ScheduleMasterScan(Clock::get()->GetAppTime(), ip.c_str(), port); }
void CalendarLimitTest::TestCalendarExtremeLimit() { UErrorCode status = U_ZERO_ERROR; Calendar *cal = Calendar::createInstance(status); if (failure(status, "Calendar::createInstance", TRUE)) return; cal->adoptTimeZone(TimeZone::createTimeZone("GMT")); DateFormat *fmt = DateFormat::createDateTimeInstance(); if(!fmt || !cal) { dataerrln("can't open cal and/or fmt"); return; } fmt->adoptCalendar(cal); ((SimpleDateFormat*) fmt)->applyPattern("HH:mm:ss.SSS Z, EEEE, MMMM d, yyyy G"); // This test used to test the algorithmic limits of the dates that // GregorianCalendar could handle. However, the algorithm has // been rewritten completely since then and the prior limits no // longer apply. Instead, we now do basic round-trip testing of // some extreme (but still manageable) dates. UDate m; logln("checking 1e16..1e17"); for ( m = 1e16; m < 1e17; m *= 1.1) { test(m, cal, fmt); } logln("checking -1e14..-1e15"); for ( m = -1e14; m > -1e15; m *= 1.1) { test(m, cal, fmt); } // This is 2^52 - 1, the largest allowable mantissa with a 0 // exponent in a 64-bit double UDate VERY_EARLY_MILLIS = - 4503599627370495.0; UDate VERY_LATE_MILLIS = 4503599627370495.0; // I am removing the previousDouble and nextDouble calls below for // two reasons: 1. As part of jitterbug 986, I am deprecating // these methods and removing calls to them. 2. This test is a // non-critical boundary behavior test. test(VERY_EARLY_MILLIS, cal, fmt); //test(previousDouble(VERY_EARLY_MILLIS), cal, fmt); test(VERY_LATE_MILLIS, cal, fmt); //test(nextDouble(VERY_LATE_MILLIS), cal, fmt); delete fmt; }
/** * j32 {JDK Bug 4210209 4209272} * DateFormat cannot parse Feb 29 2000 when setLenient(false) */ void DateFormatRegressionTest::Test4210209(void) { UErrorCode status = U_ZERO_ERROR; UnicodeString pattern("MMM d, yyyy"); SimpleDateFormat sfmt(pattern, Locale::getUS(), status); SimpleDateFormat sdisp("MMM dd yyyy GG", Locale::getUS(), status); DateFormat& fmt = *(DateFormat*)&sfmt; // Yuck: See j25 DateFormat& disp = *(DateFormat*)&sdisp; // Yuck: See j25 if (U_FAILURE(status)) { dataerrln("Couldn't create SimpleDateFormat - %s", u_errorName(status)); return; } Calendar* calx = (Calendar*)fmt.getCalendar(); // cast away const! calx->setLenient(FALSE); UDate d = date(2000-1900, UCAL_FEBRUARY, 29); UnicodeString s, ss; fmt.format(d, s); logln(disp.format(d, ss.remove()) + " f> " + pattern + " => \"" + s + "\""); ParsePosition pos(0); d = fmt.parse(s, pos); logln(UnicodeString("\"") + s + "\" p> " + pattern + " => " + disp.format(d, ss.remove())); logln(UnicodeString("Parse pos = ") + pos.getIndex() + ", error pos = " + pos.getErrorIndex()); if (pos.getErrorIndex() != -1) { errln(UnicodeString("FAIL: Error index should be -1")); } // The underlying bug is in GregorianCalendar. If the following lines // succeed, the bug is fixed. If the bug isn't fixed, they will throw // an exception. GregorianCalendar cal(status); if (U_FAILURE(status)) { errln("FAIL: Unable to create Calendar"); return; } cal.clear(); cal.setLenient(FALSE); cal.set(2000, UCAL_FEBRUARY, 29); // This should work! logln(UnicodeString("Attempt to set Calendar to Feb 29 2000: ") + disp.format(cal.getTime(status), ss.remove())); if (U_FAILURE(status)) { errln("FAIL: Unable to set Calendar to Feb 29 2000"); } }
//---------------------------------------------------------------------- void DateFormat::setCalendar(const Calendar& newCalendar) { Calendar* newCalClone = newCalendar.clone(); if (newCalClone != NULL) { adoptCalendar(newCalClone); } }
int32_t Calendar::getActualMaximum(UCalendarDateFields field, UErrorCode& status) const { int32_t fieldValue = getLeastMaximum(field); int32_t endValue = getMaximum(field); // if we know that the maximum value is always the same, just return it if (fieldValue == endValue) { return fieldValue; } // clone the calendar so we don't mess with the real one, and set it to // accept anything for the field values Calendar *work = (Calendar*)this->clone(); work->setLenient(TRUE); // if we're counting weeks, set the day of the week to Sunday. We know the // last week of a month or year will contain the first day of the week. if (field == UCAL_WEEK_OF_YEAR || field == UCAL_WEEK_OF_MONTH) work->set(UCAL_DAY_OF_WEEK, fFirstDayOfWeek); // now try each value from getLeastMaximum() to getMaximum() one by one until // we get a value that normalizes to another value. The last value that // normalizes to itself is the actual maximum for the current date int32_t result = fieldValue; do { work->set(field, fieldValue); if(work->get(field, status) != fieldValue) { break; } else { result = fieldValue; fieldValue++; } } while (fieldValue <= endValue); delete work; /* Test for buffer overflows */ if(U_FAILURE(status)) { return 0; } return result; }
// Utility methods to create a date. This is useful for converting Java constructs // which create a Date object. UDate CalendarTimeZoneTest::date(int32_t y, int32_t m, int32_t d, int32_t hr, int32_t min, int32_t sec) { Calendar* cal = getCalendar(); if (cal == 0) return 0.0; cal->clear(); cal->set(1900 + y, m, d, hr, min, sec); // Add 1900 to follow java.util.Date protocol UErrorCode status = U_ZERO_ERROR; UDate dt = cal->getTime(status); releaseCalendar(cal); if (U_FAILURE(status)) { errln("FAIL: Calendar::getTime failed: %s", u_errorName(status)); return 0.0; } return dt; }
UBool Calendar::operator==(const Calendar& that) const { UErrorCode status = U_ZERO_ERROR; return isEquivalentTo(that) && getTimeInMillis(status) == that.getTimeInMillis(status) && U_SUCCESS(status); }
void TizenSystem::getTimeAndDate(TimeDate &td) const { DateTime currentTime; if (E_SUCCESS == SystemTime::GetCurrentTime(WALL_TIME, currentTime)) { td.tm_sec = currentTime.GetSecond(); td.tm_min = currentTime.GetMinute(); td.tm_hour = currentTime.GetHour(); td.tm_mday = currentTime.GetDay(); td.tm_mon = currentTime.GetMonth(); td.tm_year = currentTime.GetYear(); Calendar *calendar = Calendar::CreateInstanceN(CALENDAR_GREGORIAN); calendar->SetTime(currentTime); td.tm_wday = calendar->GetTimeField(TIME_FIELD_DAY_OF_WEEK) - 1; delete calendar; } }
void iCalConverter::setSource(Calendar& inputCalendar) { if(calendar) delete calendar; calendar = (Calendar *)inputCalendar.clone(); if(iCalendar) { delete [] iCalendar; iCalendar = NULL; } }
/** * Verify that TaiWanCalendar shifts years to Minguo Era but otherwise * behaves like GregorianCalendar. */ void IntlCalendarTest::TestTaiwan() { // MG 1 == 1912 AD UDate timeA = Calendar::getNow(); // TODO port these to the data items int32_t data[] = { 1, // B. era [928479600000] 1, // B. year 1912, // G. year UCAL_JUNE, // month 4, // day 1, // B. era [-79204842000000] 3, // B. year 1914, // G. year UCAL_FEBRUARY, // month 12, // day 1, // B. era [-79204842000000] 96, // B. year 2007, // G. year UCAL_FEBRUARY, // month 12, // day -1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }; Calendar *cal; UErrorCode status = U_ZERO_ERROR; cal = Calendar::createInstance("en_US@calendar=roc", status); CHECK(status, UnicodeString("Creating en_US@calendar=roc calendar")); // Sanity check the calendar UDate timeB = Calendar::getNow(); UDate timeCal = cal->getTime(status); if(!(timeA <= timeCal) || !(timeCal <= timeB)) { errln((UnicodeString)"Error: Calendar time " + timeCal + " is not within sampled times [" + timeA + " to " + timeB + "]!"); } // end sanity check quasiGregorianTest(*cal,Locale("en_US"),data); delete cal; }
/** * @bug 4071441 */ void DateFormatRegressionTest::Test4071441(void) { DateFormat *fmtA = DateFormat::createInstance(); DateFormat *fmtB = DateFormat::createInstance(); if (fmtA == NULL || fmtB == NULL){ dataerrln("Error calling DateFormat::createInstance"); delete fmtA; delete fmtB; return; } // {sfb} Is it OK to cast away const here? Calendar *calA = (Calendar*) fmtA->getCalendar(); Calendar *calB = (Calendar*) fmtB->getCalendar(); if(!calA || !calB) { errln("Couldn't get proper calendars, exiting"); delete fmtA; delete fmtB; return; } UDate epoch = date(0, 0, 0); UDate xmas = date(61, UCAL_DECEMBER, 25); UErrorCode status = U_ZERO_ERROR; calA->setTime(epoch, status); failure(status, "calA->setTime"); calB->setTime(epoch, status); failure(status, "calB->setTime"); if (*calA != *calB) errln("Fail: Can't complete test; Calendar instances unequal"); if (*fmtA != *fmtB) errln("Fail: DateFormat unequal when Calendars equal"); calB->setTime(xmas, status); failure(status, "calB->setTime"); if (*calA == *calB) errln("Fail: Can't complete test; Calendar instances equal"); if (*fmtA != *fmtB) errln("Fail: DateFormat unequal when Calendars equivalent"); logln("DateFormat.equals ok"); delete fmtA; delete fmtB; }
UBool Calendar::isEquivalentTo(const Calendar& other) const { return getDynamicClassID() == other.getDynamicClassID() && fLenient == other.fLenient && fFirstDayOfWeek == other.fFirstDayOfWeek && fMinimalDaysInFirstWeek == other.fMinimalDaysInFirstWeek && *fZone == *other.fZone; }
/** * Verify that BuddhistCalendar shifts years to Buddhist Era but otherwise * behaves like GregorianCalendar. */ void IntlCalendarTest::TestBuddhist() { // BE 2542 == 1999 CE UDate timeA = Calendar::getNow(); int32_t data[] = { 0, // B. era [928479600000] 2542, // B. year 1999, // G. year UCAL_JUNE, // month 4, // day 0, // B. era [-79204842000000] 3, // B. year -540, // G. year UCAL_FEBRUARY, // month 12, // day 0, // test month calculation: 4795 BE = 4252 AD is a leap year, but 4795 AD is not. 4795, // BE [72018057600000] 4252, // AD UCAL_FEBRUARY, 29, -1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }; Calendar *cal; UErrorCode status = U_ZERO_ERROR; cal = Calendar::createInstance("th_TH@calendar=buddhist", status); CHECK(status, UnicodeString("Creating th_TH@calendar=buddhist calendar")); // Sanity check the calendar UDate timeB = Calendar::getNow(); UDate timeCal = cal->getTime(status); if(!(timeA <= timeCal) || !(timeCal <= timeB)) { errln((UnicodeString)"Error: Calendar time " + timeCal + " is not within sampled times [" + timeA + " to " + timeB + "]!"); } // end sanity check quasiGregorianTest(*cal,Locale("th_TH@calendar=gregorian"),data); delete cal; }
static bool test_bond_schedule_anotherday_cython() { Date last_month; Date today; FixedRateBond* bond; Calendar calendar; Date s_date; Date b_date; Date e_date; last_month = Date(30, August, 2011); today = Date::endOfMonth(last_month); bond = get_bond_for_evaluation_date(today); calendar = TARGET(); s_date = calendar.advance(today, 3, Days, Following, 0); b_date = bond->settlementDate(); e_date = QL::get_evaluation_date(); if (s_date != b_date) { std::cout << "Dates are not equivalent " << s_date << " vs " << b_date << std::endl; return false; } if (today != e_date) { std::cout << "Evaluation dates are not equivalent " << today << " vs " << e_date << std::endl; return false; } return true; }
void test_remove_event(){ Calendar<Gregorian> cal; cal.set_date(2024,5,12); cal.add_event("aa"); cal.add_event("aa",12,5,2024,20,00,1); cal.add_event("ab",13); cal.add_event("ac",20,6); cal.add_event("aa",3,8,2030,23,59,60*25); mod_Stripper<Gregorian> stripperTest; stripperTest << cal; stringstream ss; ss << stripperTest; std::string test_string = ss.str(); TS_ASSERT_DIFFERS(test_string.find("2405121300"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("2405121700"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("aa"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("2405122000"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("2405122001"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("aa"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("2405131300"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("2405131700"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("ab"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("2406201300"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("2406201700"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("ac"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("3008032359"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("3008050059"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("aa"),std::string::npos); cal.remove_event("aa"); mod_Stripper<Gregorian> stripperTest2; stripperTest2 << cal; stringstream ss2; ss2 << stripperTest2; test_string = ss2.str(); TS_ASSERT_EQUALS(test_string.find("2405121300"),std::string::npos); TS_ASSERT_EQUALS(test_string.find("2405121700"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("2405122000"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("2405122001"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("aa"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("2405131300"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("2405131700"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("ab"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("2406201300"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("2406201700"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("ac"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("3008032359"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("3008050059"),std::string::npos); TS_ASSERT_DIFFERS(test_string.find("aa"),std::string::npos); }
void CalendarCaseTest::Coptic() { static const TestCase tests[] = { // JD Era Year Month Day WkDay Hour Min Sec {2401442.5, 1, 1579, 2, 20, WED, 0, 0, 0}, // Gregorian: 20/10/1862 {2402422.5, 1, 1581, 10, 29, WED, 0, 0, 0}, // Gregorian: 05/07/1865 {2402630.5, 1, 1582, 5, 22, MON, 0, 0, 0}, // Gregorian: 29/01/1866 {2402708.5, 1, 1582, 8, 10, TUE, 0, 0, 0}, // Gregorian: 17/04/1866 {2402971.5, 1, 1583, 4, 28, SAT, 0, 0, 0}, // Gregorian: 05/01/1867 {2403344.5, 1, 1584, 5, 5, MON, 0, 0, 0}, // Gregorian: 13/01/1868 {1721059.5, 0, 285, 5, 7, SAT, 0, 0, 0}, // Gregorian: 01/01/0000 {1721425.5, 0, 284, 5, 8, MON, 0, 0, 0}, // Gregorian: 01/01/0001 {1824663.5, 0, 2, 13, 6, WED, 0, 0, 0}, // Gregorian: 29/08/0283 {1824664.5, 0, 1, 1, 1, THU, 0, 0, 0}, // Gregorian: 30/08/0283 {1825029.5, 1, 1, 1, 1, FRI, 0, 0, 0}, // Gregorian: 29/08/0284 {1825394.5, 1, 2, 1, 1, SAT, 0, 0, 0}, // Gregorian: 29/08/0285 {1825759.5, 1, 3, 1, 1, SUN, 0, 0, 0}, // Gregorian: 29/08/0286 {1826125.5, 1, 4, 1, 1, TUE, 0, 0, 0}, // Gregorian: 30/08/0287 {1825028.5, 0, 1, 13, 5, THU, 0, 0, 0}, // Gregorian: 28/08/0284 {1825393.5, 1, 1, 13, 5, FRI, 0, 0, 0}, // Gregorian: 28/08/0285 {1825758.5, 1, 2, 13, 5, SAT, 0, 0, 0}, // Gregorian: 28/08/0286 {1826123.5, 1, 3, 13, 5, SUN, 0, 0, 0}, // Gregorian: 28/08/0287 {1826124.5, 1, 3, 13, 6, MON, 0, 0, 0}, // Gregorian: 29/08/0287 // above is first coptic leap year {1826489.5, 1, 4, 13, 5, TUE, 0, 0, 0}, // Gregorian: 28/08/0288 {2299158.5, 1, 1299, 2, 6, WED, 0, 0, 0}, // Gregorian: 13/10/1582 {2299159.5, 1, 1299, 2, 7, THU, 0, 0, 0}, // Gregorian: 14/10/1582 {2299160.5, 1, 1299, 2, 8, FRI, 0, 0, 0}, // Gregorian: 15/10/1582 {2299161.5, 1, 1299, 2, 9, SAT, 0, 0, 0}, // Gregorian: 16/10/1582 {2415020.5, 1, 1616, 4, 23, MON, 0, 0, 0}, // Gregorian: 01/01/1900 {2453371.5, 1, 1721, 4, 23, SAT, 0, 0, 0}, // Gregorian: 01/01/2005 {2555528.5, 1, 2000, 13, 5, FRI, 0, 0, 0}, // Gregorian: 12/09/2284 { -1, -1, -1, -1, -1, -1, -1, -1, -1} }; UErrorCode status = U_ZERO_ERROR; Calendar *c = Calendar::createInstance("cop_EG@calendar=coptic", status); if (failure(status, "Calendar::createInstance", TRUE)) return; c->setLenient(TRUE); doTestCases(tests, c); delete c; }
/** * Verify that JapaneseCalendar shifts years to Japanese Eras but otherwise * behaves like GregorianCalendar. */ void IntlCalendarTest::TestJapanese() { UDate timeA = Calendar::getNow(); /* Sorry.. japancal.h is private! */ #define JapaneseCalendar_MEIJI 232 #define JapaneseCalendar_TAISHO 233 #define JapaneseCalendar_SHOWA 234 #define JapaneseCalendar_HEISEI 235 // BE 2542 == 1999 CE int32_t data[] = { // Jera Jyr Gyear m d JapaneseCalendar_MEIJI, 1, 1868, UCAL_SEPTEMBER, 8, JapaneseCalendar_MEIJI, 1, 1868, UCAL_SEPTEMBER, 9, JapaneseCalendar_MEIJI, 2, 1869, UCAL_JUNE, 4, JapaneseCalendar_MEIJI, 45, 1912, UCAL_JULY, 29, JapaneseCalendar_TAISHO, 1, 1912, UCAL_JULY, 30, JapaneseCalendar_TAISHO, 1, 1912, UCAL_AUGUST, 1, // new tests (not in java) JapaneseCalendar_SHOWA, 64, 1989, UCAL_JANUARY, 7, // Test current era transition (different code path than others) JapaneseCalendar_HEISEI, 1, 1989, UCAL_JANUARY, 8, JapaneseCalendar_HEISEI, 1, 1989, UCAL_JANUARY, 9, JapaneseCalendar_HEISEI, 1, 1989, UCAL_DECEMBER, 20, JapaneseCalendar_HEISEI, 15, 2003, UCAL_MAY, 22, -1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }; Calendar *cal; UErrorCode status = U_ZERO_ERROR; cal = Calendar::createInstance("ja_JP@calendar=japanese", status); CHECK(status, UnicodeString("Creating ja_JP@calendar=japanese calendar")); // Sanity check the calendar UDate timeB = Calendar::getNow(); UDate timeCal = cal->getTime(status); if(!(timeA <= timeCal) || !(timeCal <= timeB)) { errln((UnicodeString)"Error: Calendar time " + timeCal + " is not within sampled times [" + timeA + " to " + timeB + "]!"); } // end sanity check quasiGregorianTest(*cal,Locale("ja_JP"),data); delete cal; }
std::string GlobalizationNDK::getFirstDayOfWeek() { UErrorCode status = U_ZERO_ERROR; Calendar* cal = Calendar::createInstance(status); if (!cal) { slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::getFirstDayOfWeek: failed to create Calendar instance: %d", status); return errorInJson(UNKNOWN_ERROR, "Failed to create Calendar instance!"); } UCalendarDaysOfWeek d = cal->getFirstDayOfWeek(status); if (status != U_ZERO_ERROR && status != U_ERROR_WARNING_START) { slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::getFirstDayOfWeek: failed to call getFirstDayOfWeek: %d", status); return errorInJson(UNKNOWN_ERROR, "Failed to call getFirstDayOfWeek!"); } return resultInJson(d); }
QModelIndex CalendarItemModel::index( const Calendar *calendar, int column ) const { if ( m_project == 0 || calendar == 0 ) { return QModelIndex(); } Calendar *a = const_cast<Calendar*>(calendar); int row = -1; Calendar *par = a->parentCal(); if ( par == 0 ) { row = m_project->calendars().indexOf( a ); } else { row = par->indexOf( a ); } if ( row == -1 ) { return QModelIndex(); } return createIndex( row, column, a ); }
static void replaceFieldTypesExample() { // Use repalceFieldTypes API to replace zone 'zzzz' with 'vvvv' u_printf("========================================================================\n"); u_printf(" replaceFieldTypeExample()\n"); u_printf("\n"); u_printf(" Use replaceFieldTypes API to replace zone 'zzzz' with 'vvvv'\n"); u_printf("========================================================================\n"); //! [replaceFieldTypesExample] UFILE *out = u_finit(stdout, NULL, "UTF-8"); UErrorCode status =U_ZERO_ERROR; UnicodeString pattern,dateReturned; Locale locale =Locale::getFrance(); Calendar *cal = Calendar::createInstance(status); cal->set (1999,9,13,23,58,59); UDate date = cal->getTime(status); TimeZone *zone = TimeZone::createTimeZone(UnicodeString("Europe/Paris")); DateTimePatternGenerator *dtfg = DateTimePatternGenerator::createInstance(locale,status); SimpleDateFormat *sdf = new SimpleDateFormat("EEEE d MMMM y HH:mm:ss zzzz",locale,status); sdf->setTimeZone(*zone); pattern = sdf->toPattern(pattern); u_fprintf(out, "%S\n", UnicodeString("Pattern before replacement:").getTerminatedBuffer()); u_fprintf(out, "%S\n", pattern.getTerminatedBuffer()); dateReturned.remove(); dateReturned = sdf->format(date, dateReturned, status); u_fprintf(out, "%S\n", UnicodeString("Date/Time format in fr_FR:").getTerminatedBuffer()); u_fprintf(out, "%S\n", dateReturned.getTerminatedBuffer()); // Replace zone "zzzz" in the pattern with "vvvv" UnicodeString newPattern = dtfg->replaceFieldTypes(pattern, "vvvv", status); // Apply the new pattern sdf->applyPattern(newPattern); dateReturned.remove(); dateReturned = sdf->format(date, dateReturned, status); u_fprintf(out, "%S\n", UnicodeString("Pattern after replacement:").getTerminatedBuffer()); u_fprintf(out, "%S\n", newPattern.getTerminatedBuffer()); u_fprintf(out, "%S\n", UnicodeString("Date/Time format in fr_FR:").getTerminatedBuffer()); u_fprintf(out, "%S\n", dateReturned.getTerminatedBuffer()); delete sdf; delete dtfg; delete zone; delete cal; u_fclose(out); //! [replaceFieldTypesExample] }
void IntlCalendarTest::TestPersian() { UDate timeA = Calendar::getNow(); Calendar *cal; UErrorCode status = U_ZERO_ERROR; cal = Calendar::createInstance("fa_IR@calendar=persian", status); CHECK(status, UnicodeString("Creating fa_IR@calendar=persian calendar")); // Sanity check the calendar UDate timeB = Calendar::getNow(); UDate timeCal = cal->getTime(status); if(!(timeA <= timeCal) || !(timeCal <= timeB)) { errln((UnicodeString)"Error: Calendar time " + timeCal + " is not within sampled times [" + timeA + " to " + timeB + "]!"); } // end sanity check // quasiGregorianTest(*cal,Locale("ja_JP"),data); delete cal; }
void Cmd_AddPingURL(const char* args, bool &) { if (*args && strstarts(args, "http://")) { printf("Adding ping url %s\n", args); cal.AddPingUrl(args, Clock::get()->GetAppTime()); } else { printf("Usage: addpingurl http://..."); } }
Incidence::List DndFactory::pasteIncidences( const QDate &newDate, const QTime *newTime ) { QClipboard *cb = QApplication::clipboard(); Calendar *cal = createDropCalendar( cb->mimeData() ); Incidence::List list; if ( !cal ) { kDebug() << "Can't parse clipboard"; return list; } // All pasted incidences get new uids, must keep track of old uids, // so we can update child's parents QHash<QString,Incidence*> oldUidToNewInc; Incidence::List::ConstIterator it; const Incidence::List incs = cal->incidences(); for ( it = incs.constBegin(); it != incs.constEnd(); ++it ) { Incidence *inc = d->pasteIncidence( *it, newDate, newTime ); if ( inc ) { list.append( inc ); oldUidToNewInc[( *it )->uid()] = inc; } } // update relations for ( it = list.constBegin(); it != list.constEnd(); ++it ) { Incidence *inc = *it; if ( oldUidToNewInc.contains( inc->relatedToUid() ) ) { Incidence *parentInc = oldUidToNewInc[inc->relatedToUid()]; inc->setRelatedToUid( parentInc->uid() ); inc->setRelatedTo( parentInc ); } else { // not related to anything in the clipboard inc->setRelatedToUid( QString() ); inc->setRelatedTo( 0 ); } } return list; }
boost::shared_ptr<VanillaSwap> InstrumentFactory::make_vanillaSwap(Real notional, const Date& ref_date, const std::string& swap_index_cd, Rate fixedRate, VanillaSwap::Type fixedPayRecType, Spread floatingLegSpread, const Handle<YieldTermStructure>& evalYieldCurve, const boost::shared_ptr<PricingEngine>& engine ) { // 로드해 boost::shared_ptr<SwapIndex> swapIndex = IndexFactory::swapIndex(swap_index_cd, evalYieldCurve.currentLink()); Calendar calendar = SouthKorea(); Period maturityTenor = swapIndex->tenor(); Period couponTenor = swapIndex->fixedLegTenor(); DayCounter dayCounter = swapIndex->dayCounter(); BusinessDayConvention businessDayConvention = BusinessDayConvention::ModifiedFollowing; Schedule schedule = Schedule(ref_date, calendar.advance(ref_date, maturityTenor, businessDayConvention), couponTenor, calendar, businessDayConvention, businessDayConvention, DateGeneration::Rule::Forward, false); boost::shared_ptr<VanillaSwap> vanilla_swap = boost::shared_ptr<VanillaSwap>(new VanillaSwap(fixedPayRecType, notional, schedule, fixedRate, dayCounter, schedule, swapIndex->iborIndex()->clone(evalYieldCurve), floatingLegSpread, dayCounter)); vanilla_swap->setPricingEngine(engine); return vanilla_swap; }
void PayoffManager::initialize(const TimeGrid& timeGrid, const Calendar& calendar){ Date today = Settings::instance().evaluationDate(); Date issueDate = Date(27,Sep,2012); /*std::cout << issueDate.serialNumber() << std::endl; std::cout << payoffDate_.serialNumber() << std::endl; std::cout << payoffDate_.serialNumber() - issueDate.serialNumber() << std::endl;*/ payoffDatesPosition_ = calendar.businessDaysBetween(issueDate,payoffDate_,true,false); //std::cout << payoffDatesPosition_; }
bool PlanTJScheduler::kplatoToTJ() { m_tjProject = new TJ::Project(); m_tjProject->setScheduleGranularity( m_granularity / 1000 ); m_tjProject->getScenario( 0 )->setMinSlackRate( 0.0 ); // Do not caclulate critical path m_tjProject->setNow( m_project->constraintStartTime().toTime_t() ); m_tjProject->setStart( m_project->constraintStartTime().toTime_t() ); m_tjProject->setEnd( m_project->constraintEndTime().toTime_t() ); m_tjProject->setDailyWorkingHours( m_project->standardWorktime()->day() ); // Set working days for the project, it is used for tasks with a length specification // FIXME: Plan has task specific calendars for this estimate type KPlato::Calendar *cal = m_project->defaultCalendar(); if ( ! cal ) { m_project->calendars().value( 0 ); } if ( cal ) { int days[ 7 ] = { Qt::Sunday, Qt::Monday, Qt::Tuesday, Qt::Wednesday, Qt::Thursday, Qt::Friday, Qt::Saturday }; for ( int i = 0; i < 7; ++i ) { CalendarDay *d = 0; for ( Calendar *c = cal; c; c = c->parentCal() ) { QTime t; t.start(); d = c->weekday( days[ i ] ); Q_ASSERT( d ); if ( d == 0 || d->state() != CalendarDay::Undefined ) { break; } } if ( d && d->state() == CalendarDay::Working ) { QList<TJ::Interval*> lst; foreach ( const TimeInterval *ti, d->timeIntervals() ) { TJ::Interval *tji = new TJ::Interval( toTJInterval( ti->startTime(), ti->endTime(),tjGranularity() ) ); lst << tji; } m_tjProject->setWorkingHours( i, lst ); qDeleteAll( lst ); } } }