• Home
• com.vladsch.flexmark
• flexmark-util-sequence
• 0.61.30
• source code
• SegmentBuilderBase.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.vladsch.flexmark.util.sequence.builder.SegmentBuilderBase Maven / Gradle / Ivy

package com.vladsch.flexmark.util.sequence.builder;

import com.vladsch.flexmark.util.misc.DelimitedBuilder;
import com.vladsch.flexmark.util.sequence.Range;
import com.vladsch.flexmark.util.sequence.SequenceUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.util.Arrays;
import java.util.Iterator;
import java.util.function.Function;

import static java.lang.Integer.MAX_VALUE;
import static java.lang.Integer.MIN_VALUE;

@SuppressWarnings("UnusedReturnValue")
public class SegmentBuilderBase> implements ISegmentBuilder {
    final public static int MIN_PART_CAPACITY = 8;

    final public static int[] EMPTY_PARTS = { };

    protected @NotNull int[] parts = EMPTY_PARTS;
    protected int partsSize = 0;
    protected int anchorsSize = 0;

    protected int startOffset = Range.NULL.getStart();
    protected int endOffset = Range.NULL.getEnd();
    protected int length = 0;
    final protected SegmentStats stats;      // committed and dangling text stats
    final protected SegmentStats textStats;  // dangling text stats
    final protected int options;

    // NOTE: all text accumulation is in the string builder, dangling text segment is between immutableOffset and text.length()
    final protected StringBuilder text = new StringBuilder();    // text segment ranges come from this CharSequence
    protected int immutableOffset = 0;   // text offset for all committed text segments

    private static int[] ensureCapacity(@NotNull int[] prev, int size) {
        assert size >= 0;

        int prevSize = prev.length / 2;
        if (prevSize <= size) {
            int nextSize = Math.max(MIN_PART_CAPACITY, Math.max(prevSize + prevSize >> 1, size));
            return Arrays.copyOf(prev, nextSize * 2);
        }
        return prev;
    }

    private void ensureCapacity(int size) {
        parts = ensureCapacity(parts, size + 1);
    }

    public void trimToSize() {
        if (parts.length > partsSize) {
            parts = Arrays.copyOf(parts, partsSize * 2);
        }
    }

    protected SegmentBuilderBase() {
        this(F_INCLUDE_ANCHORS /*| F_TRACK_FIRST256*/);
    }

    protected SegmentBuilderBase(int options) {
        this.options = options & (F_INCLUDE_ANCHORS | F_TRACK_FIRST256);
        stats = new SegmentStats((options & F_TRACK_FIRST256) != 0);
        textStats = new SegmentStats((options & F_TRACK_FIRST256) != 0);
    }

    @Override
    public int getStartOffset() {
        return startOffset <= endOffset ? startOffset : -1;
    }

    public boolean needStartOffset() {
        return getStartOffsetIfNeeded() != -1;
    }

    public int getStartOffsetIfNeeded() {
        int startOffset = getStartOffset();
        Seg seg = getSegOrNull(0);
        return startOffset != -1 && seg != null && seg.isBase() && startOffset != seg.getStart() ? startOffset : -1;
    }

    @Override
    public int getEndOffset() {
        return endOffset >= startOffset ? endOffset : -1;
    }

    public boolean needEndOffset() {
        return getEndOffsetIfNeeded() != -1;
    }

    public int getEndOffsetIfNeeded() {
        int endOffset = getEndOffset();
        Seg seg = getSegOrNull(partsSize - 1);
        return endOffset != -1 && seg != null && seg.isBase() && endOffset != seg.getEnd() ? endOffset : -1;
    }

    @Override
    public boolean isEmpty() {
        return length == 0;
    }

    @Override
    public boolean isBaseSubSequenceRange() {
        return getBaseSubSequenceRange() != null;
    }

    @Nullable
    @Override
    public Range getBaseSubSequenceRange() {
        if (partsSize == 1 && !haveDanglingText()) {
            Seg seg = getSeg(partsSize - 1);
            if (seg.length() != 0 && anchorsSize == 1) seg = getSeg(partsSize - 2);
            if (seg.isBase() && seg.getStart() == startOffset && seg.getEnd() == endOffset) {
                return seg.getRange();
            }
        }
        return null;
    }

    @Override
    public boolean haveOffsets() {
        return startOffset <= endOffset;
    }

    @Override
    public int size() {
        return partsSize + (haveDanglingText() ? 1 : 0);
    }

    @Override
    public CharSequence getText() {
        return text;
    }

    @Override
    public int noAnchorsSize() {
        return size() - anchorsSize;
    }

    private int computeLength() {
        int length = 0;
        int iMax = partsSize;
        for (int i = 0; i < iMax; i++) {
            Seg part = getSeg(i);
            length += part.length();
        }

        if (haveDanglingText()) {
            length += text.length() - immutableOffset;
        }
        return length;
    }

    @Override
    public int length() {
        // RELEASE: remove assert for release
        assert length == computeLength() : "length:" + length + " != computeLength(): " + computeLength();
        return length;
    }

    public SegmentStats getStats() {
        return stats;
    }

    // @formatter:off
    @Override public boolean isTrackTextFirst256() { return stats.isTrackTextFirst256(); }
    @Override public int getTextLength() { return stats.getTextLength(); }
    @Override public int getTextSegments() { return stats.getTextSegments(); }
    @Override public int getTextSpaceLength() { return stats.getTextSpaceLength(); }
    @Override public int getTextSpaceSegments() { return stats.getTextSpaceSegments(); }
    @Override public int getTextFirst256Length() { return stats.getTextFirst256Length(); }
    @Override public int getTextFirst256Segments() { return stats.getTextFirst256Segments(); }

// @formatter:on

    @Override
    public @NotNull Iterator