Changed typename to class; some libraries helpfully #define typename

[SVN r15970]

include/boost/detail/shared_count.hpp

@@ -309,7 +309,7 @@ public:
 
     // auto_ptr<Y> is special cased to provide the strong guarantee
 
-    template<typename Y>
+    template<class Y>
     explicit shared_count(std::auto_ptr<Y> & r): pi_(new counted_base_impl< Y *, checked_deleter<Y> >(r.get(), checked_deleter<Y>(), 1, 1))
     {
         r.release();

include/boost/scoped_array.hpp

@@ -24,7 +24,7 @@ namespace boost
 //  is guaranteed, either on destruction of the scoped_array or via an explicit
 //  reset(). Use shared_array or std::vector if your needs are more complex.
 
-template<typename T> class scoped_array // noncopyable
+template<class T> class scoped_array // noncopyable
 {
 private:
 

include/boost/scoped_ptr.hpp

@@ -27,7 +27,7 @@ namespace boost
 //  an explicit reset(). scoped_ptr is a simple solution for simple needs;
 //  use shared_ptr or std::auto_ptr if your needs are more complex.
 
-template<typename T> class scoped_ptr // noncopyable
+template<class T> class scoped_ptr // noncopyable
 {
 private:
 
@@ -106,14 +106,14 @@ public:
     }
 };
 
-template<typename T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) // never throws
+template<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) // never throws
 {
     a.swap(b);
 }
 
 // get_pointer(p) is a generic way to say p.get()
 
-template<typename T> inline T * get_pointer(scoped_ptr<T> const & p)
+template<class T> inline T * get_pointer(scoped_ptr<T> const & p)
 {
     return p.get();
 }

include/boost/shared_array.hpp

@@ -41,7 +41,7 @@ namespace boost
 //  is destroyed or reset.
 //
 
-template<typename T> class shared_array
+template<class T> class shared_array
 {
 private:
 
@@ -63,7 +63,7 @@ public:
     // shared_array will release p by calling d(p)
     //
 
-    template<typename D> shared_array(T * p, D d): px(p), pn(p, d)
+    template<class D> shared_array(T * p, D d): px(p), pn(p, d)
     {
     }
 
@@ -75,7 +75,7 @@ public:
         this_type(p).swap(*this);
     }
 
-    template <typename D> void reset(T * p, D d)
+    template <class D> void reset(T * p, D d)
     {
         this_type(p, d).swap(*this);
     }
@@ -129,22 +129,22 @@ private:
 
 };  // shared_array
 
-template<typename T> inline bool operator==(shared_array<T> const & a, shared_array<T> const & b) // never throws
+template<class T> inline bool operator==(shared_array<T> const & a, shared_array<T> const & b) // never throws
 {
     return a.get() == b.get();
 }
 
-template<typename T> inline bool operator!=(shared_array<T> const & a, shared_array<T> const & b) // never throws
+template<class T> inline bool operator!=(shared_array<T> const & a, shared_array<T> const & b) // never throws
 {
     return a.get() != b.get();
 }
 
-template<typename T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b) // never throws
+template<class T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b) // never throws
 {
     return std::less<T*>()(a.get(), b.get());
 }
 
-template<typename T> void swap(shared_array<T> & a, shared_array<T> & b) // never throws
+template<class T> void swap(shared_array<T> & a, shared_array<T> & b) // never throws
 {
     a.swap(b);
 }

include/boost/shared_ptr.hpp

@@ -46,7 +46,7 @@ struct static_cast_tag {};
 struct dynamic_cast_tag {};
 struct polymorphic_cast_tag {};
 
-template<typename T> struct shared_ptr_traits
+template<class T> struct shared_ptr_traits
 {
     typedef T & reference;
 };
@@ -76,10 +76,10 @@ template<> struct shared_ptr_traits<void const>
 //  is destroyed or reset.
 //
 
-template<typename T> class weak_ptr;
-template<typename T> class intrusive_ptr;
+template<class T> class weak_ptr;
+template<class T> class intrusive_ptr;
 
-template<typename T> class shared_ptr
+template<class T> class shared_ptr
 {
 private:
 
@@ -96,7 +96,7 @@ public:
     {
     }
 
-    template<typename Y>
+    template<class Y>
     explicit shared_ptr(Y * p): px(p), pn(p, checked_deleter<Y>(), p) // Y must be complete
     {
     }
@@ -107,33 +107,33 @@ public:
     // shared_ptr will release p by calling d(p)
     //
 
-    template<typename Y, typename D> shared_ptr(Y * p, D d): px(p), pn(p, d)
+    template<class Y, class D> shared_ptr(Y * p, D d): px(p), pn(p, d)
     {
     }
 
 //  generated copy constructor, assignment, destructor are fine
 
-    template<typename Y>
+    template<class Y>
     explicit shared_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn) // may throw
     {
     }
 
-    template<typename Y>
+    template<class Y>
     shared_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
     {
     }
 
-    template<typename Y>
+    template<class Y>
     shared_ptr(intrusive_ptr<Y> const & r): px(r.get()), pn(r.get()) // never throws
     {
     }
 
