#ifndef THREADSAFELOOKUP_HPP
#define THREADSAFELOOKUP_HPP

#include <QtCore/QHash>
#include <QtCore/QMutex>

#include <boost/optional.hpp>

struct Nothing {
  Nothing() {}
  Nothing(const Nothing&) {}
  Nothing(const Nothing*) {}
};

template <bool Locks>
struct Locking {
  typedef QMutex Lock_t;
  typedef QMutexLocker Locker_t;
};

template <>
struct Locking<false> {
  typedef Nothing Lock_t;
  typedef Nothing Locker_t;
};

template <typename Key_t, typename Value_t, bool isLocking = true>
class ThreadSafeLookup {

private:
  typedef QHash<Key_t, Value_t> map_t;
  map_t map;

  mutable typename Locking<isLocking>::Lock_t masterLock;
public:

  boost::optional<Value_t> value(const Key_t& key) const
  {
    boost::optional<Value_t> retVal;
    typename Locking<isLocking>::Locker_t lock(&masterLock);
    typename map_t::const_iterator c = map.find(key);
    if (c != map.end()) {
      retVal = c.value();
    }
    return retVal;
  }

  bool insert(const Key_t& key, const Value_t& value, bool forceInsert = false)
  {
    typename Locking<isLocking>::Locker_t lock(&masterLock);
    typename map_t::iterator c = map.find(key);
    bool exists = (c != map.end());

    if (exists) {
      c.value() = value;
    }
    else {
      map.insert(key, value);
    }
    return exists;
  }
};

#endif //THREADSAFELOOKUP_HPP