Reapply 53476 and 53480, with a fix so that it properly updates

[oota-llvm.git] / include / llvm / Support / Annotation.h

diff --git a/include/llvm/Support/Annotation.h b/include/llvm/Support/Annotation.h
index 8dbad760d7a2b232ad45e6dc8d6702a3a4039b41..2be1c1061690b2f08baa885d9e35546751168688 100644 (file)
--- a/include/llvm/Support/Annotation.h
+++ b/include/llvm/Support/Annotation.h
@@ -1,4 +1,11 @@
-//===-- Support/Annotation.h - Annotation classes ---------------*- C++ -*-===//
+//===-- llvm/Support/Annotation.h - Annotation classes ----------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
 //
 // This file contains the declarations for two classes: Annotation & Annotable.
 // Using these two simple classes, anything that derives from Annotable can have
@@ -12,15 +19,18 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SUPPORT_ANNOTATION_H
-#define SUPPORT_ANNOTATION_H
+#ifndef LLVM_SUPPORT_ANNOTATION_H
+#define LLVM_SUPPORT_ANNOTATION_H
 
 #include <string>
-#include <assert.h>
+#include <cassert>
+
+namespace llvm {
+
 class AnnotationID;
 class Annotation;
 class Annotable;
-class AnnotationManager;
+struct AnnotationManager;
 
 //===----------------------------------------------------------------------===//
 //
@@ -29,11 +39,13 @@ class AnnotationManager;
 // freely around and passed byvalue with little or no overhead.
 //
 class AnnotationID {
-  friend class AnnotationManager;
+  friend struct AnnotationManager;
   unsigned ID;
 
   AnnotationID();                             // Default ctor is disabled
-  inline AnnotationID(unsigned i) : ID(i) {}  // Only creatable from AnnMgr
+
+  // AnnotationID is only creatable from AnnMgr.
+  explicit inline AnnotationID(unsigned i) : ID(i) {}
 public:
   inline AnnotationID(const AnnotationID &A) : ID(A.ID) {}
 
@@ -57,8 +69,8 @@ class Annotation {
   AnnotationID ID;         // ID number, as obtained from AnnotationManager
   Annotation *Next;        // The next annotation in the linked list
 public:
-  inline Annotation(AnnotationID id) : ID(id), Next(0) {}
-  virtual ~Annotation() {}  // Designed to be subclassed
+  explicit inline Annotation(AnnotationID id) : ID(id), Next(0) {}
+  virtual ~Annotation();  // Designed to be subclassed
 
   // getID - Return the unique ID# of this annotation
   inline AnnotationID getID() const { return ID; }
@@ -71,8 +83,7 @@ public:
 //===----------------------------------------------------------------------===//
 //
 // Annotable - This class is used as a base class for all objects that would
-// like to have annotation capability.  One notable subclass is Value, which 
-// means annotations can be attached to almost everything in LLVM.
+// like to have annotation capability.
 //
 // Annotable objects keep their annotation list sorted as annotations are
 // inserted and deleted.  This is used to ensure that annotations with identical
@@ -85,14 +96,7 @@ class Annotable {
   void operator=(const Annotable &);   // Do not implement
 public:
   Annotable() : AnnotationList(0) {}
-  virtual ~Annotable() {   // Virtual because it's designed to be subclassed...
-    Annotation *A = AnnotationList;
-    while (A) {
-      Annotation *Next = A->getNext();
-      delete A;
-      A = Next;
-    }
-  }
+  ~Annotable();
 
   // getAnnotation - Search the list for annotations of the specified ID.  The
   // pointer returned is either null (if no annotations of the specified ID
@@ -129,10 +133,10 @@ public:
   inline Annotation *unlinkAnnotation(AnnotationID ID) const {
     for (Annotation **A = &AnnotationList; *A; A = &((*A)->Next))
       if ((*A)->getID() == ID) {
-       Annotation *Ret = *A;
-       *A = Ret->Next;
-       Ret->Next = 0;
-       return Ret;
+        Annotation *Ret = *A;
+        *A = Ret->Next;
+        Ret->Next = 0;
+        return Ret;
       }
     return 0;
   }
@@ -154,13 +158,13 @@ public:
 // one-to-one mapping between string Annotation names and Annotation ID numbers.
 //
 // Compared to the rest of the Annotation system, these mapping methods are
-// relatively slow, so they should be avoided by locally caching Annotation 
+// relatively slow, so they should be avoided by locally caching Annotation
 // ID #'s.  These methods are safe to call at any time, even by static ctors, so
 // they should be used by static ctors most of the time.
 //
 // This class also provides support for annotations that are created on demand
 // by the Annotable::getOrCreateAnnotation method.  To get this to work, simply
-// register an annotation handler 
+// register an annotation handler
 //
 struct AnnotationManager {
   typedef Annotation *(*Factory)(AnnotationID, const Annotable *, void*);
@@ -180,11 +184,11 @@ struct AnnotationManager {
   // Annotation creation on demand support...
 
   // registerAnnotationFactory - This method is used to register a callback
-  // function used to create an annotation on demand if it is needed by the 
+  // function used to create an annotation on demand if it is needed by the
   // Annotable::getOrCreateAnnotation method.
   //
   static void registerAnnotationFactory(AnnotationID ID, Factory Func,
-                                       void *ExtraData = 0);
+                                        void *ExtraData = 0);
 
   // createAnnotation - Create an annotation of the specified ID for the
   // specified object, using a register annotation creation function.
@@ -209,4 +213,6 @@ inline Annotation *Annotable::getOrCreateAnnotation(AnnotationID ID) const {
   return A;
 }
 
+} // End namespace llvm
+
 #endif