ICU 78.2: common/unicode/rep.h Source File

ICU 78.2 78.2

rep.h
Go to the documentation of this file.
1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /*
4 **************************************************************************
5 * Copyright (C) 1999-2012, International Business Machines Corporation and
6 * others. All Rights Reserved.
7 **************************************************************************
8 * Date Name Description
9 * 11/17/99 aliu Creation. Ported from java. Modified to
10 * match current UnicodeString API. Forced
11 * to use name "handleReplaceBetween" because
12 * of existing methods in UnicodeString.
13 **************************************************************************
14 */
15
16 #ifndef REP_H
17 #define REP_H
18
19 #include "unicode/utypes.h"
20
21 #if U_SHOW_CPLUSPLUS_API
22
23 #include "unicode/uobject.h"
24
30 U_NAMESPACE_BEGIN
31
32 class UnicodeString;
33
77 class U_COMMON_API Replaceable : public UObject {
78
79 public:
84 virtual ~Replaceable();
85
91 inline int32_t length() const;
92
100 inline char16_t charAt(int32_t offset) const;
101
114 inline UChar32 char32At(int32_t offset) const;
115
126 virtual void extractBetween(int32_t start,
127 int32_t limit,
128 UnicodeString& target) const = 0;
129
150 virtual void handleReplaceBetween(int32_t start,
151 int32_t limit,
152 const UnicodeString& text) = 0;
153 // Note: All other methods in this class take the names of
154 // existing UnicodeString methods. This method is the exception.
155 // It is named differently because all replace methods of
156 // UnicodeString return a UnicodeString&. The 'between' is
157 // required in order to conform to the UnicodeString naming
158 // convention; API taking start/length are named <operation>, and
159 // those taking start/limit are named <operationBetween>. The
160 // 'handle' is added because 'replaceBetween' and
161 // 'doReplaceBetween' are already taken.
162
178 virtual void copy(int32_t start, int32_t limit, int32_t dest) = 0;
179
189 virtual UBool hasMetaData() const;
190
203 virtual Replaceable *clone() const;
204
205 protected:
206
211 inline Replaceable();
212
213 /*
214 * Assignment operator not declared. The compiler will provide one
215 * which does nothing since this class does not contain any data members.
216 * API/code coverage may show the assignment operator as present and
217 * untested - ignore.
218 * Subclasses need this assignment operator if they use compiler-provided
219 * assignment operators of their own. An alternative to not declaring one
220 * here would be to declare and empty-implement a protected or public one.
221 Replaceable &Replaceable::operator=(const Replaceable &);
222 */
223
228 virtual int32_t getLength() const = 0;
229
234 virtual char16_t getCharAt(int32_t offset) const = 0;
235
240 virtual UChar32 getChar32At(int32_t offset) const = 0;
241 };
242
243 inline Replaceable::Replaceable() {}
244
245 inline int32_t
246 Replaceable::length() const {
247 return getLength();
248 }
249
250 inline char16_t
251 Replaceable::charAt(int32_t offset) const {
252 return getCharAt(offset);
253 }
254
255 inline UChar32
256 Replaceable::char32At(int32_t offset) const {
257 return getChar32At(offset);
258 }
259
260 // There is no rep.cpp, see unistr.cpp for Replaceable function implementations.
261
262 U_NAMESPACE_END
263
264 #endif /* U_SHOW_CPLUSPLUS_API */
265
266 #endif
icu::Replaceable
Replaceable is an abstract base class representing a string of characters that supports the replaceme...
Definition: rep.h:77
icu::Replaceable::~Replaceable
virtual ~Replaceable()
Destructor.
icu::Replaceable::extractBetween
virtual void extractBetween(int32_t start, int32_t limit, UnicodeString &target) const =0
Copies characters in the range [start, limit) into the UnicodeString target.
icu::Replaceable::getChar32At
virtual UChar32 getChar32At(int32_t offset) const =0
Virtual version of char32At().
icu::Replaceable::copy
virtual void copy(int32_t start, int32_t limit, int32_t dest)=0
Copies a substring of this object, retaining metadata.
icu::Replaceable::handleReplaceBetween
virtual void handleReplaceBetween(int32_t start, int32_t limit, const UnicodeString &text)=0
Replaces a substring of this object with the given text.
icu::Replaceable::getCharAt
virtual char16_t getCharAt(int32_t offset) const =0
Virtual version of charAt().
icu::Replaceable::getLength
virtual int32_t getLength() const =0
Virtual version of length().
icu::Replaceable::clone
virtual Replaceable * clone() const
Clone this object, an instance of a subclass of Replaceable.
icu::Replaceable::hasMetaData
virtual UBool hasMetaData() const
Returns true if this object contains metadata.
icu::UObject
UObject is the common ICU "boilerplate" class.
Definition: uobject.h:222
icu::UnicodeString
UnicodeString is a string class that stores Unicode characters directly and provides similar function...
Definition: unistr.h:303
UChar32
int32_t UChar32
Define UChar32 as a type for single Unicode code points.
Definition: umachine.h:449
UBool
int8_t UBool
The ICU boolean type, a signed-byte integer.
Definition: umachine.h:269
uobject.h
C++ API: Common ICU base class UObject.
utypes.h
Basic definitions for ICU, for both C and C++ APIs.
U_COMMON_API
#define U_COMMON_API
Set to export library symbols from inside the common library, and to import them from outside.
Definition: utypes.h:315