src/core/Manager.cpp

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