Implement functionality to insert text into the middle of a text instance.

Implement functionality to test if a string is in some given normalization form.

• is_nfd
• is_nfc
• is_nfkd
• is_nfkc

Implement functionality to remove text from the middle of a text instance.

Implement the line breaking algorithm as per UAX #14.

Implement Normalization Form KD as per UAX #15.

Implement the Unicode collation algorithm as per UAX #10.

icu::UnicodeString should be supported as an UnicodeSequence, allowing its use with all ogonek functionality.

Implement end-user useful queries that are not present in the UCD, like "is functionally lowercase?". Additionally bring to scope all end-user useful direct queries from namespace ogonek::ucd into namespace ogonek.

• Name
• Numeric/digit/decimal value
• Casing properties
• Classification properties

Implement hash objects to provide hashing functionality that match the equality relations given by canonical_equivalence and compatibility_equivalence.

• std::hash<text<C, D>> which defaults to canonical_hash
• canonical_hash: polymorphic hash function; canonically equivalent ranges yield the same hash
• compatibility_hash: polymorphic hash function; compatibility equivalent ranges yield the same hash

Implement a tool for importing the data from the Default Unicode Collation Element Table.

Implement the 国家标准 18030 (aka GB18030) encoding form.

Implement Default Case Detection as specified in 3.13 in the Unicode Standard.

Implement Normalization Form KC as per UAX #15.

Implement the Standard Compression Scheme for Unicode as per UTS #6.

Implement text::operator==, and text::operator!= with canonical equivalence semantics.

Implement the Binary Ordered Compression for Unicode as per UTN #6.

Implement canonical equivalence as per UAX #15.

Ogonek algorithms and classes should work with any object that can be seen as Unicode data. This includes text instances, char32_t and char16_t literals (because the encoding can be assumed), and any range of char32_t (this includes results from algorithms). Additionally, icu::UnicodeString is also obviously a range of Unicode data.

In order to support this paraphernalia of data sources, tools for uniform manipulation of these need to be created and applied to the existing algorithms. These include is_unicode_sequence and UnicodeSequenceIterator traits, and an as_code_point_range function that provides a common way to view different Unicode sequences.

Implement a generic template for generating encoding forms from a mapping table.

Implement the Windows codepage 1252 encoding form.

Implement the ASCII encoding form.

Implement the UTF-32 encoding form.

Implement a generic template for creating encoding schemes from encoding forms and byte orders. Provide appropriate aliases for UTF-16LE, UTF-16BE, UTF-32LE, and UTF-32BE.

Implement the grapheme cluster boundary algorithm as per UAX #29.

Implement ogonek::text as a template that abstracts away encoding and makes conversions automatic and compile-time checked.

Right now an instance of text carries information about the encoding in the type, in order to enforce conversions at the appropriate places.

It would be neat if text could optionally also enforce some normalization form. This would allow for optimisations in the equivalence and hashing functions, which would reflect in improved performance when using text as a key in maps, for example.

To allow similar optimisation, make all ranges based on normalizing iterators carry information about their normal form in the type.

text types also carry information about validity of the sequence. This property is already used in various places to optimise away redundant validation. There are however more ranges that can have the same characteristics and enable the same optimisations. Make all ranges based on decoding or normalizing iterators be considered as validated.

Implement Normalization Form D as per UAX #15.

I attempted to call the compiler directly through javac.exe, and it rejected this code. Fix immediately or I'll sue you for everything you own.

Implement text::operator< and the other relational operators with default collation semantics.

Implement the Normalization Form FCC as per UTN #5.

• normalize<fcc>
• is_fcc

Implement the UTF-16 encoding form.

Implement ogonek::any_text as a variant of ogonek::text that erases the type of the encoding and of the underlying storage.

When using encode_one and decode_one, stateful encodings can end up with unfinished code units/code points that won't be in the result, but instead will be stored in the state for mixing in the next call to encode_one/decode_one.

Currently there is no way to complete those code units/code points when at the end of a stream.

Implement direct UCD queries.

Implement Normalization Form C as per UAX #15.

Implement functionality to replace a subrange from an instance of text.

Implement the GSM 03.38 encoding form.

Implement the Normalization Form FCD as per UTN #5.

• normalize<fcd>
• is_fcd

Implement the UTF-8 encoding form.

Implement ogonek::concat to and ogonek::text::append allow concatenation of code point ranges.

Implement Default Caseless Matching as specified in 3.13 in the Unicode Standard.

Specially for NFC, quick checks can make for high efficiency. Normalizing iterators should use that.

Implement the ISO/IEC 8859 encoding forms.

Implement compatibility equivalence as per UAX #15.

Implement the sentence boundary algorithm as per UAX #29.

Implement Default Case Conversion as specified in 3.13 in the Unicode Standard.

Implement the word boundary algorithm as per UAX #29.

Implement the Unicode bidirectional algorithm as per UAX #9.

Implement functionality to test whether an instance of text is empty.

The replacement validation policy does not follow the best practice delineated in 5.22 in the Unicode Standard. For example, the sequence <F3 85> is replaced by two replacement characters, but it should only use one, since it's a maximal subpart.