SomeNumericArray.hpp

Go to the documentation of this file.

#ifndef TATAMI_SOME_NUMERIC_ARRAY_HPP
#define TATAMI_SOME_NUMERIC_ARRAY_HPP
 
#include <cstdint>
#include <cstddef>
#include <iterator>
 
namespace tatami {
 
enum SomeNumericType { I8, U8, I16, U16, I32, U32, I64, U64, F32, F64 };
 
template<typename Value_ = double>
class SomeNumericArray {
public:
    SomeNumericArray(void* ptr, size_t number, SomeNumericType type) : my_number(number), my_type(type) {
        switch(my_type) {
            case I8:
                my_i8 = static_cast<const int8_t*>(ptr);
                break;
            case U8:
                my_u8 = static_cast<const uint8_t*>(ptr);
                break;
            case I16:
                my_i16 = static_cast<const int16_t*>(ptr);
                break;
            case U16:
                my_u16 = static_cast<const uint16_t*>(ptr);
                break;
            case I32:
                my_i32 = static_cast<const int32_t*>(ptr);
                break;
            case U32:
                my_u32 = static_cast<const uint32_t*>(ptr);
                break;
            case I64:
                my_i64 = static_cast<const int64_t*>(ptr);
                break;
            case U64:
                my_u64 = static_cast<const uint64_t*>(ptr);
                break;
            case F32:
                my_f32 = static_cast<const float*>(ptr);
                break;
            case F64:
                my_f64 = static_cast<const double*>(ptr);
                break;
        }
    }
 
    SomeNumericArray(const int8_t* ptr, size_t number) : my_i8(ptr), my_number(number), my_type(I8) {}
 
    SomeNumericArray(const uint8_t* ptr, size_t number) : my_u8(ptr), my_number(number), my_type(U8) {}
 
    SomeNumericArray(const int16_t* ptr, size_t number) : my_i16(ptr), my_number(number), my_type(I16) {}
 
    SomeNumericArray(const uint16_t* ptr, size_t number) : my_u16(ptr), my_number(number), my_type(U16) {}
    
    SomeNumericArray(const int32_t* ptr, size_t number) : my_i32(ptr), my_number(number), my_type(I32) {}
    
    SomeNumericArray(const uint32_t* ptr, size_t number) : my_u32(ptr), my_number(number), my_type(U32) {}
    
    SomeNumericArray(const int64_t* ptr, size_t number) : my_i64(ptr), my_number(number), my_type(I64) {}
    
    SomeNumericArray(const uint64_t* ptr, size_t number) : my_u64(ptr), my_number(number), my_type(U64) {}
    
    SomeNumericArray(const float* ptr, size_t number) : my_f32(ptr), my_number(number), my_type(F32) {}
    
    SomeNumericArray(const double* ptr, size_t number) : my_f64(ptr), my_number(number), my_type(F64) {}
 
private:
    const int8_t* my_i8 = NULL;
    const uint8_t* my_u8 = NULL;
    const int16_t* my_i16 = NULL;
    const uint16_t* my_u16 = NULL;
    const int32_t* my_i32 = NULL;
    const uint32_t* my_u32 = NULL;
    const int64_t* my_i64 = NULL;
    const uint64_t* my_u64 = NULL;
    const float* my_f32 = NULL;
    const double* my_f64 = NULL;
 
    size_t my_number;
    SomeNumericType my_type;
 
public:
    Value_ operator[](size_t i) const {
        switch (my_type) {
            case I8:
                return my_i8[i];
            case U8:
                return my_u8[i];
            case I16:
                return my_i16[i];
            case U16:
                return my_u16[i];
            case I32:
                return my_i32[i];
            case U32:
                return my_u32[i];
            case I64:
                return my_i64[i];
            case U64:
                return my_u64[i];
            case F32:
                return my_f32[i];
            case F64:
                return my_f64[i];
        }
        return 0; // shouldn't reach here, but whatever.
    }
 
    size_t size() const {
        return my_number;
    }
 
public:
    struct Iterator {
        Iterator() : my_parent(NULL), my_index(0) {}
 
        Iterator(const SomeNumericArray* parent, size_t index) : my_parent(parent), my_index(index) {}
 
    public:
        // Tags to pretend it's an iterator, at least enough for tatami to work;
        // see https://internalpointers.com/post/writing-custom-iterators-modern-cpp for details.
 
        using iterator_category = std::random_access_iterator_tag;
 
        using difference_type = std::ptrdiff_t;
 
        using value_type = Value_;
 
        using pointer = const Value_*;  
 
        using reference = const Value_&; 
 
    private:
        const SomeNumericArray* my_parent;
        size_t my_index;
 
    public:
        value_type operator*() const {
            return (*my_parent)[my_index];
        }
 
        value_type operator[](size_t i) const {
            return (*my_parent)[my_index + i];
        }
 
    public:
        bool operator==(const Iterator& right) const {
            return my_index == right.my_index;
        }
 
        bool operator!=(const Iterator& right) const {
            return !(*this == right);
        }
 
        bool operator<(const Iterator& right) const {
            return my_index < right.my_index;
        }
 
        bool operator>=(const Iterator& right) const {
            return !(*this < right);
        }
 
        bool operator>(const Iterator& right) const {
            return my_index > right.my_index;
        }
 
        bool operator<=(const Iterator& right) const {
            return !(*this > right);
        }
 
    public:
        Iterator& operator+=(size_t n) {
            my_index += n;
            return *this;
        }
 
        Iterator& operator++() {
            *this += 1;
            return *this;
        }
 
        Iterator operator++(int) {
            auto copy = *this;
            ++(*this);
            return copy;
        }
 
        Iterator& operator-=(size_t n) {
            my_index -= n;
            return *this;
        }
 
        Iterator& operator--() {
            *this -= 1;
            return *this;
        }
 
        Iterator operator--(int) {
            auto copy = *this;
            --(*this);
            return copy;
        }
 
    public:
        Iterator operator+(size_t n) const {
            return Iterator(my_parent, my_index + n);
        }
 
        Iterator operator-(size_t n) const {
            return Iterator(my_parent, my_index - n);
        }
 
        friend Iterator operator+(size_t n, const Iterator& it) {
            return Iterator(it.my_parent, it.my_index + n);
        }
 
        std::ptrdiff_t operator-(const Iterator& right) const {
            std::ptrdiff_t out;
            if (right.my_index > my_index) {
                out = right.my_index - my_index;
                out *= -1;
            } else {
                out = my_index - right.my_index;
            }
            return out;
        }
    };
 
    Iterator begin() const {
        return Iterator(this, 0);
    }
 
    Iterator end() const {
        return Iterator(this, this->size());
    }
};
 
}
 
#endif