array.h

Go to the documentation of this file.

#ifndef WMARRAY_H
#define WMARRAY_H
 
// Wx includes
#include "lib/wxrange.h"
 
// Wm includes
#include "warpxm/warpxm_config.h"
 
// STL includes
#include <cstring>
#include <map>
#include <memory>
 
namespace wxm
{
namespace array
{
 
template<typename T> class array_allocation_t
{
public:
    array_allocation_t() = default;
 
    array_allocation_t(const WxRange& range) : _range(range)
    {
        allocate();
    }
 
    array_allocation_t(const array_allocation_t& other) = default;
 
    virtual ~array_allocation_t()
    {
        terminate();
    }
 
    array_allocation_t& operator=(const array_allocation_t& other)
    {
        if (&other != this)
        {
            link(other);
        }
        return *this;
    }
 
    void fill(const T& value)
    {
        std::fill_n(data(), _range.size(), value);
    }
 
    T* data()
    {
        return _data->data();
    }
 
    const T* data() const
    {
        return _data->data();
    }
 
    virtual T& operator[](int index)
    {
        return (*_data)[index];
    }
 
    virtual const T& operator[](int index) const
    {
        return (*_data)[index];
    }
 
    T& operator()(size_t i, size_t j)
    {
        return operator[](i* _range.length(1) + j);
    }
 
    const T& operator()(size_t i, size_t j) const
    {
        return operator[](i* _range.length(1) + j);
    }
 
    const T& operator()(size_t i, size_t j, size_t k) const
    {
        return operator[]((i * _range.length(1) + j) * _range.length(2) + k);
    }
 
    T& operator()(size_t i, size_t j, size_t k)
    {
        return operator[]((i * _range.length(1) + j) * _range.length(2) + k);
    }
 
    const WxRange& range() const
    {
        return _range;
    }
 
    friend std::ostream& operator<<(std::ostream& stream, const array_allocation_t& array)
    {
        int num_pts = array.range().size();
        stream << "[";
        for (int i = 0; i < num_pts; i++)
        {
            stream << array[i];
            if (i != num_pts - 1)
            {
                stream << ", ";
            }
        }
        stream << "]";
        return stream;
    }
 
protected:
    void copy(const array_allocation_t& other)
    {
        // This is a deep copy - all data in _data is copied to new
        // class
        terminate();
        _range = other._range;
        allocate();
        std::memcpy(data(), other.data(), _range.size() * sizeof(T));
    }
 
    void link(const array_allocation_t& other)
    {
        // This is a shallow copy, only the reference to the data is
        // really stored
        terminate();
        _range = other._range;
        _data = other._data;
    }
 
    void allocate()
    {
        // Allocate a new dataset
        _data.reset();
        _data = std::make_shared<std::vector<T>>(std::vector<T>());
        _data->resize(_range.size());
    }
 
    void terminate()
    {
        // Delete the array - if array is linked, then the core data may
        // be saved depending on
        // the existance of other linked arrays
        _data.reset();
    }
 
    WxRange _range;
 
    std::shared_ptr<std::vector<T>> _data;
 
private:
};
 
class patch_array_t : public array_allocation_t<real>
{
public:
    patch_array_t() = default;
 
    patch_array_t(const WxRange& range)
        : array_allocation_t<real>(range), _interior_range(range)
    {
    }
 
    patch_array_t(const patch_array_t& other) = default;
 
    virtual ~patch_array_t()
    {
        terminate();
    }
 
    patch_array_t& operator=(const patch_array_t& other)
    {
        if (&other != this)
        {
            link(static_cast<const array_allocation_t<real>&>(other));
        }
        return *this;
    }
 
    const WxRange& interior_range() const
    {
        return _interior_range;
    }
 
protected:
    WxRange _interior_range;
};
} // namespace array
} // namespace wxm
 
#endif // WMARRAY_H