HashedLock.h

#pragma once

#include <Poco/Exception.h>
#include <Poco/SharedPtr.h>

#include <vector>

namespace BeeeOn {

template <typename LockType, typename ID, typename Hash = typename ID::Hash>
class HashedLock {
public:
        typedef LockType Lock;
        typedef Poco::SharedPtr<HashedLock<Lock, ID, Hash>> Ptr;

        HashedLock();

        HashedLock(unsigned int count);

        void delayedInit(unsigned int count);

        Lock &find(const ID &id);

        Lock &at(const unsigned int index);

        unsigned int size() const;

protected:
        void assureInitialized();

private:
        std::vector<Lock> m_lock;
};

template <typename Lock, typename ID, typename Hash>
HashedLock<Lock, ID, Hash>::HashedLock():
        HashedLock<Lock, ID, Hash>(0)
{
}

template <typename Lock, typename ID, typename Hash>
HashedLock<Lock, ID, Hash>::HashedLock(unsigned int count):
        m_lock(count)
{
}

template <typename Lock, typename ID, typename Hash>
void HashedLock<Lock, ID, Hash>::delayedInit(unsigned int count)
{
        if (count == 0) {
                throw Poco::InvalidArgumentException(
                        "HashedLock must be initialized by non-zero count of locks");
        }

        if (m_lock.empty()) {
                m_lock = std::vector<Lock>(count);
        }
        else {
                throw Poco::InvalidAccessException(
                        "delayedInit() can be called only once");
        }
}

template <typename Lock, typename ID, typename Hash>
Lock &HashedLock<Lock, ID, Hash>::find(const ID &id)
{
        assureInitialized();

        Hash hash;
        const unsigned int index = hash(id) % size();
        return at(index);
}

template <typename Lock, typename ID, typename Hash>
Lock &HashedLock<Lock, ID, Hash>::at(const unsigned int index)
{
        assureInitialized();
        return m_lock[index];
}

template <typename Lock, typename ID, typename Hash>
unsigned int HashedLock<Lock, ID, Hash>::size() const
{
        return m_lock.size();
}

template <typename Lock, typename ID, typename Hash>
void HashedLock<Lock, ID, Hash>::assureInitialized()
{
        if (m_lock.empty()) {
                throw Poco::IllegalStateException(
                        "HashedLock has not been initialized yet");
        }
}

}