[pclasses-cvs] pclasses2/include/pclasses Algorithm.h,1.2,1.3

[Christian P. <cp...@us...>]

Update of /cvsroot/pclasses/pclasses2/include/pclasses
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv5928/include/pclasses

Modified Files:
	Algorithm.h 
Log Message:
- Details::construct(..., Traits::FalseType) is now exception safe 
- Added min() and max()  

Index: Algorithm.h
===================================================================
RCS file: /cvsroot/pclasses/pclasses2/include/pclasses/Algorithm.h,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- Algorithm.h	24 Dec 2004 16:49:14 -0000	1.2
+++ Algorithm.h	29 Jun 2005 20:19:41 -0000	1.3
@@ -18,8 +18,8 @@
  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  ***************************************************************************/
 
-#ifndef _P_Algorithm_h_
-#define _P_Algorithm_h_
+#ifndef P_Algorithm_h
+#define P_Algorithm_h
 
 #include <pclasses/BasicTypes.h>
 #include <pclasses/TypeTraits.h>
@@ -32,25 +32,42 @@
 
 //! POD-type construction
 template <typename Type>
-void construct(Type* dest, size_t count, Traits::TrueType) throw()
+inline void construct(Type* dest, size_t count, Traits::TrueType) throw()
 { std::memset(dest, 0, sizeof(Type) * count); }
 
 //! Object-type construction
 template <typename Type>
 void construct(Type* dest, size_t count, Traits::FalseType)
 {
-	while(count--)
-		new(dest++) Type();
+	Type* ptr = dest;
+	size_t n = count;
+
+	try
+	{
+		while(n > 0)
+		{
+			new(ptr) Type();
+			--n;
+			++ptr;
+		}
+	}
+	catch(...)
+	{
+		// we must destruct previously constructed objects after
+		// receiving an exception ...
+		destruct(dest, count - n, Traits::FalseType());
+		throw;
+	}
 }
 
 //! POD-type destruction
 template <typename Type>
-void destruct(Type* dest, size_t count, Traits::TrueType) throw()
+inline void destruct(Type* dest, size_t count, Traits::TrueType) throw()
 { }
 
 //! Object-type destruction
 template <typename Type>
-void destruct(Type* dest, size_t count, Traits::FalseType) throw()
+inline void destruct(Type* dest, size_t count, Traits::FalseType) throw()
 {
 	while(count--)
 		(dest++)->~Type();
@@ -58,13 +75,13 @@
 
 //! POD-type copy construction
 template <typename Type>
-void copy_construct(Type* dest, const Type* src, size_t count,
+inline void copy_construct(Type* dest, const Type* src, size_t count,
 	Traits::TrueType) throw()
 { std::memcpy(dest, src, sizeof(Type) * count); }
 
 //! Object-type copy construction
 template <typename Type>
-void copy_construct(Type* dest, const Type* src, size_t count,
+inline void copy_construct(Type* dest, const Type* src, size_t count,
   Traits::FalseType)
 {
 	while(count--)
@@ -73,41 +90,43 @@
 
 //! POD-type copy
 template <typename Type>
-void copy(Type* dest, const Type* src, size_t count,
+inline void copy(Type* dest, const Type* src, size_t count,
 	Traits::TrueType) throw()
 { std::memcpy(dest, src, sizeof(Type) * count); }
 
 //! Object-type copy construction
 template <typename Type>
-void copy(Type* dest, const Type* src, size_t count, Traits::FalseType)
+inline void copy(Type* dest, const Type* src, size_t count, Traits::FalseType)
 {
 	while(count--)
 		*dest++ = *src++;
 }
 
-//! POD-type destructive-copy
-template <typename Type>
-void destructive_copy(Type* dest, Type* src, size_t count,
-	Traits::TrueType) throw()
-{ std::memcpy(dest, src, sizeof(Type) * count); }
+} // !namespace Details
+
+#undef min
 
-//! Object-type destructive-copy
 template <typename Type>
-void destructive_copy(Type* dest, Type* src, size_t count, Traits::FalseType)
+inline const Type& min(const Type& a, const Type& b)
 {
-	while(count--)
-	{
-		*dest++ = *src;
-		destruct(src++, 1, 
-			typename Traits::TypeTraits<Type>::HasTrivialCtor());
-	}
+	if(a < b)
+		return a;
+	return b;
 }
 
-} // !namespace Details
+#undef max
+
+template <typename Type>
+inline const Type& max(const Type& a, const Type& b)
+{
+	if(a > b)
+		return a;
+	return b;
+}
 
 //! Construction algorithm
 template <typename Type>
-void construct(Type* dest, size_t count)
+inline void construct(Type* dest, size_t count)
 { 
 	Details::construct(dest, count, 
 		typename Traits::TypeTraits<Type>::HasTrivialCtor()); 
@@ -115,7 +134,7 @@
 
 //! Destruction algorithm
 template <typename Type>
-void destruct(Type* dest, size_t count) throw()
+inline void destruct(Type* dest, size_t count) throw()
 { 
 	Details::destruct(dest, count, 
 		typename Traits::TypeTraits<Type>::HasTrivialCtor()); 
@@ -123,7 +142,7 @@
 
 //! Copy-construction algorithm
 template <typename Type>
-void copy_construct(Type* dest, const Type* src, size_t count)
+inline void copy_construct(Type* dest, const Type* src, size_t count)
 {
 	Details::copy_construct(dest, src, count,
 		typename Traits::TypeTraits<Type>::HasTrivialCtor());
@@ -131,22 +150,14 @@
 
 //! Copy algorithm
 template <typename Type>
-void copy(Type* dest, const Type* src, size_t count)
+inline void copy(Type* dest, const Type* src, size_t count)
 {
 	Details::copy(dest, src, count,
 		typename Traits::TypeTraits<Type>::HasTrivialCopy());
 }
 
-//! Destructive copy-algorithm
-template <typename Type>
-void destructive_copy(Type* dest, Type* src, size_t count)
-{
-	Details::destructive_copy(dest, src, count,
-		typename Traits::TypeTraits<Type>::HasTrivialCopy());
-}
-
 template <typename Iterator>
-size_t distance(Iterator begin, Iterator end)
+inline size_t distance(Iterator begin, Iterator end)
 {
 	size_t count = 0;
 	for(; begin != end; ++begin)
@@ -156,4 +167,4 @@
 
 } // !namespace P
 
-#endif // ! _P_Algorithm_h_
+#endif // ! P_Algorithm_h