.. _program_listing_file_src_tap_control_remote_map_state.cpp:

Program Listing for File remote_map_state.cpp
=============================================

|exhale_lsh| :ref:`Return to documentation for file <file_src_tap_control_remote_map_state.cpp>` (``src/tap/control/remote_map_state.cpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   /*
    * Copyright (c) 2020-2021 Advanced Robotics at the University of Washington <robomstr@uw.edu>
    *
    * This file is part of Taproot.
    *
    * Taproot is free software: you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
    * the Free Software Foundation, either version 3 of the License, or
    * (at your option) any later version.
    *
    * Taproot is distributed in the hope that it will be useful,
    * but WITHOUT ANY WARRANTY; without even the implied warranty of
    * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    * GNU General Public License for more details.
    *
    * You should have received a copy of the GNU General Public License
    * along with Taproot.  If not, see <https://www.gnu.org/licenses/>.
    */
   
   #include "remote_map_state.hpp"
   
   #include <numeric>
   
   #include "tap/errors/create_errors.hpp"
   
   using namespace tap::communication::serial;
   
   namespace tap
   {
   namespace control
   {
   RemoteMapState::RemoteMapState(
       tap::communication::serial::Remote::SwitchState leftss,
       tap::communication::serial::Remote::SwitchState rightss,
       const std::list<tap::communication::serial::Remote::Key> &keySet,
       const std::list<tap::communication::serial::Remote::Key> &negKeySet,
       bool mouseButtonLeftPressed,
       bool mouseButtonRightPressed)
   {
       initLSwitch(leftss);
       initRSwitch(rightss);
       initKeys(keySet);
       initNegKeys(negKeySet);
       if (mouseButtonLeftPressed)
       {
           initLMouseButton();
       }
       if (mouseButtonRightPressed)
       {
           initRMouseButton();
       }
   }
   
   RemoteMapState::RemoteMapState(Remote::Switch swh, Remote::SwitchState switchState)
   {
       if (swh == Remote::Switch::LEFT_SWITCH)
       {
           initLSwitch(switchState);
       }
       else
       {
           initRSwitch(switchState);
       }
   }
   
   RemoteMapState::RemoteMapState(Remote::SwitchState leftss, Remote::SwitchState rightss)
   {
       initLSwitch(leftss);
       initRSwitch(rightss);
   }
   
   RemoteMapState::RemoteMapState(
       const std::list<Remote::Key> &keySet,
       const std::list<Remote::Key> &negKeySet)
   {
       initKeys(keySet);
       initNegKeys(negKeySet);
   }
   
   RemoteMapState::RemoteMapState(
       RemoteMapState::MouseButton button,
       const std::list<Remote::Key> &keySet,
       const std::list<Remote::Key> &negKeySet)
   {
       if (button == MouseButton::LEFT)
       {
           initLMouseButton();
       }
       else
       {
           initRMouseButton();
       }
       initKeys(keySet);
       initNegKeys(negKeySet);
   }
   
   RemoteMapState::RemoteMapState(MouseButton button)
   {
       if (button == MouseButton::LEFT)
       {
           initLMouseButton();
       }
       else
       {
           initRMouseButton();
       }
   }
   
   void RemoteMapState::initLSwitch(Remote::SwitchState ss)
   {
       if (ss == Remote::SwitchState::UNKNOWN)
       {
           return;
       }
       lSwitch = ss;
   }
   
   void RemoteMapState::initRSwitch(Remote::SwitchState ss)
   {
       if (ss == Remote::SwitchState::UNKNOWN)
       {
           return;
       }
       rSwitch = ss;
   }
   
   void RemoteMapState::initKeys(uint16_t keys)
   {
       if (keys == 0)
       {
           return;
       }
       if ((this->negKeys & keys) != 0)
       {
           return;
       }
       this->keys = keys;
   }
   
   void RemoteMapState::initNegKeys(uint16_t negKeys)
   {
       if (negKeys == 0)
       {
           return;
       }
       if ((this->keys & negKeys) != 0)
       {
           return;
       }
       this->negKeys = negKeys;
   }
   
   void RemoteMapState::initKeys(const std::list<Remote::Key> &keySet)
   {
       uint16_t keys = std::accumulate(
           keySet.begin(),
           keySet.end(),
           0,
           [](int acc, Remote::Key key) { return acc |= 1 << static_cast<uint16_t>(key); });
       initKeys(keys);
   }
   
   void RemoteMapState::initNegKeys(const std::list<Remote::Key> &negKeySet)
   {
       // extract a bit form of the key set.
       uint16_t negKeys = std::accumulate(
           negKeySet.begin(),
           negKeySet.end(),
           0,
           [](int acc, Remote::Key key) { return acc |= 1 << static_cast<uint16_t>(key); });
       initNegKeys(negKeys);
   }
   
   void RemoteMapState::initLMouseButton() { lMouseButton = true; }
   
   void RemoteMapState::initRMouseButton() { rMouseButton = true; }
   
   bool RemoteMapState::stateSubsetOf(const RemoteMapState &other) const
   {
       if (rSwitch != Remote::SwitchState::UNKNOWN && rSwitch != other.rSwitch)
       {
           return false;
       }
       if (lSwitch != Remote::SwitchState::UNKNOWN && lSwitch != other.lSwitch)
       {
           return false;
       }
       if ((keys & other.keys) != keys)
       {
           return false;
       }
       if (lMouseButton && other.lMouseButton != lMouseButton)
       {
           return false;
       }
       if (rMouseButton && other.rMouseButton != rMouseButton)
       {
           return false;
       }
       return true;
   }
   
   bool operator==(const RemoteMapState &rms1, const RemoteMapState &rms2)
   {
       return rms1.lSwitch == rms2.lSwitch && rms1.rSwitch == rms2.rSwitch && rms1.keys == rms2.keys &&
              rms1.negKeys == rms2.negKeys && rms1.lMouseButton == rms2.lMouseButton &&
              rms1.rMouseButton == rms2.rMouseButton;
   }
   
   bool operator!=(const RemoteMapState &rms1, const RemoteMapState &rms2) { return !(rms1 == rms2); }
   
   }  // namespace control
   }  // namespace tap