README

Lampese/lomo/op does not have a README file

#
CounterOp

pub struct CounterOp {
delta : Double
}

impl Show for CounterOp

#
CounterOp::delta

fn CounterOp::delta(self : CounterOp) -> Double

#
CounterOp::new

fn CounterOp::new(delta : Double) -> CounterOp

#
DeleteSpan

pub struct DeleteSpan {
pos : Int
signed_len : Int
}

impl Eq for DeleteSpan
impl Show for DeleteSpan

#
DeleteSpan::bidirectional

fn DeleteSpan::bidirectional(self : DeleteSpan) -> Bool

#
DeleteSpan::direction

fn DeleteSpan::direction(self : DeleteSpan) -> Int

#
DeleteSpan::end

fn DeleteSpan::end(self : DeleteSpan) -> Int

#
DeleteSpan::is_mergeable

fn DeleteSpan::is_mergeable(self : DeleteSpan, other : DeleteSpan) -> Bool

#
DeleteSpan::is_reversed

fn DeleteSpan::is_reversed(self : DeleteSpan) -> Bool

#
DeleteSpan::last

fn DeleteSpan::last(self : DeleteSpan) -> Int

#
DeleteSpan::len

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

#
DeleteSpan::merge

fn DeleteSpan::merge(self : DeleteSpan, other : DeleteSpan) -> DeleteSpan

#
DeleteSpan::new

fn DeleteSpan::new(pos : Int, len : Int) -> DeleteSpan

#
DeleteSpan::next_pos

fn DeleteSpan::next_pos(self : DeleteSpan) -> Int

#
DeleteSpan::pos

fn DeleteSpan::pos(self : DeleteSpan) -> Int

#
DeleteSpan::prev_pos

fn DeleteSpan::prev_pos(self : DeleteSpan) -> Int

#
DeleteSpan::signed_len

fn DeleteSpan::signed_len(self : DeleteSpan) -> Int

#
DeleteSpan::slice

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

#
DeleteSpan::start

fn DeleteSpan::start(self : DeleteSpan) -> Int

#
DeleteSpanWithId

pub struct DeleteSpanWithId {
id_start :
ID

span : DeleteSpan
}

#
DeleteSpanWithId::content_len

fn DeleteSpanWithId::content_len(self : DeleteSpanWithId) -> Int

#
DeleteSpanWithId::end

fn DeleteSpanWithId::end(self : DeleteSpanWithId) -> Int

#
DeleteSpanWithId::id_end

#
DeleteSpanWithId::id_last

#
DeleteSpanWithId::id_start

#
DeleteSpanWithId::is_mergeable

fn DeleteSpanWithId::is_mergeable(self : DeleteSpanWithId, other : DeleteSpanWithId) -> Bool

#
DeleteSpanWithId::is_reversed

fn DeleteSpanWithId::is_reversed(self : DeleteSpanWithId) -> Bool

#
DeleteSpanWithId::last

fn DeleteSpanWithId::last(self : DeleteSpanWithId) -> Int

#
DeleteSpanWithId::merge

#
DeleteSpanWithId::new

fn DeleteSpanWithId::new(id_start :
ID
, pos : Int, len : Int) -> DeleteSpanWithId

#
DeleteSpanWithId::slice

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

#
DeleteSpanWithId::span

#
DeleteSpanWithId::start

fn DeleteSpanWithId::start(self : DeleteSpanWithId) -> Int

#
InnerContent

pub(all) enum InnerContent {
List(InnerListOp)
Map(MapSet)
Tree(TreeOp)
Counter(CounterOp)
RichText
MovableList
Unknown
}

#
InnerContent::content_len

fn InnerContent::content_len(self : InnerContent) -> Int

#
InnerContent::slice

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

#
InnerListOp

pub(all) enum InnerListOp {
Insert(SliceRange, Int)
InsertText(String, Int, Int, Int)
Delete(DeleteSpanWithId)
Move(Int,
IdLp
, Int)
Set(
IdLp
,
LoroValue
)
StyleStart(Int, Int, String, Int,
LoroValue
)
StyleEnd
}

impl Show for InnerListOp

#
InnerListOp::content_len

