Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-24 09:04:33 +01:00
Code Issues Projects Releases Packages Wiki Activity

Move Range::relation_to_range

Browse source
This commit is contained in:
Brian J. Burg 2012-11-18 18:31:01 -08:00
parent 0562871cc7
commit a706a57f32
1 changed files with 48 additions and 53 deletions
Download patch file Download diff file Expand all files Collapse all files

101
src/servo-gfx/util/range.rs
View file

@ -52,55 +52,6 @@ pub impl Range {
pub pure fn adjust_by(off_i: int, len_i: int) -> Range {
Range(((self.off as int) + off_i) as uint, ((self.len as int) + len_i) as uint)
}
/// Computes the relationship between two ranges (`self` and `other`),
/// from the point of view of `self`. So, 'EntirelyBefore' means
/// that the `self` range is entirely before `other` range.
fn relation_to_range(&self, other: Range) -> RangeRelation {
if other.begin() > self.end() {
return EntirelyBefore;
}
if self.begin() > other.end() {
return EntirelyAfter;
}
if self.begin() == other.begin() && self.end() == other.end() {
return Coincides;
}
if self.begin() <= other.begin() && self.end() >= other.end() {
return Contains;
}
if self.begin() >= other.begin() && self.end() <= other.end() {
return ContainedBy;
}
if self.begin() < other.begin() && self.end() < other.end() {
let overlap = self.end() - other.begin();
return OverlapsBegin(overlap);
}
if self.begin() > other.begin() && self.end() > other.end() {
let overlap = other.end() - self.begin();
return OverlapsEnd(overlap);
}
fail fmt!("relation_to_range(): didn't classify self=%?, other=%?",
self, other);
}
fn repair_after_coalesced_range(&self, other: Range) -> Range {
let relation = self.relation_to_range(other);
debug!("repair_after_coalesced_range: possibly repairing range %?", self);
debug!("repair_after_coalesced_range: relation of original range and coalesced range(%?): %?",
other, relation);
let new_range = match relation {
EntirelyBefore => { *self },
EntirelyAfter => { self.shift_by(-(other.length() as int)) },
Coincides | ContainedBy => { Range(other.begin(), 1) },
Contains => { self.extend_by(-(other.length() as int)) },
OverlapsBegin(overlap) => { self.extend_by(1 - (overlap as int)) },
OverlapsEnd(overlap) =>
{ Range(other.begin(), self.length() - overlap + 1) }
};
debug!("repair_after_coalesced_range: new range: ---- %?", new_range);
new_range
}
}
pub pure fn empty_mut() -> MutableRange { MutableRange::new(0, 0) }
@ -132,10 +83,6 @@ pub impl MutableRange {
i >= self.begin() && i < self.end()
}
fn relation_to_range(&const self, other: &MutableRange) -> RangeRelation {
self.as_immutable().relation_to_range(other.as_immutable())
}
pure fn as_immutable(&const self) -> Range {
Range(self.begin(), self.length())
}
@ -165,4 +112,52 @@ pub impl MutableRange {
self.off = off_i;
self.len = len_i;
}
/// Computes the relationship between two ranges (`self` and `other`),
/// from the point of view of `self`. So, 'EntirelyBefore' means
/// that the `self` range is entirely before `other` range.
pure fn relation_to_range(&const self, other: &const MutableRange) -> RangeRelation {
if other.begin() > self.end() {
return EntirelyBefore;
}
if self.begin() > other.end() {
return EntirelyAfter;
}
if self.begin() == other.begin() && self.end() == other.end() {
return Coincides;
}
if self.begin() <= other.begin() && self.end() >= other.end() {
return Contains;
}
if self.begin() >= other.begin() && self.end() <= other.end() {
return ContainedBy;
}
if self.begin() < other.begin() && self.end() < other.end() {
let overlap = self.end() - other.begin();
return OverlapsBegin(overlap);
}
if self.begin() > other.begin() && self.end() > other.end() {
let overlap = other.end() - self.begin();
return OverlapsEnd(overlap);
}
fail fmt!("relation_to_range(): didn't classify self=%?, other=%?",
self, other);
}
fn repair_after_coalesced_range(&mut self, other: &const MutableRange) {
let relation = self.relation_to_range(other);
debug!("repair_after_coalesced_range: possibly repairing range %?", self);
debug!("repair_after_coalesced_range: relation of original range and coalesced range(%?): %?",
other, relation);
match relation {
EntirelyBefore => { },
EntirelyAfter => { self.shift_by(-(other.length() as int)); },
Coincides | ContainedBy => { self.reset(other.begin(), 1); },
Contains => { self.extend_by(-(other.length() as int)); },
OverlapsBegin(overlap) => { self.extend_by(1 - (overlap as int)); },
OverlapsEnd(overlap) =>
{ self.reset(other.begin(), self.length() - overlap + 1); }
};
debug!("repair_after_coalesced_range: new range: ---- %?", self);
}
}