tools/aapt2/ResourceUtils.h

   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_RESOURCEUTILS_H
  18 #define AAPT_RESOURCEUTILS_H
  19
  20 #include "NameMangler.h"
  21 #include "Resource.h"
  22 #include "ResourceValues.h"
  23 #include "util/StringPiece.h"
  24
  25 #include <functional>
  26 #include <memory>
  27
  28 namespace aapt {
  29 namespace ResourceUtils {
  30
  31 /*
  32  * Extracts the package, type, and name from a string of the format:
  33  *
  34  *      [package:]type/name
  35  *
  36  * where the package can be empty. Validation must be performed on each
  37  * individual extracted piece to verify that the pieces are valid.
  38  * Returns false if there was no package but a ':' was present.
  39  */
  40 bool extractResourceName(const StringPiece16& str, StringPiece16* outPackage,
  41                          StringPiece16* outType, StringPiece16* outEntry);
  42
  43 /**
  44  * Returns true if the string was parsed as a resource name ([*][package:]type/name), with
  45  * `outResource` set to the parsed resource name and `outPrivate` set to true if a '*' prefix
  46  * was present.
  47  */
  48 bool parseResourceName(const StringPiece16& str, ResourceNameRef* outResource,
  49                        bool* outPrivate = nullptr);
  50
  51 /*
  52  * Returns true if the string was parsed as a reference (@[+][package:]type/name), with
  53  * `outReference` set to the parsed reference.
  54  *
  55  * If '+' was present in the reference, `outCreate` is set to true.
  56  * If '*' was present in the reference, `outPrivate` is set to true.
  57  */
  58 bool tryParseReference(const StringPiece16& str, ResourceNameRef* outReference,
  59                        bool* outCreate = nullptr, bool* outPrivate = nullptr);
  60
  61 /*
  62  * Returns true if the string is in the form of a resource reference (@[+][package:]type/name).
  63  */
  64 bool isReference(const StringPiece16& str);
  65
  66 /*
  67  * Returns true if the string was parsed as an attribute reference (?[package:][type/]name),
  68  * with `outReference` set to the parsed reference.
  69  */
  70 bool tryParseAttributeReference(const StringPiece16& str, ResourceNameRef* outReference);
  71
  72 /**
  73  * Returns true if the string is in the form of an attribute reference(?[package:][type/]name).
  74  */
  75 bool isAttributeReference(const StringPiece16& str);
  76
  77 /**
  78  * Returns true if the value is a boolean, putting the result in `outValue`.
  79  */
  80 bool tryParseBool(const StringPiece16& str, bool* outValue);
  81
  82 /*
  83  * Returns a Reference, or None Maybe instance if the string `str` was parsed as a
  84  * valid reference to a style.
  85  * The format for a style parent is slightly more flexible than a normal reference:
  86  *
  87  * @[package:]style/<entry> or
  88  * ?[package:]style/<entry> or
  89  * <package>:[style/]<entry>
  90  */
  91 Maybe<Reference> parseStyleParentReference(const StringPiece16& str, std::string* outError);
  92
  93 /*
  94  * Returns a Reference object if the string was parsed as a resource or attribute reference,
  95  * ( @[+][package:]type/name | ?[package:]type/name ) setting outCreate to true if
  96  * the '+' was present in the string.
  97  */
  98 std::unique_ptr<Reference> tryParseReference(const StringPiece16& str, bool* outCreate = nullptr);
  99
 100 /*
 101  * Returns a BinaryPrimitve object representing @null or @empty if the string was parsed
 102  * as one.
 103  */
 104 std::unique_ptr<BinaryPrimitive> tryParseNullOrEmpty(const StringPiece16& str);
 105
 106 /*
 107  * Returns a BinaryPrimitve object representing a color if the string was parsed
 108  * as one.
 109  */
 110 std::unique_ptr<BinaryPrimitive> tryParseColor(const StringPiece16& str);
 111
 112 /*
 113  * Returns a BinaryPrimitve object representing a boolean if the string was parsed
 114  * as one.
 115  */
 116 std::unique_ptr<BinaryPrimitive> tryParseBool(const StringPiece16& str);
 117
 118 /*
 119  * Returns a BinaryPrimitve object representing an integer if the string was parsed
 120  * as one.
 121  */
 122 std::unique_ptr<BinaryPrimitive> tryParseInt(const StringPiece16& str);
 123
 124 /*
 125  * Returns a BinaryPrimitve object representing a floating point number
 126  * (float, dimension, etc) if the string was parsed as one.
 127  */
 128 std::unique_ptr<BinaryPrimitive> tryParseFloat(const StringPiece16& str);
 129
 130 /*
 131  * Returns a BinaryPrimitve object representing an enum symbol if the string was parsed
 132  * as one.
 133  */
 134 std::unique_ptr<BinaryPrimitive> tryParseEnumSymbol(const Attribute* enumAttr,
 135                                                     const StringPiece16& str);
 136
 137 /*
 138  * Returns a BinaryPrimitve object representing a flag symbol if the string was parsed
 139  * as one.
 140  */
 141 std::unique_ptr<BinaryPrimitive> tryParseFlagSymbol(const Attribute* enumAttr,
 142                                                     const StringPiece16& str);
 143 /*
 144  * Try to convert a string to an Item for the given attribute. The attribute will
 145  * restrict what values the string can be converted to.
 146  * The callback function onCreateReference is called when the parsed item is a
 147  * reference to an ID that must be created (@+id/foo).
 148  */
 149 std::unique_ptr<Item> parseItemForAttribute(
 150         const StringPiece16& value, const Attribute* attr,
 151         std::function<void(const ResourceName&)> onCreateReference = {});
 152
 153 std::unique_ptr<Item> parseItemForAttribute(
 154         const StringPiece16& value, uint32_t typeMask,
 155         std::function<void(const ResourceName&)> onCreateReference = {});
 156
 157 uint32_t androidTypeToAttributeTypeMask(uint16_t type);
 158
 159 /**
 160  * Returns a string path suitable for use within an APK. The path will look like:
 161  *
 162  * res/type[-config]/<name>.<ext>
 163  *
 164  * Then name may be mangled if a NameMangler is supplied (can be nullptr) and the package
 165  * requires mangling.
 166  */
 167 std::string buildResourceFileName(const ResourceFile& resFile, const NameMangler* mangler);
 168
 169 } // namespace ResourceUtils
 170 } // namespace aapt
 171
 172 #endif /* AAPT_RESOURCEUTILS_H */