dense_0d.h

#pragma once
#include <muda/viewer/viewer_base.h>

namespace muda
{
template <bool IsConst, typename T>
class DenseViewerBase : public ViewerBase<IsConst>
{
    using Base = ViewerBase<IsConst>;
    MUDA_VIEWER_COMMON_NAME(DenseViewerBase);

  public:
    using ConstViewer    = DenseViewerBase<true, T>;
    using NonConstViewer = DenseViewerBase<false, T>;
    using ThisViewer     = DenseViewerBase<IsConst, T>;

  protected:
    template <typename U>
    using auto_const_t = typename Base::template auto_const_t<U>;
    auto_const_t<T>* m_data;

  public:
    using value_type = T;

    MUDA_GENERIC DenseViewerBase() MUDA_NOEXCEPT : m_data(nullptr) {}

    MUDA_GENERIC explicit DenseViewerBase(auto_const_t<T>* p) MUDA_NOEXCEPT : m_data(p)
    {
    }

    MUDA_GENERIC auto as_const() const MUDA_NOEXCEPT
    {
        return ConstViewer{m_data};
    }

    MUDA_GENERIC operator ConstViewer() const MUDA_NOEXCEPT
    {
        return as_const();
    }

    MUDA_GENERIC auto_const_t<T>& operator*() MUDA_NOEXCEPT
    {
        check();
        return *m_data;
    }

    MUDA_GENERIC auto_const_t<T>* operator->() MUDA_NOEXCEPT
    {
        check();
        return m_data;
    }

    MUDA_GENERIC auto_const_t<T>* data() MUDA_NOEXCEPT { return m_data; }

    MUDA_GENERIC const T& operator*() const MUDA_NOEXCEPT
    {
        return remove_const(*this).operator*();
    }

    MUDA_GENERIC const T* operator->() const MUDA_NOEXCEPT
    {
        return remove_const(*this).operator->();
    }

    MUDA_GENERIC const T* data() const MUDA_NOEXCEPT { return m_data; }

    MUDA_GENERIC operator const T&() const MUDA_NOEXCEPT { return *m_data; }

  protected:
    MUDA_INLINE MUDA_GENERIC void check() const MUDA_NOEXCEPT
    {
        if constexpr(DEBUG_VIEWER)
        {
            MUDA_KERNEL_ASSERT(m_data,
                               "Dense[%s:%s]: m_data is null",
                               this->name(),
                               this->kernel_name());
        }
    }
};

template <typename T>
class Dense : public DenseViewerBase<false, T>
{
    MUDA_VIEWER_COMMON_NAME(Dense);

  public:
    using Base           = DenseViewerBase<false, T>;
    using ConstViewer    = typename Base::ConstViewer;
    using NonConstViewer = Dense<T>;
    using ThisViewer     = Dense<T>;

    using Base::Base;

    MUDA_GENERIC Dense(const Base& base) MUDA_NOEXCEPT : Base(base) {}

    MUDA_GENERIC Dense& operator=(const T& base) MUDA_NOEXCEPT
    {
        Base::check();
        *this->m_data = base;
        return *this;
    }

    using Base::operator*;
    using Base::operator->;
    using Base::as_const;
    using Base::data;

    MUDA_GENERIC operator T&() MUDA_NOEXCEPT { return *this->m_data; }
    MUDA_GENERIC operator const T&() const MUDA_NOEXCEPT
    {
        return *this->m_data;
    }

    MUDA_GENERIC operator ConstViewer() const MUDA_NOEXCEPT
    {
        return this->as_const();
    }
};

template <typename T>
using CDense = DenseViewerBase<true, T>;

// viewer traits
template <typename T>
struct read_only_viewer<Dense<T>>
{
    using type = CDense<T>;
};

template <typename T>
struct read_write_viewer<CDense<T>>
{
    using type = Dense<T>;
};

// make functions
template <typename T>
MUDA_INLINE MUDA_GENERIC auto make_cdense(const T* data) MUDA_NOEXCEPT
{
    return CDense<T>{data};
}

template <typename T>
MUDA_INLINE MUDA_GENERIC auto make_dense(T* data) MUDA_NOEXCEPT
{
    return Dense<T>{data};
}

//print convert
template <typename T>
MUDA_INLINE MUDA_GENERIC const T& print_convert(const Dense<T>& v) MUDA_NOEXCEPT
{
    return v.operator const T&();
}

template <typename T>
MUDA_INLINE MUDA_GENERIC const T& print_convert(const CDense<T>& v) MUDA_NOEXCEPT
{
    return v.operator const T&();
}

}  // namespace muda