How to make derived class do actions before calling base class?

Question

Before anything: I'm not a developer and I might not understand some of your messages, and as English is not my native language my question could be hard to understand.

Considering :

class MyVector  
{
    std::vector<command> vec;
    std::mutex vector_m;

public:
    void MVpush_back(command t)
    {
        this->vector_m.lock();
        this->vec.push_back(t);
        this->vector_m.unlock();
    }

};

command is a custom class (its content doesn't seem relevant here; copy constructor does exist).

Basically, as I have a lot of possible writer & readers, thus I want to force the use of the mutex to access to the vec parameter.

As I'll only use push_back(), erase() and find() I could redefine them, but I was wondering if there is a way not have to redefine all functions.

something like:

 <template> safe(*function name*<template>)
 {
   this->vector_m.lock();
   <template> retval = vec.*function name*<parameter>;
   this->vector_m.unlock();
   return retval;
 }

where the function to call is a kind of parameter...

I thought it could be done using std::initializer_list<type> but the type requirement is blocking.

Is there a way to do such a thing?

Rephrased question: is there a way to push a function with parameter(1) as parameter of a function(2) and make function(2) call function(1) ?

Answer 1

If you don't mind sacrificing the use of the member access operator (.), you can wrap all the vector operations neatly into lockable operations.

class MyVector {
  std::vector<command> vec;
  std::mutex vector_m;

  struct locker {
    MyVector& _ref;
    locker(MyVector& parent) : _ref(parent) {
      _ref.vector_m.lock();
    }
    ~locker() { _ref.vector_m.unlock(); }

    std::vector<command>* operator->() && { return &_ref.vec; }
  };

  public:
    locker operator->() { return {*this}; }
};

Now, every access to the underlying vector will lock and unlock the vector for the duration of the operation:

MyVector mv;
mv->push_back(/* ... */);
// This locks the mutex before doing the push back
// And unlocks it immediately after, even in the face of exceptions.

The magic is in operator-> acting in a transitive manner. It is applied to the return value of itself until a regular pointer is returned, which is then accessed as usual. But every temporary along the way is created and destroyed in LIFO order. So the temporary MyVector::locker object has a lifetime that is just the duration of the access more or less.

Answer 2

Here's a quick not particularly fantastic version of the suggestion I made in the comments; not compiled or tested; just something so that you can get the idea.

template<class T>
class OverkillProtector {
private:
    T& d;
    std::unique_lock<std::mutex>lock ;

public:
    OverkillProtector(T& d_, std::mutex& m_) :
        d(d_),
        lock(m_)
    {}
    OverkillProtector(const OverkillProtector&) = delete;
    OverkillProtector& operator =(const OverkillProtector&) = delete;

    T& getValue() { return d; }
    const T& getValue() const { return d; }
};

Note that in the (default) desturctor, the unique lock will be destroyed, which will release the mutex. Note that the lifetime of this object is required to be less than that of the mutex or the data you're wrapping.

Answer 3

A template approach might look like this:

class MyVector
{
    std::vector<command> vec;
    mutable std::mutex vector_m;
public:
    template <typename R, typename ... T, typename ... P>
    R safeCall(R (std::vector<command>::*f)(T ...), P&& ... p)
    {
        std::lock_guard<std::mutex> l(vector_m);
        return (vec.*f)(std::forward<P>(p)...);
    }
    template <typename R, typename ... T, typename ... P>
    R safeCall(R (std::vector<command>::*f)(T ...) const, P&&  ... p) const
    {
        std::lock_guard<std::mutex> l(vector_m);
        return (vec.*f)(std::forward<P>(p)...);
    }
};

void test()
{
    MyVector v;
    v.safeCall(&std::vector<int>::push_back, 7);
    MyVector const* vv = &v;
    int n = vv->safeCall(&std::vector<int>::operator[], 0);
}

Well, you safe the work of re-implementing the interface, but usage gets rather ugly – typedef for the vector type gets it minimally shorter, but still... A macro?

#define safe_call(V, R, F, ...) V R safeCall(&std::vector<int>::F, ## __VA_ARGS__)
safe_call(v, ., push_back, 7);
safe_call(vv, ->, operator[], 1);

Or a little shorter:

#define safe_call(V, F, ...) V safeCall(&std::vector<int>::F, ## __VA_ARGS__)
safe_call(v., push_back, 7);
safe_call(vv->, operator[], 1);

Well, I won't comment further, decide yourself...

In the end, you might bite the bullet and really duplicate the interface for the sake of more convenient usage afterwards - a helper template might facilitate the task, though:

class MyVector
{
    std::vector<command> vec;
    mutable std::mutex vector_m;

    template <typename R, typename ... T>
    R safeCall(R (std::vector<command>::*f)(T...), T... t)
    {
        std::lock_guard<std::mutex> l(vector_m);
        return (vec.*f)(t...);
    }
    // const variant, too
public:
    // ...
};

void MyVector::push_back(Command t)
{
    safeCall(&std::vector<Command>::push_back, t);
}

Answer 4

You might do something like:

class MyVector  
{
    std::vector<command> vec;
    std::mutex vector_m;
public:
    template <typename F>
    decltype(auto) Do(F&& f)
    {
        std::unique_lock<std::mutex> lock{vector_m};
        return std::forward<F>(f)(vec);
    }
};

With usage similar to:

MyVector myVector;
command myCommand;

myVector.Do([&](auto& vec) { vec.push_back(myCommand); });