setup_native/source/win32/customactions/reg4msdoc/registry.hxx

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