Class: Omnizip::Algorithms::LZMA2::ChunkManager

Inherits:
Object
  • Object
show all
Includes:
Constants
Defined in:
lib/omnizip/algorithms/lzma2/chunk_manager.rb

Overview

LZMA2 Chunk Manager - handles chunk boundaries and decisions

This class is responsible for:

  • Splitting data into chunks of appropriate size
  • Deciding whether to compress or store each chunk uncompressed
  • Managing chunk buffering
  • Providing thread safety infrastructure (for future use)

The chunk manager implements intelligent compression decisions based on compression ratio thresholds.

IMPORTANT: LZMA2 format limits uncompressed chunk size to 65536 bytes due to 2-byte size encoding. This manager enforces that limit.

Defined Under Namespace

Classes: Chunk

Constant Summary collapse

MAX_CHUNK_BYTES =

Maximum bytes per chunk (LZMA2 spec limit)

UNCOMPRESSED_SIZE_MAX + 1

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(chunk_size = CHUNK_SIZE_DEFAULT) ⇒ ChunkManager

Initialize chunk manager

Parameters:

  • chunk_size (Integer) (defaults to: CHUNK_SIZE_DEFAULT) —

    Desired chunk size



96
97
98
99
100
 
# File 'lib/omnizip/algorithms/lzma2/chunk_manager.rb', line 96

def initialize(chunk_size = CHUNK_SIZE_DEFAULT)
  @chunk_size = validate_chunk_size(chunk_size)
  # Enforce LZMA2 format limit
  @effective_chunk_size = [@chunk_size, MAX_CHUNK_BYTES].min
end

Instance Attribute Details

#chunk_size ⇒ Object (readonly)

Returns the value of attribute chunk_size.



42
43
44
 
# File 'lib/omnizip/algorithms/lzma2/chunk_manager.rb', line 42

def chunk_size
  @chunk_size
end

Instance Method Details

#create_chunks(data) ⇒ Array<Chunk>

Split data into chunks

Parameters:

  • data (String) —

    Data to split

Returns:

  • (Array<Chunk>) —

    Array of chunks



106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/omnizip/algorithms/lzma2/chunk_manager.rb', line 106

def create_chunks(data)
  chunks = []
  pos = 0

  while pos < data.bytesize
    chunk_data = data.byteslice(pos, @effective_chunk_size)
    chunks << Chunk.new(chunk_data)
    pos += @effective_chunk_size
  end

  chunks
end

#last_chunk?(chunk_index, total_chunks) ⇒ Boolean

Decide if chunk is last chunk

Parameters:

  • chunk_index (Integer) —

    Current chunk index

  • total_chunks (Integer) —

    Total number of chunks

Returns:

  • (Boolean) —

    True if last chunk



142
143
144
 
# File 'lib/omnizip/algorithms/lzma2/chunk_manager.rb', line 142

def last_chunk?(chunk_index, total_chunks)
  chunk_index == total_chunks - 1
end

#optimal_chunk_size(data_size) ⇒ Integer

Calculate optimal chunk size for data

This method can be used to dynamically adjust chunk size based on data characteristics (future enhancement).

Parameters:

  • data_size (Integer) —

    Total data size

Returns:

  • (Integer) —

    Optimal chunk size



153
154
155
156
157
158
159
160
 
# File 'lib/omnizip/algorithms/lzma2/chunk_manager.rb', line 153

def optimal_chunk_size(data_size)
  # For now, use effective chunk size
  # Future: could adjust based on data size
  return @effective_chunk_size if data_size <= @effective_chunk_size * 2

  # For larger data, might want larger chunks (up to max)
  [@effective_chunk_size * 2, MAX_CHUNK_BYTES].min
end

#should_compress?(chunk) ⇒ Boolean

Decide if chunk should be compressed

Makes decision based on compression ratio threshold. If compressed size is not significantly smaller than uncompressed size, store uncompressed.

Parameters:

  • chunk (Chunk) —

    Chunk with compressed data set

Returns:

  • (Boolean) —

    True if should use compression



127
128
129
130
131
132
133
134
135
 
# File 'lib/omnizip/algorithms/lzma2/chunk_manager.rb', line 127

def should_compress?(chunk)
  return false unless chunk.compressed_data

  # Calculate compression ratio
  ratio = chunk.output_size.to_f / chunk.uncompressed_size

  # Only use compression if ratio is below threshold
  ratio < COMPRESSION_THRESHOLD
end