presence: Add any of redundancy policy

Add a bitwise logical or redundancy policy implementation
(fan is present if any sensor indicates as such).

Change-Id: I1d161478a4a6fe9d5690a385703e41c6fff9c81c
Signed-off-by: Brad Bishop <bradleyb@fuzziesquirrel.com>

3 files changed, 154 insertions, 0 deletions

diff --git a/presence/Makefile.am b/presence/Makefile.am
index e144858..b51563d 100644
--- a/presence/Makefile.am
+++ b/presence/Makefile.am
@@ -5,6 +5,7 @@ sbin_PROGRAMS = \
 	phosphor-fan-presence-tach
 
 phosphor_fan_presence_tach_SOURCES = \
+	anyof.cpp \
 	fallback.cpp \
 	fan.cpp \
 	gpio.cpp \
diff --git a/presence/anyof.cpp b/presence/anyof.cpp
new file mode 100644
index 0000000..4dbf356
--- /dev/null
+++ b/presence/anyof.cpp
@@ -0,0 +1,78 @@
+/**
+ * Copyright © 2017 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <algorithm>
+#include <phosphor-logging/log.hpp>
+#include "anyof.hpp"
+#include "fan.hpp"
+#include "psensor.hpp"
+
+namespace phosphor
+{
+namespace fan
+{
+namespace presence
+{
+AnyOf::AnyOf(
+        const Fan& fan,
+        const std::vector<std::reference_wrapper<PresenceSensor>>& s)
+        : RedundancyPolicy(fan),
+        state()
+{
+    for (auto& sensor: s)
+    {
+        state.emplace_back(sensor, false);
+    }
+}
+
+void AnyOf::stateChanged(bool present, PresenceSensor& sensor)
+{
+    // Find the sensor that changed state.
+    auto sit = std::find_if(
+            state.begin(),
+            state.end(),
+            [&sensor](const auto& s){ return std::get<0>(s).get() == sensor; });
+    if (sit != state.end())
+    {
+        // Update our cache of the sensors state and re-evaluate.
+        std::get<bool>(*sit) = present;
+        auto newState = std::any_of(
+                state.begin(),
+                state.end(),
+                [](const auto& s){ return std::get<bool>(s); });
+        setPresence(fan, newState);
+    }
+}
+
+void AnyOf::monitor()
+{
+    // Start all sensors in the anyof redundancy set.
+
+    for (auto& s: state)
+    {
+        auto &sensor = std::get<0>(s);
+        std::get<bool>(s) = sensor.get().start();
+    }
+
+    auto present = std::any_of(
+            state.begin(),
+            state.end(),
+            [](const auto& s){ return std::get<bool>(s); });
+    setPresence(fan, present);
+}
+
+} // namespace presence
+} // namespace fan
+} // namespace phosphor
diff --git a/presence/anyof.hpp b/presence/anyof.hpp
new file mode 100644
index 0000000..70ddb43
--- /dev/null
+++ b/presence/anyof.hpp
@@ -0,0 +1,75 @@
+#pragma once
+
+#include <functional>
+#include <vector>
+#include "fan.hpp"
+#include "rpolicy.hpp"
+
+namespace phosphor
+{
+namespace fan
+{
+namespace presence
+{
+
+class PresenceSensor;
+
+/**
+ * @class AnyOf
+ * @brief AnyOf redundancy policy.
+ *
+ * The any of redundancy policy monitors all sensor
+ * states in the redundancy set and reports true when any
+ * sensor in the set reports true.
+ */
+class AnyOf : public RedundancyPolicy
+{
+    public:
+        AnyOf() = delete;
+        AnyOf(const AnyOf&) = default;
+        AnyOf& operator=(const AnyOf&) = default;
+        AnyOf(AnyOf&&) = default;
+        AnyOf& operator=(AnyOf&&) = default;
+        ~AnyOf() = default;
+
+        /**
+         * @brief Construct an any of bitwise policy.
+         *
+         * @param[in] fan - The fan associated with the policy.
+         * @param[in] s - The set of sensors associated with the policy.
+         */
+        AnyOf(
+                const Fan& fan,
+                const std::vector<std::reference_wrapper<PresenceSensor>>& s);
+
+        /**
+         * @brief stateChanged
+         *
+         * Update the inventory and execute the fallback
+         * policy.
+         *
+         * @param[in] present - The new presence state according
+         *             to the specified sensor.
+         * @param[in] sensor - The sensor reporting the new state.
+         */
+        void stateChanged(bool present, PresenceSensor& sensor) override;
+
+        /**
+         * @brief monitor
+         *
+         * Start monitoring the fan.
+         */
+        void monitor() override;
+
+    private:
+
+        /** @brief All presence sensors in the redundancy set. */
+        std::vector<
+            std::tuple<
+                std::reference_wrapper<PresenceSensor>,
+                bool>> state;
+};
+
+} // namespace presence
+} // namespace fan
+} // namespace phosphor