You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
133 lines
4.0 KiB
133 lines
4.0 KiB
// 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_
|