#ifndef LLVM_SUPPORT_REGISTRY_H
#define LLVM_SUPPORT_REGISTRY_H
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/Compiler.h"
+#include <memory>
+
namespace llvm {
/// A simple registry entry which provides only a name, description, and
/// no-argument constructor.
template <typename T>
class SimpleRegistryEntry {
const char *Name, *Desc;
- T *(*Ctor)();
+ std::unique_ptr<T> (*Ctor)();
public:
- SimpleRegistryEntry(const char *N, const char *D, T *(*C)())
+ SimpleRegistryEntry(const char *N, const char *D, std::unique_ptr<T> (*C)())
: Name(N), Desc(D), Ctor(C)
{}
const char *getName() const { return Name; }
const char *getDesc() const { return Desc; }
- T *instantiate() const { return Ctor(); }
+ std::unique_ptr<T> instantiate() const { return Ctor(); }
};
-
/// Traits for registry entries. If using other than SimpleRegistryEntry, it
/// is necessary to define an alternate traits class.
template <typename T>
class RegistryTraits {
- RegistryTraits(); // Do not implement.
+ RegistryTraits() = delete;
public:
typedef SimpleRegistryEntry<T> entry;
static const char *descof(const entry &Entry) { return Entry.getDesc(); }
};
-
/// A global registry used in conjunction with static constructors to make
/// pluggable components (like targets or garbage collectors) "just work" when
/// linked with an executable.
class iterator;
private:
- Registry(); // Do not implement.
+ Registry() = delete;
static void Announce(const entry &E) {
for (listener *Cur = ListenerHead; Cur; Cur = Cur->Next)
const entry& Val;
public:
- node(const entry& V) : Next(0), Val(V) {
+ node(const entry& V) : Next(nullptr), Val(V) {
if (Tail)
Tail->Next = this;
else
}
};
-
/// Iterators for registry entries.
///
class iterator {
};
static iterator begin() { return iterator(Head); }
- static iterator end() { return iterator(0); }
+ static iterator end() { return iterator(nullptr); }
+ static iterator_range<iterator> entries() {
+ return iterator_range<iterator>(begin(), end());
+ }
/// Abstract base class for registry listeners, which are informed when new
/// entries are added to the registry. Simply subclass and instantiate:
///
+ /// \code
/// class CollectorPrinter : public Registry<Collector>::listener {
/// protected:
/// void registered(const Registry<Collector>::entry &e) {
/// };
///
/// CollectorPrinter Printer;
- ///
+ /// \endcode
class listener {
listener *Prev, *Next;
}
public:
- listener() : Prev(ListenerTail), Next(0) {
+ listener() : Prev(ListenerTail), Next(nullptr) {
if (Prev)
Prev->Next = this;
else
}
};
-
/// A static registration template. Use like such:
///
/// Registry<Collector>::Add<FancyGC>
entry Entry;
node Node;
- static T *CtorFn() { return new V(); }
+ static std::unique_ptr<T> CtorFn() { return make_unique<V>(); }
public:
Add(const char *Name, const char *Desc)
};
/// Registry::Parser now lives in llvm/Support/RegistryParser.h.
-
};
+ // Since these are defined in a header file, plugins must be sure to export
+ // these symbols.
template <typename T, typename U>
typename Registry<T,U>::node *Registry<T,U>::Head;
template <typename T, typename U>
typename Registry<T,U>::listener *Registry<T,U>::ListenerTail;
-}
+} // end namespace llvm
-#endif
+#endif // LLVM_SUPPORT_REGISTRY_H