datarefs.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2013 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
#ifndef SWIFT_SIM_XSWIFTBUS_DATAREFS_H
#define SWIFT_SIM_XSWIFTBUS_DATAREFS_H
 
 
#include <XPLM/XPLMDataAccess.h>
#include <XPLM/XPLMUtilities.h>
 
#include <algorithm>
#include <array>
#include <cassert>
#include <cstring>
#include <string>
 
// Avoid checking large auto-generated header with cppcheck
#ifndef CPPCHECK
#    include "datarefs.inc"
#endif
 
namespace XSwiftBus
{
 
    class DataRefImpl
    {
    public:
        DataRefImpl(char const *name) : m_ref(XPLMFindDataRef(name))
        {
            if (!m_ref)
            {
                XPLMDebugString("Missing dataref:");
                XPLMDebugString(name);
                XPLMDebugString("\n");
            }
        }
 
        bool isValid() const { return m_ref; }
 
        template <typename T>
        void implSet(T);
 
        template <typename T>
        T implGet() const;
 
    private:
        XPLMDataRef m_ref;
    };
 
    class ArrayDataRefImpl
    {
    public:
        ArrayDataRefImpl(char const *name, int size) : m_ref(XPLMFindDataRef(name)), m_size(size)
        {
            if (!m_ref)
            {
                XPLMDebugString("Missing dataref:");
                XPLMDebugString(name);
                XPLMDebugString("\n");
            }
        }
 
        bool isValid() const { return m_ref; }
 
        template <typename T>
        void implSetAll(T *const);
 
        template <typename T>
        void implGetAll(T *) const;
 
        template <typename T>
        void implSetAt(int index, T);
 
        template <typename T>
        T implGetAt(int index) const;
 
    private:
        XPLMDataRef m_ref;
        int const m_size;
    };
 
    template <class DataRefTraits>
    class DataRef : private DataRefImpl
    {
        static_assert(!DataRefTraits::is_array, "this is an array dataref");
 
    public:
        DataRef() : DataRefImpl(DataRefTraits::name()) {}
 
        using TraitsType = DataRefTraits;
 
        using DataRefType = typename DataRefTraits::type;
 
        void set(DataRefType d)
        {
            static_assert(DataRefTraits::writable, "read-only dataref");
            DataRefImpl::implSet(d);
        }
 
        void setAsInt(int d) { this->set(static_cast<DataRefType>(d)); }
 
        void setAsDouble(double d) { this->set(static_cast<DataRefType>(d)); }
 
        DataRefType get() const { return DataRefImpl::implGet<DataRefType>(); }
 
        using DataRefImpl::isValid;
    };
 
    template <class DataRefTraits>
    class ArrayDataRef : private ArrayDataRefImpl
    {
        static_assert(DataRefTraits::is_array, "not an array dataref");
 
    public:
        ArrayDataRef() : ArrayDataRefImpl(DataRefTraits::name(), DataRefTraits::size) {}
 
        using TraitsType = DataRefTraits;
 
        using DataRefType = typename DataRefTraits::type;
 
        static constexpr auto DataRefSize = DataRefTraits::size;
 
        void setAll(std::array<DataRefType, DataRefSize> const &a)
        {
            static_assert(DataRefTraits::writable, "read-only dataref");
            ArrayDataRefImpl::implSetAll<DataRefType>(a.data());
        }
 
        std::array<DataRefType, DataRefSize> getAll() const
        {
            std::array<DataRefType, DataRefSize> result;
            ArrayDataRefImpl::implGetAll<DataRefType>(result.data());
            return result;
        }
 
        void setAt(int index, DataRefType d)
        {
            static_assert(DataRefTraits::writable, "read-only dataref");
            ArrayDataRefImpl::implSetAt(index, d);
        }
 
        DataRefType getAt(int index) const { return ArrayDataRefImpl::implGetAt<DataRefType>(index); }
 
        using ArrayDataRefImpl::isValid;
    };
 
    template <class DataRefTraits>
    class StringDataRef
    {
        static_assert(DataRefTraits::is_array, "not an array dataref");
 
    public:
        StringDataRef() : m_ref(XPLMFindDataRef(DataRefTraits::name()))
        {
            if (!m_ref)
            {
                XPLMDebugString("Missing dataref:");
                XPLMDebugString(DataRefTraits::name());
                XPLMDebugString("\n");
            }
        }
 
        bool isValid() const { return m_ref; }
 
        void set(std::string const &s) { setSubstr(0, s); }
 
        std::string get() const { return getSubstr(0, DataRefTraits::size); }
 
        void setSubstr(size_t offset, std::string const &s)
        {
            static_assert(DataRefTraits::writable, "read-only dataref");
            assert((s.size() + 1) <= (DataRefTraits::size - offset));
            XPLMSetDatab(m_ref, (void *)s.c_str(), (int)offset, (int)s.size() + 1);
        }
 
        std::string getSubstr(size_t offset, size_t size) const
        {
            std::string s(size, 0);
            XPLMGetDatab(m_ref, &s[0], (int)offset, (int)size);
            size = s.find(char(0));
            if (size != std::string::npos) s.resize(size);
            return s;
        }
 
