/usr/include/phonenumbers/unicodestring.h is in libphonenumber-dev 7.0.8-0ubuntu3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 | // Copyright (C) 2011 The Libphonenumber Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Author: Philippe Liard
#ifndef I18N_PHONENUMBERS_UNICODESTRING_H_
#define I18N_PHONENUMBERS_UNICODESTRING_H_
#include "phonenumbers/utf/unicodetext.h"
#include <cstring>
#include <limits>
namespace i18n {
namespace phonenumbers {
// This class supports the minimal subset of icu::UnicodeString needed by
// AsYouTypeFormatter in order to let the libphonenumber not depend on ICU
// which is not available by default on some systems, such as iOS.
class UnicodeString {
public:
UnicodeString() : cached_index_(-1) {}
// Constructs a new unicode string copying the provided C string.
explicit UnicodeString(const char* utf8)
: text_(UTF8ToUnicodeText(utf8, std::strlen(utf8))),
cached_index_(-1) {}
// Constructs a new unicode string containing the provided codepoint.
explicit UnicodeString(char32 codepoint) : cached_index_(-1) {
append(codepoint);
}
UnicodeString(const UnicodeString& src)
: text_(src.text_), cached_index_(-1) {}
UnicodeString& operator=(const UnicodeString& src);
bool operator==(const UnicodeString& rhs) const;
void append(const UnicodeString& unicode_string);
inline void append(char32 codepoint) {
invalidateCachedIndex();
text_.push_back(codepoint);
}
typedef UnicodeText::const_iterator const_iterator;
inline const_iterator begin() const {
return text_.begin();
}
inline const_iterator end() const {
return text_.end();
}
// Returns the index of the provided codepoint or -1 if not found.
int indexOf(char32 codepoint) const;
// Returns the number of codepoints contained in the unicode string.
inline int length() const {
return text_.size();
}
// Clears the unicode string.
inline void remove() {
invalidateCachedIndex();
text_.clear();
}
// Replaces the substring located at [ start, start + length - 1 ] with the
// provided unicode string.
void replace(int start, int length, const UnicodeString& src);
void setCharAt(int pos, char32 c);
// Copies the provided C string.
inline void setTo(const char* s, size_t len) {
invalidateCachedIndex();
text_.CopyUTF8(s, len);
}
// Returns the substring located at [ start, start + length - 1 ] without
// copying the underlying C string. If one of the provided parameters is out
// of range, the function returns an empty unicode string.
UnicodeString tempSubString(
int start,
int length = std::numeric_limits<int>::max()) const;
inline void toUTF8String(string& out) const {
out = UnicodeTextToUTF8(text_);
}
char32 operator[](int index) const;
private:
UnicodeText text_;
// As UnicodeText doesn't provide random access, an operator[] implementation
// would naively iterate from the beginning of the string to the supplied
// index which would be inefficient.
// As operator[] is very likely to be called in a loop with consecutive
// indexes, we save the corresponding iterator so we can reuse it the next
// time it is called.
// The following function which invalidates the cached index corresponding to
// the iterator position must be called every time the unicode string is
// modified (i.e. in all the non-const methods).
inline void invalidateCachedIndex() {
cached_index_ = -1;
}
// Iterator corresponding to the cached index below, used by operator[].
mutable UnicodeText::const_iterator cached_it_;
mutable int cached_index_;
};
} // namespace phonenumbers
} // namespace i18n
#endif // I18N_PHONENUMBERS_UNICODESTRING_H_
|