Home | News | Projects | Releases
Bugs | RFE | Repositories | Help
aecb136388dab31f88effecdef2404ce2385b305
[xestiacalendar/.git] / source / objects / calendarobject / CalendarObject.cpp
1 #include "CalendarObject.h"
2 #include "../../common/file.h"
4 using namespace std;
6 CalendarObjectLoadResult CalendarObject::LoadFile(std::string LoadFilename){
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         }
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 }
50 CalendarObjectLoadResult CalendarObject::LoadString(std::string *LoadStringData){
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;
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.
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.
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         
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++){
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         }
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         
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         
Xestia Software Development
Yn Maystri
© 2006 - 2019 Xestia Software Development
Software

Xestia Address Book
Xestia Calendar
Development

Xestia Gelforn
Everything else

About
News
Privacy Policy