fn InnerListOp::content_len(self : InnerListOp) -> Int

#
InnerListOp::is_mergeable

fn InnerListOp::is_mergeable(self : InnerListOp, other : InnerListOp) -> Bool

#
InnerListOp::merge

fn InnerListOp::merge(self : InnerListOp, other : InnerListOp) -> InnerListOp

#
InnerListOp::slice

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

#
ListOp

pub(all) enum ListOp {
Insert(ListSlice, Int)
Delete(DeleteSpanWithId)
Move(Int, Int,
IdLp
)
Set(
IdLp
,
LoroValue
)
StyleStart(Int, Int, String, Int,
LoroValue
)
StyleEnd
}

impl Show for ListOp

#
ListOp::content_len

fn ListOp::content_len(self : ListOp) -> Int

#
ListOp::is_mergeable

fn ListOp::is_mergeable(self : ListOp, other : ListOp) -> Bool

#
ListOp::merge

fn ListOp::merge(self : ListOp, other : ListOp) -> ListOp

#
ListOp::new_del

fn ListOp::new_del(id_start :
ID
, pos : Int, len : Int) -> ListOp

#
ListOp::slice

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

#
ListSlice

pub(all) enum ListSlice {
RawData(Array[
LoroValue
])
RawStr(String, Int)
}

impl Show for ListSlice

#
ListSlice::content_len

fn ListSlice::content_len(self : ListSlice) -> Int

#
ListSlice::from_str

fn ListSlice::from_str(str : String) -> ListSlice

#
ListSlice::is_mergeable

fn ListSlice::is_mergeable(_self : ListSlice, _other : ListSlice) -> Bool

#
ListSlice::slice

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

#
MapSet

pub struct MapSet {
key : String
value :
LoroValue
?
}

impl Show for MapSet

#
MapSet::key

fn MapSet::key(self : MapSet) -> String

#
MapSet::new

fn MapSet::new(key : String, value :
LoroValue
?) -> MapSet

#
MapSet::value

pub struct Op {
counter : Int
container :
ContainerID

content : InnerContent
}

impl Show for Op

#
Op::container

#
Op::content

fn Op::content(self : Op) -> InnerContent

#
Op::content_len

fn Op::content_len(self : Op) -> Int

#
Op::counter

fn Op::counter(self : Op) -> Int

#
Op::new

fn Op::new(counter : Int, container :
ContainerID
, content : InnerContent) -> Op

#
Op::slice

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

#
RawOp

pub struct RawOp {
id :
ID

lamport : UInt
container :
ContainerID

content : RawOpContent
}

impl Show for RawOp

#
RawOp::container

#
RawOp::content

fn RawOp::content(self : RawOp) -> RawOpContent

#
RawOp::id

#
RawOp::id_full

#
RawOp::lamport

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

#
RawOp::new

fn RawOp::new(id :
ID
, lamport : UInt, container :
ContainerID
, content : RawOpContent) -> RawOp

#
RawOpContent

pub(all) enum RawOpContent {
Map(MapSet)
List(ListOp)
Tree(TreeOp)
Counter(CounterOp)
}

#
RawOpContent::content_len

fn RawOpContent::content_len(self : RawOpContent) -> Int

#
SliceRange

pub struct SliceRange {
start : UInt
end : UInt
}

impl Eq for SliceRange
impl Show for SliceRange

#
SliceRange::end

fn SliceRange::end(self : SliceRange) -> UInt

#
SliceRange::is_mergeable

fn SliceRange::is_mergeable(self : SliceRange, other : SliceRange) -> Bool

#
SliceRange::is_unknown

fn SliceRange::is_unknown(self : SliceRange) -> Bool

#
SliceRange::len

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

#
SliceRange::merge

fn SliceRange::merge(self : SliceRange, other : SliceRange) -> SliceRange

#
SliceRange::new

fn SliceRange::new(start : UInt, end : UInt) -> SliceRange

#
SliceRange::new_unknown

fn SliceRange::new_unknown(size : UInt) -> SliceRange

#
SliceRange::slice

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

#
SliceRange::start

fn SliceRange::start(self : SliceRange) -> UInt