C++ adapting a library for multithreading

Question

I'm working with libconfig++ and threads for making a small server application. The point is, libconfig++ is not thread safe, so my idea is to create another class which acts as a wrapper with a Mutex, something like this:

class app_config {
public:
    app_config();
    /* Here be my problems. */
    void set(); 
    void get();
    virtual ~app_config();

private:
    Config cfg;
    boost::mutex *cfg_mutex;
};

Now, this is all good until I realize that libconfig supports plenty of types for its variables. And thats when our protagonist (me) finds himself in search of any C++ guru with a kind heart willing to show him any way to get this working.

Essentially, the get and set functions would need a std::string or a char* path variable containing the path to the configuration file's variable (I wouldn't mind using either) and the return type (or the second argument in the set's case) should vary...

As always, any help will be appreciated.

Julian

Be careful with lifetime management of the mutex. Either make `app_config` noncopyable and use a `mutex` member (instead of a `mutex*`) or use a `unique_ptr` member and define your own copy operations to create a new instance. — James McNellis, Jan 14 '12 at 03:28
Oh, this is because of the mutex being noncopyable, right?. Thanks!. — Misguided, Jan 14 '12 at 03:33

score 1 · Answer 1 · answered Jan 14 '12 at 04:07

You could write a decorator class that forwards all function calls to a private libconfig instance. This means you need to add all the functions you want to use to your decorator. Another possibility is to forward the call to libconfig to a class that does the actual locking.

#include <boost/thread/mutex.hpp>
#include <boost/thread/locks.hpp>
#include <boost/bind.hpp>

class MultithreadingWrapper {
public:
    template <class V, class T>
    V ExecuteThreadSaveWithReturn(T func) {
        boost::lock_guard<boost::mutex> l(m_Mutex);
        return func();
    }

    template <class T>
    void ExecuteThreadSave(T func) {
        boost::lock_guard<boost::mutex> l(m_Mutex);
        func();
    }

private:
    boost::mutex m_Mutex;
};

void f() {}
void f(int) { }
int f(int, int) { return 0; }

int main() {
    MultithreadingWrapper wrapper;
    wrapper.ExecuteThreadSave(boost::bind(f));
    wrapper.ExecuteThreadSave(boost::bind(f, 1));
    int i = wrapper.ExecuteThreadSaveWithReturn<int>(boost::bind(f, 1, 1));
    return i;
}

This is a really good approach, I'll keep the question open though, kind of interested in seeing what other alternatives there are. EDIT: what would actually happen with exceptions? — Misguided, Jan 14 '12 at 04:14
@JulianBayardoSpadafora Exceptions would propagate through the wrapper and should be handled where you call wrapper.ExecuteThreadSave. The lock would be reset even when a exception is thrown since the lock is deleted at the end of the ExecuteThreadSave function. — David Feurle, Jan 14 '12 at 04:35

score 1 · Accepted Answer · answered Jan 14 '12 at 04:47

You could as well use this approach. I think it more difficult to missuse and therefore superior. The Libconfig instance is a private member inside of the wrapper and can't be accessed without a lock.

#include <boost/thread/mutex.hpp>
#include <boost/thread/locks.hpp>
#include <boost/shared_ptr.hpp>

class Libconfig {
public:
    int Get(const char*) { return 0; }
};

class LibConfLock;

class LibconfMultithreadingWrapper {
    friend class LibConfLock;
public:
    LibconfMultithreadingWrapper()
        :m_Libconfig(new Libconfig())
        ,m_Mutex(new boost::mutex())
    {}

private:
    boost::shared_ptr<Libconfig> m_Libconfig;
    boost::shared_ptr<boost::mutex> m_Mutex;
};

class LibConfLock  {
public:
    LibConfLock(const LibconfMultithreadingWrapper& wrapper)
        :m_Libconfig(wrapper.m_Libconfig)
        ,m_Mutex(wrapper.m_Mutex)
        ,m_Lock(new LockType(*m_Mutex))
    {}
    Libconfig& GetLibconf() const { return *m_Libconfig; }
private:
    typedef boost::lock_guard<boost::mutex> LockType;
    boost::shared_ptr<Libconfig> m_Libconfig;
    boost::shared_ptr<boost::mutex> m_Mutex;
    boost::shared_ptr<LockType> m_Lock;
};

int main() {
    LibconfMultithreadingWrapper wrapper;
    int i = LibConfLock(wrapper).GetLibconf().Get("hallo");

    return i;
}

C++ adapting a library for multithreading

2 Answers2

Linked