1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 #ifndef _REGISTRY_HXX_ 25 #define _REGISTRY_HXX_ 26 27 #ifdef _MSC_VER 28 #pragma warning(push, 1) /* disable warnings within system headers */ 29 #endif 30 #include <windows.h> 31 #ifdef _MSC_VER 32 #pragma warning(pop) 33 #endif 34 35 #include <memory> 36 #include <vector> 37 #include <string> 38 39 #include "registryvalueimpl.hxx" 40 41 //--------------------------------------- 42 // forward declaration 43 //--------------------------------------- 44 45 class RegistryKeyImpl; 46 47 //--------------------------------------- 48 // typedefs 49 //--------------------------------------- 50 51 typedef std::auto_ptr<RegistryKeyImpl> RegistryKey; 52 typedef std::vector<std::wstring> StringList; 53 typedef std::auto_ptr<StringList> StringListPtr; 54 55 //--------------------------------------- 56 // 57 //--------------------------------------- 58 59 class RegistryKeyImpl 60 { 61 public: 62 63 //############################################ 64 // Destruction 65 //############################################ 66 67 virtual ~RegistryKeyImpl(); 68 69 70 //############################################ 71 // Queries 72 //############################################ 73 74 75 /** The name of the key at hand, maybe empty 76 if this is any of the root keys 77 */ 78 std::wstring GetName() const; 79 80 /** The number of sub values of the key at hand 81 82 @precond IsOpen = true 83 84 @throws 85 */ 86 virtual size_t GetSubValueCount() const = 0; 87 88 /** The number of sub-keys of the key at hand 89 90 @precond IsOpen = true 91 92 @throws 93 */ 94 virtual size_t GetSubKeyCount() const = 0; 95 96 bool IsOpen() const; 97 98 /** Do we have write access on the key at hand 99 */ 100 bool IsWriteable() const; 101 102 /** The StringList will be allocated on the heap, 103 so this is in fact a transfer of ownership 104 to the caller 105 106 @precond IsOpen = true 107 108 @throws RegistryIOException 109 */ 110 virtual StringListPtr GetSubKeyNames() const = 0; 111 112 /** The StringList will be allocated on the heap, 113 so this is in fact a transfer of ownership 114 to the caller 115 116 @precond IsOpen = true 117 118 @throws RegistryIOException 119 */ 120 virtual StringListPtr GetSubValueNames() const = 0; 121 122 /** Get the specified registry value 123 124 @precond IsOpen = true 125 */ 126 virtual RegistryValue GetValue(const std::wstring& Name) const = 0; 127 128 /** Get the specified registry value, return the given 129 default value if value not found 130 131 @precond IsOpen = true 132 */ 133 virtual RegistryValue GetValue(const std::wstring& Name, const RegistryValue& Default) const = 0; 134 135 /** Convenience function to determine if the 136 Registry key at hand has the specified 137 value 138 139 @precond IsOpen = true 140 141 throws RegistryAccessDenyException 142 */ 143 bool HasValue(const std::wstring& Name) const; 144 145 /** Convenience function to determine if the 146 Registry key at hand has the specified 147 sub-key 148 149 @precond IsOpen = true 150 151 throws RegistryAccessDenyException 152 */ 153 bool HasSubKey(const std::wstring& Name) const; 154 155 156 //############################################ 157 // Commands 158 //############################################ 159 160 161 /** Open the registry key, has no effect if 162 the key is already open 163 164 @precond IsOpen = false 165 166 @throws RegistryWriteAccessDenyException 167 RegistryAccessDenyException 168 */ 169 virtual void Open(bool Writeable = true) = 0; 170 171 /** Close the registry key at hand, further 172 using it without re-opening may cause 173 RegistryIOExceptions to be thrown 174 175 This is a template method that calls 176 ImplClose which has to be overwritten 177 by sub-classes 178 */ 179 void Close(); 180 181 /** Open the specified sub-key of the registry key 182 at hand 183 184 @precond IsOpen = true 185 HasSubKey(Name) = true 186 187 @throws RegistryIOException 188 RegistryKeyNotFoundException 189 RegistryAccessDeniedException 190 */ 191 virtual RegistryKey OpenSubKey(const std::wstring& Name, bool Writeable = true) = 0; 192 193 /** Creates a new sub-key below the key at hand 194 195 @precond IsOpen = true 196 IsWriteable = true 197 198 @throws RegistryIOException 199 RegistryWriteAccessDenyException 200 */ 201 virtual RegistryKey CreateSubKey(const std::wstring& Name) = 0; 202 203 /** Deletes a sub-key below the key at hand, the 204 key must not have sub-keys 205 206 @precond IsOpen = true 207 IsWriteable = true 208 209 @throws RegistryIOException 210 RegistryWriteAccessDenyException 211 */ 212 virtual void DeleteSubKey(const std::wstring& Name) = 0; 213 214 /** Deletes a sub-key below the key at hand with all 215 its sub-keys 216 217 @precond IsOpen = true 218 IsWriteable = true; 219 220 @throws RegistryIOException 221 RegistryWriteAccessDenyException 222 */ 223 virtual void DeleteSubKeyTree(const std::wstring& Name) = 0; 224 225 /** Delete the specified value 226 227 @precond IsOpen = true 228 IsWriteable = true 229 HasValue(Name) = true 230 231 @throws RegistryIOException 232 RegistryWriteAccessDeniedException 233 RegistryValueNotFoundException 234 */ 235 virtual void DeleteValue(const std::wstring& Name) = 0; 236 237 /** Set the specified registry value 238 239 @precond IsOpen = true 240 IsWriteable = true 241 242 @throws RegistryIOException 243 RegistryWriteAccessDenyException 244 */ 245 virtual void SetValue(const RegistryValue& Value) = 0; 246 247 248 /** Copies the specified value from RegistryKey to 249 the registry key at hand, if a value with this 250 name already exist under the registry key at hand 251 it will be overwritten 252 253 @precond IsOpen = true 254 IsWriteable = true 255 RegistryKey.HasSubValue(Name) = true 256 257 @throws RegistryIOException 258 RegistryWriteAccessDeniedException 259 RegistryValueNotFoundException 260 */ 261 virtual void CopyValue(const RegistryKey& RegistryKey, const std::wstring& Name); 262 263 /** Copies the specified value from RegistryKey to 264 the registry key at hand under a new name, 265 if a value with this name already exist there 266 it will be overwritten 267 268 @precond IsOpen = true 269 IsWriteable = true 270 RegistryKey.HasSubValue(Name) = true 271 272 @throws RegistryIOException 273 RegistryWriteAccessDeniedException 274 RegistryValueNotFoundException 275 */ 276 virtual void CopyValue(const RegistryKey& RegistryKey, const std::wstring& Name, const std::wstring& NewName); 277 278 //############################################ 279 // Creation 280 // only possible through WindowsRegistry class 281 //############################################ 282 283 284 protected: 285 /** Create instance of the specified Registry key 286 287 @throws RegistryWriteAccessDenyException 288 RegistryAccessDenyException 289 RegistryKeyNotFoundException 290 */ 291 RegistryKeyImpl(HKEY RootKey, const std::wstring& KeyName); 292 293 /** Create instance of the specified Registry key. 294 RootKey should only one of the predefined 295 keys HKEY_CLASSES_ROOT, HKEY_CURRENT_USER, 296 HKEY_LOCAL_MACHINE, HKEY_USERS 297 298 @throws RegistryWriteAccessDenyException 299 RegistryAccessDenyException 300 RegistryKeyNotFoundException 301 */ 302 RegistryKeyImpl(HKEY RootKey); 303 304 /** Create an instances of the specified Registry key, 305 the key is assumed to be already opened. 306 */ 307 RegistryKeyImpl(HKEY RootKey, HKEY SubKey, const std::wstring& KeyName, bool Writeable = true); 308 309 /** Is this one of the root keys 310 HKEY_CLASSES_ROOT 311 HKEY_CURRENT_USER 312 etc. 313 */ 314 bool IsRootKey() const; 315 316 protected: 317 HKEY m_hRootKey; 318 HKEY m_hSubKey; 319 std::wstring m_KeyName; 320 bool m_IsWriteable; 321 322 // prevent copy and assignment 323 private: 324 RegistryKeyImpl(const RegistryKeyImpl&); 325 RegistryKeyImpl& operator=(const RegistryKeyImpl&); 326 327 //###################################### 328 // Friend declarations 329 //###################################### 330 331 friend class WindowsRegistry; 332 }; 333 334 #endif 335