Concurrent Map.h

#pragma once
#include<map>
#include<condition_variable>
#include<mutex>
#include<set>
namespace concurrent {

    template<typename K, typename V>
    class map {
    private:
        typedef std::unique_lock<std::mutex> guard;
        typedef std::map<K, V> map_type;
        typedef std::pair<K, V> entry_type;
        map_type _map;
        mutable std::mutex mutex;
        std::condition_variable cond;
    public:
        void insert(const entry_type & e) {
            guard lock(mutex);
            _map.insert(e);
        }

        V & operator[](const K & key) {
            guard lock(mutex);
            return _map[key];
        }

        const V & at(const K & key) const {
            guard lock(mutex);
            return _map.at(key);
        }

        bool contains(const K & key) const {
            guard lock(mutex);
            return _map.find(key) != _map.end();
        }

        bool empty() const {
            guard lock(mutex);
            return _map.empty();
        }

        size_t erase(const K & key) {
            guard lock(mutex);
            return _map.erase(key);
        }

        std::set<K> getKeySet() const {
            guard lock(mutex);
            std::set<K> keys;
            for (const auto & pair : _map) {
                keys.insert(pair.first);
            }
            return keys;
        }
    };
}