Util.h revision cf95a580149ec03588b1c75f036c924730f83615 
1/*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef AAPT_UTIL_H
18#define AAPT_UTIL_H
19
20#include "util/BigBuffer.h"
21#include "util/Maybe.h"
22#include "util/StringPiece.h"
23
24#include <androidfw/ResourceTypes.h>
25#include <functional>
26#include <memory>
27#include <ostream>
28#include <string>
29#include <vector>
30
31namespace aapt {
32namespace util {
33
34std::vector<std::string> split(const StringPiece& str, char sep);
35std::vector<std::string> splitAndLowercase(const StringPiece& str, char sep);
36
37/**
38 * Returns true if the string starts with prefix.
39 */
40template <typename T>
41bool stringStartsWith(const BasicStringPiece<T>& str, const BasicStringPiece<T>& prefix) {
42    if (str.size() < prefix.size()) {
43        return false;
44    }
45    return str.substr(0, prefix.size()) == prefix;
46}
47
48/**
49 * Returns true if the string ends with suffix.
50 */
51template <typename T>
52bool stringEndsWith(const BasicStringPiece<T>& str, const BasicStringPiece<T>& suffix) {
53    if (str.size() < suffix.size()) {
54        return false;
55    }
56    return str.substr(str.size() - suffix.size(), suffix.size()) == suffix;
57}
58
59/**
60 * Creates a new StringPiece16 that points to a substring
61 * of the original string without leading or trailing whitespace.
62 */
63StringPiece16 trimWhitespace(const StringPiece16& str);
64
65StringPiece trimWhitespace(const StringPiece& str);
66
67/**
68 * UTF-16 isspace(). It basically checks for lower range characters that are
69 * whitespace.
70 */
71inline bool isspace16(char16_t c) {
72    return c < 0x0080 && isspace(c);
73}
74
75/**
76 * Returns an iterator to the first character that is not alpha-numeric and that
77 * is not in the allowedChars set.
78 */
79StringPiece16::const_iterator findNonAlphaNumericAndNotInSet(const StringPiece16& str,
80        const StringPiece16& allowedChars);
81
82/**
83 * Tests that the string is a valid Java class name.
84 */
85bool isJavaClassName(const StringPiece16& str);
86
87/**
88 * Tests that the string is a valid Java package name.
89 */
90bool isJavaPackageName(const StringPiece16& str);
91
92/**
93 * Converts the class name to a fully qualified class name from the given `package`. Ex:
94 *
95 * asdf         --> package.asdf
96 * .asdf        --> package.asdf
97 * .a.b         --> package.a.b
98 * asdf.adsf    --> asdf.adsf
99 */
100Maybe<std::u16string> getFullyQualifiedClassName(const StringPiece16& package,
101                                                 const StringPiece16& className);
102
103
104/**
105 * Makes a std::unique_ptr<> with the template parameter inferred by the compiler.
106 * This will be present in C++14 and can be removed then.
107 */
108template <typename T, class... Args>
109std::unique_ptr<T> make_unique(Args&&... args) {
110    return std::unique_ptr<T>(new T{std::forward<Args>(args)...});
111}
112
113/**
114 * Writes a set of items to the std::ostream, joining the times with the provided
115 * separator.
116 */
117template <typename Iterator>
118::std::function<::std::ostream&(::std::ostream&)> joiner(Iterator begin, Iterator end,
119        const char* sep) {
120    return [begin, end, sep](::std::ostream& out) -> ::std::ostream& {
121        for (auto iter = begin; iter != end; ++iter) {
122            if (iter != begin) {
123                out << sep;
124            }
125            out << *iter;
126        }
127        return out;
128    };
129}
130
131inline ::std::function<::std::ostream&(::std::ostream&)> formatSize(size_t size) {
132    return [size](::std::ostream& out) -> ::std::ostream& {
133        constexpr size_t K = 1024u;
134        constexpr size_t M = K * K;
135        constexpr size_t G = M * K;
136        if (size < K) {
137            out << size << "B";
138        } else if (size < M) {
139            out << (double(size) / K) << " KiB";
140        } else if (size < G) {
141            out << (double(size) / M) << " MiB";
142        } else {
143            out << (double(size) / G) << " GiB";
144        }
145        return out;
146    };
147}
148
149/**
150 * Helper method to extract a string from a StringPool.
151 */
152inline StringPiece16 getString(const android::ResStringPool& pool, size_t idx) {
153    size_t len;
154    const char16_t* str = pool.stringAt(idx, &len);
155    if (str != nullptr) {
156        return StringPiece16(str, len);
157    }
158    return StringPiece16();
159}
160
161/**
162 * Checks that the Java string format contains no non-positional arguments (arguments without
163 * explicitly specifying an index) when there are more than one argument. This is an error
164 * because translations may rearrange the order of the arguments in the string, which will
165 * break the string interpolation.
166 */
167bool verifyJavaStringFormat(const StringPiece16& str);
168
169class StringBuilder {
170public:
171    StringBuilder& append(const StringPiece16& str);
172    const std::u16string& str() const;
173    const std::string& error() const;
174    operator bool() const;
175
176private:
177    std::u16string mStr;
178    bool mQuote = false;
179    bool mTrailingSpace = false;
180    bool mLastCharWasEscape = false;
181    std::string mError;
182};
183
184inline const std::u16string& StringBuilder::str() const {
185    return mStr;
186}
187
188inline const std::string& StringBuilder::error() const {
189    return mError;
190}
191
192inline StringBuilder::operator bool() const {
193    return mError.empty();
194}
195
196/**
197 * Converts a UTF8 string to a UTF16 string.
198 */
199std::u16string utf8ToUtf16(const StringPiece& utf8);
200std::string utf16ToUtf8(const StringPiece16& utf8);
201
202/**
203 * Writes the entire BigBuffer to the output stream.
204 */
205bool writeAll(std::ostream& out, const BigBuffer& buffer);
206
207/*
208 * Copies the entire BigBuffer into a single buffer.
209 */
210std::unique_ptr<uint8_t[]> copy(const BigBuffer& buffer);
211
212/**
213 * A Tokenizer implemented as an iterable collection. It does not allocate
214 * any memory on the heap nor use standard containers.
215 */
216template <typename Char>
217class Tokenizer {
218public:
219    class iterator {
220    public:
221        iterator(const iterator&) = default;
222        iterator& operator=(const iterator&) = default;
223
224        iterator& operator++();
225        BasicStringPiece<Char> operator*();
226        bool operator==(const iterator& rhs) const;
227        bool operator!=(const iterator& rhs) const;
228
229    private:
230        friend class Tokenizer<Char>;
231
232        iterator(BasicStringPiece<Char> s, Char sep, BasicStringPiece<Char> tok, bool end);
233
234        BasicStringPiece<Char> mStr;
235        Char mSeparator;
236        BasicStringPiece<Char> mToken;
237        bool mEnd;
238    };
239
240    Tokenizer(BasicStringPiece<Char> str, Char sep);
241    iterator begin();
242    iterator end();
243
244private:
245    const iterator mBegin;
246    const iterator mEnd;
247};
248
249template <typename Char>
250inline Tokenizer<Char> tokenize(BasicStringPiece<Char> str, Char sep) {
251    return Tokenizer<Char>(str, sep);
252}
253
254template <typename Char>
255typename Tokenizer<Char>::iterator& Tokenizer<Char>::iterator::operator++() {
256    const Char* start = mToken.end();
257    const Char* end = mStr.end();
258    if (start == end) {
259        mEnd = true;
260        mToken.assign(mToken.end(), 0);
261        return *this;
262    }
263
264    start += 1;
265    const Char* current = start;
266    while (current != end) {
267        if (*current == mSeparator) {
268            mToken.assign(start, current - start);
269            return *this;
270        }
271        ++current;
272    }
273    mToken.assign(start, end - start);
274    return *this;
275}
276
277template <typename Char>
278inline BasicStringPiece<Char> Tokenizer<Char>::iterator::operator*() {
279    return mToken;
280}
281
282template <typename Char>
283inline bool Tokenizer<Char>::iterator::operator==(const iterator& rhs) const {
284    // We check equality here a bit differently.
285    // We need to know that the addresses are the same.
286    return mToken.begin() == rhs.mToken.begin() && mToken.end() == rhs.mToken.end() &&
287            mEnd == rhs.mEnd;
288}
289
290template <typename Char>
291inline bool Tokenizer<Char>::iterator::operator!=(const iterator& rhs) const {
292    return !(*this == rhs);
293}
294
295template <typename Char>
296inline Tokenizer<Char>::iterator::iterator(BasicStringPiece<Char> s, Char sep,
297                                           BasicStringPiece<Char> tok, bool end) :
298        mStr(s), mSeparator(sep), mToken(tok), mEnd(end) {
299}
300
301template <typename Char>
302inline typename Tokenizer<Char>::iterator Tokenizer<Char>::begin() {
303    return mBegin;
304}
305
306template <typename Char>
307inline typename Tokenizer<Char>::iterator Tokenizer<Char>::end() {
308    return mEnd;
309}
310
311template <typename Char>
312inline Tokenizer<Char>::Tokenizer(BasicStringPiece<Char> str, Char sep) :
313        mBegin(++iterator(str, sep, BasicStringPiece<Char>(str.begin() - 1, 0), false)),
314        mEnd(str, sep, BasicStringPiece<Char>(str.end(), 0), true) {
315}
316
317inline uint16_t hostToDevice16(uint16_t value) {
318    return htods(value);
319}
320
321inline uint32_t hostToDevice32(uint32_t value) {
322    return htodl(value);
323}
324
325inline uint16_t deviceToHost16(uint16_t value) {
326    return dtohs(value);
327}
328
329inline uint32_t deviceToHost32(uint32_t value) {
330    return dtohl(value);
331}
332
333/**
334 * Returns a package name if the namespace URI is of the form:
335 * http://schemas.android.com/apk/res/<package>
336 *
337 * Special case: if namespaceUri is http://schemas.android.com/apk/res-auto,
338 * returns an empty package name.
339 */
340Maybe<std::u16string> extractPackageFromNamespace(const std::u16string& namespaceUri);
341
342/**
343 * Given a path like: res/xml-sw600dp/foo.xml
344 *
345 * Extracts "res/xml-sw600dp/" into outPrefix.
346 * Extracts "foo" into outEntry.
347 * Extracts ".xml" into outSuffix.
348 *
349 * Returns true if successful.
350 */
351bool extractResFilePathParts(const StringPiece16& path, StringPiece16* outPrefix,
352                             StringPiece16* outEntry, StringPiece16* outSuffix);
353
354} // namespace util
355
356/**
357 * Stream operator for functions. Calls the function with the stream as an argument.
358 * In the aapt namespace for lookup.
359 */
360inline ::std::ostream& operator<<(::std::ostream& out,
361                                  ::std::function<::std::ostream&(::std::ostream&)> f) {
362    return f(out);
363}
364
365} // namespace aapt
366
367#endif // AAPT_UTIL_H
368