src/core/Manager.cpp

   1 #include <fstream>
   2 #include <sstream>
   3 #include <set>
   4 #include <map>
   5 #include <ctime>
   6 #include <cstdlib>
   7
   8 #include "ConfigHolder.h"
   9 #include "Manager.h"
  10 #include "ForgetCurve.h"
  11 #include "Task.h"
  12
  13 namespace freeRecite {
  14
  15 bool Manager::load() {
  16   std::ifstream ifs(configHolder.mgrFile().c_str());
  17   if(!ifs.is_open())
  18     return false;
  19   Task tmpTask;
  20   unsigned amount;
  21   ifs >> amount;
  22   ifs.ignore(1,',');
  23   ifs >> maxTaskID;
  24   ifs.ignore(1,'\n');
  25   bool firstFlag = true;
  26   while(amount > 0 && ifs.good()) {
  27     ifs >> tmpTask;
  28     allTasks[tmpTask.getID()] = tmpTask;
  29
  30     if(tmpTask.shouldReview())
  31       activeID.push_back(tmpTask.getID());
  32     else if(firstFlag){
  33       firstReviewTime = tmpTask.getReviewTime();
  34       firstFlag = false;
  35     }else if(firstReviewTime > tmpTask.getReviewTime())
  36       firstReviewTime = tmpTask.getReviewTime();
  37     --amount;
  38   }
  39
  40   if(!activeID.empty())
  41     firstReviewTime = 0;
  42   return true;
  43 }
  44
  45 bool Manager::save() {
  46   std::ofstream ofs(configHolder.mgrFile().c_str());
  47   if(!ofs.is_open())
  48     return false;
  49   ofs << static_cast<unsigned>(allTasks.size())
  50       << ',' << maxTaskID << '\n';
  51   std::map<time_t,Task>::const_iterator itr = allTasks.begin();
  52   while(itr != allTasks.end()){
  53     if(!ofs.good())
  54       return false;
  55     else {
  56       if((itr->second).isAvailable())
  57         ofs << itr->second;
  58       ++itr;
  59     }
  60   }
  61   return true;
  62 }
  63
  64 bool Manager::refresh() {
  65   if(save()) {
  66     activeID.clear();
  67     allTasks.clear();
  68     return load();
  69   }else
  70     return false;
  71 }
  72
  73 bool Manager::hasTask(time_t taskID) {
  74   if(allTasks.find(taskID) == allTasks.end())
  75     return true;
  76   else
  77     return false;
  78 }
  79
  80
  81 bool Manager::createTask(const std::set<std::string> &words,
  82                          const char *taskName, unsigned maxLimit) {
  83   if(words.size()==0)
  84     return false;
  85   unsigned tasksNum = words.size()/maxLimit + 1;
  86   maxLimit = words.size()/tasksNum;
  87   std::string baseName;
  88   std::string realName;
  89   std::ofstream desFile;
  90   std::ostringstream os;
  91
  92   time_t curTime;
  93   struct tm * timeinfo;
  94   char buffer[20];
  95   std::set<std::string>::const_iterator itr = words.begin();
  96   time(&curTime);
  97
  98
  99   if(taskName != 0)
 100     baseName = taskName;
 101
 102   if(baseName.empty()){
 103     timeinfo = localtime(&curTime);
 104     strftime(buffer,20,"%Y%m%d%H%M%S",timeinfo);
 105     baseName = buffer;
 106   }
 107
 108   for (int i = 1; i <= tasksNum; ++i) { //[0]
 109     memset(buffer,0,20);
 110     os.str("");
 111     os << "_" << i;
 112
 113     if(tasksNum > 1)
 114       realName = baseName + os.str();
 115     else
 116       realName = baseName;
 117     if(curTime > maxTaskID)
 118       maxTaskID = curTime;
 119     else
 120       ++maxTaskID;
 121     timeinfo = localtime(&maxTaskID);
 122     strftime(buffer,20,"%Y%m%d%H%M%S.tkwd",timeinfo);
 123     std::string desFileName = configHolder.tasksDir() + buffer;
 124
 125     desFile.open(desFileName.c_str());
 126     if(!desFile.is_open()) {
 127
 128       return false;
 129     }
 130
 131     //Write words into file.
 132     int j = 0;
 133     while(j++ < maxLimit && itr != words.end()) {
 134       if(!desFile.good()){
 135         std::cerr << "error when open file" << std::endl;
 136         return false;
 137       }
 138       if(itr->empty()) {
 139         ++itr;
 140         continue;
 141       }else {
 142         desFile << *itr << std::endl;
 143         ++itr;
 144       }
 145     }
 146
 147     Task newTask(maxTaskID,realName.c_str());
 148     //Pass a copy of newTask here.
 149     allTasks[newTask.getID()] = newTask;
 150     activeID.push_back(newTask.getID());
 151     desFile.close();
 152   } //[!0]
 153   return true;
 154 }
 155
 156 const std::vector<time_t> &Manager::getActiveTasks() const{
 157   return activeID;
 158 }
 159
 160 //Get the number of the active tasks.
 161 int Manager::getActiveTaskNum() const {
 162   return activeID.size();
 163 }
 164
 165 //Get the task's name.
 166 const std::string &Manager::getTaskName(time_t taskID)const {
 167   return (allTasks.find(taskID)->second).getName();
 168 }
 169
 170
 171 time_t Manager::getNextTime(time_t taskID) const {
 172   return (allTasks.find(taskID)->second).getReviewTime();
 173 }
 174 //Get the step of the task.
 175 int Manager::getTaskStep(time_t taskID)const {
 176   return (allTasks.find(taskID)->second).getStep();
 177 }
 178
 179 bool Manager::test(time_t taskID,int mark) {
 180   bool result = (allTasks[taskID]).test(mark);
 181   return (refresh() && result);
 182 }
 183
 184 //This is a global variable.
 185 Manager manager;
 186
 187 } //namespace freeRecite end