ControlRequest.hpp

Go to the documentation of this file.

/*
 * Copyright (C) Cross The Road Electronics.  All rights reserved.
 * License information can be found in CTRE_LICENSE.txt
 * For support and suggestions contact support@ctr-electronics.com or file
 * an issue tracker at https://github.com/CrossTheRoadElec/Phoenix-Releases
 */
#pragma once
 
#include <map>
#include <memory>
#include <sstream>
#include <string>
 
namespace ctre {
namespace phoenixpro {
 
namespace hardware {
    class ParentDevice;
}
 
namespace controls {
 
    /**
     * \brief Information about a control request.
     *
     * This type contains a map that maps control parameter names to
     * the corresponding applied value. Users can iterate through the map
     * to look at the applied control parameters of the control request.
     */
    class ControlInfo
    {
        std::map<std::string, std::string> values{};
 
    public:
        /**
         * \brief Constructs a new ControlInfo object for the control request of the given name.
         *
         * This is constructed by the ControlRequest class and can be accessed by calling ControlRequest#GetControlInfo.
         *
         * \param name Name of the control request
         */
        ControlInfo(std::string name)
        {
            values["name"] = std::move(name);
        }
 
        /**
         * \brief Gets the map of control parameter names to the corresponding applied value.
         *
         * \returns Map of control parameter names and corresponding applied values
         */
        std::map<std::string, std::string> &GetNameValues() { return values; }
        /**
         * \brief Gets the map of control parameter names to the corresponding applied value.
         *
         * \returns Map of control parameter names and corresponding applied values
         */
        const std::map<std::string, std::string> &GetNameValues() const { return values; }
    };
 
    /**
     * \brief Abstract Control Request class that other control requests extend for use.
     */
    class ControlRequest
    {
        friend hardware::ParentDevice;
        virtual ctre::phoenix::StatusCode SendRequest(const char *network, uint32_t deviceHash, bool cancelOtherRequests, std::shared_ptr<ControlRequest> &req) = 0;
 
    protected:
        ControlInfo requestReference;
 
        /* don't allow copy and move of the base class, only derived classes */
        ControlRequest(ControlRequest const &) = default;
        ControlRequest(ControlRequest &&) = default;
        ControlRequest &operator=(ControlRequest const &) = default;
        ControlRequest &operator=(ControlRequest &&) = default;
 
    public:
        /**
         * \brief Constructs a new Control Request with the given name.
         *
         * \param name Name of the control request
         */
        ControlRequest(std::string name) : requestReference{std::move(name)}
        {
        }
 
        /**
         * \brief Gets information about this control request.
         *
         * \returns An instance of ControlInfo containing information about this control request
         */
        ControlInfo &GetControlInfo()
        {
            return requestReference;
        }
        /**
         * \brief Gets information about this control request.
         *
         * \returns An instance of ControlInfo containing information about this control request
         */
        const ControlInfo &GetControlInfo() const
        {
            return requestReference;
        }
 
        virtual ~ControlRequest() = default;
        virtual std::string ToString() const = 0;
    };
 
    /**
     * \brief Generic Empty Control class used to do nothing.
     */
    class EmptyControl : public ControlRequest
    {
        ctre::phoenix::StatusCode SendRequest(const char *network, uint32_t deviceHash, bool cancelOtherRequests, std::shared_ptr<ControlRequest> &req)
        {
            (void)network;
            (void)deviceHash;
            (void)cancelOtherRequests;
 
            if (req.get() != this)
            {
                auto const reqCast = dynamic_cast<EmptyControl *>(req.get());
                if (reqCast != nullptr)
                {
                    *reqCast = *this;
                }
                else
                {
                    req = std::make_shared<EmptyControl>(*this);
                }
            }
 
            return 0;
        }
 
    public:
        /**
         * \brief Constructs an empty control request.
         */
        EmptyControl() : ControlRequest{"EmptyControl"}
        {
        }
 
        std::string ToString() const
        {
            std::stringstream ss;
            ss << "class: EmptyControl" << std::endl;
            return ss.str();
        }
    };
 
}
 
}
}