Date operator-(Date a, int b) { Date q; q.Set(a.Get() - b); return q; }
void CheckStatPlan::setNextRunTime (PlanItem &oPlan)
{
Date d (oPlan.m_sNextRunTime);
Date dNow;
char sDate[15];
char sMsg[1024] = {0};
if (oPlan.m_iIntervalType == 1) //时间间隔(秒)
{
int iAddSecs = atoi (oPlan.m_sTimeInterval);
if (iAddSecs <= 0) {
strcpy (sDate, "30000101000000");
}
else {
d.addSec (iAddSecs);
if (oPlan.m_iDataType == 0) {
while (strcmp(d.toString(), dNow.toString()) <= 0)
d.addSec (iAddSecs);
//修正动态刷新指标的数据时间
Date dData (d.toString());
dData.addSec (0 - atoi(oPlan.m_sTimeInterval));
strcpy (oPlan.m_sDataEndTime, dData.toString());
dData.addSec (0 - atoi(oPlan.m_sTimeInterval));
strcpy (oPlan.m_sDataBeginTime, dData.toString());
}
strcpy (sDate, d.toString());
}
}
else if (oPlan.m_iIntervalType == 2) //每个月固定时间
{
strcpy (sDate, oPlan.m_sNextRunTime);
while (strcmp(sDate, dNow.toString()) <= 0)
getNextMonth (sDate, oPlan.m_sTimeInterval);
}
else {
//##异常, 置无穷大
strcpy (sDate, "30000101000000");
strcpy (sMsg, "interval_type 字段值非法, 请检查修改");
}
//update table
DEFINE_QUERY (qry);
if (sMsg[0])
{
qry.setSQL ("update B_Check_Stat_Plan "
" set next_run_time = to_date(:vDate,'yyyymmddhh24miss'),"
" Message = :vMsg "
" where plan_id = :vPlanID "
);
qry.setParameter ("vMsg", sMsg);
}
else {
qry.setSQL ("update B_Check_Stat_Plan "
" set next_run_time = to_date(:vDate,'yyyymmddhh24miss')"
" where plan_id = :vPlanID "
);
}
qry.setParameter ("vPlanID", oPlan.m_iPlanID);
qry.setParameter ("vDate", sDate);
qry.execute();
qry.close();
if (sMsg[0]) {
qry.setSQL ("Insert into b_check_stat_log ( "
" log_id, plan_id, msg_time, message ) "
" values (:vLogID, :vPlanID, sysdate, '[RUN] '||:vMsg )"
);
qry.setParameter ("vLogID", getNextStatLogID());
qry.setParameter ("vPlanID", oPlan.m_iPlanID);
qry.setParameter ("vMsg", sMsg);
qry.execute();
}
qry.commit ();
#ifdef _debug
Log::log (0, "设置下一次运行时间:%s", sDate);
#endif
}
Date operator+(int a, Date b) { Date q; q.Set(b.Get() + a); return q; }
/// copy constructor
Date::Date(const Date& other)
: m_baseYear(other.baseYear()), m_assumedBaseYear(other.assumedBaseYear())
{
initFromYearMonthDay(other.year(), other.monthOfYear(), other.dayOfMonth());
}
int operator-(Date a, Date b) { return a.Get() - b.Get(); }
int main()
{
// test Date class
Date d;
d.set_month(1).set_day(2).set_year(3);
cout << "date is initially " << d << endl;
cout << "date is post-incremented " << d++ << endl;
cout << "date is now " << d << endl;
cout << "date is pre-incremented " << ++d << endl;
cout << "date is now " << d << endl;
d = d + 5;
cout << "date is added by 5 " << d << endl;
cout << endl;
// test Name class
Name n("Name", "Test");
cout << "Name is " << n << endl;
cout << endl;
// test Person class
Person p("Person", "Class", 1, 2, 3);
cout << "Person is " << p << endl;
cout << endl;
// test Student derived class
Student s("Student", "Derived", 4, 5, 6, 3.5);
cout << "Student is " << s << endl;
cout << endl;
// test Employee derived class
Employee e("Employee", "Derived", 5, 6, 7, 8, 9, 10);
cout << "Employee is " << e << endl;
cout << endl;
// array of ptr to Person
Person *parray[3] = { &p,&s,&e };
for (int i = 0; i < 3; i++) {
cout << "parray[" << i << "] = " << *parray[i] << endl;
}
cout << endl;
// array of reference to Person
// ERROR: Person &ref_array[3] = { &p,&s,&e };
// array of reference to Person, by embedding reference in a structure
struct {
Person &p;
} ref[3] = { {p}, {s}, {e} };
for (int i = 0; i < 3; i++) {
cout << "ref[" << i << "].p = " << ref[i].p << endl;
}
cout << endl;
// copy constructor, and alternate form of copy constructor
cout << "person count before copy construct= " << Person::get_count() << endl;
Person p2(p);
cout << "p2: " << p2 << endl;
cout << "person count after copy construct= " << Person::get_count() << endl;
cout << endl;
cout << "person count before copy alternate construct= " << Person::get_count() << endl;
Person p3 = p;
cout << "p3: " << p3 << endl;
cout << "person count after alternate copy construct= " << Person::get_count() << endl;
cout << endl;
// object assignment
Person p4;
cout << "default person p4: " << p4 << endl;
p4 = p;
cout << "person p4 after assignment: " << p4 << endl;
p4 = p4;
cout << "person p4 after self assignment: " << p4 << endl;
cout << endl;
// const object
const Person p5("Const", "Person", 9,9,9);
cout << "const person " << p5 << endl;
// ERROR p5 = p;
cout << endl;
// terminating
cout << "program terminating" << endl;
cout << endl;
}
bool Date::operator==(const Date &date) const {
return (this->mod_julian_day() == date.mod_julian_day());
}
void test_conversions(void)
{
printf("test_conversions - start");
Date d;
printf("test_conversions - date <--> time_t");
// Date <--> time_t
time_t t;
t = time(NULL);
d.SetValue(t);
d.SetCurrent();
t = d;
printf("test_conversions - date <--> struct tm*");
// Date <--> struct tm*
struct tm* stm;
t = time(NULL);
stm = localtime(&t);
d.SetValue(stm);
d.SetCurrent();
const struct tm* cstm = d;
printf("test_conversions - date <--> xmlChar*");
// Date <--> xmlChar*
xmlChar* xmlc = (xmlChar*)xmlMalloc(24);
memcpy(xmlc, "2002/10/30 10:33:00", 19);
d.SetValue(xmlc);
const xmlChar* cxmlc = d;
printf("test_conversions - date <--> char*");
// Date <--> char*
char* c = "2002/10/30 10:33:00";
d.SetValue(c);
const char* cc = d;
#ifdef _WIN32
/*
// Date <--> CTime
CTime ct;
d.SetValue(ct);
ct = (CTime)d;
// Date <--> COleDateTime
COleDateTime codt;
d.SetValue(codt);
codt = (COleDateTime)d;
// Date <--> DATE
DATE D;
d.SetValue(D);
D = d;
*/
#endif _WIN32
printf("test_conversions - done");
}
int main (void)
{
Date ad;
Date bd;
Date cd;
printf("ad is (%s)\n", ad.GetValue()());
printf("ad is also (%s)\n", ad.GetValue("%Y-%m-%d-%H-%M-%S")());
bd.SetValue("07/13/2001 01:02:03.456", "%m/%d/%Y %H:%M:%S");
printf("bd is (%s)\n", bd.GetValue()());
printf("bd is also (%s)\n", bd.GetValue("%m/%d/%Y %H:%M:%S")());
printf("bd is also (%s)\n", bd.GetValue("%Y%m%d%H%M%S")());
printf("bd is also (%s)\n", bd.EDate()());
printf("bd is also (%s)\n", bd.EDate()());
printf("bd is also (%s)\n", bd.EDate()());
printf("bd is also (%s)\n", bd.EDate()());
twine tmp, tmp2;
tmp2 = bd.EDate();
tmp.format("Date: %s\r\n", tmp2() );
printf("%s\n", tmp());
printf("Before direct format\n");
tmp.format("Date: %s\r\n", bd.GetValue("%Y%m%d%H%M%S")() );
printf("After direct format\n");
printf("%s", tmp() );
printf("Before EDate format\n");
tmp.format("Date: %s\r\n", bd.EDate()() );
printf("After EDate format\n");
printf("%s", tmp() );
ad.Floor();
bd = ad;
bd.Ceil();
printf("ad is (%s) bd is (%s)\n", ad.GetValue()(), bd.GetValue()());
cd.SetValue("7/4/2001", "%m/%d/%Y");
printf("cd is (%s)\n", cd.GetValue()());
cd.SetValue("7/4/89", "%m/%d/%Y");
printf("cd is (%s)\n", cd.GetValue()());
cd.SetValue("7/4/01", "%m/%d/%Y");
printf("cd is (%s)\n", cd.GetValue()());
cd.SetValue("20010714080910.123", "%Y%m%d%H%M%S");
printf("cd is (%s)\n", cd.GetValue()());
cd.SetValue("2001/09/01 00:08:05");
printf("Initial cd is (%s)\n", cd.GetValue()());
cd.AddSec(-65);
printf("cd is (%s)\n", cd.GetValue()());
ad.SetValue("2001/08/09 12:00:00");
bd.SetValue("2001/08/09 12:30:00");
if(bd - ad > SLib::Interval(10, MINUTES)){
printf("(%s) - (%s) has a difference greater than 10 minutes\n",
bd.GetValue()(), ad.GetValue()());
}
if(bd - ad > SLib::Interval(20, MINUTES)){
printf("(%s) - (%s) has a difference greater than 20 minutes\n",
bd.GetValue()(), ad.GetValue()());
}
if(bd - ad > SLib::Interval(1, DAY)){
printf("(%s) - (%s) has a difference greater than 1 day\n",
bd.GetValue()(), ad.GetValue()());
}
test_conversions();
return 0;
}
bool China::SseImpl::isBusinessDay(const Date& date) const {
Weekday w = date.weekday();
Day d = date.dayOfMonth();
Month m = date.month();
Year y = date.year();
if (isWeekend(w)
// New Year's Day
|| (d == 1 && m == January)
|| (y == 2005 && d == 3 && m == January)
|| (y == 2006 && (d == 2 || d == 3) && m == January)
|| (y == 2007 && d <= 3 && m == January)
|| (y == 2007 && d == 31 && m == December)
|| (y == 2009 && d == 2 && m == January)
|| (y == 2011 && d == 3 && m == January)
|| (y == 2012 && (d == 2 || d == 3) && m == January)
|| (y == 2013 && d <= 3 && m == January)
|| (y == 2014 && d == 1 && m == January)
// Chinese New Year
|| (y == 2004 && d >= 19 && d <= 28 && m == January)
|| (y == 2005 && d >= 7 && d <= 15 && m == February)
|| (y == 2006 && ((d >= 26 && m == January) ||
(d <= 3 && m == February)))
|| (y == 2007 && d >= 17 && d <= 25 && m == February)
|| (y == 2008 && d >= 6 && d <= 12 && m == February)
|| (y == 2009 && d >= 26 && d <= 30 && m == January)
|| (y == 2010 && d >= 15 && d <= 19 && m == January)
|| (y == 2011 && d >= 2 && d <= 8 && m == February)
|| (y == 2012 && d >= 23 && d <= 28 && m == January)
|| (y == 2013 && d >= 11 && d <= 15 && m == February)
|| (y == 2014 && d >= 31 && m == January)
|| (y == 2014 && d <= 6 && m == February)
// Ching Ming Festival
|| (y <= 2008 && d == 4 && m == April)
|| (y == 2009 && d == 6 && m == April)
|| (y == 2010 && d == 5 && m == April)
|| (y == 2011 && d >=3 && d <= 5 && m == April)
|| (y == 2012 && d >= 2 && d <= 4 && m == April)
|| (y == 2013 && d >= 4 && d <= 5 && m == April)
|| (y == 2014 && d == 7 && m == April)
// Labor Day
|| (y <= 2007 && d >= 1 && d <= 7 && m == May)
|| (y == 2008 && d >= 1 && d <= 2 && m == May)
|| (y == 2009 && d == 1 && m == May)
|| (y == 2010 && d == 3 && m == May)
|| (y == 2011 && d == 2 && m == May)
|| (y == 2012 && ((d == 30 && m == April) ||
(d == 1 && m == May)))
|| (y == 2013 && ((d >= 29 && m == April) ||
(d == 1 && m == May)))
|| (y == 2014 && d >= 1 && d <=3 && m == May)
// Tuen Ng Festival
|| (y <= 2008 && d == 9 && m == June)
|| (y == 2009 && (d == 28 || d == 29) && m == May)
|| (y == 2010 && d >= 14 && d <= 16 && m == June)
|| (y == 2011 && d >= 4 && d <= 6 && m == June)
|| (y == 2012 && d >= 22 && d <= 24 && m == June)
|| (y == 2013 && d >= 10 && d <= 12 && m == June)
|| (y == 2014 && d == 2 && m == June)
// Mid-Autumn Festival
|| (y <= 2008 && d == 15 && m == September)
|| (y == 2010 && d >= 22 && d <= 24 && m == September)
|| (y == 2011 && d >= 10 && d <= 12 && m == September)
|| (y == 2012 && d == 30 && m == September)
|| (y == 2013 && d >= 19 && d <= 20 && m == September)
|| (y == 2014 && d == 8 && m == September)
// National Day
|| (y <= 2007 && d >= 1 && d <= 7 && m == October)
|| (y == 2008 && ((d >= 29 && m == September) ||
(d <= 3 && m == October)))
|| (y == 2009 && d >= 1 && d <= 8 && m == October)
|| (y == 2010 && d >= 1 && d <= 7 && m == October)
|| (y == 2011 && d >= 1 && d <= 7 && m == October)
|| (y == 2012 && d >= 1 && d <= 7 && m == October)
|| (y == 2013 && d >= 1 && d <= 7 && m == October)
|| (y == 2014 && d >= 1 && d <= 7 && m == October)
)
return false;
return true;
}
// Get the number of days between the two given dates.
int Date::operator-(const Date &other) const
{
return DaysSinceEpoch() - other.DaysSinceEpoch();
}
int StatServ::GetFieldValue(int iFieldID,TFieldValue * pTFieldValue)
{
char sTemp[200];
int iValue;
static Date date;
class OrgMgr orgmgr;
//基本域
switch ( iFieldID){
case FA_S_ORG_LEVELID100:
{
if (pServ!=NULL){
int iOrgID=pServ->getOrgID(date.toString());
int iOrgLevelID=-1;
for (;iOrgID>=0;){
iOrgLevelID=orgmgr.getLevel(iOrgID);
if (iOrgLevelID==100)
break;
iOrgID=orgmgr.getParentID(iOrgID);
}
if (iOrgLevelID==100)
pTFieldValue->AutoSetValue(iOrgID);
else
pTFieldValue->SetDefaultValue();
}
else{
pTFieldValue->SetDefaultValue();
}
}
break;
case FA_S_ORG_LEVELID200:
{
if (pServ!=NULL){
int iOrgID=pServ->getOrgID(date.toString());
int iOrgLevelID=-1;
for (;iOrgID>=0;){
iOrgLevelID=orgmgr.getLevel(iOrgID);
if (iOrgLevelID==200)
break;
iOrgID=orgmgr.getParentID(iOrgID);
}
if (iOrgLevelID==200)
pTFieldValue->AutoSetValue(iOrgID);
else
pTFieldValue->SetDefaultValue();
}
else{
pTFieldValue->SetDefaultValue();
}
}
break;
case FA_S_ORG_LEVELID300:
{
if (pServ!=NULL){
int iOrgID=pServ->getOrgID(date.toString());
int iOrgLevelID=-1;
for (;iOrgID>=0;){
iOrgLevelID=orgmgr.getLevel(iOrgID);
if (iOrgLevelID==300)
break;
iOrgID=orgmgr.getParentID(iOrgID);
}
if (iOrgLevelID==300)
pTFieldValue->AutoSetValue(iOrgID);
else
pTFieldValue->SetDefaultValue();
}
else{
pTFieldValue->SetDefaultValue();
}
}
break;
case FA_S_ORG_LEVELID400:
{
if (pServ!=NULL){
int iOrgID=pServ->getOrgID(date.toString());
int iOrgLevelID=-1;
for (;iOrgID>=0;){
iOrgLevelID=orgmgr.getLevel(iOrgID);
if (iOrgLevelID==400)
break;
iOrgID=orgmgr.getParentID(iOrgID);
}
if (iOrgLevelID==400)
pTFieldValue->AutoSetValue(iOrgID);
else
pTFieldValue->SetDefaultValue();
}
else{
pTFieldValue->SetDefaultValue();
}
}
break;
case FA_S_ORG_LEVELID500:
{
if (pServ!=NULL){
int iOrgID=pServ->getOrgID(date.toString());
int iOrgLevelID=-1;
for (;iOrgID>=0;){
iOrgLevelID=orgmgr.getLevel(iOrgID);
if (iOrgLevelID==500)
break;
iOrgID=orgmgr.getParentID(iOrgID);
}
if (iOrgLevelID==500)
pTFieldValue->AutoSetValue(iOrgID);
else
pTFieldValue->SetDefaultValue();
}
else{
pTFieldValue->SetDefaultValue();
}
}
break;
case FA_S_SERV_CREATE_DATE:
strncpy(sTemp,pservinfo->m_sCreateDate,8);
sTemp[8]='\0';
if (pservinfo)
pTFieldValue->AutoSetValue(sTemp);
else
pTFieldValue->SetDefaultValue();
break;
case FA_S_STATE_DATE:
strncpy(sTemp,pservinfo->m_sStateDate,8);
sTemp[8]='\0';
if (pservinfo)
pTFieldValue->AutoSetValue(sTemp);
else
pTFieldValue->SetDefaultValue();
break;
case FA_S_PRODUCT_ID:
if (pservinfo)
pTFieldValue->AutoSetValue(pservinfo->m_iProductID);
else
pTFieldValue->SetDefaultValue();
break;
case FA_S_BILLING_MODE:
if (pservinfo)
pTFieldValue->AutoSetValue(pservinfo->m_iBillingMode);
else
pTFieldValue->SetDefaultValue();
break;
case FA_S_CUST_TYPE_ID:
if (pcustinfo)
pTFieldValue->AutoSetValue(pcustinfo->m_sCustType);
else
pTFieldValue->SetDefaultValue();
break;
case FA_S_STATE:
if (pservinfo)
pTFieldValue->AutoSetValue(pservinfo->m_sState);
else
pTFieldValue->SetDefaultValue();
break;
case FA_S_OFFER_ID:
if (pServ){
static int offers[MAX_OFFERS];
static int iCnt=0;
static int i=0;
if (i==iCnt){
iCnt=pServ->getOffers(offers,date.toString());
i=0;
if (iCnt==0){
pTFieldValue->SetDefaultValue();
break;
}
}
pTFieldValue->AutoSetValue(offers[i++]);
if(i!=iCnt)
return 1;
}
else
pTFieldValue->SetDefaultValue();
break;
case FA_S_AGENT_ID:/*?待定?*/
break;
case FA_S_SERV_CNT:
if (pTFieldValue->ValType==VT_INT)
pTFieldValue->SetValue(1);
else if ( pTFieldValue->ValType==VT_STRING)
throw TException("SERV_CNT:不能为string型，请修改统计配置!");
break;
case FA_S_SERV_ID:
pTFieldValue->AutoSetValue(pRead->Get_SERV_ID());
break;
case FA_S_ACCT_ID:
default :
return -1;
}
return 0;
}
void printDate(Date d)
{
cout << d.year() << "-" << d.month() << "-" << d.day() << endl;
}
int CmdTimesheet::execute (std::string& output)
{
int rc = 0;
// Scan the pending tasks.
handleRecurrence ();
std::vector <Task> all = context.tdb2.all_tasks ();
context.tdb2.commit ();
// What day of the week does the user consider the first?
int weekStart = Date::dayOfWeek (context.config.get ("weekstart"));
if (weekStart != 0 && weekStart != 1)
throw std::string (STRING_DATE_BAD_WEEKSTART);
// Determine the date of the first day of the most recent report.
Date today;
Date start;
start -= (((today.dayOfWeek () - weekStart) + 7) % 7) * 86400;
// Roll back to midnight.
start = Date (start.month (), start.day (), start.year ());
Date end = start + (7 * 86400);
// Determine how many reports to run.
int quantity = 1;
std::vector <std::string> words = context.a3.extract_words ();
if (words.size () == 1)
quantity = strtol (words[0].c_str (), NULL, 10);;
std::stringstream out;
for (int week = 0; week < quantity; ++week)
{
Date endString (end);
endString -= 86400;
std::string title = start.toString (context.config.get ("dateformat"))
+ " - "
+ endString.toString (context.config.get ("dateformat"));
Color bold (Color::nocolor, Color::nocolor, false, true, false);
out << "\n"
<< (context.color () ? bold.colorize (title) : title)
<< "\n";
// Render the completed table.
ViewText completed;
completed.width (context.getWidth ());
completed.add (Column::factory ("string", " "));
completed.add (Column::factory ("string", STRING_COLUMN_LABEL_PROJECT));
completed.add (Column::factory ("string.right", STRING_COLUMN_LABEL_DUE));
completed.add (Column::factory ("string", STRING_COLUMN_LABEL_DESC));
std::vector <Task>::iterator task;
for (task = all.begin (); task != all.end (); ++task)
{
// If task completed within range.
if (task->getStatus () == Task::completed)
{
Date compDate (task->get_date ("end"));
if (compDate >= start && compDate < end)
{
Color c;
if (context.color ())
autoColorize (*task, c);
int row = completed.addRow ();
std::string format = context.config.get ("dateformat.report");
if (format == "")
format = context.config.get ("dateformat");
completed.set (row, 1, task->get ("project"), c);
if(task->has ("due"))
{
Date dt (task->get_date ("due"));
completed.set (row, 2, dt.toString (format));
}
std::string description = task->get ("description");
int indent = context.config.getInteger ("indent.annotation");
std::map <std::string, std::string> annotations;
task->getAnnotations (annotations);
std::map <std::string, std::string>::iterator ann;
for (ann = annotations.begin (); ann != annotations.end (); ++ann)
description += "\n"
+ std::string (indent, ' ')
+ Date (ann->first.substr (11)).toString (context.config.get ("dateformat"))
+ " "
+ ann->second;
completed.set (row, 3, description, c);
}
}
}
out << " " << format (STRING_CMD_TIMESHEET_DONE, completed.rows ()) << "\n";
if (completed.rows ())
out << completed.render ()
<< "\n";
// Now render the started table.
ViewText started;
started.width (context.getWidth ());
started.add (Column::factory ("string", " "));
started.add (Column::factory ("string", STRING_COLUMN_LABEL_PROJECT));
started.add (Column::factory ("string.right", STRING_COLUMN_LABEL_DUE));
started.add (Column::factory ("string", STRING_COLUMN_LABEL_DESC));
for (task = all.begin (); task != all.end (); ++task)
{
// If task started within range, but not completed withing range.
if (task->getStatus () == Task::pending &&
task->has ("start"))
{
Date startDate (task->get_date ("start"));
if (startDate >= start && startDate < end)
{
Color c;
if (context.color ())
autoColorize (*task, c);
int row = started.addRow ();
std::string format = context.config.get ("dateformat.report");
if (format == "")
format = context.config.get ("dateformat");
started.set (row, 1, task->get ("project"), c);
if(task->has ("due"))
{
Date dt (task->get_date ("due"));
started.set (row, 2, dt.toString (format));
}
std::string description = task->get ("description");
int indent = context.config.getInteger ("indent.annotation");
std::map <std::string, std::string> annotations;
task->getAnnotations (annotations);
std::map <std::string, std::string>::iterator ann;
for (ann = annotations.begin (); ann != annotations.end (); ++ann)
description += "\n"
+ std::string (indent, ' ')
+ Date (ann->first.substr (11)).toString (context.config.get ("dateformat"))
+ " "
+ ann->second;
started.set (row, 3, description, c);
}
}
}
out << " " << format (STRING_CMD_TIMESHEET_STARTED, started.rows ()) << "\n";
if (started.rows ())
out << started.render ()
<< "\n\n";
// Prior week.
start -= 7 * 86400;
end -= 7 * 86400;
}
output = out.str ();
return rc;
}
int DayOfWeek(Date date) {
return (date.Get() + 6) % 7;
}
int CmdInfo::execute (std::string& output)
{
int rc = 0;
// Apply filter.
std::vector <Task> filtered;
filter (filtered);
if (! filtered.size ())
{
context.footnote (STRING_FEEDBACK_NO_MATCH);
rc = 1;
}
// Get the undo data.
std::vector <std::string> undo;
if (context.config.getBoolean ("journal.info"))
undo = context.tdb2.undo.get_lines ();
// Determine the output date format, which uses a hierarchy of definitions.
// rc.dateformat.info
// rc.dateformat
std::string dateformat = context.config.get ("dateformat.info");
if (dateformat == "")
dateformat = context.config.get ("dateformat");
std::string dateformatanno = context.config.get ("dateformat.annotation");
if (dateformatanno == "")
dateformatanno = dateformat;
// Render each task.
std::stringstream out;
std::vector <Task>::iterator task;
for (task = filtered.begin (); task != filtered.end (); ++task)
{
ViewText view;
view.width (context.getWidth ());
view.add (Column::factory ("string", STRING_COLUMN_LABEL_NAME));
view.add (Column::factory ("string", STRING_COLUMN_LABEL_VALUE));
// If an alternating row color is specified, notify the table.
if (context.color ())
{
Color alternate (context.config.get ("color.alternate"));
view.colorOdd (alternate);
view.intraColorOdd (alternate);
}
Date now;
// id
int row = view.addRow ();
view.set (row, 0, STRING_COLUMN_LABEL_ID);
view.set (row, 1, (task->id ? format (task->id) : "-"));
std::string status = ucFirst (Task::statusToText (task->getStatus ()));
// description
Color c;
autoColorize (*task, c);
std::string description = task->get ("description");
int indent = context.config.getInteger ("indent.annotation");
std::map <std::string, std::string> annotations;
task->getAnnotations (annotations);
std::map <std::string, std::string>::iterator ann;
for (ann = annotations.begin (); ann != annotations.end (); ++ann)
description += "\n"
+ std::string (indent, ' ')
+ Date (ann->first.substr (11)).toString (dateformatanno)
+ " "
+ ann->second;
row = view.addRow ();
view.set (row, 0, STRING_COLUMN_LABEL_DESC);
view.set (row, 1, description, c);
// status
row = view.addRow ();
view.set (row, 0, STRING_COLUMN_LABEL_STATUS);
view.set (row, 1, status);
// project
if (task->has ("project"))
{
row = view.addRow ();
view.set (row, 0, STRING_COLUMN_LABEL_PROJECT);
view.set (row, 1, task->get ("project"));
}
// priority
if (task->has ("priority"))
{
row = view.addRow ();
view.set (row, 0, STRING_COLUMN_LABEL_PRIORITY);
view.set (row, 1, task->get ("priority"));
}
// dependencies: blocked
{
std::vector <Task> blocked;
dependencyGetBlocking (*task, blocked);
if (blocked.size ())
{
std::stringstream message;
std::vector <Task>::const_iterator it;
for (it = blocked.begin (); it != blocked.end (); ++it)
message << it->id << " " << it->get ("description") << "\n";
row = view.addRow ();
view.set (row, 0, STRING_CMD_INFO_BLOCKED);
view.set (row, 1, message.str ());
}
}
// dependencies: blocking
{
std::vector <Task> blocking;
dependencyGetBlocked (*task, blocking);
if (blocking.size ())
{
std::stringstream message;
std::vector <Task>::const_iterator it;
for (it = blocking.begin (); it != blocking.end (); ++it)
message << it->id << " " << it->get ("description") << "\n";
row = view.addRow ();
view.set (row, 0, STRING_CMD_INFO_BLOCKING);
view.set (row, 1, message.str ());
}
}
// recur
if (task->has ("recur"))
{
row = view.addRow ();
view.set (row, 0, STRING_COLUMN_LABEL_RECUR_L);
view.set (row, 1, task->get ("recur"));
}
// until
if (task->has ("until"))
{
row = view.addRow ();
view.set (row, 0, STRING_CMD_INFO_UNTIL);
view.set (row, 1, Date (task->get_date ("until")).toString (dateformat));
}
// mask
if (task->getStatus () == Task::recurring)
{
row = view.addRow ();
view.set (row, 0, STRING_COLUMN_LABEL_MASK);
view.set (row, 1, task->get ("mask"));
}
if (task->has ("parent"))
{
// parent
row = view.addRow ();
view.set (row, 0, STRING_COLUMN_LABEL_PARENT);
view.set (row, 1, task->get ("parent"));
// imask
row = view.addRow ();
view.set (row, 0, STRING_COLUMN_LABEL_MASK_IDX);
view.set (row, 1, task->get ("imask"));
}
// due (colored)
if (task->has ("due"))
{
row = view.addRow ();
view.set (row, 0, STRING_COLUMN_LABEL_DUE);
view.set (row, 1, Date (task->get_date ("due")).toString (dateformat));
}
// wait
if (task->has ("wait"))
{
row = view.addRow ();
view.set (row, 0, STRING_COLUMN_LABEL_WAITING);
view.set (row, 1, Date (task->get_date ("wait")).toString (dateformat));
}
// scheduled
if (task->has ("scheduled"))
{
row = view.addRow ();
view.set (row, 0, STRING_COLUMN_LABEL_SCHED);
view.set (row, 1, Date (task->get_date ("scheduled")).toString (dateformat));
}
// start
if (task->has ("start"))
{
row = view.addRow ();
view.set (row, 0, STRING_COLUMN_LABEL_START);
view.set (row, 1, Date (task->get_date ("start")).toString (dateformat));
}
// end
if (task->has ("end"))
{
row = view.addRow ();
view.set (row, 0, STRING_COLUMN_LABEL_END);
view.set (row, 1, Date (task->get_date ("end")).toString (dateformat));
}
// tags ...
std::vector <std::string> tags;
task->getTags (tags);
if (tags.size ())
{
std::string allTags;
join (allTags, " ", tags);
row = view.addRow ();
view.set (row, 0, STRING_COLUMN_LABEL_TAGS);
view.set (row, 1, allTags);
}
// uuid
row = view.addRow ();
view.set (row, 0, STRING_COLUMN_LABEL_UUID);
std::string uuid = task->get ("uuid");
view.set (row, 1, uuid);
// entry
row = view.addRow ();
view.set (row, 0, STRING_COLUMN_LABEL_ENTERED);
Date dt (task->get_date ("entry"));
std::string entry = dt.toString (dateformat);
std::string age;
std::string created = task->get ("entry");
if (created.length ())
{
Date dt (strtol (created.c_str (), NULL, 10));
age = Duration (now - dt).format ();
}
view.set (row, 1, entry + " (" + age + ")");
// fg TODO deprecated 2.0
std::string color = task->get ("fg");
if (color != "")
{
row = view.addRow ();
view.set (row, 0, STRING_COLUMN_LABEL_FG);
view.set (row, 1, color);
}
// bg TODO deprecated 2.0
color = task->get ("bg");
if (color != "")
{
row = view.addRow ();
view.set (row, 0, STRING_COLUMN_LABEL_BG);
view.set (row, 1, color);
}
// Task::urgency
row = view.addRow ();
view.set (row, 0, STRING_COLUMN_LABEL_URGENCY);
view.set (row, 1, trimLeft (format (task->urgency (), 4, 4)));
// Show any UDAs
std::vector <std::string> all = task->all ();
std::vector <std::string>::iterator att;
std::string type;
for (att = all.begin (); att != all.end (); ++att)
{
type = context.config.get ("uda." + *att + ".type");
if (type != "")
{
Column* col = context.columns[*att];
if (col)
{
std::string value = task->get (*att);
if (value != "")
{
row = view.addRow ();
view.set (row, 0, col->label ());
if (type == "date")
value = Date (value).toString (dateformat);
else if (type == "duration")
value = Duration (value).formatCompact ();
view.set (row, 1, value);
}
}
}
}
// Show any orphaned UDAs, which are identified by not being represented in
// the context.columns map.
for (att = all.begin (); att != all.end (); ++att)
if (att->substr (0, 11) != "annotation_" &&
context.columns.find (*att) == context.columns.end ())
{
row = view.addRow ();
view.set (row, 0, "[" + *att);
view.set (row, 1, task->get (*att) + "]");
}
// Create a second table, containing undo log change details.
ViewText journal;
// If an alternating row color is specified, notify the table.
if (context.color ())
{
Color alternate (context.config.get ("color.alternate"));
journal.colorOdd (alternate);
journal.intraColorOdd (alternate);
}
journal.width (context.getWidth ());
journal.add (Column::factory ("string", STRING_COLUMN_LABEL_DATE));
journal.add (Column::factory ("string", STRING_CMD_INFO_MODIFICATION));
if (context.config.getBoolean ("journal.info") &&
undo.size () > 3)
{
// Scan the undo data for entries matching this task.
std::string when;
std::string previous;
std::string current;
unsigned int i = 0;
long total_time = 0;
while (i < undo.size ())
{
when = undo[i++];
previous = "";
if (undo[i].substr (0, 3) == "old")
previous = undo[i++];
current = undo[i++];
i++; // Separator
if (current.find ("uuid:\"" + uuid) != std::string::npos)
{
if (previous != "")
{
int row = journal.addRow ();
Date timestamp (strtol (when.substr (5).c_str (), NULL, 10));
journal.set (row, 0, timestamp.toString (dateformat));
Task before (previous.substr (4));
Task after (current.substr (4));
journal.set (row, 1, taskInfoDifferences (before, after, dateformat));
// calculate the total active time
if (before.get ("start") == ""
&& after.get ("start") != "")
{
// task started
total_time -= timestamp.toEpoch ();
}
else if (((before.get ("start") != "" &&
after.get ("start") == "") ||
(before.get ("status") != "completed" &&
after.get ("status") == "completed")) &&
total_time < 0)
{
// task stopped or done
total_time += timestamp.toEpoch ();
}
}
}
}
// add now() if task is still active
if (total_time < 0)
total_time += Date ().toEpoch ();
// print total active time
if (total_time > 0)
{
row = journal.addRow ();
journal.set (row, 0, STRING_CMD_INFO_TOTAL_ACTIVE);
journal.set (row, 1, Duration (total_time).formatPrecise (),
(context.color () ? Color ("bold") : Color ()));
}
}
out << optionalBlankLine ()
<< view.render ()
<< "\n";
if (journal.rows () > 0)
out << journal.render ()
<< "\n";
}
output = out.str ();
return rc;
}
int main (int argc, char** argv)
{
#ifdef NIBBLER_FEATURE_DATE
#ifdef NIBBLER_FEATURE_REGEX
UnitTest t (382);
#else
UnitTest t (358);
#endif
#else
#ifdef NIBBLER_FEATURE_REGEX
UnitTest t (332);
#else
UnitTest t (308);
#endif
#endif
try
{
Nibbler n;
std::string s;
int i;
double d;
time_t ti;
#ifdef NIBBLER_FEATURE_DATE
Date dt;
#endif
std::vector <std::string> options;
// Make sure the nibbler behaves itself with trivial input.
t.diag ("Test all nibbler calls given empty input");
n = Nibbler ("");
t.notok (n.getUntil (' ', s), "trivial: getUntil");
t.notok (n.getUntil ("hi", s), "trivial: getUntil");
t.notok (n.getUntilOneOf ("ab", s), "trivial: getUntilOneOf");
t.notok (n.skipN (123), "trivial: skipN");
t.notok (n.skip ('x'), "trivial: skip");
t.notok (n.skipAll ('x'), "trivial: skipAll");
t.notok (n.skipAllOneOf ("abc"), "trivial: skipAllOneOf");
t.notok (n.getQuoted ('"', s), "trivial: getQuoted");
t.notok (n.getDigit (i), "trivial: getDigit");
t.notok (n.getInt (i), "trivial: getInt"); // 10
t.notok (n.getHex (i), "trivial: getHex");
t.notok (n.getUnsignedInt (i), "trivial: getUnsignedInt");
t.notok (n.getUntilEOL (s), "trivial: getUntilEOL");
t.notok (n.getUntilEOS (s), "trivial: getUntilEOS");
t.notok (n.getDateISO (ti), "trivial: getDateISO");
#ifdef NIBBLER_FEATURE_DATE
t.notok (n.getDate ("YYYYMMDD", ti), "trivial: getDate");
#endif
t.notok (n.getOneOf (options, s), "trivial: getOneOf");
t.ok (n.depleted (), "trivial: depleted");
// bool getUntil (char, std::string&);
t.diag ("Nibbler::getUntil");
n = Nibbler ("one two");
t.ok (n.getUntil (' ', s), " 'one two' : getUntil (' ') -> true");
t.is (s, "one", " 'one two' : getUntil (' ') -> 'one'"); // 20
t.ok (n.getUntil (' ', s), " ' two' : getUntil (' ') -> true");
t.is (s, "", " ' two' : getUntil (' ') -> ''");
t.ok (n.skip (' '), " ' two' : skip (' ') -> true");
t.ok (n.getUntil (' ', s), " 'two' : getUntil (' ') -> 'two'");
t.notok (n.getUntil (' ', s), " '' : getUntil (' ') -> false");
t.ok (n.depleted (), " '' : depleted () -> true");
#ifdef NIBBLER_FEATURE_REGEX
// bool getUntilRx (const std::string&, std::string&);
t.diag ("Nibbler::getUntilRx");
n = Nibbler ("one two");
t.ok (n.getUntilRx ("th", s), " 'one two' : getUntilRx ('th') -> true");
t.is (s, "one two", " 'one two' : getUntilRx ('th') -> 'one two'");
n = Nibbler ("one two");
t.ok (n.getUntilRx ("e", s), " 'one two' : getUntilRx ('e') -> true");
t.is (s, "on", " 'one two' : getUntilRx ('e') -> 'on'"); // 30
t.ok (n.getUntilRx ("tw", s), " 'e two' : getUntilRx ('tw') -> true");
t.is (s, "e ", " 'e two' : getUntilRx ('tw') -> 'e '");
t.ok (n.getUntilRx ("$", s), " 'two' : getUntilRx ('$') -> true");
t.is (s, "two", " 'two' : getUntilRx ('$') -> 'two'");
t.ok (n.depleted (), " '' : depleted () -> true");
#endif
// bool getUntilOneOf (const std::string&, std::string&);
t.diag ("Nibbler::getUntilOneOf");
n = Nibbler ("ab.cd");
t.ok (n.getUntilOneOf (".:", s), " 'ab.cd' : getUntilOneOf ('.:') -> true");
t.is (s, "ab", " 'ab.cd' : getUntilOneOf ('.:') -> 'ab'");
t.ok (n.skipN (), " '.cd' : skipN () -> true");
t.ok (n.getUntilOneOf (".:", s), " 'cd' : getUntilOneOf ('.:') -> true");
t.notok (n.getUntilOneOf (".:", s), " '' : getUntilOneOf ('.:') -> false");
t.ok (n.depleted (), " '' : depleted () -> true");
// bool getUntil (const std::string&, std::string&);
t.diag ("Nibbler::getUntil");
n = Nibbler ("ab\r\ncd");
t.ok (n.getUntil ("\r\n", s), "'ab\\r\\ncd' : getUntil ('\\r\\n') -> true");
t.ok (n.skipN (2), " '\\r\\ncd' : skipN (2) -> true");
t.ok (n.getUntil ("\r\n", s), " 'cd' : getUntil ('\\r\\n') -> true");
t.ok (n.depleted (), " '' : depleted () -> true");
// bool getUntilWS (std::string&);
t.diag ("Nibbler::getUntilWS");
n = Nibbler ("ab \t\ncd");
t.ok (n.getUntilWS (s), " 'ab \\t\\ncd' : getUntilWS () -> true");
t.is (s, "ab", " 'ab \\t\\ncd' : getUntilWS () -> 'ab'");
t.ok (n.getUntilWS (s), " ' \\t\\ncd' : getUntilWS () -> true");
t.is (s, "", " ' \\t\\ncd' : getUntilWS () -> ''");
t.ok (n.skipWS (), " 'cd' : skipWS () -> true");
t.ok (n.getUntilWS (s), " '' : getUntilWS () -> true");
t.is (s, "cd", " 'cd' : getUntilWS () -> 'cd'");
t.ok (n.depleted (), " '' : depleted () -> true");
// bool skipN (const int quantity = 1);
t.diag ("Nibbler::skipN");
n = Nibbler ("abcde");
t.ok (n.skipN (), " 'abcde' : skipN () -> true");
t.ok (n.skipN (2), " 'bcde' : skipN (2 -> true");
t.notok (n.skipN (3), " 'de' : skipN (3 -> false");
t.notok (n.depleted (), " 'de' : depleted () -> true");
// bool skip (char);
t.diag ("Nibbler::skip");
n = Nibbler (" a");
t.ok (n.skip (' '), " ' a' : skip (' ') -> true");
t.ok (n.skip (' '), " ' a' : skip (' ') -> true");
t.notok (n.skip (' '), " 'a' : skip (' ') -> false");
t.notok (n.depleted (), " 'a' : depleted () -> false");
t.ok (n.skip ('a'), " 'a' : skip ('a') -> true");
t.ok (n.depleted (), " '' : depleted () -> true");
// bool skipAll (char);
t.diag ("Nibbler::skipAll");
n = Nibbler ("aaaabb");
t.ok (n.skipAll ('a'), " 'aaaabb' : skipAll ('a') -> true");
t.notok (n.skipAll ('a'), " 'bb' : skipAll ('a') -> false");
t.ok (n.skipAll ('b'), " 'bb' : skipAll ('b') -> true");
t.notok (n.skipAll ('b'), " '' : skipAll ('b') -> false");
t.ok (n.depleted (), " '' : depleted () -> true");
// bool skipAllOneOf (const std::string&);
t.diag ("Nibbler::skipAllOneOf");
n = Nibbler ("abababcc");
t.ok (n.skipAllOneOf ("ab"), "'abababcc' : skipAllOneOf ('ab') -> true");
t.notok (n.skipAllOneOf ("ab"), " 'cc' : skipAllOneOf ('ab') -> false");
t.ok (n.skipAllOneOf ("c"), " 'cc' : skipAllOneOf ('ab') -> false");
t.ok (n.depleted (), " '' : depleted () -> true");
// bool skipWS ();
t.diag ("Nibbler::skipWS");
n = Nibbler (" \tfoo");
t.ok (n.skipWS (), " ' \\tfoo' : skipWS () -> true");
t.notok (n.skipWS (), " 'foo' : skipWS () -> false");
t.ok (n.getUntilEOS (s), " 'foo' : getUntilEOS () -> true");
t.is (s, "foo", " 'foo' : getUntilEOS () -> 'foo'");
t.ok (n.depleted (), " '' : depleted () -> true");
#ifdef NIBBLER_FEATURE_REGEX
// bool skipRx (const std::string&);
t.diag ("Nibbler::skipRx");
n = Nibbler ("one two");
t.ok (n.skipRx ("o."), " 'one two' : skipRx ('o.') -> true");
t.notok (n.skipRx ("A+"), " 'e two' : skipRx ('A+') -> false");
t.ok (n.skipRx ("e+"), " 'e two' : skipRx ('e+') -> true");
t.ok (n.skipRx ("...."), " ' two' : skipRx ('....') -> true");
t.ok (n.depleted (), " '' : depleted () -> true");
#endif
// bool getQuoted (char, std::string&);
t.diag ("Nibbler::getQuoted");
n = Nibbler ("''");
t.ok (n.getQuoted ('\'', s), " '''' : getQuoted (''') -> true");
t.is (s, "", " '''' : getQuoted (''') -> ''");
n = Nibbler ("'\"'");
t.ok (n.getQuoted ('\'', s), " ''\"'' : getQuoted (''') -> true");
t.is (s, "\"", " ''\"'' : getQuoted (''') -> '\"'");
n = Nibbler ("'x'");
t.ok (n.getQuoted ('\'', s), " ''x'' : getQuoted (''') -> true");
t.is (s, "x", " ''x'' : getQuoted (''') -> ''");
n = Nibbler ("'x");
t.notok (n.getQuoted ('\'', s), " ''x' : getQuoted (''') -> false");
n = Nibbler ("x");
t.notok (n.getQuoted ('\'', s), " 'x' : getQuoted (''') -> false"); // 90
n = Nibbler ("\"one\\\"two\"");
t.notok (n.getQuoted ('\'', s), "\"one\\\"two\" : getQuoted (''') -> false");
n = Nibbler ("\"one\\\"two\"");
t.ok (n.getQuoted ('"', s, false), "\"one\\\"two\" : getQuoted ('\"', false, false) -> true");
t.is (s, "one\\\"two", "getQuoted ('\"', false) -> one\\\"two");
n = Nibbler ("\"one\\\"two\"");
t.ok (n.getQuoted ('"', s, true), "\"one\\\"two\" : getQuoted ('\"', false, true) -> true");
t.is (s, "\"one\\\"two\"", "getQuoted ('\"', true) -> \"one\\\"two\"");
n = Nibbler ("\"one\\\"two\"");
t.ok (n.getQuoted ('"', s, false), "\"one\\\"two\" : getQuoted ('\"', true, false) -> true");
t.is (s, "one\\\"two", "getQuoted ('\"', false) -> one\\\"two");
n = Nibbler ("\"one\\\"two\"");
t.ok (n.getQuoted ('"', s, true), "\"one\\\"two\" : getQuoted ('\"', s, true) -> true");
t.is (s, "\"one\\\"two\"", "getQuoted ('\"', s, true) -> \"one\\\"two\"");
n = Nibbler ("\"one\\\\\"");
t.ok (n.getQuoted ('\"', s, true), "\"one\\\" : getQuoted ('\"', s, true) -> true");
t.is (s, "\"one\\\\\"", "getQuoted ('\"', s, true) -> \"one\\\\\"");
n = Nibbler ("\"one\\\\\"");
t.ok (n.getQuoted ('\"', s, false), "one\\ : getQuoted ('\"', s, false) -> true");
t.is (s, "one\\\\", "getQuoted ('\"', s, false) -> \"one\\\\\"");
// bool getDigit (int&);
t.diag ("Nibbler::getDigit");
n = Nibbler ("12x");
t.ok (n.getDigit (i), " '12x' : getDigit () -> true");
t.is (i, 1, " '12x' : getDigit () -> 1");
t.ok (n.getDigit (i), " '2x' : getDigit () -> true");
t.is (i, 2, " '2x' : getDigit () -> 2");
t.notok (n.getDigit (i), " 'x' : getDigit () -> false");
// bool getInt (int&);
t.diag ("Nibbler::getInt");
n = Nibbler ("123 -4");
t.ok (n.getInt (i), " '123 -4' : getInt () -> true");
t.is (i, 123, " '123 -4' : getInt () -> '123'");
t.ok (n.skip (' '), " ' -4' : skip (' ') -> true");
t.ok (n.getInt (i), " '-4' : getInt () -> true");
t.is (i, -4, " '-4' : getInt () -> '-4'");
t.ok (n.depleted (), " '' : depleted () -> true");
// bool getHex (int&);
t.diag ("Nibbler::getHex");
n = Nibbler ("123 7b");
t.ok (n.getHex (i), " '123 7b' : getHex () -> true");
t.is (i, 291, " '123 7b' : getHex () -> '291'");
t.ok (n.skip (' '), " ' 7b' : skip (' ') -> true");
t.ok (n.getHex (i), " '7b' : getHex () -> true");
t.is (i, 123, " '7b' : getHex () -> '123'");
t.ok (n.depleted (), " '' : depleted () -> true");
// bool getUnsignedInt (int&i);
t.diag ("Nibbler::getUnsignedInt");
n = Nibbler ("123 4");
t.ok (n.getUnsignedInt (i), " '123 4' : getUnsignedInt () -> true");
t.is (i, 123, " '123 4' : getUnsignedInt () -> '123'");
t.ok (n.skip (' '), " ' 4' : skip (' ') -> true");
t.ok (n.getUnsignedInt (i), " '4' : getUnsignedInt () -> true");
t.is (i, 4, " '4' : getUnsignedInt () -> '4'");
t.ok (n.depleted (), " '' : depleted () -> true");
// bool getNumber (double&);
t.diag ("Nibbler::getNumber");
n = Nibbler ("-1.234 2.3e4");
t.ok (n.getNumber (d), "'-1.234 2.3e4' : getNumber () -> true");
t.is (d, -1.234, 0.000001, "'-1.234 2.3e4' : getNumber () -> '-1.234'");
t.ok (n.skip (' '), " ' 2.3e4' : skip (' ') -> true");
t.ok (n.getNumber (d), " '2.3e4' : getNumber () -> true");
t.is (d, 2.3e4, " '2.3e4' : getNumber () -> '2.3e4'");
t.ok (n.depleted (), " '' : depleted () -> true");
n = Nibbler ("2.0");
t.ok (n.getNumber (d), "'2.0' : getNumber () -> true");
t.is (d, 2.0, 0.000001, "'2.0' : getNumber () -> '2.0'");
t.ok (n.depleted (), " '' : depleted () -> true");
n = Nibbler ("-864000.00000");
t.ok (n.getNumber (d), "'-864000.00000' : getNumber () -> true");
t.is (d, -864000.0, "'-864000.00000' : getNumber () -> -864000.0");
t.ok (n.depleted (), " '' : depleted () -> true");
// bool getLiteral (const std::string&);
t.diag ("Nibbler::getLiteral");
n = Nibbler ("foobar");
t.ok (n.getLiteral ("foo"), " 'foobar' : getLiteral ('foo') -> true");
t.notok (n.getLiteral ("foo"), " 'bar' : getLiteral ('foo') -> false");
t.ok (n.getLiteral ("bar"), " 'bar' : getLiteral ('bar') -> true");
t.ok (n.depleted (), " '' : depleted () -> true");
#ifdef NIBBLER_FEATURE_REGEX
// bool getRx (const std::string&, std::string&);
t.diag ("Nibbler::getRx");
n = Nibbler ("one two three");
t.ok (n.getRx ("^(o..)", s), "'one two three' : getRx ('^(o..)') -> true");
t.is (s, "one", "'one two three' : getRx ('^(o..)') -> 'one'");
t.ok (n.skip (' '), " ' two three' : skip (' ') -> true");
t.ok (n.getRx ("t..", s), " 'two three' : getRx ('t..') -> true");
t.is (s, "two", " 'two three' : getRx ('t..') -> 'two'");
t.notok (n.getRx ("th...", s), " ' three' : getRx ('th...') -> false");
t.ok (n.skip (' '), " ' three' : skip (' ') -> true");
t.ok (n.getRx ("th...", s), " 'three' : getRx ('th...') -> true");
t.is (s, "three", " 'three' : getRx ('th...') -> 'three'");
t.ok (n.depleted (), " '' : depleted () -> true");
#endif
// bool getUUID (std::string&);
t.diag ("Nibbler::getUUID");
n = Nibbler ("a0b1c2d3-e4f5-A6B7-C8D9-E0F1a2b3c4d5");
t.ok (n.getUUID (s), "uuid 1 found");
t.is (s, "a0b1c2d3-e4f5-A6B7-C8D9-E0F1a2b3c4d5", "uuid 1 -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("00000000-0000-0000-0000-000000000000,a0b1c2d3-e4f5-A6B7-C8D9-E0F1a2b3c4d5");
t.ok (n.getUUID (s), "uuid 1 found");
t.is (s, "00000000-0000-0000-0000-000000000000", "uuid 1 -> correct");
t.ok (n.skip (','), "comma -> skipped");
t.ok (n.getUUID (s), "uuid 2 -> found");
t.is (s, "a0b1c2d3-e4f5-A6B7-C8D9-E0F1a2b3c4d5", "uuid 2 -> correct");
t.ok (n.depleted (), "depleted");
// bool getPartialUUID (std::string&);
t.diag ("Nibbler::getPartialUUID");
n = Nibbler ("a0b1c2d3-e4f5-A6B7-C8D9-E0F1a2b3c4d5");
t.ok (n.getPartialUUID (s), "partial uuid [36] found");
t.is (s, "a0b1c2d3-e4f5-A6B7-C8D9-E0F1a2b3c4d5", "partial uuid [36] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5-A6B7-C8D9-E0F1a2b3c4d");
t.ok (n.getPartialUUID (s), "partial uuid [35] found");
t.is (s, "a0b1c2d3-e4f5-A6B7-C8D9-E0F1a2b3c4d", "partial uuid [35] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5-A6B7-C8D9-E0F1a2b3c4");
t.ok (n.getPartialUUID (s), "partial uuid [34] found");
t.is (s, "a0b1c2d3-e4f5-A6B7-C8D9-E0F1a2b3c4", "partial uuid [34] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5-A6B7-C8D9-E0F1a2b3c");
t.ok (n.getPartialUUID (s), "partial uuid [33] found");
t.is (s, "a0b1c2d3-e4f5-A6B7-C8D9-E0F1a2b3c", "partial uuid [33] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5-A6B7-C8D9-E0F1a2b3");
t.ok (n.getPartialUUID (s), "partial uuid [32] found");
t.is (s, "a0b1c2d3-e4f5-A6B7-C8D9-E0F1a2b3", "partial uuid [32] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5-A6B7-C8D9-E0F1a2b");
t.ok (n.getPartialUUID (s), "partial uuid [31] found");
t.is (s, "a0b1c2d3-e4f5-A6B7-C8D9-E0F1a2b", "partial uuid [31] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5-A6B7-C8D9-E0F1a2");
t.ok (n.getPartialUUID (s), "partial uuid [30] found");
t.is (s, "a0b1c2d3-e4f5-A6B7-C8D9-E0F1a2", "partial uuid [30] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5-A6B7-C8D9-E0F1a");
t.ok (n.getPartialUUID (s), "partial uuid [29] found");
t.is (s, "a0b1c2d3-e4f5-A6B7-C8D9-E0F1a", "partial uuid [29] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5-A6B7-C8D9-E0F1");
t.ok (n.getPartialUUID (s), "partial uuid [28] found");
t.is (s, "a0b1c2d3-e4f5-A6B7-C8D9-E0F1", "partial uuid [28] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5-A6B7-C8D9-E0F");
t.ok (n.getPartialUUID (s), "partial uuid [27] found");
t.is (s, "a0b1c2d3-e4f5-A6B7-C8D9-E0F", "partial uuid [27] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5-A6B7-C8D9-E0");
t.ok (n.getPartialUUID (s), "partial uuid [26] found");
t.is (s, "a0b1c2d3-e4f5-A6B7-C8D9-E0", "partial uuid [26] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5-A6B7-C8D9-E");
t.ok (n.getPartialUUID (s), "partial uuid [25] found");
t.is (s, "a0b1c2d3-e4f5-A6B7-C8D9-E", "partial uuid [25] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5-A6B7-C8D9-");
t.ok (n.getPartialUUID (s), "partial uuid [24] found");
t.is (s, "a0b1c2d3-e4f5-A6B7-C8D9-", "partial uuid [24] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5-A6B7-C8D9");
t.ok (n.getPartialUUID (s), "partial uuid [23] found");
t.is (s, "a0b1c2d3-e4f5-A6B7-C8D9", "partial uuid [23] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5-A6B7-C8D");
t.ok (n.getPartialUUID (s), "partial uuid [22] found");
t.is (s, "a0b1c2d3-e4f5-A6B7-C8D", "partial uuid [22] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5-A6B7-C8");
t.ok (n.getPartialUUID (s), "partial uuid [21] found");
t.is (s, "a0b1c2d3-e4f5-A6B7-C8", "partial uuid [21] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5-A6B7-C");
t.ok (n.getPartialUUID (s), "partial uuid [20] found");
t.is (s, "a0b1c2d3-e4f5-A6B7-C", "partial uuid [20] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5-A6B7-");
t.ok (n.getPartialUUID (s), "partial uuid [19] found");
t.is (s, "a0b1c2d3-e4f5-A6B7-", "partial uuid [19] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5-A6B7");
t.ok (n.getPartialUUID (s), "partial uuid [18] found");
t.is (s, "a0b1c2d3-e4f5-A6B7", "partial uuid [18] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5-A6B");
t.ok (n.getPartialUUID (s), "partial uuid [17] found");
t.is (s, "a0b1c2d3-e4f5-A6B", "partial uuid [17] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5-A6");
t.ok (n.getPartialUUID (s), "partial uuid [16] found");
t.is (s, "a0b1c2d3-e4f5-A6", "partial uuid [16] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5-A");
t.ok (n.getPartialUUID (s), "partial uuid [15] found");
t.is (s, "a0b1c2d3-e4f5-A", "partial uuid [15] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5-");
t.ok (n.getPartialUUID (s), "partial uuid [14] found");
t.is (s, "a0b1c2d3-e4f5-", "partial uuid [14] -> correct");
t.ok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f5");
t.notok (n.getPartialUUID (s), "partial uuid [13] not found");
t.notok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4f");
t.notok (n.getPartialUUID (s), "partial uuid [12] not found");
t.notok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e4");
t.notok (n.getPartialUUID (s), "partial uuid [11] not found");
t.notok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-e");
t.notok (n.getPartialUUID (s), "partial uuid [10] not found");
t.notok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3-");
t.notok (n.getPartialUUID (s), "partial uuid [9] not found");
t.notok (n.depleted (), "depleted");
n = Nibbler ("a0b1c2d3");
t.notok (n.getPartialUUID (s), "partial uuid [8] not found");
t.notok (n.depleted (), "not depleted");
// bool getDateISO (time_t&);
t.diag ("Nibbler::getDateISO");
n = Nibbler ("19980119T070000Z");
t.ok (n.getDateISO (ti), "'19980119T070000Z': getDateISO () -> true");
t.is (ti, 885193200, "'19980119T070000Z': getDateISO () -> 885193200");
t.ok (n.depleted (), "depleted");
n = Nibbler ("20090213T233130Z");
t.ok (n.getDateISO (ti), "'20090213T233130Z': getDateISO () -> true");
t.is (ti, 1234567890, "'20090213T233130Z': getDateISO () -> 1234567890");
t.ok (n.depleted (), "depleted");
#ifdef NIBBLER_FEATURE_DATE
// bool getDate (time_t&, const std::string&);
t.diag ("Nibbler::getDate");
n = Nibbler ("1/1/2008");
t.ok (n.getDate ("m/d/Y", ti), "m/d/Y ok");
dt = Date (ti);
t.is (dt.month (), 1, "ctor (std::string) -> m");
t.is (dt.day (), 1, "ctor (std::string) -> d");
t.is (dt.year (), 2008, "ctor (std::string) -> y");
n = Nibbler ("20080101");
t.ok (n.getDate ("YMD", ti), "YMD ok");
dt = Date (ti);
t.is (dt.month (), 1, "ctor (std::string) -> m");
t.is (dt.day (), 1, "ctor (std::string) -> d");
t.is (dt.year (), 2008, "ctor (std::string) -> y");
n = Nibbler ("12/31/2007");
t.ok (n.getDate ("m/d/Y", ti), "m/d/Y ok");
dt = Date (ti);
t.is (dt.month (), 12, "ctor (std::string) -> m");
t.is (dt.day (), 31, "ctor (std::string) -> d");
t.is (dt.year (), 2007, "ctor (std::string) -> y");
n = Nibbler ("20071231");
t.ok (n.getDate ("YMD", ti), "YMD ok");
dt = Date (ti);
t.is (dt.month (), 12, "ctor (std::string) -> m");
t.is (dt.day (), 31, "ctor (std::string) -> d");
t.is (dt.year (), 2007, "ctor (std::string) -> y");
n = Nibbler ("Tue 01 Jan 2008 (01)");
t.ok (n.getDate ("a D b Y (V)", ti), "a D b Y (V)");
dt = Date (ti);
t.is (dt.month (), 1, "ctor (std::string) -> m");
t.is (dt.day (), 1, "ctor (std::string) -> d");
t.is (dt.year (), 2008, "ctor (std::string) -> y");
n = Nibbler ("Tuesday, January 1, 2008");
t.ok (n.getDate ("A, B d, Y", ti), "A, B d, Y ok");
dt = Date (ti);
t.is (dt.month (), 1, "ctor (std::string) -> m");
t.is (dt.day (), 1, "ctor (std::string) -> d");
t.is (dt.year (), 2008, "ctor (std::string) -> y");
n = Nibbler ("v01 Tue 2008-01-01");
t.ok (n.getDate ("vV a Y-M-D", ti), "vV a Y-M-D ok");
dt = Date (ti);
t.is (dt.month (), 1, "ctor (std::string) -> m");
t.is (dt.day (), 1, "ctor (std::string) -> d");
t.is (dt.year (), 2008, "ctor (std::string) -> y");
n = Nibbler ("6/7/2010 1:23:45");
t.ok (n.getDate ("m/d/Y h:N:S", ti), "m/d/Y h:N:S ok");
dt = Date (ti);
t.is (dt.month (), 6, "ctor (std::string) -> m");
t.is (dt.day (), 7, "ctor (std::string) -> d");
t.is (dt.year (), 2010, "ctor (std::string) -> Y");
t.is (dt.hour (), 1, "ctor (std::string) -> h");
t.is (dt.minute (), 23, "ctor (std::string) -> N");
t.is (dt.second (), 45, "ctor (std::string) -> S");
n = Nibbler ("6/7/2010 01:23:45");
t.ok (n.getDate ("m/d/Y H:N:S", ti), "m/d/Y H:N:S ok");
dt = Date (ti);
t.is (dt.month (), 6, "ctor (std::string) -> m");
t.is (dt.day (), 7, "ctor (std::string) -> d");
t.is (dt.year (), 2010, "ctor (std::string) -> Y");
t.is (dt.hour (), 1, "ctor (std::string) -> h");
t.is (dt.minute (), 23, "ctor (std::string) -> N");
t.is (dt.second (), 45, "ctor (std::string) -> S");
n = Nibbler ("6/7/2010 12:34:56");
t.ok (n.getDate ("m/d/Y H:N:S", ti), "m/d/Y H:N:S ok");
dt = Date (ti);
t.is (dt.month (), 6, "ctor (std::string) -> m");
t.is (dt.day (), 7, "ctor (std::string) -> d");
t.is (dt.year (), 2010, "ctor (std::string) -> Y");
t.is (dt.hour (), 12, "ctor (std::string) -> h");
t.is (dt.minute (), 34, "ctor (std::string) -> N");
t.is (dt.second (), 56, "ctor (std::string) -> S");
#endif
// bool getOneOf (const std::vector <std::string>&, std::string&);
t.diag ("Nibbler::getOneOf");
options.push_back ("one");
options.push_back ("two");
options.push_back ("three");
n = Nibbler ("onetwothreefour");
t.ok (n.getOneOf (options, s), "'onetwothreefour': getOneOf () -> true");
t.is (s, "one", "'onetwothreefour': getOneOf () -> one");
t.ok (n.getOneOf (options, s), " 'twothreefour': getOneOf () -> true");
t.is (s, "two", " 'twothreefour': getOneOf () -> two");
t.ok (n.getOneOf (options, s), " 'threefour': getOneOf () -> true");
t.is (s, "three", " 'threefour': getOneOf () -> three");
t.notok (n.getOneOf (options, s), " 'four': getOneOf () -> false");
// bool getName (std::string&);
t.diag ("Nibbler::getName");
n = Nibbler ("a1 one one.two 9");
t.ok (n.getName (s), "'a1 one one.two 9' getName -> ok");
t.is (s, "a1", " ' one one.two 9' getName -> 'a1'");
t.ok (n.skipWS (), " 'one one.two 9' skipWS -> ok");
t.ok (n.getName (s), " 'one one.two 9' getName -> ok");
t.is (s, "one", " ' one.two 9' getName -> 'one'");
t.ok (n.skipWS (), " 'one.two 9' skipWS -> ok");
t.ok (n.getName (s), " 'one.two 9' getName -> ok");
t.is (s, "one", " '.two 9' getName -> 'one'");
t.ok (n.skip ('.'), " 'two 9' skip . -> ok");
t.ok (n.getName (s), " 'two 9' getName -> ok");
t.is (s, "two", " ' 9' getName -> 'two'");
t.ok (n.skipWS (), " '9' skipWS -> ok");
t.notok (n.getName (s), " '9' getName -> not ok");
t.ok (n.skip ('9'), " '' skip 9 -> ok");
t.ok (n.depleted (), "depleted");
n = Nibbler ("entrée");
t.ok (n.getName (s), "'entrée' -> ok");
t.is (s, "entrée", "'entrée' -> 'entrée'");
// bool getWord (std::string&);
t.diag ("Nibbler::getWord");
n = Nibbler ("one two th3ee");
t.ok (n.getWord (s), "'one' getWord -> ok");
t.is (s, "one", "'one' getWord -> 'one'");
t.ok (n.skipWS (), "skipWS");
t.ok (n.getWord (s), "'two' getWord -> ok");
t.is (s, "two", "'two' getWord -> 'two'");
t.ok (n.skipWS (), "skipWS");
t.ok (n.getWord (s), "'th' getWord -> ok");
t.is (s, "th", "'th' getWord -> 'th'");
t.ok (n.skip ('3'), "skip(3)");
t.ok (n.getWord (s), "'ee' getWord -> ok");
t.is (s, "ee", "'ee' getWord -> 'ee'");
t.ok (n.depleted (), "depleted");
t.diag ("Nibbler::getWord");
n = Nibbler ("one TWO,three,f ");
t.ok (n.getWord (s), "'one TWO,three,f ' getWord -> ok");
t.is (s, "one", " ' TWO,three,f ' getWord -> one");
t.ok (n.skipWS (), " 'TWO,three,f ' skipWS -> ok");
t.ok (n.getWord (s), " 'TWO,three,f ' getWord -> ok");
t.is (s, "TWO", " ',three,f ' getWord -> TWO");
t.ok (n.skip (','), " 'three,f ' skip , -> ok");
t.ok (n.getWord (s), " 'three,f ' getWord -> ok");
t.is (s, "three", " ',f ' getWord -> three");
t.ok (n.skip (','), " 'f ' skip , -> ok");
t.ok (n.getWord (s), " 'f ' getWord -> ok");
t.is (s, "f", " ' ' getWord -> f");
t.ok (n.skipWS (), " '' skip , -> ok");
t.ok (n.depleted (), " '' depleted -> true");
// bool getN (int, std::string&);
t.diag ("Nibbler::getN");
n = Nibbler ("111223");
t.ok (n.getN (3, s), " '111223' : getN (3) -> true");
t.is (s, "111", " '111223' : getN (3) -> '111'");
t.ok (n.getN (2, s), " '223' : getN (2) -> true");
t.is (s, "22", " '223' : getN (2) -> '22'");
t.ok (n.getN (1, s), " '3' : getN (1) -> true");
t.is (s, "3", " '3' : getN (1) -> '1'");
t.ok (n.depleted (), " '' : depleted () -> true");
// bool getUntilEOL (std::string&);
t.diag ("Nibbler::getUntilEOL");
n = Nibbler ("one\ntwo");
t.ok (n.getUntilEOL (s), "'one\\ntwo' : getUntilEOL () -> true");
t.is (s, "one", "'one\\ntwo' : getUntilEOL () -> 'one'");
t.ok (n.skip ('\n'), " '\\ntwo' : skip ('\\n') -> true");
t.ok (n.getUntilEOL (s), " 'two' : getUntilEOL () -> true");
t.is (s, "two", " 'two' : getUntilEOL () -> 'two'");
t.ok (n.depleted (), " '' : depleted () -> true");
// bool getUntilEOS (std::string&);
t.diag ("Nibbler::getUntilEOS");
n = Nibbler ("one two");
t.ok (n.getUntilEOS (s), " 'one two' : getUntilEOS () -> 'one two'");
t.ok (n.depleted (), " '' : depleted () -> true");
// char next ();
t.diag ("Nibbler::next");
n = Nibbler ("hello");
t.is (n.next (), 'h', " 'hello' : next () -> 'h'");
t.is (n.next (), 'h', " 'hello' : next () -> 'h'");
t.ok (n.skipN (4), " 'hello' : skipN (4) -> true");
t.is (n.next (), 'o', " 'o' : next () -> 'o'");
t.ok (n.skipN (1), " 'o' : skipN () -> true");
t.ok (n.depleted (), " '' : depleted () -> true");
// std::string next (const int quantity);
t.diag ("Nibbler::next");
n = Nibbler ("hello");
t.is (n.next (1), "h", " 'hello' : next (1) -> 'h'");
t.is (n.next (1), "h", " 'hello' : next (1) -> 'h'");
t.is (n.next (2), "he", " 'hello' : next (2) -> 'he'");
t.is (n.next (3), "hel", " 'hello' : next (3) -> 'hel'");
t.is (n.next (4), "hell", " 'hello' : next (4) -> 'hell'");
t.is (n.next (5), "hello", " 'hello' : next (5) -> 'hello'");
t.is (n.next (6), "", " 'hello' : next (6) -> ''");
// bool depleted ();
t.diag ("Nibbler::depleted");
n = Nibbler (" ");
t.notok (n.depleted (), " ' ' : depleted () -> false");
t.ok (n.skipN (), " '' : skip () -> true");
t.ok (n.depleted (), " '' : depleted () -> true");
// void save ();
// void restore ();
n = Nibbler ("abcde");
t.ok (n.skipN (), " 'abcde' : skip () -> true");
n.save ();
t.ok (n.skipN (), " 'bcde' : skip () -> true");
t.ok (n.skipN (), " 'cde' : skip () -> true");
t.ok (n.skipN (), " 'de' : skip () -> true");
n.restore ();
t.is (n.next (1), "b", " 'bcde' : skip () -> 'b'");
}
catch (std::string& e) {t.diag (e);}
return 0;
}
Event* ICalendar::Query::GetNextEvent(bool WithAlarm) {
static Event *RecurrentEvent = NULL;
/* not all events have DtEnd, but we need some DtEnd for various checks,
so we will use this for temporary DtEnd derived from DtStart (following
RFC 2445, 4.6.1) */
Date DtEnd;
unsigned long Difference;
unsigned short Rest;
if (RecurrentEvent != NULL) {
RecurrentEvent->DtStart[RecurrentEvent->RRule.Freq] += RecurrentEvent->RRule.Interval;
if (!RecurrentEvent->DtEnd.IsEmpty())
RecurrentEvent->DtEnd[RecurrentEvent->RRule.Freq] += RecurrentEvent->RRule.Interval;
++RecurrentEvent->RecurrenceNo;
if (
(!WithAlarm &&
RecurrentEvent->DtStart <= Criteria.To &&
(RecurrentEvent->RRule.Until.IsEmpty() || RecurrentEvent->RRule.Until >= RecurrentEvent->DtStart) &&
(RecurrentEvent->RRule.Count == 0 || RecurrentEvent->RecurrenceNo < RecurrentEvent->RRule.Count)) ||
(WithAlarm && RecurrentEvent->HasAlarm(Criteria.From, Criteria.To))
) {
RecurrentEvents.push_back(new Event(*RecurrentEvent));
return RecurrentEvents.back();
}
delete RecurrentEvent;
RecurrentEvent = NULL;
}
if (RecurrentEvent == NULL) {
for (; EventsIterator != Calendar->Events.end(); ++EventsIterator) {
if ((*EventsIterator)->DtEnd.IsEmpty()) {
DtEnd = (*EventsIterator)->DtStart;
if ((*EventsIterator)->DtStart.WithTime == false)
++DtEnd[DAY];
} else {
DtEnd = (*EventsIterator)->DtEnd;
}
if (
Criteria.AllEvents == true || (
!WithAlarm &&
// DtEnd is non-inclusive (according to RFC 2445)
(DtEnd > Criteria.From || (*EventsIterator)->DtStart >= Criteria.From) &&
(*EventsIterator)->DtStart <= Criteria.To
) ||
(WithAlarm && (*EventsIterator)->HasAlarm(Criteria.From, Criteria.To))
) {
if (Criteria.AllEvents == false && Criteria.IncludeRecurrent == true && (*EventsIterator)->RRule.IsEmpty() == false)
RecurrentEvent = new Event(**EventsIterator);
return *(EventsIterator++);
} else if (
(*EventsIterator)->RRule.IsEmpty() == false &&
(*EventsIterator)->DtStart < Criteria.From &&
((*EventsIterator)->RRule.Until.IsEmpty() || (*EventsIterator)->RRule.Until >= Criteria.From) &&
Criteria.IncludeRecurrent == true
) {
RecurrentEvent = new Event(**EventsIterator);
Difference = Criteria.From.Difference(DtEnd, RecurrentEvent->RRule.Freq);
Rest = Difference%RecurrentEvent->RRule.Interval;
if (Rest != 0)
Difference += RecurrentEvent->RRule.Interval - Rest;
cout << Criteria.From.Format() << endl;
cout << DtEnd.Format() << endl;
cout << Difference << endl;
RecurrentEvent->DtStart[RecurrentEvent->RRule.Freq] += Difference;
DtEnd[RecurrentEvent->RRule.Freq] += Difference;
RecurrentEvent->RecurrenceNo = Difference / RecurrentEvent->RRule.Interval;
// <= because DtEnd is non-inclusive (according to RFC 2445)
while (DtEnd <= Criteria.From) {
RecurrentEvent->DtStart[RecurrentEvent->RRule.Freq] += RecurrentEvent->RRule.Interval;
DtEnd[RecurrentEvent->RRule.Freq] += RecurrentEvent->RRule.Interval;
++RecurrentEvent->RecurrenceNo;
}
if (
(!WithAlarm &&
RecurrentEvent->DtStart <= Criteria.To &&
// < because DtStart counts as the first occurence
(RecurrentEvent->RRule.Count == 0 || RecurrentEvent->RecurrenceNo < RecurrentEvent->RRule.Count)) ||
(WithAlarm && RecurrentEvent->HasAlarm(Criteria.From, Criteria.To))
) {
++EventsIterator;
if (!RecurrentEvent->DtEnd.IsEmpty())
RecurrentEvent->DtEnd = DtEnd;
RecurrentEvents.push_back(new Event(*RecurrentEvent));
return RecurrentEvents.back();
}
delete RecurrentEvent;
RecurrentEvent = NULL;
}
}
}
return NULL;
}
unsigned int Date::operator-(const Date &date) const {
return (((int) this->mod_julian_day()) - ((int) date.mod_julian_day()));
}
int CmdHistoryMonthly::execute (std::string& output)
{
int rc = 0;
std::map <time_t, int> groups; // Represents any month with data
std::map <time_t, int> addedGroup; // Additions by month
std::map <time_t, int> completedGroup; // Completions by month
std::map <time_t, int> deletedGroup; // Deletions by month
// Apply filter.
handleRecurrence ();
Filter filter;
std::vector <Task> filtered;
filter.subset (filtered);
std::vector <Task>::iterator task;
for (task = filtered.begin (); task != filtered.end (); ++task)
{
Date entry (task->get_date ("entry"));
Date end;
if (task->has ("end"))
end = Date (task->get_date ("end"));
time_t epoch = entry.startOfMonth ().toEpoch ();
groups[epoch] = 0;
// Every task has an entry date.
++addedGroup[epoch];
// All deleted tasks have an end date.
if (task->getStatus () == Task::deleted)
{
epoch = end.startOfMonth ().toEpoch ();
groups[epoch] = 0;
++deletedGroup[epoch];
}
// All completed tasks have an end date.
else if (task->getStatus () == Task::completed)
{
epoch = end.startOfMonth ().toEpoch ();
groups[epoch] = 0;
++completedGroup[epoch];
}
}
// Now build the view.
ViewText view;
view.width (context.getWidth ());
view.add (Column::factory ("string", STRING_CMD_HISTORY_YEAR));
view.add (Column::factory ("string", STRING_CMD_HISTORY_MONTH));
view.add (Column::factory ("string.right", STRING_CMD_HISTORY_ADDED));
view.add (Column::factory ("string.right", STRING_CMD_HISTORY_COMP));
view.add (Column::factory ("string.right", STRING_CMD_HISTORY_DEL));
view.add (Column::factory ("string.right", STRING_CMD_HISTORY_NET));
Color label (context.config.get ("color.label"));
view.colorHeader (label);
int totalAdded = 0;
int totalCompleted = 0;
int totalDeleted = 0;
int priorYear = 0;
int row = 0;
std::map <time_t, int>::iterator i;
for (i = groups.begin (); i != groups.end (); ++i)
{
row = view.addRow ();
totalAdded += addedGroup [i->first];
totalCompleted += completedGroup [i->first];
totalDeleted += deletedGroup [i->first];
Date dt (i->first);
int m, d, y;
dt.toMDY (m, d, y);
if (y != priorYear)
{
view.set (row, 0, y);
priorYear = y;
}
view.set (row, 1, Date::monthName(m));
int net = 0;
if (addedGroup.find (i->first) != addedGroup.end ())
{
view.set (row, 2, addedGroup[i->first]);
net +=addedGroup[i->first];
}
if (completedGroup.find (i->first) != completedGroup.end ())
{
view.set (row, 3, completedGroup[i->first]);
net -= completedGroup[i->first];
}
if (deletedGroup.find (i->first) != deletedGroup.end ())
{
view.set (row, 4, deletedGroup[i->first]);
net -= deletedGroup[i->first];
}
Color net_color;
if (context.color () && net)
net_color = net > 0
? Color (Color::red)
: Color (Color::green);
view.set (row, 5, net, net_color);
}
if (view.rows ())
{
row = view.addRow ();
view.set (row, 0, " ");
row = view.addRow ();
Color row_color;
if (context.color ())
row_color = Color (Color::nocolor, Color::nocolor, false, true, false);
view.set (row, 1, STRING_CMD_HISTORY_AVERAGE, row_color);
view.set (row, 2, totalAdded / (view.rows () - 2), row_color);
view.set (row, 3, totalCompleted / (view.rows () - 2), row_color);
view.set (row, 4, totalDeleted / (view.rows () - 2), row_color);
view.set (row, 5, (totalAdded - totalCompleted - totalDeleted) / (view.rows () - 2), row_color);
}
std::stringstream out;
if (view.rows ())
out << optionalBlankLine ()
<< view.render ()
<< "\n";
else
{
context.footnote (STRING_FEEDBACK_NO_TASKS);
rc = 1;
}
output = out.str ();
return rc;
}
bool Date::operator<(const Date &date) const {
return this->mod_julian_day() < date.mod_julian_day();
}
int CmdGHistoryAnnual::execute (std::string& output)
{
int rc = 0;
std::map <time_t, int> groups; // Represents any month with data
std::map <time_t, int> addedGroup; // Additions by month
std::map <time_t, int> completedGroup; // Completions by month
std::map <time_t, int> deletedGroup; // Deletions by month
// Apply filter.
handleRecurrence ();
Filter filter;
std::vector <Task> filtered;
filter.subset (filtered);
std::vector <Task>::iterator task;
for (task = filtered.begin (); task != filtered.end (); ++task)
{
Date entry (task->get_date ("entry"));
Date end;
if (task->has ("end"))
end = Date (task->get_date ("end"));
time_t epoch = entry.startOfYear ().toEpoch ();
groups[epoch] = 0;
// Every task has an entry date.
++addedGroup[epoch];
// All deleted tasks have an end date.
if (task->getStatus () == Task::deleted)
{
epoch = end.startOfYear ().toEpoch ();
groups[epoch] = 0;
++deletedGroup[epoch];
}
// All completed tasks have an end date.
else if (task->getStatus () == Task::completed)
{
epoch = end.startOfYear ().toEpoch ();
groups[epoch] = 0;
++completedGroup[epoch];
}
}
int widthOfBar = context.getWidth () - 5; // 5 == strlen ("YYYY ")
// Now build the view.
ViewText view;
view.width (context.getWidth ());
view.add (Column::factory ("string", STRING_CMD_GHISTORY_YEAR));
view.add (Column::factory ("string.left_fixed", STRING_CMD_GHISTORY_NUMBER));
Color color_add (context.config.get ("color.history.add"));
Color color_done (context.config.get ("color.history.done"));
Color color_delete (context.config.get ("color.history.delete"));
Color label (context.config.get ("color.label"));
view.colorHeader (label);
// Determine the longest line, and the longest "added" line.
int maxAddedLine = 0;
int maxRemovedLine = 0;
std::map <time_t, int>::iterator i;
for (i = groups.begin (); i != groups.end (); ++i)
{
if (completedGroup[i->first] + deletedGroup[i->first] > maxRemovedLine)
maxRemovedLine = completedGroup[i->first] + deletedGroup[i->first];
if (addedGroup[i->first] > maxAddedLine)
maxAddedLine = addedGroup[i->first];
}
int maxLine = maxAddedLine + maxRemovedLine;
if (maxLine > 0)
{
unsigned int leftOffset = (widthOfBar * maxAddedLine) / maxLine;
int totalAdded = 0;
int totalCompleted = 0;
int totalDeleted = 0;
int priorYear = 0;
int row = 0;
std::map <time_t, int>::iterator i;
for (i = groups.begin (); i != groups.end (); ++i)
{
row = view.addRow ();
totalAdded += addedGroup[i->first];
totalCompleted += completedGroup[i->first];
totalDeleted += deletedGroup[i->first];
Date dt (i->first);
int m, d, y;
dt.toMDY (m, d, y);
if (y != priorYear)
{
view.set (row, 0, y);
priorYear = y;
}
unsigned int addedBar = (widthOfBar * addedGroup[i->first]) / maxLine;
unsigned int completedBar = (widthOfBar * completedGroup[i->first]) / maxLine;
unsigned int deletedBar = (widthOfBar * deletedGroup[i->first]) / maxLine;
std::string bar = "";
if (context.color ())
{
std::string aBar = "";
if (addedGroup[i->first])
{
aBar = format (addedGroup[i->first]);
while (aBar.length () < addedBar)
aBar = " " + aBar;
}
std::string cBar = "";
if (completedGroup[i->first])
{
cBar = format (completedGroup[i->first]);
while (cBar.length () < completedBar)
cBar = " " + cBar;
}
std::string dBar = "";
if (deletedGroup[i->first])
{
dBar = format (deletedGroup[i->first]);
while (dBar.length () < deletedBar)
dBar = " " + dBar;
}
bar += std::string (leftOffset - aBar.length (), ' ');
bar += color_add.colorize (aBar);
bar += color_done.colorize (cBar);
bar += color_delete.colorize (dBar);
}
else
{
std::string aBar = ""; while (aBar.length () < addedBar) aBar += "+";
std::string cBar = ""; while (cBar.length () < completedBar) cBar += "X";
std::string dBar = ""; while (dBar.length () < deletedBar) dBar += "-";
bar += std::string (leftOffset - aBar.length (), ' ');
bar += aBar + cBar + dBar;
}
view.set (row, 1, bar);
}
}
std::stringstream out;
if (view.rows ())
{
out << optionalBlankLine ()
<< view.render ()
<< "\n";
if (context.color ())
out << format (STRING_CMD_HISTORY_LEGEND,
color_add.colorize (STRING_CMD_HISTORY_ADDED),
color_done.colorize (STRING_CMD_HISTORY_COMP),
color_delete.colorize (STRING_CMD_HISTORY_DEL))
<< optionalBlankLine ()
<< "\n";
else
out << STRING_CMD_HISTORY_LEGEND_A
<< "\n";
}
else
{
context.footnote (STRING_FEEDBACK_NO_TASKS);
rc = 1;
}
output = out.str ();
return rc;
}
bool operator<(Date a, Date b) {
return a.Compare(b) < 0;
}
bool Run(requestFormatter* request) {
astrologyPlanetSet* natalPlanetSet = m_natal->getPlanetSet();
astrologyHouseSet* natalHouseSet = m_natal->getHouseSet();
double houseLongitude = natalHouseSet->getHouse(m_houseId)->getCuspLongitude();
int sign = astrologySign::getSignFromLongitude(houseLongitude);
int ruler = astrologyPlanet::getRulerFromSign(sign, false);
this->addAspect(eASPECT_CONJUNCTION);
this->addAspect(eASPECT_OPPOSITION);
this->addAspect(eASPECT_SEXTILE);
this->addAspect(eASPECT_TRINE);
// dafault pref
int pref = ePREFNAME_NARA;
// orb
double orb = 1.0f;
if (m_planetId == ePLANET_MOON) {
orb = 15.0;
}
// 支配星の度数を取得
double rulerDegree = natalPlanetSet->getPlanet(ruler)->getLongitude();
double latitude = japanCoodinate::getLatitudeFromId(pref);
double longitude = japanCoodinate::getLongitudeFromId(pref);
// transit horoscope
m_hBuilder->setDateTime(request->getYmd());
m_hBuilder->setTime(12, 0, 0);
m_hBuilder->setLongitude(longitude);
m_hBuilder->setLatitude(latitude);
astrologyHoroscope* transitHoroscope = m_hBuilder->generate();
// aspect search
for (int i = 0; i < 1000; i++) {
m_hBuilder->generate(transitHoroscope);
astrologyPlanetSet* transitPlanetSet = transitHoroscope->getPlanetSet();
double delta = transitPlanetSet->getPlanet(m_planetId)->getLongitude() - rulerDegree;
if (this->matchAspects(delta, orb)) {
break;
}
m_hBuilder->addDays(1);
}
// ymd
char str[512];
formatterBase* transit = m_top->addChild("transit", NULL, 0);
formatterBase* datePref = transit->addChild("datePref", NULL, 0);
Date* ymd = request->getYmd();
sprintf(str, "%04d%02d%02d", ymd->getYear(), ymd->getMonth(), ymd->getDay());
datePref->addChild("ymd", str, (int)strlen(str) + 1);
// tag
double transitLongitude = transitHoroscope->getPlanetSet()->getPlanet(m_planetId)->getLongitude();
astrologyHouse* house = natalHouseSet->getHouseOfDegree(transitLongitude);
sprintf(str, "%02d", house->getHouse() + 1);
// add pattern
if (m_pattern == 1) {
double jd = transitHoroscope->getJulianDay();
int v = (int)jd % 2 + 1;
char addtag[32];
sprintf(addtag, "%d", v);
strcat(str, addtag);
}
m_top->addChild("tag", str, (int)strlen(str) + 1);
// startDate
const JulianDate* date = m_hBuilder->getDate();
sprintf(str, "%04d%02d%02d", date->getYear(), date->getMonth(), date->getDay());
m_top->addChild("startDate", str, (int)strlen(str) + 1);
delete transitHoroscope;
return true;
}
Date operator+(Date a, int b) { Date q; q.Set(a.Get() + b); return q; }
void CheckStatPlan::parsePlan (PlanItem *p)
{
Date d;
d.getTimeString (p->m_sDataBeginTime);
d.getTimeString (p->m_sDataEndTime);
// p->m_iDataType = 0; //默认 提取动态刷新指标
p->m_iDataType = 1 ;
if (p->m_iDataTimeOffset>0/*数据偏移时间*/
&& p->m_iIntervalType==1/*时间间隔类型*/)
{
Date d (p->m_sNextRunTime);
d.addSec (0 - p->m_iDataTimeOffset);
strcpy (p->m_sDataEndTime, d.toString());
d.addSec (0 - atoi(p->m_sTimeInterval));
strcpy (p->m_sDataBeginTime, d.toString());
p->m_iDataType = 1; //判定为增量指标
}
else if (p->m_iDataTimeOffset == 0 //针对动态刷新指标
&& p->m_iIntervalType==1)
{
strcpy (p->m_sDataEndTime, p->m_sNextRunTime);
Date d (p->m_sNextRunTime);
d.addSec (0 - atoi(p->m_sTimeInterval));
strcpy (p->m_sDataBeginTime, d.toString());
}
else if (p->m_iIntervalType==2)
{
strcpy (p->m_sDataEndTime, p->m_sNextRunTime);
Date d (p->m_sNextRunTime);
d.addMonth(-1);
strcpy (p->m_sDataBeginTime, d.toString());
p->m_iDataType = 2; //每月固定值
}
}
