Concurrent Map for c++

ConcurrentMap.hpp

#pragma once 

#include <mutex>
#include <map>
#include <functional>
#include <chrono>

template<class keyType, class dataType>
class ConcurrentMap {
    std::map<keyType, dataType> dataMap;
    std::timed_mutex ConcurrentMapLock;

public:

    void insert(const std::pair<keyType, dataType> &toinsert) {
        std::lock_guard<std::timed_mutex> lck(ConcurrentMapLock);
        auto found = dataMap.find(toinsert.first);
        if( found == dataMap.end()) {
            dataMap.insert(toinsert);
        }
    }

    void erase(keyType key) {
        std::lock_guard<std::timed_mutex> lck(ConcurrentMapLock);
        if(dataMap.find(key) != dataMap.end()) {
            dataMap.erase(key);
        }
    }

    int thread_safe_operation(
        std::function<int(std::map<keyType, dataType>&)> thread_safe_fcall) {

        std::lock_guard<std::timed_mutex> lck(ConcurrentMapLock);
        int ret = thread_safe_fcall(dataMap);
        return ret;
    }

    int thread_safe_operation_with_timeout(
        std::function<int(std::map<keyType, dataType>&)> thread_safe_fcall,
        std::chrono::milliseconds timeout) {

        if(ConcurrentMapLock.try_lock_for(timeout)) {
            std::lock_guard<std::timed_mutex> lck(ConcurrentMapLock, std::adopt_lock_t());
            int ret = thread_safe_fcall(dataMap);
            return ret;
        }
        return -1;
    }
};