// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:generate go run gen.go gen_trieval.go gen_ranges.go

// Package bidi contains functionality for bidirectional text support. // // See https://www.unicode.org/reports/tr9. // // NOTE: UNDER CONSTRUCTION. This API may change in backwards incompatible ways // and without notice.
package bidi // import "golang.org/x/text/unicode/bidi" // TODO: // The following functionality would not be hard to implement, but hinges on // the definition of a Segmenter interface. For now this is up to the user. // - Iterate over paragraphs // - Segmenter to iterate over runs directly from a given text. // Also: // - Transformer for reordering? // - Transformer (validator, really) for Bidi Rule. // This API tries to avoid dealing with embedding levels for now. Under the hood // these will be computed, but the question is to which extent the user should // know they exist. We should at some point allow the user to specify an // embedding hierarchy, though. // A Direction indicates the overall flow of text. type Direction int const ( // LeftToRight indicates the text contains no right-to-left characters and // that either there are some left-to-right characters or the option // DefaultDirection(LeftToRight) was passed. LeftToRight Direction = iota // RightToLeft indicates the text contains no left-to-right characters and // that either there are some right-to-left characters or the option // DefaultDirection(RightToLeft) was passed. RightToLeft // Mixed indicates text contains both left-to-right and right-to-left // characters. Mixed // Neutral means that text contains no left-to-right and right-to-left // characters and that no default direction has been set. Neutral ) type options struct{} // An Option is an option for Bidi processing. type Option func(*options) // ICU allows the user to define embedding levels. This may be used, for example, // to use hierarchical structure of markup languages to define embeddings. // The following option may be a way to expose this functionality in this API. // // LevelFunc sets a function that associates nesting levels with the given text. // // The levels function will be called with monotonically increasing values for p. // func LevelFunc(levels func(p int) int) Option { // panic("unimplemented") // } // DefaultDirection sets the default direction for a Paragraph. The direction is // overridden if the text contains directional characters. func ( Direction) Option { panic("unimplemented") } // A Paragraph holds a single Paragraph for Bidi processing. type Paragraph struct { // buffers } // SetBytes configures p for the given paragraph text. It replaces text // previously set by SetBytes or SetString. If b contains a paragraph separator // it will only process the first paragraph and report the number of bytes // consumed from b including this separator. Error may be non-nil if options are // given. func ( *Paragraph) ( []byte, ...Option) ( int, error) { panic("unimplemented") } // SetString configures p for the given paragraph text. It replaces text // previously set by SetBytes or SetString. If b contains a paragraph separator // it will only process the first paragraph and report the number of bytes // consumed from b including this separator. Error may be non-nil if options are // given. func ( *Paragraph) ( string, ...Option) ( int, error) { panic("unimplemented") } // IsLeftToRight reports whether the principle direction of rendering for this // paragraphs is left-to-right. If this returns false, the principle direction // of rendering is right-to-left. func ( *Paragraph) () bool { panic("unimplemented") } // Direction returns the direction of the text of this paragraph. // // The direction may be LeftToRight, RightToLeft, Mixed, or Neutral. func ( *Paragraph) () Direction { panic("unimplemented") } // RunAt reports the Run at the given position of the input text. // // This method can be used for computing line breaks on paragraphs. func ( *Paragraph) ( int) Run { panic("unimplemented") } // Order computes the visual ordering of all the runs in a Paragraph. func ( *Paragraph) () (Ordering, error) { panic("unimplemented") } // Line computes the visual ordering of runs for a single line starting and // ending at the given positions in the original text. func ( *Paragraph) (, int) (Ordering, error) { panic("unimplemented") } // An Ordering holds the computed visual order of runs of a Paragraph. Calling // SetBytes or SetString on the originating Paragraph invalidates an Ordering. // The methods of an Ordering should only be called by one goroutine at a time. type Ordering struct{} // Direction reports the directionality of the runs. // // The direction may be LeftToRight, RightToLeft, Mixed, or Neutral. func ( *Ordering) () Direction { panic("unimplemented") } // NumRuns returns the number of runs. func ( *Ordering) () int { panic("unimplemented") } // Run returns the ith run within the ordering. func ( *Ordering) ( int) Run { panic("unimplemented") } // TODO: perhaps with options. // // Reorder creates a reader that reads the runes in visual order per character. // // Modifiers remain after the runes they modify. // func (l *Runs) Reorder() io.Reader { // panic("unimplemented") // } // A Run is a continuous sequence of characters of a single direction. type Run struct { } // String returns the text of the run in its original order. func ( *Run) () string { panic("unimplemented") } // Bytes returns the text of the run in its original order. func ( *Run) () []byte { panic("unimplemented") } // TODO: methods for // - Display order // - headers and footers // - bracket replacement. // Direction reports the direction of the run. func ( *Run) () Direction { panic("unimplemented") } // Position of the Run within the text passed to SetBytes or SetString of the // originating Paragraph value. func ( *Run) () (, int) { panic("unimplemented") } // AppendReverse reverses the order of characters of in, appends them to out, // and returns the result. Modifiers will still follow the runes they modify. // Brackets are replaced with their counterparts. func (, []byte) []byte { panic("unimplemented") } // ReverseString reverses the order of characters in s and returns a new string. // Modifiers will still follow the runes they modify. Brackets are replaced with // their counterparts. func ( string) string { panic("unimplemented") }