Line data Source code
1 : // © 2016 and later: Unicode, Inc. and others.
2 : // License & terms of use: http://www.unicode.org/copyright.html
3 : /*
4 : **********************************************************************
5 : * Copyright (c) 2001-2015, International Business Machines
6 : * Corporation and others. All Rights Reserved.
7 : **********************************************************************
8 : * Date Name Description
9 : * 11/19/2001 aliu Creation.
10 : * 05/19/2010 markus Rewritten from scratch
11 : **********************************************************************
12 : */
13 :
14 : #ifndef CHARSTRING_H
15 : #define CHARSTRING_H
16 :
17 : #include "unicode/utypes.h"
18 : #include "unicode/unistr.h"
19 : #include "unicode/uobject.h"
20 : #include "cmemory.h"
21 :
22 : U_NAMESPACE_BEGIN
23 :
24 : // Windows needs us to DLL-export the MaybeStackArray template specialization,
25 : // but MacOS X cannot handle it. Same as in digitlst.h.
26 : #if !U_PLATFORM_IS_DARWIN_BASED
27 : template class U_COMMON_API MaybeStackArray<char, 40>;
28 : #endif
29 :
30 : /**
31 : * ICU-internal char * string class.
32 : * This class does not assume or enforce any particular character encoding.
33 : * Raw bytes can be stored. The string object owns its characters.
34 : * A terminating NUL is stored, but the class does not prevent embedded NUL characters.
35 : *
36 : * This class wants to be convenient but is also deliberately minimalist.
37 : * Please do not add methods if they only add minor convenience.
38 : * For example:
39 : * cs.data()[5]='a'; // no need for setCharAt(5, 'a')
40 : */
41 : class U_COMMON_API CharString : public UMemory {
42 : public:
43 58 : CharString() : len(0) { buffer[0]=0; }
44 0 : CharString(StringPiece s, UErrorCode &errorCode) : len(0) {
45 0 : buffer[0]=0;
46 0 : append(s, errorCode);
47 0 : }
48 0 : CharString(const CharString &s, UErrorCode &errorCode) : len(0) {
49 0 : buffer[0]=0;
50 0 : append(s, errorCode);
51 0 : }
52 1 : CharString(const char *s, int32_t sLength, UErrorCode &errorCode) : len(0) {
53 1 : buffer[0]=0;
54 1 : append(s, sLength, errorCode);
55 1 : }
56 59 : ~CharString() {}
57 :
58 : /**
59 : * Replaces this string's contents with the other string's contents.
60 : * CharString does not support the standard copy constructor nor
61 : * the assignment operator, to make copies explicit and to
62 : * use a UErrorCode where memory allocations might be needed.
63 : */
64 : CharString ©From(const CharString &other, UErrorCode &errorCode);
65 :
66 17 : UBool isEmpty() const { return len==0; }
67 51 : int32_t length() const { return len; }
68 10 : char operator[](int32_t index) const { return buffer[index]; }
69 0 : StringPiece toStringPiece() const { return StringPiece(buffer.getAlias(), len); }
70 :
71 14 : const char *data() const { return buffer.getAlias(); }
72 115 : char *data() { return buffer.getAlias(); }
73 :
74 : /** @return last index of c, or -1 if c is not in this string */
75 : int32_t lastIndexOf(char c) const;
76 :
77 10 : CharString &clear() { len=0; buffer[0]=0; return *this; }
78 : CharString &truncate(int32_t newLength);
79 :
80 : CharString &append(char c, UErrorCode &errorCode);
81 69 : CharString &append(StringPiece s, UErrorCode &errorCode) {
82 69 : return append(s.data(), s.length(), errorCode);
83 : }
84 14 : CharString &append(const CharString &s, UErrorCode &errorCode) {
85 14 : return append(s.data(), s.length(), errorCode);
86 : }
87 : CharString &append(const char *s, int32_t sLength, UErrorCode &status);
88 : /**
89 : * Returns a writable buffer for appending and writes the buffer's capacity to
90 : * resultCapacity. Guarantees resultCapacity>=minCapacity if U_SUCCESS().
91 : * There will additionally be space for a terminating NUL right at resultCapacity.
92 : * (This function is similar to ByteSink.GetAppendBuffer().)
93 : *
94 : * The returned buffer is only valid until the next write operation
95 : * on this string.
96 : *
97 : * After writing at most resultCapacity bytes, call append() with the
98 : * pointer returned from this function and the number of bytes written.
99 : *
100 : * @param minCapacity required minimum capacity of the returned buffer;
101 : * must be non-negative
102 : * @param desiredCapacityHint desired capacity of the returned buffer;
103 : * must be non-negative
104 : * @param resultCapacity will be set to the capacity of the returned buffer
105 : * @param errorCode in/out error code
106 : * @return a buffer with resultCapacity>=min_capacity
107 : */
108 : char *getAppendBuffer(int32_t minCapacity,
109 : int32_t desiredCapacityHint,
110 : int32_t &resultCapacity,
111 : UErrorCode &errorCode);
112 :
113 : CharString &appendInvariantChars(const UnicodeString &s, UErrorCode &errorCode);
114 :
115 : /**
116 : * Appends a filename/path part, e.g., a directory name.
117 : * First appends a U_FILE_SEP_CHAR if necessary.
118 : * Does nothing if s is empty.
119 : */
120 : CharString &appendPathPart(StringPiece s, UErrorCode &errorCode);
121 :
122 : /**
123 : * Appends a U_FILE_SEP_CHAR if this string is not empty
124 : * and does not already end with a U_FILE_SEP_CHAR or U_FILE_ALT_SEP_CHAR.
125 : */
126 : CharString &ensureEndsWithFileSeparator(UErrorCode &errorCode);
127 :
128 : private:
129 : MaybeStackArray<char, 40> buffer;
130 : int32_t len;
131 :
132 : UBool ensureCapacity(int32_t capacity, int32_t desiredCapacityHint, UErrorCode &errorCode);
133 :
134 : CharString(const CharString &other); // forbid copying of this class
135 : CharString &operator=(const CharString &other); // forbid copying of this class
136 : };
137 :
138 : U_NAMESPACE_END
139 :
140 : #endif
141 : //eof
|
