chore: clang format following the current style

fntlnz · leodido · fntlnz · commit b2ef08fd3093 · 2019-07-03T09:07:00.000+02:00
Signed-off-by: Lorenzo Fontana &lt;lo@linux.com&gt;

Co-authored-by: Leonardo Di Donato &lt;leodidonato@gmail.com&gt;
diff --git a/.clang-format b/.clang-format
@@ -1,10 +1,16 @@
-# This coding convention's solely goal is to approximately match the current code style.
-# It MUST not be intended in any other way until a real and definitive coding convention is put in.
 ---
-BreakBeforeBraces: GNU
-ColumnLimit: 0
-IndentWidth: 4
 Language: Cpp
+BasedOnStyle: LLVM
+AccessModifierOffset: -8
+BreakBeforeBraces: Allman
+BreakConstructorInitializers: AfterColon
+ColumnLimit: 0
+ConstructorInitializerIndentWidth: 8
+ContinuationIndentWidth: 8
+DerivePointerAlignment: true
+IndentWidth: 8
+SortIncludes: false
+SpaceAfterTemplateKeyword: false
+SpaceBeforeCtorInitializerColon: false
 SpaceBeforeParens: Never
-Standard: Auto
-UseTab: Always
+UseTab: Always
diff --git a/tests/engine/test_token_bucket.cpp b/tests/engine/test_token_bucket.cpp
@@ -23,61 +23,61 @@ using namespace Catch::literals;
 
 TEST_CASE("token bucket default ctor", "[token_bucket]")
 {
-    auto tb = new token_bucket();
-
-    REQUIRE(tb->get_tokens() == 1);
-
-    SECTION("initialising with specific time, rate 2 tokens/sec")
-    {
-	auto max = 2.0;
-	uint64_t now = 1;
-	tb->init(1.0, max, now);
-	REQUIRE(tb->get_last_seen() == now);
-	REQUIRE(tb->get_tokens() == max);
-    }
+	auto tb = new token_bucket();
+
+	REQUIRE(tb->get_tokens() == 1);
+
+	SECTION("initialising with specific time, rate 2 tokens/sec")
+	{
+		auto max = 2.0;
+		uint64_t now = 1;
+		tb->init(1.0, max, now);
+		REQUIRE(tb->get_last_seen() == now);
+		REQUIRE(tb->get_tokens() == max);
+	}
 }
 
 TEST_CASE("token bucket ctor with custom timer", "[token_bucket]")
 {
-    auto t = []() -> uint64_t { return 22; };
-    auto tb = new token_bucket(t);
+	auto t = []() -> uint64_t { return 22; };
+	auto tb = new token_bucket(t);
 
-    REQUIRE(tb->get_tokens() == 1);
-    REQUIRE(tb->get_last_seen() == 22);
+	REQUIRE(tb->get_tokens() == 1);
+	REQUIRE(tb->get_last_seen() == 22);
 }
 
 TEST_CASE("token bucket with 2 tokens/sec rate, max 10 tokens", "[token_bucket]")
 {
-    auto tb = new token_bucket();
-    tb->init(2.0, 10, 1);
-
-    SECTION("claiming 5 tokens")
-    {
-	bool claimed = tb->claim(5, 1000000001);
-	REQUIRE(tb->get_last_seen() == 1000000001);
-	REQUIRE(tb->get_tokens() == 5.0_a);
-	REQUIRE(claimed);
+	auto tb = new token_bucket();
+	tb->init(2.0, 10, 1);
 
-	SECTION("claiming all the 7 remaining tokens")
+	SECTION("claiming 5 tokens")
 	{
-	    bool claimed = tb->claim(7, 2000000001);
-	    REQUIRE(tb->get_last_seen() == 2000000001);
-	    REQUIRE(tb->get_tokens() == 0.0_a);
-	    REQUIRE(claimed);
-
-	    SECTION("claiming 1 token more than the 2 available fails")
-	    {
-		bool claimed = tb->claim(3, 3000000001);
-		REQUIRE(tb->get_last_seen() == 3000000001);
-		REQUIRE(tb->get_tokens() == 2.0_a);
-		REQUIRE_FALSE(claimed);
-	    }
+		bool claimed = tb->claim(5, 1000000001);
+		REQUIRE(tb->get_last_seen() == 1000000001);
+		REQUIRE(tb->get_tokens() == 5.0_a);
+		REQUIRE(claimed);
+
+		SECTION("claiming all the 7 remaining tokens")
+		{
+			bool claimed = tb->claim(7, 2000000001);
+			REQUIRE(tb->get_last_seen() == 2000000001);
+			REQUIRE(tb->get_tokens() == 0.0_a);
+			REQUIRE(claimed);
+
+			SECTION("claiming 1 token more than the 2 available fails")
+			{
+				bool claimed = tb->claim(3, 3000000001);
+				REQUIRE(tb->get_last_seen() == 3000000001);
+				REQUIRE(tb->get_tokens() == 2.0_a);
+				REQUIRE_FALSE(claimed);
+			}
+		}
 	}
-    }
 }
 
 TEST_CASE("token bucket default initialization", "[token_bucket]")
 {
-    token_bucket tb;
-    REQUIRE(tb.get_tokens() == 1);
+	token_bucket tb;
+	REQUIRE(tb.get_tokens() == 1);
 }
