Re: templates - method return value is multiple types

Is it possible to create a method that can return different types
using a template?

My goal is to get a value from the Window's Registry in one handy
dandy place. However my question is on template methods, not the
WIndows API.

I suppose I could split this up into one private method and two public
ones,

taking an [out] reference to a string, while the other take an [out]
reference to an int.

method though. I don't use templates much, so I figured this is an
opportunity to learn more.

I read that the compiler generates code based on the T, so I suppose
the errors I am getting make sense about "return cannot convert from _
to_" and makes me believe what I want here cannot be done with
templates, but I want to be sure there isn't another way using
templates.

Here is what I tried initially:

     class RegistrySettings
     {
     public:

         /// The one and only registry key for the .....
         static const std::wstring MYCOMPONENT_REG_KEY;

         ~RegistrySettings();
         static const RegistrySettings * Instance();

         template<typename T>
         const T GetValue(const std::wstring& valueName) const
         {
             HKEY registryKey = NULL;
             DWORD disposition = 0;

             if( ERROR_SUCCESS != RegCreateKeyEx(HKEY_LOCAL_MACHINE,

RegistrySettings::MYCOMPONENT_REG_KEY.c_str(),
                                                 0,
                                                 NULL,

REG_OPTION_NON_VOLATILE,
                                                 KEY_ALL_ACCESS,
                                                 NULL,
                                                 &registryKey,
                                                 &disposition) )
             {
                 // Unexpected error
             }

             boost::scoped_array<TCHAR> buffer;
             DWORD bufferSize = (MAX_PATH / 2) *
sizeof(TCHAR);
             DWORD type = 0;
             DWORD result = 0;

             do
             {
                 bufferSize *= 2;
                 buffer.reset(new TCHAR[bufferSize]);

                 result = RegQueryValueEx(registryKey,
                                          valueName.c_str(),
                                          NULL,
                                          &type,
                                          reinterpret_cast<BYTE
*>(buffer.get()),
                                          &bufferSize);

             }while(result == ERROR_MORE_DATA);

             if( result != ERROR_SUCCESS )
             {
                 // Unexpected Error
             }

             if( ERROR_SUCCESS != RegCloseKey(registryKey) )
             {
                 // Unexpected Error
             }

             switch(type)
             {
             case REG_DWORD:
                 return boost::lexical_cast<DWORD>(buffer.get());

             case REG_SZ:
                 return std::wstring(buffer.get());

             case REG_EXPAND_SZ:
                 boost::scoped_array<TCHAR> expandedBuffer;
                 DWORD expandedBufferSize =
(MAX_PATH / 2) * sizeof(TCHAR);
                 DWORD characterCount = 0;

                 characterCount =
ExpandEnvironmentStrings(buffer.get(),

expandedBuffer.get(),

expandedBufferSize);

                 while( characterCount> expandedBufferSize )
                 {
                     // Buffer was too small, retry
                     // TODO - TEST THIS for infinite loop!!!
                     expandedBufferSize = characterCount;
                     expandedBuffer.reset(new
TCHAR[expandedBufferSize]);

                     characterCount =
ExpandEnvironmentStrings(buffer.get(),

expandedBuffer.get(),

expandedBufferSize);
                 }

                 if( !characterCount )
                 {
                     // Unexpected Error
                 }

                 return std::wstring(expandedBuffer.get());

             default:
                 throw common::NotImplementedException(__WFILE__,
__LINE__)<< L"The registry value type cannot be converted."<<
valueName;
             }

          }

     private:

         RegistrySettings();
         RegistrySettings(const RegistrySettings& rhs);

         static const RegistrySettings * m_instance;
     };

}

#endif // REGISTRY_STRINGS