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         return StringProcResult;
 148
 149 }
 150
 151 CalendarObjectValidResult CalendarObject::ValidBaseObject(){
 152
 153         bool ValidBegin = false;
 154         bool ValidVersion = false;
 155         bool ValidEnd = false;
 156         int SeekCount = 0;
 157
 158         // Check that the first line contains BEGIN:VCALENDAR
 159         // and it only appears once.
 160
 161         for (vector<string>::iterator iter = ObjectName.begin();
 162                 iter != ObjectName.end(); iter++){
 163
 164                 if (ObjectName[SeekCount] == "BEGIN" &&
 165                         ObjectData[SeekCount] == "VCALENDAR"){
 166
 167                         if (ValidBegin == false){
 168                                 ValidBegin = true;
 169                         } else {
 170                                 return CALENDAROBJECTVALID_INVALIDFORMAT;
 171                         }
 172
 173                 }
 174
 175                 SeekCount++;
 176
 177         }
 178
 179         SeekCount = 0;
 180
 181         // Check that the last line contains END:VCALENDAR
 182         // and it only appears once.
 183
 184         for (vector<string>::iterator iter = ObjectName.begin();
 185                 iter != ObjectName.end(); iter++){
 186
 187                 if (ObjectName[SeekCount] == "END" &&
 188                         ObjectData[SeekCount] == "VCALENDAR"){
 189
 190                         if (ValidEnd == false){
 191                                 ValidEnd = true;
 192                         } else {
 193                                 return CALENDAROBJECTVALID_INVALIDFORMAT;
 194                         }
 195
 196                 }
 197
 198                 SeekCount++;
 199
 200         }
 201
 202         SeekCount = 0;
 203
 204         // Check that the VERSION value contains 2.0 and that
 205         // it only appears once.
 206
 207         for (vector<string>::iterator iter = ObjectName.begin();
 208                 iter != ObjectName.end(); iter++){
 209
 210                 if (ObjectName[SeekCount] == "VERSION" &&
 211                         ObjectData[SeekCount] == "2.0"){
 212
 213                         if (ValidVersion == false){
 214                                 ValidVersion = true;
 215                         } else {
 216                                 return CALENDAROBJECTVALID_INVALIDFORMAT;
 217                         }
 218
 219                 }
 220
 221                 SeekCount++;
 222
 223         }
 224
 225         if (ValidBegin == true &&
 226                 ValidEnd == true &&
 227                 ValidVersion == true){
 228
 229                 return CALENDAROBJECTVALID_OK;
 230
 231         } else {
 232
 233                 return CALENDAROBJECTVALID_INVALIDFORMAT;
 234
 235         }
 236
 237
 238
 239 }