This is firmly in n00b territory.
I'm trying to use a boost::mutex to lock a STL queue. The mutex is stored
in a class in a map. When I pass the mutex to the boost::mutex::scoped_lock
constructor, I get this error:
/usr/local/include/boost/noncopyable.hpp: In copy constructor
‘boost::mutex::mutex(const boost::mutex&)’:
/usr/local/include/boost/thread/pthread/mutex.hpp:31: instantiated from
‘_Tp& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const _Key&) [with
_Key = int, _Tp = boost::mutex, _Compare = std::less<int>, _Alloc =
std::allocator >]’
SwitchBox.cpp:15: instantiated from here
/usr/local/include/boost/noncopyable.hpp:27: error:
‘boost::noncopyable_::noncopyable::noncopyable(const
boost::noncopyable_::noncopyable&)’ is private
/usr/local/include/boost/thread/pthread/mutex.hpp:31: error: within this
context
/usr/include/c++/4.2.1/bits/stl_map.h: In member function ‘_Tp&
std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const _Key&) [with _Key =
int, _Tp = boost::mutex, _Compare = std::less<int>, _Alloc =
std::allocator >]’:
/usr/include/c++/4.2.1/bits/stl_map.h:350: note: synthesized method
‘boost::mutex::mutex(const boost::mutex&)’ first required here
This appears to be complaining about me passing the mutex into the
scoped_lock. Can anyone give me some help here? I've included a much
shortened version of the code that otherwise compiles.
Thanks for your help,
Wesley
SwitchBox.hpp
-----
#include <map>
#include <queue>
#include
#include
using boost::asio::ip::tcp;
using namespace std;
namespace Network {
typedef struct Message {
int type;
unsigned long sender;
unsigned long destination;
int size;
void *body;
char *PackHeader();
void UnpackHeader(char *);
} Message;
class SwitchBox {
protected:
unsigned long myID;
int headerSize;
map< int, queue< Message > > sendQueues;
map< int, boost::mutex > sendMutexes;
bool Initialize();
void SendThread(unsigned long id, tcp::socket sock);
};
}
SwitchBox.cpp
------
#include "Switchbox.hpp"
using namespace Network;
bool SwitchBox::Initialize() {
myID = 0;
headerSize = sizeof(int) + sizeof(unsigned long) * 2 + sizeof(int);
return true;
}
void SwitchBox::SendThread(unsigned long id, tcp::socket sock) {
// Set up the lock so it can be locked and unlocked as we need
boost::mutex::scoped_lock sendLock(sendMutexes[id], boost::defer_lock);
while (true) {
// First get the message off of the message queue
// Lock the message queue so nothing is moved unexpectedly
sendLock.lock();
Message m = sendQueues[id].front();
sendQueues[id].pop();
// Unlock the message queue so everyone else can get to it now
sendLock.unlock();
// Next send the message through the socket
boost::asio::write(sock, boost::asio::buffer(m.PackHeader(), headerSize));
boost::asio::write(sock, boost::asio::buffer((char *) m.body, m.size));
}
}
