CRYPTOPP 5.6.3 RC6 checkin

1 files changed, 281 insertions, 254 deletions

diff --git a/smartptr.h b/smartptr.h
index 4afd48d1..068ab52c 100644
--- a/smartptr.h
+++ b/smartptr.h
@@ -1,254 +1,281 @@
-#ifndef CRYPTOPP_SMARTPTR_H
-#define CRYPTOPP_SMARTPTR_H
-
-#include "config.h"
-#include "stdcpp.h"
-#include "trap.h"
-
-NAMESPACE_BEGIN(CryptoPP)
-
-// CryptoPP::auto_ptr in created in both cases
-#if defined(CRYPTOPP_CXX11_UNIQUE_PTR) && defined(CRYPTOPP_CXX11_TEMPLATE_ALIAS)
-  template<typename T>
-    using auto_ptr = std::unique_ptr<T>;
-#else
-  using std::auto_ptr;
-#endif
-
-template <class T> class simple_ptr
-{
-public:
-	simple_ptr(T *p = NULL) : m_p(p) {}
-	~simple_ptr();
-
-public:
-	T *m_p;
-
-private:
-	simple_ptr(const simple_ptr<T>& rhs);		// copy not allowed
-	void operator=(const simple_ptr<T>& rhs);	// assignment not allowed
-};
-
-// Set m_p to NULL so double destruction (which might occur in Singleton) will be harmless
-template <class T> simple_ptr<T>::~simple_ptr()
-{
-	delete m_p;
-	*((volatile T**)(&m_p)) = 0;
-}
-
-template <class T> class member_ptr
-{
-public:
-	explicit member_ptr(T *p = NULL) : m_p(p) {}
-
-	~member_ptr();
-
-	const T& operator*() const { return *m_p; }
-	T& operator*() { return *m_p; }
-
-	const T* operator->() const { return m_p; }
-	T* operator->() { return m_p; }
-
-	const T* get() const { return m_p; }
-	T* get() { return m_p; }
-
-	T* release()
-	{
-		T *old_p = m_p;
-		*((volatile T**)(&m_p)) = 0;
-		return old_p;
-	}
-
-	void reset(T *p = 0);
-
-protected:
-	T *m_p;
-
-private:
-	member_ptr(const member_ptr<T>& rhs);		// copy not allowed
-	void operator=(const member_ptr<T>& rhs);	// assignment not allowed
-};
-
-template <class T> member_ptr<T>::~member_ptr() {delete m_p;}
-template <class T> void member_ptr<T>::reset(T *p) {delete m_p; m_p = p;}
-
-// ********************************************************
-
-template<class T> class value_ptr : public member_ptr<T>
-{
-public:
-	value_ptr(const T &obj) : member_ptr<T>(new T(obj)) {}
-	value_ptr(T *p = NULL) : member_ptr<T>(p) {}
-	value_ptr(const value_ptr<T>& rhs)
-		: member_ptr<T>(rhs.m_p ? new T(*rhs.m_p) : NULL) {}
-
-	value_ptr<T>& operator=(const value_ptr<T>& rhs);
-	bool operator==(const value_ptr<T>& rhs)
-	{
-		return (!this->m_p && !rhs.m_p) || (this->m_p && rhs.m_p && *this->m_p == *rhs.m_p);
-	}
-};
-
-template <class T> value_ptr<T>& value_ptr<T>::operator=(const value_ptr<T>& rhs)
-{
-	if (this != &rhs)
-	{
-		T *old_p = this->m_p;
-		this->m_p = rhs.m_p ? new T(*rhs.m_p) : NULL;
-		delete old_p;
-	}
-	return *this;
-}
-
-// ********************************************************
-
-template<class T> class clonable_ptr : public member_ptr<T>
-{
-public:
-	clonable_ptr(const T &obj) : member_ptr<T>(obj.Clone()) {}
-	clonable_ptr(T *p = NULL) : member_ptr<T>(p) {}
-	clonable_ptr(const clonable_ptr<T>& rhs)
-		: member_ptr<T>(rhs.m_p ? rhs.m_p->Clone() : NULL) {}
-
-	clonable_ptr<T>& operator=(const clonable_ptr<T>& rhs);
-};
-
-template <class T> clonable_ptr<T>& clonable_ptr<T>::operator=(const clonable_ptr<T>& rhs)
-{
-	if (this !=  &rhs)
-	{
-		T *old_p = this->m_p;
-		this->m_p = rhs.m_p ? rhs.m_p->Clone() : NULL;
-		delete old_p;
-	}
-	return *this;
-}
-
-// ********************************************************
-
-template<class T> class counted_ptr
-{
-public:
-	explicit counted_ptr(T *p = 0);
-	counted_ptr(const T &r) : m_p(0) {attach(r);}
-	counted_ptr(const counted_ptr<T>& rhs);
-
-	~counted_ptr();
-
-	const T& operator*() const { return *m_p; }
-	T& operator*() { return *m_p; }
-
-	const T* operator->() const { return m_p; }
-	T* operator->() { return get(); }
-
-	const T* get() const { return m_p; }
-	T* get();
-
-	void attach(const T &p);
-
-	counted_ptr<T> & operator=(const counted_ptr<T>& rhs);
-
-protected:
-	T *m_p;
-};
-
-template <class T> counted_ptr<T>::counted_ptr(T *p)
-	: m_p(p)
-{
-	if (m_p)
-		m_p->m_referenceCount = 1;
-}
-
-template <class T> counted_ptr<T>::counted_ptr(const counted_ptr<T>& rhs)
-	: m_p(rhs.m_p)
-{
-	if (m_p)
-		m_p->m_referenceCount++;
-}
-
-template <class T> counted_ptr<T>::~counted_ptr()
-{
-	if (m_p && --m_p->m_referenceCount == 0)
-		delete m_p;
-}
-
-template <class T> void counted_ptr<T>::attach(const T &r)
-{
-	if (m_p && --m_p->m_referenceCount == 0)
-		delete m_p;
-	if (r.m_referenceCount == 0)
-	{
-		m_p = r.clone();
-		m_p->m_referenceCount = 1;
-	}
-	else
-	{
-		m_p = const_cast<T *>(&r);
-		m_p->m_referenceCount++;
-	}
-}
-
-template <class T> T* counted_ptr<T>::get()
-{
-	if (m_p && m_p->m_referenceCount > 1)
-	{
-		T *temp = m_p->clone();
-		m_p->m_referenceCount--;
-		m_p = temp;
-		m_p->m_referenceCount = 1;
-	}
-	return m_p;
-}
-
-template <class T> counted_ptr<T> & counted_ptr<T>::operator=(const counted_ptr<T>& rhs)
-{
-	if (this == &rhs) { return *this; }
-
-	if (m_p != rhs.m_p)
-	{
-		if (m_p && --m_p->m_referenceCount == 0)
-			delete m_p;
-		m_p = rhs.m_p;
-		if (m_p)
-			m_p->m_referenceCount++;
-	}
-	return *this;
-}
-
-// ********************************************************
-
-template <class T> class vector_member_ptrs
-{
-public:
-	vector_member_ptrs(size_t size=0)
-		: m_size(size), m_ptr(new member_ptr<T>[size]) {}
-	~vector_member_ptrs()
-		{delete [] this->m_ptr;}
-
-	member_ptr<T>& operator[](size_t index)
-		{CRYPTOPP_ASSERT(index<this->m_size); return this->m_ptr[index];}
-	const member_ptr<T>& operator[](size_t index) const
-		{CRYPTOPP_ASSERT(index<this->m_size); return this->m_ptr[index];}
-
-	size_t size() const {return this->m_size;}
-	void resize(size_t newSize)
-	{
-		member_ptr<T> *newPtr = new member_ptr<T>[newSize];
-		for (size_t i=0; i<this->m_size && i<newSize; i++)
-			newPtr[i].reset(this->m_ptr[i].release());
-		delete [] this->m_ptr;
-		this->m_size = newSize;
-		this->m_ptr = newPtr;
-	}
-
-private:
-	vector_member_ptrs(const vector_member_ptrs<T> &c);	// copy not allowed
-	void operator=(const vector_member_ptrs<T> &x);		// assignment not allowed
-
-	size_t m_size;
-	member_ptr<T> *m_ptr;
-};
-
-NAMESPACE_END
-
-#endif
+#ifndef CRYPTOPP_SMARTPTR_H