-    template<typename Y>
+    template<class Y>
     shared_ptr(shared_ptr<Y> const & r, detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
     {
     }
 
-    template<typename Y>
+    template<class Y>
     shared_ptr(shared_ptr<Y> const & r, detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
     {
         if (px == 0) // need to allocate new counter -- the cast failed
@@ -142,7 +142,7 @@ public:
         }
     }
 
-    template<typename Y>
+    template<class Y>
     shared_ptr(shared_ptr<Y> const & r, detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
     {
         if (px == 0)
@@ -153,7 +153,7 @@ public:
 
 #ifndef BOOST_NO_AUTO_PTR
 
-    template<typename Y>
+    template<class Y>
     explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn(r)
     {
     }
@@ -162,7 +162,7 @@ public:
 
 #if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200)
 
-    template<typename Y>
+    template<class Y>
     shared_ptr & operator=(shared_ptr<Y> const & r) // never throws
     {
         px = r.px;
@@ -174,7 +174,7 @@ public:
 
 #ifndef BOOST_NO_AUTO_PTR
 
-    template<typename Y>
+    template<class Y>
     shared_ptr & operator=(std::auto_ptr<Y> & r)
     {
         this_type(r).swap(*this);
@@ -188,13 +188,13 @@ public:
         this_type().swap(*this);
     }
 
-    template<typename Y> void reset(Y * p) // Y must be complete
+    template<class Y> void reset(Y * p) // Y must be complete
     {
         BOOST_ASSERT(p == 0 || p != px); // catch self-reset errors
         this_type(p).swap(*this);
     }
 
-    template<typename Y, typename D> void reset(Y * p, D d)
+    template<class Y, class D> void reset(Y * p, D d)
     {
         this_type(p, d).swap(*this);
     }
@@ -253,8 +253,8 @@ public:
 
 private:
 
-    template<typename Y> friend class shared_ptr;
-    template<typename Y> friend class weak_ptr;
+    template<class Y> friend class shared_ptr;
+    template<class Y> friend class weak_ptr;
 
 
 #endif
@@ -264,12 +264,12 @@ private:
 
 };  // shared_ptr
 
-template<typename T, typename U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
+template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
 {
     return a.get() == b.get();
 }
 
-template<typename T, typename U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
+template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
 {
     return a.get() != b.get();
 }
@@ -278,39 +278,39 @@ template<typename T, typename U> inline bool operator!=(shared_ptr<T> const & a,
 
 // Resolve the ambiguity between our op!= and the one in rel_ops
 
-template<typename T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b)
+template<class T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b)
 {
     return a.get() != b.get();
 }
 
 #endif
 
-template<typename T> inline bool operator<(shared_ptr<T> const & a, shared_ptr<T> const & b)
+template<class T> inline bool operator<(shared_ptr<T> const & a, shared_ptr<T> const & b)
 {
     return std::less<T*>()(a.get(), b.get());
 }
 
-template<typename T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
+template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
 {
     a.swap(b);
 }
 
-template<typename T, typename U> shared_ptr<T> shared_static_cast(shared_ptr<U> const & r)
+template<class T, class U> shared_ptr<T> shared_static_cast(shared_ptr<U> const & r)
 {
     return shared_ptr<T>(r, detail::static_cast_tag());
 }
 
-template<typename T, typename U> shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const & r)
+template<class T, class U> shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const & r)
 {
     return shared_ptr<T>(r, detail::dynamic_cast_tag());
 }
 
-template<typename T, typename U> shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const & r)
+template<class T, class U> shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const & r)
 {
     return shared_ptr<T>(r, detail::polymorphic_cast_tag());
 }
 
-template<typename T, typename U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const & r)
+template<class T, class U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const & r)
 {
     BOOST_ASSERT(dynamic_cast<T *>(r.get()) == r.get());
     return shared_static_cast<T>(r);
@@ -318,7 +318,7 @@ template<typename T, typename U> shared_ptr<T> shared_polymorphic_downcast(share
 
 // get_pointer() enables boost::mem_fn to recognize shared_ptr
 
-template<typename T> inline T * get_pointer(shared_ptr<T> const & p)
+template<class T> inline T * get_pointer(shared_ptr<T> const & p)
 {
     return p.get();
 }

include/boost/weak_ptr.hpp

@@ -24,7 +24,7 @@
 namespace boost
 {
 
-template<typename T> class weak_ptr
+template<class T> class weak_ptr
 {
 private:
 
@@ -41,19 +41,19 @@ public:
 
 //  generated copy constructor, assignment, destructor are fine
 
-    template<typename Y>
+    template<class Y>
     weak_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
     {
     }
 
-    template<typename Y>
+    template<class Y>
     weak_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
     {
     }
 
 #if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200)
 
-    template<typename Y>
+    template<class Y>
     weak_ptr & operator=(weak_ptr<Y> const & r) // never throws
     {
         px = r.px;
@@ -61,7 +61,7 @@ public:
         return *this;
     }
 
-    template<typename Y>
+    template<class Y>
     weak_ptr & operator=(shared_ptr<Y> const & r) // never throws
     {
         px = r.px;
@@ -109,8 +109,8 @@ public:
 
 private:
 
-    template<typename Y> friend class weak_ptr;
-    template<typename Y> friend class shared_ptr;
+    template<class Y> friend class weak_ptr;
+    template<class Y> friend class shared_ptr;
 
 #endif
 
@@ -133,7 +133,7 @@ template<class T, class U> inline bool operator!=(weak_ptr<T> const & a, weak_pt
 
 // Resolve the ambiguity between our op!= and the one in rel_ops
 
-template<typename T> inline bool operator!=(weak_ptr<T> const & a, weak_ptr<T> const & b)
+template<class T> inline bool operator!=(weak_ptr<T> const & a, weak_ptr<T> const & b)
 {
     return a.get() != b.get();
 }