X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fptr.h;h=29db23501ead133f09d92fcd47c432bcbe7423d8;hp=c8b0691230bc5c8d8b8c49fc7f7d63620a2387c9;hb=ed914545e01d60ecf2544e6141d6c5142c01327f;hpb=7d870583a6bf21a2ffb7b6f051b702064623892e

diff --git a/ginac/ptr.h b/ginac/ptr.h
index c8b06912..29db2350 100644
--- a/ginac/ptr.h
+++ b/ginac/ptr.h
@@ -3,7 +3,7 @@
  *  Reference-counted pointer template. */
 
 /*
- *  GiNaC Copyright (C) 1999-2008 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2016 Johannes Gutenberg University Mainz, Germany
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -20,30 +20,29 @@
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-#ifndef __GINAC_PTR_H__
-#define __GINAC_PTR_H__
+#ifndef GINAC_PTR_H
+#define GINAC_PTR_H
+
+#include "assertion.h"
 
 #include <cstddef> // for size_t
 #include <functional>
 #include <iosfwd>
 
-#include "assertion.h"
-
 namespace GiNaC {
 
-
 /** Base class for reference-counted objects. */
 class refcounted {
 public:
-	refcounted() throw() : refcount(0) {}
+	refcounted() noexcept : refcount(0) {}
 
-	size_t add_reference() throw() { return ++refcount; }
-	size_t remove_reference() throw() { return --refcount; }
-	size_t get_refcount() const throw() { return refcount; }
-	void set_refcount(size_t r) throw() { refcount = r; }
+	unsigned int add_reference() noexcept { return ++refcount; }
+	unsigned int remove_reference() noexcept { return --refcount; }
+	unsigned int get_refcount() const noexcept { return refcount; }
+	void set_refcount(unsigned int r) noexcept { refcount = r; }
 
 private:
-	size_t refcount; ///< reference counter
+	unsigned int refcount; ///< reference counter
 };
 
 
@@ -55,7 +54,7 @@ private:
  *      from refcounted)
  *    T* T::duplicate() member function (only if makewriteable() is used) */
 template <class T> class ptr {
-	friend class std::less< ptr<T> >;
+	friend struct std::less<ptr<T>>;
 
 	// NB: This implementation of reference counting is not thread-safe.
 	// The reference counter needs to be incremented/decremented atomically,
@@ -65,12 +64,12 @@ public:
     // no default ctor: a ptr is never unbound
 
 	/** Bind ptr to newly created object, start reference counting. */
-	ptr(T *t) throw() : p(t) { GINAC_ASSERT(p); p->set_refcount(1); }
+	ptr(T *t) noexcept : p(t) { GINAC_ASSERT(p); p->set_refcount(1); }
 
 	/** Bind ptr to existing reference-counted object. */
-	explicit ptr(T &t) throw() : p(&t) { p->add_reference(); }
+	explicit ptr(T &t) noexcept : p(&t) { p->add_reference(); }
 
-	ptr(const ptr & other) throw() : p(other.p) { p->add_reference(); }
+	ptr(const ptr & other) noexcept : p(other.p) { p->add_reference(); }
 
 	~ptr()
 	{
@@ -91,10 +90,10 @@ public:
 		return *this;
 	}
 
-	T &operator*() const throw() { return *p; }
-	T *operator->() const throw() { return p; }
+	T &operator*() const noexcept { return *p; }
+	T *operator->() const noexcept { return p; }
 
-	friend inline T *get_pointer(const ptr & x) throw() { return x.p; }
+	friend inline T *get_pointer(const ptr & x) noexcept { 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. */
@@ -109,7 +108,7 @@ public:
 	}
 
 	/** Swap the bound object of this ptr with another ptr. */
-	void swap(ptr & other) throw()
+	void swap(ptr & other) noexcept
 	{
 		T *t = p;
 		p = other.p;
@@ -122,22 +121,22 @@ public:
 	// to different (probably derived) types and raw pointers.
 
 	template <class U>
-	bool operator==(const ptr<U> & rhs) const throw() { return p == get_pointer(rhs); }
+	bool operator==(const ptr<U> & rhs) const noexcept { return p == get_pointer(rhs); }
 
 	template <class U>
-	bool operator!=(const ptr<U> & rhs) const throw() { return p != get_pointer(rhs); }
+	bool operator!=(const ptr<U> & rhs) const noexcept { return p != get_pointer(rhs); }
 
 	template <class U>
-	inline friend bool operator==(const ptr & lhs, const U * rhs) throw() { return lhs.p == rhs; }
+	inline friend bool operator==(const ptr & lhs, const U * rhs) noexcept { return lhs.p == rhs; }
 
 	template <class U>
-	inline friend bool operator!=(const ptr & lhs, const U * rhs) throw() { return lhs.p != rhs; }
+	inline friend bool operator!=(const ptr & lhs, const U * rhs) noexcept { return lhs.p != rhs; }
 
 	template <class U>
-	inline friend bool operator==(const U * lhs, const ptr & rhs) throw() { return lhs == rhs.p; }
+	inline friend bool operator==(const U * lhs, const ptr & rhs) noexcept { return lhs == rhs.p; }
 
 	template <class U>
-	inline friend bool operator!=(const U * lhs, const ptr & rhs) throw() { return lhs != rhs.p; }
+	inline friend bool operator!=(const U * lhs, const ptr & rhs) noexcept { return lhs != rhs.p; }
 
 	inline friend std::ostream & operator<<(std::ostream & os, const ptr<T> & rhs)
 	{
@@ -156,7 +155,7 @@ namespace std {
 
 /** Specialization of std::less for ptr<T> to enable ordering of ptr<T>
  *  objects (e.g. for the use as std::map keys). */
-template <class T> struct less< GiNaC::ptr<T> >
+template <class T> struct less<GiNaC::ptr<T>>
  : public binary_function<GiNaC::ptr<T>, GiNaC::ptr<T>, bool> {
 	bool operator()(const GiNaC::ptr<T> &lhs, const GiNaC::ptr<T> &rhs) const
 	{
@@ -166,4 +165,4 @@ template <class T> struct less< GiNaC::ptr<T> >
 
 } // namespace std
 
-#endif // ndef __GINAC_PTR_H__
+#endif // ndef GINAC_PTR_H