diff --git a/userspace/engine/token_bucket.cpp b/userspace/engine/token_bucket.cpp
@@ -24,14 +24,15 @@ limitations under the License.
 #include "token_bucket.h"
 #include "utils.h"
 
-token_bucket::token_bucket() : token_bucket(sinsp_utils::get_current_time_ns)
+token_bucket::token_bucket():
+	token_bucket(sinsp_utils::get_current_time_ns)
 {
 }
 
 token_bucket::token_bucket(std::function<uint64_t()> timer)
 {
-    m_timer = timer;
-    init(1, 1);
+	m_timer = timer;
+	init(1, 1);
 }
 
 token_bucket::~token_bucket()
@@ -40,51 +41,51 @@ token_bucket::~token_bucket()
 
 void token_bucket::init(double rate, double max_tokens, uint64_t now)
 {
-    m_rate = rate;
-    m_max_tokens = max_tokens;
-    m_tokens = max_tokens;
-    m_last_seen = now == 0 ? m_timer() : now;
+	m_rate = rate;
+	m_max_tokens = max_tokens;
+	m_tokens = max_tokens;
+	m_last_seen = now == 0 ? m_timer() : now;
 }
 
 bool token_bucket::claim()
 {
-    return claim(1, m_timer());
+	return claim(1, m_timer());
 }
 
 bool token_bucket::claim(double tokens, uint64_t now)
 {
-    double tokens_gained = m_rate * ((now - m_last_seen) / (1000000000.0));
-    m_last_seen = now;
+	double tokens_gained = m_rate * ((now - m_last_seen) / (1000000000.0));
+	m_last_seen = now;
 
-    m_tokens += tokens_gained;
+	m_tokens += tokens_gained;
 
-    //
-    // Cap at max_tokens
-    //
-    if(m_tokens > m_max_tokens)
+	//
+	// Cap at max_tokens
+	//
+	if(m_tokens > m_max_tokens)
 	{
-	    m_tokens = m_max_tokens;
+		m_tokens = m_max_tokens;
 	}
 
-    //
-    // If m_tokens is < tokens, can't claim.
-    //
-    if(m_tokens < tokens)
+	//
+	// If m_tokens is < tokens, can't claim.
+	//
+	if(m_tokens < tokens)
 	{
-	    return false;
+		return false;
 	}
 
-    m_tokens -= tokens;
+	m_tokens -= tokens;
 
-    return true;
+	return true;
 }
 
 double token_bucket::get_tokens()
 {
-    return m_tokens;
+	return m_tokens;
 }
 
 uint64_t token_bucket::get_last_seen()
 {
-    return m_last_seen;
+	return m_last_seen;
 }
diff --git a/userspace/engine/token_bucket.h b/userspace/engine/token_bucket.h
@@ -26,55 +26,55 @@ limitations under the License.
 // for limited bursting in the form of "banked" tokens.
 class token_bucket
 {
-  public:
-    token_bucket();
-    token_bucket(std::function<uint64_t()> timer);
-    virtual ~token_bucket();
-
-    //
-    // Initialize the token bucket and start accumulating tokens
-    //
-    void init(double rate, double max_tokens, uint64_t now = 0);
-
-    //
-    // Try to claim tokens tokens from the token bucket, using a
-    // timestamp of now. Returns true if the tokens could be
-    // claimed. Also updates internal metrics.
-    //
-    bool claim(double tokens, uint64_t now);
-
-    // Simpler version of claim that claims a single token and
-    // uses the current time for now
-    bool claim();
-
-    // Return the current number of tokens available
-    double get_tokens();
-
-    // Return the last time someone tried to claim a token.
-    uint64_t get_last_seen();
-
-  private:
-    std::function<uint64_t()> m_timer;
-
-    //
-    // The number of tokens generated per second.
-    //
-    double m_rate;
-
-    //
-    // The maximum number of tokens that can be banked for future
-    // claim()s.
-    //
-    double m_max_tokens;
-
-    //
-    // The current number of tokens
-    //
-    double m_tokens;
-
-    //
-    // The last time claim() was called (or the object was created).
-    // Nanoseconds since the epoch.
-    //
-    uint64_t m_last_seen;
+public:
+	token_bucket();
+	token_bucket(std::function<uint64_t()> timer);
+	virtual ~token_bucket();
+
+	//
+	// Initialize the token bucket and start accumulating tokens
+	//
+	void init(double rate, double max_tokens, uint64_t now = 0);
+
+	//
+	// Try to claim tokens tokens from the token bucket, using a
+	// timestamp of now. Returns true if the tokens could be
+	// claimed. Also updates internal metrics.
+	//
+	bool claim(double tokens, uint64_t now);
+
+	// Simpler version of claim that claims a single token and
+	// uses the current time for now
+	bool claim();
+
+	// Return the current number of tokens available
+	double get_tokens();
+
+	// Return the last time someone tried to claim a token.
+	uint64_t get_last_seen();
+
+private:
+	std::function<uint64_t()> m_timer;
+
+	//
+	// The number of tokens generated per second.
+	//
+	double m_rate;
+
+	//
+	// The maximum number of tokens that can be banked for future
+	// claim()s.
+	//
+	double m_max_tokens;
+
+	//
+	// The current number of tokens
+	//
+	double m_tokens;
+
+	//
+	// The last time claim() was called (or the object was created).
+	// Nanoseconds since the epoch.
+	//
+	uint64_t m_last_seen;
 };

