Java BasedSequence.length方法代码示例

import com.vladsch.flexmark.util.sequence.BasedSequence; //导入方法依赖的package包/类
@Override
public void setTextChars(BasedSequence textChars) {
    int textCharsLength = textChars.length();
    textOpeningMarker = textChars.subSequence(0, 1);
    text = textChars.subSequence(1, textCharsLength - 1).trim();
    textClosingMarker = textChars.subSequence(textCharsLength - 1, textCharsLength);
}
 

import com.vladsch.flexmark.util.sequence.BasedSequence; //导入方法依赖的package包/类
protected boolean perform(@NotNull LineSelectionManager manager, @NotNull Caret caret, @NotNull Range range, @NotNull ArrayList<CaretState> createCarets) {
    Editor editor = caret.getEditor();
    final BasedSequence chars = BasedSequenceImpl.of(editor.getDocument().getCharsSequence());
    boolean keepCaret = !isMoveFirstMatch();

    T matcher = prepareMatcher(manager, caret, range, chars);
    if (matcher != null) {
        // forward search withing range in document
        CaretMatch lastMatch = null;
        while (true) {
            CaretMatch match = nextMatch(matcher, chars, range, lastMatch);
            if (match == null) break;

            // found it, create or move caret here
            if (!keepCaret) {
                keepCaret = true;
                if (isMoveFirstMatch()) {
                    caret.moveToOffset(match.caretOffset);
                    caret.setSelection(match.selectionStart, match.selectionEnd);
                }
            } else {
                // create a new position if caret moved
                LogicalPosition offset = editor.offsetToLogicalPosition(match.caretOffset);
                LogicalPosition startOffset = editor.offsetToLogicalPosition(match.selectionStart);
                LogicalPosition endOffset = editor.offsetToLogicalPosition(match.selectionEnd);
                CaretState caretState = new CaretState(offset, startOffset, endOffset);
                createCarets.add(caretState);
            }

            if (isSingleMatch() || match.caretOffset + match.matchLength >= chars.length()) break;
            lastMatch = match;
        }
    }

    return keepCaret || isSingleMatch();
}
 

import com.vladsch.flexmark.util.sequence.BasedSequence; //导入方法依赖的package包/类
public InsertedRangeContext(@NotNull BasedSequence charSequence, int beforeOffset, int afterOffset, int separators) {
    this.charSequence = charSequence;
    mySeparators = separators;
    this.textLength = charSequence.length();

    if (beforeOffset < 0) beforeOffset = 0;
    if (afterOffset > textLength) afterOffset = textLength;
    if (beforeOffset > afterOffset) beforeOffset = afterOffset;
    if (afterOffset < beforeOffset) afterOffset = beforeOffset;

    this.beforeOffset = beforeOffset;
    this.afterOffset = afterOffset;
    TextRange range = EditHelpers.getWordRangeAtOffsets(charSequence, beforeOffset, afterOffset, WORD_IDENTIFIER, false, true);
    this.expandedBeforeOffset = range.getStartOffset();
    this.expandedAfterOffset = range.getEndOffset();

    this.expandedPrefix = expandedBeforeOffset > beforeOffset ? "" : charSequence.subSequence(expandedBeforeOffset, beforeOffset).toString();
    this.expandedSuffix = expandedAfterOffset < afterOffset ? "" : charSequence.subSequence(afterOffset, expandedAfterOffset).toString();

    this.inserted = charSequence.subSequence(beforeOffset, afterOffset).toString();

    this.charBefore = beforeOffset > 0 && beforeOffset - 1 < textLength ? charSequence.charAt(beforeOffset - 1) : ' ';
    this.charAfter = afterOffset < textLength ? charSequence.charAt(afterOffset) : ' ';
    this.sBefore = String.valueOf(charBefore);
    this.sAfter = String.valueOf(charAfter);
    this.isWordStartAtStart = isWordStart(charSequence, beforeOffset, false);
    this.isWordEndAtStart = isWordEnd(charSequence, beforeOffset, false);
    this.isWordStartAtEnd = isWordStart(charSequence, afterOffset, false);
    this.isWordEndAtEnd = isWordEnd(charSequence, afterOffset, false);

    myWord = inserted;
    myStudiedWord = StudiedWord.of(myWord, mySeparators);
    myCaretDelta = 0;
    myPrefixRemoved = false;
}
 

import com.vladsch.flexmark.util.sequence.BasedSequence; //导入方法依赖的package包/类
/**
 * Extract a number from given sequence based on prefix/suffix, base and template
 *
 * @param charSequence character sequence from which to extract a number
 * @param numberBase
 * @return number or null if unable to extract
 */
