source/common/etag.cpp

   1 #include "etag.h"
   2 #include "../common/dirs.h"
   3
   4 ETagDB::~ETagDB(){
   5
   6     // Write out the database to file.
   7
   8     ProcessLock->try_lock();
   9
  10     if (NeedsWrite == TRUE){
  11
  12         WriteETagDB();
  13
  14     }
  15
  16     ProcessLock->unlock();
  17
  18 }
  19
  20 void ETagDB::SetupDB(wxString AccountDirInc){
  21
  22     AccountDir = AccountDirInc;
  23     LoadETagDB();
  24
  25 }
  26
  27 void ETagDB::AddETag(wxString Filename, wxString ETag, wxString ETagOriginal){
  28
  29     // Lock or wait if it is already locked.
  30
  31     ProcessLock->lock();
  32
  33     // Process the ETag addition.
  34
  35     FilenameETag.insert(std::make_pair(Filename, ETag));
  36     FilenameETagOriginal.insert(std::make_pair(Filename, ETagOriginal));
  37
  38     NeedsWrite = TRUE;
  39
  40     // Unlock.
  41
  42     ProcessLock->unlock();
  43
  44 }
  45
  46 void ETagDB::RemoveETag(wxString Filename){
  47
  48     // Lock or wait if it is already locked.
  49
  50     ProcessLock->lock();
  51
  52     // Remove the ETag.
  53
  54     Filename.Trim();
  55
  56     FilenameETag.erase(Filename);
  57     FilenameETagOriginal.erase(Filename);
  58
  59     NeedsWrite = TRUE;
  60
  61     // Unlock.
  62
  63     ProcessLock->unlock();
  64
  65 }
  66
  67 void ETagDB::UpdateETag(wxString Filename, wxString ETag){
  68
  69     // Lock or wait if it is already locked.
  70
  71     ProcessLock->lock();
  72
  73     // Update the ETag.
  74
  75     FilenameETag.erase(Filename);
  76     FilenameETag.insert(std::make_pair(Filename, ETag));
  77
  78     NeedsWrite = TRUE;
  79
  80     // Unlock.
  81
  82     ProcessLock->unlock();
  83
  84 }
  85
  86 void ETagDB::UpdateETag(wxString Filename, wxString ETag, wxString ETagOriginal){
  87
  88     // Lock or wait if it is already locked.
  89
  90     ProcessLock->lock();
  91
  92     // Update the ETag.
  93
  94     FilenameETag.erase(Filename);
  95     FilenameETagOriginal.erase(Filename);
  96     FilenameETag.insert(std::make_pair(Filename, ETag));
  97     FilenameETagOriginal.insert(std::make_pair(Filename, ETagOriginal));
  98
  99     std::map<wxString,wxString>::iterator IterWxS;
 100     IterWxS = FilenameETagOriginal.find(Filename);
 101     NeedsWrite = TRUE;
 102
 103     // Unlock.
 104
 105     ProcessLock->unlock();
 106
 107 }
 108
 109 std::map<wxString,wxString>* ETagDB::GetFilenamePointer(){
 110
 111     return &FilenameETag;
 112
 113 }
 114
 115 wxString ETagDB::GetETag(wxString Filename){
 116
 117     // Lock or wait if it is already locked.
 118
 119     wxString ETagOut;
 120     std::map<wxString,wxString>::iterator IterwxS;
 121
 122     ProcessLock->lock();
 123
 124     // Get the ETag.
 125
 126     //IterwxS = FilenameETag.find(Filename);
 127
 128     if (FilenameETag.find(Filename) != FilenameETag.end()){
 129
 130         IterwxS = FilenameETag.find(Filename);
 131
 132         ETagOut = IterwxS->second;
 133
 134     }
 135
 136     // Unlock.
 137
 138     ProcessLock->unlock();
 139
 140     return ETagOut;
 141
 142 }
 143
 144 wxString ETagDB::GetETagOriginal(wxString Filename){
 145
 146     // Lock or wait if it is already locked.
 147
 148     wxString ETagOrigOut;
 149     std::map<wxString,wxString>::iterator IterwxS;
 150
 151     ProcessLock->lock();
 152
 153     // Get the ETag.
 154
 155     //IterwxS = FilenameETag.find(Filename);
 156
 157     if (FilenameETagOriginal.find(Filename) != FilenameETagOriginal.end()){
 158
 159         IterwxS = FilenameETagOriginal.find(Filename);
 160
 161         ETagOrigOut = IterwxS->second;
 162
 163     }
 164
 165     // Unlock.
 166
 167     ProcessLock->unlock();
 168
 169     return ETagOrigOut;
 170
 171 }
 172
 173 bool ETagDB::WriteETagDB(){
 174
 175     // Lock or wait if it is already locked.
 176
 177     ProcessLock->lock();
 178
 179     // Write the ETag database.
 180
 181     wxString AccountETagDB;
 182     std::map<wxString,wxString>::iterator IterwxS;
 183     int LineSeek = 0;
 184
 185
 186
 187 #if defined(__HAIKU__)
 188
 189     //preffilename = wxT("noo");
 190
 191 #elif defined(__WIN32__)
 192
 193     AccountETagDB.Clear();
 194     AccountETagDB = GetAccountDir(AccountDir, FALSE);
 195     AccountETagDB.Append(wxT("\\etag.db"));
 196
 197 #else
 198
 199     // This entry applies to OSX as well.
 200
 201     AccountETagDB.Clear();
 202     AccountETagDB = GetAccountDir(AccountDir, FALSE);
 203     AccountETagDB.Append(wxT("/etag.db"));
 204
 205 #endif
 206
 207     wxTextFile ETagDBFile;
 208     wxString SettingLine;
 209
 210     if (wxFileExists(AccountETagDB) == FALSE){
 211
 212         if (ETagDBFile.Create(AccountETagDB) == FALSE){
 213             ////ProcessLock.unlock();
 214             return FALSE;
 215         }
 216
 217     } else {
 218
 219         if (ETagDBFile.Open(AccountETagDB) == FALSE){
 220             ////ProcessLock.unlock();
 221             return FALSE;
 222         }
 223
 224     }
 225
 226     ETagDBFile.Clear();
 227
 228     for (std::map<wxString,wxString>::iterator iter = FilenameETag.begin();
 229          iter != FilenameETag.end(); ++iter){
 230
 231         // Get Original ETag as well.
 232
 233         IterwxS = FilenameETagOriginal.find(iter->first);
 234
 235         if (iter->first.IsEmpty()){
 236             continue;
 237         }
 238
 239         SettingLine = iter->first + wxT("|") + iter->second + wxT("|") + IterwxS->second;
 240
 241         ETagDBFile.InsertLine(SettingLine, LineSeek);
 242
 243         LineSeek++;
 244
 245     }
 246
 247     ETagDBFile.Write();
 248
 249     NeedsWrite = FALSE;
 250
 251     // Unlock.
 252
 253     ProcessLock->unlock();
 254
 255     return TRUE;
 256
 257 }
 258
 259 bool ETagDB::LoadETagDB(){
 260
 261     // Lock or wait if it is already locked.
 262
 263     ProcessLock->lock();
 264
 265     // Load the ETag database.
 266
 267     wxString AccountETagDB;
 268     wxString AccountDirPath;
 269
 270 #if defined(__HAIKU__)
 271
 272     //preffilename = wxT("noo");
 273
 274 #elif defined(__WIN32__)
 275
 276     AccountDirPath = GetAccountDir(AccountDir, FALSE);
 277
 278     AccountETagDB = AccountDirPath;
 279     AccountETagDB.Append(wxT("\\etag.db"));
 280
 281 #else
 282
 283     AccountDirPath = GetAccountDir(AccountDir, FALSE);
 284
 285     AccountETagDB = AccountDirPath;
 286     AccountETagDB.Append(wxT("/etag.db"));
 287
 288 #endif
 289
 290     wxTextFile ETagDBFile;
 291
 292     if (wxFileExists(AccountETagDB) == FALSE){
 293
 294         if (ETagDBFile.Create(AccountETagDB) == FALSE){
 295             ////ProcessLock.unlock();
 296             //ProcessLock->unlock();
 297             return FALSE;
 298         }
 299
 300     } else {
 301
 302         if (ETagDBFile.Open(AccountETagDB, wxConvUTF8) == FALSE){
 303             ////ProcessLock.unlock();
 304             //ProcessLock->unlock();
 305             return FALSE;
 306         }
 307
 308     }
 309
 310     wxString wxSFilename;
 311     wxString wxSValue;
 312     wxString ETagContactFilename;
 313
 314     for (wxStringTokenizer ETagDBLine(ETagDBFile.GetFirstLine(), wxT("|"));
 315          !ETagDBFile.Eof(); ETagDBLine.SetString(ETagDBFile.GetNextLine(), wxT("|"), wxTOKEN_DEFAULT) )
 316     {
 317
 318         // Split the file into three.
 319
 320         wxSFilename = ETagDBLine.GetNextToken();
 321
 322         // Get the ETag.
 323
 324         wxSValue = ETagDBLine.GetNextToken();
 325         FilenameETag.insert(std::make_pair(wxSFilename, wxSValue));
 326
 327         // Get the original ETag.
 328
 329         wxSValue = ETagDBLine.GetNextToken();
 330         wxSValue.Trim();
 331         FilenameETagOriginal.insert(std::make_pair(wxSFilename, wxSValue));
 332
 333     }
 334
 335     // Unlock.
 336
 337     ProcessLock->unlock();
 338
 339     return TRUE;
 340
 341 }
 342
 343 void ETagDB::DeleteETagDB(){
 344
 345     // Lock or wait if it is already locked.
 346
 347     ProcessLock->lock();
 348
 349     wxString AccountETagDB;
 350
 351     // Delete the ETagDB.
 352
 353 #if defined(__HAIKU__)
 354
 355     //preffilename = wxT("noo");
 356
 357 #elif defined(__WIN32__)
 358
 359     AccountETagDB.Clear();
 360     AccountETagDB = GetAccountDir(AccountDir, FALSE);
 361     AccountETagDB.Append(wxT("\\etag.db"));
 362
 363     wxRemoveFile(AccountETagDB);
 364
 365 #else
 366
 367     AccountETagDB.Clear();
 368     AccountETagDB = GetAccountDir(AccountDir, FALSE);
 369     AccountETagDB.Append(wxT("/etag.db"));
 370
 371     wxRemoveFile(AccountETagDB);
 372
 373 #endif
 374
 375     // Unlock.
 376
 377     ProcessLock->unlock();
 378
 379 }
 380
 381 bool ETagDB::CheckETagExists(wxString Filename){
 382
 383     if (FilenameETag.find(Filename) == FilenameETag.end()){
 384
 385         return FALSE;
 386
 387     } else {
 388
 389         return TRUE;
 390
 391     }
 392
 393 }
 394
 395 std::map<wxString,ETagData> ETagDB::GetETagData(){
 396
 397     // Lock the database.
 398
 399     ProcessLock->lock();
 400
 401     // Go through each of the ETags and process them accordingly.
 402
 403     std::map<wxString,ETagData> DataSet;
 404
 405     for (std::map<wxString,wxString>::iterator iter = FilenameETag.begin();
 406          iter != FilenameETag.end(); ++iter){
 407
 408         std::map<wxString,wxString>::iterator origiter = FilenameETagOriginal.find(iter->first);
 409
 410         ETagData etd;
 411
 412         etd.ETagValue = iter->second;
 413         etd.ETagOrigValue = origiter->second;
 414
 415         DataSet.insert(std::make_pair(iter->first, etd));
 416
 417     }
 418
 419     // Unlock the database.
 420
 421     ProcessLock->unlock();
 422
 423     return DataSet;
 424
 425 }
 426
 427 bool ETagDB::GetWriteStatus(){
 428
 429     return NeedsWrite;
 430
 431 }