anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2024-12-22 05:16:21 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

dont throw, assert or ponder on instead

Browse Source 
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@4184 a592a061-630c-0410-9148-cb99ea01b6c8
This commit is contained in:
Lars Gullik Bjønnes 2002-05-22 06:29:42 +00:00
parent 482c04ecca
commit c7bc2da4a2
4 changed files with 103 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
boost/ChangeLog
View File

@ -1,5 +1,8 @@
2002-05-22 Lars Gullik Bjønnes <larsbj@birdstep.com>
* boost/detail/shared_count.hpp: never throw, assert or ponder on
instead.
* major boost update. (a bit more is comming)
2001-09-07 Jean-Marc Lasgouttes <Jean-Marc.Lasgouttes@inria.fr>

184
boost/boost/detail/shared_count.hpp
View File

@ -26,20 +26,24 @@
#include <boost/detail/lightweight_mutex.hpp>
#include <functional> // for std::less
#if 0
#include <exception> // for std::exception
#endif
namespace boost
{
#if 0
class use_count_is_zero: public std::exception
{
public:
virtual char const * what() const throw()
{
return "use_count_is_zero";
return "use_count_is_zero";
}
};
#endif
class counted_base
{
@ -50,14 +54,14 @@ private:
public:
counted_base():
use_count_(0), weak_count_(0), self_deleter_(&self_delete)
use_count_(0), weak_count_(0), self_deleter_(&self_delete)
{
}
// pre: initial_use_count <= initial_weak_count
explicit counted_base(long initial_use_count, long initial_weak_count):
use_count_(initial_use_count), weak_count_(initial_weak_count), self_deleter_(&self_delete)
use_count_(initial_use_count), weak_count_(initial_weak_count), self_deleter_(&self_delete)
{
}
@ -81,70 +85,74 @@ public:
void add_ref()
{
#ifdef BOOST_HAS_THREADS
mutex_type::scoped_lock lock(mtx_);
mutex_type::scoped_lock lock(mtx_);
#endif
if(use_count_ == 0 && weak_count_ != 0) throw use_count_is_zero();
++use_count_;
++weak_count_;
#if 0
if(use_count_ == 0 && weak_count_ != 0) throw use_count_is_zero();
#else
if(use_count_ == 0 && weak_count_ != 0) assert(false);
#endif
++use_count_;
++weak_count_;
}
void release() // nothrow
{
long new_use_count;
long new_weak_count;
long new_use_count;
long new_weak_count;
{
{
#ifdef BOOST_HAS_THREADS
mutex_type::scoped_lock lock(mtx_);
mutex_type::scoped_lock lock(mtx_);
#endif
new_use_count = --use_count_;
new_weak_count = --weak_count_;
}
new_use_count = --use_count_;
new_weak_count = --weak_count_;
}
if(new_use_count == 0)
{
dispose();
}
if(new_use_count == 0)
{
dispose();
}
if(new_weak_count == 0)
{
// not a direct 'delete this', because the inlined
// release() may use a different heap manager
self_deleter_(this);
}
if(new_weak_count == 0)
{
// not a direct 'delete this', because the inlined
// release() may use a different heap manager
self_deleter_(this);
}
}
void weak_add_ref() // nothrow
{
#ifdef BOOST_HAS_THREADS
mutex_type::scoped_lock lock(mtx_);
mutex_type::scoped_lock lock(mtx_);
#endif
++weak_count_;
++weak_count_;
}
void weak_release() // nothrow
{
long new_weak_count;
long new_weak_count;
{
{
#ifdef BOOST_HAS_THREADS
mutex_type::scoped_lock lock(mtx_);
mutex_type::scoped_lock lock(mtx_);
#endif
new_weak_count = --weak_count_;
}
new_weak_count = --weak_count_;
}
if(new_weak_count == 0)
{
self_deleter_(this);
}
if(new_weak_count == 0)
{
self_deleter_(this);
}
}
long use_count() const // nothrow
{
#ifdef BOOST_HAS_THREADS
mutex_type::scoped_lock lock(mtx_);
mutex_type::scoped_lock lock(mtx_);
#endif
return use_count_;
return use_count_;
}
private:
@ -154,7 +162,7 @@ private:
static void self_delete(counted_base * p)
{
delete p;
delete p;
}
// inv: use_count_ <= weak_count_
@ -195,13 +203,13 @@ public:
// pre: initial_use_count <= initial_weak_count, d(p) must not throw
counted_base_impl(P p, D d, long initial_use_count, long initial_weak_count):
counted_base(initial_use_count, initial_weak_count), ptr(p), del(d)
counted_base(initial_use_count, initial_weak_count), ptr(p), del(d)
{
}
virtual void dispose() // nothrow
{
del(ptr);
del(ptr);
}
};
@ -225,25 +233,29 @@ public:
explicit shared_count(counted_base * pi): pi_(pi) // never throws
{
pi_->add_ref();
pi_->add_ref();
}
template<class P, class D> shared_count(P p, D d, void const * = 0): pi_(0)
{
try
{
pi_ = new counted_base_impl<P, D>(p, d, 1, 1);
}
catch(...)
{
d(p); // delete p
throw;
}
#if 0
try
{
#endif
pi_ = new counted_base_impl<P, D>(p, d, 1, 1);
#if 0
}
catch(...)
{
d(p); // delete p
throw;
}
#endif
}
template<class P, class D> shared_count(P, D, counted_base * pi): pi_(pi)
{
pi_->add_ref();
pi_->add_ref();
}
#ifndef BOOST_NO_AUTO_PTR
@ -253,58 +265,58 @@ public:
template<typename Y>
explicit shared_count(std::auto_ptr<Y> & r): pi_(new counted_base_impl< Y *, checked_deleter<Y> >(r.get(), checked_deleter<Y>(), 1, 1))
{
r.release();
r.release();
}
#endif
#endif
~shared_count() // nothrow
{
pi_->release();
pi_->release();
}
shared_count(shared_count const & r): pi_(r.pi_) // nothrow
{
pi_->add_ref();
pi_->add_ref();
}
explicit shared_count(weak_count const & r); // throws use_count_is_zero when r.use_count() == 0
shared_count & operator= (shared_count const & r) // nothrow
{
counted_base * tmp = r.pi_;
tmp->add_ref();
pi_->release();
pi_ = tmp;
counted_base * tmp = r.pi_;
tmp->add_ref();
pi_->release();
pi_ = tmp;
return *this;
return *this;
}
void swap(shared_count & r) // nothrow
{
counted_base * tmp = r.pi_;
r.pi_ = pi_;
pi_ = tmp;
counted_base * tmp = r.pi_;
r.pi_ = pi_;
pi_ = tmp;
}
long use_count() const // nothrow
{
return pi_->use_count();
return pi_->use_count();
}
bool unique() const // nothrow
{
return pi_->use_count() == 1;
return pi_->use_count() == 1;
}
friend inline bool operator==(shared_count const & a, shared_count const & b)
{
return a.pi_ == b.pi_;
return a.pi_ == b.pi_;
}
friend inline bool operator<(shared_count const & a, shared_count const & b)
{
return std::less<counted_base *>()(a.pi_, b.pi_);
return std::less<counted_base *>()(a.pi_, b.pi_);
}
};
@ -324,59 +336,59 @@ public:
weak_count(shared_count const & r): pi_(r.pi_) // nothrow
{
pi_->weak_add_ref();
pi_->weak_add_ref();
}
weak_count(weak_count const & r): pi_(r.pi_) // nothrow
{
pi_->weak_add_ref();
pi_->weak_add_ref();
}
~weak_count() // nothrow
{
pi_->weak_release();
pi_->weak_release();
}
weak_count & operator= (shared_count const & r) // nothrow
{
counted_base * tmp = r.pi_;
tmp->weak_add_ref();
pi_->weak_release();
pi_ = tmp;
counted_base * tmp = r.pi_;
tmp->weak_add_ref();
pi_->weak_release();
pi_ = tmp;
return *this;
return *this;
}
weak_count & operator= (weak_count const & r) // nothrow
{
counted_base * tmp = r.pi_;
tmp->weak_add_ref();
pi_->weak_release();
pi_ = tmp;
counted_base * tmp = r.pi_;
tmp->weak_add_ref();
pi_->weak_release();
pi_ = tmp;
return *this;
return *this;
}
void swap(weak_count & r) // nothrow
{
counted_base * tmp = r.pi_;
r.pi_ = pi_;
pi_ = tmp;
counted_base * tmp = r.pi_;
r.pi_ = pi_;
pi_ = tmp;
}
long use_count() const // nothrow
{
return pi_->use_count();
return pi_->use_count();
}
friend inline bool operator==(weak_count const & a, weak_count const & b)
{
return a.pi_ == b.pi_;
return a.pi_ == b.pi_;
}
friend inline bool operator<(weak_count const & a, weak_count const & b)
{
return std::less<counted_base *>()(a.pi_, b.pi_);
return std::less<counted_base *>()(a.pi_, b.pi_);
}
};

1
config/ChangeLog
View File

@ -1,6 +1,7 @@
2002-05-22 Lars Gullik Bjønnes <larsbj@birdstep.com>
* lyxinclude.m4 (lyx_warning): add entry for gcc 3.1
(lyx_warning): disable exceptions for gcc 3.1 too
* kde.m4: remove file

2
config/lyxinclude.m4
View File

@ -211,7 +211,7 @@ if test x$GXX = xyes; then
2.95.*) CXXFLAGS="$lyx_opt -fno-exceptions";;
2.96*) CXXFLAGS="$lyx_opt -fno-exceptions";;
3.0*) CXXFLAGS="$lyx_opt -fno-rtti -fno-exceptions";;
3.1*) CXXFLAGS="$lyx_opt";;
3.1*) CXXFLAGS="$lyx_opt -fno-rtti -fno-exceptions";;
*2.91.*) CXXFLAGS="$lyx_opt -fno-rtti -fno-exceptions";;
*) CXXFLAGS="$lyx_opt -fno-rtti -fno-exceptions";;
esac