    private:
        XPLMDataRef m_ref;
    };
 
    template <class...>
    constexpr bool dependent_false = false;
 
    template <class DataRefTraits>
    class CustomDataRef
    {
    public:
        CustomDataRef()
        {
            if constexpr (std::is_same_v<typename DataRefTraits::type, int>)
            {
                m_ref = XPLMRegisterDataAccessor(DataRefTraits::name(), xplmType_Int, 0, readInt, nullptr, nullptr,
                                                 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
                                                 nullptr, this, nullptr);
            }
            else if constexpr (std::is_same_v<typename DataRefTraits::type, std::string>)
            {
                m_ref = XPLMRegisterDataAccessor(DataRefTraits::name(), xplmType_Data, 0, nullptr, nullptr, nullptr,
                                                 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
                                                 readData, nullptr, this, nullptr);
            }
            else { static_assert(dependent_false<typename DataRefTraits::type>, "Unsupported custom dataref type"); }
            if (!m_ref)
            {
                XPLMDebugString("Missing dataref:");
                XPLMDebugString(DataRefTraits::name());
                XPLMDebugString("\n");
            }
        }
 
        CustomDataRef(const CustomDataRef &) = delete;
        CustomDataRef &operator=(const CustomDataRef &) = delete;
        CustomDataRef(CustomDataRef &&other) = delete;
        CustomDataRef &operator=(CustomDataRef &&other) = delete;
        ~CustomDataRef()
        {
            if (m_ref) { XPLMUnregisterDataAccessor(m_ref); }
        }
 
        static typename DataRefTraits::type readInt(void *refcon)
        {
            return reinterpret_cast<CustomDataRef *>(refcon)->get();
        }
 
        static int readData(void *refcon, void *out, int offset, int max_length)
        {
            if constexpr (std::is_same_v<typename DataRefTraits::type, std::string>)
            {
                std::string_view sv(reinterpret_cast<CustomDataRef *>(refcon)->get());
                const size_t start = std::clamp<size_t>(offset, 0, sv.size());
                const size_t remaining_length = sv.size() - start;
                const auto len = std::min(static_cast<size_t>(max_length), remaining_length);
                sv = sv.substr(start, len);
                std::memcpy(out, sv.data(), len);
                return static_cast<int>(len);
            }
 
            return -1; // should never be reached
        }
 
        bool isValid() const { return m_ref != nullptr; }
 
        void set(typename DataRefTraits::type val) { m_datarefVal = val; }
 
        const typename DataRefTraits::type &get() const { return m_datarefVal; }
 
        XPLMDataRef m_ref;
 
        typename DataRefTraits::type m_datarefVal;
    };
 
    template <>
    inline void DataRefImpl::implSet<int>(int d)
    {
        XPLMSetDatai(m_ref, d);
    }
    template <>
    inline void DataRefImpl::implSet<float>(float d)
    {
        XPLMSetDataf(m_ref, d);
    }
    template <>
    inline void DataRefImpl::implSet<double>(double d)
    {
        XPLMSetDatad(m_ref, d);
    }
    template <>
    inline int DataRefImpl::implGet<int>() const
    {
        return XPLMGetDatai(m_ref);
    }
    template <>
    inline float DataRefImpl::implGet<float>() const
    {
        return XPLMGetDataf(m_ref);
    }
    template <>
    inline double DataRefImpl::implGet<double>() const
    {
        return XPLMGetDatad(m_ref);
    }
 
    template <>
    inline void ArrayDataRefImpl::implSetAll(int const *v)
    {
        XPLMSetDatavi(m_ref, const_cast<int *>(v), 0, m_size);
    }
    template <>
    inline void ArrayDataRefImpl::implSetAll(float const *v)
    {
        XPLMSetDatavf(m_ref, const_cast<float *>(v), 0, m_size);
    }
    template <>
    inline void ArrayDataRefImpl::implGetAll(int *v) const
    {
        XPLMGetDatavi(m_ref, &v[0], 0, m_size);
    }
    template <>
    inline void ArrayDataRefImpl::implGetAll(float *v) const
    {
        XPLMGetDatavf(m_ref, &v[0], 0, m_size);
    }
 
    template <>
    inline void ArrayDataRefImpl::implSetAt<int>(int i, int d)
    {
        assert(i <= m_size);
        XPLMSetDatavi(m_ref, &d, i, 1);
    }
    template <>
    inline void ArrayDataRefImpl::implSetAt<float>(int i, float d)
    {
        assert(i <= m_size);
        XPLMSetDatavf(m_ref, &d, i, 1);
    }
    template <>
    inline int ArrayDataRefImpl::implGetAt<int>(int i) const
    {
        assert(i <= m_size);
        int d;
        XPLMGetDatavi(m_ref, &d, i, 1);
        return d;
    }
    template <>
    inline float ArrayDataRefImpl::implGetAt<float>(int i) const
    {
        assert(i <= m_size);
        float d;
        XPLMGetDatavf(m_ref, &d, i, 1);
        return d;
    }
 
} // namespace XSwiftBus
 
#endif // SWIFT_SIM_XSWIFTBUS_DATAREFS_H