void CalendarTemplateElement::unlink()
{
if(getCalendar())
{
const_cast<CalendarTemplate*>(getCalendar())->removeElement(*this);
}
}
void CalendarTemplateElement::toParametersMap( util::ParametersMap& map, bool withAdditionalParameters, boost::logic::tribool withFiles /*= boost::logic::indeterminate*/, std::string prefix /*= std::string() */ ) const
{
map.insert(TABLE_COL_ID, getKey());
map.insert(
CalendarTemplateElementTableSync::COL_CALENDAR_ID,
getCalendar() ? getCalendar()->getKey() : RegistryKeyType(0)
);
map.insert(
CalendarTemplateElementTableSync::COL_RANK,
getRank()
);
map.insert(
CalendarTemplateElementTableSync::COL_MIN_DATE,
getMinDate().is_special() ? string() : to_iso_extended_string(getMinDate())
);
map.insert(
CalendarTemplateElementTableSync::COL_MAX_DATE,
getMaxDate().is_special() ? string() : to_iso_extended_string(getMaxDate())
);
map.insert(
CalendarTemplateElementTableSync::COL_INTERVAL,
boost::lexical_cast<std::string>(static_cast<int>(getStep().days()))
);
map.insert(
CalendarTemplateElementTableSync::COL_POSITIVE,
static_cast<int>(getOperation())
);
map.insert(
CalendarTemplateElementTableSync::COL_INCLUDE_ID,
getInclude() ? getInclude()->getKey() : RegistryKeyType(0)
);
}
void CalendarTemplateElement::link( util::Env& env, bool withAlgorithmOptimizations /*= false*/ )
{
if(getCalendar())
{
const_cast<CalendarTemplate*>(getCalendar())->addElement(*this);
}
}
RcppExport SEXP endOfMonth(SEXP calSexp, SEXP dateSexp){
try {
boost::shared_ptr<QuantLib::Calendar> pcal( getCalendar(Rcpp::as<std::string>(calSexp)) );
Rcpp::DateVector dates = Rcpp::DateVector(dateSexp);
int n = dates.size();
std::vector<QuantLib::Date> eom(n);
for (int i=0; i<n; i++) {
QuantLib::Date day( dateFromR(dates[i]) );
eom[i] = pcal->endOfMonth(day);
dates[i] = Rcpp::Date(eom[i].month(), eom[i].dayOfMonth(), eom[i].year());
}
return Rcpp::wrap(dates);
} catch(std::exception &ex) {
forward_exception_to_r(ex);
} catch(...) {
::Rf_error("c++ exception (unknown reason)");
}
return R_NilValue;
}
RcppExport SEXP holidayList(SEXP calSexp, SEXP params) {
try {
boost::shared_ptr<QuantLib::Calendar> pcal( getCalendar(Rcpp::as<std::string>(calSexp)) );
Rcpp::List rparam(params);
int iw = Rcpp::as<int>(rparam["includeWeekends"]);
std::vector<QuantLib::Date>
holidays = QuantLib::Calendar::holidayList(*pcal,
QuantLib::Date(dateFromR(Rcpp::as<Rcpp::Date>( rparam["from"]))),
QuantLib::Date(dateFromR(Rcpp::as<Rcpp::Date>( rparam["to"] ))),
iw == 1 ? true : false);
if (holidays.size() > 0) {
Rcpp::DateVector dv( holidays.size() );
for (unsigned int i = 0; i< holidays.size(); i++){
dv[i] = Rcpp::Date(holidays[i].month(), holidays[i].dayOfMonth(), holidays[i].year());
}
return Rcpp::wrap(dv);
} else {
return R_NilValue;
}
} catch(std::exception &ex) {
forward_exception_to_r(ex);
} catch(...) {
::Rf_error("c++ exception (unknown reason)");
}
return R_NilValue;
}
bool showCalendar(int year, int month, int day) {
int firstDay, theNumberOfDays;
if(!inputYrMn(year, month)) return false;
get1stOfMonth(year, month, firstDay, theNumberOfDays);
getCalendar(year, month, firstDay, theNumberOfDays, day);
return true;
}
RcppExport SEXP businessDaysBetween(SEXP calSexp, SEXP params,
SEXP from, SEXP to){
try {
boost::shared_ptr<QuantLib::Calendar> pcal( getCalendar(Rcpp::as<std::string>(calSexp)) );
Rcpp::List rparam(params);
double ifirst = Rcpp::as<double>(rparam["includeFirst"]);
double ilast = Rcpp::as<double>(rparam["includeLast"]);
Rcpp::DateVector dates1 = Rcpp::DateVector(from);
Rcpp::DateVector dates2 = Rcpp::DateVector(to);
int n = dates1.size();
std::vector<double> between(n);
for (int i=0; i<n; i++) {
QuantLib::Date day1( dateFromR(dates1[i]) );
QuantLib::Date day2( dateFromR(dates2[i]) );
between[i] = pcal->businessDaysBetween(day1, day2,
(ifirst == 1) ? true: false,
(ilast == 1) ? true: false);
}
return Rcpp::wrap(between);
} catch(std::exception &ex) {
forward_exception_to_r(ex);
} catch(...) {
::Rf_error("c++ exception (unknown reason)");
}
return R_NilValue;
}
RcppExport SEXP advance2(SEXP calSexp, SEXP param, SEXP dateSexp){
try {
boost::shared_ptr<QuantLib::Calendar> pcal( getCalendar(Rcpp::as<std::string>(calSexp)) );
Rcpp::List rparam(param);
QuantLib::BusinessDayConvention bdc = getBusinessDayConvention( Rcpp::as<double>(rparam["bdc"]) );
double emr = Rcpp::as<double>(rparam["emr"]);
double period = Rcpp::as<double>(rparam["period"]);
Rcpp::DateVector dates = Rcpp::DateVector(dateSexp);
int n = dates.size();
std::vector<QuantLib::Date> advance(n);
for (int i=0; i<n; i++) {
QuantLib::Date day( dateFromR(dates[i]) );
advance[i] = pcal->advance(day, QuantLib::Period(getFrequency(period)),
bdc, (emr == 1)?true:false );
dates[i] = Rcpp::Date(advance[i].month(),
advance[i].dayOfMonth(),
advance[i].year());
}
return Rcpp::wrap(dates);
} catch(std::exception &ex) {
forward_exception_to_r(ex);
} catch(...) {
::Rf_error("c++ exception (unknown reason)");
}
return R_NilValue;
}
RcppExport SEXP adjust(SEXP calSexp, SEXP bdcSEXP, SEXP dateSexp){
try {
boost::shared_ptr<QuantLib::Calendar> pcal( getCalendar(Rcpp::as<std::string>(calSexp)) );
QuantLib::BusinessDayConvention bdc = getBusinessDayConvention( Rcpp::as<double>(bdcSEXP) );
Rcpp::DateVector dates = Rcpp::DateVector(dateSexp);
int n = dates.size();
std::vector<QuantLib::Date> adjusted(n);
for (int i=0; i<n; i++) {
QuantLib::Date day( dateFromR(dates[i]) );
adjusted[i] = pcal->adjust(day, bdc);
dates[i] = Rcpp::Date(adjusted[i].month(),
adjusted[i].dayOfMonth(),
adjusted[i].year());
}
return Rcpp::wrap(dates);
} catch(std::exception &ex) {
forward_exception_to_r(ex);
} catch(...) {
::Rf_error("c++ exception (unknown reason)");
}
return R_NilValue;
}
// [[Rcpp::export]]
std::vector<QuantLib::Date> getHolidayList(std::string calendar,
QuantLib::Date from, QuantLib::Date to,
bool includeWeekends=false) {
boost::shared_ptr<QuantLib::Calendar> pcal(getCalendar(calendar));
std::vector<QuantLib::Date> holidays = QuantLib::Calendar::holidayList(*pcal, from, to, includeWeekends);
return holidays;
}
// [[Rcpp::export]]
std::vector<bool> isHoliday(std::string calendar, std::vector<QuantLib::Date> dates) {
boost::shared_ptr<QuantLib::Calendar> pcal(getCalendar(calendar));
int n = dates.size();
std::vector<bool> hdays(n);
for (int i=0; i<n; i++) {
hdays[i] = pcal->isHoliday(dates[i]);
}
return hdays;
}
// [[Rcpp::export]]
std::vector<bool> isWeekend(std::string calendar, std::vector<QuantLib::Date> dates) {
boost::shared_ptr<QuantLib::Calendar> pcal(getCalendar(calendar));
int n = dates.size();
std::vector<bool> weekends(n);
for (int i=0; i<n; i++) {
weekends[i] = pcal->isWeekend(dates[i].weekday());
}
return weekends;
}
// [[Rcpp::export]]
std::vector<QuantLib::Date> getEndOfMonth(std::string calendar, std::vector<QuantLib::Date> dates) {
boost::shared_ptr<QuantLib::Calendar> pcal(getCalendar(calendar));
int n = dates.size();
std::vector<QuantLib::Date> ndates(n);
for (int i=0; i<n; i++) {
ndates[i] = pcal->endOfMonth(dates[i]);
}
return ndates;
}
void
USFederalHolidayCalendarTest::test_2012_data_driven()
{
CalendarSharedPtr calA = getCalendar ("United States Federal Holiday Calendar");
BusinessCalendarSharedPtr busCalA =
CHECKED_SHARED_POINTER_CAST(BusinessCalendar,Calendar,calA);
runCalendaTest(*busCalA, Year(2012));
}
// [[Rcpp::export]]
std::vector<QuantLib::Date> adjust(std::string calendar, std::vector<QuantLib::Date> dates, int bdc=0) {
boost::shared_ptr<QuantLib::Calendar> pcal(getCalendar(calendar));
QuantLib::BusinessDayConvention bdcval = getBusinessDayConvention(bdc);
int n = dates.size();
std::vector<QuantLib::Date> adjusted(n);
for (int i=0; i<n; i++) {
adjusted[i] = pcal->adjust(dates[i], bdcval);
}
return adjusted;
}
// [[Rcpp::export]]
std::vector<double> businessDaysBetween(std::string calendar,
std::vector<QuantLib::Date> from,
std::vector<QuantLib::Date> to,
bool includeFirst=true, bool includeLast=false) {
boost::shared_ptr<QuantLib::Calendar> pcal(getCalendar(calendar));
int n = from.size();
std::vector<double> between(n);
for (int i=0; i<n; i++) {
between[i] = pcal->businessDaysBetween(from[i], to[i], includeFirst, includeLast);
}
return between;
}
// [[Rcpp::export]]
std::vector<QuantLib::Date> advance1(std::string calendar,
double amount, double unit, int bdcVal, double emr,
std::vector<QuantLib::Date> dates) {
boost::shared_ptr<QuantLib::Calendar> pcal(getCalendar(calendar));
QuantLib::BusinessDayConvention bdc = getBusinessDayConvention(bdcVal);
int n = dates.size();
std::vector<QuantLib::Date> advance(n);
for (int i=0; i<n; i++) {
advance[i] = pcal->advance(dates[i], amount, getTimeUnit(unit), bdc, (emr == 1) ? true : false);
}
return advance;
}
// Mimics Date.getYear() etc.
void
CalendarTimeZoneTest::dateToFields(UDate 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;
UErrorCode status = U_ZERO_ERROR;
cal->setTime(date, status);
y = cal->get(UCAL_YEAR, status) - 1900;
m = cal->get(UCAL_MONTH, status);
d = cal->get(UCAL_DATE, status);
hr = cal->get(UCAL_HOUR_OF_DAY, status);
min = cal->get(UCAL_MINUTE, status);
sec = cal->get(UCAL_SECOND, status);
releaseCalendar(cal);
}
// [[Rcpp::export]]
std::vector<QuantLib::Date> advance2(std::string calendar,
double period, int bdcVal, double emr,
std::vector<QuantLib::Date> dates) {
boost::shared_ptr<QuantLib::Calendar> pcal(getCalendar(calendar));
QuantLib::BusinessDayConvention bdc = getBusinessDayConvention(bdcVal);
int n = dates.size();
std::vector<QuantLib::Date> advance(n);
for (int i=0; i<n; i++) {
advance[i] = pcal->advance(dates[i], QuantLib::Period(getFrequency(period)),
bdc, (emr == 1) ? true : false);
}
return advance;
}
// 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;
}
// [[Rcpp::export]]
bool setCalendarContext(std::string calendar, int fixingDays, QuantLib::Date settleDate) {
// Rcpp Attribute cannot reflect complicated default arguments
if (settleDate.serialNumber() == 0) {
calendar = "TARGET";
fixingDays = 2;
settleDate = QuantLib::Date::todaysDate() + 2;
}
// set fixingDays and settleDate
RQLContext::instance().fixingDays = fixingDays;
RQLContext::instance().settleDate = settleDate;
boost::shared_ptr<QuantLib::Calendar> pcal(getCalendar(calendar));
RQLContext::instance().calendar = *pcal; // set calendar in global singleton
return true;
}
RcppExport SEXP setContext(SEXP parSEXP) {
try {
Rcpp::List par(parSEXP);
// set fixingDays and settleDate
RQLContext::instance().fixingDays = Rcpp::as<int>(par["fixingDays"]);
RQLContext::instance().settleDate = QuantLib::Date(dateFromR(Rcpp::as<Rcpp::Date>(par["settleDate"])));
boost::shared_ptr<QuantLib::Calendar> pcal( getCalendar(Rcpp::as<std::string>(par["calendar"])) );
RQLContext::instance().calendar = *pcal; // set calendar in global singleton
} catch(std::exception &ex) {
forward_exception_to_r(ex);
} catch(...) {
::Rf_error("c++ exception (unknown reason)");
}
return R_NilValue;
}
void Groupwise::get(const KURL &url)
{
kdDebug(7000) << "Groupwise::get()" << endl;
kdDebug(7000) << " URL: " << url.url() << endl;
#if 1
kdDebug(7000) << " Path: " << url.path() << endl;
kdDebug(7000) << " Query: " << url.query() << endl;
kdDebug(7000) << " Protocol: " << url.protocol() << endl;
kdDebug(7000) << " Filename: " << url.filename() << endl;
#endif
mimeType("text/plain");
QString path = url.path();
debugMessage("Path: " + path);
if(path.contains("/freebusy"))
{
getFreeBusy(url);
}
else if(path.contains("/calendar"))
{
getCalendar(url);
}
else if(path.contains("/addressbook"))
{
if(url.query().contains("update=true"))
updateAddressbook(url);
else
getAddressbook(url);
}
else
{
QString error = i18n("Unknown path. Known paths are '/freebusy/', "
"'/calendar/' and '/addressbook/'.") + QString(" path was %1").arg(url.url());
errorMessage(error);
}
kdDebug(7000) << "Groupwise::get() done" << endl;
}
RcppExport SEXP isHoliday(SEXP calSexp, SEXP dateSexp){
try {
boost::shared_ptr<QuantLib::Calendar> pcal( getCalendar(Rcpp::as<std::string>(calSexp)) );
Rcpp::DateVector dates = Rcpp::DateVector(dateSexp);
int n = dates.size();
std::vector<int> hdays(n);
for (int i=0; i<n; i++) {
QuantLib::Date day( dateFromR(dates[i]) );
hdays[i] = pcal->isHoliday(day);
}
return Rcpp::wrap(hdays);
} catch(std::exception &ex) {
forward_exception_to_r(ex);
} catch(...) {
::Rf_error("c++ exception (unknown reason)");
}
return R_NilValue;
}
ADCalendar::ADCalendar(const QString &url, const QCString &appname)
: KCal::CalendarLocal(QString::fromLatin1("UTC")),
mUrlString(url),
mAppName(appname),
mLoaded(false),
mLoadedConnected(false),
mUnregistered(false),
mEnabled(true)
{
ADCalendar *cal = getCalendar(url);
if(cal)
{
kdError(5900) << "ADCalendar::ADCalendar(" << url << "): calendar already exists" << endl;
assert(0);
}
mUrlIndex = mCalendarUrls.findIndex(url); // get unique index for this URL
if(mUrlIndex < 0)
{
mUrlIndex = static_cast<int>(mCalendarUrls.count());
mCalendarUrls.append(url);
}
loadFile(false);
mCalendars.append(this);
}
bool CalendarTemplateElement::loadFromRecord( const Record& record, util::Env& env )
{
bool result(false);
if(record.isDefined(TABLE_COL_ID))
{
RegistryKeyType value(record.getDefault<RegistryKeyType>(TABLE_COL_ID, 0));
if(value != getKey())
{
result = true;
setKey(value);
}
}
// Rank
if(record.isDefined(CalendarTemplateElementTableSync::COL_RANK))
{
size_t value(
record.getDefault<size_t>(CalendarTemplateElementTableSync::COL_RANK, 0)
);
if(value != getRank())
{
result = true;
setRank(value);
}
}
// Min date
if(record.isDefined(CalendarTemplateElementTableSync::COL_MIN_DATE))
{
date value(neg_infin);
if(!record.get<string>(CalendarTemplateElementTableSync::COL_MIN_DATE).empty())
{
try
{
value = from_string(record.get<string>(CalendarTemplateElementTableSync::COL_MIN_DATE));
}
catch(...)
{
}
}
if(value != getMinDate())
{
result = true;
setMinDate(value);
}
}
// Max date
if(record.isDefined(CalendarTemplateElementTableSync::COL_MAX_DATE))
{
date value(pos_infin);
if(!record.get<string>(CalendarTemplateElementTableSync::COL_MAX_DATE).empty())
{
try
{
value = from_string(record.get<string>(CalendarTemplateElementTableSync::COL_MAX_DATE));
}
catch(...)
{
}
}
if(value != getMaxDate())
{
result = true;
setMaxDate(value);
}
}
// Days modulo
if(record.isDefined(CalendarTemplateElementTableSync::COL_INTERVAL))
{
days value(
record.getDefault<long>(CalendarTemplateElementTableSync::COL_INTERVAL, 0)
);
if(value != getStep())
{
result = true;
setStep(value);
}
}
// Operation
if(record.isDefined(CalendarTemplateElementTableSync::COL_POSITIVE))
{
Operation value(
static_cast<Operation>(
record.getDefault<int>(CalendarTemplateElementTableSync::COL_POSITIVE, 0)
) );
if(value != getOperation())
{
result = true;
setOperation(value);
}
}
// Included calendar
// if(linkLevel > FIELDS_ONLY_LOAD_LEVEL)
{
if(record.isDefined(CalendarTemplateElementTableSync::COL_INCLUDE_ID))
{
CalendarTemplate* value(NULL);
RegistryKeyType iid(
record.getDefault<RegistryKeyType>(
CalendarTemplateElementTableSync::COL_INCLUDE_ID,
0
) );
if(iid > 0) try
{
value = CalendarTemplateTableSync::GetEditable(iid, env).get();
}
catch (ObjectNotFoundException<CalendarTemplate> e)
{
Log::GetInstance().warn("Data corrupted in " + CalendarTemplateElementTableSync::TABLE.NAME + "/" + CalendarTemplateElementTableSync::COL_INCLUDE_ID, e);
}
if(value != getInclude())
{
result = true;
setInclude(value);
}
}
}
// Link with calendar template
// if(linkLevel == UP_LINKS_LOAD_LEVEL || linkLevel == UP_DOWN_LINKS_LOAD_LEVEL || linkLevel == ALGORITHMS_OPTIMIZATION_LOAD_LEVEL)
{
if(record.isDefined(CalendarTemplateElementTableSync::COL_CALENDAR_ID))
{
CalendarTemplate* value(NULL);
RegistryKeyType id(
record.getDefault<RegistryKeyType>(
CalendarTemplateElementTableSync::COL_CALENDAR_ID,
0
) );
if(id > 0) try
{
value = CalendarTemplateTableSync::GetEditable(id, env).get();
}
catch (ObjectNotFoundException<CalendarTemplate> e)
{
Log::GetInstance().warn("Data corrupted in " + CalendarTemplateElementTableSync::TABLE.NAME + "/" + CalendarTemplateElementTableSync::COL_CALENDAR_ID, e);
}
if(value != getCalendar())
{
result = true;
setCalendar(value);
}
}
}
return result;
}
