arrow-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From w...@apache.org
Subject [2/7] arrow git commit: ARROW-1219: [C++] Use Google C++ code formatting
Date Tue, 25 Jul 2017 02:55:58 GMT
http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/type.cc
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/type.cc b/cpp/src/arrow/type.cc
index 623c193..586da2d 100644
--- a/cpp/src/arrow/type.cc
+++ b/cpp/src/arrow/type.cc
@@ -37,7 +37,7 @@ std::shared_ptr<Field> Field::AddMetadata(
 }
 
 Status Field::AddMetadata(const std::shared_ptr<const KeyValueMetadata>& metadata,
-    std::shared_ptr<Field>* out) const {
+                          std::shared_ptr<Field>* out) const {
   *out = AddMetadata(metadata);
   return Status::OK();
 }
@@ -47,7 +47,9 @@ std::shared_ptr<Field> Field::RemoveMetadata() const {
 }
 
 bool Field::Equals(const Field& other) const {
-  if (this == &other) { return true; }
+  if (this == &other) {
+    return true;
+  }
   if (this->name_ == other.name_ && this->nullable_ == other.nullable_ &&
       this->type_->Equals(*other.type_.get())) {
     if (metadata_ == nullptr && other.metadata_ == nullptr) {
@@ -68,7 +70,9 @@ bool Field::Equals(const std::shared_ptr<Field>& other) const {
 std::string Field::ToString() const {
   std::stringstream ss;
   ss << this->name_ << ": " << this->type_->ToString();
-  if (!this->nullable_) { ss << " not null"; }
+  if (!this->nullable_) {
+    ss << " not null";
+  }
   return ss.str();
 }
 
@@ -77,34 +81,28 @@ DataType::~DataType() {}
 bool DataType::Equals(const DataType& other) const {
   bool are_equal = false;
   Status error = TypeEquals(*this, other, &are_equal);
-  if (!error.ok()) { DCHECK(false) << "Types not comparable: " << error.ToString(); }
+  if (!error.ok()) {
+    DCHECK(false) << "Types not comparable: " << error.ToString();
+  }
   return are_equal;
 }
 
 bool DataType::Equals(const std::shared_ptr<DataType>& other) const {
-  if (!other) { return false; }
+  if (!other) {
+    return false;
+  }
   return Equals(*other.get());
 }
 
-std::string BooleanType::ToString() const {
-  return name();
-}
+std::string BooleanType::ToString() const { return name(); }
 
-FloatingPoint::Precision HalfFloatType::precision() const {
-  return FloatingPoint::HALF;
-}
+FloatingPoint::Precision HalfFloatType::precision() const { return FloatingPoint::HALF; }
 
-FloatingPoint::Precision FloatType::precision() const {
-  return FloatingPoint::SINGLE;
-}
+FloatingPoint::Precision FloatType::precision() const { return FloatingPoint::SINGLE; }
 
-FloatingPoint::Precision DoubleType::precision() const {
-  return FloatingPoint::DOUBLE;
-}
+FloatingPoint::Precision DoubleType::precision() const { return FloatingPoint::DOUBLE; }
 
-std::string StringType::ToString() const {
-  return std::string("string");
-}
+std::string StringType::ToString() const { return std::string("string"); }
 
 std::string ListType::ToString() const {
   std::stringstream s;
@@ -112,13 +110,9 @@ std::string ListType::ToString() const {
   return s.str();
 }
 
-std::string BinaryType::ToString() const {
-  return std::string("binary");
-}
+std::string BinaryType::ToString() const { return std::string("binary"); }
 
-int FixedSizeBinaryType::bit_width() const {
-  return CHAR_BIT * byte_width();
-}
+int FixedSizeBinaryType::bit_width() const { return CHAR_BIT * byte_width(); }
 
 std::string FixedSizeBinaryType::ToString() const {
   std::stringstream ss;
@@ -130,7 +124,9 @@ std::string StructType::ToString() const {
   std::stringstream s;
   s << "struct<";
   for (int i = 0; i < this->num_children(); ++i) {
-    if (i > 0) { s << ", "; }
+    if (i > 0) {
+      s << ", ";
+    }
     std::shared_ptr<Field> field = this->child(i);
     s << field->name() << ": " << field->type()->ToString();
   }
@@ -148,13 +144,9 @@ Date32Type::Date32Type() : DateType(Type::DATE32, DateUnit::DAY) {}
 
 Date64Type::Date64Type() : DateType(Type::DATE64, DateUnit::MILLI) {}
 
-std::string Date64Type::ToString() const {
-  return std::string("date64[ms]");
-}
+std::string Date64Type::ToString() const { return std::string("date64[ms]"); }
 
-std::string Date32Type::ToString() const {
-  return std::string("date32[day]");
-}
+std::string Date32Type::ToString() const { return std::string("date32[day]"); }
 
 // ----------------------------------------------------------------------
 // Time types
@@ -190,7 +182,9 @@ std::string Time64Type::ToString() const {
 std::string TimestampType::ToString() const {
   std::stringstream ss;
   ss << "timestamp[" << this->unit_;
-  if (this->timezone_.size() > 0) { ss << ", tz=" << this->timezone_; }
+  if (this->timezone_.size() > 0) {
+    ss << ", tz=" << this->timezone_;
+  }
   ss << "]";
   return ss.str();
 }
@@ -199,7 +193,7 @@ std::string TimestampType::ToString() const {
 // Union type
 
 UnionType::UnionType(const std::vector<std::shared_ptr<Field>>& fields,
-    const std::vector<uint8_t>& type_codes, UnionMode mode)
+                     const std::vector<uint8_t>& type_codes, UnionMode mode)
     : NestedType(Type::UNION), mode_(mode), type_codes_(type_codes) {
   children_ = fields;
 }
@@ -214,7 +208,9 @@ std::string UnionType::ToString() const {
   }
 
   for (size_t i = 0; i < children_.size(); ++i) {
-    if (i) { s << ", "; }
+    if (i) {
+      s << ", ";
+    }
     s << children_[i]->ToString() << "=" << static_cast<int>(type_codes_[i]);
   }
   s << ">";
@@ -225,7 +221,7 @@ std::string UnionType::ToString() const {
 // DictionaryType
 
 DictionaryType::DictionaryType(const std::shared_ptr<DataType>& index_type,
-    const std::shared_ptr<Array>& dictionary, bool ordered)
+                               const std::shared_ptr<Array>& dictionary, bool ordered)
     : FixedWidthType(Type::DICTIONARY),
       index_type_(index_type),
       dictionary_(dictionary),
@@ -235,9 +231,7 @@ int DictionaryType::bit_width() const {
   return static_cast<const FixedWidthType*>(index_type_.get())->bit_width();
 }
 
-std::shared_ptr<Array> DictionaryType::dictionary() const {
-  return dictionary_;
-}
+std::shared_ptr<Array> DictionaryType::dictionary() const { return dictionary_; }
 
 std::string DictionaryType::ToString() const {
   std::stringstream ss;
@@ -249,23 +243,27 @@ std::string DictionaryType::ToString() const {
 // ----------------------------------------------------------------------
 // Null type
 
-std::string NullType::ToString() const {
-  return name();
-}
+std::string NullType::ToString() const { return name(); }
 
 // ----------------------------------------------------------------------
 // Schema implementation
 
 Schema::Schema(const std::vector<std::shared_ptr<Field>>& fields,
-    const std::shared_ptr<const KeyValueMetadata>& metadata)
+               const std::shared_ptr<const KeyValueMetadata>& metadata)
     : fields_(fields), metadata_(metadata) {}
 
 bool Schema::Equals(const Schema& other) const {
-  if (this == &other) { return true; }
+  if (this == &other) {
+    return true;
+  }
 
-  if (num_fields() != other.num_fields()) { return false; }
+  if (num_fields() != other.num_fields()) {
+    return false;
+  }
   for (int i = 0; i < num_fields(); ++i) {
-    if (!field(i)->Equals(*other.field(i).get())) { return false; }
+    if (!field(i)->Equals(*other.field(i).get())) {
+      return false;
+    }
   }
   return true;
 }
@@ -290,8 +288,8 @@ int64_t Schema::GetFieldIndex(const std::string& name) const {
   }
 }
 
-Status Schema::AddField(
-    int i, const std::shared_ptr<Field>& field, std::shared_ptr<Schema>* out) const {
+Status Schema::AddField(int i, const std::shared_ptr<Field>& field,
+                        std::shared_ptr<Schema>* out) const {
   DCHECK_GE(i, 0);
   DCHECK_LE(i, this->num_fields());
 
@@ -305,7 +303,7 @@ std::shared_ptr<Schema> Schema::AddMetadata(
 }
 
 Status Schema::AddMetadata(const std::shared_ptr<const KeyValueMetadata>& metadata,
-    std::shared_ptr<Schema>* out) const {
+                           std::shared_ptr<Schema>* out) const {
   *out = AddMetadata(metadata);
   return Status::OK();
 }
@@ -327,7 +325,9 @@ std::string Schema::ToString() const {
 
   int i = 0;
   for (auto field : fields_) {
-    if (i > 0) { buffer << std::endl; }
+    if (i > 0) {
+      buffer << std::endl;
+    }
     buffer << field->ToString();
     ++i;
   }
@@ -422,18 +422,18 @@ std::shared_ptr<DataType> struct_(const std::vector<std::shared_ptr<Field>>& fie
 }
 
 std::shared_ptr<DataType> union_(const std::vector<std::shared_ptr<Field>>& child_fields,
-    const std::vector<uint8_t>& type_codes, UnionMode mode) {
+                                 const std::vector<uint8_t>& type_codes, UnionMode mode) {
   return std::make_shared<UnionType>(child_fields, type_codes, mode);
 }
 
 std::shared_ptr<DataType> dictionary(const std::shared_ptr<DataType>& index_type,
-    const std::shared_ptr<Array>& dict_values) {
+                                     const std::shared_ptr<Array>& dict_values) {
   return std::make_shared<DictionaryType>(index_type, dict_values);
 }
 
 std::shared_ptr<Field> field(const std::string& name,
-    const std::shared_ptr<DataType>& type, bool nullable,
-    const std::shared_ptr<const KeyValueMetadata>& metadata) {
+                             const std::shared_ptr<DataType>& type, bool nullable,
+                             const std::shared_ptr<const KeyValueMetadata>& metadata) {
   return std::make_shared<Field>(name, type, nullable, metadata);
 }
 
@@ -454,9 +454,7 @@ std::vector<BufferDescr> FixedWidthType::GetBufferLayout() const {
   return {kValidityBuffer, BufferDescr(BufferType::DATA, bit_width())};
 }
 
-std::vector<BufferDescr> NullType::GetBufferLayout() const {
-  return {};
-}
+std::vector<BufferDescr> NullType::GetBufferLayout() const { return {}; }
 
 std::vector<BufferDescr> BinaryType::GetBufferLayout() const {
   return {kValidityBuffer, kOffsetBuffer, kValues8};
@@ -474,9 +472,7 @@ std::vector<BufferDescr> ListType::GetBufferLayout() const {
   return {kValidityBuffer, kOffsetBuffer};
 }
 
-std::vector<BufferDescr> StructType::GetBufferLayout() const {
-  return {kValidityBuffer};
-}
+std::vector<BufferDescr> StructType::GetBufferLayout() const { return {kValidityBuffer}; }
 
 std::vector<BufferDescr> UnionType::GetBufferLayout() const {
   if (mode_ == UnionMode::SPARSE) {

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/type.h
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/type.h b/cpp/src/arrow/type.h
index fffb840..e0df722 100644
--- a/cpp/src/arrow/type.h
+++ b/cpp/src/arrow/type.h
@@ -204,15 +204,15 @@ class NoExtraMeta {};
 class ARROW_EXPORT Field {
  public:
   Field(const std::string& name, const std::shared_ptr<DataType>& type,
-      bool nullable = true,
-      const std::shared_ptr<const KeyValueMetadata>& metadata = nullptr)
+        bool nullable = true,
+        const std::shared_ptr<const KeyValueMetadata>& metadata = nullptr)
       : name_(name), type_(type), nullable_(nullable), metadata_(metadata) {}
 
   std::shared_ptr<const KeyValueMetadata> metadata() const { return metadata_; }
 
   /// \deprecated
   Status AddMetadata(const std::shared_ptr<const KeyValueMetadata>& metadata,
-      std::shared_ptr<Field>* out) const;
+                     std::shared_ptr<Field>* out) const;
 
   std::shared_ptr<Field> AddMetadata(
       const std::shared_ptr<const KeyValueMetadata>& metadata) const;
@@ -489,7 +489,7 @@ class ARROW_EXPORT UnionType : public NestedType {
   static constexpr Type::type type_id = Type::UNION;
 
   UnionType(const std::vector<std::shared_ptr<Field>>& fields,
-      const std::vector<uint8_t>& type_codes, UnionMode mode = UnionMode::SPARSE);
+            const std::vector<uint8_t>& type_codes, UnionMode mode = UnionMode::SPARSE);
 
   std::string ToString() const override;
   static std::string name() { return "union"; }
@@ -669,7 +669,7 @@ class ARROW_EXPORT DictionaryType : public FixedWidthType {
   static constexpr Type::type type_id = Type::DICTIONARY;
 
   DictionaryType(const std::shared_ptr<DataType>& index_type,
-      const std::shared_ptr<Array>& dictionary, bool ordered = false);
+                 const std::shared_ptr<Array>& dictionary, bool ordered = false);
 
   int bit_width() const override;
 
@@ -699,7 +699,7 @@ class ARROW_EXPORT DictionaryType : public FixedWidthType {
 class ARROW_EXPORT Schema {
  public:
   explicit Schema(const std::vector<std::shared_ptr<Field>>& fields,
-      const std::shared_ptr<const KeyValueMetadata>& metadata = nullptr);
+                  const std::shared_ptr<const KeyValueMetadata>& metadata = nullptr);
   virtual ~Schema() = default;
 
   /// Returns true if all of the schema fields are equal
@@ -724,13 +724,13 @@ class ARROW_EXPORT Schema {
   /// \brief Render a string representation of the schema suitable for debugging
   std::string ToString() const;
 
-  Status AddField(
-      int i, const std::shared_ptr<Field>& field, std::shared_ptr<Schema>* out) const;
+  Status AddField(int i, const std::shared_ptr<Field>& field,
+                  std::shared_ptr<Schema>* out) const;
   Status RemoveField(int i, std::shared_ptr<Schema>* out) const;
 
   /// \deprecated
   Status AddMetadata(const std::shared_ptr<const KeyValueMetadata>& metadata,
-      std::shared_ptr<Schema>* out) const;
+                     std::shared_ptr<Schema>* out) const;
 
   /// \brief Replace key-value metadata with new metadata
   ///
@@ -761,8 +761,8 @@ std::shared_ptr<DataType> ARROW_EXPORT list(const std::shared_ptr<Field>& value_
 std::shared_ptr<DataType> ARROW_EXPORT list(const std::shared_ptr<DataType>& value_type);
 
 std::shared_ptr<DataType> ARROW_EXPORT timestamp(TimeUnit::type unit);
-std::shared_ptr<DataType> ARROW_EXPORT timestamp(
-    TimeUnit::type unit, const std::string& timezone);
+std::shared_ptr<DataType> ARROW_EXPORT timestamp(TimeUnit::type unit,
+                                                 const std::string& timezone);
 
 /// Unit can be either SECOND or MILLI
 std::shared_ptr<DataType> ARROW_EXPORT time32(TimeUnit::type unit);
@@ -770,18 +770,18 @@ std::shared_ptr<DataType> ARROW_EXPORT time32(TimeUnit::type unit);
 /// Unit can be either MICRO or NANO
 std::shared_ptr<DataType> ARROW_EXPORT time64(TimeUnit::type unit);
 
-std::shared_ptr<DataType> ARROW_EXPORT struct_(
-    const std::vector<std::shared_ptr<Field>>& fields);
+std::shared_ptr<DataType> ARROW_EXPORT
+struct_(const std::vector<std::shared_ptr<Field>>& fields);
 
-std::shared_ptr<DataType> ARROW_EXPORT union_(
-    const std::vector<std::shared_ptr<Field>>& child_fields,
-    const std::vector<uint8_t>& type_codes, UnionMode mode = UnionMode::SPARSE);
+std::shared_ptr<DataType> ARROW_EXPORT
+union_(const std::vector<std::shared_ptr<Field>>& child_fields,
+       const std::vector<uint8_t>& type_codes, UnionMode mode = UnionMode::SPARSE);
 
 std::shared_ptr<DataType> ARROW_EXPORT dictionary(
     const std::shared_ptr<DataType>& index_type, const std::shared_ptr<Array>& values);
 
-std::shared_ptr<Field> ARROW_EXPORT field(const std::string& name,
-    const std::shared_ptr<DataType>& type, bool nullable = true,
+std::shared_ptr<Field> ARROW_EXPORT field(
+    const std::string& name, const std::shared_ptr<DataType>& type, bool nullable = true,
     const std::shared_ptr<const KeyValueMetadata>& metadata = nullptr);
 
 // ----------------------------------------------------------------------

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/type_traits.h
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/type_traits.h b/cpp/src/arrow/type_traits.h
index 3e8ea23..8be67b2 100644
--- a/cpp/src/arrow/type_traits.h
+++ b/cpp/src/arrow/type_traits.h
@@ -319,9 +319,10 @@ GET_ATTR(TypeClass, void);
 
 #undef GET_ATTR
 
-#define PRIMITIVE_TRAITS(T)                                                           \
-  using TypeClass = typename std::conditional<std::is_base_of<DataType, T>::value, T, \
-      typename GetAttr_TypeClass<T>::type>::type;                                     \
+#define PRIMITIVE_TRAITS(T)                                                 \
+  using TypeClass =                                                         \
+      typename std::conditional<std::is_base_of<DataType, T>::value, T,     \
+                                typename GetAttr_TypeClass<T>::type>::type; \
   using c_type = typename GetAttr_c_type<TypeClass>::type;
 
 template <typename T>

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/bit-stream-utils.h
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/bit-stream-utils.h b/cpp/src/arrow/util/bit-stream-utils.h
index 537fdc3..318f5ba 100644
--- a/cpp/src/arrow/util/bit-stream-utils.h
+++ b/cpp/src/arrow/util/bit-stream-utils.h
@@ -20,9 +20,9 @@
 #ifndef ARROW_UTIL_BIT_STREAM_UTILS_H
 #define ARROW_UTIL_BIT_STREAM_UTILS_H
 
+#include <string.h>
 #include <algorithm>
 #include <cstdint>
-#include <string.h>
 
 #include "arrow/util/bit-util.h"
 #include "arrow/util/bpacking.h"
@@ -229,13 +229,13 @@ inline bool BitWriter::PutVlqInt(uint32_t v) {
 
 template <typename T>
 inline void GetValue_(int num_bits, T* v, int max_bytes, const uint8_t* buffer,
-    int* bit_offset, int* byte_offset, uint64_t* buffered_values) {
+                      int* bit_offset, int* byte_offset, uint64_t* buffered_values) {
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable : 4800)
 #endif
-  *v = static_cast<T>(
-      BitUtil::TrailingBits(*buffered_values, *bit_offset + num_bits) >> *bit_offset);
+  *v = static_cast<T>(BitUtil::TrailingBits(*buffered_values, *bit_offset + num_bits) >>
+                      *bit_offset);
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
@@ -292,13 +292,14 @@ inline int BitReader::GetBatch(int num_bits, T* v, int batch_size) {
   if (UNLIKELY(bit_offset != 0)) {
     for (; i < batch_size && bit_offset != 0; ++i) {
       GetValue_(num_bits, &v[i], max_bytes, buffer, &bit_offset, &byte_offset,
-          &buffered_values);
+                &buffered_values);
     }
   }
 
   if (sizeof(T) == 4) {
-    int num_unpacked = unpack32(reinterpret_cast<const uint32_t*>(buffer + byte_offset),
-        reinterpret_cast<uint32_t*>(v + i), batch_size - i, num_bits);
+    int num_unpacked =
+        unpack32(reinterpret_cast<const uint32_t*>(buffer + byte_offset),
+                 reinterpret_cast<uint32_t*>(v + i), batch_size - i, num_bits);
     i += num_unpacked;
     byte_offset += num_unpacked * num_bits / 8;
   } else {
@@ -307,8 +308,10 @@ inline int BitReader::GetBatch(int num_bits, T* v, int batch_size) {
     while (i < batch_size) {
       int unpack_size = std::min(buffer_size, batch_size - i);
       int num_unpacked = unpack32(reinterpret_cast<const uint32_t*>(buffer + byte_offset),
-          unpack_buffer, unpack_size, num_bits);
-      if (num_unpacked == 0) { break; }
+                                  unpack_buffer, unpack_size, num_bits);
+      if (num_unpacked == 0) {
+        break;
+      }
       for (int k = 0; k < num_unpacked; ++k) {
 #ifdef _MSC_VER
 #pragma warning(push)
@@ -332,8 +335,8 @@ inline int BitReader::GetBatch(int num_bits, T* v, int batch_size) {
   }
 
   for (; i < batch_size; ++i) {
-    GetValue_(
-        num_bits, &v[i], max_bytes, buffer, &bit_offset, &byte_offset, &buffered_values);
+    GetValue_(num_bits, &v[i], max_bytes, buffer, &bit_offset, &byte_offset,
+              &buffered_values);
   }
 
   bit_offset_ = bit_offset;

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/bit-util-test.cc
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/bit-util-test.cc b/cpp/src/arrow/util/bit-util-test.cc
index cd94558..231bf54 100644
--- a/cpp/src/arrow/util/bit-util-test.cc
+++ b/cpp/src/arrow/util/bit-util-test.cc
@@ -35,7 +35,9 @@
 namespace arrow {
 
 static void EnsureCpuInfoInitialized() {
-  if (!CpuInfo::initialized()) { CpuInfo::Init(); }
+  if (!CpuInfo::initialized()) {
+    CpuInfo::Init();
+  }
 }
 
 TEST(BitUtilTests, TestIsMultipleOf64) {
@@ -68,11 +70,13 @@ TEST(BitUtilTests, TestNextPower2) {
   ASSERT_EQ(1LL << 62, NextPower2((1LL << 62) - 1));
 }
 
-static inline int64_t SlowCountBits(
-    const uint8_t* data, int64_t bit_offset, int64_t length) {
+static inline int64_t SlowCountBits(const uint8_t* data, int64_t bit_offset,
+                                    int64_t length) {
   int64_t count = 0;
   for (int64_t i = bit_offset; i < bit_offset + length; ++i) {
-    if (BitUtil::GetBit(data, i)) { ++count; }
+    if (BitUtil::GetBit(data, i)) {
+      ++count;
+    }
   }
   return count;
 }
@@ -175,9 +179,9 @@ TEST(BitUtil, TrailingBits) {
   EXPECT_EQ(BitUtil::TrailingBits(BOOST_BINARY(1 1 1 1 1 1 1 1), 0), 0);
   EXPECT_EQ(BitUtil::TrailingBits(BOOST_BINARY(1 1 1 1 1 1 1 1), 1), 1);
   EXPECT_EQ(BitUtil::TrailingBits(BOOST_BINARY(1 1 1 1 1 1 1 1), 64),
-      BOOST_BINARY(1 1 1 1 1 1 1 1));
+            BOOST_BINARY(1 1 1 1 1 1 1 1));
   EXPECT_EQ(BitUtil::TrailingBits(BOOST_BINARY(1 1 1 1 1 1 1 1), 100),
-      BOOST_BINARY(1 1 1 1 1 1 1 1));
+            BOOST_BINARY(1 1 1 1 1 1 1 1));
   EXPECT_EQ(BitUtil::TrailingBits(0, 1), 0);
   EXPECT_EQ(BitUtil::TrailingBits(0, 64), 0);
   EXPECT_EQ(BitUtil::TrailingBits(1LL << 63, 0), 0);
@@ -193,12 +197,12 @@ TEST(BitUtil, ByteSwap) {
   EXPECT_EQ(BitUtil::ByteSwap(static_cast<int32_t>(0x11223344)), 0x44332211);
 
   EXPECT_EQ(BitUtil::ByteSwap(static_cast<uint64_t>(0)), 0);
-  EXPECT_EQ(
-      BitUtil::ByteSwap(static_cast<uint64_t>(0x1122334455667788)), 0x8877665544332211);
+  EXPECT_EQ(BitUtil::ByteSwap(static_cast<uint64_t>(0x1122334455667788)),
+            0x8877665544332211);
 
   EXPECT_EQ(BitUtil::ByteSwap(static_cast<int64_t>(0)), 0);
-  EXPECT_EQ(
-      BitUtil::ByteSwap(static_cast<int64_t>(0x1122334455667788)), 0x8877665544332211);
+  EXPECT_EQ(BitUtil::ByteSwap(static_cast<int64_t>(0x1122334455667788)),
+            0x8877665544332211);
 
   EXPECT_EQ(BitUtil::ByteSwap(static_cast<int16_t>(0)), 0);
   EXPECT_EQ(BitUtil::ByteSwap(static_cast<int16_t>(0x1122)), 0x2211);

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/bit-util.cc
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/bit-util.cc b/cpp/src/arrow/util/bit-util.cc
index 5bbec6f..f255f95 100644
--- a/cpp/src/arrow/util/bit-util.cc
+++ b/cpp/src/arrow/util/bit-util.cc
@@ -36,12 +36,14 @@ namespace arrow {
 
 void BitUtil::FillBitsFromBytes(const std::vector<uint8_t>& bytes, uint8_t* bits) {
   for (size_t i = 0; i < bytes.size(); ++i) {
-    if (bytes[i] > 0) { SetBit(bits, i); }
+    if (bytes[i] > 0) {
+      SetBit(bits, i);
+    }
   }
 }
 
-Status BitUtil::BytesToBits(
-    const std::vector<uint8_t>& bytes, std::shared_ptr<Buffer>* out) {
+Status BitUtil::BytesToBits(const std::vector<uint8_t>& bytes,
+                            std::shared_ptr<Buffer>* out) {
   int64_t bit_length = BitUtil::BytesForBits(bytes.size());
 
   std::shared_ptr<MutableBuffer> buffer;
@@ -65,7 +67,9 @@ int64_t CountSetBits(const uint8_t* data, int64_t bit_offset, int64_t length) {
   // The number of bits until fast_count_start
   const int64_t initial_bits = std::min(length, fast_count_start - bit_offset);
   for (int64_t i = bit_offset; i < bit_offset + initial_bits; ++i) {
-    if (BitUtil::GetBit(data, i)) { ++count; }
+    if (BitUtil::GetBit(data, i)) {
+      ++count;
+    }
   }
 
   const int64_t fast_counts = (length - initial_bits) / pop_len;
@@ -85,21 +89,23 @@ int64_t CountSetBits(const uint8_t* data, int64_t bit_offset, int64_t length) {
   // versions of popcount but the code complexity is likely not worth it)
   const int64_t tail_index = bit_offset + initial_bits + fast_counts * pop_len;
   for (int64_t i = tail_index; i < bit_offset + length; ++i) {
-    if (BitUtil::GetBit(data, i)) { ++count; }
+    if (BitUtil::GetBit(data, i)) {
+      ++count;
+    }
   }
 
   return count;
 }
 
-Status GetEmptyBitmap(
-    MemoryPool* pool, int64_t length, std::shared_ptr<MutableBuffer>* result) {
+Status GetEmptyBitmap(MemoryPool* pool, int64_t length,
+                      std::shared_ptr<MutableBuffer>* result) {
   RETURN_NOT_OK(AllocateBuffer(pool, BitUtil::BytesForBits(length), result));
   memset((*result)->mutable_data(), 0, static_cast<size_t>((*result)->size()));
   return Status::OK();
 }
 
 Status CopyBitmap(MemoryPool* pool, const uint8_t* data, int64_t offset, int64_t length,
-    std::shared_ptr<Buffer>* out) {
+                  std::shared_ptr<Buffer>* out) {
   std::shared_ptr<MutableBuffer> buffer;
   RETURN_NOT_OK(GetEmptyBitmap(pool, length, &buffer));
   uint8_t* dest = buffer->mutable_data();
@@ -111,12 +117,14 @@ Status CopyBitmap(MemoryPool* pool, const uint8_t* data, int64_t offset, int64_t
 }
 
 bool BitmapEquals(const uint8_t* left, int64_t left_offset, const uint8_t* right,
-    int64_t right_offset, int64_t bit_length) {
+                  int64_t right_offset, int64_t bit_length) {
   if (left_offset % 8 == 0 && right_offset % 8 == 0) {
     // byte aligned, can use memcmp
     bool bytes_equal = std::memcmp(left + left_offset / 8, right + right_offset / 8,
-                           bit_length / 8) == 0;
-    if (!bytes_equal) { return false; }
+                                   bit_length / 8) == 0;
+    if (!bytes_equal) {
+      return false;
+    }
     for (int64_t i = (bit_length / 8) * 8; i < bit_length; ++i) {
       if (BitUtil::GetBit(left, left_offset + i) !=
           BitUtil::GetBit(right, right_offset + i)) {

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/bit-util.h
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/bit-util.h b/cpp/src/arrow/util/bit-util.h
index d055c75..f036763 100644
--- a/cpp/src/arrow/util/bit-util.h
+++ b/cpp/src/arrow/util/bit-util.h
@@ -101,17 +101,11 @@ static constexpr uint8_t kBitmask[] = {1, 2, 4, 8, 16, 32, 64, 128};
 // the ~i byte version of kBitmaks
 static constexpr uint8_t kFlippedBitmask[] = {254, 253, 251, 247, 239, 223, 191, 127};
 
-static inline int64_t CeilByte(int64_t size) {
-  return (size + 7) & ~7;
-}
+static inline int64_t CeilByte(int64_t size) { return (size + 7) & ~7; }
 
-static inline int64_t BytesForBits(int64_t size) {
-  return CeilByte(size) / 8;
-}
+static inline int64_t BytesForBits(int64_t size) { return CeilByte(size) / 8; }
 
-static inline int64_t Ceil2Bytes(int64_t size) {
-  return (size + 15) & ~15;
-}
+static inline int64_t Ceil2Bytes(int64_t size) { return (size + 15) & ~15; }
 
 static inline bool GetBit(const uint8_t* bits, int64_t i) {
   return (bits[i / 8] & kBitmask[i % 8]) != 0;
@@ -125,13 +119,13 @@ static inline void ClearBit(uint8_t* bits, int64_t i) {
   bits[i / 8] &= kFlippedBitmask[i % 8];
 }
 
-static inline void SetBit(uint8_t* bits, int64_t i) {
-  bits[i / 8] |= kBitmask[i % 8];
-}
+static inline void SetBit(uint8_t* bits, int64_t i) { bits[i / 8] |= kBitmask[i % 8]; }
 
 /// Set bit if is_set is true, but cannot clear bit
 static inline void SetArrayBit(uint8_t* bits, int i, bool is_set) {
-  if (is_set) { SetBit(bits, i); }
+  if (is_set) {
+    SetBit(bits, i);
+  }
 }
 
 static inline void SetBitTo(uint8_t* bits, int64_t i, bool bit_is_set) {
@@ -168,13 +162,9 @@ static inline int64_t NextPower2(int64_t n) {
   return n;
 }
 
-static inline bool IsMultipleOf64(int64_t n) {
-  return (n & 63) == 0;
-}
+static inline bool IsMultipleOf64(int64_t n) { return (n & 63) == 0; }
 
-static inline bool IsMultipleOf8(int64_t n) {
-  return (n & 7) == 0;
-}
+static inline bool IsMultipleOf8(int64_t n) { return (n & 7) == 0; }
 
 /// Returns the ceil of value/divisor
 static inline int64_t Ceil(int64_t value, int64_t divisor) {
@@ -206,34 +196,22 @@ static inline int RoundDownToPowerOf2(int value, int factor) {
 /// Specialized round up and down functions for frequently used factors,
 /// like 8 (bits->bytes), 32 (bits->i32), and 64 (bits->i64).
 /// Returns the rounded up number of bytes that fit the number of bits.
-static inline uint32_t RoundUpNumBytes(uint32_t bits) {
-  return (bits + 7) >> 3;
-}
+static inline uint32_t RoundUpNumBytes(uint32_t bits) { return (bits + 7) >> 3; }
 
 /// Returns the rounded down number of bytes that fit the number of bits.
-static inline uint32_t RoundDownNumBytes(uint32_t bits) {
-  return bits >> 3;
-}
+static inline uint32_t RoundDownNumBytes(uint32_t bits) { return bits >> 3; }
 
 /// Returns the rounded up to 32 multiple. Used for conversions of bits to i32.
-static inline uint32_t RoundUpNumi32(uint32_t bits) {
-  return (bits + 31) >> 5;
-}
+static inline uint32_t RoundUpNumi32(uint32_t bits) { return (bits + 31) >> 5; }
 
 /// Returns the rounded up 32 multiple.
-static inline uint32_t RoundDownNumi32(uint32_t bits) {
-  return bits >> 5;
-}
+static inline uint32_t RoundDownNumi32(uint32_t bits) { return bits >> 5; }
 
 /// Returns the rounded up to 64 multiple. Used for conversions of bits to i64.
-static inline uint32_t RoundUpNumi64(uint32_t bits) {
-  return (bits + 63) >> 6;
-}
+static inline uint32_t RoundUpNumi64(uint32_t bits) { return (bits + 63) >> 6; }
 
 /// Returns the rounded down to 64 multiple.
-static inline uint32_t RoundDownNumi64(uint32_t bits) {
-  return bits >> 6;
-}
+static inline uint32_t RoundDownNumi64(uint32_t bits) { return bits >> 6; }
 
 static inline int64_t RoundUpToMultipleOf64(int64_t num) {
   // TODO(wesm): is this definitely needed?
@@ -242,7 +220,9 @@ static inline int64_t RoundUpToMultipleOf64(int64_t num) {
   constexpr int64_t force_carry_addend = round_to - 1;
   constexpr int64_t truncate_bitmask = ~(round_to - 1);
   constexpr int64_t max_roundable_num = std::numeric_limits<int64_t>::max() - round_to;
-  if (num <= max_roundable_num) { return (num + force_carry_addend) & truncate_bitmask; }
+  if (num <= max_roundable_num) {
+    return (num + force_carry_addend) & truncate_bitmask;
+  }
   // handle overflow case.  This should result in a malloc error upstream
   return num;
 }
@@ -252,8 +232,7 @@ static inline int64_t RoundUpToMultipleOf64(int64_t num) {
 /// might be a much faster way to implement this.
 static inline int PopcountNoHw(uint64_t x) {
   int count = 0;
-  for (; x != 0; ++count)
-    x &= x - 1;
+  for (; x != 0; ++count) x &= x - 1;
   return count;
 }
 
@@ -297,21 +276,16 @@ static inline int Log2(uint64_t x) {
   // (floor(log2(n)) = MSB(n) (0-indexed))
   --x;
   int result = 1;
-  while (x >>= 1)
-    ++result;
+  while (x >>= 1) ++result;
   return result;
 }
 
 /// Swaps the byte order (i.e. endianess)
-static inline int64_t ByteSwap(int64_t value) {
-  return ARROW_BYTE_SWAP64(value);
-}
+static inline int64_t ByteSwap(int64_t value) { return ARROW_BYTE_SWAP64(value); }
 static inline uint64_t ByteSwap(uint64_t value) {
   return static_cast<uint64_t>(ARROW_BYTE_SWAP64(value));
 }
-static inline int32_t ByteSwap(int32_t value) {
-  return ARROW_BYTE_SWAP32(value);
-}
+static inline int32_t ByteSwap(int32_t value) { return ARROW_BYTE_SWAP32(value); }
 static inline uint32_t ByteSwap(uint32_t value) {
   return static_cast<uint32_t>(ARROW_BYTE_SWAP32(value));
 }
@@ -352,84 +326,36 @@ static inline void ByteSwap(void* dst, const void* src, int len) {
 /// Converts to big endian format (if not already in big endian) from the
 /// machine's native endian format.
 #if __BYTE_ORDER == __LITTLE_ENDIAN
-static inline int64_t ToBigEndian(int64_t value) {
-  return ByteSwap(value);
-}
-static inline uint64_t ToBigEndian(uint64_t value) {
-  return ByteSwap(value);
-}
-static inline int32_t ToBigEndian(int32_t value) {
-  return ByteSwap(value);
-}
-static inline uint32_t ToBigEndian(uint32_t value) {
-  return ByteSwap(value);
-}
-static inline int16_t ToBigEndian(int16_t value) {
-  return ByteSwap(value);
-}
-static inline uint16_t ToBigEndian(uint16_t value) {
-  return ByteSwap(value);
-}
+static inline int64_t ToBigEndian(int64_t value) { return ByteSwap(value); }
+static inline uint64_t ToBigEndian(uint64_t value) { return ByteSwap(value); }
+static inline int32_t ToBigEndian(int32_t value) { return ByteSwap(value); }
+static inline uint32_t ToBigEndian(uint32_t value) { return ByteSwap(value); }
+static inline int16_t ToBigEndian(int16_t value) { return ByteSwap(value); }
+static inline uint16_t ToBigEndian(uint16_t value) { return ByteSwap(value); }
 #else
-static inline int64_t ToBigEndian(int64_t val) {
-  return val;
-}
-static inline uint64_t ToBigEndian(uint64_t val) {
-  return val;
-}
-static inline int32_t ToBigEndian(int32_t val) {
-  return val;
-}
-static inline uint32_t ToBigEndian(uint32_t val) {
-  return val;
-}
-static inline int16_t ToBigEndian(int16_t val) {
-  return val;
-}
-static inline uint16_t ToBigEndian(uint16_t val) {
-  return val;
-}
+static inline int64_t ToBigEndian(int64_t val) { return val; }
+static inline uint64_t ToBigEndian(uint64_t val) { return val; }
+static inline int32_t ToBigEndian(int32_t val) { return val; }
+static inline uint32_t ToBigEndian(uint32_t val) { return val; }
+static inline int16_t ToBigEndian(int16_t val) { return val; }
+static inline uint16_t ToBigEndian(uint16_t val) { return val; }
 #endif
 
 /// Converts from big endian format to the machine's native endian format.
 #if __BYTE_ORDER == __LITTLE_ENDIAN
-static inline int64_t FromBigEndian(int64_t value) {
-  return ByteSwap(value);
-}
-static inline uint64_t FromBigEndian(uint64_t value) {
-  return ByteSwap(value);
-}
-static inline int32_t FromBigEndian(int32_t value) {
-  return ByteSwap(value);
-}
-static inline uint32_t FromBigEndian(uint32_t value) {
-  return ByteSwap(value);
-}
-static inline int16_t FromBigEndian(int16_t value) {
-  return ByteSwap(value);
-}
-static inline uint16_t FromBigEndian(uint16_t value) {
-  return ByteSwap(value);
-}
+static inline int64_t FromBigEndian(int64_t value) { return ByteSwap(value); }
+static inline uint64_t FromBigEndian(uint64_t value) { return ByteSwap(value); }
+static inline int32_t FromBigEndian(int32_t value) { return ByteSwap(value); }
+static inline uint32_t FromBigEndian(uint32_t value) { return ByteSwap(value); }
+static inline int16_t FromBigEndian(int16_t value) { return ByteSwap(value); }
+static inline uint16_t FromBigEndian(uint16_t value) { return ByteSwap(value); }
 #else
-static inline int64_t FromBigEndian(int64_t val) {
-  return val;
-}
-static inline uint64_t FromBigEndian(uint64_t val) {
-  return val;
-}
-static inline int32_t FromBigEndian(int32_t val) {
-  return val;
-}
-static inline uint32_t FromBigEndian(uint32_t val) {
-  return val;
-}
-static inline int16_t FromBigEndian(int16_t val) {
-  return val;
-}
-static inline uint16_t FromBigEndian(uint16_t val) {
-  return val;
-}
+static inline int64_t FromBigEndian(int64_t val) { return val; }
+static inline uint64_t FromBigEndian(uint64_t val) { return val; }
+static inline int32_t FromBigEndian(int32_t val) { return val; }
+static inline uint32_t FromBigEndian(uint32_t val) { return val; }
+static inline int16_t FromBigEndian(int16_t val) { return val; }
+static inline uint16_t FromBigEndian(uint16_t val) { return val; }
 #endif
 
 // Logical right shift for signed integer types
@@ -449,8 +375,8 @@ ARROW_EXPORT Status BytesToBits(const std::vector<uint8_t>&, std::shared_ptr<Buf
 // ----------------------------------------------------------------------
 // Bitmap utilities
 
-Status ARROW_EXPORT GetEmptyBitmap(
-    MemoryPool* pool, int64_t length, std::shared_ptr<MutableBuffer>* result);
+Status ARROW_EXPORT GetEmptyBitmap(MemoryPool* pool, int64_t length,
+                                   std::shared_ptr<MutableBuffer>* result);
 
 /// Copy a bit range of an existing bitmap
 ///
@@ -462,7 +388,7 @@ Status ARROW_EXPORT GetEmptyBitmap(
 ///
 /// \return Status message
 Status ARROW_EXPORT CopyBitmap(MemoryPool* pool, const uint8_t* bitmap, int64_t offset,
-    int64_t length, std::shared_ptr<Buffer>* out);
+                               int64_t length, std::shared_ptr<Buffer>* out);
 
 /// Compute the number of 1's in the given data array
 ///
@@ -471,11 +397,12 @@ Status ARROW_EXPORT CopyBitmap(MemoryPool* pool, const uint8_t* bitmap, int64_t
 /// \param[in] length the number of bits to inspect in the bitmap relative to the offset
 ///
 /// \return The number of set (1) bits in the range
-int64_t ARROW_EXPORT CountSetBits(
-    const uint8_t* data, int64_t bit_offset, int64_t length);
+int64_t ARROW_EXPORT CountSetBits(const uint8_t* data, int64_t bit_offset,
+                                  int64_t length);
 
 bool ARROW_EXPORT BitmapEquals(const uint8_t* left, int64_t left_offset,
-    const uint8_t* right, int64_t right_offset, int64_t bit_length);
+                               const uint8_t* right, int64_t right_offset,
+                               int64_t bit_length);
 }  // namespace arrow
 
 #endif  // ARROW_UTIL_BIT_UTIL_H

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/bpacking.h
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/bpacking.h b/cpp/src/arrow/util/bpacking.h
index fce5f55..4d25de0 100644
--- a/cpp/src/arrow/util/bpacking.h
+++ b/cpp/src/arrow/util/bpacking.h
@@ -3199,136 +3199,103 @@ inline int unpack32(const uint32_t* in, uint32_t* out, int batch_size, int num_b
 
   switch (num_bits) {
     case 0:
-      for (int i = 0; i < num_loops; ++i)
-        in = nullunpacker32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = nullunpacker32(in, out + i * 32);
       break;
     case 1:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack1_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack1_32(in, out + i * 32);
       break;
     case 2:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack2_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack2_32(in, out + i * 32);
       break;
     case 3:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack3_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack3_32(in, out + i * 32);
       break;
     case 4:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack4_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack4_32(in, out + i * 32);
       break;
     case 5:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack5_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack5_32(in, out + i * 32);
       break;
     case 6:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack6_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack6_32(in, out + i * 32);
       break;
     case 7:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack7_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack7_32(in, out + i * 32);
       break;
     case 8:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack8_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack8_32(in, out + i * 32);
       break;
     case 9:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack9_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack9_32(in, out + i * 32);
       break;
     case 10:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack10_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack10_32(in, out + i * 32);
       break;
     case 11:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack11_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack11_32(in, out + i * 32);
       break;
     case 12:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack12_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack12_32(in, out + i * 32);
       break;
     case 13:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack13_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack13_32(in, out + i * 32);
       break;
     case 14:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack14_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack14_32(in, out + i * 32);
       break;
     case 15:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack15_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack15_32(in, out + i * 32);
       break;
     case 16:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack16_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack16_32(in, out + i * 32);
       break;
     case 17:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack17_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack17_32(in, out + i * 32);
       break;
     case 18:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack18_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack18_32(in, out + i * 32);
       break;
     case 19:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack19_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack19_32(in, out + i * 32);
       break;
     case 20:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack20_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack20_32(in, out + i * 32);
       break;
     case 21:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack21_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack21_32(in, out + i * 32);
       break;
     case 22:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack22_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack22_32(in, out + i * 32);
       break;
     case 23:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack23_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack23_32(in, out + i * 32);
       break;
     case 24:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack24_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack24_32(in, out + i * 32);
       break;
     case 25:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack25_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack25_32(in, out + i * 32);
       break;
     case 26:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack26_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack26_32(in, out + i * 32);
       break;
     case 27:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack27_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack27_32(in, out + i * 32);
       break;
     case 28:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack28_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack28_32(in, out + i * 32);
       break;
     case 29:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack29_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack29_32(in, out + i * 32);
       break;
     case 30:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack30_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack30_32(in, out + i * 32);
       break;
     case 31:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack31_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack31_32(in, out + i * 32);
       break;
     case 32:
-      for (int i = 0; i < num_loops; ++i)
-        in = unpack32_32(in, out + i * 32);
+      for (int i = 0; i < num_loops; ++i) in = unpack32_32(in, out + i * 32);
       break;
     default:
       DCHECK(false) << "Unsupported num_bits";

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/compression-test.cc
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/compression-test.cc b/cpp/src/arrow/util/compression-test.cc
index f7739fc..64896dd 100644
--- a/cpp/src/arrow/util/compression-test.cc
+++ b/cpp/src/arrow/util/compression-test.cc
@@ -15,8 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#include <cstdint>
 #include <gtest/gtest.h>
+#include <cstdint>
 #include <string>
 #include <vector>
 
@@ -43,25 +43,25 @@ void CheckCodecRoundtrip(const vector<uint8_t>& data) {
 
   // compress with c1
   int64_t actual_size;
-  ASSERT_OK(c1->Compress(
-      data.size(), &data[0], max_compressed_len, &compressed[0], &actual_size));
+  ASSERT_OK(c1->Compress(data.size(), &data[0], max_compressed_len, &compressed[0],
+                         &actual_size));
   compressed.resize(actual_size);
 
   // decompress with c2
-  ASSERT_OK(c2->Decompress(
-      compressed.size(), &compressed[0], decompressed.size(), &decompressed[0]));
+  ASSERT_OK(c2->Decompress(compressed.size(), &compressed[0], decompressed.size(),
+                           &decompressed[0]));
 
   ASSERT_EQ(data, decompressed);
 
   // compress with c2
   int64_t actual_size2;
-  ASSERT_OK(c2->Compress(
-      data.size(), &data[0], max_compressed_len, &compressed[0], &actual_size2));
+  ASSERT_OK(c2->Compress(data.size(), &data[0], max_compressed_len, &compressed[0],
+                         &actual_size2));
   ASSERT_EQ(actual_size2, actual_size);
 
   // decompress with c1
-  ASSERT_OK(c1->Decompress(
-      compressed.size(), &compressed[0], decompressed.size(), &decompressed[0]));
+  ASSERT_OK(c1->Decompress(compressed.size(), &compressed[0], decompressed.size(),
+                           &decompressed[0]));
 
   ASSERT_EQ(data, decompressed);
 }
@@ -76,24 +76,14 @@ void CheckCodec() {
   }
 }
 
-TEST(TestCompressors, Snappy) {
-  CheckCodec<Compression::SNAPPY>();
-}
+TEST(TestCompressors, Snappy) { CheckCodec<Compression::SNAPPY>(); }
 
-TEST(TestCompressors, Brotli) {
-  CheckCodec<Compression::BROTLI>();
-}
+TEST(TestCompressors, Brotli) { CheckCodec<Compression::BROTLI>(); }
 
-TEST(TestCompressors, GZip) {
-  CheckCodec<Compression::GZIP>();
-}
+TEST(TestCompressors, GZip) { CheckCodec<Compression::GZIP>(); }
 
-TEST(TestCompressors, ZSTD) {
-  CheckCodec<Compression::ZSTD>();
-}
+TEST(TestCompressors, ZSTD) { CheckCodec<Compression::ZSTD>(); }
 
-TEST(TestCompressors, Lz4) {
-  CheckCodec<Compression::LZ4>();
-}
+TEST(TestCompressors, Lz4) { CheckCodec<Compression::LZ4>(); }
 
 }  // namespace arrow

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/compression.h
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/compression.h b/cpp/src/arrow/util/compression.h
index 19c6117..ae187a7 100644
--- a/cpp/src/arrow/util/compression.h
+++ b/cpp/src/arrow/util/compression.h
@@ -37,10 +37,11 @@ class ARROW_EXPORT Codec {
   static Status Create(Compression::type codec, std::unique_ptr<Codec>* out);
 
   virtual Status Decompress(int64_t input_len, const uint8_t* input, int64_t output_len,
-      uint8_t* output_buffer) = 0;
+                            uint8_t* output_buffer) = 0;
 
   virtual Status Compress(int64_t input_len, const uint8_t* input,
-      int64_t output_buffer_len, uint8_t* output_buffer, int64_t* output_length) = 0;
+                          int64_t output_buffer_len, uint8_t* output_buffer,
+                          int64_t* output_length) = 0;
 
   virtual int64_t MaxCompressedLen(int64_t input_len, const uint8_t* input) = 0;
 

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/compression_brotli.cc
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/compression_brotli.cc b/cpp/src/arrow/util/compression_brotli.cc
index c03573b..e463908 100644
--- a/cpp/src/arrow/util/compression_brotli.cc
+++ b/cpp/src/arrow/util/compression_brotli.cc
@@ -33,8 +33,8 @@ namespace arrow {
 // ----------------------------------------------------------------------
 // Brotli implementation
 
-Status BrotliCodec::Decompress(
-    int64_t input_len, const uint8_t* input, int64_t output_len, uint8_t* output_buffer) {
+Status BrotliCodec::Decompress(int64_t input_len, const uint8_t* input,
+                               int64_t output_len, uint8_t* output_buffer) {
   size_t output_size = output_len;
   if (BrotliDecoderDecompress(input_len, input, &output_size, output_buffer) !=
       BROTLI_DECODER_RESULT_SUCCESS) {
@@ -48,12 +48,13 @@ int64_t BrotliCodec::MaxCompressedLen(int64_t input_len, const uint8_t* input) {
 }
 
 Status BrotliCodec::Compress(int64_t input_len, const uint8_t* input,
-    int64_t output_buffer_len, uint8_t* output_buffer, int64_t* output_length) {
+                             int64_t output_buffer_len, uint8_t* output_buffer,
+                             int64_t* output_length) {
   size_t output_len = output_buffer_len;
   // TODO: Make quality configurable. We use 8 as a default as it is the best
   //       trade-off for Parquet workload
   if (BrotliEncoderCompress(8, BROTLI_DEFAULT_WINDOW, BROTLI_DEFAULT_MODE, input_len,
-          input, &output_len, output_buffer) == BROTLI_FALSE) {
+                            input, &output_len, output_buffer) == BROTLI_FALSE) {
     return Status::IOError("Brotli compression failure.");
   }
   *output_length = output_len;

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/compression_brotli.h
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/compression_brotli.h b/cpp/src/arrow/util/compression_brotli.h
index 08bd337..9e92cb1 100644
--- a/cpp/src/arrow/util/compression_brotli.h
+++ b/cpp/src/arrow/util/compression_brotli.h
@@ -30,10 +30,10 @@ namespace arrow {
 class ARROW_EXPORT BrotliCodec : public Codec {
  public:
   Status Decompress(int64_t input_len, const uint8_t* input, int64_t output_len,
-      uint8_t* output_buffer) override;
+                    uint8_t* output_buffer) override;
 
   Status Compress(int64_t input_len, const uint8_t* input, int64_t output_buffer_len,
-      uint8_t* output_buffer, int64_t* output_length) override;
+                  uint8_t* output_buffer, int64_t* output_length) override;
 
   int64_t MaxCompressedLen(int64_t input_len, const uint8_t* input) override;
 

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/compression_lz4.cc
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/compression_lz4.cc b/cpp/src/arrow/util/compression_lz4.cc
index 65eaa08..295e9a4 100644
--- a/cpp/src/arrow/util/compression_lz4.cc
+++ b/cpp/src/arrow/util/compression_lz4.cc
@@ -32,12 +32,14 @@ namespace arrow {
 // ----------------------------------------------------------------------
 // Lz4 implementation
 
-Status Lz4Codec::Decompress(
-    int64_t input_len, const uint8_t* input, int64_t output_len, uint8_t* output_buffer) {
-  int64_t decompressed_size = LZ4_decompress_safe(reinterpret_cast<const char*>(input),
-      reinterpret_cast<char*>(output_buffer), static_cast<int>(input_len),
-      static_cast<int>(output_len));
-  if (decompressed_size < 1) { return Status::IOError("Corrupt Lz4 compressed data."); }
+Status Lz4Codec::Decompress(int64_t input_len, const uint8_t* input, int64_t output_len,
+                            uint8_t* output_buffer) {
+  int64_t decompressed_size = LZ4_decompress_safe(
+      reinterpret_cast<const char*>(input), reinterpret_cast<char*>(output_buffer),
+      static_cast<int>(input_len), static_cast<int>(output_len));
+  if (decompressed_size < 1) {
+    return Status::IOError("Corrupt Lz4 compressed data.");
+  }
   return Status::OK();
 }
 
@@ -46,11 +48,14 @@ int64_t Lz4Codec::MaxCompressedLen(int64_t input_len, const uint8_t* input) {
 }
 
 Status Lz4Codec::Compress(int64_t input_len, const uint8_t* input,
-    int64_t output_buffer_len, uint8_t* output_buffer, int64_t* output_length) {
-  *output_length = LZ4_compress_default(reinterpret_cast<const char*>(input),
-      reinterpret_cast<char*>(output_buffer), static_cast<int>(input_len),
-      static_cast<int>(output_buffer_len));
-  if (*output_length < 1) { return Status::IOError("Lz4 compression failure."); }
+                          int64_t output_buffer_len, uint8_t* output_buffer,
+                          int64_t* output_length) {
+  *output_length = LZ4_compress_default(
+      reinterpret_cast<const char*>(input), reinterpret_cast<char*>(output_buffer),
+      static_cast<int>(input_len), static_cast<int>(output_buffer_len));
+  if (*output_length < 1) {
+    return Status::IOError("Lz4 compression failure.");
+  }
   return Status::OK();
 }
 

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/compression_lz4.h
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/compression_lz4.h b/cpp/src/arrow/util/compression_lz4.h
index 9668fec..0af2289 100644
--- a/cpp/src/arrow/util/compression_lz4.h
+++ b/cpp/src/arrow/util/compression_lz4.h
@@ -30,10 +30,10 @@ namespace arrow {
 class ARROW_EXPORT Lz4Codec : public Codec {
  public:
   Status Decompress(int64_t input_len, const uint8_t* input, int64_t output_len,
-      uint8_t* output_buffer) override;
+                    uint8_t* output_buffer) override;
 
   Status Compress(int64_t input_len, const uint8_t* input, int64_t output_buffer_len,
-      uint8_t* output_buffer, int64_t* output_length) override;
+                  uint8_t* output_buffer, int64_t* output_length) override;
 
   int64_t MaxCompressedLen(int64_t input_len, const uint8_t* input) override;
 

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/compression_snappy.cc
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/compression_snappy.cc b/cpp/src/arrow/util/compression_snappy.cc
index db2b673..947ffe5 100644
--- a/cpp/src/arrow/util/compression_snappy.cc
+++ b/cpp/src/arrow/util/compression_snappy.cc
@@ -37,10 +37,11 @@ namespace arrow {
 // ----------------------------------------------------------------------
 // Snappy implementation
 
-Status SnappyCodec::Decompress(
-    int64_t input_len, const uint8_t* input, int64_t output_len, uint8_t* output_buffer) {
+Status SnappyCodec::Decompress(int64_t input_len, const uint8_t* input,
+                               int64_t output_len, uint8_t* output_buffer) {
   if (!snappy::RawUncompress(reinterpret_cast<const char*>(input),
-          static_cast<size_t>(input_len), reinterpret_cast<char*>(output_buffer))) {
+                             static_cast<size_t>(input_len),
+                             reinterpret_cast<char*>(output_buffer))) {
     return Status::IOError("Corrupt snappy compressed data.");
   }
   return Status::OK();
@@ -51,11 +52,12 @@ int64_t SnappyCodec::MaxCompressedLen(int64_t input_len, const uint8_t* input) {
 }
 
 Status SnappyCodec::Compress(int64_t input_len, const uint8_t* input,
-    int64_t output_buffer_len, uint8_t* output_buffer, int64_t* output_length) {
+                             int64_t output_buffer_len, uint8_t* output_buffer,
+                             int64_t* output_length) {
   size_t output_len;
   snappy::RawCompress(reinterpret_cast<const char*>(input),
-      static_cast<size_t>(input_len), reinterpret_cast<char*>(output_buffer),
-      &output_len);
+                      static_cast<size_t>(input_len),
+                      reinterpret_cast<char*>(output_buffer), &output_len);
   *output_length = static_cast<int64_t>(output_len);
   return Status::OK();
 }

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/compression_snappy.h
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/compression_snappy.h b/cpp/src/arrow/util/compression_snappy.h
index 25281e1..5cc10c4 100644
--- a/cpp/src/arrow/util/compression_snappy.h
+++ b/cpp/src/arrow/util/compression_snappy.h
@@ -29,10 +29,10 @@ namespace arrow {
 class ARROW_EXPORT SnappyCodec : public Codec {
  public:
   Status Decompress(int64_t input_len, const uint8_t* input, int64_t output_len,
-      uint8_t* output_buffer) override;
+                    uint8_t* output_buffer) override;
 
   Status Compress(int64_t input_len, const uint8_t* input, int64_t output_buffer_len,
-      uint8_t* output_buffer, int64_t* output_length) override;
+                  uint8_t* output_buffer, int64_t* output_length) override;
 
   int64_t MaxCompressedLen(int64_t input_len, const uint8_t* input) override;
 

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/compression_zlib.cc
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/compression_zlib.cc b/cpp/src/arrow/util/compression_zlib.cc
index 3ff33b8..ae6627e 100644
--- a/cpp/src/arrow/util/compression_zlib.cc
+++ b/cpp/src/arrow/util/compression_zlib.cc
@@ -69,7 +69,7 @@ class GZipCodec::GZipCodecImpl {
       window_bits += GZIP_CODEC;
     }
     if ((ret = deflateInit2(&stream_, Z_DEFAULT_COMPRESSION, Z_DEFLATED, window_bits, 9,
-             Z_DEFAULT_STRATEGY)) != Z_OK) {
+                            Z_DEFAULT_STRATEGY)) != Z_OK) {
       std::stringstream ss;
       ss << "zlib deflateInit failed: " << std::string(stream_.msg);
       return Status::IOError(ss.str());
@@ -79,7 +79,9 @@ class GZipCodec::GZipCodecImpl {
   }
 
   void EndCompressor() {
-    if (compressor_initialized_) { (void)deflateEnd(&stream_); }
+    if (compressor_initialized_) {
+      (void)deflateEnd(&stream_);
+    }
     compressor_initialized_ = false;
   }
 
@@ -100,13 +102,17 @@ class GZipCodec::GZipCodecImpl {
   }
 
   void EndDecompressor() {
-    if (decompressor_initialized_) { (void)inflateEnd(&stream_); }
+    if (decompressor_initialized_) {
+      (void)inflateEnd(&stream_);
+    }
     decompressor_initialized_ = false;
   }
 
   Status Decompress(int64_t input_length, const uint8_t* input, int64_t output_length,
-      uint8_t* output) {
-    if (!decompressor_initialized_) { RETURN_NOT_OK(InitDecompressor()); }
+                    uint8_t* output) {
+    if (!decompressor_initialized_) {
+      RETURN_NOT_OK(InitDecompressor());
+    }
     if (output_length == 0) {
       // The zlib library does not allow *output to be NULL, even when output_length
       // is 0 (inflate() will return Z_STREAM_ERROR). We don't consider this an
@@ -168,8 +174,10 @@ class GZipCodec::GZipCodecImpl {
   }
 
   Status Compress(int64_t input_length, const uint8_t* input, int64_t output_buffer_len,
-      uint8_t* output, int64_t* output_length) {
-    if (!compressor_initialized_) { RETURN_NOT_OK(InitCompressor()); }
+                  uint8_t* output, int64_t* output_length) {
+    if (!compressor_initialized_) {
+      RETURN_NOT_OK(InitCompressor());
+    }
     stream_.next_in = const_cast<Bytef*>(reinterpret_cast<const Bytef*>(input));
     stream_.avail_in = static_cast<uInt>(input_length);
     stream_.next_out = reinterpret_cast<Bytef*>(output);
@@ -218,14 +226,12 @@ class GZipCodec::GZipCodecImpl {
   bool decompressor_initialized_;
 };
 
-GZipCodec::GZipCodec(Format format) {
-  impl_.reset(new GZipCodecImpl(format));
-}
+GZipCodec::GZipCodec(Format format) { impl_.reset(new GZipCodecImpl(format)); }
 
 GZipCodec::~GZipCodec() {}
 
 Status GZipCodec::Decompress(int64_t input_length, const uint8_t* input,
-    int64_t output_buffer_len, uint8_t* output) {
+                             int64_t output_buffer_len, uint8_t* output) {
   return impl_->Decompress(input_length, input, output_buffer_len, output);
 }
 
@@ -234,12 +240,11 @@ int64_t GZipCodec::MaxCompressedLen(int64_t input_length, const uint8_t* input)
 }
 
 Status GZipCodec::Compress(int64_t input_length, const uint8_t* input,
-    int64_t output_buffer_len, uint8_t* output, int64_t* output_length) {
+                           int64_t output_buffer_len, uint8_t* output,
+                           int64_t* output_length) {
   return impl_->Compress(input_length, input, output_buffer_len, output, output_length);
 }
 
-const char* GZipCodec::name() const {
-  return "gzip";
-}
+const char* GZipCodec::name() const { return "gzip"; }
 
 }  // namespace arrow

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/compression_zlib.h
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/compression_zlib.h b/cpp/src/arrow/util/compression_zlib.h
index 517a061..f55d668 100644
--- a/cpp/src/arrow/util/compression_zlib.h
+++ b/cpp/src/arrow/util/compression_zlib.h
@@ -40,10 +40,10 @@ class ARROW_EXPORT GZipCodec : public Codec {
   virtual ~GZipCodec();
 
   Status Decompress(int64_t input_len, const uint8_t* input, int64_t output_len,
-      uint8_t* output_buffer) override;
+                    uint8_t* output_buffer) override;
 
   Status Compress(int64_t input_len, const uint8_t* input, int64_t output_buffer_len,
-      uint8_t* output_buffer, int64_t* output_length) override;
+                  uint8_t* output_buffer, int64_t* output_length) override;
 
   int64_t MaxCompressedLen(int64_t input_len, const uint8_t* input) override;
 

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/compression_zstd.cc
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/compression_zstd.cc b/cpp/src/arrow/util/compression_zstd.cc
index 5511cb9..ac6e906 100644
--- a/cpp/src/arrow/util/compression_zstd.cc
+++ b/cpp/src/arrow/util/compression_zstd.cc
@@ -32,10 +32,11 @@ namespace arrow {
 // ----------------------------------------------------------------------
 // ZSTD implementation
 
-Status ZSTDCodec::Decompress(
-    int64_t input_len, const uint8_t* input, int64_t output_len, uint8_t* output_buffer) {
-  int64_t decompressed_size = ZSTD_decompress(output_buffer,
-      static_cast<size_t>(output_len), input, static_cast<size_t>(input_len));
+Status ZSTDCodec::Decompress(int64_t input_len, const uint8_t* input, int64_t output_len,
+                             uint8_t* output_buffer) {
+  int64_t decompressed_size =
+      ZSTD_decompress(output_buffer, static_cast<size_t>(output_len), input,
+                      static_cast<size_t>(input_len));
   if (decompressed_size != output_len) {
     return Status::IOError("Corrupt ZSTD compressed data.");
   }
@@ -47,9 +48,10 @@ int64_t ZSTDCodec::MaxCompressedLen(int64_t input_len, const uint8_t* input) {
 }
 
 Status ZSTDCodec::Compress(int64_t input_len, const uint8_t* input,
-    int64_t output_buffer_len, uint8_t* output_buffer, int64_t* output_length) {
+                           int64_t output_buffer_len, uint8_t* output_buffer,
+                           int64_t* output_length) {
   *output_length = ZSTD_compress(output_buffer, static_cast<size_t>(output_buffer_len),
-      input, static_cast<size_t>(input_len), 1);
+                                 input, static_cast<size_t>(input_len), 1);
   if (ZSTD_isError(*output_length)) {
     return Status::IOError("ZSTD compression failure.");
   }

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/compression_zstd.h
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/compression_zstd.h b/cpp/src/arrow/util/compression_zstd.h
index 2356d58..6e40e19 100644
--- a/cpp/src/arrow/util/compression_zstd.h
+++ b/cpp/src/arrow/util/compression_zstd.h
@@ -30,10 +30,10 @@ namespace arrow {
 class ARROW_EXPORT ZSTDCodec : public Codec {
  public:
   Status Decompress(int64_t input_len, const uint8_t* input, int64_t output_len,
-      uint8_t* output_buffer) override;
+                    uint8_t* output_buffer) override;
 
   Status Compress(int64_t input_len, const uint8_t* input, int64_t output_buffer_len,
-      uint8_t* output_buffer, int64_t* output_length) override;
+                  uint8_t* output_buffer, int64_t* output_length) override;
 
   int64_t MaxCompressedLen(int64_t input_len, const uint8_t* input) override;
 

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/cpu-info.cc
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/cpu-info.cc b/cpp/src/arrow/util/cpu-info.cc
index dcd6b40..b0667cb 100644
--- a/cpp/src/arrow/util/cpu-info.cc
+++ b/cpp/src/arrow/util/cpu-info.cc
@@ -66,7 +66,9 @@ static struct {
   string name;
   int64_t flag;
 } flag_mappings[] = {
-    {"ssse3", CpuInfo::SSSE3}, {"sse4_1", CpuInfo::SSE4_1}, {"sse4_2", CpuInfo::SSE4_2},
+    {"ssse3", CpuInfo::SSSE3},
+    {"sse4_1", CpuInfo::SSE4_1},
+    {"sse4_2", CpuInfo::SSE4_2},
     {"popcnt", CpuInfo::POPCNT},
 };
 static const int64_t num_flags = sizeof(flag_mappings) / sizeof(flag_mappings[0]);
@@ -78,14 +80,18 @@ static const int64_t num_flags = sizeof(flag_mappings) / sizeof(flag_mappings[0]
 int64_t ParseCPUFlags(const string& values) {
   int64_t flags = 0;
   for (int i = 0; i < num_flags; ++i) {
-    if (contains(values, flag_mappings[i].name)) { flags |= flag_mappings[i].flag; }
+    if (contains(values, flag_mappings[i].name)) {
+      flags |= flag_mappings[i].flag;
+    }
   }
   return flags;
 }
 
 #ifdef _WIN32
 bool RetrieveCacheSize(int64_t* cache_sizes) {
-  if (!cache_sizes) { return false; }
+  if (!cache_sizes) {
+    return false;
+  }
   PSYSTEM_LOGICAL_PROCESSOR_INFORMATION buffer = nullptr;
   PSYSTEM_LOGICAL_PROCESSOR_INFORMATION buffer_position = nullptr;
   DWORD buffer_size = 0;
@@ -95,7 +101,9 @@ bool RetrieveCacheSize(int64_t* cache_sizes) {
       (GetLogicalProcessorInformationFuncPointer)GetProcAddress(
           GetModuleHandle("kernel32"), "GetLogicalProcessorInformation");
 
-  if (!func_pointer) { return false; }
+  if (!func_pointer) {
+    return false;
+  }
 
   // Get buffer size
   if (func_pointer(buffer, &buffer_size) && GetLastError() != ERROR_INSUFFICIENT_BUFFER)
@@ -103,7 +111,9 @@ bool RetrieveCacheSize(int64_t* cache_sizes) {
 
   buffer = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION)malloc(buffer_size);
 
-  if (!buffer || !func_pointer(buffer, &buffer_size)) { return false; }
+  if (!buffer || !func_pointer(buffer, &buffer_size)) {
+    return false;
+  }
 
   buffer_position = buffer;
   while (offset + sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION) <= buffer_size) {
@@ -117,7 +127,9 @@ bool RetrieveCacheSize(int64_t* cache_sizes) {
     buffer_position++;
   }
 
-  if (buffer) { free(buffer); }
+  if (buffer) {
+    free(buffer);
+  }
   return true;
 }
 #endif
@@ -125,7 +137,9 @@ bool RetrieveCacheSize(int64_t* cache_sizes) {
 void CpuInfo::Init() {
   std::lock_guard<std::mutex> cpuinfo_lock(cpuinfo_mutex);
 
-  if (initialized()) { return; }
+  if (initialized()) {
+    return;
+  }
 
   string line;
   string name;
@@ -186,7 +200,9 @@ void CpuInfo::Init() {
     cache_sizes_[i] = data[i];
   }
 #elif _WIN32
-  if (!RetrieveCacheSize(cache_sizes_)) { SetDefaultCacheSize(); }
+  if (!RetrieveCacheSize(cache_sizes_)) {
+    SetDefaultCacheSize();
+  }
 #else
   SetDefaultCacheSize();
 #endif

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/decimal.cc
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/decimal.cc b/cpp/src/arrow/util/decimal.cc
index 72ede35..1a12e20 100644
--- a/cpp/src/arrow/util/decimal.cc
+++ b/cpp/src/arrow/util/decimal.cc
@@ -21,8 +21,8 @@ namespace arrow {
 namespace decimal {
 
 template <typename T>
-ARROW_EXPORT Status FromString(
-    const std::string& s, Decimal<T>* out, int* precision, int* scale) {
+ARROW_EXPORT Status FromString(const std::string& s, Decimal<T>* out, int* precision,
+                               int* scale) {
   // Implements this regex: "(\\+?|-?)((0*)(\\d*))(\\.(\\d+))?";
   if (s.empty()) {
     return Status::Invalid("Empty string cannot be converted to decimal");
@@ -34,7 +34,9 @@ ARROW_EXPORT Status FromString(
 
   char first_char = *charp;
   if (first_char == '+' || first_char == '-') {
-    if (first_char == '-') { sign = -1; }
+    if (first_char == '-') {
+      sign = -1;
+    }
     ++charp;
   }
 
@@ -55,7 +57,9 @@ ARROW_EXPORT Status FromString(
 
   // all zeros and no decimal point
   if (charp == end) {
-    if (out != nullptr) { out->value = static_cast<T>(0); }
+    if (out != nullptr) {
+      out->value = static_cast<T>(0);
+    }
 
     // Not sure what other libraries assign precision to for this case (this case of
     // a string consisting only of one or more zeros)
@@ -63,7 +67,9 @@ ARROW_EXPORT Status FromString(
       *precision = static_cast<int>(charp - numeric_string_start);
     }
 
-    if (scale != nullptr) { *scale = 0; }
+    if (scale != nullptr) {
+      *scale = 0;
+    }
 
     return Status::OK();
   }
@@ -127,22 +133,26 @@ ARROW_EXPORT Status FromString(
     *precision = static_cast<int>(whole_part.size() + fractional_part.size());
   }
 
-  if (scale != nullptr) { *scale = static_cast<int>(fractional_part.size()); }
+  if (scale != nullptr) {
+    *scale = static_cast<int>(fractional_part.size());
+  }
 
-  if (out != nullptr) { StringToInteger(whole_part, fractional_part, sign, &out->value); }
+  if (out != nullptr) {
+    StringToInteger(whole_part, fractional_part, sign, &out->value);
+  }
 
   return Status::OK();
 }
 
-template ARROW_EXPORT Status FromString(
-    const std::string& s, Decimal32* out, int* precision, int* scale);
-template ARROW_EXPORT Status FromString(
-    const std::string& s, Decimal64* out, int* precision, int* scale);
-template ARROW_EXPORT Status FromString(
-    const std::string& s, Decimal128* out, int* precision, int* scale);
+template ARROW_EXPORT Status FromString(const std::string& s, Decimal32* out,
+                                        int* precision, int* scale);
+template ARROW_EXPORT Status FromString(const std::string& s, Decimal64* out,
+                                        int* precision, int* scale);
+template ARROW_EXPORT Status FromString(const std::string& s, Decimal128* out,
+                                        int* precision, int* scale);
 
-void StringToInteger(
-    const std::string& whole, const std::string& fractional, int8_t sign, int32_t* out) {
+void StringToInteger(const std::string& whole, const std::string& fractional, int8_t sign,
+                     int32_t* out) {
   DCHECK(sign == -1 || sign == 1);
   DCHECK_NE(out, nullptr);
   DCHECK(!whole.empty() || !fractional.empty());
@@ -150,12 +160,14 @@ void StringToInteger(
     *out = std::stoi(whole, nullptr, 10) *
            static_cast<int32_t>(pow(10.0, static_cast<double>(fractional.size())));
   }
-  if (!fractional.empty()) { *out += std::stoi(fractional, nullptr, 10); }
+  if (!fractional.empty()) {
+    *out += std::stoi(fractional, nullptr, 10);
+  }
   *out *= sign;
 }
 
-void StringToInteger(
-    const std::string& whole, const std::string& fractional, int8_t sign, int64_t* out) {
+void StringToInteger(const std::string& whole, const std::string& fractional, int8_t sign,
+                     int64_t* out) {
   DCHECK(sign == -1 || sign == 1);
   DCHECK_NE(out, nullptr);
   DCHECK(!whole.empty() || !fractional.empty());
@@ -163,12 +175,14 @@ void StringToInteger(
     *out = static_cast<int64_t>(std::stoll(whole, nullptr, 10)) *
            static_cast<int64_t>(pow(10.0, static_cast<double>(fractional.size())));
   }
-  if (!fractional.empty()) { *out += std::stoll(fractional, nullptr, 10); }
+  if (!fractional.empty()) {
+    *out += std::stoll(fractional, nullptr, 10);
+  }
   *out *= sign;
 }
 
-void StringToInteger(
-    const std::string& whole, const std::string& fractional, int8_t sign, int128_t* out) {
+void StringToInteger(const std::string& whole, const std::string& fractional, int8_t sign,
+                     int128_t* out) {
   DCHECK(sign == -1 || sign == 1);
   DCHECK_NE(out, nullptr);
   DCHECK(!whole.empty() || !fractional.empty());
@@ -200,7 +214,9 @@ void FromBytes(const uint8_t* bytes, bool is_negative, Decimal128* decimal) {
   int128_t::backend_type& backend(decimal_value.backend());
   backend.resize(LIMBS_IN_INT128, LIMBS_IN_INT128);
   std::memcpy(backend.limbs(), bytes, BYTES_IN_128_BITS);
-  if (is_negative) { decimal->value = -decimal->value; }
+  if (is_negative) {
+    decimal->value = -decimal->value;
+  }
 }
 
 void ToBytes(const Decimal32& value, uint8_t** bytes) {

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/decimal.h
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/decimal.h b/cpp/src/arrow/util/decimal.h
index 0d84ba8..20142fa 100644
--- a/cpp/src/arrow/util/decimal.h
+++ b/cpp/src/arrow/util/decimal.h
@@ -37,16 +37,16 @@ using boost::multiprecision::int128_t;
 template <typename T>
 struct ARROW_EXPORT Decimal;
 
-ARROW_EXPORT void StringToInteger(
-    const std::string& whole, const std::string& fractional, int8_t sign, int32_t* out);
-ARROW_EXPORT void StringToInteger(
-    const std::string& whole, const std::string& fractional, int8_t sign, int64_t* out);
-ARROW_EXPORT void StringToInteger(
-    const std::string& whole, const std::string& fractional, int8_t sign, int128_t* out);
+ARROW_EXPORT void StringToInteger(const std::string& whole, const std::string& fractional,
+                                  int8_t sign, int32_t* out);
+ARROW_EXPORT void StringToInteger(const std::string& whole, const std::string& fractional,
+                                  int8_t sign, int64_t* out);
+ARROW_EXPORT void StringToInteger(const std::string& whole, const std::string& fractional,
+                                  int8_t sign, int128_t* out);
 
 template <typename T>
 ARROW_EXPORT Status FromString(const std::string& s, Decimal<T>* out,
-    int* precision = nullptr, int* scale = nullptr);
+                               int* precision = nullptr, int* scale = nullptr);
 
 template <typename T>
 struct ARROW_EXPORT Decimal {
@@ -85,8 +85,8 @@ struct ARROW_EXPORT DecimalPrecision<int128_t> {
 };
 
 template <typename T>
-ARROW_EXPORT std::string ToString(
-    const Decimal<T>& decimal_value, int precision, int scale) {
+ARROW_EXPORT std::string ToString(const Decimal<T>& decimal_value, int precision,
+                                  int scale) {
   T value = decimal_value.value;
 
   // Decimal values are sent to clients as strings so in the interest of
@@ -108,8 +108,8 @@ ARROW_EXPORT std::string ToString(
   if (scale > 0) {
     int remaining_scale = scale;
     do {
-      str[--last_char_idx] = static_cast<char>(
-          (remaining_value % 10) + static_cast<T>('0'));  // Ascii offset
+      str[--last_char_idx] = static_cast<char>((remaining_value % 10) +
+                                               static_cast<T>('0'));  // Ascii offset
       remaining_value /= 10;
     } while (--remaining_scale > 0);
     str[--last_char_idx] = '.';

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/key_value_metadata.cc
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/key_value_metadata.cc b/cpp/src/arrow/util/key_value_metadata.cc
index 8bddd5d..6877a6a 100644
--- a/cpp/src/arrow/util/key_value_metadata.cc
+++ b/cpp/src/arrow/util/key_value_metadata.cc
@@ -48,8 +48,8 @@ KeyValueMetadata::KeyValueMetadata(
     const std::unordered_map<std::string, std::string>& map)
     : keys_(UnorderedMapKeys(map)), values_(UnorderedMapValues(map)) {}
 
-KeyValueMetadata::KeyValueMetadata(
-    const std::vector<std::string>& keys, const std::vector<std::string>& values)
+KeyValueMetadata::KeyValueMetadata(const std::vector<std::string>& keys,
+                                   const std::vector<std::string>& values)
     : keys_(keys), values_(values) {
   DCHECK_EQ(keys.size(), values.size());
 }

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/key_value_metadata.h
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/key_value_metadata.h b/cpp/src/arrow/util/key_value_metadata.h
index a2a4623..3d60213 100644
--- a/cpp/src/arrow/util/key_value_metadata.h
+++ b/cpp/src/arrow/util/key_value_metadata.h
@@ -32,8 +32,8 @@ namespace arrow {
 class ARROW_EXPORT KeyValueMetadata {
  public:
   KeyValueMetadata();
-  KeyValueMetadata(
-      const std::vector<std::string>& keys, const std::vector<std::string>& values);
+  KeyValueMetadata(const std::vector<std::string>& keys,
+                   const std::vector<std::string>& values);
   explicit KeyValueMetadata(const std::unordered_map<std::string, std::string>& map);
   virtual ~KeyValueMetadata() = default;
 

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/logging.h
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/logging.h b/cpp/src/arrow/util/logging.h
index 0edaa9d..89e69f9 100644
--- a/cpp/src/arrow/util/logging.h
+++ b/cpp/src/arrow/util/logging.h
@@ -50,32 +50,25 @@ namespace arrow {
 
 #define DCHECK(condition)      \
   ARROW_IGNORE_EXPR(condition) \
-  while (false)                \
-  ::arrow::internal::NullLog()
+  while (false) ::arrow::internal::NullLog()
 #define DCHECK_EQ(val1, val2) \
   ARROW_IGNORE_EXPR(val1)     \
-  while (false)               \
-  ::arrow::internal::NullLog()
+  while (false) ::arrow::internal::NullLog()
 #define DCHECK_NE(val1, val2) \
   ARROW_IGNORE_EXPR(val1)     \
-  while (false)               \
-  ::arrow::internal::NullLog()
+  while (false) ::arrow::internal::NullLog()
 #define DCHECK_LE(val1, val2) \
   ARROW_IGNORE_EXPR(val1)     \
-  while (false)               \
-  ::arrow::internal::NullLog()
+  while (false) ::arrow::internal::NullLog()
 #define DCHECK_LT(val1, val2) \
   ARROW_IGNORE_EXPR(val1)     \
-  while (false)               \
-  ::arrow::internal::NullLog()
+  while (false) ::arrow::internal::NullLog()
 #define DCHECK_GE(val1, val2) \
   ARROW_IGNORE_EXPR(val1)     \
-  while (false)               \
-  ::arrow::internal::NullLog()
+  while (false) ::arrow::internal::NullLog()
 #define DCHECK_GT(val1, val2) \
   ARROW_IGNORE_EXPR(val1)     \
-  while (false)               \
-  ::arrow::internal::NullLog()
+  while (false) ::arrow::internal::NullLog()
 
 #else
 #define ARROW_DFATAL ARROW_FATAL
@@ -107,8 +100,12 @@ class CerrLog {
         has_logged_(false) {}
 
   virtual ~CerrLog() {
-    if (has_logged_) { std::cerr << std::endl; }
-    if (severity_ == ARROW_FATAL) { std::exit(1); }
+    if (has_logged_) {
+      std::cerr << std::endl;
+    }
+    if (severity_ == ARROW_FATAL) {
+      std::exit(1);
+    }
   }
 
   template <class T>
@@ -133,7 +130,9 @@ class FatalLog : public CerrLog {
       : CerrLog(ARROW_FATAL){}           // NOLINT
 
             [[noreturn]] ~FatalLog() {
-    if (has_logged_) { std::cerr << std::endl; }
+    if (has_logged_) {
+      std::cerr << std::endl;
+    }
     std::exit(1);
   }
 };

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/memory.h
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/memory.h b/cpp/src/arrow/util/memory.h
index c5c17ef..fce9e19 100644
--- a/cpp/src/arrow/util/memory.h
+++ b/cpp/src/arrow/util/memory.h
@@ -31,7 +31,7 @@ uint8_t* pointer_logical_and(const uint8_t* address, uintptr_t bits) {
 // A helper function for doing memcpy with multiple threads. This is required
 // to saturate the memory bandwidth of modern cpus.
 void parallel_memcopy(uint8_t* dst, const uint8_t* src, int64_t nbytes,
-    uintptr_t block_size, int num_threads) {
+                      uintptr_t block_size, int num_threads) {
   std::vector<std::thread> threadpool(num_threads);
   uint8_t* left = pointer_logical_and(src + block_size - 1, ~(block_size - 1));
   uint8_t* right = pointer_logical_and(src + nbytes, ~(block_size - 1));
@@ -52,15 +52,17 @@ void parallel_memcopy(uint8_t* dst, const uint8_t* src, int64_t nbytes,
 
   // Start all threads first and handle leftovers while threads run.
   for (int i = 0; i < num_threads; i++) {
-    threadpool[i] = std::thread(
-        memcpy, dst + prefix + i * chunk_size, left + i * chunk_size, chunk_size);
+    threadpool[i] = std::thread(memcpy, dst + prefix + i * chunk_size,
+                                left + i * chunk_size, chunk_size);
   }
 
   memcpy(dst, src, prefix);
   memcpy(dst + prefix + num_threads * chunk_size, right, suffix);
 
   for (auto& t : threadpool) {
-    if (t.joinable()) { t.join(); }
+    if (t.joinable()) {
+      t.join();
+    }
   }
 }
 

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/random.h
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/random.h b/cpp/src/arrow/util/random.h
index 31f2b06..ec48d5d 100644
--- a/cpp/src/arrow/util/random.h
+++ b/cpp/src/arrow/util/random.h
@@ -27,7 +27,9 @@ class Random {
  public:
   explicit Random(uint32_t s) : seed_(s & 0x7fffffffu) {
     // Avoid bad seeds.
-    if (seed_ == 0 || seed_ == random_internal::M) { seed_ = 1; }
+    if (seed_ == 0 || seed_ == random_internal::M) {
+      seed_ = 1;
+    }
   }
 
   // Next pseudo-random 32-bit unsigned integer.
@@ -48,7 +50,9 @@ class Random {
     // The first reduction may overflow by 1 bit, so we may need to
     // repeat.  mod == M is not possible; using > allows the faster
     // sign-bit-based test.
-    if (seed_ > random_internal::M) { seed_ -= random_internal::M; }
+    if (seed_ > random_internal::M) {
+      seed_ -= random_internal::M;
+    }
     return seed_;
   }
 
@@ -97,9 +101,9 @@ class Random {
   double Normal(double mean, double std_dev) {
     double uniform1 = (Next() + 1.0) / (random_internal::M + 1.0);
     double uniform2 = (Next() + 1.0) / (random_internal::M + 1.0);
-    return (
-        mean +
-        std_dev * sqrt(-2 * ::log(uniform1)) * cos(random_internal::kTwoPi * uniform2));
+    return (mean +
+            std_dev * sqrt(-2 * ::log(uniform1)) *
+                cos(random_internal::kTwoPi * uniform2));
   }
 
   // Return a random number between 0.0 and 1.0 inclusive.

http://git-wip-us.apache.org/repos/asf/arrow/blob/07b89bf3/cpp/src/arrow/util/rle-encoding-test.cc
----------------------------------------------------------------------
diff --git a/cpp/src/arrow/util/rle-encoding-test.cc b/cpp/src/arrow/util/rle-encoding-test.cc
index 7c9b33c..7549b87 100644
--- a/cpp/src/arrow/util/rle-encoding-test.cc
+++ b/cpp/src/arrow/util/rle-encoding-test.cc
@@ -178,7 +178,7 @@ TEST(BitArray, TestMixed) {
 // exactly 'expected_encoding'.
 // if expected_len is not -1, it will validate the encoded size is correct.
 void ValidateRle(const vector<int>& values, int bit_width, uint8_t* expected_encoding,
-    int expected_len) {
+                 int expected_len) {
   const int len = 64 * 1024;
   uint8_t buffer[len];
   EXPECT_LE(expected_len, len);
@@ -190,7 +190,9 @@ void ValidateRle(const vector<int>& values, int bit_width, uint8_t* expected_enc
   }
   int encoded_len = encoder.Flush();
 
-  if (expected_len != -1) { EXPECT_EQ(encoded_len, expected_len); }
+  if (expected_len != -1) {
+    EXPECT_EQ(encoded_len, expected_len);
+  }
   if (expected_encoding != NULL) {
     EXPECT_EQ(memcmp(buffer, expected_encoding, expected_len), 0);
   }
@@ -211,7 +213,7 @@ void ValidateRle(const vector<int>& values, int bit_width, uint8_t* expected_enc
     RleDecoder decoder(buffer, len, bit_width);
     vector<int> values_read(values.size());
     ASSERT_EQ(values.size(),
-        decoder.GetBatch(values_read.data(), static_cast<int>(values.size())));
+              decoder.GetBatch(values_read.data(), static_cast<int>(values.size())));
     EXPECT_EQ(values, values_read);
   }
 }
@@ -224,7 +226,9 @@ bool CheckRoundTrip(const vector<int>& values, int bit_width) {
   RleEncoder encoder(buffer, len, bit_width);
   for (size_t i = 0; i < values.size(); ++i) {
     bool result = encoder.Put(values[i]);
-    if (!result) { return false; }
+    if (!result) {
+      return false;
+    }
   }
   int encoded_len = encoder.Flush();
   int out = 0;
@@ -233,7 +237,9 @@ bool CheckRoundTrip(const vector<int>& values, int bit_width) {
     RleDecoder decoder(buffer, encoded_len, bit_width);
     for (size_t i = 0; i < values.size(); ++i) {
       EXPECT_TRUE(decoder.Get(&out));
-      if (values[i] != out) { return false; }
+      if (values[i] != out) {
+        return false;
+      }
     }
   }
 
@@ -245,7 +251,9 @@ bool CheckRoundTrip(const vector<int>& values, int bit_width) {
         decoder.GetBatch(values_read.data(), static_cast<int>(values.size()))) {
       return false;
     }
-    if (values != values_read) { return false; }
+    if (values != values_read) {
+      return false;
+    }
   }
 
   return true;
@@ -294,8 +302,8 @@ TEST(Rle, SpecificSequences) {
   ValidateRle(values, 1, expected_buffer, 1 + num_groups);
   for (int width = 2; width <= MAX_WIDTH; ++width) {
     int num_values = static_cast<int>(BitUtil::Ceil(100, 8)) * 8;
-    ValidateRle(
-        values, width, NULL, 1 + static_cast<int>(BitUtil::Ceil(width * num_values, 8)));
+    ValidateRle(values, width, NULL,
+                1 + static_cast<int>(BitUtil::Ceil(width * num_values, 8)));
   }
 }
 
@@ -352,8 +360,7 @@ TEST(Rle, BitWidthZeroLiteral) {
 // group but flush before finishing.
 TEST(BitRle, Flush) {
   vector<int> values;
-  for (int i = 0; i < 16; ++i)
-    values.push_back(1);
+  for (int i = 0; i < 16; ++i) values.push_back(1);
   values.push_back(0);
   ValidateRle(values, 1, NULL, -1);
   values.push_back(1);
@@ -385,7 +392,9 @@ TEST(BitRle, Random) {
 
     for (int i = 0; i < ngroups; ++i) {
       int group_size = dist(gen);
-      if (group_size > max_group_size) { group_size = 1; }
+      if (group_size > max_group_size) {
+        group_size = 1;
+      }
       for (int i = 0; i < group_size; ++i) {
         values.push_back(parity);
       }


Mime
View raw message