[llvm] r210190 - Support: style/documentation cleanup for format

Saleem Abdulrasool compnerd at compnerd.org
Wed Jun 4 08:47:08 PDT 2014


Author: compnerd
Date: Wed Jun  4 10:47:07 2014
New Revision: 210190

URL: http://llvm.org/viewvc/llvm-project?rev=210190&view=rev
Log:
Support: style/documentation cleanup for format

This is purely a documentation/whitespace cleanup for the format support
functions.

The current style does not duplicate the function/class names in the
documentation; conform to this style.

Additionally, there was a large amount of duplication of comments that added no
real value.  Use block comments for the related sets of functions which are used
for type deduction and parameter container classes.

No functional change.

Modified:
    llvm/trunk/include/llvm/Support/Format.h

Modified: llvm/trunk/include/llvm/Support/Format.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/Format.h?rev=210190&r1=210189&r2=210190&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Support/Format.h (original)
+++ llvm/trunk/include/llvm/Support/Format.h Wed Jun  4 10:47:07 2014
@@ -36,23 +36,23 @@
 
 namespace llvm {
 
-/// format_object_base - This is a helper class used for handling formatted
-/// output.  It is the abstract base class of a templated derived class.
+/// This is a helper class used for handling formatted output.  It is the
+/// abstract base class of a templated derived class.
 class format_object_base {
 protected:
   const char *Fmt;
   virtual void home(); // Out of line virtual method.
 
-  /// snprint - Call snprintf() for this object, on the given buffer and size.
+  /// Call snprintf() for this object, on the given buffer and size.
   virtual int snprint(char *Buffer, unsigned BufferSize) const = 0;
 
 public:
   format_object_base(const char *fmt) : Fmt(fmt) {}
   virtual ~format_object_base() {}
 
-  /// print - Format the object into the specified buffer.  On success, this
-  /// returns the length of the formatted string.  If the buffer is too small,
-  /// this returns a length to retry with, which will be larger than BufferSize.
+  /// Format the object into the specified buffer.  On success, this returns
+  /// the length of the formatted string.  If the buffer is too small, this
+  /// returns a length to retry with, which will be larger than BufferSize.
   unsigned print(char *Buffer, unsigned BufferSize) const {
     assert(BufferSize && "Invalid buffer size!");
 
@@ -61,21 +61,23 @@ public:
 
     // VC++ and old GlibC return negative on overflow, just double the size.
     if (N < 0)
-      return BufferSize*2;
+      return BufferSize * 2;
 
-    // Other impls yield number of bytes needed, not including the final '\0'.
+    // Other implementations yield number of bytes needed, not including the
+    // final '\0'.
     if (unsigned(N) >= BufferSize)
-      return N+1;
+      return N + 1;
 
     // Otherwise N is the length of output (not including the final '\0').
     return N;
   }
 };
 
-/// format_object1 - This is a templated helper class used by the format
-/// function that captures the object to be formated and the format string. When
-/// actually printed, this synthesizes the string into a temporary buffer
-/// provided and returns whether or not it is big enough.
+/// These are templated helper classes used by the format function that
+/// capture the object to be formated and the format string. When actually
+/// printed, this synthesizes the string into a temporary buffer provided and
+/// returns whether or not it is big enough.
+
 template <typename T>
 class format_object1 : public format_object_base {
   T Val;
@@ -89,10 +91,6 @@ public:
   }
 };
 
-/// format_object2 - This is a templated helper class used by the format
-/// function that captures the object to be formated and the format string. When
-/// actually printed, this synthesizes the string into a temporary buffer
-/// provided and returns whether or not it is big enough.
 template <typename T1, typename T2>
 class format_object2 : public format_object_base {
   T1 Val1;
@@ -107,10 +105,6 @@ public:
   }
 };
 
-/// format_object3 - This is a templated helper class used by the format
-/// function that captures the object to be formated and the format string. When
-/// actually printed, this synthesizes the string into a temporary buffer
-/// provided and returns whether or not it is big enough.
 template <typename T1, typename T2, typename T3>
 class format_object3 : public format_object_base {
   T1 Val1;
@@ -126,10 +120,6 @@ public:
   }
 };
 
