ArrayView.h

Go to the documentation of this file.

#pragma once
 
 
#include "objects/utility/Iterator.h"
 
NAMESPACE_SPH_BEGIN
 
template <typename T, typename TCounter = Size>
class ArrayView {
private:
    using StorageType = typename WrapReferenceType<T>::Type;
 
    StorageType* data;
    TCounter actSize = 0;
 
public:
    using Type = T;
    using Counter = TCounter;
 
    INLINE ArrayView()
        : data(nullptr) {}
 
    INLINE ArrayView(StorageType* data, TCounter size)
        : data(data)
        , actSize(size) {}
 
    INLINE ArrayView(const ArrayView& other)
        : data(other.data)
        , actSize(other.actSize) {}
 
    INLINE ArrayView(std::nullptr_t)
        : data(nullptr) {}
 
    INLINE ArrayView& operator=(const ArrayView& other) {
        this->data = other.data;
        this->actSize = other.actSize;
        return *this;
    }
 
    INLINE operator ArrayView<const T, TCounter>() const {
        return ArrayView<const T, TCounter>(data, actSize);
    }
 
    INLINE Iterator<StorageType> begin() {
        return Iterator<StorageType>(data, data, data + actSize);
    }
 
    INLINE Iterator<const StorageType> begin() const {
        return Iterator<const StorageType>(data, data, data + actSize);
    }
 
    INLINE Iterator<StorageType> end() {
        return Iterator<StorageType>(data + actSize, data, data + actSize);
    }
 
    INLINE Iterator<const StorageType> end() const {
        return Iterator<const StorageType>(data + actSize, data, data + actSize);
    }
 
    INLINE T& operator[](const TCounter idx) {
        SPH_ASSERT(unsigned(idx) < unsigned(actSize), idx, actSize);
        return data[idx];
    }
 
    INLINE const T& operator[](const TCounter idx) const {
        SPH_ASSERT(unsigned(idx) < unsigned(actSize), idx, actSize);
        return data[idx];
    }
 
    INLINE T& front() {
        SPH_ASSERT(actSize > 0);
        return data[0];
    }
 
    INLINE const T& front() const {
        SPH_ASSERT(actSize > 0);
        return data[0];
    }
 
    INLINE T& back() {
        SPH_ASSERT(actSize > 0);
        return data[actSize - 1];
    }
 
    INLINE const T& back() const {
        SPH_ASSERT(actSize > 0);
        return data[actSize - 1];
    }
 
    INLINE TCounter size() const {
        return this->actSize;
    }
 
    INLINE bool empty() const {
        return this->actSize == 0;
    }
 
    INLINE ArrayView subset(const TCounter start, const TCounter length) const {
        SPH_ASSERT(start <= size() && start + length <= size());
        return ArrayView(data + start, length);
    }
 
    INLINE bool operator!() const {
        return data == nullptr;
    }
 
    INLINE explicit operator bool() const {
        return data != nullptr;
    }
 
    bool operator==(const ArrayView& other) const {
        if (actSize != other.actSize) {
            return false;
        }
        for (TCounter i = 0; i < actSize; ++i) {
            if (data[i] != other[i]) {
                return false;
            }
        }
        return true;
    }
 
    bool operator!=(const ArrayView& other) const {
        return !(*this == other);
    }
 
    friend std::ostream& operator<<(std::ostream& stream, const ArrayView& array) {
        for (const T& t : array) {
            stream << t << std::endl;
        }
        return stream;
    }
};
 
template <typename T>
bool almostEqual(const ArrayView<T> v1, const ArrayView<T> v2, const Float& eps) {
    if (v1.size() != v2.size()) {
        return false;
    }
 
    for (Size i = 0; i < v1.size(); ++i) {
        if (!Sph::almostEqual(v1[i], v2[i], eps)) {
            return false;
        }
    }
    return true;
}
 
template <typename T>
INLINE ArrayView<T> getSingleValueView(T& value) {
    return ArrayView<T>(&value, 1);
}
 
NAMESPACE_SPH_END