clang format 120 length

src/chunkers/includes/Buzhash.h

@@ -30,9 +30,10 @@ public:
     uint32_t feed(uint8_t in);
 
 private:
-    uint32_t cur = 0;            ///< Current hash value
-    const uint32_t blockSize;    ///< Hashing window size
-    std::deque<uint32_t> history;///< Bytes used to calculate current hash, used to compute the hash in a rolling fashion (to remove the oldest byte from the hash when blockSize is reached)
+    uint32_t cur = 0;        ///< Current hash value
+    const uint32_t blockSize;///< Hashing window size
+    std::deque<uint32_t>
+            history;///< Bytes used to calculate current hash, used to compute the hash in a rolling fashion (to remove the oldest byte from the hash when blockSize is reached)
 
     // Circular shift taken from: https://en.wikipedia.org/wiki/Circular_shift
     /// Shift \p value \p count bits to the right circularly

src/chunkers/includes/BuzhashChunker.h

@@ -18,7 +18,8 @@ public:
     /// \param minBytes Minimum amount of bytes in returned chunks
     /// \param mask     Amount of trailing zeroes in the rolling hash at which the file is cut (results in average chunk size of 2^mask bytes)
     /// \param window   Rolling hash window (how many of chunks last bytes are included in the hash, the default is recommended)
-    BuzhashChunker(std::streambuf *buf, unsigned long long minBytes, unsigned long long maxBytes, unsigned long long mask, uint32_t window = 4095);
+    BuzhashChunker(std::streambuf *buf, unsigned long long minBytes, unsigned long long maxBytes,
+                   unsigned long long mask, uint32_t window = 4095);
 
     /// \copydoc Chunker::getNext
     std::pair<std::string, std::vector<char>> getNext() override;

src/chunkers/srcs/Buzhash.cpp

@@ -6,9 +6,7 @@
 
 Buzhash::Buzhash(uint32_t blockSize) : blockSize(blockSize), history() {}
 
-uint32_t Buzhash::get() const {
-    return cur;
-}
+uint32_t Buzhash::get() const { return cur; }
 
 uint32_t Buzhash::feed(uint8_t in) {
     cur = rotr32(cur, 1);

src/chunkers/srcs/BuzhashChunker.cpp

@@ -7,7 +7,9 @@
 #include "Exception.h"
 #include "SHA.h"
 
-BuzhashChunker::BuzhashChunker(std::streambuf *buf, unsigned long long minBytes, unsigned long long maxBytes, unsigned long long mask, uint32_t window) : Chunker(buf, maxBytes), window(window), minBytes(minBytes), mask(mask), buzhash(window) {}
+BuzhashChunker::BuzhashChunker(std::streambuf *buf, unsigned long long minBytes, unsigned long long maxBytes,
+                               unsigned long long mask, uint32_t window)
+    : Chunker(buf, maxBytes), window(window), minBytes(minBytes), mask(mask), buzhash(window) {}
 
 std::pair<std::string, std::vector<char>> BuzhashChunker::getNext() {
     if (eof) throw Exception("Trying to read from a file that is finished!");
@@ -21,9 +23,7 @@ std::pair<std::string, std::vector<char>> BuzhashChunker::getNext() {
         return {SHA::calculate(rbuf), rbuf};
     }
 
-    for (auto c: rbuf) {
-        buzhash.feed(static_cast<uint8_t>(c));
-    }
+    for (auto c: rbuf) { buzhash.feed(static_cast<uint8_t>(c)); }
 
     // Continue reading the file until either the last mask bits are zero of we exceed the maxSize
     while (((buzhash.get() & (~0UL >> (sizeof(unsigned long long) * 8 - mask))) != 0) && rbuf.size() < maxBytes) {

src/chunkers/srcs/Chunker.cpp

@@ -8,44 +8,31 @@
 
 Chunker::Chunker(std::streambuf *buf, unsigned long long maxBytes) : buf(buf), maxBytes(maxBytes) {}
 
-bool Chunker::getEof() const {
-    return eof;
-}
+bool Chunker::getEof() const { return eof; }
 
 Chunker::~Chunker() = default;
 
-Chunker::ChunkerIterator Chunker::begin() {
-    return {this};
-}
+Chunker::ChunkerIterator Chunker::begin() { return {this}; }
 
-Chunker::ChunkerIterator Chunker::end() {
-    return {nullptr};
-}
+Chunker::ChunkerIterator Chunker::end() { return {nullptr}; }
 
 Chunker::ChunkerIterator &Chunker::ChunkerIterator::operator++() {
     if (pastEOF) throw Exception("Trying to increment pastEOF ChunkerIterator!");
-    if (source->getEof())
-        pastEOF = true;
+    if (source->getEof()) pastEOF = true;
     else
         buf = source->getNext();
     return *this;
 }
 
-bool Chunker::ChunkerIterator::operator!=(const Chunker::ChunkerIterator &rhs) const {
-    return pastEOF != rhs.pastEOF;
-}
+bool Chunker::ChunkerIterator::operator!=(const Chunker::ChunkerIterator &rhs) const { return pastEOF != rhs.pastEOF; }
 
 Chunker::ChunkerIterator::value_type Chunker::ChunkerIterator::operator*() const {
     if (pastEOF) throw Exception("Trying to dereference pastEOF ChunkerIterator!");
     return buf.value();
 }
 
-bool Chunker::ChunkerIterator::operator==(const Chunker::ChunkerIterator &rhs) const {
-    return pastEOF == rhs.pastEOF;
-}
+bool Chunker::ChunkerIterator::operator==(const Chunker::ChunkerIterator &rhs) const { return pastEOF == rhs.pastEOF; }
 
-Chunker::ChunkerIterator::ChunkerIterator(Chunker *source)
-    : source(source), pastEOF(source == nullptr) {
-    if (source)
-        operator++();
+Chunker::ChunkerIterator::ChunkerIterator(Chunker *source) : source(source), pastEOF(source == nullptr) {
+    if (source) operator++();
 }

src/chunkers/srcs/ChunkerFactory.cpp

@@ -12,7 +12,8 @@ std::unique_ptr<Chunker> ChunkerFactory::getChunker(const Config &config, std::s
     if (config.getStr("chunker") == "const") {
         return std::make_unique<ConstChunker>(buf, config.getInt("chunker-max") * 1024);
     } else if (config.getStr("chunker") == "buzhash") {
-        return std::make_unique<BuzhashChunker>(buf, config.getInt("chunker-min") * 1024, config.getInt("chunker-max") * 1024, config.getInt("chunker-mask"));
+        return std::make_unique<BuzhashChunker>(buf, config.getInt("chunker-min") * 1024,
+                                                config.getInt("chunker-max") * 1024, config.getInt("chunker-mask"));
     } else {
         throw Exception("Unknown chunker type!");
     }