vector_view.h

/*
 * cugar
 * Copyright (c) 2011-2018, NVIDIA CORPORATION. All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *    * Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *    * Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *    * Neither the name of the NVIDIA CORPORATION nor the
 *      names of its contributors may be used to endorse or promote products
 *      derived from this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#pragma once

#include <cugar/basic/types.h>
#include <cugar/basic/iterator.h>
#include <iterator>
#include <vector>

namespace cugar {



template <typename Iterator, typename IndexType = uint32>
struct vector_view
{
    typedef Iterator                                                    iterator;
    typedef Iterator                                                    const_iterator;
    typedef typename iterator_traits<Iterator>::forward_iterator        forward_iterator;

    typedef typename iterator_traits<Iterator>::value_type              value_type;
    typedef typename iterator_traits<Iterator>::reference               reference;
    typedef typename to_const<reference>::type                          const_reference;
    typedef typename iterator_traits<Iterator>::pointer                 pointer;
    typedef IndexType                                                   size_type;
    typedef IndexType                                                   index_type;
    typedef typename iterator_traits<Iterator>::difference_type         difference_type;
    typedef std::random_access_iterator_tag                             iterator_category;

    typedef vector_view<Iterator,IndexType>                                   plain_view_type;
    typedef vector_view<Iterator,IndexType>                             const_plain_view_type;

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    vector_view() {}

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    vector_view(const IndexType size, Iterator vec) : m_size( size ), m_vec( vec ) {}

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    void resize(const uint32 sz) { m_size = sz; }

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    void clear() { m_size = 0; }

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    IndexType size() const { return m_size; }

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    IndexType length() const { return m_size; }

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    bool empty() const { return m_size == 0; }

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    const_reference operator*() const                   { CUGAR_CUDA_DEBUG_ASSERT( 0 < m_size, "vector_view: access out of bounds, dereferenced zero sized vector\n" ); return *m_vec; }

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    reference operator*()                               { CUGAR_CUDA_DEBUG_ASSERT( 0 < m_size, "vector_view: access out of bounds, dereferenced zero sized vector\n" ); return *m_vec; }

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    const_reference operator[](const IndexType i) const { CUGAR_CUDA_DEBUG_ASSERT( i < m_size, "vector_view: access out of bounds, %llu >= %llu\n", uint64(i), uint64(m_size) ); return m_vec[i]; }

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    reference operator[](const IndexType i)             { CUGAR_CUDA_DEBUG_ASSERT( i < m_size, "vector_view: access out of bounds, %llu >= %llu\n", uint64(i), uint64(m_size) ); return m_vec[i]; }

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    const_reference front(void) const { return m_vec[0]; }

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    reference front(void) { return m_vec[0]; }

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    const_reference back(void) const { return m_vec[m_size-1]; }

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    reference back(void) { return m_vec[m_size-1]; }

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    Iterator base() const { return m_vec; }

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    const_iterator begin() const { return m_vec; }

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    const_iterator end() const { return m_vec + m_size; }

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    iterator begin() { return m_vec; }

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    iterator end() { return m_vec + m_size; }

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    operator Iterator() const { return m_vec; }

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    void push_back(const_reference val) { m_vec[ m_size ] = val; m_size++; }

    CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
    void pop_back() { --m_size; }

    IndexType   m_size;
    Iterator    m_vec;
};

template <typename Iterator>
CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
uint32 length(const vector_view<Iterator>& vec) { return vec.length(); }

template <typename T>
CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
T raw_pointer(const vector_view<T>& vec) { return vec.base(); }

template <typename T, typename I>
CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
T begin(vector_view<T,I>& vec) { return vec.begin(); }

template <typename T, typename I>
CUGAR_FORCEINLINE CUGAR_HOST_DEVICE
T begin(const vector_view<T,I>& vec) { return vec.begin(); }

//
// --- std::vector views ----------------------------------------------------------------------------
//

template <typename T> struct plain_view_subtype< std::vector<T> > { typedef vector_view<T*,uint64> type; };

template <typename T> struct plain_view_subtype< const std::vector<T> > { typedef vector_view<const T*,uint64> type; };


template <typename T>
vector_view<T*,uint64> plain_view(std::vector<T>& vec) { return vector_view<T*,uint64>( vec.size(), vec.size() ? &vec[0] : NULL ); }

template <typename T>
vector_view<const T*,uint64> plain_view(const std::vector<T>& vec) { return vector_view<const T*,uint64>( vec.size(), vec.size() ? &vec[0] : NULL ); }

template <typename T>
T* raw_pointer(std::vector<T>& vec) { return vec.size() ? &vec[0] : NULL; }

template <typename T>
const T* raw_pointer(const std::vector<T>& vec) { return vec.size() ? &vec[0] : NULL; }

template <typename T> T* begin(T* vec) { return vec; }

template <typename T> const T* begin(const T* vec) { return vec; }


} // namespace cugar