src/apps/debugger/settings/SettingsManager.cpp

   1 /*
   2  * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
   3  * Distributed under the terms of the MIT License.
   4  */
   5
   6
   7 #include "SettingsManager.h"
   8
   9 #include <new>
  10
  11 #include <Directory.h>
  12 #include <File.h>
  13 #include <FindDirectory.h>
  14
  15 #include <AutoDeleter.h>
  16 #include <AutoLocker.h>
  17
  18 #include "TeamSettings.h"
  19
  20
  21 static const char* const kSettingsDirPath               = "Debugger";
  22 static const char* const kGlobalSettingsName    = "Global";
  23 static const int32 kMaxRecentTeamSettings               = 10;
  24
  25
  26 SettingsManager::SettingsManager()
  27         :
  28         fLock("settings manager"),
  29         fRecentTeamSettings(kMaxRecentTeamSettings, true),
  30         fUiSettingsFactory(NULL)
  31 {
  32 }
  33
  34
  35 SettingsManager::~SettingsManager()
  36 {
  37         _Unset();
  38 }
  39
  40
  41 status_t
  42 SettingsManager::Init(TeamUiSettingsFactory* factory)
  43 {
  44         // check the lock
  45         status_t error = fLock.InitCheck();
  46         if (error != B_OK)
  47                 return error;
  48
  49         fUiSettingsFactory = factory;
  50
  51         // get and create our settings directory
  52         if (find_directory(B_USER_SETTINGS_DIRECTORY, &fSettingsPath, true) == B_OK
  53                 && fSettingsPath.Append(kSettingsDirPath) == B_OK
  54                 && create_directory(fSettingsPath.Path(), 0700) == B_OK
  55                 && fSettingsPath.Append(kGlobalSettingsName) == B_OK) {
  56                 // load the settings
  57                 _LoadSettings();
  58         } else {
  59                 // something went wrong -- clear the path
  60                 fSettingsPath.Unset();
  61         }
  62
  63         return B_OK;
  64 }
  65
  66
  67 status_t
  68 SettingsManager::LoadTeamSettings(const char* teamName, TeamSettings& settings)
  69 {
  70         AutoLocker<BLocker> locker(fLock);
  71
  72         int32 index = _TeamSettingsIndex(teamName);
  73         if (index < 0)
  74                 return B_ENTRY_NOT_FOUND;
  75
  76         try {
  77                 settings = *fRecentTeamSettings.ItemAt(index);
  78                 return B_OK;
  79         } catch (std::bad_alloc) {
  80                 return B_NO_MEMORY;
  81         }
  82 }
  83
  84
  85 status_t
  86 SettingsManager::SaveTeamSettings(const TeamSettings& _settings)
  87 {
  88         AutoLocker<BLocker> locker(fLock);
  89
  90         TeamSettings* settings;
  91         int32 index = _TeamSettingsIndex(_settings.TeamName());
  92         if (index >= 0) {
  93                 settings = fRecentTeamSettings.RemoveItemAt(index);
  94         } else {
  95                 settings = new(std::nothrow) TeamSettings;
  96                 if (settings == NULL)
  97                         return B_NO_MEMORY;
  98
  99                 // enforce recent limit
 100                 while (fRecentTeamSettings.CountItems() >= kMaxRecentTeamSettings)
 101                         delete fRecentTeamSettings.RemoveItemAt(0);
 102
 103         }
 104         ObjectDeleter<TeamSettings> settingsDeleter(settings);
 105
 106         try {
 107                 *settings = _settings;
 108                 if (!fRecentTeamSettings.AddItem(settings))
 109                         return B_NO_MEMORY;
 110                 settingsDeleter.Detach();
 111
 112                 return _SaveSettings();
 113         } catch (std::bad_alloc) {
 114                 return B_NO_MEMORY;
 115         }
 116 }
 117
 118
 119 void
 120 SettingsManager::_Unset()
 121 {
 122         fRecentTeamSettings.MakeEmpty();
 123 }
 124
 125
 126 status_t
 127 SettingsManager::_LoadSettings()
 128 {
 129         _Unset();
 130
 131         if (fSettingsPath.Path() == NULL)
 132                 return B_ENTRY_NOT_FOUND;
 133
 134         // read the settings file
 135         BFile file;
 136         status_t error = file.SetTo(fSettingsPath.Path(), B_READ_ONLY);
 137         if (error != B_OK)
 138                 return error;
 139
 140         BMessage archive;
 141         error = archive.Unflatten(&file);
 142         if (error != B_OK)
 143                 return error;
 144
 145         // unarchive the recent team settings
 146         BMessage childArchive;
 147         for (int32 i = 0; archive.FindMessage("teamSettings", i, &childArchive)
 148                         == B_OK; i++) {
 149                 TeamSettings* settings = new(std::nothrow) TeamSettings;
 150                 if (settings == NULL)
 151                         return B_NO_MEMORY;
 152
 153                 error = settings->SetTo(childArchive, *fUiSettingsFactory);
 154                 if (error != B_OK) {
 155                         delete settings;
 156                         continue;
 157                 }
 158
 159                 if (!fRecentTeamSettings.AddItem(settings)) {
 160                         delete settings;
 161                         return B_NO_MEMORY;
 162                 }
 163         }
 164
 165         return B_OK;
 166 }
 167
 168
 169 status_t
 170 SettingsManager::_SaveSettings()
 171 {
 172         if (fSettingsPath.Path() == NULL)
 173                 return B_ENTRY_NOT_FOUND;
 174
 175         // archive the recent team settings
 176         BMessage archive;
 177         for (int32 i = 0; TeamSettings* settings = fRecentTeamSettings.ItemAt(i);
 178                         i++) {
 179                 BMessage childArchive;
 180                 status_t error = settings->WriteTo(childArchive);
 181                 if (error != B_OK)
 182                         return error;
 183
 184                 error = archive.AddMessage("teamSettings", &childArchive);
 185                 if (error != B_OK)
 186                         return error;
 187         }
 188
 189         // open the settings file
 190         BFile file;
 191         status_t error = file.SetTo(fSettingsPath.Path(),
 192                 B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);
 193         if (error != B_OK)
 194                 return error;
 195
 196         return archive.Flatten(&file);
 197 }
 198
 199
 200 int32
 201 SettingsManager::_TeamSettingsIndex(const char* teamName) const
 202 {
 203         for (int32 i = 0; TeamSettings* settings = fRecentTeamSettings.ItemAt(i);
 204                         i++) {
 205                 if (settings->TeamName() == teamName)
 206                         return i;
 207         }
 208
 209         return -1;
 210 }