Support: Add llvm::center_justify.

[marsupial]

Summary

Completes the set.

[ruiu]

include/llvm/Support/Format.h

132 ↗

(On Diff #106103)

Why don't you use Justification as a type? I think you don't need to save a few bits here.

lib/Support/raw_ostream.cpp

334–343 ↗

(On Diff #106103)

Using an enum value as a bitmask looks too tricky. It is probably better to write in three-way branches like this.

switch (FS.Justify) {
case JustifyRight:
  this->indent(FS.Width - Len);
  this->operator<<(FS.Str);
  break;
case JustifyCenter: {
  int PadAmount = (FS.Width - Len) / 2;
  this->indent(PadAmount);
  this->operator<<(FS.Str);  
  this->indent(Difference - PadAmount * 2);
}
case JustifyLeft:
  this->operator<<(FS.Str);
  this->indent(FS.Width - Len);
  break;
}

[marsupial]

Ok,

[ruiu]

lib/Support/raw_ostream.cpp

344 ↗

(On Diff #106111)

nit; since the scope of this variable is very small, I wouldn't add const as it is obvious.

347 ↗

(On Diff #106111)

PadAmount + (Difference - (PadAmount * 2))

is the same as

PadAmount + Difference - PadAmount * 2

and thus

Difference - PadAmount

?

348 ↗

(On Diff #106111)

I believe we usually write this way.

  break;
}

[ruiu]

lib/Support/raw_ostream.cpp

347 ↗

(On Diff #106111)

Isn't this the same as Difference - PadAmount as I wrote above?

[marsupial]

Updated

[ruiu]

It looks good to me, but I'll LGTM tomorrow to give other reviewers a chance to take a look.

[ruiu]

LGTM

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

 ///   OS << format("%0.4f", myfloat) << '\n';
 /// \endcode
 
 template <typename... Ts>
 inline format_object<Ts...> format(const char *Fmt, const Ts &... Vals) {
   return format_object<Ts...>(Fmt, Vals...);
 }
 
-/// This is a helper class used for left_justify() and right_justify().
+/// This is a helper class for left_justify, right_justify, and center_justify.
 class FormattedString {
+public:
+  enum Justification { JustifyNone, JustifyLeft, JustifyRight, JustifyCenter };
+  FormattedString(StringRef S, unsigned W, Justification J)
+      : Str(S), Width(W), Justify(J) {}
+
+private:
   StringRef Str;
   unsigned Width;
-  bool RightJustify;
+  Justification Justify;
   friend class raw_ostream;
-
-public:
-    FormattedString(StringRef S, unsigned W, bool R)
-      : Str(S), Width(W), RightJustify(R) { }
 };
 
 /// left_justify - append spaces after string so total output is
 /// \p Width characters.  If \p Str is larger that \p Width, full string
 /// is written with no padding.
 inline FormattedString left_justify(StringRef Str, unsigned Width) {
-  return FormattedString(Str, Width, false);
+  return FormattedString(Str, Width, FormattedString::JustifyLeft);
 }
 
 /// right_justify - add spaces before string so total output is
 /// \p Width characters.  If \p Str is larger that \p Width, full string
 /// is written with no padding.
 inline FormattedString right_justify(StringRef Str, unsigned Width) {
-  return FormattedString(Str, Width, true);
+  return FormattedString(Str, Width, FormattedString::JustifyRight);
+}
+
+/// center_justify - add spaces before and after string so total output is
+/// \p Width characters.  If \p Str is larger that \p Width, full string
+/// is written with no padding.
+inline FormattedString center_justify(StringRef Str, unsigned Width) {
+  return FormattedString(Str, Width, FormattedString::JustifyCenter);
 }
 
 /// This is a helper class used for format_hex() and format_decimal().
 class FormattedNumber {
   uint64_t HexValue;
   int64_t DecValue;
   unsigned Width;
   bool Hex;

llvm/trunk/lib/Support/raw_ostream.cpp

 
 raw_ostream &raw_ostream::operator<<(const formatv_object_base &Obj) {
   SmallString<128> S;
   Obj.format(*this);
   return *this;
 }
 
 raw_ostream &raw_ostream::operator<<(const FormattedString &FS) {
-  unsigned Len = FS.Str.size(); 
-  int PadAmount = FS.Width - Len;
-  if (FS.RightJustify && (PadAmount > 0))
-    this->indent(PadAmount);
+  if (FS.Str.size() >= FS.Width || FS.Justify == FormattedString::JustifyNone) {
+    this->operator<<(FS.Str);
+    return *this;
+  }
+  const size_t Difference = FS.Width - FS.Str.size();
+  switch (FS.Justify) {
+  case FormattedString::JustifyLeft:
+    this->operator<<(FS.Str);
+    this->indent(Difference);
+    break;
+  case FormattedString::JustifyRight:
+    this->indent(Difference);
     this->operator<<(FS.Str);
-  if (!FS.RightJustify && (PadAmount > 0))
+    break;
+  case FormattedString::JustifyCenter: {
+    int PadAmount = Difference / 2;
     this->indent(PadAmount);
+    this->operator<<(FS.Str);
+    this->indent(Difference - PadAmount);
+    break;
+  }
+  default:
+    llvm_unreachable("Bad Justification");
+  }
   return *this;
 }
 
 raw_ostream &raw_ostream::operator<<(const FormattedNumber &FN) {
   if (FN.Hex) {
     HexPrintStyle Style;
     if (FN.Upper && FN.HexPrefix)
       Style = HexPrintStyle::PrefixUpper;

llvm/trunk/unittests/Support/raw_ostream_test.cpp

 
 TEST(raw_ostreamTest, Justify) {  
   EXPECT_EQ("xyz   ", printToString(left_justify("xyz", 6), 6));
   EXPECT_EQ("abc",    printToString(left_justify("abc", 3), 3));
   EXPECT_EQ("big",    printToString(left_justify("big", 1), 3));
   EXPECT_EQ("   xyz", printToString(right_justify("xyz", 6), 6));
   EXPECT_EQ("abc",    printToString(right_justify("abc", 3), 3));
   EXPECT_EQ("big",    printToString(right_justify("big", 1), 3));
+  EXPECT_EQ("   on    ",    printToString(center_justify("on", 9), 9));
+  EXPECT_EQ("   off    ",    printToString(center_justify("off", 10), 10));
+  EXPECT_EQ("single ",    printToString(center_justify("single", 7), 7));
+  EXPECT_EQ("none",    printToString(center_justify("none", 1), 4));
+  EXPECT_EQ("none",    printToString(center_justify("none", 1), 1));
 }
 
 TEST(raw_ostreamTest, FormatHex) {  
   EXPECT_EQ("0x1234",     printToString(format_hex(0x1234, 6), 6));
   EXPECT_EQ("0x001234",   printToString(format_hex(0x1234, 8), 8));
   EXPECT_EQ("0x00001234", printToString(format_hex(0x1234, 10), 10));
   EXPECT_EQ("0x1234",     printToString(format_hex(0x1234, 4), 6));
   EXPECT_EQ("0xff",       printToString(format_hex(255, 4), 4));