mirror of
https://github.com/codex-storage/nim-codex.git
synced 2025-01-10 04:55:40 +00:00
fffb674bba
* rework merkle tree support * rename merkletree -> codexmerkletree * treed and proof encoding/decoding * style * adding codex merkle and coders tests * use default hash codec * proof size changed * add from nodes test * shorte file names * wip poseidon tree * shorten file names * root returns a result * import poseidon tests * fix merge issues and cleanup a few warnings * setting up slot builder * Getting cids in slot * ensures blocks are devisable by number of slots * wip * Implements indexing strategies * Swaps in indexing strategy into erasure. * wires slot and indexing tests up * Fixes issue where indexing strategy stepped gives wrong values for smallest of ranges * debugs indexing strategies * Can select slot blocks * finding number of pad cells * Implements building slot tree * finishes implementing slot builder * Adds check that block size is a multiple of cell size * Cleanup slotbuilder * Review comments by Tomasz * Fixes issue where ecK was used as numberOfSlots. * rework merkle tree support * deps * rename merkletree -> codexmerkletree * treed and proof encoding/decoding * style * adding codex merkle and coders tests * remove new codecs for now * proof size changed * add from nodes test * shorte file names * wip poseidon tree * shorten file names * fix bad `elements` iter * bump * bump * wip * reworking slotbuilder * move out of manifest * expose getCidAndProof * import index strat... * remove getMHash * remove unused artifacts * alias zero * add digest for multihash * merge issues * remove unused hashes * add option to result converter * misc * fix tests * add helper to derive EC block count * rename method * misc * bump * extract slot root building into own proc * revert to manifest to accessor --------- Co-authored-by: benbierens <thatbenbierens@gmail.com>
62 lines
2.2 KiB
Nim
62 lines
2.2 KiB
Nim
import std/sequtils
|
|
import ./utils
|
|
|
|
# I'm choosing to use an assert here because:
|
|
# 1. These are a programmer errors and *should not* happen during application runtime.
|
|
# 2. Users don't have to deal with Result types.
|
|
|
|
type
|
|
# Representing a strategy for grouping indices (of blocks usually)
|
|
# Given an interation-count as input, will produce a seq of
|
|
# selected indices.
|
|
IndexingStrategy* = ref object of RootObj
|
|
firstIndex*: int # Lowest index that can be returned
|
|
lastIndex*: int # Highest index that can be returned
|
|
numberOfIterations*: int # getIndices(iteration) will run from 0 ..< numberOfIterations
|
|
step*: int
|
|
|
|
# Simplest approach:
|
|
# 0 => 0, 1, 2
|
|
# 1 => 3, 4, 5
|
|
# 2 => 6, 7, 8
|
|
LinearIndexingStrategy* = ref object of IndexingStrategy
|
|
|
|
# Stepped indexing:
|
|
# 0 => 0, 3, 6
|
|
# 1 => 1, 4, 7
|
|
# 2 => 2, 5, 8
|
|
SteppedIndexingStrategy* = ref object of IndexingStrategy
|
|
|
|
proc assertIteration(self: IndexingStrategy, iteration: int): void =
|
|
if iteration >= self.numberOfIterations:
|
|
raiseAssert("Indexing iteration can't be greater than or equal to numberOfIterations.")
|
|
|
|
method getIndicies*(self: IndexingStrategy, iteration: int): seq[int] {.base.} =
|
|
raiseAssert("Not implemented")
|
|
|
|
proc new*(T: type IndexingStrategy, firstIndex, lastIndex, numberOfIterations: int): T =
|
|
if firstIndex > lastIndex:
|
|
raiseAssert("firstIndex (" & $firstIndex & ") can't be greater than lastIndex (" & $lastIndex & ")")
|
|
if numberOfIterations <= 0:
|
|
raiseAssert("numberOfIteration (" & $numberOfIterations & ") must be greater than zero.")
|
|
|
|
T(
|
|
firstIndex: firstIndex,
|
|
lastIndex: lastIndex,
|
|
numberOfIterations: numberOfIterations,
|
|
step: divUp((lastIndex - firstIndex), numberOfIterations)
|
|
)
|
|
|
|
method getIndicies*(self: LinearIndexingStrategy, iteration: int): seq[int] =
|
|
self.assertIteration(iteration)
|
|
|
|
let
|
|
first = self.firstIndex + iteration * (self.step + 1)
|
|
last = min(first + self.step, self.lastIndex)
|
|
|
|
toSeq(countup(first, last, 1))
|
|
|
|
method getIndicies*(self: SteppedIndexingStrategy, iteration: int): seq[int] =
|
|
self.assertIteration(iteration)
|
|
toSeq(countup(self.firstIndex + iteration, self.lastIndex, self.numberOfIterations))
|