public static long extractNumber(@NotNull CharSequence charSequence, @NotNull NumberingOptions options, int numberBase, @Nullable Ref<Integer> refMaxDigit) {
    BasedSequence chars = BasedSequenceImpl.of(charSequence).trim();

    if (!options.getPrefix().trim().isEmpty()) chars = chars.removePrefix(options.getPrefix().trim());
    if (!options.getSuffix().trim().isEmpty()) chars = chars.removeSuffix(options.getSuffix().trim());

    chars = chars.trim();

    // see if we have a template and it matches somewhat
    long number = 0;
    boolean negative = false;
    int maxDigit = refMaxDigit != null ? refMaxDigit.value : numberBase - 1;

    for (int i = 0; i < chars.length(); i++) {
        char c = chars.charAt(i);
        if (c == '-' && i == 0) {
            negative = true;
            continue;
        }

        int digit = c >= '0' && c <= '9' ? c - '0' : c >= 'a' && c <= 'z' ? c - 'a' + 10 : c >= 'A' && c <= 'A' ? c - 'A' + 10 : -1;
        if (maxDigit < digit) maxDigit = digit;
        if (digit < 0 || digit >= numberBase) continue;
        number *= numberBase;
        number += digit;
    }

    if (negative) {
        number = -number;
    }
    if (refMaxDigit != null) refMaxDigit.value = maxDigit;
    return number;
}
 

import com.vladsch.flexmark.util.sequence.BasedSequence; //导入方法依赖的package包/类
private void surroundSelectionAndReplaceMarker(String leading, String trailing, String hint,
		DelimitedNode node, String newOpeningMarker, String newClosingMarker)
{
	IndexRange selection = textArea.getSelection();
	int start = selection.getStart();
	int end = selection.getEnd();

	String selectedText = textArea.getSelectedText();

	// remove leading and trailing whitespaces from selected text
	String trimmedSelectedText = selectedText.trim();
	if (trimmedSelectedText.length() < selectedText.length()) {
		start += selectedText.indexOf(trimmedSelectedText);
		end = start + trimmedSelectedText.length();
	}

	BasedSequence openingMarker = node.getOpeningMarker();
	BasedSequence closingMarker = node.getClosingMarker();

	int selStart = start + leading.length() + (newOpeningMarker.length() - openingMarker.length());
	int selEnd = selStart + trimmedSelectedText.length();

	// insert hint text if selection is empty
	if (hint != null && trimmedSelectedText.isEmpty()) {
		trimmedSelectedText = hint;
		selEnd = selStart + hint.length();
	}

	// replace text and update selection
	// Note: using single textArea.replaceText() to avoid multiple changes in undo history
	String before = textArea.getText(openingMarker.getEndOffset(), start);
	String after = textArea.getText(end, closingMarker.getStartOffset());
	replaceText(textArea, openingMarker.getStartOffset(), closingMarker.getEndOffset(),
			newOpeningMarker + before + leading + trimmedSelectedText + trailing + after + newClosingMarker );
	selectRange(textArea, selStart, selEnd);
}
 

import com.vladsch.flexmark.util.sequence.BasedSequence; //导入方法依赖的package包/类
@NotNull
protected DefaultActionGroup createPopupActionGroup(JComponent button, @Nullable Editor editor) {
    final DefaultActionGroup group = new DefaultActionGroup();

    if (editor != null) {
        final LineSelectionManager manager = LineSelectionManager.getInstance(editor);
        final RangeMarker[] markers = manager.getSavedSelections();
        BasedSequence chars = BasedSequenceImpl.of(editor.getDocument().getCharsSequence());
        final Range exclusionRange = excludeOverlap(editor);

        for (int i = markers.length; i-- > 0; ) {
            RangeMarker marker = markers[i];

            BasedSequence text = chars.subSequence(marker.getStartOffset(), marker.getEndOffset());
            BasedSequence label = text;

            if (text.length() > 40) {
                label = text.subSequence(0, 20).append(PrefixedSubSequence.of("…", text.subSequence(20, 20))).append(text.endSequence(20, 0));
            }

            label = label.replace("\n", "⏎");

            final int index = markers.length - i - 1;
            Document document = marker.getDocument();
            final int startLine = document.getLineNumber(marker.getStartOffset());
            final int endLine = document.getLineNumber(marker.getEndOffset());
            final int startColumn = marker.getStartOffset() - document.getLineStartOffset(startLine);
            final Icon icon;
            boolean disabled = false;

            if (exclusionRange != null) {
                Range range = new Range(marker.getStartOffset(), marker.getEndOffset());
                if (exclusionRange.doesContain(range) || range.doesContain(exclusionRange)) {
                    disabled = true;
                }
            }

            if (disabled) {
                icon = PluginIcons.Clipboard_disabled_caret;
            } else if (text.endsWith("\n") && startColumn == 0) {
                icon = PluginIcons.Clipboard_line_caret;
            } else if (startLine != endLine) {
                icon = PluginIcons.Clipboard_char_lines_caret;
            } else {
                icon = PluginIcons.Clipboard_char_caret;
            }

            final String actionText = String.format("line %d \"%s\"", startLine, text);
            final boolean isDisabled = disabled;

            DumbAwareAction action = new DumbAwareAction("\"" + label.toString() + "\"", actionText, icon) {
                @Override
                public void actionPerformed(final AnActionEvent e) {
                    if (!isDisabled) {
                        RangeMarker rangeMarker = manager.getRangeMarker();
                        manager.recallLastSelection(index, removeRangeMarker(e, editor, rangeMarker), false, true);
                        SelectionListActionBase.this.actionPerformed(e, editor, rangeMarker);
                    }
                }
            };

            group.add(action);
        }
    }

    return group;
}