clang-format: copy latest and re-format
clang-format-16 has some backwards incompatible changes that require
additional settings for best compatibility and re-running the formatter.
Copy the latest .clang-format from the docs repository and reformat the
repository.
Change-Id: I1ac255c58971ac5cc4697b8bb1069067aad02d18
Signed-off-by: Patrick Williams <patrick@stwcx.xyz>
diff --git a/.clang-format b/.clang-format
index 52ac0a1..d92a3f1 100644
--- a/.clang-format
+++ b/.clang-format
@@ -6,12 +6,14 @@
AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false
AlignEscapedNewlines: Right
-AlignOperands: true
-AlignTrailingComments: true
+AlignOperands: Align
+AlignTrailingComments:
+ Kind: Always
+ OverEmptyLines: 1
AllowAllParametersOfDeclarationOnNextLine: true
-AllowShortBlocksOnASingleLine: false
+AllowShortBlocksOnASingleLine: Empty
AllowShortCaseLabelsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: None
+AllowShortFunctionsOnASingleLine: Empty
AllowShortIfStatementsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterReturnType: None
@@ -36,12 +38,13 @@
SplitEmptyFunction: false
SplitEmptyRecord: false
SplitEmptyNamespace: false
+BreakAfterAttributes: Never
BreakBeforeBinaryOperators: None
BreakBeforeBraces: Custom
BreakBeforeTernaryOperators: true
BreakConstructorInitializers: AfterColon
BreakInheritanceList: AfterColon
-BreakStringLiterals: true
+BreakStringLiterals: false
ColumnLimit: 80
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false
@@ -49,6 +52,7 @@
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
+DeriveLineEnding: false
DerivePointerAlignment: false
PointerAlignment: Left
DisableFormat: false
@@ -74,9 +78,13 @@
- Regex: '.*'
Priority: 6
IndentCaseLabels: true
+IndentRequiresClause: true
IndentWidth: 4
IndentWrappedFunctionNames: true
-KeepEmptyLinesAtTheStartOfBlocks: true
+InsertNewlineAtEOF: true
+KeepEmptyLinesAtTheStartOfBlocks: false
+LambdaBodyIndentation: OuterScope
+LineEnding: LF
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1
@@ -84,13 +92,19 @@
ObjCBlockIndentWidth: 2
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 25
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 60
+PenaltyIndentedWhitespace: 0
+QualifierAlignment: Left
+ReferenceAlignment: Left
ReflowComments: true
+RequiresClausePosition: OwnLine
+RequiresExpressionIndentation: Keyword
SortIncludes: true
SortUsingDeclarations: true
SpaceAfterCStyleCast: false
diff --git a/src/main.cpp b/src/main.cpp
index bea8a13..59a2d30 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -20,13 +20,13 @@
signals.async_wait(
[&ioc](const boost::system::error_code ec, const int& sig) {
- if (ec)
- {
- throw std::runtime_error("Signal should not be canceled");
- }
+ if (ec)
+ {
+ throw std::runtime_error("Signal should not be canceled");
+ }
- ioc.stop();
- });
+ ioc.stop();
+ });
phosphor::logging::log<phosphor::logging::level::INFO>(
"Telemetry starting");
diff --git a/src/metric.cpp b/src/metric.cpp
index f7a0642..222af3c 100644
--- a/src/metric.cpp
+++ b/src/metric.cpp
@@ -30,12 +30,12 @@
void Metric::unregisterFromUpdates(interfaces::MetricListener& listener)
{
- listeners.erase(
- std::remove_if(listeners.begin(), listeners.end(),
- [&listener](const interfaces::MetricListener& item) {
- return &item == &listener;
- }),
- listeners.end());
+ listeners.erase(std::remove_if(
+ listeners.begin(), listeners.end(),
+ [&listener](const interfaces::MetricListener& item) {
+ return &item == &listener;
+ }),
+ listeners.end());
}
void Metric::initialize()
@@ -108,9 +108,10 @@
metrics::CollectionData&
Metric::findAssociatedData(const interfaces::Sensor& notifier)
{
- auto it = std::find_if(
- sensors.begin(), sensors.end(),
- [¬ifier](const auto& sensor) { return sensor.get() == ¬ifier; });
+ auto it = std::find_if(sensors.begin(), sensors.end(),
+ [¬ifier](const auto& sensor) {
+ return sensor.get() == ¬ifier;
+ });
auto index = std::distance(sensors.begin(), it);
return *collectionAlgorithms.at(index);
}
diff --git a/src/metrics/collection_data.cpp b/src/metrics/collection_data.cpp
index 7ab5354..3610cba 100644
--- a/src/metrics/collection_data.cpp
+++ b/src/metrics/collection_data.cpp
@@ -85,8 +85,8 @@
if (timestamp > duration.t)
{
- readings.front().first =
- std::max(readings.front().first, timestamp - duration.t);
+ readings.front().first = std::max(readings.front().first,
+ timestamp - duration.t);
}
}
@@ -139,9 +139,8 @@
case CollectionTimeScope::interval:
std::generate_n(std::back_inserter(result), size,
[cf = makeCollectionFunction(op), duration] {
- return std::make_unique<DataInterval>(cf,
- duration);
- });
+ return std::make_unique<DataInterval>(cf, duration);
+ });
break;
case CollectionTimeScope::point:
std::generate_n(std::back_inserter(result), size,
@@ -150,8 +149,8 @@
case CollectionTimeScope::startup:
std::generate_n(std::back_inserter(result), size,
[cf = makeCollectionFunction(op)] {
- return std::make_unique<DataStartup>(cf);
- });
+ return std::make_unique<DataStartup>(cf);
+ });
break;
}
diff --git a/src/metrics/collection_function.cpp b/src/metrics/collection_function.cpp
index 717bb68..7170936 100644
--- a/src/metrics/collection_function.cpp
+++ b/src/metrics/collection_function.cpp
@@ -14,10 +14,8 @@
return std::min_element(
readings.begin(), readings.end(),
[](const auto& left, const auto& right) {
- return std::make_tuple(!std::isfinite(left.second),
- left.second) <
- std::make_tuple(!std::isfinite(right.second),
- right.second);
+ return std::make_tuple(!std::isfinite(left.second), left.second) <
+ std::make_tuple(!std::isfinite(right.second), right.second);
})
->second;
}
@@ -40,10 +38,8 @@
return std::max_element(
readings.begin(), readings.end(),
[](const auto& left, const auto& right) {
- return std::make_tuple(std::isfinite(left.second),
- left.second) <
- std::make_tuple(std::isfinite(right.second),
- right.second);
+ return std::make_tuple(std::isfinite(left.second), left.second) <
+ std::make_tuple(std::isfinite(right.second), right.second);
})
->second;
}
diff --git a/src/numeric_threshold.cpp b/src/numeric_threshold.cpp
index 0b60dac..5980e23 100644
--- a/src/numeric_threshold.cpp
+++ b/src/numeric_threshold.cpp
@@ -57,10 +57,10 @@
return;
}
- bool crossedDecreasing =
- thresholdValue < prevValue && thresholdValue > value;
- bool crossedIncreasing =
- thresholdValue > prevValue && thresholdValue < value;
+ bool crossedDecreasing = thresholdValue < prevValue &&
+ thresholdValue > value;
+ bool crossedIncreasing = thresholdValue > prevValue &&
+ thresholdValue < value;
if (!crossedDecreasing && !crossedIncreasing && thresholdValue == prevValue)
{
diff --git a/src/report.cpp b/src/report.cpp
index 9e69b62..dbc1a9a 100644
--- a/src/report.cpp
+++ b/src/report.cpp
@@ -48,34 +48,34 @@
return metric->dumpConfiguration();
}));
- readingParametersPastVersion =
- utils::transform(readingParameters, [](const auto& item) {
- const auto& [sensorData, operationType, id, collectionTimeScope,
- collectionDuration] = item;
+ readingParametersPastVersion = utils::transform(readingParameters,
+ [](const auto& item) {
+ const auto& [sensorData, operationType, id, collectionTimeScope,
+ collectionDuration] = item;
- return ReadingParametersPastVersion::value_type(
- std::get<0>(sensorData.front()), operationType, id,
- std::get<1>(sensorData.front()));
- });
+ return ReadingParametersPastVersion::value_type(
+ std::get<0>(sensorData.front()), operationType, id,
+ std::get<1>(sensorData.front()));
+ });
reportActions.insert(ReportAction::logToMetricReportsCollection);
deleteIface = objServer->add_unique_interface(
getPath(), deleteIfaceName,
[this, &ioc, &reportManager](auto& dbusIface) {
- dbusIface.register_method("Delete", [this, &ioc, &reportManager] {
- if (persistency)
- {
- persistency = false;
+ dbusIface.register_method("Delete", [this, &ioc, &reportManager] {
+ if (persistency)
+ {
+ persistency = false;
- reportIface->signal_property("Persistency");
- }
+ reportIface->signal_property("Persistency");
+ }
- boost::asio::post(ioc, [this, &reportManager] {
- reportManager.removeReport(this);
- });
+ boost::asio::post(ioc, [this, &reportManager] {
+ reportManager.removeReport(this);
});
});
+ });
errorMessages = verify();
state.set<ReportFlags::enabled, ReportFlags::valid>(enabledIn,
@@ -86,29 +86,29 @@
messanger.on_receive<messages::TriggerPresenceChangedInd>(
[this](const auto& msg) {
- const auto oldSize = triggerIds.size();
+ const auto oldSize = triggerIds.size();
- if (msg.presence == messages::Presence::Exist)
+ if (msg.presence == messages::Presence::Exist)
+ {
+ if (utils::contains(msg.reportIds, id))
{
- if (utils::contains(msg.reportIds, id))
- {
- triggerIds.insert(msg.triggerId);
- }
- else if (!utils::contains(msg.reportIds, id))
- {
- triggerIds.erase(msg.triggerId);
- }
+ triggerIds.insert(msg.triggerId);
}
- else if (msg.presence == messages::Presence::Removed)
+ else if (!utils::contains(msg.reportIds, id))
{
triggerIds.erase(msg.triggerId);
}
+ }
+ else if (msg.presence == messages::Presence::Removed)
+ {
+ triggerIds.erase(msg.triggerId);
+ }
- if (triggerIds.size() != oldSize)
- {
- reportIface->signal_property("Triggers");
- }
- });
+ if (triggerIds.size() != oldSize)
+ {
+ reportIface->signal_property("Triggers");
+ }
+ });
messanger.on_receive<messages::UpdateReportInd>([this](const auto& msg) {
if (utils::contains(msg.reportIds, id))
@@ -191,8 +191,8 @@
void Report::setReadingBuffer(const ReportUpdates newReportUpdates)
{
- const auto newBufferSize =
- deduceBufferSize(newReportUpdates, reportingType);
+ const auto newBufferSize = deduceBufferSize(newReportUpdates,
+ reportingType);
if (readingsBuffer.size() != newBufferSize)
{
readingsBuffer.clearAndResize(newBufferSize);
@@ -211,73 +211,72 @@
std::unique_ptr<sdbusplus::asio::dbus_interface>
Report::makeReportInterface(const interfaces::ReportFactory& reportFactory)
{
- auto dbusIface =
- objServer->add_unique_interface(getPath(), reportIfaceName);
+ auto dbusIface = objServer->add_unique_interface(getPath(),
+ reportIfaceName);
dbusIface->register_property_rw<bool>(
"Enabled", sdbusplus::vtable::property_::emits_change,
[this](bool newVal, auto& oldValue) {
- if (newVal != state.get<ReportFlags::enabled>())
- {
- state.set<ReportFlags::enabled>(oldValue = newVal);
+ if (newVal != state.get<ReportFlags::enabled>())
+ {
+ state.set<ReportFlags::enabled>(oldValue = newVal);
- persistency = storeConfiguration();
- }
- return 1;
+ persistency = storeConfiguration();
+ }
+ return 1;
},
[this](const auto&) { return state.get<ReportFlags::enabled>(); });
dbusIface->register_property_r<
std::vector<std::tuple<std::string, std::string>>>(
"ErrorMessages", sdbusplus::vtable::property_::emits_change,
[this](const auto&) {
- return utils::transform(errorMessages, [](const auto& em) {
- return std::tuple<std::string, std::string>(
- utils::enumToString(em.error), em.arg0);
- });
+ return utils::transform(errorMessages, [](const auto& em) {
+ return std::tuple<std::string, std::string>(
+ utils::enumToString(em.error), em.arg0);
+ });
});
dbusIface->register_property_rw<uint64_t>(
"Interval", sdbusplus::vtable::property_::emits_change,
[this](uint64_t newVal, auto& oldVal) {
- const Milliseconds newValT{newVal};
- if (newValT < ReportManager::minInterval &&
- newValT != Milliseconds{0})
+ const Milliseconds newValT{newVal};
+ if (newValT < ReportManager::minInterval && newValT != Milliseconds{0})
+ {
+ throw errors::InvalidArgument("Interval");
+ }
+
+ if (newValT != interval)
+ {
+ oldVal = newVal;
+ interval = newValT;
+
+ errorMessages = verify();
+ if (state.set<ReportFlags::valid>(errorMessages.empty()) ==
+ StateEvent::active)
{
- throw errors::InvalidArgument("Interval");
+ scheduleTimer();
}
- if (newValT != interval)
- {
- oldVal = newVal;
- interval = newValT;
-
- errorMessages = verify();
- if (state.set<ReportFlags::valid>(errorMessages.empty()) ==
- StateEvent::active)
- {
- scheduleTimer();
- }
-
- persistency = storeConfiguration();
- }
- return 1;
+ persistency = storeConfiguration();
+ }
+ return 1;
},
[this](const auto&) { return interval.count(); });
dbusIface->register_property_rw<bool>(
"Persistency", sdbusplus::vtable::property_::emits_change,
[this](bool newVal, auto& oldVal) {
- if (newVal == persistency)
- {
- return 1;
- }
- if (newVal)
- {
- persistency = oldVal = storeConfiguration();
- }
- else
- {
- reportStorage.remove(reportFileName());
- persistency = oldVal = false;
- }
+ if (newVal == persistency)
+ {
return 1;
+ }
+ if (newVal)
+ {
+ persistency = oldVal = storeConfiguration();
+ }
+ else
+ {
+ reportStorage.remove(reportFileName());
+ persistency = oldVal = false;
+ }
+ return 1;
},
[this](const auto&) { return persistency; });
@@ -287,24 +286,24 @@
dbusIface->register_property_rw<std::string>(
"ReportingType", sdbusplus::vtable::property_::emits_change,
[this](auto newVal, auto& oldVal) {
- ReportingType tmp = utils::toReportingType(newVal);
- if (tmp != reportingType)
+ ReportingType tmp = utils::toReportingType(newVal);
+ if (tmp != reportingType)
+ {
+ reportingType = tmp;
+ oldVal = std::move(newVal);
+
+ errorMessages = verify();
+ if (state.set<ReportFlags::valid>(errorMessages.empty()) ==
+ StateEvent::active)
{
- reportingType = tmp;
- oldVal = std::move(newVal);
-
- errorMessages = verify();
- if (state.set<ReportFlags::valid>(errorMessages.empty()) ==
- StateEvent::active)
- {
- scheduleTimer();
- }
-
- persistency = storeConfiguration();
-
- setReadingBuffer(reportUpdates);
+ scheduleTimer();
}
- return 1;
+
+ persistency = storeConfiguration();
+
+ setReadingBuffer(reportUpdates);
+ }
+ return 1;
},
[this](const auto&) { return utils::enumToString(reportingType); });
dbusIface->register_property_r(
@@ -315,60 +314,58 @@
"ReadingParametersFutureVersion", readingParameters,
sdbusplus::vtable::property_::emits_change,
[this, &reportFactory](auto newVal, auto& oldVal) {
- auto labeledMetricParams =
- reportFactory.convertMetricParams(newVal);
- ReportManager::verifyMetricParameters(labeledMetricParams);
- reportFactory.updateMetrics(metrics,
- state.get<ReportFlags::enabled>(),
- labeledMetricParams);
- readingParameters = toReadingParameters(
- utils::transform(metrics, [](const auto& metric) {
- return metric->dumpConfiguration();
- }));
- metricCount = getMetricCount(metrics);
- setReadingBuffer(reportUpdates);
- persistency = storeConfiguration();
- oldVal = std::move(newVal);
- return 1;
+ auto labeledMetricParams = reportFactory.convertMetricParams(newVal);
+ ReportManager::verifyMetricParameters(labeledMetricParams);
+ reportFactory.updateMetrics(metrics, state.get<ReportFlags::enabled>(),
+ labeledMetricParams);
+ readingParameters = toReadingParameters(
+ utils::transform(metrics, [](const auto& metric) {
+ return metric->dumpConfiguration();
+ }));
+ metricCount = getMetricCount(metrics);
+ setReadingBuffer(reportUpdates);
+ persistency = storeConfiguration();
+ oldVal = std::move(newVal);
+ return 1;
},
[this](const auto&) { return readingParameters; });
- dbusIface->register_property_r<bool>(
- "EmitsReadingsUpdate", sdbusplus::vtable::property_::none,
- [this](const auto&) {
- return reportActions.contains(ReportAction::emitsReadingsUpdate);
- });
+ dbusIface->register_property_r<bool>("EmitsReadingsUpdate",
+ sdbusplus::vtable::property_::none,
+ [this](const auto&) {
+ return reportActions.contains(ReportAction::emitsReadingsUpdate);
+ });
dbusIface->register_property_r<std::string>(
"Name", sdbusplus::vtable::property_::const_,
[this](const auto&) { return name; });
- dbusIface->register_property_r<bool>(
- "LogToMetricReportsCollection", sdbusplus::vtable::property_::const_,
- [this](const auto&) {
- return reportActions.contains(
- ReportAction::logToMetricReportsCollection);
- });
+ dbusIface->register_property_r<bool>("LogToMetricReportsCollection",
+ sdbusplus::vtable::property_::const_,
+ [this](const auto&) {
+ return reportActions.contains(
+ ReportAction::logToMetricReportsCollection);
+ });
dbusIface->register_property_rw<std::vector<std::string>>(
"ReportActions", sdbusplus::vtable::property_::emits_change,
[this](auto newVal, auto& oldVal) {
- auto tmp = utils::transform<std::unordered_set>(
- newVal, [](const auto& reportAction) {
- return utils::toReportAction(reportAction);
- });
- tmp.insert(ReportAction::logToMetricReportsCollection);
+ auto tmp = utils::transform<std::unordered_set>(
+ newVal, [](const auto& reportAction) {
+ return utils::toReportAction(reportAction);
+ });
+ tmp.insert(ReportAction::logToMetricReportsCollection);
- if (tmp != reportActions)
- {
- reportActions = tmp;
- persistency = storeConfiguration();
- oldVal = std::move(newVal);
- }
- return 1;
+ if (tmp != reportActions)
+ {
+ reportActions = tmp;
+ persistency = storeConfiguration();
+ oldVal = std::move(newVal);
+ }
+ return 1;
},
[this](const auto&) {
- return utils::transform<std::vector>(
- reportActions, [](const auto reportAction) {
- return utils::enumToString(reportAction);
- });
+ return utils::transform<std::vector>(reportActions,
+ [](const auto reportAction) {
+ return utils::enumToString(reportAction);
});
+ });
dbusIface->register_property_r<uint64_t>(
"AppendLimit", sdbusplus::vtable::property_::emits_change,
[this](const auto&) { return appendLimit; });
@@ -376,19 +373,19 @@
"ReportUpdates", std::string(),
sdbusplus::vtable::property_::emits_change,
[this](auto newVal, auto& oldVal) {
- setReportUpdates(utils::toReportUpdates(newVal));
- oldVal = newVal;
- return 1;
+ setReportUpdates(utils::toReportUpdates(newVal));
+ oldVal = newVal;
+ return 1;
},
[this](const auto&) { return utils::enumToString(reportUpdates); });
dbusIface->register_property_r(
"Triggers", std::vector<sdbusplus::message::object_path>{},
sdbusplus::vtable::property_::emits_change, [this](const auto&) {
- return utils::transform<std::vector>(
- triggerIds, [](const auto& triggerId) {
- return utils::pathAppend(utils::constants::triggerDirPath,
- triggerId);
- });
+ return utils::transform<std::vector>(triggerIds,
+ [](const auto& triggerId) {
+ return utils::pathAppend(utils::constants::triggerDirPath,
+ triggerId);
+ });
});
dbusIface->register_method("Update", [this] {
if (reportingType == ReportingType::onRequest)
@@ -515,17 +512,17 @@
data["Id"] = id;
data["Name"] = name;
data["ReportingType"] = utils::toUnderlying(reportingType);
- data["ReportActions"] =
- utils::transform(reportActions, [](const auto reportAction) {
- return utils::toUnderlying(reportAction);
- });
+ data["ReportActions"] = utils::transform(reportActions,
+ [](const auto reportAction) {
+ return utils::toUnderlying(reportAction);
+ });
data["Interval"] = interval.count();
data["AppendLimit"] = appendLimit;
data["ReportUpdates"] = utils::toUnderlying(reportUpdates);
- data["ReadingParameters"] =
- utils::transform(metrics, [](const auto& metric) {
- return metric->dumpConfiguration();
- });
+ data["ReadingParameters"] = utils::transform(metrics,
+ [](const auto& metric) {
+ return metric->dumpConfiguration();
+ });
if (shouldStoreMetricValues())
{
diff --git a/src/report.hpp b/src/report.hpp
index d3c88ec..be22c4f 100644
--- a/src/report.hpp
+++ b/src/report.hpp
@@ -32,8 +32,7 @@
class OnChangeContext
{
public:
- OnChangeContext(Report& report) : report(report)
- {}
+ OnChangeContext(Report& report) : report(report) {}
~OnChangeContext()
{
diff --git a/src/report_factory.cpp b/src/report_factory.cpp
index 8b150e1..d3a9bb0 100644
--- a/src/report_factory.cpp
+++ b/src/report_factory.cpp
@@ -58,9 +58,8 @@
{
auto existing = std::find_if(oldMetrics.begin(), oldMetrics.end(),
[labeledMetricParam](auto metric) {
- return labeledMetricParam ==
- metric->dumpConfiguration();
- });
+ return labeledMetricParam == metric->dumpConfiguration();
+ });
if (existing != oldMetrics.end())
{
@@ -152,8 +151,8 @@
{
auto it = std::find_if(tree.begin(), tree.end(),
[path = sensorPath](const auto& v) {
- return v.first == path;
- });
+ return v.first == path;
+ });
if (it != tree.end() && it->second.size() == 1)
{
diff --git a/src/report_manager.cpp b/src/report_manager.cpp
index d12e6aa..69a110c 100644
--- a/src/report_manager.cpp
+++ b/src/report_manager.cpp
@@ -44,118 +44,112 @@
loadFromPersistent();
reportManagerIface = objServer->add_unique_interface(
- reportManagerPath, reportManagerIfaceName, [this](auto& dbusIface) {
- dbusIface.register_property_r(
- "MaxReports", size_t{}, sdbusplus::vtable::property_::const_,
- [](const auto&) { return maxReports; });
- dbusIface.register_property_r(
- "MinInterval", uint64_t{}, sdbusplus::vtable::property_::const_,
- [](const auto&) -> uint64_t { return minInterval.count(); });
- dbusIface.register_property_r(
- "SupportedOperationTypes", std::vector<std::string>{},
- sdbusplus::vtable::property_::const_,
- [](const auto&) -> std::vector<std::string> {
- return utils::transform<std::vector>(
- utils::convDataOperationType, [](const auto& item) {
- return std::string(item.first);
- });
- });
+ reportManagerPath, reportManagerIfaceName,
+ [this](auto& dbusIface) {
+ dbusIface.register_property_r("MaxReports", size_t{},
+ sdbusplus::vtable::property_::const_,
+ [](const auto&) { return maxReports; });
+ dbusIface.register_property_r(
+ "MinInterval", uint64_t{}, sdbusplus::vtable::property_::const_,
+ [](const auto&) -> uint64_t { return minInterval.count(); });
+ dbusIface.register_property_r(
+ "SupportedOperationTypes", std::vector<std::string>{},
+ sdbusplus::vtable::property_::const_,
+ [](const auto&) -> std::vector<std::string> {
+ return utils::transform<std::vector>(
+ utils::convDataOperationType,
+ [](const auto& item) { return std::string(item.first); });
+ });
- dbusIface.register_method(
- "AddReport", [this](boost::asio::yield_context& yield,
- const std::string& reportId,
- const std::string& reportingType,
- const bool emitsReadingsUpdate,
- const bool logToMetricReportsCollection,
- const uint64_t interval,
- ReadingParametersPastVersion metricParams) {
- constexpr auto enabledDefault = true;
- constexpr ReportUpdates reportUpdatesDefault =
- ReportUpdates::overwrite;
+ dbusIface.register_method(
+ "AddReport",
+ [this](boost::asio::yield_context& yield,
+ const std::string& reportId,
+ const std::string& reportingType,
+ const bool emitsReadingsUpdate,
+ const bool logToMetricReportsCollection,
+ const uint64_t interval,
+ ReadingParametersPastVersion metricParams) {
+ constexpr auto enabledDefault = true;
+ constexpr ReportUpdates reportUpdatesDefault =
+ ReportUpdates::overwrite;
- std::vector<ReportAction> reportActions;
+ std::vector<ReportAction> reportActions;
- if (emitsReadingsUpdate)
- {
- reportActions.emplace_back(
- ReportAction::emitsReadingsUpdate);
- }
- if (logToMetricReportsCollection)
- {
- reportActions.emplace_back(
- ReportAction::logToMetricReportsCollection);
- }
+ if (emitsReadingsUpdate)
+ {
+ reportActions.emplace_back(ReportAction::emitsReadingsUpdate);
+ }
+ if (logToMetricReportsCollection)
+ {
+ reportActions.emplace_back(
+ ReportAction::logToMetricReportsCollection);
+ }
- return addReport(yield, reportId, reportId,
- utils::toReportingType(reportingType),
- reportActions, Milliseconds(interval),
- maxAppendLimit, reportUpdatesDefault,
- convertToReadingParameters(
- std::move(metricParams)),
- enabledDefault)
- .getPath();
- });
+ return addReport(
+ yield, reportId, reportId,
+ utils::toReportingType(reportingType), reportActions,
+ Milliseconds(interval), maxAppendLimit,
+ reportUpdatesDefault,
+ convertToReadingParameters(std::move(metricParams)),
+ enabledDefault)
+ .getPath();
+ });
- dbusIface.register_method(
- "AddReportFutureVersion",
- [this](
- boost::asio::yield_context& yield,
- const std::vector<
- std::pair<std::string, AddReportFutureVersionVariant>>&
- properties) {
- std::optional<std::string> reportId;
- std::optional<std::string> reportName;
- std::optional<std::string> reportingType;
- std::optional<std::vector<std::string>> reportActions;
- std::optional<uint64_t> interval;
- std::optional<uint64_t> appendLimit;
- std::optional<std::string> reportUpdates;
- std::optional<ReadingParameters> metricParams;
- std::optional<ReadingParameters> readingParameters;
- std::optional<bool> enabled;
+ dbusIface.register_method(
+ "AddReportFutureVersion",
+ [this](boost::asio::yield_context& yield,
+ const std::vector<
+ std::pair<std::string, AddReportFutureVersionVariant>>&
+ properties) {
+ std::optional<std::string> reportId;
+ std::optional<std::string> reportName;
+ std::optional<std::string> reportingType;
+ std::optional<std::vector<std::string>> reportActions;
+ std::optional<uint64_t> interval;
+ std::optional<uint64_t> appendLimit;
+ std::optional<std::string> reportUpdates;
+ std::optional<ReadingParameters> metricParams;
+ std::optional<ReadingParameters> readingParameters;
+ std::optional<bool> enabled;
- try
- {
- sdbusplus::unpackProperties(
- properties, "Id", reportId, "Name", reportName,
- "ReportingType", reportingType, "ReportActions",
- reportActions, "Interval", interval, "AppendLimit",
- appendLimit, "ReportUpdates", reportUpdates,
- "MetricParams", metricParams, "Enabled", enabled,
- "ReadingParameters", readingParameters);
- }
- catch (const sdbusplus::exception::UnpackPropertyError& e)
- {
- throw errors::InvalidArgument(e.propertyName);
- }
+ try
+ {
+ sdbusplus::unpackProperties(
+ properties, "Id", reportId, "Name", reportName,
+ "ReportingType", reportingType, "ReportActions",
+ reportActions, "Interval", interval, "AppendLimit",
+ appendLimit, "ReportUpdates", reportUpdates, "MetricParams",
+ metricParams, "Enabled", enabled, "ReadingParameters",
+ readingParameters);
+ }
+ catch (const sdbusplus::exception::UnpackPropertyError& e)
+ {
+ throw errors::InvalidArgument(e.propertyName);
+ }
- if (readingParameters == std::nullopt)
- {
- readingParameters = metricParams;
- }
+ if (readingParameters == std::nullopt)
+ {
+ readingParameters = metricParams;
+ }
- return addReport(
- yield, reportId.value_or(""),
- reportName.value_or(""),
- utils::toReportingType(
- reportingType.value_or(utils::enumToString(
- ReportingType::onRequest))),
- utils::transform(
- reportActions.value_or(
- std::vector<std::string>{}),
- [](const auto& reportAction) {
- return utils::toReportAction(
- reportAction);
- }),
- Milliseconds(interval.value_or(0)),
- appendLimit.value_or(maxAppendLimit),
- utils::toReportUpdates(
- reportUpdates.value_or(utils::enumToString(
- ReportUpdates::overwrite))),
- readingParameters.value_or(ReadingParameters{}),
- enabled.value_or(true))
- .getPath();
- });
+ return addReport(
+ yield, reportId.value_or(""), reportName.value_or(""),
+ utils::toReportingType(reportingType.value_or(
+ utils::enumToString(ReportingType::onRequest))),
+ utils::transform(
+ reportActions.value_or(std::vector<std::string>{}),
+ [](const auto& reportAction) {
+ return utils::toReportAction(reportAction);
+ }),
+ Milliseconds(interval.value_or(0)),
+ appendLimit.value_or(maxAppendLimit),
+ utils::toReportUpdates(reportUpdates.value_or(
+ utils::enumToString(ReportUpdates::overwrite))),
+ readingParameters.value_or(ReadingParameters{}),
+ enabled.value_or(true))
+ .getPath();
+ });
});
}
@@ -240,8 +234,8 @@
const uint64_t appendLimit, const ReportUpdates reportUpdates,
ReadingParameters metricParams, const bool enabled)
{
- auto labeledMetricParams =
- reportFactory->convertMetricParams(yield, metricParams);
+ auto labeledMetricParams = reportFactory->convertMetricParams(yield,
+ metricParams);
return addReport(reportId, reportName, reportingType, reportActions,
interval, appendLimit, reportUpdates,
@@ -295,7 +289,7 @@
std::vector<ReportAction> reportActions = utils::transform(
data->at("ReportActions").get<std::vector<uint32_t>>(),
[](const auto reportAction) {
- return utils::toReportAction(reportAction);
+ return utils::toReportAction(reportAction);
});
uint64_t interval = data->at("Interval").get<uint64_t>();
uint64_t appendLimit = data->at("AppendLimit").get<uint64_t>();
diff --git a/src/sensor.cpp b/src/sensor.cpp
index ce25a86..efebc5d 100644
--- a/src/sensor.cpp
+++ b/src/sensor.cpp
@@ -49,18 +49,18 @@
"xyz.openbmc_project.Sensor.Value", "Value",
[lock, id = sensorId, weakSelf = weak_from_this()](
boost::system::error_code ec, double newValue) {
- if (ec)
- {
- phosphor::logging::log<phosphor::logging::level::WARNING>(
- "DBus 'GetProperty' call failed on Sensor Value",
- phosphor::logging::entry("SENSOR_PATH=%s", id.path.c_str()),
- phosphor::logging::entry("ERROR_CODE=%d", ec.value()));
- return;
- }
- if (auto self = weakSelf.lock())
- {
- self->updateValue(newValue);
- }
+ if (ec)
+ {
+ phosphor::logging::log<phosphor::logging::level::WARNING>(
+ "DBus 'GetProperty' call failed on Sensor Value",
+ phosphor::logging::entry("SENSOR_PATH=%s", id.path.c_str()),
+ phosphor::logging::entry("ERROR_CODE=%d", ec.value()));
+ return;
+ }
+ if (auto self = weakSelf.lock())
+ {
+ self->updateValue(newValue);
+ }
});
}
@@ -96,8 +96,8 @@
std::remove_if(
listeners.begin(), listeners.end(),
[listenerToUnregister = listener.get()](const auto& listener) {
- return (listener.expired() ||
- listener.lock().get() == listenerToUnregister);
+ return (listener.expired() ||
+ listener.lock().get() == listenerToUnregister);
}),
listeners.end());
}
@@ -137,7 +137,7 @@
signalMonitor = std::make_unique<sdbusplus::bus::match_t>(
*bus, param,
[weakSelf = weak_from_this()](sdbusplus::message_t& message) {
- signalProc(weakSelf, message);
+ signalProc(weakSelf, message);
});
}
diff --git a/src/state.hpp b/src/state.hpp
index 91a7daf..fedc8c5 100644
--- a/src/state.hpp
+++ b/src/state.hpp
@@ -23,8 +23,7 @@
class State
{
public:
- explicit State(Object& object) : object(object)
- {}
+ explicit State(Object& object) : object(object) {}
template <Flags... Indexes>
StateEvent set(boolean auto... values)
diff --git a/src/trigger.cpp b/src/trigger.cpp
index ff08638..a167d3c 100644
--- a/src/trigger.cpp
+++ b/src/trigger.cpp
@@ -52,20 +52,20 @@
"Persistent", persistent,
sdbusplus::vtable::property_::emits_change,
[this](bool newVal, const auto&) {
- if (newVal == persistent)
- {
- return 1;
- }
- if (newVal)
- {
- persistent = storeConfiguration();
- }
- else
- {
- triggerStorage.remove(fileName);
- persistent = false;
- }
- return 1;
+ if (newVal == persistent)
+ {
+ return 1;
+ }
+ if (newVal)
+ {
+ persistent = storeConfiguration();
+ }
+ else
+ {
+ triggerStorage.remove(fileName);
+ persistent = false;
+ }
+ return 1;
},
[this](const auto&) { return persistent; });
@@ -73,60 +73,57 @@
"Thresholds", TriggerThresholdParams{},
sdbusplus::vtable::property_::emits_change,
[this, &triggerFactory](auto newVal, auto& oldVal) {
- auto newThresholdParams = std::visit(
- utils::ToLabeledThresholdParamConversion(), newVal);
- TriggerManager::verifyThresholdParams(newThresholdParams);
- triggerFactory.updateThresholds(
- thresholds, *id, triggerActions, reportIds, sensors,
- newThresholdParams);
- oldVal = std::move(newVal);
- return 1;
+ auto newThresholdParams =
+ std::visit(utils::ToLabeledThresholdParamConversion(), newVal);
+ TriggerManager::verifyThresholdParams(newThresholdParams);
+ triggerFactory.updateThresholds(thresholds, *id, triggerActions,
+ reportIds, sensors,
+ newThresholdParams);
+ oldVal = std::move(newVal);
+ return 1;
},
[this](const auto&) {
- return fromLabeledThresholdParam(getLabeledThresholds());
- });
+ return fromLabeledThresholdParam(getLabeledThresholds());
+ });
dbusIface.register_property_rw(
"Sensors", SensorsInfo{},
sdbusplus::vtable::property_::emits_change,
[this, &triggerFactory](auto newVal, auto& oldVal) {
- auto labeledSensorInfo =
- triggerFactory.getLabeledSensorsInfo(newVal);
- triggerFactory.updateSensors(sensors, labeledSensorInfo);
- for (const auto& threshold : thresholds)
- {
- threshold->updateSensors(sensors);
- }
- oldVal = std::move(newVal);
- return 1;
+ auto labeledSensorInfo =
+ triggerFactory.getLabeledSensorsInfo(newVal);
+ triggerFactory.updateSensors(sensors, labeledSensorInfo);
+ for (const auto& threshold : thresholds)
+ {
+ threshold->updateSensors(sensors);
+ }
+ oldVal = std::move(newVal);
+ return 1;
},
[this](const auto&) {
- return utils::fromLabeledSensorsInfo(
- getLabeledSensorInfo());
- });
+ return utils::fromLabeledSensorsInfo(getLabeledSensorInfo());
+ });
dbusIface.register_property_rw(
"Reports", std::vector<sdbusplus::message::object_path>(),
sdbusplus::vtable::property_::emits_change,
[this](auto newVal, auto& oldVal) {
- auto newReportIds = utils::transform<std::vector>(
- newVal, [](const auto& path) {
- return utils::reportPathToId(path);
- });
- TriggerManager::verifyReportIds(newReportIds);
- *reportIds = newReportIds;
- messanger.send(messages::TriggerPresenceChangedInd{
- messages::Presence::Exist, *id, *reportIds});
- oldVal = std::move(newVal);
- return 1;
+ auto newReportIds = utils::transform<std::vector>(
+ newVal,
+ [](const auto& path) { return utils::reportPathToId(path); });
+ TriggerManager::verifyReportIds(newReportIds);
+ *reportIds = newReportIds;
+ messanger.send(messages::TriggerPresenceChangedInd{
+ messages::Presence::Exist, *id, *reportIds});
+ oldVal = std::move(newVal);
+ return 1;
},
[this](const auto&) {
- return utils::transform<std::vector>(
- *reportIds, [](const auto& id) {
- return utils::pathAppend(
- utils::constants::reportDirPath, id);
- });
- });
+ return utils::transform<std::vector>(*reportIds,
+ [](const auto& id) {
+ return utils::pathAppend(utils::constants::reportDirPath, id);
+ });
+ });
dbusIface.register_property_r(
"Discrete", isDiscreate(), sdbusplus::vtable::property_::const_,
@@ -135,24 +132,23 @@
dbusIface.register_property_rw(
"Name", name, sdbusplus::vtable::property_::emits_change,
[this](auto newVal, auto& oldVal) {
- if (newVal.length() > utils::constants::maxIdNameLength)
- {
- throw errors::InvalidArgument("Name",
- "Name is too long.");
- }
- name = oldVal = newVal;
- return 1;
+ if (newVal.length() > utils::constants::maxIdNameLength)
+ {
+ throw errors::InvalidArgument("Name", "Name is too long.");
+ }
+ name = oldVal = newVal;
+ return 1;
},
[this](const auto&) { return name; });
- dbusIface.register_property_r(
- "TriggerActions", std::vector<std::string>(),
- sdbusplus::vtable::property_::const_, [this](const auto&) {
- return utils::transform(triggerActions,
- [](const auto& action) {
- return actionToString(action);
- });
- });
+ dbusIface.register_property_r("TriggerActions",
+ std::vector<std::string>(),
+ sdbusplus::vtable::property_::const_,
+ [this](const auto&) {
+ return utils::transform(triggerActions, [](const auto& action) {
+ return actionToString(action);
+ });
+ });
});
for (const auto& threshold : thresholds)
@@ -162,11 +158,11 @@
messanger.on_receive<messages::CollectTriggerIdReq>(
[this](const auto& msg) {
- if (utils::contains(*reportIds, msg.reportId))
- {
- messanger.send(messages::CollectTriggerIdResp{*id});
- }
- });
+ if (utils::contains(*reportIds, msg.reportId))
+ {
+ messanger.send(messages::CollectTriggerIdResp{*id});
+ }
+ });
messanger.send(messages::TriggerPresenceChangedInd{
messages::Presence::Exist, *id, *reportIds});
@@ -186,10 +182,10 @@
data["Id"] = *id;
data["Name"] = name;
data["ThresholdParamsDiscriminator"] = labeledThresholdParams.index();
- data["TriggerActions"] =
- utils::transform(triggerActions, [](const auto& action) {
- return actionToString(action);
- });
+ data["TriggerActions"] = utils::transform(triggerActions,
+ [](const auto& action) {
+ return actionToString(action);
+ });
data["ThresholdParams"] =
utils::labeledThresholdParamsToJson(labeledThresholdParams);
data["ReportIds"] = *reportIds;
diff --git a/src/trigger_actions.hpp b/src/trigger_actions.hpp
index a74cc7a..14f6294 100644
--- a/src/trigger_actions.hpp
+++ b/src/trigger_actions.hpp
@@ -68,8 +68,7 @@
class LogToJournal : public interfaces::TriggerAction
{
public:
- explicit LogToJournal(::discrete::Severity severity) : severity(severity)
- {}
+ explicit LogToJournal(::discrete::Severity severity) : severity(severity) {}
void commit(const std::string& triggerId, const ThresholdName thresholdName,
const std::string& sensorName, const Milliseconds timestamp,
@@ -107,8 +106,7 @@
class LogToJournal : public interfaces::TriggerAction
{
public:
- LogToJournal()
- {}
+ LogToJournal() {}
void commit(const std::string& triggerId, const ThresholdName thresholdName,
const std::string& sensorName, const Milliseconds timestamp,
@@ -118,8 +116,7 @@
class LogToRedfishEventLog : public interfaces::TriggerAction
{
public:
- LogToRedfishEventLog()
- {}
+ LogToRedfishEventLog() {}
void commit(const std::string& triggerId, const ThresholdName thresholdName,
const std::string& sensorName, const Milliseconds timestamp,
diff --git a/src/trigger_factory.cpp b/src/trigger_factory.cpp
index 615d42d..9ac8f49 100644
--- a/src/trigger_factory.cpp
+++ b/src/trigger_factory.cpp
@@ -223,10 +223,10 @@
const std::vector<LabeledSensorInfo>& labeledSensorsInfo) const
{
const auto& sensors = getSensors(labeledSensorsInfo);
- auto triggerActions =
- utils::transform(triggerActionsIn, [](const auto& triggerActionStr) {
- return toTriggerAction(triggerActionStr);
- });
+ auto triggerActions = utils::transform(triggerActionsIn,
+ [](const auto& triggerActionStr) {
+ return toTriggerAction(triggerActionStr);
+ });
std::vector<std::shared_ptr<interfaces::Threshold>> thresholds;
auto id = std::make_unique<const std::string>(idIn);
@@ -260,9 +260,8 @@
{
auto existing = std::find_if(oldSensors.begin(), oldSensors.end(),
[labeledSensorInfo](auto sensor) {
- return labeledSensorInfo ==
- sensor->getLabeledSensorInfo();
- });
+ return labeledSensorInfo == sensor->getLabeledSensorInfo();
+ });
if (existing != oldSensors.end())
{
@@ -311,9 +310,10 @@
{
return utils::transform(sensorsInfo, [&tree](const auto& item) {
const auto& [sensorPath, metadata] = item;
- auto found = std::find_if(
- tree.begin(), tree.end(),
- [path = sensorPath](const auto& x) { return x.first == path; });
+ auto found = std::find_if(tree.begin(), tree.end(),
+ [path = sensorPath](const auto& x) {
+ return x.first == path;
+ });
if (tree.end() != found)
{
diff --git a/src/trigger_manager.cpp b/src/trigger_manager.cpp
index fc6bbcd..984b434 100644
--- a/src/trigger_manager.cpp
+++ b/src/trigger_manager.cpp
@@ -21,36 +21,33 @@
{
loadFromPersistent();
- managerIface = objServer->add_unique_interface(
- triggerManagerPath, triggerManagerIfaceName, [this](auto& iface) {
- iface.register_method(
- "AddTrigger",
- [this](
- boost::asio::yield_context& yield, const std::string& id,
- const std::string& name,
- const std::vector<std::string>& triggerActions,
- const SensorsInfo& sensors,
- const std::vector<sdbusplus::message::object_path>& reports,
- const TriggerThresholdParamsExt& thresholds) {
- LabeledTriggerThresholdParams
- labeledTriggerThresholdParams = std::visit(
- utils::ToLabeledThresholdParamConversion(),
- thresholds);
+ managerIface = objServer->add_unique_interface(triggerManagerPath,
+ triggerManagerIfaceName,
+ [this](auto& iface) {
+ iface.register_method(
+ "AddTrigger",
+ [this](boost::asio::yield_context& yield, const std::string& id,
+ const std::string& name,
+ const std::vector<std::string>& triggerActions,
+ const SensorsInfo& sensors,
+ const std::vector<sdbusplus::message::object_path>& reports,
+ const TriggerThresholdParamsExt& thresholds) {
+ LabeledTriggerThresholdParams labeledTriggerThresholdParams =
+ std::visit(utils::ToLabeledThresholdParamConversion(),
+ thresholds);
- std::vector<LabeledSensorInfo> labeledSensorsInfo =
- triggerFactory->getLabeledSensorsInfo(yield, sensors);
+ std::vector<LabeledSensorInfo> labeledSensorsInfo =
+ triggerFactory->getLabeledSensorsInfo(yield, sensors);
- auto reportIds = utils::transform<std::vector>(
- reports, [](const auto& item) {
- return utils::reportPathToId(item);
- });
+ auto reportIds = utils::transform<std::vector>(
+ reports,
+ [](const auto& item) { return utils::reportPathToId(item); });
- return addTrigger(id, name, triggerActions,
- labeledSensorsInfo, reportIds,
- labeledTriggerThresholdParams)
- .getPath();
- });
- });
+ return addTrigger(id, name, triggerActions, labeledSensorsInfo,
+ reportIds, labeledTriggerThresholdParams)
+ .getPath();
+ });
+ });
}
void TriggerManager::removeTrigger(const interfaces::Trigger* trigger)
diff --git a/src/types/error_type.hpp b/src/types/error_type.hpp
index 00e9bb1..ae2dd4b 100644
--- a/src/types/error_type.hpp
+++ b/src/types/error_type.hpp
@@ -23,9 +23,9 @@
static constexpr auto propertyName = ConstexprString{"ErrorType"};
};
-constexpr auto convDataErrorType =
- std::array{std::make_pair<std::string_view, ErrorType>(
- "PropertyConflict", ErrorType::propertyConflict)};
+constexpr auto convDataErrorType = std::array{
+ std::make_pair<std::string_view, ErrorType>("PropertyConflict",
+ ErrorType::propertyConflict)};
inline ErrorType toErrorType(std::underlying_type_t<ErrorType> value)
{
diff --git a/src/types/readings.cpp b/src/types/readings.cpp
index 2f6246b..5782158 100644
--- a/src/types/readings.cpp
+++ b/src/types/readings.cpp
@@ -9,11 +9,11 @@
LabeledReadings toLabeledReadings(const Readings& readings)
{
- return LabeledReadings{
- std::get<0>(readings),
- utils::transform(std::get<1>(readings), [](const auto& readingData) {
- return LabeledReadingData{readingData};
- })};
+ return LabeledReadings{std::get<0>(readings),
+ utils::transform(std::get<1>(readings),
+ [](const auto& readingData) {
+ return LabeledReadingData{readingData};
+ })};
}
Readings toReadings(const LabeledReadings& labeledReadings)
@@ -21,8 +21,8 @@
return Readings{labeledReadings.at_label<ts::Timestamp>(),
utils::transform(labeledReadings.at_label<ts::Readings>(),
[](const auto& labeledReadingData) {
- return labeledReadingData.to_tuple();
- })};
+ return labeledReadingData.to_tuple();
+ })};
}
} // namespace utils
diff --git a/src/types/report_types.cpp b/src/types/report_types.cpp
index 72bce4b..4fb0b4e 100644
--- a/src/types/report_types.cpp
+++ b/src/types/report_types.cpp
@@ -7,21 +7,20 @@
{
namespace ts = utils::tstring;
- return utils::transform(
- labeled, [](const LabeledMetricParameters& metricParams) {
- return ReadingParameters::value_type(
- utils::transform(
- metricParams.at_label<ts::SensorPath>(),
- [](const LabeledSensorInfo& sensorParameters) {
- return std::tuple<sdbusplus::message::object_path,
- std::string>(
- sensorParameters.at_label<ts::Path>(),
- sensorParameters.at_label<ts::Metadata>());
- }),
- utils::enumToString(metricParams.at_label<ts::OperationType>()),
- metricParams.at_label<ts::Id>(),
- utils::enumToString(
- metricParams.at_label<ts::CollectionTimeScope>()),
- metricParams.at_label<ts::CollectionDuration>().t.count());
- });
+ return utils::transform(labeled,
+ [](const LabeledMetricParameters& metricParams) {
+ return ReadingParameters::value_type(
+ utils::transform(
+ metricParams.at_label<ts::SensorPath>(),
+ [](const LabeledSensorInfo& sensorParameters) {
+ return std::tuple<sdbusplus::message::object_path, std::string>(
+ sensorParameters.at_label<ts::Path>(),
+ sensorParameters.at_label<ts::Metadata>());
+ }),
+ utils::enumToString(metricParams.at_label<ts::OperationType>()),
+ metricParams.at_label<ts::Id>(),
+ utils::enumToString(
+ metricParams.at_label<ts::CollectionTimeScope>()),
+ metricParams.at_label<ts::CollectionDuration>().t.count());
+ });
}
diff --git a/src/types/report_updates.hpp b/src/types/report_updates.hpp
index 8313a94..a3dfe81 100644
--- a/src/types/report_updates.hpp
+++ b/src/types/report_updates.hpp
@@ -25,13 +25,13 @@
static constexpr auto propertyName = ConstexprString{"ReportUpdates"};
};
-constexpr auto convDataReportUpdates =
- std::array{std::make_pair<std::string_view, ReportUpdates>(
- "Overwrite", ReportUpdates::overwrite),
- std::make_pair<std::string_view, ReportUpdates>(
- "AppendStopsWhenFull", ReportUpdates::appendStopsWhenFull),
- std::make_pair<std::string_view, ReportUpdates>(
- "AppendWrapsWhenFull", ReportUpdates::appendWrapsWhenFull)};
+constexpr auto convDataReportUpdates = std::array{
+ std::make_pair<std::string_view, ReportUpdates>("Overwrite",
+ ReportUpdates::overwrite),
+ std::make_pair<std::string_view, ReportUpdates>(
+ "AppendStopsWhenFull", ReportUpdates::appendStopsWhenFull),
+ std::make_pair<std::string_view, ReportUpdates>(
+ "AppendWrapsWhenFull", ReportUpdates::appendWrapsWhenFull)};
inline ReportUpdates
toReportUpdates(std::underlying_type_t<ReportUpdates> value)
diff --git a/src/utils/conversion.hpp b/src/utils/conversion.hpp
index e92249a..f528044 100644
--- a/src/utils/conversion.hpp
+++ b/src/utils/conversion.hpp
@@ -90,9 +90,10 @@
inline T toEnum(const std::array<std::pair<std::string_view, T>, N>& data,
const std::string& value)
{
- auto it = std::find_if(
- std::begin(data), std::end(data),
- [&value](const auto& item) { return item.first == value; });
+ auto it = std::find_if(std::begin(data), std::end(data),
+ [&value](const auto& item) {
+ return item.first == value;
+ });
if (it == std::end(data))
{
throwConversionError(EnumTraits<T>::propertyName);
@@ -105,9 +106,10 @@
enumToString(const std::array<std::pair<std::string_view, T>, N>& data,
T value)
{
- auto it = std::find_if(
- std::begin(data), std::end(data),
- [value](const auto& item) { return item.second == value; });
+ auto it = std::find_if(std::begin(data), std::end(data),
+ [value](const auto& item) {
+ return item.second == value;
+ });
if (it == std::end(data))
{
throwConversionError(EnumTraits<T>::propertyName);
diff --git a/src/utils/conversion_trigger.cpp b/src/utils/conversion_trigger.cpp
index d65eae9..a8417e5 100644
--- a/src/utils/conversion_trigger.cpp
+++ b/src/utils/conversion_trigger.cpp
@@ -21,8 +21,8 @@
const std::vector<numeric::ThresholdParam>& arg) const
{
return utils::transform(arg, [](const auto& thresholdParam) {
- const auto& [type, dwellTime, direction, thresholdValue] =
- thresholdParam;
+ const auto& [type, dwellTime, direction,
+ thresholdValue] = thresholdParam;
return numeric::LabeledThresholdParam(numeric::toType(type), dwellTime,
numeric::toDirection(direction),
thresholdValue);
@@ -33,8 +33,8 @@
const std::vector<discrete::ThresholdParam>& arg) const
{
return utils::transform(arg, [](const auto& thresholdParam) {
- const auto& [userId, severity, dwellTime, thresholdValue] =
- thresholdParam;
+ const auto& [userId, severity, dwellTime,
+ thresholdValue] = thresholdParam;
return discrete::LabeledThresholdParam(
userId, discrete::toSeverity(severity), dwellTime, thresholdValue);
});
@@ -44,14 +44,14 @@
const std::vector<numeric::LabeledThresholdParam>& arg) const
{
return utils::transform(
- arg, [](const numeric::LabeledThresholdParam& labeledThresholdParam) {
- return numeric::ThresholdParam(
- numeric::typeToString(
- labeledThresholdParam.at_label<ts::Type>()),
- labeledThresholdParam.at_label<ts::DwellTime>(),
- numeric::directionToString(
- labeledThresholdParam.at_label<ts::Direction>()),
- labeledThresholdParam.at_label<ts::ThresholdValue>());
+ arg,
+ [](const numeric::LabeledThresholdParam& labeledThresholdParam) {
+ return numeric::ThresholdParam(
+ numeric::typeToString(labeledThresholdParam.at_label<ts::Type>()),
+ labeledThresholdParam.at_label<ts::DwellTime>(),
+ numeric::directionToString(
+ labeledThresholdParam.at_label<ts::Direction>()),
+ labeledThresholdParam.at_label<ts::ThresholdValue>());
});
}
diff --git a/src/utils/conversion_trigger.hpp b/src/utils/conversion_trigger.hpp
index 8719df2..10b0c03 100644
--- a/src/utils/conversion_trigger.hpp
+++ b/src/utils/conversion_trigger.hpp
@@ -45,8 +45,8 @@
inline constexpr bool is_variant_v = is_variant<T>::value;
template <typename AlternativeT, typename VariantT>
- requires is_variant_v<VariantT> bool
-isFirstElementOfType(const std::vector<VariantT>& collection)
+ requires is_variant_v<VariantT>
+bool isFirstElementOfType(const std::vector<VariantT>& collection)
{
if (collection.empty())
{
diff --git a/src/utils/ensure.hpp b/src/utils/ensure.hpp
index 8c4fc99..8b7567e 100644
--- a/src/utils/ensure.hpp
+++ b/src/utils/ensure.hpp
@@ -15,8 +15,7 @@
Ensure(U&& functor) : functor(std::forward<U>(functor))
{}
- Ensure(F functor) : functor(std::move(functor))
- {}
+ Ensure(F functor) : functor(std::move(functor)) {}
Ensure(Ensure&& other) = delete;
Ensure(const Ensure&) = delete;
diff --git a/src/utils/labeled_tuple.hpp b/src/utils/labeled_tuple.hpp
index c4120c9..b320c3b 100644
--- a/src/utils/labeled_tuple.hpp
+++ b/src/utils/labeled_tuple.hpp
@@ -151,10 +151,8 @@
LabeledTuple(const LabeledTuple&) = default;
LabeledTuple(LabeledTuple&&) = default;
- explicit LabeledTuple(tuple_type v) : value(std::move(v))
- {}
- LabeledTuple(Args... args) : value(std::move(args)...)
- {}
+ explicit LabeledTuple(tuple_type v) : value(std::move(v)) {}
+ LabeledTuple(Args... args) : value(std::move(args)...) {}
LabeledTuple& operator=(const LabeledTuple&) = default;
LabeledTuple& operator=(LabeledTuple&&) = default;
@@ -209,11 +207,9 @@
{
return std::apply(
[&](auto&&... x) {
- return std::apply(
- [&](auto&&... y) {
- return (true && ... && detail::eq(x, y));
- },
- value);
+ return std::apply(
+ [&](auto&&... y) { return (true && ... && detail::eq(x, y)); },
+ value);
},
other.value);
}
diff --git a/src/utils/make_id_name.cpp b/src/utils/make_id_name.cpp
index 1390dad..1148622 100644
--- a/src/utils/make_id_name.cpp
+++ b/src/utils/make_id_name.cpp
@@ -49,19 +49,17 @@
{
strippedId = defaultName;
}
- strippedId.erase(
- std::remove_if(
- strippedId.begin(), strippedId.end(),
- [](char c) {
- return c == '/' ||
- utils::constants::allowedCharactersInPath.find(c) ==
- std::string_view::npos;
- }),
- strippedId.end());
+ strippedId.erase(std::remove_if(
+ strippedId.begin(), strippedId.end(),
+ [](char c) {
+ return c == '/' || utils::constants::allowedCharactersInPath.find(c) ==
+ std::string_view::npos;
+ }),
+ strippedId.end());
size_t idx = 0;
- std::string tmpId =
- prefixes + strippedId.substr(0, constants::maxIdNameLength);
+ std::string tmpId = prefixes +
+ strippedId.substr(0, constants::maxIdNameLength);
while (std::find(conflictIds.begin(), conflictIds.end(), tmpId) !=
conflictIds.end())
diff --git a/src/utils/messanger_service.cpp b/src/utils/messanger_service.cpp
index e04de34..25f154c 100644
--- a/src/utils/messanger_service.cpp
+++ b/src/utils/messanger_service.cpp
@@ -16,11 +16,11 @@
void MessangerService::destroy(MessangerService::Context& context)
{
- contexts_.erase(std::remove_if(contexts_.begin(), contexts_.end(),
- [&context](const auto& item) {
- return item.get() == &context;
- }),
- contexts_.end());
+ contexts_.erase(
+ std::remove_if(
+ contexts_.begin(), contexts_.end(),
+ [&context](const auto& item) { return item.get() == &context; }),
+ contexts_.end());
}
boost::asio::execution_context::id MessangerService::id = {};
diff --git a/src/utils/messanger_service.hpp b/src/utils/messanger_service.hpp
index 86dd2ff..f79bcc7 100644
--- a/src/utils/messanger_service.hpp
+++ b/src/utils/messanger_service.hpp
@@ -20,8 +20,7 @@
MessangerService(boost::asio::execution_context& execution_context);
~MessangerService() = default;
- void shutdown()
- {}
+ void shutdown() {}
Context& create();
void destroy(Context& context);
diff --git a/src/utils/threshold_operations.hpp b/src/utils/threshold_operations.hpp
index 99ae4a5..42d469e 100644
--- a/src/utils/threshold_operations.hpp
+++ b/src/utils/threshold_operations.hpp
@@ -22,10 +22,11 @@
getDetails(ThresholdType* thresholdPtr,
const interfaces::Sensor& sensor)
{
- auto it = std::find_if(
- thresholdPtr->sensorDetails.begin(),
- thresholdPtr->sensorDetails.end(),
- [&sensor](const auto& x) { return &sensor == x.first.get(); });
+ auto it = std::find_if(thresholdPtr->sensorDetails.begin(),
+ thresholdPtr->sensorDetails.end(),
+ [&sensor](const auto& x) {
+ return &sensor == x.first.get();
+ });
return *it->second;
}
diff --git a/tests/src/dbus_environment.hpp b/tests/src/dbus_environment.hpp
index eabb53a..558445e 100644
--- a/tests/src/dbus_environment.hpp
+++ b/tests/src/dbus_environment.hpp
@@ -104,12 +104,12 @@
*DbusEnvironment::getBus(), DbusEnvironment::serviceName(), path,
interfaceName, property,
[&propertyPromise](const boost::system::error_code& ec, T t) {
- if (ec)
- {
- utils::setException(propertyPromise, "GetProperty failed");
- return;
- }
- propertyPromise.set_value(t);
+ if (ec)
+ {
+ utils::setException(propertyPromise, "GetProperty failed");
+ return;
+ }
+ propertyPromise.set_value(t);
});
return DbusEnvironment::waitForFuture(std::move(propertyFuture));
}
@@ -124,9 +124,9 @@
sdbusplus::asio::setProperty(
*DbusEnvironment::getBus(), DbusEnvironment::serviceName(), path,
interfaceName, property, std::move(newValue),
- [promise =
- std::move(promise)](boost::system::error_code ec) mutable {
- promise.set_value(ec);
+ [promise = std::move(promise)](
+ boost::system::error_code ec) mutable {
+ promise.set_value(ec);
});
return DbusEnvironment::waitForFuture(std::move(future));
}
diff --git a/tests/src/helpers/interfaces/json_storage_helpers.hpp b/tests/src/helpers/interfaces/json_storage_helpers.hpp
index b5d4004..f339381 100644
--- a/tests/src/helpers/interfaces/json_storage_helpers.hpp
+++ b/tests/src/helpers/interfaces/json_storage_helpers.hpp
@@ -16,4 +16,4 @@
(*os) << static_cast<std::filesystem::path>(o);
}
-} // namespace interfaces
\ No newline at end of file
+} // namespace interfaces
diff --git a/tests/src/helpers/interfaces/sensor_id_helpers.hpp b/tests/src/helpers/interfaces/sensor_id_helpers.hpp
index 9b59d22..3268e07 100644
--- a/tests/src/helpers/interfaces/sensor_id_helpers.hpp
+++ b/tests/src/helpers/interfaces/sensor_id_helpers.hpp
@@ -19,4 +19,4 @@
std::tie(right.type, right.service, right.path);
}
-} // namespace interfaces
\ No newline at end of file
+} // namespace interfaces
diff --git a/tests/src/helpers/metric_value_helpers.hpp b/tests/src/helpers/metric_value_helpers.hpp
index f21d42a..9634de3 100644
--- a/tests/src/helpers/metric_value_helpers.hpp
+++ b/tests/src/helpers/metric_value_helpers.hpp
@@ -14,4 +14,4 @@
{
return std::tie(left.id, left.metadata, left.value, left.timestamp) ==
std::tie(right.id, right.metadata, right.value, right.timestamp);
-}
\ No newline at end of file
+}
diff --git a/tests/src/mocks/report_factory_mock.hpp b/tests/src/mocks/report_factory_mock.hpp
index a043c09..8af6d5c 100644
--- a/tests/src/mocks/report_factory_mock.hpp
+++ b/tests/src/mocks/report_factory_mock.hpp
@@ -14,12 +14,12 @@
{
return utils::transform(readingParams, [](const auto& params) {
return LabeledMetricParameters(
- utils::transform(std::get<0>(params),
- [](const auto& sensorData) {
- return LabeledSensorInfo(
- "Service", std::get<0>(sensorData),
+ utils::transform(
+ std::get<0>(params),
+ [](const auto& sensorData) {
+ return LabeledSensorInfo("Service", std::get<0>(sensorData),
std::get<1>(sensorData));
- }),
+ }),
utils::toOperationType(std::get<1>(params)),
std::get<2>(params),
utils::toCollectionTimeScope(std::get<3>(params)),
diff --git a/tests/src/mocks/trigger_factory_mock.hpp b/tests/src/mocks/trigger_factory_mock.hpp
index d3d83e5..f1dfa1f 100644
--- a/tests/src/mocks/trigger_factory_mock.hpp
+++ b/tests/src/mocks/trigger_factory_mock.hpp
@@ -73,10 +73,11 @@
return EXPECT_CALL(
*this, make(params.id(), params.name(),
- utils::transform(params.triggerActions(),
- [](const auto& action) {
- return actionToString(action);
- }),
+ utils::transform(
+ params.triggerActions(),
+ [](const auto& action) {
+ return actionToString(action);
+ }),
params.reportIds(), tm, triggerStorage,
params.thresholdParams(), params.sensors()));
}
diff --git a/tests/src/params/trigger_params.hpp b/tests/src/params/trigger_params.hpp
index 9f633b8..b39941c 100644
--- a/tests/src/params/trigger_params.hpp
+++ b/tests/src/params/trigger_params.hpp
@@ -18,10 +18,10 @@
public:
TriggerParams()
{
- reportsProperty =
- utils::transform(reportIdsProperty, [](const auto& id) {
- return utils::pathAppend(utils::constants::reportDirPath, id);
- });
+ reportsProperty = utils::transform(reportIdsProperty,
+ [](const auto& id) {
+ return utils::pathAppend(utils::constants::reportDirPath, id);
+ });
}
TriggerParams& id(std::string_view val)
@@ -70,10 +70,10 @@
TriggerParams& reportIds(std::vector<std::string> val)
{
reportIdsProperty = std::move(val);
- reportsProperty = utils::transform<std::vector>(
- reportIdsProperty, [](const auto& id) {
- return utils::pathAppend(utils::constants::reportDirPath, id);
- });
+ reportsProperty = utils::transform<std::vector>(reportIdsProperty,
+ [](const auto& id) {
+ return utils::pathAppend(utils::constants::reportDirPath, id);
+ });
return *this;
}
diff --git a/tests/src/stubs/dbus_sensor_object.cpp b/tests/src/stubs/dbus_sensor_object.cpp
index b73478e..dbe95ca 100644
--- a/tests/src/stubs/dbus_sensor_object.cpp
+++ b/tests/src/stubs/dbus_sensor_object.cpp
@@ -17,13 +17,12 @@
ioc(ioc),
bus(bus), objServer(objServer)
{
- sensorIface = objServer->add_unique_interface(
- path(), interface(), [this](auto& iface) {
- iface.register_property_r(
- property.value(), value,
- sdbusplus::vtable::property_::emits_change,
- [this](const auto&) { return value; });
- });
+ sensorIface = objServer->add_unique_interface(path(), interface(),
+ [this](auto& iface) {
+ iface.register_property_r(property.value(), value,
+ sdbusplus::vtable::property_::emits_change,
+ [this](const auto&) { return value; });
+ });
}
void DbusSensorObject::setValue(double v)
diff --git a/tests/src/test_discrete_threshold.cpp b/tests/src/test_discrete_threshold.cpp
index 953ddd5..8b9168b 100644
--- a/tests/src/test_discrete_threshold.cpp
+++ b/tests/src/test_discrete_threshold.cpp
@@ -104,8 +104,7 @@
class TestDiscreteThresholdInit : public TestDiscreteThreshold
{
- void SetUp() override
- {}
+ void SetUp() override {}
};
TEST_F(TestDiscreteThresholdInit, nonEmptyNameIsNotChanged)
diff --git a/tests/src/test_metric.cpp b/tests/src/test_metric.cpp
index cd6a6ec..952651c 100644
--- a/tests/src/test_metric.cpp
+++ b/tests/src/test_metric.cpp
@@ -353,8 +353,8 @@
clockFake.advance(timestamp);
}
- const auto [expectedTimestamp, expectedReading] =
- GetParam().expectedReading();
+ const auto [expectedTimestamp,
+ expectedReading] = GetParam().expectedReading();
const auto readings = sut->getUpdatedReadings();
EXPECT_THAT(readings,
@@ -373,8 +373,8 @@
sut->getUpdatedReadings();
}
- const auto [expectedTimestamp, expectedReading] =
- GetParam().expectedReading();
+ const auto [expectedTimestamp,
+ expectedReading] = GetParam().expectedReading();
const auto readings = sut->getUpdatedReadings();
EXPECT_THAT(readings,
diff --git a/tests/src/test_report.cpp b/tests/src/test_report.cpp
index 875bd4b..1d0f0bb 100644
--- a/tests/src/test_report.cpp
+++ b/tests/src/test_report.cpp
@@ -188,7 +188,7 @@
std::promise<boost::system::error_code> methodPromise;
DbusEnvironment::getBus()->async_method_call(
[&methodPromise](boost::system::error_code ec) {
- methodPromise.set_value(ec);
+ methodPromise.set_value(ec);
},
DbusEnvironment::serviceName(), path, interface, method);
return DbusEnvironment::waitForFuture(methodPromise.get_future());
@@ -671,8 +671,7 @@
public TestReport,
public WithParamInterface<std::pair<std::string, nlohmann::json>>
{
- void SetUp() override
- {}
+ void SetUp() override {}
};
INSTANTIATE_TEST_SUITE_P(
@@ -687,7 +686,7 @@
std::make_pair("ReportActions", nlohmann::json(utils::transform(
defaultParams().reportActions(),
[](const auto v) {
- return utils::toUnderlying(v);
+ return utils::toUnderlying(v);
}))),
std::make_pair("Interval",
nlohmann::json(defaultParams().interval().count())),
@@ -754,8 +753,7 @@
public WithParamInterface<ReportParams>
{
public:
- void SetUp() override
- {}
+ void SetUp() override {}
};
INSTANTIATE_TEST_SUITE_P(
@@ -774,8 +772,7 @@
public WithParamInterface<ReportParams>
{
public:
- void SetUp() override
- {}
+ void SetUp() override {}
};
INSTANTIATE_TEST_SUITE_P(InvalidNames, TestReportInvalidIds,
@@ -823,8 +820,8 @@
clockFake.system.advance(10ms);
messanger.send(messages::UpdateReportInd{{sut->getId()}});
- const auto [timestamp, readings] =
- getProperty<Readings>(sut->getPath(), "Readings");
+ const auto [timestamp, readings] = getProperty<Readings>(sut->getPath(),
+ "Readings");
EXPECT_THAT(Milliseconds{timestamp}, Eq(systemTimestamp + 10ms));
}
@@ -835,8 +832,8 @@
setProperty(sut->getPath(), "Enabled", false);
messanger.send(messages::UpdateReportInd{{sut->getId()}});
- const auto [timestamp, readings] =
- getProperty<Readings>(sut->getPath(), "Readings");
+ const auto [timestamp, readings] = getProperty<Readings>(sut->getPath(),
+ "Readings");
EXPECT_THAT(Milliseconds{timestamp}, Eq(0ms));
}
@@ -846,8 +843,8 @@
clockFake.system.advance(10ms);
messanger.send(messages::UpdateReportInd{{sut->getId() + "x"s}});
- const auto [timestamp, readings] =
- getProperty<Readings>(sut->getPath(), "Readings");
+ const auto [timestamp, readings] = getProperty<Readings>(sut->getPath(),
+ "Readings");
EXPECT_THAT(Milliseconds{timestamp}, Eq(0ms));
}
@@ -867,8 +864,8 @@
ASSERT_THAT(update(sut->getPath()), Eq(boost::system::errc::success));
- const auto [timestamp, readings] =
- getProperty<Readings>(sut->getPath(), "Readings");
+ const auto [timestamp, readings] = getProperty<Readings>(sut->getPath(),
+ "Readings");
EXPECT_THAT(Milliseconds{timestamp}, Eq(systemTimestamp + 10ms));
}
@@ -877,8 +874,8 @@
{
ASSERT_THAT(update(sut->getPath()), Eq(boost::system::errc::success));
- const auto [timestamp, readings] =
- getProperty<Readings>(sut->getPath(), "Readings");
+ const auto [timestamp, readings] = getProperty<Readings>(sut->getPath(),
+ "Readings");
EXPECT_THAT(readings,
ElementsAre(std::make_tuple("a"s, "b"s, 17.1, 114u),
@@ -948,8 +945,8 @@
clockFake.system.advance(10ms);
DbusEnvironment::sleepFor(ReportManager::minInterval + 1ms);
- const auto [timestamp, readings] =
- getProperty<Readings>(sut->getPath(), "Readings");
+ const auto [timestamp, readings] = getProperty<Readings>(sut->getPath(),
+ "Readings");
EXPECT_THAT(Milliseconds{timestamp}, Eq(systemTimestamp + 10ms));
}
@@ -958,8 +955,8 @@
{
DbusEnvironment::sleepFor(ReportManager::minInterval + 1ms);
- const auto [timestamp, readings] =
- getProperty<Readings>(sut->getPath(), "Readings");
+ const auto [timestamp, readings] = getProperty<Readings>(sut->getPath(),
+ "Readings");
EXPECT_THAT(readings,
ElementsAre(std::make_tuple("a"s, "b"s, 17.1, 114u),
@@ -978,8 +975,7 @@
public WithParamInterface<ReportUpdatesReportParams>
{
public:
- void SetUp() override
- {}
+ void SetUp() override {}
void changeReport(ReportingType rt, Milliseconds interval)
{
@@ -990,8 +986,8 @@
auto readings()
{
- auto [timestamp, readings] =
- getProperty<Readings>(sut->getPath(), "Readings");
+ auto [timestamp, readings] = getProperty<Readings>(sut->getPath(),
+ "Readings");
return readings;
}
@@ -1285,8 +1281,8 @@
{
messanger.on_receive<messages::CollectTriggerIdReq>(
[this, triggerId](const auto& msg) {
- messanger.send(messages::CollectTriggerIdResp{triggerId});
- });
+ messanger.send(messages::CollectTriggerIdResp{triggerId});
+ });
}
sut = makeReport(ReportParams());
diff --git a/tests/src/test_report_manager.cpp b/tests/src/test_report_manager.cpp
index 51140b7..fc394ae 100644
--- a/tests/src/test_report_manager.cpp
+++ b/tests/src/test_report_manager.cpp
@@ -67,7 +67,7 @@
DbusEnvironment::getBus()->async_method_call(
[&addReportPromise](boost::system::error_code ec,
const std::string& path) {
- addReportPromise.set_value({ec, path});
+ addReportPromise.set_value({ec, path});
},
DbusEnvironment::serviceName(), ReportManager::reportManagerPath,
ReportManager::reportManagerIfaceName, "AddReportFutureVersion",
@@ -88,11 +88,11 @@
utils::enumToString(params.reportUpdates()));
properties.emplace_back("AppendLimit", params.appendLimit());
properties.emplace_back("Enabled", params.enabled());
- properties.emplace_back(
- "ReportActions",
- utils::transform(params.reportActions(), [](const auto v) {
- return utils::enumToString(v);
- }));
+ properties.emplace_back("ReportActions",
+ utils::transform(params.reportActions(),
+ [](const auto v) {
+ return utils::enumToString(v);
+ }));
properties.emplace_back("Interval", params.interval().count());
properties.emplace_back("ReadingParameters",
toReadingParameters(params.metricParameters()));
diff --git a/tests/src/test_sensor_cache.cpp b/tests/src/test_sensor_cache.cpp
index b59a062..218e160 100644
--- a/tests/src/test_sensor_cache.cpp
+++ b/tests/src/test_sensor_cache.cpp
@@ -59,10 +59,10 @@
TEST_P(TestSensorCacheP, shouldReturnDifferentSensorWhenIdsAreDifferent)
{
- auto sensor1 =
- sut.makeSensor<NiceMock<SensorMock>>(id<0>().service, id<0>().path);
- auto sensor2 =
- sut.makeSensor<NiceMock<SensorMock>>(id<1>().service, id<1>().path);
+ auto sensor1 = sut.makeSensor<NiceMock<SensorMock>>(id<0>().service,
+ id<0>().path);
+ auto sensor2 = sut.makeSensor<NiceMock<SensorMock>>(id<1>().service,
+ id<1>().path);
ASSERT_THAT(sensor1.get(), Not(Eq(sensor2.get())));
ASSERT_THAT(sensor1->mockId, Not(Eq(sensor2->mockId)));
@@ -70,10 +70,10 @@
TEST_F(TestSensorCache, shouldReturnSameSensorWhenSensorWithSameIdStillExists)
{
- auto sensor1 =
- sut.makeSensor<NiceMock<SensorMock>>("sensor-service", "sensor-path");
- auto sensor2 =
- sut.makeSensor<NiceMock<SensorMock>>("sensor-service", "sensor-path");
+ auto sensor1 = sut.makeSensor<NiceMock<SensorMock>>("sensor-service",
+ "sensor-path");
+ auto sensor2 = sut.makeSensor<NiceMock<SensorMock>>("sensor-service",
+ "sensor-path");
ASSERT_THAT(sensor1.get(), Eq(sensor2.get()));
ASSERT_THAT(sensor1->mockId, Eq(sensor2->mockId));
@@ -81,21 +81,21 @@
TEST_F(TestSensorCache, shouldReturnDifferentSensorWhenPreviousSensorExpired)
{
- auto mockId1 =
- sut.makeSensor<NiceMock<SensorMock>>("sensor-service", "sensor-path")
- ->mockId;
- auto mockId2 =
- sut.makeSensor<NiceMock<SensorMock>>("sensor-service", "sensor-path")
- ->mockId;
+ auto mockId1 = sut.makeSensor<NiceMock<SensorMock>>("sensor-service",
+ "sensor-path")
+ ->mockId;
+ auto mockId2 = sut.makeSensor<NiceMock<SensorMock>>("sensor-service",
+ "sensor-path")
+ ->mockId;
ASSERT_THAT(mockId2, Not(Eq(mockId1)));
}
TEST_F(TestSensorCache, shouldCreateSensorWithCorrespondingId)
{
- auto id =
- sut.makeSensor<NiceMock<SensorMock>>("sensor-service", "sensor-path")
- ->id();
+ auto id = sut.makeSensor<NiceMock<SensorMock>>("sensor-service",
+ "sensor-path")
+ ->id();
auto expected = SensorMock::makeId("sensor-service", "sensor-path");
diff --git a/tests/src/test_trigger.cpp b/tests/src/test_trigger.cpp
index 9db2632..f55dec1 100644
--- a/tests/src/test_trigger.cpp
+++ b/tests/src/test_trigger.cpp
@@ -140,7 +140,7 @@
std::promise<boost::system::error_code> methodPromise;
DbusEnvironment::getBus()->async_method_call(
[&methodPromise](boost::system::error_code ec) {
- methodPromise.set_value(ec);
+ methodPromise.set_value(ec);
},
DbusEnvironment::serviceName(), path, Trigger::deleteIfaceName,
"Delete");
@@ -155,9 +155,10 @@
EXPECT_THAT(getProperty<bool>(sut->getPath(), "Persistent"), Eq(true));
EXPECT_THAT(
getProperty<std::vector<std::string>>(sut->getPath(), "TriggerActions"),
- Eq(utils::transform(
- triggerParams.triggerActions(),
- [](const auto& action) { return actionToString(action); })));
+ Eq(utils::transform(triggerParams.triggerActions(),
+ [](const auto& action) {
+ return actionToString(action);
+ })));
EXPECT_THAT((getProperty<SensorsInfo>(sut->getPath(), "Sensors")),
Eq(utils::fromLabeledSensorsInfo(triggerParams.sensors())));
EXPECT_THAT(
@@ -442,8 +443,7 @@
class TestTriggerInitialization : public TestTrigger
{
public:
- void SetUp() override
- {}
+ void SetUp() override {}
nlohmann::json storedConfiguration;
};
@@ -516,8 +516,8 @@
ASSERT_THAT(storedConfiguration.at("TriggerActions"),
Eq(utils::transform(triggerParams.triggerActions(),
[](const auto& action) {
- return actionToString(action);
- })));
+ return actionToString(action);
+ })));
}
TEST_F(TestTriggerStore, settingPersistencyToTrueStoresTriggerReportIds)
diff --git a/tests/src/test_trigger_actions.cpp b/tests/src/test_trigger_actions.cpp
index 42488aa..8711378 100644
--- a/tests/src/test_trigger_actions.cpp
+++ b/tests/src/test_trigger_actions.cpp
@@ -249,8 +249,7 @@
class TestUpdateReport : public Test
{
public:
- TestUpdateReport() : messanger(DbusEnvironment::getIoc())
- {}
+ TestUpdateReport() : messanger(DbusEnvironment::getIoc()) {}
void make(std::vector<std::string> names)
{
diff --git a/tests/src/test_trigger_manager.cpp b/tests/src/test_trigger_manager.cpp
index 48c76ea..03ec5ce 100644
--- a/tests/src/test_trigger_manager.cpp
+++ b/tests/src/test_trigger_manager.cpp
@@ -30,7 +30,7 @@
DbusEnvironment::getBus()->async_method_call(
[&addTriggerPromise](boost::system::error_code ec,
const std::string& path) {
- addTriggerPromise.set_value({ec, path});
+ addTriggerPromise.set_value({ec, path});
},
DbusEnvironment::serviceName(), TriggerManager::triggerManagerPath,
TriggerManager::triggerManagerIfaceName, "AddTrigger", params.id(),
@@ -465,10 +465,10 @@
{"Name", TriggerParams().name()},
{"ThresholdParamsDiscriminator",
TriggerParams().thresholdParams().index()},
- {"TriggerActions", utils::transform(TriggerParams().triggerActions(),
- [](const auto& action) {
- return actionToString(action);
- })},
+ {"TriggerActions",
+ utils::transform(
+ TriggerParams().triggerActions(),
+ [](const auto& action) { return actionToString(action); })},
{"ThresholdParams", utils::labeledThresholdParamsToJson(
TriggerParams().thresholdParams())},
{"ReportIds", TriggerParams().reportIds()},
diff --git a/tests/src/utils/string_utils.cpp b/tests/src/utils/string_utils.cpp
index a39afca..f85f441 100644
--- a/tests/src/utils/string_utils.cpp
+++ b/tests/src/utils/string_utils.cpp
@@ -71,4 +71,4 @@
{
return details::getStringWithSpaces(constants::maxIdNameLength + 1);
}
-} // namespace utils::string_utils
\ No newline at end of file
+} // namespace utils::string_utils
diff --git a/tests/src/utils/string_utils.hpp b/tests/src/utils/string_utils.hpp
index 90f802c..8dcf9dc 100644
--- a/tests/src/utils/string_utils.hpp
+++ b/tests/src/utils/string_utils.hpp
@@ -10,4 +10,4 @@
std::string getTooLongPrefix();
std::string getTooLongId();
std::string getTooLongName();
-} // namespace utils::string_utils
\ No newline at end of file
+} // namespace utils::string_utils