registry.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_GLUE_REGISTRY_HEADER
#define LIBFILEZILLA_GLUE_REGISTRY_HEADER

 
#include "../libfilezilla.hpp"
 
#ifdef FZ_WINDOWS
 
#include "windows.hpp"
 
#include <optional>
#include <string>
 
namespace fz {

class FZ_PUBLIC_SYMBOL regkey final
{
public:
    regkey() = default;
    ~regkey();
 
    enum regview {
        regview_native,
        regview_32,
        regview_64
    };
 

    explicit regkey(HKEY const root, std::wstring const& subkey, bool readonly, regview v = regview_native);
 
    regkey(regkey const&) = delete;
    regkey& operator=(regkey const&) = delete;
 
    void close();

    bool open(HKEY const root, std::wstring const& subkey, bool readonly, regview v = regview_native);
 
    bool has_value(std::wstring const& name) const;

    std::wstring value(std::wstring const& name) const;

    uint64_t int_value(std::wstring const& name) const;
 
    bool set_value(std::wstring const& name, std::wstring const& value);
    bool set_value(std::wstring const& name, uint64_t value);
 
    explicit operator bool() const {
        return key_.has_value();
    }
 
    bool delete_value(std::wstring const& name);
 
    struct iterator final
    {
        struct value final
        {
            std::wstring name;
            DWORD type{};
        };
 
        iterator() = default;
 
        iterator &operator++()
        {
            if (key_ && key_->key_) {
                DWORD len{16383};
                v_.name.resize(len);
 
                DWORD res = RegEnumValueW(*key_->key_, ++index_, v_.name.data(), &len, nullptr, &v_.type, nullptr, nullptr);
                if (res != ERROR_SUCCESS || !len) {
                    index_ = DWORD(-1);
                }
                else {
                    v_.name.resize(len);
                }
            }
            return *this;
        }
 
        bool operator==(iterator const& op) const
        {
            return index_ == op.index_;
        }
 
        bool operator!=(iterator const& op) const
        {
            return !(*this == op);
        }
 
        value const& operator*() const
        {
            return v_;
        }
 
        value const* operator->() const
        {
            return &v_;
        }
 
    private:
        friend regkey;
 
        iterator(regkey const* key)
            : key_(key)
        {
            operator++();
        }
 
        regkey const* key_{};
        DWORD index_{DWORD(-1)};
        value v_;
    };
    using const_iterator = iterator;
 
    iterator begin() const
    {
        return { this };
    }
 
    iterator end() const
    {
        return {};
    }
 
    const_iterator cbegin() const
    {
        return { this };
    }
 
    const_iterator cend() const
    {
        return {};
    }
 
private:
    mutable std::optional<HKEY> key_;
};
}
 
#else
#error This file is for Windows only
#endif
 
#endif