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