How to avoid duplicate code including std::map and std::mutex - c++

Question

I have a class including a map, and a mutex. In every member function the mutex protects the map from multiple thread accessing the object of this class, for ex:
class bar
{
public:
void hello() {}
void set_something(int x) {}
int get_something(int x, int y) { return x + y; }
};
class foo
{
public:
foo()
{
m_map[0];
m_map[1];
m_map[2];
}
void hello(unsigned int index)
{
std::lock_guard<std::mutex> lock(m_mut);
const auto iter = m_map.find(index);
if (iter != m_map.end())
iter->second.hello();
}
void set_something(unsigned int index, int x)
{
std::lock_guard<std::mutex> lock(m_mut);
const auto iter = m_map.find(index);
if (iter != m_map.end())
iter->second.set_something(x);
}
int get_something(unsigned int index, int x, int y)
{
std::lock_guard<std::mutex> lock(m_mut);
const auto iter = m_map.find(index);
if (iter != m_map.end())
return iter->second.get_something(x, y);
return 0;
}
private:
std::mutex m_mut;
std::map<unsigned int, bar> m_map;
};
Is there an elegant method to avoid duplicate code?

Answer 1

You could use a proxy and RAII like this :
#include <iostream>
#include <mutex>
#include <map>
template < typename F, typename S>
struct mutex_map {
std::recursive_mutex m_;
std::map<F,S> map_;
struct Proxy {
Proxy( std::map<F,S> & map, std::recursive_mutex &m ) : map_(&map), lock_(m) {
std::cout << "lock\n";
}
~Proxy() { std::cout << "unlock\n"; }
std::map<F,S>* map_;
std::unique_lock<std::recursive_mutex> lock_;
std::map<F,S>* operator->() { return map_; }
};
Proxy operator->() {
return { map_, m_ };
}
};
int main() {
mutex_map<int, int> mm;
mm->emplace(1, 3);
std::cout << (mm->find(1) == mm->end()) << "\n";
std::cout << (mm->find(2) == mm->end()) << "\n";
}

Answer 2

You can move common part into "do_something" and pass functor into it:
...
void do_something(const std::function<void(bar&)>& func)
{
std::lock_guard<std::mutex> lock(m_mut);
const auto iter = m_map.find(index);
if (iter != m_map.end())
func(std::ref(*iter));
}
int get_something(unsigned int index, int x, int y)
{
do_something(std::bind(&bar::get_something, std::placeholders::_1, index, x, y));
}
...
One question - do you need to protect with mutex only std::map or std::map and its elements? You may think about granularity