Safe Haskell	None
Language	Haskell2010

Ouroboros.Consensus.Fragment.Diff

Contents

Queries
Constructors
Application
Manipulation

Description

Intended for qualified import

import Ouroboros.Consensus.Fragment.Diff (ChainDiff (..))
import qualified Ouroboros.Consensus.Fragment.Diff as Diff

Synopsis

data ChainDiff b = ChainDiff {
- getRollback :: ! Word64
- getSuffix :: !( AnchoredFragment b)
}
getAnchorPoint :: ChainDiff b -> Point b
getTip :: HasHeader b => ChainDiff b -> Point b
rollbackExceedsSuffix :: HasHeader b => ChainDiff b -> Bool
diff :: ( HasHeader b, HasCallStack ) => AnchoredFragment b -> AnchoredFragment b -> ChainDiff b
extend :: AnchoredFragment b -> ChainDiff b
apply :: HasHeader b => AnchoredFragment b -> ChainDiff b -> Maybe ( AnchoredFragment b)
append :: HasHeader b => ChainDiff b -> b -> ChainDiff b
mapM :: forall a b m. ( HasHeader b, HeaderHash a ~ HeaderHash b, Monad m) => (a -> m b) -> ChainDiff a -> m ( ChainDiff b)
takeWhileOldest :: HasHeader b => (b -> Bool ) -> ChainDiff b -> ChainDiff b
truncate :: ( HasHeader b, HasCallStack ) => Point b -> ChainDiff b -> ChainDiff b

Documentation

data ChainDiff b Source #

A diff of a chain (fragment).

Typical instantiations of the type argument b : a block type blk , Header blk , HeaderFields , ..., anything that supports HasHeader .

Note: we allow the suffix to be shorter than the number of blocks to roll back. In other words, applying a ChainDiff can result in a chain shorter than the chain to which the diff was applied.

Constructors

ChainDiff
Fields getRollback :: ! Word64 The number of blocks/headers to roll back the current chain getSuffix :: !( AnchoredFragment b) The new blocks/headers to add after rolling back the current chain.

Instances

Instances details

( StandardHash b, Eq b) => Eq ( ChainDiff b) Source #
Instance details Defined in Ouroboros.Consensus.Fragment.Diff Methods (==) :: ChainDiff b -> ChainDiff b -> Bool Source # (/=) :: ChainDiff b -> ChainDiff b -> Bool Source #
( StandardHash b, Show b) => Show ( ChainDiff b) Source #
Instance details Defined in Ouroboros.Consensus.Fragment.Diff Methods showsPrec :: Int -> ChainDiff b -> ShowS Source # show :: ChainDiff b -> String Source # showList :: [ ChainDiff b] -> ShowS Source #

Queries

getAnchorPoint :: ChainDiff b -> Point b Source #

Return the anchor point of the new suffix

getTip :: HasHeader b => ChainDiff b -> Point b Source #

Return the tip of the new suffix

rollbackExceedsSuffix :: HasHeader b => ChainDiff b -> Bool Source #

Return True iff applying the ChainDiff to a chain C will result in a chain shorter than C , i.e., the number of blocks to roll back is greater than the length of the new elements in the suffix to add.

Constructors

diff Source #

Arguments

:: ( HasHeader b, HasCallStack )
=> AnchoredFragment b	Current chain
-> AnchoredFragment b	Candidate chain
-> ChainDiff b

Diff a candidate chain with the current chain.

If the candidate fragment is shorter than the current chain, Nothing is returned (this would violate the invariant of ChainDiff ).

PRECONDITION: the candidate fragment must intersect with the current chain fragment.

extend :: AnchoredFragment b -> ChainDiff b Source #

Make an extension-only (no rollback) ChainDiff .

Application

apply :: HasHeader b => AnchoredFragment b -> ChainDiff b -> Maybe ( AnchoredFragment b) Source #

Apply the ChainDiff on the given chain fragment.

The fragment is first rolled back a number of blocks before appending the new suffix.

If the ChainDiff doesn't fit (anchor point mismatch), Nothing is returned.

The returned fragment will have the same anchor point as the given fragment.

Manipulation

append :: HasHeader b => ChainDiff b -> b -> ChainDiff b Source #

Append a b to a ChainDiff .

PRECONDITION: it must fit onto the end of the suffix.

mapM :: forall a b m. ( HasHeader b, HeaderHash a ~ HeaderHash b, Monad m) => (a -> m b) -> ChainDiff a -> m ( ChainDiff b) Source #

takeWhileOldest :: HasHeader b => (b -> Bool ) -> ChainDiff b -> ChainDiff b Source #

Return the longest prefix of the suffix matching the given predicate, starting from the left, i.e., the "oldest" blocks.

If the new suffix is shorter than the diff's rollback, return Nothing .

truncate :: ( HasHeader b, HasCallStack ) => Point b -> ChainDiff b -> ChainDiff b Source #

Truncate the diff by rolling back the new suffix to the given point.

PRECONDITION: the given point must correspond to one of the new blocks/headers of the new suffix or its anchor (i.e, withinFragmentBounds pt (getSuffix diff) ).

If the length of the truncated suffix is shorter than the rollback, Nothing is returned.