From 6eedac996204ebc3355807d7f887b0c366cb3c07 Mon Sep 17 00:00:00 2001 From: Christian Bauer Date: Tue, 26 Aug 2003 22:14:37 +0000 Subject: [PATCH] - added some (empty) exception specifications (reduces code size a little) - synced to 1.1 (ex::const_iterator::operator[]) --- ginac/ex.h | 49 ++++++++++++++++++++++++------------------------ ginac/ptr.h | 26 ++++++++++++------------- ginac/symbol.cpp | 2 +- ginac/symbol.h | 8 ++++---- 4 files changed, 43 insertions(+), 42 deletions(-) diff --git a/ginac/ex.h b/ginac/ex.h index ee891a2f..70ce112d 100644 --- a/ginac/ex.h +++ b/ginac/ex.h @@ -69,7 +69,7 @@ class ex // default constructor, copy constructor and assignment operator public: - ex(); + ex() throw(); #ifdef OBSCURE_CINT_HACK ex(const ex & other); ex & operator=(const ex & other); @@ -97,35 +97,35 @@ public: friend class ex; public: - const_iterator() {} - const_iterator(const basic *bp_, size_t i_) : bp(bp_), i(i_) {} + const_iterator() throw() {} + const_iterator(const basic *bp_, size_t i_) throw() : bp(bp_), i(i_) {} - bool operator==(const const_iterator &other) const + bool operator==(const const_iterator &other) const throw() { return bp == other.bp && i == other.i; } - bool operator!=(const const_iterator &other) const + bool operator!=(const const_iterator &other) const throw() { return !(*this == other); } - bool operator<(const const_iterator &other) const + bool operator<(const const_iterator &other) const throw() { return i < other.i; } - bool operator>(const const_iterator &other) const + bool operator>(const const_iterator &other) const throw() { return other < *this; } - bool operator<=(const const_iterator &other) const + bool operator<=(const const_iterator &other) const throw() { return !(other < *this); } - bool operator>=(const const_iterator &other) const + bool operator>=(const const_iterator &other) const throw() { return !(*this < other); } @@ -146,66 +146,67 @@ public: } #endif - const_iterator &operator++() + const_iterator &operator++() throw() { ++i; return *this; } - const_iterator operator++(int) + const_iterator operator++(int) throw() { const_iterator tmp = *this; ++i; return tmp; } - const_iterator &operator+=(difference_type n) + const_iterator &operator+=(difference_type n) throw() { i += n; return *this; } - const_iterator operator+(difference_type n) const + const_iterator operator+(difference_type n) const throw() { return const_iterator(bp, i + n); } - inline friend const_iterator operator+(difference_type n, const const_iterator &it) + inline friend const_iterator operator+(difference_type n, const const_iterator &it) throw() { return const_iterator(it.bp, it.i + n); } - const_iterator &operator--() + const_iterator &operator--() throw() { --i; return *this; } - const_iterator operator--(int) + const_iterator operator--(int) throw() { const_iterator tmp = *this; --i; return tmp; } - const_iterator &operator-=(difference_type n) + const_iterator &operator-=(difference_type n) throw() { i -= n; return *this; } - const_iterator operator-(difference_type n) const + const_iterator operator-(difference_type n) const throw() { return const_iterator(bp, i - n); } - inline friend difference_type operator-(const const_iterator &lhs, const const_iterator &rhs) + inline friend difference_type operator-(const const_iterator &lhs, const const_iterator &rhs) throw() { return lhs.i - rhs.i; } - reference operator[](difference_type n) const + ex operator[](difference_type n) const { + return bp->op(i + n); } protected: @@ -213,8 +214,8 @@ public: size_t i; }; - const_iterator begin() const { return const_iterator(get_pointer(bp), 0); } - const_iterator end() const { return const_iterator(get_pointer(bp), bp->nops()); } + const_iterator begin() const throw() { return const_iterator(get_pointer(bp), 0); } + const_iterator end() const throw() { return const_iterator(get_pointer(bp), bp->nops()); } #if 0 // This doesn't work because of the "reference to temporary" problem @@ -227,7 +228,7 @@ public: // non-virtual functions in this class public: /** Efficiently swap the contents of two expressions. */ - void swap(ex & other) + void swap(ex & other) throw() { GINAC_ASSERT(bp->flags & status_flags::dynallocated); GINAC_ASSERT(other.bp->flags & status_flags::dynallocated); @@ -387,7 +388,7 @@ public: extern const basic *_num0_bp; inline -ex::ex() : bp(*const_cast(_num0_bp)) +ex::ex() throw() : bp(*const_cast(_num0_bp)) { GINAC_ASSERT(bp->flags & status_flags::dynallocated); #ifdef OBSCURE_CINT_HACK diff --git a/ginac/ptr.h b/ginac/ptr.h index df758808..fd380506 100644 --- a/ginac/ptr.h +++ b/ginac/ptr.h @@ -48,12 +48,12 @@ public: // no default ctor: a ptr is never unbound /** Bind ptr to newly created object, start reference counting. */ - ptr(T *t) : p(t) { GINAC_ASSERT(p); p->refcount = 1; } + ptr(T *t) throw() : p(t) { GINAC_ASSERT(p); p->refcount = 1; } /** Bind ptr to existing reference-counted object. */ - explicit ptr(T &t) : p(&t) { ++p->refcount; } + explicit ptr(T &t) throw() : p(&t) { ++p->refcount; } - ptr(const ptr & other) : p(other.p) { ++p->refcount; } + ptr(const ptr & other) throw() : p(other.p) { ++p->refcount; } ~ptr() { @@ -71,10 +71,10 @@ public: return *this; } - T &operator*() const { return *p; } - T *operator->() const { return p; } + T &operator*() const throw() { return *p; } + T *operator->() const throw() { return p; } - friend inline T *get_pointer(const ptr & x) { return x.p; } + friend inline T *get_pointer(const ptr & x) throw() { return x.p; } /** Announce your intention to modify the object bound to this ptr. * This ensures that the object is not shared by any other ptrs. */ @@ -89,7 +89,7 @@ public: } /** Swap the bound object of this ptr with another ptr. */ - void swap(ptr & other) + void swap(ptr & other) throw() { T *t = p; p = other.p; @@ -102,22 +102,22 @@ public: // to different (probably derived) types and raw pointers. template - bool operator==(const ptr & rhs) const { return p == get_pointer(rhs); } + bool operator==(const ptr & rhs) const throw() { return p == get_pointer(rhs); } template - bool operator!=(const ptr & rhs) const { return p != get_pointer(rhs); } + bool operator!=(const ptr & rhs) const throw() { return p != get_pointer(rhs); } template - inline friend bool operator==(const ptr & lhs, const U * rhs) { return lhs.p == rhs; } + inline friend bool operator==(const ptr & lhs, const U * rhs) throw() { return lhs.p == rhs; } template - inline friend bool operator!=(const ptr & lhs, const U * rhs) { return lhs.p != rhs; } + inline friend bool operator!=(const ptr & lhs, const U * rhs) throw() { return lhs.p != rhs; } template - inline friend bool operator==(const U * lhs, const ptr & rhs) { return lhs == rhs.p; } + inline friend bool operator==(const U * lhs, const ptr & rhs) throw() { return lhs == rhs.p; } template - inline friend bool operator!=(const U * lhs, const ptr & rhs) { return lhs != rhs.p; } + inline friend bool operator!=(const U * lhs, const ptr & rhs) throw() { return lhs != rhs.p; } inline friend std::ostream & operator<<(std::ostream & os, const ptr & rhs) { diff --git a/ginac/symbol.cpp b/ginac/symbol.cpp index dd6e6643..480c25c4 100644 --- a/ginac/symbol.cpp +++ b/ginac/symbol.cpp @@ -296,7 +296,7 @@ unsigned symbol::next_serial = 0; ////////// /** Default ctor. Defaults to unassigned. */ -symbol::assigned_ex_info::assigned_ex_info() : is_assigned(false) +symbol::assigned_ex_info::assigned_ex_info() throw() : is_assigned(false) { } diff --git a/ginac/symbol.h b/ginac/symbol.h index 707aedb1..bacd59fa 100644 --- a/ginac/symbol.h +++ b/ginac/symbol.h @@ -46,11 +46,11 @@ class symbol : public basic class assigned_ex_info { friend class ptr; public: - assigned_ex_info(); ///< Default ctor - bool is_assigned; ///< True if there is an expression assigned - ex assigned_expression; ///< The actual expression + assigned_ex_info() throw(); ///< Default ctor + bool is_assigned; ///< True if there is an expression assigned + ex assigned_expression; ///< The actual expression private: - size_t refcount; ///< Reference counter, managed by ptr + size_t refcount; ///< Reference counter, managed by ptr }; // member functions -- 2.45.1