#include <lazy_reader.h>

Inheritance diagram for tatooine::lazy_reader< DataSet, GlobalIndexOrder, LocalIndexOrder >:

Collaboration diagram for tatooine::lazy_reader< DataSet, GlobalIndexOrder, LocalIndexOrder >:

Public Types
using	this_type = lazy_reader< DataSet, GlobalIndexOrder, LocalIndexOrder >

using	value_type = typename DataSet::value_type

using	parent_type = chunked_multidim_array< value_type, GlobalIndexOrder, LocalIndexOrder >

Public Types inherited from tatooine::chunked_multidim_array< T, GlobalIndexOrder, LocalIndexOrder >
using	value_type = T

using	parent_type = dynamic_multidim_size< GlobalIndexOrder >

using	this_type = chunked_multidim_array< T, GlobalIndexOrder, LocalIndexOrder >

using	chunk_t = dynamic_multidim_array< T, LocalIndexOrder >

using	chunk_ptr_t = std::unique_ptr< chunk_t >

using	chunk_ptr_field_t = std::vector< chunk_ptr_t >

using	global_index_order_t = GlobalIndexOrder

using	local_index_order_t = LocalIndexOrder

Public Types inherited from tatooine::dynamic_multidim_size< IndexOrder >
using	this_type = dynamic_multidim_size< IndexOrder >

using	index_order_type = IndexOrder

Public Member Functions
	lazy_reader (DataSet const &file, std::vector< std::size_t > const &chunk_size)

	lazy_reader (lazy_reader const &other)

auto	at (integral auto const ... indices) const -> value_type const &

template<integral Index, std::size_t N>
auto	at (std::array< Index, N > const &indices) const -> value_type const &

auto	operator() (integral auto const ... indices) const -> value_type const &

auto	is_chunk_filled_with_value (std::size_t const plain_chunk_index, value_type const &value) const -> bool

auto	is_chunk_filled_with_zeros (std::size_t const plain_chunk_index) const -> bool

auto	set_max_num_chunks_loaded (std::size_t const)

auto	limit_num_chunks_loaded (bool const =true)

auto	num_chunks_loaded () const

auto	chunks_loaded () const -> auto const &

auto	chunk_is_loaded (std::size_t const plain_chunk_index) const

auto	chunk_at (integral auto const chunk_index0, integral auto const ... chunk_indices) const -> auto const &

Public Member Functions inherited from tatooine::chunked_multidim_array< T, GlobalIndexOrder, LocalIndexOrder >
	chunked_multidim_array (chunked_multidim_array const &other)

template<range SizeRange, range ChunkSizeRange> requires (is_integral<typename std::decay_t<SizeRange>::value_type>) && (is_integral<typename std::decay_t<ChunkSizeRange>::value_type>)
	chunked_multidim_array (SizeRange &&size, ChunkSizeRange &&chunk_size)

template<range Range>
	chunked_multidim_array (Range &&data, std::vector< std::size_t > const &size, std::vector< std::size_t > const &chunk_size)

template<can_read< this_type > Reader>
	chunked_multidim_array (Reader &&reader, std::vector< std::size_t > const &chunk_size)

template<range SizeRange>
auto	resize (SizeRange &&size) -> void requires(is_integral< typename std::decay_t< SizeRange >::value_type >)

template<range SizeRange, range ChunkSizeRange> requires integral<tatooine::value_type<std::decay_t<SizeRange>>> && integral<tatooine::value_type<std::decay_t<ChunkSizeRange>>>
auto	resize (SizeRange &&size, ChunkSizeRange &&chunk_size)

auto	resize (integral auto const ... sizes) -> void

template<typename Tensor , integral Int, std::size_t N>
auto	resize (base_tensor< Tensor, Int, N > const &v) -> void

template<integral Int, std::size_t N>
auto	resize (std::array< Int, N > const &v)

auto	plain_internal_chunk_index_from_global_indices (std::size_t plain_chunk_index, integral auto const ... is) const

auto	plain_chunk_index_from_global_indices (integral auto const ... is) const

auto	internal_chunk_indices_from_global_indices (integral auto const ... is) const

template<integral Int>
auto	internal_chunk_indices_from_global_indices (std::vector< Int > is) const

auto	chunk_indices_from_global_indices (integral auto const ... is) const

template<integral Int>
auto	chunk_indices_from_global_indices (std::vector< Int > is) const

template<integral Int>
auto	global_indices_from_chunk_indices (std::vector< Int > is) const

auto	plain_chunk_index_from_chunk_indices (integral auto const ... chunk_indices) const

template<integral Int>
auto	plain_chunk_index_from_chunk_indices (std::vector< Int > const &chunk_indices) const

auto	chunk_at (integral auto const chunk_index0, integral auto const ... chunk_indices) const -> auto const &

auto	chunk_at_is_null (integral auto const chunk_index0, integral auto const ... chunk_indices) const

auto	create_all_chunks () const -> void

auto	create_chunk_at (std::size_t const plain_chunk_index, std::vector< std::size_t > const &multi_indices) const -> auto const &

auto	create_chunk_at (std::size_t const plain_chunk_index) const -> auto const &

auto	create_chunk_at (integral auto const chunk_index0, integral auto const chunk_index1, integral auto const ... chunk_indices) const -> auto const &

