for (; seg != null; seg = seg.getNext()) { if (seg.isAnchor()) { continue; final Interval ulpos = resolve(new ImmutableInterval(seg.getStart(), seg.getEnd())); start = seg.getStart() + (i.getStart() - ulstart); break; seg = seg.getNext(); start = seg.getStart(); for (; seg != null; seg = seg.getNext()) { if (seg instanceof ObliqueSegment) { final ObliqueSegment oseg = (ObliqueSegment) seg; end = seg.getStart() + (i.getEnd() - ulstart); break;
prefix.split(start); suffix = prefix._next; suffix = suffix.split(end); AbstractDataSegment s = segAtStart; while (s != segAtEnd) { if (s.isAnchor()) { throw new UnsupportedOperationException( "Unable to replace text containing anchors."); segAtStart.split(start); prefix = segAtStart; suffix = segAtEnd.split(end); if (s.isAnchor()) {
suffix = prefix.split(pos);
/** * Get an anchor at the specified position. Breaks up the segment at the given point if * necessary. If there already is an anchor, it is reused. * * @param pos * a position. * @return an anchor. */ public Anchor getAnchor(final int pos) { if (pos == 0) { return _first; } // Split up segment final AbstractDataSegment prefix = getSegmentAt(pos, true); if (prefix.isAnchor()) { return (Anchor) prefix; } else { final AbstractDataSegment suffix = prefix.split(pos); // Insert segment final AnchorSegment seg = new AnchorSegment(prefix, suffix); prefix._next = seg; suffix._prev = seg; // Drop useless segments dropSuperflourous(prefix); dropSuperflourous(suffix); return seg; } }
public void updateCaches() { if (_underlying != null) { _underlying.updateCaches(); } get(); if (_startDirty) { int length = 0; AbstractDataSegment seg = _first; while (seg != null) { seg._cachedStart = length; length += seg.length(); seg = seg._next; } _startDirty = false; System.out.println("startDirty false"); } }
/** * If the given segment is a zero-length base segment, then it can be dropped. Zero-length * oblique segments need to be retained because through them we can know e.g. if we extended a * word. In the following example the empty oblique segments allows us to do an inverse resolve * from "hyphen- ated" to "hyphenated". * * Underlying: * (B:0[This is a hyphen]16)(A:16)(B:16[- ]18)(A:18)(B:18[ated]22)(A:22)(B:22[ sentence]31) * * Wrapping: * (O:0[This is a hyphen]16)(B:16[ated]20)(O:20[]20)(O:20[ sentence]29) */ private void dropSuperflourous(final AbstractDataSegment seg) { if ((seg instanceof BaseSegment) && // !seg.isAnchor() && (seg.length() == 0)) { seg._prev._next = seg._next; seg._next._prev = seg._prev; } }
/** * Get all the segments. * * @return all the segments. */ public Collection<DataSegment> getSegments() { final ArrayList<DataSegment> segments = new ArrayList<DataSegment>(); for (AbstractDataSegment s = _first; s != null; s = s._next) { if (!s.isAnchor()) { segments.add(s); } } segments.trimToSize(); return segments; }
@Override public int getStart() { if (_startDirty || _cachedStart == -1) { int pos = 0; AbstractDataSegment seg = this._prev; while (seg != null) { pos += seg.length(); seg = seg._prev; } return pos; } else { return _cachedStart; } }
/** * Get all the anchors. * * @return all the anchors. */ public Collection<Anchor> getAnchors() { final ArrayList<Anchor> anchors = new ArrayList<Anchor>(); for (AbstractDataSegment s = _first; s != null; s = s._next) { if (s.isAnchor()) { anchors.add((Anchor) s); } } anchors.trimToSize(); return anchors; }
@Override public AlignedString.DataSegment next() { final AlignedString.DataSegment result = _next; if (_includeAll) { _next = _next._next; } else { _next = _next.getNext(); } return result; }
@Override public AbstractDataSegment getNext() { AbstractDataSegment s = _next; // We skip the Anchors with have a zero length. while ((s != null) && s.isAnchor()) { s = s._next; } return s; }
@Override public DataSegment getPrevious() { AbstractDataSegment s = _prev; // We skip the Anchors with have a zero length. while ((s != null) && s.isAnchor()) { s = s._prev; } return s; }