UnlockedAccounts.h

Go to the documentation of this file.

 
#pragma once
#include "catapult/cache_core/AccountStateCache.h"
#include "catapult/crypto/KeyPair.h"
#include "catapult/utils/Hashers.h"
#include <vector>
 
namespace catapult { namespace harvesting {
 
#define UNLOCKED_ACCOUNTS_ADD_RESULT_LIST \
    /* Account was successfully unlocked (it might have already been unlocked). */ \
    ENUM_VALUE(Success) \
    \
    /* Account could not be unlocked because it is ineligible for harvesting. */ \
    ENUM_VALUE(Failure_Harvesting_Ineligible) \
    \
    /* Account could not be unlocked because it is blocked from harvesting. */ \
    ENUM_VALUE(Failure_Harvesting_Blocked) \
    \
    /* Account could not be unlocked because limit on the server has been hit. */ \
    ENUM_VALUE(Failure_Server_Limit)
 
#define ENUM_VALUE(LABEL) LABEL,
    enum class UnlockedAccountsAddResult {
        UNLOCKED_ACCOUNTS_ADD_RESULT_LIST
    };
#undef ENUM_VALUE
 
    std::ostream& operator<<(std::ostream& out, UnlockedAccountsAddResult value);
 
    class UnlockedAccountsView : utils::MoveOnly {
    public:
        explicit UnlockedAccountsView(
                const std::vector<crypto::KeyPair>& keyPairs,
                utils::SpinReaderWriterLock::ReaderLockGuard&& readLock)
                : m_keyPairs(keyPairs)
                , m_readLock(std::move(readLock))
        {}
 
    public:
        size_t size() const;
 
        bool contains(const Key& publicKey) const;
 
        auto begin() const {
            return m_keyPairs.cbegin();
        }
 
        auto end() const {
            return m_keyPairs.cend();
        }
 
    private:
        const std::vector<crypto::KeyPair>& m_keyPairs;
        utils::SpinReaderWriterLock::ReaderLockGuard m_readLock;
    };
 
    class UnlockedAccountsModifier : utils::MoveOnly {
    private:
        using KeyPredicate = predicate<const Key&>;
 
    public:
        UnlockedAccountsModifier(
                size_t maxUnlockedAccounts,
                std::vector<crypto::KeyPair>& keyPairs,
                utils::SpinReaderWriterLock::ReaderLockGuard&& readLock)
                : m_maxUnlockedAccounts(maxUnlockedAccounts)
                , m_keyPairs(keyPairs)
                , m_readLock(std::move(readLock))
                , m_writeLock(m_readLock.promoteToWriter())
        {}
 
    public:
        UnlockedAccountsAddResult add(crypto::KeyPair&& keyPair);
 
        void remove(const Key& publicKey);
 
        void removeIf(const KeyPredicate& predicate);
 
    private:
        size_t m_maxUnlockedAccounts;
        std::vector<crypto::KeyPair>& m_keyPairs;
        utils::SpinReaderWriterLock::ReaderLockGuard m_readLock;
        utils::SpinReaderWriterLock::WriterLockGuard m_writeLock;
    };
 
    class UnlockedAccounts {
    public:
        explicit UnlockedAccounts(size_t maxUnlockedAccounts) : m_maxUnlockedAccounts(maxUnlockedAccounts)
        {}
 
    public:
        UnlockedAccountsView view() const;
 
        UnlockedAccountsModifier modifier();
 
    private:
        size_t m_maxUnlockedAccounts;
        std::vector<crypto::KeyPair> m_keyPairs;
        mutable utils::SpinReaderWriterLock m_lock;
    };
}}