// This file contains some templates that are useful if you are working with the
// STL at all.
//
-// No library is required when using these functinons.
+// No library is required when using these functions.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ADT_STLEXTRAS_H
#define LLVM_ADT_STLEXTRAS_H
+#include <cstddef> // for std::size_t
+#include <cstdlib> // for qsort
#include <functional>
+#include <iterator>
#include <utility> // for std::pair
-#include <cstring> // for std::size_t
-#include "llvm/ADT/iterator.h"
namespace llvm {
// Extra additions to <functional>
//===----------------------------------------------------------------------===//
+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 {
/// Find the length of an array.
template<class T, std::size_t N>
-inline size_t array_lengthof(T (&x)[N]) {
+inline size_t array_lengthof(T (&)[N]) {
return N;
}
/// array_pod_sort_comparator - This is helper function for array_pod_sort,
-/// which does a memcmp of a specific size.
-template<unsigned Size>
+/// which just uses operator< on T.
+template<typename T>
static inline int array_pod_sort_comparator(const void *P1, const void *P2) {
- if (Size == sizeof(char))
- return *(const char*)P1 - *(const char*)P2;
- if (Size == sizeof(int))
- return *(const int*)P1 - *(const int*)P2;
- if (Size == sizeof(long long))
- return *(const long long*)P1 - *(const long long*)P2;
- if (Size == sizeof(intptr_t))
- return *(intptr_t*)P1 - *(intptr_t*)P2;
- return memcmp(P1, P2, Size);
+ if (*reinterpret_cast<const T*>(P1) < *reinterpret_cast<const T*>(P2))
+ return -1;
+ if (*reinterpret_cast<const T*>(P2) < *reinterpret_cast<const T*>(P1))
+ return 1;
+ return 0;
}
+/// get_array_pad_sort_comparator - This is an internal helper function used to
+/// get type deduction of T right.
+template<typename T>
+static int (*get_array_pad_sort_comparator(const T &))
+ (const void*, const void*) {
+ return array_pod_sort_comparator<T>;
+}
+
+
/// array_pod_sort - This sorts an array with the specified start and end
/// extent. This is just like std::sort, except that it calls qsort instead of
/// using an inlined template. qsort is slightly slower than std::sort, but
/// possible.
///
/// This function assumes that you have simple POD-like types that can be
-/// compared with memcmp and can be moved with memcpy. If this isn't true, you
-/// should use std::sort.
+/// compared with operator< and can be moved with memcpy. If this isn't true,
+/// you should use std::sort.
///
/// NOTE: If qsort_r were portable, we could allow a custom comparator and
/// default to std::less.
// Don't dereference start iterator of empty sequence.
if (Start == End) return;
qsort(&*Start, End-Start, sizeof(*Start),
- array_pod_sort_comparator<sizeof(*Start)>);
+ get_array_pad_sort_comparator(*Start));
+}
+
+template<class IteratorTy>
+static inline void array_pod_sort(IteratorTy Start, IteratorTy End,
+ int (*Compare)(const void*, const void*)) {
+ // Don't dereference start iterator of empty sequence.
+ if (Start == End) return;
+ qsort(&*Start, End-Start, sizeof(*Start), Compare);
}
+//===----------------------------------------------------------------------===//
+// Extra additions to <algorithm>
+//===----------------------------------------------------------------------===//
+
+/// For a container of pointers, deletes the pointers and then clears the
+/// container.
+template<typename Container>
+void DeleteContainerPointers(Container &C) {
+ for (typename Container::iterator I = C.begin(), E = C.end(); I != E; ++I)
+ delete *I;
+ C.clear();
+}
+
+/// In a container of pairs (usually a map) whose second element is a pointer,
+/// deletes the second elements and then clears the container.
+template<typename Container>
+void DeleteContainerSeconds(Container &C) {
+ for (typename Container::iterator I = C.begin(), E = C.end(); I != E; ++I)
+ delete I->second;
+ C.clear();
+}
+
} // End llvm namespace
#endif