mirror of
https://github.com/VictoriaMetrics/VictoriaMetrics.git
synced 2024-11-21 14:44:00 +00:00
113 lines
3.9 KiB
Go
113 lines
3.9 KiB
Go
package uniseg
|
|
|
|
import "unicode/utf8"
|
|
|
|
// FirstLineSegment returns the prefix of the given byte slice after which a
|
|
// decision to break the string over to the next line can or must be made,
|
|
// according to the rules of Unicode Standard Annex #14. This is used to
|
|
// implement line breaking.
|
|
//
|
|
// Line breaking, also known as word wrapping, is the process of breaking a
|
|
// section of text into lines such that it will fit in the available width of a
|
|
// page, window or other display area.
|
|
//
|
|
// The returned "segment" may not be broken into smaller parts, unless no other
|
|
// breaking opportunities present themselves, in which case you may break by
|
|
// grapheme clusters (using the FirstGraphemeCluster() function to determine the
|
|
// grapheme clusters).
|
|
//
|
|
// The "mustBreak" flag indicates whether you MUST break the line after the
|
|
// given segment (true), for example after newline characters, or you MAY break
|
|
// the line after the given segment (false).
|
|
//
|
|
// This function can be called continuously to extract all non-breaking sub-sets
|
|
// from a byte slice, as illustrated in the example below.
|
|
//
|
|
// If you don't know the current state, for example when calling the function
|
|
// for the first time, you must pass -1. For consecutive calls, pass the state
|
|
// and rest slice returned by the previous call.
|
|
//
|
|
// The "rest" slice is the sub-slice of the original byte slice "b" starting
|
|
// after the last byte of the identified line segment. If the length of the
|
|
// "rest" slice is 0, the entire byte slice "b" has been processed. The
|
|
// "segment" byte slice is the sub-slice of the input slice containing the
|
|
// identified line segment.
|
|
//
|
|
// Given an empty byte slice "b", the function returns nil values.
|
|
//
|
|
// Note that in accordance with UAX #14 LB3, the final segment will end with
|
|
// "mustBreak" set to true. You can choose to ignore this by checking if the
|
|
// length of the "rest" slice is 0.
|
|
//
|
|
// Note also that this algorithm may break within grapheme clusters. This is
|
|
// addressed in Section 8.2 Example 6 of UAX #14. To avoid this, you can use
|
|
// the Step() function instead.
|
|
func FirstLineSegment(b []byte, state int) (segment, rest []byte, mustBreak bool, newState int) {
|
|
// An empty byte slice returns nothing.
|
|
if len(b) == 0 {
|
|
return
|
|
}
|
|
|
|
// Extract the first rune.
|
|
r, length := utf8.DecodeRune(b)
|
|
if len(b) <= length { // If we're already past the end, there is nothing else to parse.
|
|
return b, nil, true, lbAny // LB3.
|
|
}
|
|
|
|
// If we don't know the state, determine it now.
|
|
if state < 0 {
|
|
state, _ = transitionLineBreakState(state, r, b[length:], "")
|
|
}
|
|
|
|
// Transition until we find a boundary.
|
|
var boundary int
|
|
for {
|
|
r, l := utf8.DecodeRune(b[length:])
|
|
state, boundary = transitionLineBreakState(state, r, b[length+l:], "")
|
|
|
|
if boundary != LineDontBreak {
|
|
return b[:length], b[length:], boundary == LineMustBreak, state
|
|
}
|
|
|
|
length += l
|
|
if len(b) <= length {
|
|
return b, nil, true, lbAny // LB3
|
|
}
|
|
}
|
|
}
|
|
|
|
// FirstLineSegmentInString is like FirstLineSegment() but its input and outputs
|
|
// are strings.
|
|
func FirstLineSegmentInString(str string, state int) (segment, rest string, mustBreak bool, newState int) {
|
|
// An empty byte slice returns nothing.
|
|
if len(str) == 0 {
|
|
return
|
|
}
|
|
|
|
// Extract the first rune.
|
|
r, length := utf8.DecodeRuneInString(str)
|
|
if len(str) <= length { // If we're already past the end, there is nothing else to parse.
|
|
return str, "", true, lbAny // LB3.
|
|
}
|
|
|
|
// If we don't know the state, determine it now.
|
|
if state < 0 {
|
|
state, _ = transitionLineBreakState(state, r, nil, str[length:])
|
|
}
|
|
|
|
// Transition until we find a boundary.
|
|
var boundary int
|
|
for {
|
|
r, l := utf8.DecodeRuneInString(str[length:])
|
|
state, boundary = transitionLineBreakState(state, r, nil, str[length+l:])
|
|
|
|
if boundary != LineDontBreak {
|
|
return str[:length], str[length:], boundary == LineMustBreak, state
|
|
}
|
|
|
|
length += l
|
|
if len(str) <= length {
|
|
return str, "", true, lbAny // LB3.
|
|
}
|
|
}
|
|
}
|