For PR1338: rename include/llvm/ADT/ilist and friends to end with ".h"

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

diff --git a/include/llvm/ADT/STLExtras.h b/include/llvm/ADT/STLExtras.h
index e13f9f9ce7abfd85623b650e60c5fdb428e8d9c4..f1883959d762c351250bfc6388ac772a409bfdf2 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 {
 
@@ -27,39 +28,6 @@ namespace llvm {
 //     Extra additions to <functional>
 //===----------------------------------------------------------------------===//
 
-// bind_obj - Often times you want to apply the member function of an object
-// as a unary functor.  This macro is shorthand that makes it happen less
-// verbosely.
-//
-// Example:
-//  struct Summer { void accumulate(int x); }
-//  vector<int> Numbers;
-//  Summer MyS;
-//  for_each(Numbers.begin(), Numbers.end(),
-//           bind_obj(&MyS, &Summer::accumulate));
-//
-// TODO: When I get lots of extra time, convert this from an evil macro
-//
-#define bind_obj(OBJ, METHOD) std::bind1st(std::mem_fun(METHOD), OBJ)
-
-
-// bitwise_or - This is a simple functor that applys operator| on its two 
-// arguments to get a boolean result.
-//
-template<class Ty>
-struct bitwise_or : public std::binary_function<Ty, Ty, bool> {
-  bool operator()(const Ty& left, const Ty& right) const {
-    return left | right;
-  }
-};
-
-template<class Ty>
-struct less_ptr : public std::binary_function<Ty, Ty, bool> {
-  bool operator()(const Ty* left, const Ty* right) const {
-    return *left < *right;
-  }
-};
-
 template<class Ty>
 struct greater_ptr : public std::binary_function<Ty, Ty, bool> {
   bool operator()(const Ty* left, const Ty* right) const {
@@ -68,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;
 }
 
 
@@ -104,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
   }
 
@@ -123,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; }
@@ -135,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);
@@ -197,7 +165,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;
@@ -232,6 +200,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