use crate::segment::grow_segment::GrowSegment;
use crate::segment::piece::Piece;
use crate::segment::pieced_segment::PiecedSegment;
#[derive(Debug)]
pub enum SegmentKind {
Pieced(Box<PiecedSegment>),
Grow(GrowSegment),
}
impl SegmentKind {
pub fn is_complete(&self) -> bool {
match self {
SegmentKind::Pieced(p) => p.is_complete(),
SegmentKind::Grow(g) => g.is_complete(),
}
}
pub fn index(&self) -> usize {
match self {
SegmentKind::Pieced(p) => p.index(),
SegmentKind::Grow(g) => g.index(),
}
}
pub fn position(&self) -> u64 {
match self {
SegmentKind::Pieced(p) => p.position(),
SegmentKind::Grow(g) => g.position(),
}
}
pub fn position_to_write(&self) -> u64 {
match self {
SegmentKind::Pieced(p) => p.position_to_write(),
SegmentKind::Grow(g) => g.position_to_write(),
}
}
pub fn length(&self) -> u64 {
match self {
SegmentKind::Pieced(p) => p.length(),
SegmentKind::Grow(g) => g.length(),
}
}
pub fn segment_length(&self) -> u64 {
match self {
SegmentKind::Pieced(p) => p.segment_length(),
SegmentKind::Grow(g) => g.segment_length(),
}
}
pub fn written_length(&self) -> u64 {
match self {
SegmentKind::Pieced(p) => p.written_length(),
SegmentKind::Grow(g) => g.written_length(),
}
}
pub fn update_written_length(&mut self, bytes: u64) {
match self {
SegmentKind::Pieced(p) => p.update_written_length(bytes),
SegmentKind::Grow(g) => g.update_written_length(bytes),
}
}
pub fn update_hash(&mut self, begin: u64, data: &[u8]) -> bool {
match self {
SegmentKind::Pieced(p) => p.update_hash(begin, data),
SegmentKind::Grow(g) => g.update_hash(begin, data),
}
}
pub fn is_hash_calculated(&self) -> bool {
match self {
SegmentKind::Pieced(p) => p.is_hash_calculated(),
SegmentKind::Grow(g) => g.is_hash_calculated(),
}
}
pub fn digest(&mut self) -> String {
match self {
SegmentKind::Pieced(p) => p.digest(),
SegmentKind::Grow(g) => g.digest(),
}
}
pub fn piece(&self) -> Option<&Piece> {
match self {
SegmentKind::Pieced(p) => Some(p.piece()),
SegmentKind::Grow(_) => None,
}
}
pub fn piece_mut(&mut self) -> Option<&mut Piece> {
match self {
SegmentKind::Pieced(p) => Some(p.piece_mut()),
SegmentKind::Grow(_) => None,
}
}
}
impl PartialEq for SegmentKind {
fn eq(&self, other: &Self) -> bool {
self.index() == other.index()
}
}
impl Eq for SegmentKind {}