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 <array>
#include <cassert>
#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 <>
    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