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 bool ETagDB::ETagExists(wxString Filename){
 110
 111     // Lock or wait if it is already locked.
 112
 113     ProcessLock->lock();
 114
 115     bool FileResult = FALSE;
 116
 117     if (FilenameETag.find(Filename) != FilenameETag.end()){
 118
 119         FileResult = TRUE;
 120
 121     } else {
 122
 123         FileResult = FALSE;
 124
 125     }
 126
 127     // Unlock.
 128
 129     ProcessLock->unlock();
 130
 131     return FileResult;
 132
 133 }
 134
 135 std::map<wxString,wxString>* ETagDB::GetFilenamePointer(){
 136
 137     return &FilenameETag;
 138
 139 }
 140
 141 wxString ETagDB::GetETag(wxString Filename){
 142
 143     // Lock or wait if it is already locked.
 144
 145     wxString ETagOut;
 146     std::map<wxString,wxString>::iterator IterwxS;
 147
 148     ProcessLock->lock();
 149
 150     // Get the ETag.
 151
 152     //IterwxS = FilenameETag.find(Filename);
 153
 154     if (FilenameETag.find(Filename) != FilenameETag.end()){
 155
 156         IterwxS = FilenameETag.find(Filename);
 157
 158         ETagOut = IterwxS->second;
 159
 160     }
 161
 162     // Unlock.
 163
 164     ProcessLock->unlock();
 165
 166     return ETagOut;
 167
 168 }
 169
 170 wxString ETagDB::GetETagOriginal(wxString Filename){
 171
 172     // Lock or wait if it is already locked.
 173
 174     wxString ETagOrigOut;
 175     std::map<wxString,wxString>::iterator IterwxS;
 176
 177     ProcessLock->lock();
 178
 179     // Get the ETag.
 180
 181     //IterwxS = FilenameETag.find(Filename);
 182
 183     if (FilenameETagOriginal.find(Filename) != FilenameETagOriginal.end()){
 184
 185         IterwxS = FilenameETagOriginal.find(Filename);
 186
 187         ETagOrigOut = IterwxS->second;
 188
 189     }
 190
 191     // Unlock.
 192
 193     ProcessLock->unlock();
 194
 195     return ETagOrigOut;
 196
 197 }
 198
 199 bool ETagDB::WriteETagDB(){
 200
 201     // Lock or wait if it is already locked.
 202
 203     ProcessLock->lock();
 204
 205     // Write the ETag database.
 206
 207     wxString AccountETagDB;
 208     std::map<wxString,wxString>::iterator IterwxS;
 209     int LineSeek = 0;
 210
 211
 212
 213 #if defined(__HAIKU__)
 214
 215     //preffilename = wxT("noo");
 216
 217 #elif defined(__WIN32__)
 218
 219     AccountETagDB.Clear();
 220     AccountETagDB = GetAccountDir(AccountDir, FALSE);
 221     AccountETagDB.Append(wxT("\\etag.db"));
 222
 223 #else
 224
 225     // This entry applies to OSX as well.
 226
 227     AccountETagDB.Clear();
 228     AccountETagDB = GetAccountDir(AccountDir, FALSE);
 229     AccountETagDB.Append(wxT("/etag.db"));
 230
 231 #endif
 232
 233     wxTextFile ETagDBFile;
 234     wxString SettingLine;
 235
 236     if (wxFileExists(AccountETagDB) == FALSE){
 237
 238         if (ETagDBFile.Create(AccountETagDB) == FALSE){
 239             ////ProcessLock.unlock();
 240             return FALSE;
 241         }
 242
 243     } else {
 244
 245         if (ETagDBFile.Open(AccountETagDB) == FALSE){
 246             ////ProcessLock.unlock();
 247             return FALSE;
 248         }
 249
 250     }
 251
 252     ETagDBFile.Clear();
 253
 254     for (std::map<wxString,wxString>::iterator iter = FilenameETag.begin();
 255          iter != FilenameETag.end(); ++iter){
 256
 257         // Get Original ETag as well.
 258
 259         IterwxS = FilenameETagOriginal.find(iter->first);
 260
 261         if (iter->first.IsEmpty()){
 262             continue;
 263         }
 264
 265         SettingLine = iter->first + wxT("|") + iter->second + wxT("|") + IterwxS->second;
 266
 267         ETagDBFile.InsertLine(SettingLine, LineSeek);
 268
 269         LineSeek++;
 270
 271     }
 272
 273     ETagDBFile.Write();
 274
 275     NeedsWrite = FALSE;
 276
 277     // Unlock.
 278
 279     ProcessLock->unlock();
 280
 281     return TRUE;
 282
 283 }
 284
 285 bool ETagDB::LoadETagDB(){
 286
 287     // Lock or wait if it is already locked.
 288
 289     ProcessLock->lock();
 290
 291     // Load the ETag database.
 292
 293     wxString AccountETagDB;
 294     wxString AccountDirPath;
 295
 296 #if defined(__HAIKU__)
 297
 298     //preffilename = wxT("noo");
 299
 300 #elif defined(__WIN32__)
 301
 302     AccountDirPath = GetAccountDir(AccountDir, FALSE);
 303
 304     AccountETagDB = AccountDirPath;
 305     AccountETagDB.Append(wxT("\\etag.db"));
 306
 307 #else
 308
 309     AccountDirPath = GetAccountDir(AccountDir, FALSE);
 310
 311     AccountETagDB = AccountDirPath;
 312     AccountETagDB.Append(wxT("/etag.db"));
 313
 314 #endif
 315
 316     wxTextFile ETagDBFile;
 317
 318     if (wxFileExists(AccountETagDB) == FALSE){
 319
 320         if (ETagDBFile.Create(AccountETagDB) == FALSE){
 321             ////ProcessLock.unlock();
 322             //ProcessLock->unlock();
 323             return FALSE;
 324         }
 325
 326     } else {
 327
 328         if (ETagDBFile.Open(AccountETagDB, wxConvUTF8) == FALSE){
 329             ////ProcessLock.unlock();
 330             //ProcessLock->unlock();
 331             return FALSE;
 332         }
 333
 334     }
 335
 336     wxString wxSFilename;
 337     wxString wxSValue;
 338     wxString ETagContactFilename;
 339
 340     for (wxStringTokenizer ETagDBLine(ETagDBFile.GetFirstLine(), wxT("|"));
 341          !ETagDBFile.Eof(); ETagDBLine.SetString(ETagDBFile.GetNextLine(), wxT("|"), wxTOKEN_DEFAULT) )
 342     {
 343
 344         // Split the file into three.
 345
 346         wxSFilename = ETagDBLine.GetNextToken();
 347
 348         // Get the ETag.
 349
 350         wxSValue = ETagDBLine.GetNextToken();
 351         FilenameETag.insert(std::make_pair(wxSFilename, wxSValue));
 352
 353         // Get the original ETag.
 354
 355         wxSValue = ETagDBLine.GetNextToken();
 356         wxSValue.Trim();
 357         FilenameETagOriginal.insert(std::make_pair(wxSFilename, wxSValue));
 358
 359     }
 360
 361     // Unlock.
 362
 363     ProcessLock->unlock();
 364
 365     return TRUE;
 366
 367 }
 368
 369 void ETagDB::DeleteETagDB(){
 370
 371     // Lock or wait if it is already locked.
 372
 373     ProcessLock->lock();
 374
 375     wxString AccountETagDB;
 376
 377     // Delete the ETagDB.
 378
 379 #if defined(__HAIKU__)
 380
 381     //preffilename = wxT("noo");
 382
 383 #elif defined(__WIN32__)
 384
 385     AccountETagDB.Clear();
 386     AccountETagDB = GetAccountDir(AccountDir, FALSE);
 387     AccountETagDB.Append(wxT("\\etag.db"));
 388
 389     wxRemoveFile(AccountETagDB);
 390
 391 #else
 392
 393     AccountETagDB.Clear();
 394     AccountETagDB = GetAccountDir(AccountDir, FALSE);
 395     AccountETagDB.Append(wxT("/etag.db"));
 396
 397     wxRemoveFile(AccountETagDB);
 398
 399 #endif
 400
 401     // Unlock.
 402
 403     ProcessLock->unlock();
 404
 405 }
 406
 407 bool ETagDB::CheckETagExists(wxString Filename){
 408
 409     if (FilenameETag.find(Filename) == FilenameETag.end()){
 410
 411         return FALSE;
 412
 413     } else {
 414
 415         return TRUE;
 416
 417     }
 418
 419 }
 420
 421 std::map<wxString,ETagData> ETagDB::GetETagData(){
 422
 423     // Lock the database.
 424
 425     ProcessLock->lock();
 426
 427     // Go through each of the ETags and process them accordingly.
 428
 429     std::map<wxString,ETagData> DataSet;
 430
 431     for (std::map<wxString,wxString>::iterator iter = FilenameETag.begin();
 432          iter != FilenameETag.end(); ++iter){
 433
 434         std::map<wxString,wxString>::iterator origiter = FilenameETagOriginal.find(iter->first);
 435
 436         ETagData etd;
 437
 438         etd.ETagValue = iter->second;
 439         etd.ETagOrigValue = origiter->second;
 440
 441         DataSet.insert(std::make_pair(iter->first, etd));
 442
 443     }
 444
 445     // Unlock the database.
 446
 447     ProcessLock->unlock();
 448
 449     return DataSet;
 450
 451 }
 452
 453 bool ETagDB::GetWriteStatus(){
 454
 455     return NeedsWrite;
 456
 457 }