+#define CRYPTOPP_SMARTPTR_H

+

+#include "config.h"

+#include "stdcpp.h"

+

+NAMESPACE_BEGIN(CryptoPP)

+

+template <class T> class simple_ptr

+{

+public:

+	simple_ptr(T *p = NULL) : m_p(p) {}

+	~simple_ptr()

+	{

+		delete m_p;

+		*((volatile T**)&m_p) = NULL;

+	}

+

+	T *m_p;

+};

+

+// Expanded use of member_ptr due to https://github.com/weidai11/cryptopp/issues/48

+template <class T> class member_ptr

+{

+public:

+	explicit member_ptr(T *p = NULL) : m_p(p) {}

+

+	~member_ptr();

+

+	const T& operator*() const { return *m_p; }

+	T& operator*() { return *m_p; }

+

+	const T* operator->() const { return m_p; }

+	T* operator->() { return m_p; }

+

+	const T* get() const { return m_p; }

+	T* get() { return m_p; }

+

+	T* release()

+	{

+		T *old_p = m_p;

+		*((volatile T**)&m_p) = NULL;

+		return old_p;

+	} 

+

+	void reset(T *p = 0);

+

+protected:

+	member_ptr(const member_ptr<T>& rhs);		// copy not allowed

+	void operator=(const member_ptr<T>& rhs);	// assignment not allowed

+

+	T *m_p;

+};

