HootTelemetryBackend.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 <wpi/telemetry/TelemetryBackend.hpp>
#include <map>
#include <mutex>
 
namespace ctre {
namespace phoenix6 {
 
    /**
     * \brief A telemetry backend implementation that saves information to a CTRE hoot
     * file on disk using the Phoenix 6 SignalLogger.
     */
    class HootTelemetryBackend final : public wpi::telemetry::TelemetryBackend {
        class Entry;
 
        std::string prefix;
 
        std::mutex entriesLock;
        std::map<std::string, std::shared_ptr<Entry>, std::less<>> entries;
 
    public:
        /**
         * \brief Creates a new hoot telemetry backend. This immediately starts
         * the SignalLogger and automatically stops it once all instances are
         * destroyed.
         *
         * This will use the default path documented in SignalLogger#SetPath.
         *
         * \param prefix Prefix to prepend to all log entry names; defaults empty
         */
        HootTelemetryBackend(std::string prefix = "");
 
        /**
         * \brief Creates a new hoot telemetry backend with the target file path.
         * This immediately starts the SignalLogger and automatically stops it
         * once all instances are destroyed.
         *
         * \param prefix Prefix to prepend to all log entry names; defaults empty
         * \param path Folder path for the log files; path must exist
         */
        HootTelemetryBackend(std::string prefix, char const *path);
 
        ~HootTelemetryBackend();
 
        /**
         * \brief Create an entry for the given path.
         *
         * \param path full name
         * \returns telemetry entry
         */
        std::shared_ptr<wpi::telemetry::TelemetryEntry> GetEntry(std::string_view path) override;
        /**
         * \brief Removes an entry for the given path.
         *
         * \param path normalized full name
         */
        void RemoveEntry(std::string_view path) override;
 
        /**
         * \brief Returns whether there is a data schema already registered with the given
         * name. This does NOT perform a check as to whether the schema has already
         * been published by another node on the network.
         *
         * \param schemaName Name (the string passed as the data type for topics using
         *                   this schema)
         * \returns True if schema already registered
         */
        bool HasSchema(std::string_view schemaName) const override;
        /**
         * \brief Registers a data schema.  Data schemas provide information for how a
         * certain data type string can be decoded. The type string of a data schema
         * indicates the type of the schema itself (e.g. "protobuf" for protobuf
         * schemas, "struct" for struct schemas, etc). Duplicate calls to this function
         * with the same name are silently ignored.
         *
         * \param schemaName Name (the string passed as the data type for topics using
         *                   this schema)
         * \param type Type of schema (e.g. "protobuf", "struct", etc)
         * \param schema Schema data
         */
        void AddSchema(std::string_view schemaName, std::string_view type, std::span<uint8_t const> schema) override;
        /**
         * \brief Registers a data schema.  Data schemas provide information for how a
         * certain data type string can be decoded. The type string of a data schema
         * indicates the type of the schema itself (e.g. "protobuf" for protobuf
         * schemas, "struct" for struct schemas, etc). Duplicate calls to this function
         * with the same name are silently ignored.
         *
         * \param schemaName Name (the string passed as the data type for topics using
         *                   this schema)
         * \param type Type of schema (e.g. "protobuf", "struct", etc)
         * \param schema Schema data
         */
        void AddSchema(std::string_view schemaName, std::string_view type, std::string_view schema) override;
    };
 
}
}