base/win: Add documentation to RegKey::Read/Write functions.

base/win/registry.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_WIN_REGISTRY_H_
 #define BASE_WIN_REGISTRY_H_
 #pragma once
 
 #include <windows.h>
 #include <string>
@@ skipping 48 matching lines @@
   // True while the key is valid.
   bool Valid() const { return key_ != NULL; }
 
   // Kill a key and everything that live below it; please be careful when using
   // it.
   LONG DeleteKey(const wchar_t* name);
 
   // Deletes a single value within the key.
   LONG DeleteValue(const wchar_t* name);
 
-  LONG ReadValue(const wchar_t* name, void* data, DWORD* dsize,
+  // Getters:
+
+  // Returns an int32 value.
+  LONG ReadValue(const wchar_t* name, DWORD* out_value) const;

[M-A Ruel, 2011/10/18 18:01:58]

Don't.

Function overloading is banned by style.

I don't think this change is valuable at all.

[tfarina, 2011/10/18 18:03:27]

Yeah I know :(
Hum

I did with the intention to make it consistent with WriteValue and to clean this
mess.

[M-A Ruel, 2011/10/18 18:05:17]

Then fix WriteValue() to not use function overloading, not the reverse.

[tfarina, 2011/10/18 18:11:36]

OK, I'll hold off in renaming them for now (it breaks rlz library anyway :( ).
I'll just add the docs for now.

[tfarina, 2011/10/18 18:40:43]

Hum, reading it again, it doesn't explicit bans function overload.

It says: "You may write a function that takes a const string& and overload it
with another that takes const char*."

+
+  // Returns an int64 value.
+  LONG ReadValue(const wchar_t* name, int64* out_value) const;
+
+  // Returns a string value.
+  LONG ReadValue(const wchar_t* name, std::wstring* out_value) const;
+
+  // Returns raw data.
+  LONG ReadValue(const wchar_t* name,
+                 void* data,
+                 DWORD* dsize,
                  DWORD* dtype) const;
-  LONG ReadValue(const wchar_t* name, std::wstring* value) const;
-  LONG ReadValueDW(const wchar_t* name, DWORD* value) const;
-  LONG ReadInt64(const wchar_t* name, int64* value) const;
 
-  LONG WriteValue(const wchar_t* name, const void* data, DWORD dsize,
+  // Setters:
+
+  // Sets an int32 value.
+  LONG WriteValue(const wchar_t* name, DWORD in_value);
+
+  // Sets a string value.
+  LONG WriteValue(const wchar_t* name, const wchar_t* in_value);
+
+  // Sets raw data, including type.
+  LONG WriteValue(const wchar_t* name,
+                  const void* data,
+                  DWORD dsize,
                   DWORD dtype);
-  LONG WriteValue(const wchar_t* name, const wchar_t* value);
-  LONG WriteValue(const wchar_t* name, DWORD value);
 
   // Starts watching the key to see if any of its values have changed.
   // The key must have been opened with the KEY_NOTIFY access privilege.
   LONG StartWatching();
 
   // If StartWatching hasn't been called, always returns false.
   // Otherwise, returns true if anything under the key has changed.
   // This can't be const because the |watch_event_| may be refreshed.
   bool HasChanged();
 
@@ skipping 86 matching lines @@
 
   wchar_t name_[MAX_PATH];
 
   DISALLOW_COPY_AND_ASSIGN(RegistryKeyIterator);
 };
 
 }  // namespace win
 }  // namespace base
 
 #endif  // BASE_WIN_REGISTRY_H_