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