Make typedefs in ilist public (Visual C++ errors out when they are private).

[oota-llvm.git] / include / llvm / ADT / STLExtras.h

diff --git a/include/llvm/ADT/STLExtras.h b/include/llvm/ADT/STLExtras.h
index a58da0febd37abdab0cdb1ba1842e28260ef74a7..5c5e4aa9444f0a7edf4a30064116ad06c70c41db 100644 (file)
--- a/include/llvm/ADT/STLExtras.h
+++ b/include/llvm/ADT/STLExtras.h
@@ -1,10 +1,10 @@
 //===- llvm/ADT/STLExtras.h - Useful STL related functions ------*- C++ -*-===//
-// 
+//
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
 //===----------------------------------------------------------------------===//
 //
 // This file contains some templates that are useful if you are working with the
@@ -19,7 +19,8 @@
 
 #include <functional>
 #include <utility> // for std::pair
-#include "llvm/ADT/iterator"
+#include <cstring> // for std::size_t
+#include "llvm/ADT/iterator.h"
 
 namespace llvm {
 
@@ -35,13 +36,13 @@ struct greater_ptr : public std::binary_function<Ty, Ty, bool> {
 };
 
 // deleter - Very very very simple method that is used to invoke operator
-// delete on something.  It is used like this: 
+// delete on something.  It is used like this:
 //
 //   for_each(V.begin(), B.end(), deleter<Interval>);
 //
-template <class T> 
-static inline void deleter(T *Ptr) { 
-  delete Ptr; 
+template <class T>
+static inline void deleter(T *Ptr) {
+  delete Ptr;
 }
 
 
@@ -71,14 +72,14 @@ public:
   typedef RootIt iterator_type;
   typedef mapped_iterator<RootIt, UnaryFunc> _Self;
 
-  inline RootIt &getCurrent() const { return current; }
+  inline const RootIt &getCurrent() const { return current; }
 
   inline explicit mapped_iterator(const RootIt &I, UnaryFunc F)
     : current(I), Fn(F) {}
   inline mapped_iterator(const mapped_iterator &It)
     : current(It.current), Fn(It.Fn) {}
 
-  inline value_type operator*() const {   // All this work to do this 
+  inline value_type operator*() const {   // All this work to do this
     return Fn(*current);         // little change
   }
 
@@ -90,7 +91,7 @@ public:
   _Self& operator+=   (difference_type n) { current += n; return *this; }
   _Self  operator-    (difference_type n) const { return _Self(current - n); }
   _Self& operator-=   (difference_type n) { current -= n; return *this; }
-  reference operator[](difference_type n) const { return *(*this + n); }  
+  reference operator[](difference_type n) const { return *(*this + n); }
 
   inline bool operator!=(const _Self &X) const { return !operator==(X); }
   inline bool operator==(const _Self &X) const { return current == X.current; }
@@ -102,7 +103,7 @@ public:
 };
 
 template <class _Iterator, class Func>
-inline mapped_iterator<_Iterator, Func> 
+inline mapped_iterator<_Iterator, Func>
 operator+(typename mapped_iterator<_Iterator, Func>::difference_type N,
           const mapped_iterator<_Iterator, Func>& X) {
   return mapped_iterator<_Iterator, Func>(X.getCurrent() - N);
@@ -136,8 +137,7 @@ inline ItTy next(ItTy it, Dist n)
 template <typename ItTy>
 inline ItTy next(ItTy it)
 {
-  std::advance(it, 1);
-  return it;
+  return ++it;
 }
 
 template <typename ItTy, typename Dist>
@@ -150,8 +150,7 @@ inline ItTy prior(ItTy it, Dist n)
 template <typename ItTy>
 inline ItTy prior(ItTy it)
 {
-  std::advance(it, -1);
-  return it;
+  return --it;
 }
 
 //===----------------------------------------------------------------------===//
@@ -164,7 +163,7 @@ inline ItTy prior(ItTy it)
 // a std::pair. Since an example is worth 1000 words:
 //
 // typedef std::map<int, int> Int2IntMap;
-// 
+//
 // Int2IntMap myMap;
 // Int2IntMap::iterator where;
 // bool inserted;
@@ -199,6 +198,24 @@ inline tier<T1, T2> tie(T1& f, T2& s) {
   return tier<T1, T2>(f, s);
 }
 
+//===----------------------------------------------------------------------===//
+//     Extra additions to arrays
+//===----------------------------------------------------------------------===//
+
+/// Find where an array ends (for ending iterators)
+/// This returns a pointer to the byte immediately
+/// after the end of an array.
+template<class T, std::size_t N>
+inline T *array_endof(T (&x)[N]) {
+  return x+N;
+}
+
+/// Find the length of an array.
+template<class T, std::size_t N>
+inline size_t array_lengthof(T (&x)[N]) {
+  return N;
+}
+
 } // End llvm namespace
 
 #endif