sprint/gtl/configuration.h

Go to the documentation of this file.

/******************************************************************************
 *  GTL: GUI Template Library 
 *    A Cross Platform C++ Wrapper for Win32 users
 *  Copyright (C) 2007-2011 Paolo Medici (www.pmx.it)
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 *******************************************************************************/

#ifndef _SPRINT_CONFIGURATION_H
#define _SPRINT_CONFIGURATION_H

#include <windows.h>
#include <sprint/gtl/Registry.h>
#include <string>

namespace sprint {
        namespace gtl {

class ReadConfiguration : public Registry {
        public:
                ReadConfiguration(const char *key) : Registry(HKEY_CURRENT_USER, key) { }
                ~ReadConfiguration() { }
        
        inline bool reading() const { return true; }
        inline bool writing() const { return false; }
                
        template<class T, class R>
        inline void operator() (LPCSTR path, T &value, R _default) { if(!Read(path, &value)) value = _default;  }

        template<class T>
        inline bool operator() (LPCSTR path, T &value) { return Read(path, &value);  }
        
        inline void str (LPCSTR path, char * buffer, int buflen, const char * _default) 
                        { 
                                if(!Read(path, buffer, buflen)) strcpy(buffer, _default);  
                        }

        inline bool str (LPCSTR path, char * buffer, int buflen) 
                        { 
                                return Read(path, buffer, buflen);  
                        }

    template<class T>
        inline bool data (LPCSTR path, T & dst) 
                        { 
                                return Read(path, (LPSTR) &dst, sizeof(T));  
                        }

};

class WriteConfiguration : public Registry {
        public:
                WriteConfiguration(const char *key) : Registry(HKEY_CURRENT_USER, key) { }
                ~WriteConfiguration() { }

        inline bool reading() const { return false; }
        inline bool writing() const { return true; }
                        
        template<class T, class R>
        inline void operator() (LPCSTR path, T value, R _default) { Write(path, value);  }

        template<class T>
        inline bool operator() (LPCSTR path, T value) { Write(path, value); return true;  }
        
        inline void str (LPCSTR path, const char * buffer, int buflen, const char * _default) 
                        { 
                                Write(path, buffer);  
                        }

        inline bool str (LPCSTR path, const char * buffer, int buflen) 
                        { 
                                Write(path, buffer);  
                                return true;
                        }
    template<class T>
        inline bool data (LPCSTR path, const T & dst) 
                        { 
                                return RegSetValueExA (
                          hRegKey,
                          path,
                          0,
                          REG_BINARY,
                          (LPBYTE) &dst,
                          sizeof(T)
                           );
                        }

};

}
}

#endif // SPRINT_CONFIGURE_H