Simple Stack-Based Wrapper for Windows and XML Registries

////////////////////////////////////////////////////////////////////////////////
// forwards
//

class RegKeyImpl;
class RegValueImpl;

class RegKey;
class RegValue;


////////////////////////////////////////////////////////////////////////////////
// class RegKey
//

class RegKey
{
public:
	RegKey(const RegKey& other);
	~RegKey();

public:
	RegKey& operator=(const RegKey& rhs);

public:
	static
	RegKey		FromHKEY(HKEY root, bool& result);

public:
	RegKey		Key(LPCTSTR subKeyName) const;
	RegValue	Value(LPCTSTR valueName) const;

private:
	RegKey(RegKeyImpl*);

private:
	RegKeyImpl*	m_pImpl;
};



////////////////////////////////////////////////////////////////////////////////
// class RegValue
//

class RegValue
{
public:
	RegValue(const RegValue& other);
	~RegValue();

public:
	RegValue& operator=(const RegValue& rhs);

public:
	bool Get(bool& out);
	bool Set(const bool& in);

	bool Get(int& out);
	bool Set(const int& in);

	bool Get(double& out);
	bool Set(const double& in);

	bool Get(LPTSTR out, int size);
	bool Set(LPCTSTR in);

	bool Get(void* out, int size, unsigned long& out_count);
	bool Set(void* in,  int size);

	template <class T>
	bool GetT(T& out)
	{ unsigned long out_count; return (Get((void*)&out, sizeof(T), out_count) && (out_count == sizeof(T))); }

	template <class T>
	bool SetT(const T& in)
	{ return Set((void*)&in, sizeof(T)); }

private:
	RegValue(RegValueImpl*);

private:
	RegValueImpl* m_pImpl;
	friend RegKey;
};