-/// format_object4 - This is a templated helper class used by the format
-/// function that captures the object to be formated and the format string. When
-/// actually printed, this synthesizes the string into a temporary buffer
-/// provided and returns whether or not it is big enough.
 template <typename T1, typename T2, typename T3, typename T4>
 class format_object4 : public format_object_base {
   T1 Val1;
@@ -147,10 +137,6 @@ public:
   }
 };
 
-/// format_object5 - This is a templated helper class used by the format
-/// function that captures the object to be formated and the format string. When
-/// actually printed, this synthesizes the string into a temporary buffer
-/// provided and returns whether or not it is big enough.
 template <typename T1, typename T2, typename T3, typename T4, typename T5>
 class format_object5 : public format_object_base {
   T1 Val1;
@@ -170,10 +156,6 @@ public:
   }
 };
 
-/// format_object6 - This is a templated helper class used by the format
-/// function that captures the object to be formated and the format string. When
-/// actually printed, this synthesizes the string into a temporary buffer
-/// provided and returns whether or not it is big enough.
 template <typename T1, typename T2, typename T3, typename T4, typename T5,
           typename T6>
 class format_object6 : public format_object_base {
@@ -194,47 +176,32 @@ public:
   }
 };
 
-/// This is a helper function that is used to produce formatted output.
+/// These are helper functions used to produce formatted output.  They use
+/// template type deduction to construct the appropriate instance of the
+/// format_object class to simplify their construction.
 ///
 /// This is typically used like:
 /// \code
 ///   OS << format("%0.4f", myfloat) << '\n';
 /// \endcode
+
 template <typename T>
 inline format_object1<T> format(const char *Fmt, const T &Val) {
   return format_object1<T>(Fmt, Val);
 }
 
-/// This is a helper function that is used to produce formatted output.
-///
-/// This is typically used like:
-/// \code
-///   OS << format("%0.4f", myfloat) << '\n';
-/// \endcode
 template <typename T1, typename T2>
 inline format_object2<T1, T2> format(const char *Fmt, const T1 &Val1,
                                      const T2 &Val2) {
   return format_object2<T1, T2>(Fmt, Val1, Val2);
 }
 
-/// This is a helper function that is used to produce formatted output.
-///
-/// This is typically used like:
-/// \code
-///   OS << format("%0.4f", myfloat) << '\n';
-/// \endcode
 template <typename T1, typename T2, typename T3>
   inline format_object3<T1, T2, T3> format(const char *Fmt, const T1 &Val1,
                                            const T2 &Val2, const T3 &Val3) {
   return format_object3<T1, T2, T3>(Fmt, Val1, Val2, Val3);
 }
 
-/// This is a helper function that is used to produce formatted output.
-///
-/// This is typically used like:
-/// \code
-///   OS << format("%0.4f", myfloat) << '\n';
-/// \endcode
 template <typename T1, typename T2, typename T3, typename T4>
 inline format_object4<T1, T2, T3, T4> format(const char *Fmt, const T1 &Val1,
                                              const T2 &Val2, const T3 &Val3,
@@ -242,12 +209,6 @@ inline format_object4<T1, T2, T3, T4> fo
   return format_object4<T1, T2, T3, T4>(Fmt, Val1, Val2, Val3, Val4);
 }
 
-/// This is a helper function that is used to produce formatted output.
-///
-/// This is typically used like:
-/// \code
-///   OS << format("%0.4f", myfloat) << '\n';
-/// \endcode
 template <typename T1, typename T2, typename T3, typename T4, typename T5>
 inline format_object5<T1, T2, T3, T4, T5> format(const char *Fmt,const T1 &Val1,
                                              const T2 &Val2, const T3 &Val3,
@@ -255,12 +216,6 @@ inline format_object5<T1, T2, T3, T4, T5
   return format_object5<T1, T2, T3, T4, T5>(Fmt, Val1, Val2, Val3, Val4, Val5);
 }
 
-/// This is a helper function that is used to produce formatted output.
-///
-/// This is typically used like:
-/// \code
-///   OS << format("%0.4f", myfloat) << '\n';
-/// \endcode
 template <typename T1, typename T2, typename T3, typename T4, typename T5,
           typename T6>
 inline format_object6<T1, T2, T3, T4, T5, T6>





More information about the llvm-commits mailing list