FnConstVector.h

// Copyright (c) 2017 The Foundry Visionmongers Ltd. All Rights Reserved.
#ifndef KATANA_PLUGINAPI_FNATTRIBUTE_FNCONSTVECTOR_H_
#define KATANA_PLUGINAPI_FNATTRIBUTE_FNCONSTVECTOR_H_

#include <stdint.h>
#include <cstddef>
#include <utility>

#include "FnAttribute/FnAttributeBase.h"
#include "FnAttribute/FnSampleAccessor.h"
#include "FnAttribute/ns.h"
#include "FnAttribute/suite/FnAttributeSuite.h"
#include "FnPlatform/internal/Portability.h"

FNATTRIBUTE_NAMESPACE_ENTER
{
    template<class T>
    class ConstVectorBase
    {
    public:
        typedef T              value_type;
        typedef std::size_t    size_type;
        typedef std::ptrdiff_t difference_type;

        ConstVectorBase(const Attribute& attr, float t)
            : _accessor(attr), _elems(_accessor.getNearestSample(t).data())
        {
        }

#ifdef FNKAT_CXX11

        ConstVectorBase(Attribute&& attr, float t)
            : _accessor(std::move(attr)),
              _elems(_accessor.getNearestSample(t).data())
        {
        }
#endif  // FNKAT_CXX11

        ConstVectorBase() : _accessor(), _elems() {}

        size_type size() const
        {
            return static_cast<size_type>(_accessor.getNumberOfValues());
        }

        bool empty() const { return size() == 0; }

    protected:
        SampleAccessor<T> _accessor;
        const T* _elems;
    };

    typedef ConstVectorBase<int32_t> IntConstVectorBase;
    typedef ConstVectorBase<float> FloatConstVectorBase;
    typedef ConstVectorBase<double> DoubleConstVectorBase;
    typedef ConstVectorBase<const char*> StringConstVectorBase;

    template <class T>
    class ConstVector : public ConstVectorBase<T>
    {
    public:
        ConstVector(const Attribute& attr, float t)
            : ConstVectorBase<T>(attr, t)
        {
        }

#ifdef FNKAT_CXX11

        ConstVector(Attribute&& attr, float t)
            : ConstVectorBase<T>(std::move(attr), t)
        {
        }
#endif  // FNKAT_CXX11

        // NOLINTNEXTLINE(runtime/explicit)
        /* implicit */ ConstVector(const ConstVectorBase<T>& other)
            : ConstVectorBase<T>(other)
        {
        }

        ConstVector() {}

        typedef T value_type;
        typedef const value_type* const_iterator;
        typedef const value_type& const_reference;
        typedef std::size_t    size_type;
        typedef std::ptrdiff_t difference_type;

        size_type size() const
        {
            return static_cast<size_type>(this->_accessor.getNumberOfValues());
        }

        bool empty() const { return size() == 0; }

        const_iterator begin() const FNKAT_LVALUE_REF_QUALIFIER
        {
            return this->_elems;
        }

        const_iterator end() const FNKAT_LVALUE_REF_QUALIFIER
        {
            return this->_elems + size();
        }

        const_reference operator[](size_type i) const FNKAT_LVALUE_REF_QUALIFIER
        {
            assert(i < size());
            return this->_elems[i];
        }

        const_reference at(size_type i) const FNKAT_LVALUE_REF_QUALIFIER
        {
            if (i >= size())
            {
                throw std::out_of_range("ConstVector::at");
            }
            return this->_elems[i];
        }

        const_reference front() const FNKAT_LVALUE_REF_QUALIFIER
        {
            assert(!empty());
            return this->_elems[0];
        }

        const_reference back() const FNKAT_LVALUE_REF_QUALIFIER
        {
            assert(!empty());
            return this->_elems[size() - 1];
        }

        const value_type* data() const FNKAT_LVALUE_REF_QUALIFIER
        {
            return this->_elems;
        }

#ifdef FNKAT_CXX11

        const_iterator begin() && = delete;
        const_iterator end() && = delete;
        const_reference operator[](size_type i) && = delete;
        const_reference at(size_type i) && = delete;
        const_reference front() && = delete;
        const_reference back() && = delete;
        const value_type* data() && = delete;
#endif  // FNKAT_CXX11
    };

    typedef ConstVector<int32_t>     IntConstVector;
    typedef ConstVector<float>       FloatConstVector;
    typedef ConstVector<double>      DoubleConstVector;
    typedef ConstVector<const char*> StringConstVector;

}
FNATTRIBUTE_NAMESPACE_EXIT
#endif  // KATANA_PLUGINAPI_FNATTRIBUTE_FNCONSTVECTOR_H_