- added some (empty) exception specifications (reduces code size a little)
authorChristian Bauer <Christian.Bauer@uni-mainz.de>
Tue, 26 Aug 2003 22:14:37 +0000 (22:14 +0000)
committerChristian Bauer <Christian.Bauer@uni-mainz.de>
Tue, 26 Aug 2003 22:14:37 +0000 (22:14 +0000)
- synced to 1.1 (ex::const_iterator::operator[])

ginac/ex.h
ginac/ptr.h
ginac/symbol.cpp
ginac/symbol.h

index ee891a2fb9c431e0c66f7440a00ad5bc74c6e654..70ce112dd799690cbfe73e04fa54b68d2924a4fb 100644 (file)
@@ -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<basic *>(_num0_bp))
+ex::ex() throw() : bp(*const_cast<basic *>(_num0_bp))
 {
        GINAC_ASSERT(bp->flags & status_flags::dynallocated);
 #ifdef OBSCURE_CINT_HACK
index df758808b8e33985d542a3af8d73ad317764f95c..fd380506fdd6daaec5183e94f8557c7306f51f4c 100644 (file)
@@ -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 <class U>
-       bool operator==(const ptr<U> & rhs) const { return p == get_pointer(rhs); }
+       bool operator==(const ptr<U> & rhs) const throw() { return p == get_pointer(rhs); }
 
        template <class U>
-       bool operator!=(const ptr<U> & rhs) const { return p != get_pointer(rhs); }
+       bool operator!=(const ptr<U> & rhs) const throw() { return p != get_pointer(rhs); }
 
        template <class U>
-       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 <class U>
-       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 <class U>
-       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 <class U>
-       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<T> & rhs)
        {
index dd6e664394a4beae6f39e178372c865be1016f54..480c25c453fc8f648548cbded62cabeece80703a 100644 (file)
@@ -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)
 {
 }
 
index 707aedb1d7981bc02741adb77c888e6add4d6c30..bacd59fa370a9f49c2347e97c50be6d5d60aa2b9 100644 (file)
@@ -46,11 +46,11 @@ class symbol : public basic
        class assigned_ex_info {
                friend class ptr<assigned_ex_info>;
        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<assigned_ex_info>
+               size_t refcount;             ///< Reference counter, managed by ptr<assigned_ex_info>
        };
 
 // member functions