boost::try_mute x mutex--code review/your advise-comments

[g]

hello!

here is some code:
#ifndef RESOURCE_H_
#define RESOURCE_H_

#include <boost/date_time/gregorian/gregorian.hpp>
#include <boost/thread/mutex.hpp>
#include <map>

class Resource
{
public:
Resource(int id,bool free);
virtual ~Resource();
bool findAvailiable( const boost::gregoria n::date_period& );
bool checkPeriod(con st boost::gregoria n::date_period& );
bool addReservation( const boost::gregoria n::date_period& );
int id()const {return ID;}
void delOutOfDate();
bool trylock()
{
return try_lock.try_lo ck();
}
void unlock()
{
try_lock.unlock ();
}
private:
int ID;
bool free_;
typedef std::map<boost: :gregorian::dat e,boost::gregor ian::date_perio d>
Reserved;
Reserved reserved;
Reserved::itera tor iter;
Reserved::itera tor range_start;
Reserved::itera tor range_end;
boost::try_mute x mutex;
boost::try_mute x::scoped_try_l ock try_lock;

};

#endif /*RESOURCE_H_*/

#include "Resource.h "

Resource::Resou rce(int id,bool
free):ID(id),fr ee_(free),iter( reserved.begin( )),try_lock(mut ex,false)
{

}

Resource::~Reso urce()
{
try_lock.unlock ();
}

bool Resource::findA vailiable(const boost::gregoria n::date_period&
period)
{
boost::gregoria n::days days_length=per iod.length();
boost::gregoria n::days size(1);
int length=days_len gth.days();
if(length>15)
{
boost::gregoria n::date_duratio n d(2);
size=d;
}
short a=0;
while(a<3)
{
period.begin()+ size;
period.end()-size;
if(checkPeriod( period))return true;
a++;
}
return false;
}

bool Resource::check Period(const boost::gregoria n::date_period& period)
{
range_start=res erved.lower_bou nd(period.begin ());
range_end=reser ved.upper_bound (period.end());
while(range_sta rt!=range_end)
{
if(period.inter sects(range_sta rt->second))retu rn false;
range_start++;
}
return true;
}

bool Resource::addRe servation(const boost::gregoria n::date_period&
period)
{
range_start=res erved.lower_bou nd(period.begin ());
range_end=reser ved.upper_bound (period.end());
while(range_sta rt!=range_end)
{
if(period.inter sects(range_sta rt->second))retu rn false;
range_start++;
}
reserved.insert (std::pair<boos t::gregorian::d ate,boost::greg orian::date_per iod>(period.beg in(),period));
return true;
}

void Resource::delOu tOfDate()
{
boost::gregoria n::date now(boost::greg orian::day_cloc k::local_day()) ;
while(iter != reserved.end())
{
if(iter->second.last()< now)
{
reserved.erase( iter->second.begin() );
}
}
}
the way I access resources
bool ResourceManager ::reserveResour ce(const
boost::gregoria n::date_period& period)
{
Reserved::itera tor iter;
iter=reserved.b egin();
while(iter!=res erved.end())
{
if(iter->second->trylock())
{
if(iter->second->addReservation (period))
{
iter->second->unlock();
return true;
}
iter->second->unlock();
}
iter++;
}
return false;
}
is this thread-safe enough??

I will use a singleton for the ResourceManager
Singleton<Resou rceManager>::in stance()->reserveResourc e(some_period);
having this design I can( I hope! ) have n parallel accesses(search ing
/ reserve)
where n is the number of resources.
any sugestion in general?

thanks!

[Axter]

g wrote:

hello!

here is some code:
#ifndef RESOURCE_H_
#define RESOURCE_H_

#include <boost/date_time/gregorian/gregorian.hpp>
#include <boost/thread/mutex.hpp>
#include <map>

class Resource
{
public:
Resource(int id,bool free);
virtual ~Resource();
bool findAvailiable( const boost::gregoria n::date_period& );
bool checkPeriod(con st boost::gregoria n::date_period& );
bool addReservation( const boost::gregoria n::date_period& );
int id()const {return ID;}
void delOutOfDate();
bool trylock()
{
return try_lock.try_lo ck();
}
void unlock()
{
try_lock.unlock ();
}
private:
int ID;
bool free_;
typedef std::map<boost: :gregorian::dat e,boost::gregor ian::date_perio d>
Reserved;
Reserved reserved;
Reserved::itera tor iter;
Reserved::itera tor range_start;
Reserved::itera tor range_end;
boost::try_mute x mutex;
boost::try_mute x::scoped_try_l ock try_lock;

};

#endif /*RESOURCE_H_*/

#include "Resource.h "

Resource::Resou rce(int id,bool
free):ID(id),fr ee_(free),iter( reserved.begin( )),try_lock(mut ex,false)
{

}

Resource::~Reso urce()
{
try_lock.unlock ();
}

bool Resource::findA vailiable(const boost::gregoria n::date_period&
period)
{
boost::gregoria n::days days_length=per iod.length();
boost::gregoria n::days size(1);
int length=days_len gth.days();
if(length>15)
{
boost::gregoria n::date_duratio n d(2);
size=d;
}
short a=0;
while(a<3)
{
period.begin()+ size;
period.end()-size;
if(checkPeriod( period))return true;
a++;
}
return false;
}

bool Resource::check Period(const boost::gregoria n::date_period& period)
{
range_start=res erved.lower_bou nd(period.begin ());
range_end=reser ved.upper_bound (period.end());
while(range_sta rt!=range_end)
{
if(period.inter sects(range_sta rt->second))retu rn false;
range_start++;
}
return true;
}

bool Resource::addRe servation(const boost::gregoria n::date_period&
period)
{
range_start=res erved.lower_bou nd(period.begin ());
range_end=reser ved.upper_bound (period.end());
while(range_sta rt!=range_end)
{
if(period.inter sects(range_sta rt->second))retu rn false;
range_start++;
}
reserved.insert (std::pair<boos t::gregorian::d ate,boost::greg orian::date_per iod>(period.beg in(),period));
return true;
}

void Resource::delOu tOfDate()
{
boost::gregoria n::date now(boost::greg orian::day_cloc k::local_day()) ;
while(iter != reserved.end())
{
if(iter->second.last()< now)
{
reserved.erase( iter->second.begin() );
}
}
}
the way I access resources
bool ResourceManager ::reserveResour ce(const
boost::gregoria n::date_period& period)
{
Reserved::itera tor iter;
iter=reserved.b egin();
while(iter!=res erved.end())
{
if(iter->second->trylock())
{
if(iter->second->addReservation (period))
{
iter->second->unlock();
return true;
}
iter->second->unlock();
}
iter++;
}
return false;
}
is this thread-safe enough??

I don't see any thing checking for a successful lock.
try_lock logic should be used with is_lock logic to verify the lock is
successful.
If it's not going to check, then you should use lock instead of try_lock

[g]

if(iter->second->trylock())

this is the check!
trylock() returns true/false.

[g]

bool trylock()//should be exception-safe
{
try{
try_lock.try_lo ck();
return true;
catch(boost::lo ck_error& e){}
return false;
}

I am still waiting for your advises :-)