Struct OutOfCoreArray 

pub struct OutOfCoreArray<A, D>
where
    A: Clone + Serialize + for<'de> Deserialize<'de>,
    D: Dimension + Serialize + for<'de> Deserialize<'de>,
{ /* private fields */ }

An array that stores data on disk to reduce memory usage

Implementations

impl<A, D> OutOfCoreArray<A, D>

where A: Clone + Serialize + for<'de> Deserialize<'de>, D: Dimension + Serialize + for<'de> Deserialize<'de>,

pub fn shape(&self) -> &[usize]

Get the shape of the array

pub fn file_path(&self) -> &Path

Get the file path

pub fn strategy(&self) -> ChunkingStrategy

Get the chunking strategy

pub fn size(&self) -> usize

Get the total size in elements

impl<A, D> OutOfCoreArray<A, D>

where A: Clone + Serialize + for<'de> Deserialize<'de>, D: Dimension + Serialize + for<'de> Deserialize<'de>,

pub fn new<S>( data: &ArrayBase<S, D>, file_path: &Path, strategy: ChunkingStrategy, ) -> Result<Self, CoreError>

where S: Data<Elem = A>,

Create a new out-of-core array with the given data and file path

This uses the V2 format by default for efficient chunk-based access. Use new_v1() if you need backward compatibility with the V1 format.

pub fn new_v1<S>( data: &ArrayBase<S, D>, file_path: &Path, strategy: ChunkingStrategy, ) -> Result<Self, CoreError>

where S: Data<Elem = A>,

Create a new out-of-core array using V1 format (legacy)

This method is provided for backward compatibility. New code should use new() instead.

pub fn open(file_path: &Path) -> Result<Self, CoreError>

Open an existing out-of-core array file with automatic version detection

This method detects whether the file is in V1 or V2 format and loads it accordingly.

pub fn migrate_to_v2( &self, new_file_path: &Path, compression: CompressionType, ) -> Result<Self, CoreError>

Migrate a V1 format file to V2 format

This creates a new V2 file at the specified path with the data from this array. Returns a new OutOfCoreArray using the V2 format.

pub fn new_temp<S>( data: &ArrayBase<S, D>, strategy: ChunkingStrategy, ) -> Result<Self, CoreError>

where S: Data<Elem = A>,

Create a new out-of-core array with a temporary file

Uses V2 format by default for efficient chunk-based access.

pub fn load(&self) -> Result<Array<A, D>, CoreError>

Load the entire array into memory

pub fn load_chunk(&self, chunkindex: usize) -> Result<Array<A, D>, CoreError>

Load a chunk of the array into memory

For V2 format, this efficiently seeks to and loads only the requested chunk. For V1 format (legacy), this loads the entire array and extracts the chunk.

pub fn num_chunks(&self) -> usize

Get the number of chunks

pub fn is_temp(&self) -> bool

Check if the array is temporary

pub fn map<F, B, R>(&self, f: F) -> Result<R, CoreError>

where F: FnMut(Array<A, D>) -> B, R: FromIterator<B>,

Apply a function to each chunk of the array

pub fn par_map<F, B, R>(&self, f: F) -> Result<R, CoreError>

where F: Fn(Array<A, D>) -> B + Send + Sync, B: Send, R: FromIterator<B> + Send, A: Send + Sync,

Apply a function to each chunk of the array in parallel

Trait Implementations

impl<A, D> Debug for OutOfCoreArray<A, D>

where A: Clone + Serialize + for<'de> Deserialize<'de> + Debug, D: Dimension + Serialize + for<'de> Deserialize<'de> + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<A, D> Drop for OutOfCoreArray<A, D>

where A: Clone + Serialize + for<'de> Deserialize<'de>, D: Dimension + Serialize + for<'de> Deserialize<'de>,

fn drop(&mut self)

Executes the destructor for this type.