+

+template <class T> member_ptr<T>::~member_ptr() {delete m_p;}

+template <class T> void member_ptr<T>::reset(T *p) {delete m_p; m_p = p;}

+

+// ********************************************************

+

+template<class T> class value_ptr : public member_ptr<T>

+{

+public:

+	value_ptr(const T &obj) : member_ptr<T>(new T(obj)) {}

+	value_ptr(T *p = NULL) : member_ptr<T>(p) {}

+	value_ptr(const value_ptr<T>& rhs)

+		: member_ptr<T>(rhs.m_p ? new T(*rhs.m_p) : NULL) {}

+

+	value_ptr<T>& operator=(const value_ptr<T>& rhs);

+	bool operator==(const value_ptr<T>& rhs)

+	{

+		return (!this->m_p && !rhs.m_p) || (this->m_p && rhs.m_p && *this->m_p == *rhs.m_p);

+	}

+};

+

+template <class T> value_ptr<T>& value_ptr<T>::operator=(const value_ptr<T>& rhs)

+{

+	T *old_p = this->m_p;

+	this->m_p = rhs.m_p ? new T(*rhs.m_p) : NULL;

+	delete old_p;

+	return *this;

+}

+

+// ********************************************************

+

+template<class T> class clonable_ptr : public member_ptr<T>

+{

+public:

+	clonable_ptr(const T &obj) : member_ptr<T>(obj.Clone()) {}

+	clonable_ptr(T *p = NULL) : member_ptr<T>(p) {}

+	clonable_ptr(const clonable_ptr<T>& rhs)

+		: member_ptr<T>(rhs.m_p ? rhs.m_p->Clone() : NULL) {}

+

+	clonable_ptr<T>& operator=(const clonable_ptr<T>& rhs);

+};

+

+template <class T> clonable_ptr<T>& clonable_ptr<T>::operator=(const clonable_ptr<T>& rhs)

+{

+	T *old_p = this->m_p;

+	this->m_p = rhs.m_p ? rhs.m_p->Clone() : NULL;

+	delete old_p;

+	return *this;

+}

+

+// ********************************************************

+

+//! reference counted pointer

+//! /details users should declare \p m_referenceCount as `std::atomic<unsigned>` under C++ 11

+template<class T> class counted_ptr

+{

+public:

+	explicit counted_ptr(T *p = 0);

+	counted_ptr(const T &r) : m_p(0) {attach(r);}

+	counted_ptr(const counted_ptr<T>& rhs);

+

+	~counted_ptr();

+

+	const T& operator*() const { return *m_p; }

+	T& operator*() { return *m_p; }

+

+	const T* operator->() const { return m_p; }

+	T* operator->() { return get(); }

+

+	const T* get() const { return m_p; }

+	T* get();

+

+	void attach(const T &p);

+

+	counted_ptr<T> & operator=(const counted_ptr<T>& rhs);

+

+private:

+	T *m_p;

+};

+

+template <class T> counted_ptr<T>::counted_ptr(T *p)

+	: m_p(p) 

+{

+	if (m_p)

+		m_p->m_referenceCount = 1;

+}

+

