From 965a2883fe7021ca1c3f6d5052f7d3923a400f59 Mon Sep 17 00:00:00 2001 From: Sergey Kuznetsov Date: Mon, 3 Jun 2024 13:11:24 +0100 Subject: [PATCH] Fix formatting --- .DS_Store | Bin 0 -> 8196 bytes src/data/BackendCounters.hpp | 44 +++++++--- src/data/CassandraBackend.hpp | 4 +- src/data/cassandra/Concepts.hpp | 80 +++++++++++++----- src/data/cassandra/impl/Statement.hpp | 3 +- src/etl/LoadBalancer.cpp | 3 +- src/feed/impl/TrackableSignalMap.hpp | 4 +- src/rpc/Errors.hpp | 4 +- src/rpc/common/Concepts.hpp | 22 +++-- src/util/prometheus/impl/CounterImpl.hpp | 12 ++- src/util/prometheus/impl/HistogramImpl.hpp | 12 ++- src/web/Resolver.hpp | 4 +- src/web/interface/Concepts.hpp | 4 +- .../data/cassandra/impl/FakesAndMocks.hpp | 2 +- 14 files changed, 144 insertions(+), 54 deletions(-) create mode 100644 .DS_Store diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..db018fd0d5755053d6301f0dd4a96a54aadf20c6 GIT binary patch literal 8196 zcmeHM&2AGh5FY2J-OvIRqEaqMD{-w#p%p*k5|UOZQu$HS!U0goW>XrnSy$Oj1Bxo; z4DY}zaOFkdT{yuvwh6o27XC zjO0ws6=(rGQJW-%6jO`3XRK|7Wxz6E8L$jk1}p>r0t48yS)4ihzHYU-Wxz7v7^lZB z%)ot0jnG!!z&33uu4P8JL^XN@zq!|4_!QxyBEr;TdPi{v`!R!EO<)gzf?xC$siVre zpSLLE`XkfR_e@XAhU6BQJXFkd;KMP!PvdfLGPuj|;0ZmZecGcsRp|hwI-VZ_-OsX{ z`p@PeQA5merZdHeLVQ z5C$^jH=yHw7fjb^2W&Tx&){3dT9TU*-qH?M!!{yrHiAb?BJzly0kzXnAUJxGRz*as z#3#tEJQXiV%M#XIi1>=};V4Cnru$Ygl0;yrwD9CzB-Rz9Ct7nA*Q;F^+V1~Mh!xAg zIbtBMeJ%6(e`o&v|2dkGb=5Lp8TeBML}9zJT?I<*>NC*1%ezRgkyzMnqP2n`OZ^bQ e^YjlxlwFuIregF&Yt%sOMS!BgW|o1!%D_)#!y;4w literal 0 HcmV?d00001 diff --git a/src/data/BackendCounters.hpp b/src/data/BackendCounters.hpp index 1e38413e..f7fe6d40 100644 --- a/src/data/BackendCounters.hpp +++ b/src/data/BackendCounters.hpp @@ -39,17 +39,39 @@ namespace data { template concept SomeBackendCounters = requires(T a) { typename T::PtrType; - { a.registerTooBusy() } -> std::same_as; - { a.registerWriteSync(std::chrono::steady_clock::time_point{}) } -> std::same_as; - { a.registerWriteSyncRetry() } -> std::same_as; - { a.registerWriteStarted() } -> std::same_as; - { a.registerWriteFinished(std::chrono::steady_clock::time_point{}) } -> std::same_as; - { a.registerWriteRetry() } -> std::same_as; - { a.registerReadStarted(std::uint64_t{}) } -> std::same_as; - { a.registerReadFinished(std::chrono::steady_clock::time_point{}, std::uint64_t{}) } -> std::same_as; - { a.registerReadRetry(std::uint64_t{}) } -> std::same_as; - { a.registerReadError(std::uint64_t{}) } -> std::same_as; - { a.report() } -> std::same_as; + { + a.registerTooBusy() + } -> std::same_as; + { + a.registerWriteSync(std::chrono::steady_clock::time_point{}) + } -> std::same_as; + { + a.registerWriteSyncRetry() + } -> std::same_as; + { + a.registerWriteStarted() + } -> std::same_as; + { + a.registerWriteFinished(std::chrono::steady_clock::time_point{}) + } -> std::same_as; + { + a.registerWriteRetry() + } -> std::same_as; + { + a.registerReadStarted(std::uint64_t{}) + } -> std::same_as; + { + a.registerReadFinished(std::chrono::steady_clock::time_point{}, std::uint64_t{}) + } -> std::same_as; + { + a.registerReadRetry(std::uint64_t{}) + } -> std::same_as; + { + a.registerReadError(std::uint64_t{}) + } -> std::same_as; + { + a.report() + } -> std::same_as; }; /** diff --git a/src/data/CassandraBackend.hpp b/src/data/CassandraBackend.hpp index d9ba1ff6..945aae1f 100644 --- a/src/data/CassandraBackend.hpp +++ b/src/data/CassandraBackend.hpp @@ -732,7 +732,9 @@ public: std::cend(keys), std::cbegin(objs), std::back_inserter(results), - [](auto const& key, auto const& obj) { return LedgerObject{key, obj}; } + [](auto const& key, auto const& obj) { + return LedgerObject{key, obj}; + } ); return results; diff --git a/src/data/cassandra/Concepts.hpp b/src/data/cassandra/Concepts.hpp index 475027d1..47f35f1a 100644 --- a/src/data/cassandra/Concepts.hpp +++ b/src/data/cassandra/Concepts.hpp @@ -41,11 +41,21 @@ namespace data::cassandra { */ template concept SomeSettingsProvider = requires(T a) { - { a.getSettings() } -> std::same_as; - { a.getKeyspace() } -> std::same_as; - { a.getTablePrefix() } -> std::same_as>; - { a.getReplicationFactor() } -> std::same_as; - { a.getTtl() } -> std::same_as; + { + a.getSettings() + } -> std::same_as; + { + a.getKeyspace() + } -> std::same_as; + { + a.getTablePrefix() + } -> std::same_as>; + { + a.getReplicationFactor() + } -> std::same_as; + { + a.getTtl() + } -> std::same_as; }; /** @@ -61,18 +71,42 @@ concept SomeExecutionStrategy = requires( PreparedStatement prepared, boost::asio::yield_context token ) { - { T(settings, handle) }; - { a.sync() } -> std::same_as; - { a.isTooBusy() } -> std::same_as; - { a.writeSync(statement) } -> std::same_as; - { a.writeSync(prepared) } -> std::same_as; - { a.write(prepared) } -> std::same_as; - { a.write(std::move(statements)) } -> std::same_as; - { a.read(token, prepared) } -> std::same_as; - { a.read(token, statement) } -> std::same_as; - { a.read(token, statements) } -> std::same_as; - { a.readEach(token, statements) } -> std::same_as>; - { a.stats() } -> std::same_as; + { + T(settings, handle) + }; + { + a.sync() + } -> std::same_as; + { + a.isTooBusy() + } -> std::same_as; + { + a.writeSync(statement) + } -> std::same_as; + { + a.writeSync(prepared) + } -> std::same_as; + { + a.write(prepared) + } -> std::same_as; + { + a.write(std::move(statements)) + } -> std::same_as; + { + a.read(token, prepared) + } -> std::same_as; + { + a.read(token, statement) + } -> std::same_as; + { + a.read(token, statements) + } -> std::same_as; + { + a.readEach(token, statements) + } -> std::same_as>; + { + a.stats() + } -> std::same_as; }; /** @@ -80,12 +114,18 @@ concept SomeExecutionStrategy = requires( */ template concept SomeRetryPolicy = requires(T a, boost::asio::io_context ioc, CassandraError err, uint32_t attempt) { - { T(ioc) }; - { a.shouldRetry(err) } -> std::same_as; + { + T(ioc) + }; + { + a.shouldRetry(err) + } -> std::same_as; { a.retry([]() {}) } -> std::same_as; - { a.calculateDelay(attempt) } -> std::same_as; + { + a.calculateDelay(attempt) + } -> std::same_as; }; } // namespace data::cassandra diff --git a/src/data/cassandra/impl/Statement.hpp b/src/data/cassandra/impl/Statement.hpp index cfbc8f0a..3cf9ce80 100644 --- a/src/data/cassandra/impl/Statement.hpp +++ b/src/data/cassandra/impl/Statement.hpp @@ -121,8 +121,7 @@ public: // reinterpret_cast is needed here :'( auto const rc = bindBytes(reinterpret_cast(value.data()), value.size()); throwErrorIfNeeded(rc, "Bind string (as bytes)"); - } else if constexpr (std::is_same_v || - std::is_same_v) { + } else if constexpr (std::is_same_v || std::is_same_v) { auto const rc = cass_statement_bind_tuple(*this, idx, Tuple{std::forward(value)}); throwErrorIfNeeded(rc, "Bind tuple or "); } else if constexpr (std::is_same_v) { diff --git a/src/etl/LoadBalancer.cpp b/src/etl/LoadBalancer.cpp index 0a6cf6f4..7320eacd 100644 --- a/src/etl/LoadBalancer.cpp +++ b/src/etl/LoadBalancer.cpp @@ -117,8 +117,7 @@ LoadBalancer::LoadBalancer( "Failed to fetch ETL state from source = {} Please check the configuration and network", source->toString() )); - } else if (etlState_ && etlState_->networkID && stateOpt->networkID && - etlState_->networkID != stateOpt->networkID) { + } else if (etlState_ && etlState_->networkID && stateOpt->networkID && etlState_->networkID != stateOpt->networkID) { checkOnETLFailure(fmt::format( "ETL sources must be on the same network. Source network id = {} does not match others network id = {}", *(stateOpt->networkID), diff --git a/src/feed/impl/TrackableSignalMap.hpp b/src/feed/impl/TrackableSignalMap.hpp index 2e79ad30..8bbb51a9 100644 --- a/src/feed/impl/TrackableSignalMap.hpp +++ b/src/feed/impl/TrackableSignalMap.hpp @@ -33,7 +33,9 @@ namespace feed::impl { template concept Hashable = requires(T a) { - { std::hash{}(a) } -> std::convertible_to; + { + std::hash{}(a) + } -> std::convertible_to; }; /** diff --git a/src/rpc/Errors.hpp b/src/rpc/Errors.hpp index da76b7e2..21dc5e1f 100644 --- a/src/rpc/Errors.hpp +++ b/src/rpc/Errors.hpp @@ -77,8 +77,8 @@ struct Status { std::optional extraInfo; Status() = default; - /* implicit */ Status(CombinedError code) : code(code) {}; - Status(CombinedError code, boost::json::object&& extraInfo) : code(code), extraInfo(std::move(extraInfo)) {}; + /* implicit */ Status(CombinedError code) : code(code){}; + Status(CombinedError code, boost::json::object&& extraInfo) : code(code), extraInfo(std::move(extraInfo)){}; // HACK. Some rippled handlers explicitly specify errors. // This means that we have to be able to duplicate this functionality. diff --git a/src/rpc/common/Concepts.hpp b/src/rpc/common/Concepts.hpp index fa8a446f..ab355b4d 100644 --- a/src/rpc/common/Concepts.hpp +++ b/src/rpc/common/Concepts.hpp @@ -35,7 +35,9 @@ namespace rpc { */ template concept SomeRequirement = requires(T a, boost::json::value lval) { - { a.verify(lval, std::string{}) } -> std::same_as; + { + a.verify(lval, std::string{}) + } -> std::same_as; }; /** @@ -43,7 +45,9 @@ concept SomeRequirement = requires(T a, boost::json::value lval) { */ template concept SomeModifier = requires(T a, boost::json::value lval) { - { a.modify(lval, std::string{}) } -> std::same_as; + { + a.modify(lval, std::string{}) + } -> std::same_as; }; /** @@ -57,7 +61,9 @@ concept SomeProcessor = (SomeRequirement or SomeModifier); */ template concept SomeContextProcessWithInput = requires(T a, typename T::Input in, typename T::Output out, Context const& ctx) { - { a.process(in, ctx) } -> std::same_as>; + { + a.process(in, ctx) + } -> std::same_as>; }; /** @@ -65,7 +71,9 @@ concept SomeContextProcessWithInput = requires(T a, typename T::Input in, typena */ template concept SomeContextProcessWithoutInput = requires(T a, typename T::Output out, Context const& ctx) { - { a.process(ctx) } -> std::same_as>; + { + a.process(ctx) + } -> std::same_as>; }; /** @@ -73,7 +81,9 @@ concept SomeContextProcessWithoutInput = requires(T a, typename T::Output out, C */ template concept SomeHandlerWithInput = requires(T a, uint32_t version) { - { a.spec(version) } -> std::same_as; + { + a.spec(version) + } -> std::same_as; } and SomeContextProcessWithInput and boost::json::has_value_to::value; /** @@ -87,6 +97,6 @@ concept SomeHandlerWithoutInput = SomeContextProcessWithoutInput; */ template concept SomeHandler = - (SomeHandlerWithInput or SomeHandlerWithoutInput) and boost::json::has_value_from::value; + (SomeHandlerWithInput or SomeHandlerWithoutInput)and boost::json::has_value_from::value; } // namespace rpc diff --git a/src/util/prometheus/impl/CounterImpl.hpp b/src/util/prometheus/impl/CounterImpl.hpp index 77c9582d..f76841a1 100644 --- a/src/util/prometheus/impl/CounterImpl.hpp +++ b/src/util/prometheus/impl/CounterImpl.hpp @@ -29,9 +29,15 @@ template concept SomeCounterImpl = requires(T a) { typename std::remove_cvref_t::ValueType; requires SomeNumberType::ValueType>; - { a.add(typename std::remove_cvref_t::ValueType{1}) } -> std::same_as; - { a.set(typename std::remove_cvref_t::ValueType{1}) } -> std::same_as; - { a.value() } -> SomeNumberType; + { + a.add(typename std::remove_cvref_t::ValueType{1}) + } -> std::same_as; + { + a.set(typename std::remove_cvref_t::ValueType{1}) + } -> std::same_as; + { + a.value() + } -> SomeNumberType; }; template diff --git a/src/util/prometheus/impl/HistogramImpl.hpp b/src/util/prometheus/impl/HistogramImpl.hpp index bb3afcab..65e29c46 100644 --- a/src/util/prometheus/impl/HistogramImpl.hpp +++ b/src/util/prometheus/impl/HistogramImpl.hpp @@ -38,9 +38,15 @@ template concept SomeHistogramImpl = requires(T t) { typename std::remove_cvref_t::ValueType; requires SomeNumberType::ValueType>; - { t.observe(typename std::remove_cvref_t::ValueType{1}) } -> std::same_as; - { t.setBuckets(std::vector::ValueType>{}) } -> std::same_as; - { t.serializeValue(std::string{}, std::string{}, std::declval()) } -> std::same_as; + { + t.observe(typename std::remove_cvref_t::ValueType{1}) + } -> std::same_as; + { + t.setBuckets(std::vector::ValueType>{}) + } -> std::same_as; + { + t.serializeValue(std::string{}, std::string{}, std::declval()) + } -> std::same_as; }; template diff --git a/src/web/Resolver.hpp b/src/web/Resolver.hpp index d92ea51c..eb32c309 100644 --- a/src/web/Resolver.hpp +++ b/src/web/Resolver.hpp @@ -33,7 +33,9 @@ namespace web { template concept SomeResolver = requires(T t) { std::is_default_constructible_v; - { t.resolve(std::string_view{}, std::string_view{}) } -> std::same_as>; + { + t.resolve(std::string_view{}, std::string_view{}) + } -> std::same_as>; }; /** diff --git a/src/web/interface/Concepts.hpp b/src/web/interface/Concepts.hpp index b8b90602..69159c45 100644 --- a/src/web/interface/Concepts.hpp +++ b/src/web/interface/Concepts.hpp @@ -36,7 +36,9 @@ template concept SomeServerHandler = requires(T handler, std::string req, std::shared_ptr ws, boost::beast::error_code ec) { // the callback when server receives a request - { handler(req, ws) }; + { + handler(req, ws) + }; }; } // namespace web diff --git a/unittests/data/cassandra/impl/FakesAndMocks.hpp b/unittests/data/cassandra/impl/FakesAndMocks.hpp index e1312c05..1f07ba1b 100644 --- a/unittests/data/cassandra/impl/FakesAndMocks.hpp +++ b/unittests/data/cassandra/impl/FakesAndMocks.hpp @@ -106,7 +106,7 @@ struct MockHandle { }; struct FakeRetryPolicy { - FakeRetryPolicy(boost::asio::io_context&) {}; // required by concept + FakeRetryPolicy(boost::asio::io_context&){}; // required by concept static std::chrono::milliseconds calculateDelay(uint32_t /* attempt */)