diff options
Diffstat (limited to 'tools/aapt2/StringPool.h')
-rw-r--r-- | tools/aapt2/StringPool.h | 215 |
1 files changed, 215 insertions, 0 deletions
diff --git a/tools/aapt2/StringPool.h b/tools/aapt2/StringPool.h new file mode 100644 index 0000000..2aa5b65 --- /dev/null +++ b/tools/aapt2/StringPool.h @@ -0,0 +1,215 @@ +/* + * Copyright (C) 2015 The Android Open Source Project + * + * 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. + */ + +#ifndef AAPT_STRING_POOL_H +#define AAPT_STRING_POOL_H + +#include "BigBuffer.h" +#include "ConfigDescription.h" +#include "StringPiece.h" + +#include <functional> +#include <map> +#include <memory> +#include <string> +#include <vector> + +namespace aapt { + +struct Span { + std::u16string name; + uint32_t firstChar; + uint32_t lastChar; +}; + +struct StyleString { + std::u16string str; + std::vector<Span> spans; +}; + +class StringPool { +public: + struct Context { + uint32_t priority; + ConfigDescription config; + }; + + class Entry; + + class Ref { + public: + Ref(); + Ref(const Ref&); + ~Ref(); + + Ref& operator=(const Ref& rhs); + const std::u16string* operator->() const; + const std::u16string& operator*() const; + + size_t getIndex() const; + const Context& getContext() const; + + private: + friend class StringPool; + + Ref(Entry* entry); + + Entry* mEntry; + }; + + class StyleEntry; + + class StyleRef { + public: + StyleRef(); + StyleRef(const StyleRef&); + ~StyleRef(); + + StyleRef& operator=(const StyleRef& rhs); + const StyleEntry* operator->() const; + const StyleEntry& operator*() const; + + size_t getIndex() const; + const Context& getContext() const; + + private: + friend class StringPool; + + StyleRef(StyleEntry* entry); + + StyleEntry* mEntry; + }; + + class Entry { + public: + std::u16string value; + Context context; + size_t index; + + private: + friend class StringPool; + friend class Ref; + + int ref; + }; + + struct Span { + Ref name; + uint32_t firstChar; + uint32_t lastChar; + }; + + class StyleEntry { + public: + Ref str; + std::vector<Span> spans; + + private: + friend class StringPool; + friend class StyleRef; + + int ref; + }; + + using const_iterator = std::vector<std::unique_ptr<Entry>>::const_iterator; + + static bool flattenUtf8(BigBuffer* out, const StringPool& pool); + static bool flatten(BigBuffer* out, const StringPool& pool); + + StringPool() = default; + StringPool(const StringPool&) = delete; + + /** + * Adds a string to the pool, unless it already exists. Returns + * a reference to the string in the pool. + */ + Ref makeRef(const StringPiece16& str); + + /** + * Adds a string to the pool, unless it already exists, with a context + * object that can be used when sorting the string pool. Returns + * a reference to the string in the pool. + */ + Ref makeRef(const StringPiece16& str, const Context& context); + + /** + * Adds a style to the string pool and returns a reference to it. + */ + StyleRef makeRef(const StyleString& str); + + /** + * Adds a style to the string pool with a context object that + * can be used when sorting the string pool. Returns a reference + * to the style in the string pool. + */ + StyleRef makeRef(const StyleString& str, const Context& context); + + /** + * Moves pool into this one without coalescing strings. When this + * function returns, pool will be empty. + */ + void merge(StringPool&& pool); + + /** + * Retuns the number of strings in the table. + */ + inline size_t size() const; + + /** + * Reserves space for strings and styles as an optimization. + */ + void hintWillAdd(size_t stringCount, size_t styleCount); + + /** + * Sorts the strings according to some comparison function. + */ + void sort(const std::function<bool(const Entry&, const Entry&)>& cmp); + + /** + * Removes any strings that have no references. + */ + void prune(); + +private: + friend const_iterator begin(const StringPool& pool); + friend const_iterator end(const StringPool& pool); + + Ref makeRefImpl(const StringPiece16& str, const Context& context, bool unique); + + std::vector<std::unique_ptr<Entry>> mStrings; + std::vector<std::unique_ptr<StyleEntry>> mStyles; + std::multimap<StringPiece16, Entry*> mIndexedStrings; +}; + +// +// Inline implementation +// + +inline size_t StringPool::size() const { + return mStrings.size(); +} + +inline StringPool::const_iterator begin(const StringPool& pool) { + return pool.mStrings.begin(); +} + +inline StringPool::const_iterator end(const StringPool& pool) { + return pool.mStrings.end(); +} + +} // namespace aapt + +#endif // AAPT_STRING_POOL_H |