Original file line number	Diff line number	Diff line change
`@@ -24,14 +24,15 @@ limitations under the License.`
`24`	`24`	`#include "token_bucket.h"`
`25`	`25`	`#include "utils.h"`
`26`	`26`
`27`		`-token_bucket::token_bucket() : token_bucket(sinsp_utils::get_current_time_ns)`
	`27`	`+token_bucket::token_bucket():`
	`28`	`+ token_bucket(sinsp_utils::get_current_time_ns)`
`28`	`29`	`{`
`29`	`30`	`}`
`30`	`31`
`31`	`32`	`token_bucket::token_bucket(std::function<uint64_t()> timer)`
`32`	`33`	`{`
`33`		`- m_timer = timer;`
`34`		`- init(1, 1);`
	`34`	`+ m_timer = timer;`
	`35`	`+ init(1, 1);`
`35`	`36`	`}`
`36`	`37`
`37`	`38`	`token_bucket::~token_bucket()`
`@@ -40,51 +41,51 @@ token_bucket::~token_bucket()`
`40`	`41`
`41`	`42`	`void token_bucket::init(double rate, double max_tokens, uint64_t now)`
`42`	`43`	`{`
`43`		`- m_rate = rate;`
`44`		`- m_max_tokens = max_tokens;`
`45`		`- m_tokens = max_tokens;`
`46`		`- m_last_seen = now == 0 ? m_timer() : now;`
	`44`	`+ m_rate = rate;`
	`45`	`+ m_max_tokens = max_tokens;`
	`46`	`+ m_tokens = max_tokens;`
	`47`	`+ m_last_seen = now == 0 ? m_timer() : now;`
`47`	`48`	`}`
`48`	`49`
`49`	`50`	`bool token_bucket::claim()`
`50`	`51`	`{`
`51`		`- return claim(1, m_timer());`
	`52`	`+ return claim(1, m_timer());`
`52`	`53`	`}`
`53`	`54`
`54`	`55`	`bool token_bucket::claim(double tokens, uint64_t now)`
`55`	`56`	`{`
`56`		`- double tokens_gained = m_rate * ((now - m_last_seen) / (1000000000.0));`
`57`		`- m_last_seen = now;`
	`57`	`+ double tokens_gained = m_rate * ((now - m_last_seen) / (1000000000.0));`
	`58`	`+ m_last_seen = now;`
`58`	`59`
`59`		`- m_tokens += tokens_gained;`
	`60`	`+ m_tokens += tokens_gained;`
`60`	`61`
`61`		`- //`
`62`		`- // Cap at max_tokens`
`63`		`- //`
`64`		`- if(m_tokens > m_max_tokens)`
	`62`	`+ //`
	`63`	`+ // Cap at max_tokens`
	`64`	`+ //`
	`65`	`+ if(m_tokens > m_max_tokens)`
`65`	`66`	`{`
`66`		`- m_tokens = m_max_tokens;`
	`67`	`+ m_tokens = m_max_tokens;`
`67`	`68`	`}`
`68`	`69`
`69`		`- //`
`70`		`- // If m_tokens is < tokens, can't claim.`
`71`		`- //`
`72`		`- if(m_tokens < tokens)`
	`70`	`+ //`
	`71`	`+ // If m_tokens is < tokens, can't claim.`
	`72`	`+ //`
	`73`	`+ if(m_tokens < tokens)`
`73`	`74`	`{`
`74`		`- return false;`
	`75`	`+ return false;`
`75`	`76`	`}`
`76`	`77`
`77`		`- m_tokens -= tokens;`
	`78`	`+ m_tokens -= tokens;`
`78`	`79`
`79`		`- return true;`
	`80`	`+ return true;`
`80`	`81`	`}`
`81`	`82`
`82`	`83`	`double token_bucket::get_tokens()`
`83`	`84`	`{`
`84`		`- return m_tokens;`
	`85`	`+ return m_tokens;`
`85`	`86`	`}`
`86`	`87`
`87`	`88`	`uint64_t token_bucket::get_last_seen()`
`88`	`89`	`{`
`89`		`- return m_last_seen;`
	`90`	`+ return m_last_seen;`
`90`	`91`	`}`