IterateChunks.hpp

Go to the documentation of this file.

#ifndef RITSUKO_HDF5_ITERATE_CHUNKS_HPP
#define RITSUKO_HDF5_ITERATE_CHUNKS_HPP
 
#include "H5Cpp.h"
 
#include <vector>
#include <algorithm>
#include <cmath>
 
#include "../utils.hpp"
#include "../itoa.hpp"
 
namespace ritsuko {
 
namespace hdf5 {
 
struct IterateChunks {
    IterateChunks(std::vector<hsize_t> data_dimensions, std::vector<hsize_t> chunk_dimensions) : 
        my_data_extent(std::move(data_dimensions)), 
        my_chunk_extent(std::move(chunk_dimensions)), 
        my_starts(my_data_extent.size()), // no need to sanisizer::cast as the types are the same.
        my_counts(my_data_extent.size())
    {
        const auto ndims = my_data_extent.size();
        assert(ndims == my_chunk_extent.size());
 
        I<decltype(ndims)> num_empty = 0;
        for (I<decltype(ndims)> d = 0; d < ndims; ++d) {
            my_chunk_extent[d] = std::min(my_data_extent[d], my_chunk_extent[d]);
            my_counts[d] = my_chunk_extent[d];
            num_empty += (my_chunk_extent[d] == 0); 
        }
 
        if (ndims == 0 || num_empty) {
            my_finished = true;
        } else {
            // Ensure that the first advance() call has no effect.
            my_counts.back() = 0;
        }
    }
 
    bool advance() {
        if (my_finished) {
            return false;
        }
 
        // Prioritizing the last dimension as this is the fastest-changing.
        const auto ndims = my_data_extent.size();
        for (auto i = ndims; i > 0; --i) {
            const auto d = i - 1;
            my_starts[d] += my_counts[d];
            if (my_starts[d] < my_data_extent[d]) {
                my_counts[d] = std::min(my_data_extent[d] - my_starts[d], my_chunk_extent[d]);
                return true; 
            }
 
            my_starts[d] = 0;
            my_counts[d] = my_chunk_extent[d];
        }
 
        my_finished = true;
        return false;
    }
 
public:
    const std::vector<hsize_t>& starts () const {
        return my_starts;
    }
 
    const std::vector<hsize_t>& counts () const {
        return my_counts;
    }
 
    const std::vector<hsize_t>& data_dimensions() const {
        return my_data_extent;
    }
 
    const std::vector<hsize_t>& chunk_dimensions() const {
        return my_chunk_extent;
    }
 
private:
    std::vector<hsize_t> my_data_extent, my_chunk_extent;
    std::vector<hsize_t> my_starts, my_counts;
    bool my_finished = false;
};
 
inline std::string emit_coordinates_as_string(hsize_t position, hsize_t chunk_size, const std::vector<hsize_t>& starts, const std::vector<hsize_t>& counts) {
    std::string msg;
    const auto ndim = starts.size();
    for (I<decltype(ndim)> d = 0; d < ndim; ++d) {
        if (d != 0) {
            msg += ", ";
        }
        chunk_size /= counts[d];
        msg += itoa(starts[d] + position / chunk_size);
        position %= chunk_size;
    }
    return "(" + msg + ")";
}
}
 
}
 
#endif