GltfDataViewer.h

#pragma once
#ifndef GLTF_DATA_VIEWER_HAS_BEEN_INCLUDED_
#define GLTF_DATA_VIEWER_HAS_BEEN_INCLUDED_

#include "GltfCommon.h"
#include <algorithm>

namespace gltf{

template <typename ResultT, typename ElemT = ResultT> 
class GltfDataAdaptorInterface
{
 public:
    virtual const ResultT operator[](size_t aIndex) const = 0;
    virtual const ResultT at(size_t aIndex) const = 0;

    virtual const gltf::TypePair& internalTypeInfo() const noexcept = 0;

    inline size_t size() const noexcept {return(mSize);}

 protected:
    size_t mSize = 0;
};

// Hide implementation within internal namespace 
namespace _internal{

template <typename ResultT, typename ElemT, gltf::DataType T_dataType, gltf::ComponentType T_compType>
class GltfDataAdaptorInternalImplementation : public GltfDataAdaptorInterface<ResultT, ElemT>
{
 public:
    GltfDataAdaptorInternalImplementation(const gltf::DataAccessBundle& aDataAccBundle, int aSkipStride = -1)
    :   mDataAccBundle(aDataAccBundle), mSkipStride(aSkipStride)
    {
        GltfDataAdaptorInterface<ResultT, ElemT>::mSize = mDataAccBundle.accessor.count;
    }

    virtual const ResultT operator[](size_t aIndex) const override;
    virtual const ResultT  at(size_t aIndex) const override;
    virtual const gltf::TypePair& internalTypeInfo() const noexcept override {return(mTypeInfo);}

 protected:

    const gltf::TypePair mTypeInfo = {T_dataType, T_compType};

    DataAccessBundle mDataAccBundle;

    int mSkipStride = -1; // Optional skip stride used when it's desirable to skip over a number of elements on each access. 
};

template <typename ResultT, typename ElemT = std::false_type>
GltfDataAdaptorInterface<ResultT, ElemT>* get_adaptor_implementation(const gltf::DataAccessBundle& aDataAccBundle, int aSkipStride = -1);

} // end namespace gltf::_internal

template <typename ResultT, typename ElemT = ResultT> 
class GltfDataAdaptor : virtual public GltfDataAdaptorInterface<ResultT, ElemT>
{
 public:

    using result_t = ResultT;
    using element_t = ElemT;

    GltfDataAdaptor(){}
    GltfDataAdaptor(const gltf::DataAccessBundle& aDataAccBundle, int aSkipStride = -1);

    bool isValid() const noexcept {return(_mInternalAdaptor != nullptr);}

    virtual const ResultT operator[](size_t aIndex) const override {
        return(_mInternalAdaptor->operator[](aIndex));
    }
    virtual const ResultT  at(size_t aIndex) const override {
        return(_mInternalAdaptor->at(aIndex));
    }
    virtual const gltf::TypePair& internalTypeInfo() const noexcept override {
        return(_mInternalAdaptor->internalTypeInfo());
    }

    void fillVector(std::vector<ResultT>& aOutVector){
        size_t size = _mInternalAdaptor->size();
        aOutVector.reserve(size);
        for(size_t idx = 0; idx < size; ++idx){
            aOutVector.emplace_back(operator[](idx));
        }
    }

 protected:

    GltfDataAdaptor(GltfDataAdaptorInterface<ResultT, ElemT>* aAdaptorInterface){
        _mInternalAdaptor = aAdaptorInterface;
        if(_mInternalAdaptor != nullptr) GltfDataAdaptorInterface<ResultT, ElemT>::mSize = _mInternalAdaptor->size();
    }
    
    std::shared_ptr<GltfDataAdaptorInterface<ResultT, ElemT>> _mInternalAdaptor = nullptr;
};

} // end namespace gltf

#include "GltfDataViewer.inl"


#endif