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