README

Lampese/lomo/oplog does not have a README file

#
AppDag

#
AppDag::calc_unknown_lamport_change

fn AppDag::calc_unknown_lamport_change(self : AppDag, change : Change) -> Result[Change,
LoroError
]

#
AppDag::contains

fn AppDag::contains(self : AppDag, id :
ID
) -> Bool

#
AppDag::frontiers

#
AppDag::get_lamport

fn AppDag::get_lamport(self : AppDag, id :
ID
) -> UInt?

#
AppDag::get_node

fn AppDag::get_node(self : AppDag, id :
ID
) -> AppDagNode?

#
AppDag::handle_deps_break_points

fn AppDag::handle_deps_break_points(self : AppDag, deps :
Frontiers
, skip_peer : UInt64) -> Unit

#
AppDag::handle_new_change

fn AppDag::handle_new_change(self : AppDag, change : Change) -> Unit

#
AppDag::is_empty

fn AppDag::is_empty(self : AppDag) -> Bool

#
AppDag::new

fn AppDag::new() -> AppDag

#
AppDagNode

pub struct AppDagNode {
peer : UInt64
cnt : Int
lamport : UInt
deps :
Frontiers

len : Int
has_succ : Bool
}

impl Show for AppDagNode

#
AppDagNode::contains_id

fn AppDagNode::contains_id(self : AppDagNode, id :
ID
) -> Bool

#
AppDagNode::ctr_end

fn AppDagNode::ctr_end(self : AppDagNode) -> Int

#
AppDagNode::id_end

#
AppDagNode::id_last

#
AppDagNode::id_start

#
AppDagNode::lamport_at

fn AppDagNode::lamport_at(self : AppDagNode, id :
ID
) -> UInt

#
AppDagNode::slice

fn AppDagNode::slice(self : AppDagNode, from : Int, to : Int) -> AppDagNode

#
Change

pub struct Change {
id :
ID

lamport : UInt
deps :
Frontiers

timestamp : Int64
commit_msg : String?
origin : String?
ops : Array[
Op
]
}

impl Show for Change

#
Change::commit_msg

fn Change::commit_msg(self : Change) -> String?

#
Change::ctr_span

#
Change::deps_on_self

fn Change::deps_on_self(self : Change) -> Bool

#
Change::id

#
Change::id_end

fn Change::id_end(self : Change) ->
ID

#
Change::id_last

fn Change::id_last(self : Change) ->
ID

#
Change::id_span

#
Change::is_empty

fn Change::is_empty(self : Change) -> Bool

#
Change::lamport

fn Change::lamport(self : Change) -> UInt

#
Change::len

fn Change::len(self : Change) -> Int

#
Change::new

fn Change::new(ops : Array[
Op
], deps :
Frontiers
, id :
ID
, lamport : UInt, timestamp : Int64) -> Change

#
Change::new_with_meta

fn Change::new_with_meta(ops : Array[
Op
], deps :
Frontiers
, id :
ID
, lamport : UInt, timestamp : Int64, commit_msg : String?, origin : String?) -> Change

#
Change::ops

#
Change::origin

fn Change::origin(self : Change) -> String?

#
Change::peer

fn Change::peer(self : Change) -> UInt64

#
Change::slice

fn Change::slice(self : Change, from : Int, to : Int) -> Change

#
Change::timestamp

fn Change::timestamp(self : Change) -> Int64

#
ChangeState

pub enum ChangeState {
Applied
CanApplyDirectly
AwaitingMissingDependency(
ID
)
}

impl Show for ChangeState

#
OpLog

pub struct OpLog {
dag : AppDag
changes : Map[
ID
, Change]
change_order : Array[
ID
]
pending_changes : PendingChanges
}

#
OpLog::all_changes

fn OpLog::all_changes(self : OpLog) -> Array[Change]

#
OpLog::apply_change_from_remote

fn OpLog::apply_change_from_remote(self : OpLog, pending_change : PendingChange) -> Unit

#
OpLog::changes_sorted

fn OpLog::changes_sorted(self : OpLog) -> Array[Change]

#
OpLog::dag

fn OpLog::dag(self : OpLog) -> AppDag

#
OpLog::extend_pending_changes_with_unknown_lamport

fn OpLog::extend_pending_changes_with_unknown_lamport(self : OpLog, remote_changes : Array[Change]) -> Result[Unit,
LoroError
]

#
OpLog::frontiers

#
OpLog::get_change

fn OpLog::get_change(self : OpLog, id :
ID
) -> Change?

#
OpLog::import_local_change

fn OpLog::import_local_change(self : OpLog, change : Change) -> Result[Unit,
LoroError
]

#
OpLog::insert_new_change

fn OpLog::insert_new_change(self : OpLog, change : Change, _from_local : Bool) -> Unit

#
OpLog::is_empty

fn OpLog::is_empty(self : OpLog) -> Bool

#
OpLog::new

fn OpLog::new() -> OpLog

#
OpLog::trim_the_known_part_of_change

fn OpLog::trim_the_known_part_of_change(self : OpLog, change : Change) -> Change?

#
OpLog::try_apply_pending

fn OpLog::try_apply_pending(self : OpLog, new_ids : Array[
ID
]) -> Unit

#
PendingChange

pub enum PendingChange {
Unknown(Change)
Known(Change)
}

#
PendingChanges

pub struct PendingChanges {
changes : Map[UInt64, Map[Int, Array[PendingChange]]]
}

#
PendingChanges::new

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io