blob: 3e18e20eb7851b2b7dc283586ea0ac34faa522ca [file] [log] [blame]
#pragma once
#include "callback.hpp"
#include "data_types.hpp"
#include <algorithm>
#include <functional>
namespace phosphor
{
namespace dbus
{
namespace monitoring
{
/** @class CountCondition
* @brief Count properties that satisfy a condition.
*
* When invoked, a count class instance performs its condition
* test in two passes.
*
* In pass one, apply a C++ relational operator to the value of
* each property in the index and a value provided by the
* configuration file.
*
* Count the number of properties that pass the test in pass
* one. In pass two, apply a second C++ relational operator
* to the number of properties that pass the test from pass one
* to a count provided by the configuration file.
*
* If the oneshot parameter is true, then this condition won't pass
* again until it fails at least once.
*/
template <typename T>
class CountCondition : public IndexedConditional
{
public:
CountCondition() = delete;
CountCondition(const CountCondition&) = default;
CountCondition(CountCondition&&) = default;
CountCondition& operator=(const CountCondition&) = default;
CountCondition& operator=(CountCondition&&) = default;
~CountCondition() = default;
CountCondition(const PropertyIndex& conditionIndex,
const std::function<bool(size_t)>& _countOp,
const std::function<bool(T)>& _propertyOp,
bool oneshot = false) :
IndexedConditional(conditionIndex),
countOp(_countOp), propertyOp(_propertyOp), oneshot(oneshot)
{
}
bool operator()() override
{
// Count the number of properties in the index that
// pass the condition specified in the config file.
auto count = std::count_if(
index.cbegin(), index.cend(),
[this](const auto& item)
// *INDENT-OFF*
{
// Get the property value from storage[0],
// and save the op result in storage[1].
const auto& storage = std::get<storageIndex>(item.second);
// Don't count properties that don't exist.
if (std::get<valueIndex>(storage.get()).empty())
{
return false;
}
const auto& value =
any_ns::any_cast<T>(std::get<valueIndex>(storage.get()));
auto r = propertyOp(value);
std::get<resultIndex>(storage.get()) = r;
return r;
});
// *INDENT-ON*
// Now apply the count condition to the count.
auto result = countOp(count);
// If this was a oneshot and the the condition has already
// passed, then don't let it pass again until the condition
// has gone back to false.
if (oneshot && result && lastResult)
{
return false;
}
lastResult = result;
return result;
}
private:
/** @brief The comparison to perform on the count. */
std::function<bool(size_t)> countOp;
/** @brief The comparison to perform on each property. */
std::function<bool(T)> propertyOp;
/** @brief If the condition can be allowed to pass again
on subsequent checks that are also true. */
const bool oneshot;
/** @brief The result of the previous check. */
bool lastResult = false;
};
} // namespace monitoring
} // namespace dbus
} // namespace phosphor