File: utf16_indexing.h

package info (click to toggle)
chromium 138.0.7204.183-1
  • links: PTS, VCS
  • area: main
  • in suites: trixie
  • size: 6,071,908 kB
  • sloc: cpp: 34,937,088; ansic: 7,176,967; javascript: 4,110,704; python: 1,419,953; asm: 946,768; xml: 739,971; pascal: 187,324; sh: 89,623; perl: 88,663; objc: 79,944; sql: 50,304; cs: 41,786; fortran: 24,137; makefile: 21,806; php: 13,980; tcl: 13,166; yacc: 8,925; ruby: 7,485; awk: 3,720; lisp: 3,096; lex: 1,327; ada: 727; jsp: 228; sed: 36
file content (51 lines) | stat: -rw-r--r-- 2,123 bytes parent folder | download | duplicates (5)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef UI_GFX_UTF16_INDEXING_H_
#define UI_GFX_UTF16_INDEXING_H_

#include <stddef.h>

#include <string_view>

#include "base/component_export.h"

namespace gfx {

// Returns false if s[index-1] is a high surrogate and s[index] is a low
// surrogate, true otherwise.
COMPONENT_EXPORT(GFX)
bool IsValidCodePointIndex(std::u16string_view s, size_t index);

// |UTF16IndexToOffset| returns the number of code points between |base| and
// |pos| in the given string. |UTF16OffsetToIndex| returns the index that is
// |offset| code points away from the given |base| index. These functions are
// named after glib's |g_utf8_pointer_to_offset| and |g_utf8_offset_to_pointer|,
// which perform the same function for UTF-8. As in glib, it is an error to
// pass an |offset| that walks off the edge of the string.
//
// These functions attempt to deal with invalid use of UTF-16 surrogates in a
// way that makes as much sense as possible: unpaired surrogates are treated as
// single characters, and if an argument index points to the middle of a valid
// surrogate pair, it is treated as though it pointed to the end of that pair.
// The index returned by |UTF16OffsetToIndex| never points to the middle of a
// surrogate pair.
//
// The following identities hold:
//   If |s| contains no surrogate pairs, then
//     UTF16IndexToOffset(s, base, pos) == pos - base
//     UTF16OffsetToIndex(s, base, offset) == base + offset
//   If |pos| does not point to the middle of a surrogate pair, then
//     UTF16OffsetToIndex(s, base, UTF16IndexToOffset(s, base, pos)) == pos
//   Always,
//     UTF16IndexToOffset(s, base, UTF16OffsetToIndex(s, base, ofs)) == ofs
//     UTF16IndexToOffset(s, i, j) == -UTF16IndexToOffset(s, j, i)
COMPONENT_EXPORT(GFX)
ptrdiff_t UTF16IndexToOffset(std::u16string_view s, size_t base, size_t pos);
COMPONENT_EXPORT(GFX)
size_t UTF16OffsetToIndex(std::u16string_view s, size_t base, ptrdiff_t offset);

}  // namespace gfx

#endif  // UI_GFX_UTF16_INDEXING_H_