// Copyright 2012 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. // Package collate contains types for comparing and sorting Unicode strings // according to a given collation order. Package locale provides a high-level // interface to collation. Users should typically use that package instead. package collate import ( "exp/norm" ) // Level identifies the collation comparison level. // The primary level corresponds to the basic sorting of text. // The secondary level corresponds to accents and related linguistic elements. // The tertiary level corresponds to casing and related concepts. // The quaternary level is derived from the other levels by the // various algorithms for handling variable elements. type Level int const ( Primary Level = iota Secondary Tertiary Quaternary Identity ) // AlternateHandling identifies the various ways in which variables are handled. // A rune with a primary weight lower than the variable top is considered a // variable. // See http://www.unicode.org/reports/tr10/#Variable_Weighting for details. type AlternateHandling int const ( // AltShifted sets variables to be ignorable for levels one through three and // adds a fourth level based on the values of the ignored levels. AltShifted AlternateHandling = iota // AltNonIgnorable turns off special handling of variables. AltNonIgnorable // AltBlanked sets variables and all subsequent primary ignorables to be // ignorable at all levels. This is identical to removing all variables // and subsequent primary ignorables from the input. AltBlanked // AltShiftTrimmed is a slight variant of AltShifted that is used to // emulate POSIX. AltShiftTrimmed ) // Collator provides functionality for comparing strings for a given // collation order. type Collator struct { // See SetVariableTop. variableTop uint32 // Strength sets the maximum level to use in comparison. Strength Level // Alternate specifies an alternative handling of variables. Alternate AlternateHandling // Backwards specifies the order of sorting at the secondary level. // This option exists predominantly to support reverse sorting of accents in French. Backwards bool // With HiraganaQuaternary enabled, Hiragana codepoints will get lower values // than all the other non-variable code points. Strength must be greater or // equal to Quaternary for this to take effect. HiraganaQuaternary bool // If CaseLevel is true, a level consisting only of case characteristics will // be inserted in front of the tertiary level. To ignore accents but take // cases into account, set Strength to Primary and CaseLevel to true. CaseLevel bool // If Numeric is true, any sequence of decimal digits (category is Nd) is sorted // at a primary level with its numeric value. For example, "A-21" < "A-123". Numeric bool f norm.Form t *table } // SetVariableTop sets all runes with primary strength less than the primary // strength of r to be variable and thus affected by alternate handling. func (c *Collator) SetVariableTop(r rune) { // TODO: implement } var ( Root = Collator{} ) // Buffer holds reusable buffers that can be used during collation. // Reusing a Buffer for the various calls that accept it may avoid // unnecessary memory allocations. type Buffer struct { // TODO: try various parameters and techniques, such as using // a chan of buffers for a pool. ba [4096]byte wa [512]weights key []byte ce []weights } func (b *Buffer) init() { if b.ce == nil { b.ce = b.wa[:0] b.key = b.ba[:0] } else { b.ce = b.ce[:0] } } // ResetKeys clears the buffer used for generated keys. Calling ResetKeys // invalidates keys previously obtained from Key or KeyFromString. func (b *Buffer) ResetKeys() { b.ce = b.ce[:0] b.key = b.key[:0] } // Compare returns an integer comparing the two byte slices. // The result will be 0 if a==b, -1 if a < b, and +1 if a > b. func (c *Collator) Compare(buf *Buffer, a, b []byte) int { // TODO: implement return 0 } // CompareString returns an integer comparing the two strings. // The result will be 0 if a==b, -1 if a < b, and +1 if a > b. func (c *Collator) CompareString(buf *Buffer, a, b string) int { // TODO: implement return 0 } // Key returns the collation key for str. // Passing the buffer buf may avoid memory allocations. // The returned slice will point to an allocation in Buffer and will retain // valid until the next call to buf.ResetKeys(). func (c *Collator) Key(buf *Buffer, str []byte) []byte { // TODO: implement return nil } // KeyFromString returns the collation key for str. // Passing the buffer buf may avoid memory allocations. // The returned slice will point to an allocation in Buffer and will retain // valid until the next call to buf.ResetKeys(). func (c *Collator) KeyFromString(buf *Buffer, str string) []byte { // TODO: implement return nil }