auto	destroy_chunk_at (integral auto const chunk_index0, integral auto const ... chunk_indices) const

auto	copy_chunks (chunked_multidim_array const &other) -> void

auto	clear ()

auto	num_chunks () const

auto	chunk_size () const

auto	chunk_size (std::size_t i) const

auto	internal_chunk_size () const

auto	internal_chunk_size (std::size_t const i) const

auto	operator[] (std::size_t plain_index) -> T &

auto	operator[] (std::size_t plain_index) const -> T const &

auto	at (integral auto const ... is) -> T &

auto	at (integral auto const ... is) const -> T const &

template<typename Tensor , std::size_t N, integral S>
auto	at (base_tensor< Tensor, S, N > const &is) -> T &

template<integral S, std::size_t N>
auto	at (std::array< S, N > const &is) -> T &

template<integral S>
auto	at (std::vector< S > const &is) -> T &

template<integral S>
auto	at (std::vector< S > const &is) const -> T const &

auto	operator() (integral auto const ... is) -> T &

auto	operator() (integral auto const ... is) const -> T const &

template<typename Tensor , std::size_t N, integral S>
auto	operator() (base_tensor< Tensor, S, N > const &is) -> T &

template<integral S, std::size_t N>
auto	operator() (std::array< S, N > const &is) -> T &

template<integral S, std::size_t N>
auto	operator() (std::array< S, N > const &is) const -> T const &

template<integral S, std::size_t N>
auto	at (std::array< S, N > const &is) const -> T const &

template<typename RandomEngine = std::mt19937_64> requires is_arithmetic<T>
auto	randu (T min=0, T max=1, RandomEngine &&random_engine=RandomEngine{std::random_device{}()}) -> void

auto	min_value () const

auto	max_value () const

auto	minmax_value () const

auto	normalize () -> void

template<typename Iteration >
auto	iterate_over_indices (Iteration &&iteration) const

auto constexpr	in_range (integral auto const ... indices) const

auto constexpr	in_range (integral_range auto const &indices) const

auto constexpr	multi_index (std::size_t const gi) const

auto	num_components () const

auto	num_dimensions () const

auto	size () const -> auto const &

auto	size (std::size_t const i) const

Public Member Functions inherited from tatooine::dynamic_multidim_size< IndexOrder >
	dynamic_multidim_size ()=default

	dynamic_multidim_size (dynamic_multidim_size const &other)=default

	dynamic_multidim_size (dynamic_multidim_size &&other) noexcept=default

auto	operator= (dynamic_multidim_size const &other) -> dynamic_multidim_size &=default

auto	operator= (dynamic_multidim_size &&other) noexcept -> dynamic_multidim_size &=default

	~dynamic_multidim_size ()=default

template<typename OtherIndexing >
	dynamic_multidim_size (dynamic_multidim_size< OtherIndexing > const &other)

template<typename OtherIndexing >
	dynamic_multidim_size (dynamic_multidim_size< OtherIndexing > &&other)

template<typename OtherIndexing >
auto	operator= (dynamic_multidim_size< OtherIndexing > const &other) -> dynamic_multidim_size &

template<typename OtherIndexing >
auto	operator= (dynamic_multidim_size< OtherIndexing > &&other) -> dynamic_multidim_size &

	dynamic_multidim_size (integral auto const ... size)

	dynamic_multidim_size (std::vector< std::size_t > &&size)

	dynamic_multidim_size (integral_range auto const &size)

template<typename OtherIndexing >
auto	operator== (dynamic_multidim_size< OtherIndexing > const &other) const

template<typename OtherIndexing >
auto	operator!= (dynamic_multidim_size< OtherIndexing > const &other) const

auto	num_dimensions () const

auto	size () const -> auto const &

auto	size (std::size_t const i) const

auto	num_components () const

auto	resize (integral auto const ... size) -> void

auto	resize (integral_range auto const &size) -> void

auto	resize (std::vector< std::size_t > &&size) -> void

auto	resize (std::vector< std::size_t > const &size) -> void

auto constexpr	in_range (integral auto const ... indices) const

auto constexpr	in_range (integral_range auto const &indices) const

auto constexpr	plain_index (integral auto const ... indices) const

auto constexpr	plain_index (integral_range auto const &indices) const

auto constexpr	multi_index (std::size_t const gi) const

auto	begin_indices () const

auto	end_indices () const

auto	indices () const

Static Public Member Functions
static auto	default_value () -> value_type &

Private Member Functions
auto	init (std::vector< std::size_t > const &chunk_size) -> void

auto	create_mutexes ()

auto	read_chunk (std::size_t const plain_chunk_index, integral auto const ... indices) const -> auto const &

template<integral Index, std::size_t N, std::size_t... Seq>
auto	at (std::array< Index, N > const &indices, std::index_sequence< Seq... >) const -> value_type const &

Private Attributes
DataSet	m_dataset

std::vector< bool >	m_read

std::size_t	m_max_num_chunks_loaded = 1024

bool	m_limit_num_chunks_loaded = false

std::mutex	m_chunks_loaded_mutex

std::vector< std::size_t >	m_chunks_loaded

std::vector< std::unique_ptr< std::mutex > >	m_mutexes

Additional Inherited Members
Protected Attributes inherited from tatooine::chunked_multidim_array< T, GlobalIndexOrder, LocalIndexOrder >
chunk_ptr_field_t	m_chunks