Re: utilizing a map with ofstreams, and a map with mutexes
In article <zOGdnenl8-LjmNDZRVn-qw@giganews.com>, clehew2
@cox-dot-net.no-spam.invalid says...
[ ... ]
typedef map<char, ofstream*> map_type;
typedef map<char, mutex*> mutex_type;
void cpApp::write_to_file(string w){
char first = *w.begin();
map_type::iterator i = stream_map.find(first);
mutex_type::iterator j = mutex_map.find(first);
mutex::scoped_lock lock (( *j->second ) );
//won't work
(*i->second) << w << endl;
//won't work
}
//basically I need to be able to access the mutex referenced in the
mutex_map, lock it, then use the referenced ofstream in the
stream_map to write the string to a file. Please let me know if I
need to provide any more information, and Thanks in advance for any
help^^
I'd separate this into two parts: one that knows how to
do mutex-protected writes to a stream, and another that
knows your special requirements for the collection of
streams (such as the stream being selected by the first
character of the string being written).
class atomic_stream {
mutex m;
std::ofstream stream;
public:
atomic_stream(std::string name) :
stream(name.c_str())
{}
void write(std::string w) {
mutex::scoped_lock lock(m);
stream << w << std::endl;
}
};
class logger {
typedef std::map<char, atomic_stream *> m_t;
m_t streams;
public:
logger() {
for (char i='a'; i<'z'; ++i) {
std::string name(1, i);
streams.insert(
std::make_pair(i,
new atomic_stream(name)));
}
}
~logger() {
m_t::iterator i;
for (i=streams.begin(); i!=streams.end(); ++i)
delete i->second;
}
void write(std::string const &w) {
m_t::iterator i = streams.find(w[0]);
if (i!=streams.end())
i->second->write(w);
else
throw std::out_of_range("No such stream");
}
};
Depending on what mutex class you're using (looks like
boost's, probably?) the usage above might need minor
adjustment, such taking the address of the mutex object
instead of it being passed by reference. Most of the
basic structure should be reasonably sound though.
One point sticks out here, at least in my mind: all the
mutex locking and unlocking is encapsulated in one tiny
bit of code, outside of which the mutex becomes
invisible. This makes reasoning about the correctness of
the mutex usage much easier as a rule. And especially for
multithreaded programming, you really need to rely on
reasoning, not testing, to be at all sure things will
work.
--
Later,
Jerry.
The universe is a figment of its own imagination.
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]