+template <class T> counted_ptr<T>::counted_ptr(const counted_ptr<T>& rhs)

+	: m_p(rhs.m_p)

+{

+	if (m_p)

+		m_p->m_referenceCount++;

+}

+

+template <class T> counted_ptr<T>::~counted_ptr()

+{

+	if (m_p && --m_p->m_referenceCount == 0)

+		delete m_p;

+}

+

+template <class T> void counted_ptr<T>::attach(const T &r)

+{

+	if (m_p && --m_p->m_referenceCount == 0)

+		delete m_p;

+	if (r.m_referenceCount == 0)

+	{

+		m_p = r.clone();

+		m_p->m_referenceCount = 1;

+	}

+	else

+	{

+		m_p = const_cast<T *>(&r);

+		m_p->m_referenceCount++;

+	}

+}

+

+template <class T> T* counted_ptr<T>::get()

+{

+	if (m_p && m_p->m_referenceCount > 1)

+	{

+		T *temp = m_p->clone();

+		m_p->m_referenceCount--;

+		m_p = temp;

+		m_p->m_referenceCount = 1;

+	}

+	return m_p;

+}

+

+template <class T> counted_ptr<T> & counted_ptr<T>::operator=(const counted_ptr<T>& rhs)

+{

+	if (m_p != rhs.m_p)

+	{

+		if (m_p && --m_p->m_referenceCount == 0)

+			delete m_p;

+		m_p = rhs.m_p;

+		if (m_p)

+			m_p->m_referenceCount++;

+	}

+	return *this;

+}

+

+// ********************************************************

+

+//! Manages the resource of an vector of T.

+template <class T> class vector_ptr

+{

+public:

+	vector_ptr(size_t size=0)

+		: m_size(size), m_ptr(new T[m_size]) {}

+	~vector_ptr()

+		{delete [] m_ptr;}

+

+	T& operator[](size_t index)

+		{assert(m_size && index<this->m_size); return this->m_ptr[index];}

+	const T& operator[](size_t index) const

+		{assert(m_size && index<this->m_size); return this->m_ptr[index];}

+

+	size_t size() const {return this->m_size;}

+	void resize(size_t newSize)

+	{

+		T *newPtr = new T[newSize];

+		for (size_t i=0; i<this->m_size && i<newSize; i++)

+			newPtr[i] = m_ptr[i];

+		delete [] this->m_ptr;

+		this->m_size = newSize;

+		this->m_ptr = newPtr;

+	}

+	

+#ifdef __BORLANDC__

+	operator T *() const

+		{return (T*)m_ptr;}

+#else

+	operator const void *() const

+		{return m_ptr;}

+	operator void *()

+		{return m_ptr;}

+

+	operator const T *() const

+		{return m_ptr;}

+	operator T *()

+		{return m_ptr;}

+#endif

+

+private:

+	vector_ptr(const vector_ptr<T> &c);	// copy not allowed

+	void operator=(const vector_ptr<T> &x);		// assignment not allowed

+

+	size_t m_size;

+	T *m_ptr;

+};

+

+// ********************************************************

+

+template <class T> class vector_member_ptrs

+{

+public:

+	vector_member_ptrs(size_t size=0)

+		: m_size(size), m_ptr(new member_ptr<T>[size]) {}

+	~vector_member_ptrs()

+		{delete [] this->m_ptr;}

+

+	member_ptr<T>& operator[](size_t index)

+		{assert(index<this->m_size); return this->m_ptr[index];}

+	const member_ptr<T>& operator[](size_t index) const

+		{assert(index<this->m_size); return this->m_ptr[index];}

+

+	size_t size() const {return this->m_size;}

+	void resize(size_t newSize)

+	{

+		member_ptr<T> *newPtr = new member_ptr<T>[newSize];

+		for (size_t i=0; i<this->m_size && i<newSize; i++)

+			newPtr[i].reset(this->m_ptr[i].release());

+		delete [] this->m_ptr;

+		this->m_size = newSize;

+		this->m_ptr = newPtr;

+	}

+

+private:

+	vector_member_ptrs(const vector_member_ptrs<T> &c);	// copy not allowed

+	void operator=(const vector_member_ptrs<T> &x);		// assignment not allowed

+

+	size_t m_size;

+	member_ptr<T> *m_ptr;

+};

+

+NAMESPACE_END

+

+#endif