source/objects/calendarobject/CalendarObject.cpp

   1 #include "CalendarObject.h"
   2 #include "../../common/file.h"
   3
   4 using namespace std;
   5
   6 CalendarObjectLoadResult CalendarObject::LoadFile(std::string LoadFilename){
   7
   8         // Check if the file exists and return
   9         // CALENDAROBJECTLOAD_CANNOTOPEN if not.
  10
  11         if (!FileExists(LoadFilename)){
  12                 return CALENDAROBJECTLOAD_MISSING;
  13         }
  14
  15         ifstream FileStream;
  16         string ReceivedStringData = "";
  17
  18         FileStream.open(LoadFilename, ifstream::in);
  19
  20         if (FileStream.rdstate() & ifstream::failbit){
  21                 return CALENDAROBJECTLOAD_CANNOTOPEN;
  22         }
  23
  24         if (FileStream.rdstate() & ifstream::badbit){
  25                 return CALENDAROBJECTLOAD_CANNOTOPEN;
  26         }
  27
  28         // Read the data into a string.
  29
  30         char *BufferRead = new char[256];
  31
  32         while (!FileStream.eof()){
  33
  34                 FileStream.getline(BufferRead, 256);
  35                 ReceivedStringData.append(BufferRead);
  36                 ReceivedStringData.append("\n");
  37
  38         }
  39
  40         delete[] BufferRead;
  41
  42         CalendarObjectLoadResult StringProcResult = CALENDAROBJECTLOAD_UNITTESTFAIL;
  43
  44         StringProcResult = LoadString(&ReceivedStringData);
  45
  46         return StringProcResult;
  47
  48 }
  49
  50 CalendarObjectLoadResult CalendarObject::LoadString(std::string *LoadStringData){
  51
  52         bool NewLine = false;
  53         bool SkipMode = false;
  54         bool ColonFound = false;
  55         char BufferChar = 0;
  56         int StringDataSize = LoadStringData->size();
  57         int SeekCount = 0;
  58         string PropertyName;
  59         string PropertyValue;
  60
  61         while (SeekCount < StringDataSize){
  62
  63                 // Check if character is blank or a tab and is the first character
  64                 // on a new line.
  65
  66                 if (((*LoadStringData)[SeekCount] == ' ' ||
  67                         (*LoadStringData)[SeekCount] == '\t')
  68                         && NewLine == true){
  69
  70                         // Character is on a new line and it is a space or
  71                         // tab. Ignore this character as it is not part
  72                         // of the value.
  73
  74                         NewLine = false;
  75
  76                 } else if (NewLine == true){
  77
  78                         // Character is on a new line but not a space or
  79                         // tab so check if the colon has been found
  80                         // and add the property name and value to
  81                         // the lists.
  82
  83                         if (ColonFound == true){
  84                                 ObjectName.insert(ObjectName.end(), PropertyName);
  85                                 ObjectData.insert(ObjectData.end(), PropertyValue);
  86                         }
  87
  88                         ColonFound = false;
  89                         NewLine = false;
  90                         PropertyName.clear();
  91                         PropertyValue.clear();
  92
  93                         BufferChar = (*LoadStringData)[SeekCount];
  94                         PropertyName += BufferChar;
  95
  96                 } else if ((*LoadStringData)[SeekCount] == '\n'){
  97
  98                         // Character is the new line character so mark
  99                         // the NewLine boolean as true.
 100
 101                         NewLine = true;
 102
 103                 } else if ((*LoadStringData)[SeekCount] == ':'){
 104
 105                         // Character is the colon. Set the colon
 106                         // found boolen to true.
 107
 108                         ColonFound = true;
 109
 110                 } else {
 111
 112                         // Character is not part of a new line and is not
 113                         // the new line character itself.
 114
 115                         BufferChar = (*LoadStringData)[SeekCount];
 116
 117                         if (ColonFound == false){
 118                                 PropertyName += BufferChar;
 119                         } else {
 120                                 PropertyValue += BufferChar;
 121                         }
 122
 123                 }
 124
 125                 SeekCount++;
 126
 127         }
 128
 129         // Finish off processing any data that wasn't processed
 130         // when the end of the string was reached.
 131
 132         if (ColonFound == true &&
 133                 PropertyName.size() > 0 &&
 134                 PropertyValue.size() > 0){
 135
 136                 ObjectName.insert(ObjectName.end(), PropertyName);
 137                 ObjectData.insert(ObjectData.end(), PropertyValue);
 138
 139         }
 140
 141         // Check that the object contains valid data.
 142
 143         CalendarObjectLoadResult StringProcResult = CALENDAROBJECTLOAD_UNITTESTFAIL;
 144         CalendarObjectValidResult BaseDataResult = ValidBaseObject();
 145         CalendarObjectValidResult EventDataResult = ValidObject();
 146
 147         if (BaseDataResult != CALENDAROBJECTVALID_OK ||
 148                 EventDataResult != CALENDAROBJECTVALID_OK){
 149
 150                 StringProcResult = CALENDAROBJECTLOAD_INVALIDFORMAT;
 151
 152         } else {
 153
 154                 StringProcResult = CALENDAROBJECTLOAD_OK;
 155
 156         }
 157
 158         ProcessBaseData();
 159         ProcessData();
 160
 161         return StringProcResult;
 162
 163 }
 164
 165 CalendarObjectValidResult CalendarObject::ValidBaseObject(){
 166
 167         bool ValidBegin = false;
 168         bool ValidVersion = false;
 169         bool ValidEnd = false;
 170         int SeekCount = 0;
 171
 172         // Check that the first line contains BEGIN:VCALENDAR
 173         // and it only appears once.
 174
 175         for (vector<string>::iterator iter = ObjectName.begin();
 176                 iter != ObjectName.end(); iter++){
 177
 178                 if (ObjectName[SeekCount] == "BEGIN" &&
 179                         ObjectData[SeekCount] == "VCALENDAR"){
 180
 181                         if (ValidBegin == false){
 182                                 ValidBegin = true;
 183                         } else {
 184                                 return CALENDAROBJECTVALID_INVALIDFORMAT;
 185                         }
 186
 187                 }
 188
 189                 if (ObjectName[SeekCount] == "END" &&
 190                         ObjectData[SeekCount] == "VCALENDAR" &&
 191                         ValidBegin == false){
 192
 193                         return CALENDAROBJECTVALID_INVALIDFORMAT;
 194
 195                 }
 196
 197                 SeekCount++;
 198
 199         }
 200
 201         SeekCount = 0;
 202
 203         // Check that the last line contains END:VCALENDAR
 204         // and it only appears once.
 205
 206         for (vector<string>::iterator iter = ObjectName.begin();
 207                 iter != ObjectName.end(); iter++){
 208
 209                 if (ObjectName[SeekCount] == "END" &&
 210                         ObjectData[SeekCount] == "VCALENDAR"){
 211
 212                         if (ValidEnd == false){
 213                                 ValidEnd = true;
 214                         } else {
 215                                 return CALENDAROBJECTVALID_INVALIDFORMAT;
 216                         }
 217
 218                 }
 219
 220                 SeekCount++;
 221
 222         }
 223
 224         SeekCount = 0;
 225
 226         // Check that the VERSION value contains 2.0 and that
 227         // it only appears once.
 228
 229         for (vector<string>::iterator iter = ObjectName.begin();
 230                 iter != ObjectName.end(); iter++){
 231
 232                 if (ObjectName[SeekCount] == "VERSION" &&
 233                         ObjectData[SeekCount] == "2.0"){
 234
 235                         if (ValidVersion == false){
 236                                 ValidVersion = true;
 237                         } else {
 238                                 return CALENDAROBJECTVALID_INVALIDFORMAT;
 239                         }
 240
 241                 }
 242
 243                 SeekCount++;
 244
 245         }
 246
 247         if (ValidBegin == true &&
 248                 ValidEnd == true &&
 249                 ValidVersion == true){
 250
 251                 return CALENDAROBJECTVALID_OK;
 252
 253         } else {
 254
 255                 return CALENDAROBJECTVALID_INVALIDFORMAT;
 256
 257         }
 258
 259 }
 260
 261 void CalendarObject::ProcessBaseData(){
 262
 263         // Process the base object data.
 264
 265         multimap<string,string> DataReceived;
 266
 267         // Get the method (METHOD).
 268
 269         DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "METHOD");
 270
 271         if (DataReceived.begin() != DataReceived.end()){
 272
 273                 try {
 274                         MethodTokens = DataReceived.begin()->first.substr(7);
 275                 }
 276
 277                 catch(const out_of_range &oor){
 278                         // Do nothing as there is no data.
 279                 }
 280
 281                 MethodData = DataReceived.begin()->second;
 282
 283         }
 284
 285         // Get the calendar scale (CALSCALE).
 286
 287         DataReceived = ProcessTextVectors(&ObjectName, &ObjectData, false, "CALSCALE");
 288
 289         if (DataReceived.begin() != DataReceived.end()){
 290
 291                 try {
 292                         CalendarScaleTokens = DataReceived.begin()->first.substr(9);
 293                 }
 294
 295                 catch(const out_of_range &oor){
 296                         // Do nothing as there is no data.
 297                 }
 298
 299                 CalendarScaleData = DataReceived.begin()->second;
 300
 301         }
 302
 303 }