Home | History | Annotate | Download | only in aidl 
      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 #include "type_cpp.h"
     18 
     19 #include <algorithm>
     20 #include <iostream>
     21 #include <vector>
     22 
     23 #include <android-base/stringprintf.h>
     24 #include <android-base/strings.h>
     25 
     26 #include "logging.h"
     27 
     28 using std::cerr;
     29 using std::endl;
     30 using std::set;
     31 using std::string;
     32 using std::unique_ptr;
     33 using std::vector;
     34 
     35 using android::base::Split;
     36 using android::base::Join;
     37 using android::base::StringPrintf;
     38 
     39 namespace android {
     40 namespace aidl {
     41 namespace cpp {
     42 namespace {
     43 
     44 const char kNoPackage[] = "";
     45 const char kNoHeader[] = "";
     46 const char kNoValidMethod[] = "";
     47 Type* const kNoArrayType = nullptr;
     48 Type* const kNoNullableType = nullptr;
     49 
     50 bool is_cpp_keyword(const std::string& str) {
     51   static const std::vector<std::string> kCppKeywords{
     52     "alignas", "alignof", "and", "and_eq", "asm", "auto", "bitand", "bitor",
     53     "bool", "break", "case", "catch", "char", "char16_t", "char32_t", "class",
     54     "compl", "concept", "const", "constexpr", "const_cast", "continue",
     55     "decltype", "default", "delete", "do", "double", "dynamic_cast", "else",
     56     "enum", "explicit", "export", "extern", "false", "float", "for", "friend",
     57     "goto", "if", "inline", "int", "long", "mutable", "namespace", "new",
     58     "noexcept", "not", "not_eq", "nullptr", "operator", "or", "or_eq",
     59     "private", "protected", "public", "register", "reinterpret_cast",
     60     "requires", "return", "short", "signed", "sizeof", "static",
     61     "static_assert", "static_cast", "struct", "switch", "template", "this",
     62     "thread_local", "throw", "true", "try", "typedef", "typeid", "typename",
     63     "union", "unsigned", "using", "virtual", "void", "volatile", "wchar_t",
     64     "while", "xor", "xor_eq",
     65   };
     66   return std::find(kCppKeywords.begin(), kCppKeywords.end(), str) !=
     67       kCppKeywords.end();
     68 }
     69 
     70 class VoidType : public Type {
     71  public:
     72   VoidType() : Type(ValidatableType::KIND_BUILT_IN, kNoPackage, "void",
     73                     {}, "void", kNoValidMethod, kNoValidMethod) {}
     74   virtual ~VoidType() = default;
     75   bool CanBeOutParameter() const override { return false; }
     76   bool CanWriteToParcel() const override { return false; }
     77 };  // class VoidType
     78 
     79 class PrimitiveType : public Type {
     80  public:
     81   PrimitiveType(int kind,  // from ValidatableType
     82                 const std::string& package,
     83                 const std::string& aidl_type,
     84                 const std::string& header,
     85                 const std::string& cpp_type,
     86                 const std::string& read_method,
     87                 const std::string& write_method,
     88                 const std::string& read_array_method,
     89                 const std::string& write_array_method)
     90       : Type(kind, package, aidl_type, {header}, cpp_type, read_method,
     91              write_method, PrimitiveArrayType(kind, package, aidl_type,
     92                                               header, cpp_type,
     93                                               read_array_method,
     94                                               write_array_method)) {}
     95 
     96   virtual ~PrimitiveType() = default;
     97   bool IsCppPrimitive() const override { return true; }
     98   bool CanBeOutParameter() const override { return is_array_; }
     99 
    100  protected:
    101   static PrimitiveType* PrimitiveArrayType(int kind,  // from ValidatableType
    102                                            const std::string& package,
    103                                            const std::string& aidl_type,
    104                                            const std::string& header,
    105                                            const std::string& cpp_type,
    106                                            const std::string& read_method,
    107                                            const std::string& write_method) {
    108     PrimitiveType* nullable =
    109         new PrimitiveType(kind, package, aidl_type + "[]", header,
    110                           "::std::unique_ptr<::std::vector<" + cpp_type + ">>",
    111                           read_method, write_method);
    112 
    113     return new PrimitiveType(kind, package, aidl_type + "[]", header,
    114                              "::std::vector<" + cpp_type + ">",
    115                              read_method, write_method, nullable);
    116   }
    117 
    118   PrimitiveType(int kind,  // from ValidatableType
    119                 const std::string& package,
    120                 const std::string& aidl_type,
    121                 const std::string& header,
    122                 const std::string& cpp_type,
    123                 const std::string& read_method,
    124                 const std::string& write_method,
    125                 Type* nullable_type = nullptr)
    126       : Type(kind, package, aidl_type, {header, "vector"}, cpp_type, read_method,
    127              write_method, kNoArrayType, nullable_type) {
    128     is_array_ = true;
    129   }
    130 
    131  private:
    132   bool is_array_ = false;
    133 
    134   DISALLOW_COPY_AND_ASSIGN(PrimitiveType);
    135 };  // class PrimitiveType
    136 
    137 class ByteType : public Type {
    138  public:
    139   ByteType() : ByteType(false, "byte", "int8_t", "readByte", "writeByte",
    140      new ByteType(true, "byte[]", "::std::vector<uint8_t>", "readByteVector",
    141          "writeByteVector", kNoArrayType,
    142          new ByteType(true, "byte[]",
    143              "::std::unique_ptr<::std::vector<uint8_t>>",
    144              "readByteVector", "writeByteVector", kNoArrayType,
    145              kNoNullableType)), kNoNullableType) {}
    146 
    147   virtual ~ByteType() = default;
    148   bool IsCppPrimitive() const override { return true; }
    149   bool CanBeOutParameter() const override { return is_array_; }
    150 
    151  protected:
    152   ByteType(bool is_array,
    153            const std::string& name,
    154            const std::string& cpp_type,
    155            const std::string& read_method,
    156            const std::string& write_method,
    157            Type* array_type,
    158            Type* nullable_type)
    159       : Type(ValidatableType::KIND_BUILT_IN, kNoPackage, name, {"cstdint"},
    160              cpp_type, read_method, write_method, array_type, nullable_type),
    161         is_array_(is_array) {}
    162 
    163  private:
    164   bool is_array_ = false;
    165 
    166   DISALLOW_COPY_AND_ASSIGN(ByteType);
    167 };  // class PrimitiveType
    168 
    169 class BinderType : public Type {
    170  public:
    171   BinderType(const AidlInterface& interface, const std::string& src_file_name)
    172       : Type(ValidatableType::KIND_GENERATED,
    173              interface.GetPackage(), interface.GetName(),
    174              {GetCppHeader(interface)}, GetCppName(interface),
    175              "readStrongBinder", "writeStrongBinder",
    176              kNoArrayType, kNoNullableType, src_file_name,
    177              interface.GetLine()),
    178         write_cast_(GetRawCppName(interface) + "::asBinder") {}
    179   virtual ~BinderType() = default;
    180 
    181   string WriteCast(const string& val) const override {
    182     return write_cast_ + "(" + val + ")";
    183   }
    184 
    185  private:
    186   static string GetCppName(const AidlInterface& interface) {
    187     return "::android::sp<" + GetRawCppName(interface) + ">";
    188   }
    189 
    190   static string GetRawCppName(const AidlInterface& interface) {
    191     vector<string> name = interface.GetSplitPackage();
    192     string ret;
    193 
    194     name.push_back(interface.GetName());
    195 
    196     for (const auto& term : name) {
    197       ret += "::" + term;
    198     }
    199 
    200     return ret;
    201   }
    202 
    203   static string GetCppHeader(const AidlInterface& interface) {
    204     vector<string> name = interface.GetSplitPackage();
    205     name.push_back(interface.GetName());
    206     return Join(name, '/') + ".h";
    207   }
    208 
    209   std::string write_cast_;
    210 };
    211 
    212 class NullableParcelableArrayType : public ArrayType {
    213  public:
    214   NullableParcelableArrayType(const AidlParcelable& parcelable,
    215                               const std::string& src_file_name)
    216       : ArrayType(ValidatableType::KIND_PARCELABLE,
    217                   parcelable.GetPackage(), parcelable.GetName(),
    218                   {parcelable.GetCppHeader(), "vector"},
    219                   GetCppName(parcelable), "readParcelableVector",
    220                   "writeParcelableVector", kNoArrayType, kNoNullableType,
    221                   src_file_name, parcelable.GetLine()) {}
    222   virtual ~NullableParcelableArrayType() = default;
    223 
    224  private:
    225   static string GetCppName(const AidlParcelable& parcelable) {
    226     return "::std::unique_ptr<::std::vector<std::unique_ptr<" +
    227         Join(parcelable.GetSplitPackage(), "::") + "::" +
    228         parcelable.GetName() + ">>>";
    229   }
    230 };
    231 
    232 class ParcelableArrayType : public ArrayType {
    233  public:
    234   ParcelableArrayType(const AidlParcelable& parcelable,
    235                       const std::string& src_file_name)
    236       : ArrayType(ValidatableType::KIND_PARCELABLE,
    237                   parcelable.GetPackage(), parcelable.GetName(),
    238                   {parcelable.GetCppHeader(), "vector"},
    239                   GetCppName(parcelable), "readParcelableVector",
    240                   "writeParcelableVector", kNoArrayType,
    241                   new NullableParcelableArrayType(parcelable, src_file_name),
    242                   src_file_name, parcelable.GetLine()) {}
    243   virtual ~ParcelableArrayType() = default;
    244 
    245  private:
    246   static string GetCppName(const AidlParcelable& parcelable) {
    247     return "::std::vector<" + Join(parcelable.GetSplitPackage(), "::") +
    248         "::" + parcelable.GetName() + ">";
    249   }
    250 };
    251 
    252 class NullableParcelableType : public Type {
    253  public:
    254   NullableParcelableType(const AidlParcelable& parcelable,
    255                          const std::string& src_file_name)
    256       : Type(ValidatableType::KIND_PARCELABLE,
    257              parcelable.GetPackage(), parcelable.GetName(),
    258              {parcelable.GetCppHeader()}, GetCppName(parcelable),
    259              "readParcelable", "writeNullableParcelable",
    260              kNoArrayType, kNoNullableType,
    261              src_file_name, parcelable.GetLine()) {}
    262   virtual ~NullableParcelableType() = default;
    263   bool CanBeOutParameter() const override { return true; }
    264 
    265  private:
    266   static string GetCppName(const AidlParcelable& parcelable) {
    267     return "::std::unique_ptr<::" + Join(parcelable.GetSplitPackage(), "::") +
    268         "::" + parcelable.GetName() + ">";
    269   }
    270 };
    271 
    272 class ParcelableType : public Type {
    273  public:
    274   ParcelableType(const AidlParcelable& parcelable,
    275                  const std::string& src_file_name)
    276       : Type(ValidatableType::KIND_PARCELABLE,
    277              parcelable.GetPackage(), parcelable.GetName(),
    278              {parcelable.GetCppHeader()}, GetCppName(parcelable),
    279              "readParcelable", "writeParcelable",
    280              new ParcelableArrayType(parcelable, src_file_name),
    281              new NullableParcelableType(parcelable, src_file_name),
    282              src_file_name, parcelable.GetLine()) {}
    283   virtual ~ParcelableType() = default;
    284   bool CanBeOutParameter() const override { return true; }
    285 
    286  private:
    287   static string GetCppName(const AidlParcelable& parcelable) {
    288     return "::" + Join(parcelable.GetSplitPackage(), "::") +
    289         "::" + parcelable.GetName();
    290   }
    291 };
    292 
    293 class NullableStringListType : public Type {
    294  public:
    295   NullableStringListType()
    296       : Type(ValidatableType::KIND_BUILT_IN,
    297              "java.util", "List<" + string(kStringCanonicalName) + ">",
    298              {"utils/String16.h", "memory", "vector"},
    299              "::std::unique_ptr<::std::vector<std::unique_ptr<::android::String16>>>",
    300              "readString16Vector", "writeString16Vector") {}
    301   virtual ~NullableStringListType() = default;
    302   bool CanBeOutParameter() const override { return true; }
    303 
    304  private:
    305   DISALLOW_COPY_AND_ASSIGN(NullableStringListType);
    306 };  // class NullableStringListType
    307 
    308 class StringListType : public Type {
    309  public:
    310   StringListType()
    311       : Type(ValidatableType::KIND_BUILT_IN,
    312              "java.util", "List<" + string(kStringCanonicalName) + ">",
    313              {"utils/String16.h", "vector"},
    314              "::std::vector<::android::String16>",
    315              "readString16Vector", "writeString16Vector",
    316              kNoArrayType, new NullableStringListType()) {}
    317   virtual ~StringListType() = default;
    318   bool CanBeOutParameter() const override { return true; }
    319 
    320  private:
    321   DISALLOW_COPY_AND_ASSIGN(StringListType);
    322 };  // class StringListType
    323 
    324 class NullableUtf8InCppStringListType : public Type {
    325  public:
    326   NullableUtf8InCppStringListType()
    327       : Type(ValidatableType::KIND_BUILT_IN,
    328              "java.util", "List<" + string(kUtf8InCppStringCanonicalName) + ">",
    329              {"memory", "string", "vector"},
    330              "::std::unique_ptr<::std::vector<std::unique_ptr<::std::string>>>",
    331              "readUtf8VectorFromUtf16Vector", "writeUtf8VectorAsUtf16Vector") {}
    332   virtual ~NullableUtf8InCppStringListType() = default;
    333   bool CanBeOutParameter() const override { return true; }
    334 
    335  private:
    336   DISALLOW_COPY_AND_ASSIGN(NullableUtf8InCppStringListType);
    337 };  // class NullableUtf8InCppStringListType
    338 
    339 class Utf8InCppStringListType : public Type {
    340  public:
    341   Utf8InCppStringListType()
    342       : Type(ValidatableType::KIND_BUILT_IN,
    343              "java.util", "List<" + string(kUtf8InCppStringCanonicalName) + ">",
    344              {"string", "vector"},
    345              "::std::vector<::std::string>",
    346              "readUtf8VectorFromUtf16Vector", "writeUtf8VectorAsUtf16Vector",
    347              kNoArrayType, new NullableUtf8InCppStringListType()) {}
    348   virtual ~Utf8InCppStringListType() = default;
    349   bool CanBeOutParameter() const override { return true; }
    350 
    351  private:
    352   DISALLOW_COPY_AND_ASSIGN(Utf8InCppStringListType);
    353 };  // class Utf8InCppStringListType
    354 
    355 class NullableBinderListType : public Type {
    356  public:
    357   NullableBinderListType()
    358       : Type(ValidatableType::KIND_BUILT_IN, "java.util",
    359              "List<android.os.IBinder>", {"binder/IBinder.h", "vector"},
    360              "::std::unique_ptr<::std::vector<::android::sp<::android::IBinder>>>",
    361              "readStrongBinderVector", "writeStrongBinderVector") {}
    362   virtual ~NullableBinderListType() = default;
    363   bool CanBeOutParameter() const override { return true; }
    364 
    365  private:
    366   DISALLOW_COPY_AND_ASSIGN(NullableBinderListType);
    367 };  // class NullableBinderListType
    368 
    369 class BinderListType : public Type {
    370  public:
    371   BinderListType()
    372       : Type(ValidatableType::KIND_BUILT_IN, "java.util",
    373              "List<android.os.IBinder>", {"binder/IBinder.h", "vector"},
    374              "::std::vector<::android::sp<::android::IBinder>>",
    375              "readStrongBinderVector", "writeStrongBinderVector",
    376              kNoArrayType, new NullableBinderListType()) {}
    377   virtual ~BinderListType() = default;
    378   bool CanBeOutParameter() const override { return true; }
    379 
    380  private:
    381   DISALLOW_COPY_AND_ASSIGN(BinderListType);
    382 };  // class BinderListType
    383 
    384 }  // namespace
    385 
    386 Type::Type(int kind,
    387            const std::string& package,
    388            const std::string& aidl_type,
    389            const vector<string>& headers,
    390            const string& cpp_type,
    391            const string& read_method,
    392            const string& write_method,
    393            Type* array_type,
    394            Type* nullable_type,
    395            const string& src_file_name,
    396            int line)
    397     : ValidatableType(kind, package, aidl_type, src_file_name, line),
    398       headers_(headers),
    399       aidl_type_(aidl_type),
    400       cpp_type_(cpp_type),
    401       parcel_read_method_(read_method),
    402       parcel_write_method_(write_method),
    403       array_type_(array_type),
    404       nullable_type_(nullable_type) {}
    405 
    406 bool Type::CanWriteToParcel() const { return true; }
    407 
    408 void TypeNamespace::Init() {
    409   Add(new ByteType());
    410   Add(new PrimitiveType(
    411       ValidatableType::KIND_BUILT_IN, kNoPackage, "int",
    412       "cstdint", "int32_t", "readInt32", "writeInt32",
    413       "readInt32Vector", "writeInt32Vector"));
    414   Add(new PrimitiveType(
    415       ValidatableType::KIND_BUILT_IN, kNoPackage, "long",
    416       "cstdint", "int64_t", "readInt64", "writeInt64",
    417       "readInt64Vector", "writeInt64Vector"));
    418   Add(new PrimitiveType(
    419       ValidatableType::KIND_BUILT_IN, kNoPackage, "float",
    420       kNoHeader, "float", "readFloat", "writeFloat",
    421       "readFloatVector", "writeFloatVector"));
    422   Add(new PrimitiveType(
    423       ValidatableType::KIND_BUILT_IN, kNoPackage, "double",
    424       kNoHeader, "double", "readDouble", "writeDouble",
    425       "readDoubleVector", "writeDoubleVector"));
    426   Add(new PrimitiveType(
    427       ValidatableType::KIND_BUILT_IN, kNoPackage, "boolean",
    428       kNoHeader, "bool", "readBool", "writeBool",
    429       "readBoolVector", "writeBoolVector"));
    430   // C++11 defines the char16_t type as a built in for Unicode characters.
    431   Add(new PrimitiveType(
    432       ValidatableType::KIND_BUILT_IN, kNoPackage, "char",
    433       kNoHeader, "char16_t", "readChar", "writeChar",
    434       "readCharVector", "writeCharVector"));
    435 
    436   Type* nullable_string_array_type =
    437       new ArrayType(ValidatableType::KIND_BUILT_IN, "java.lang", "String[]",
    438                     {"utils/String16.h", "memory", "vector"},
    439                     "::std::unique_ptr<::std::vector<::std::unique_ptr<::android::String16>>>",
    440                     "readString16Vector", "writeString16Vector");
    441 
    442   Type* string_array_type = new ArrayType(ValidatableType::KIND_BUILT_IN,
    443                                           "java.lang", "String[]",
    444                                           {"utils/String16.h", "vector"},
    445                                           "::std::vector<::android::String16>",
    446                                           "readString16Vector",
    447                                           "writeString16Vector", kNoArrayType,
    448                                           nullable_string_array_type);
    449 
    450   Type* nullable_string_type =
    451       new Type(ValidatableType::KIND_BUILT_IN, "java.lang", "String",
    452                {"memory", "utils/String16.h"}, "::std::unique_ptr<::android::String16>",
    453                "readString16", "writeString16");
    454 
    455   string_type_ = new Type(ValidatableType::KIND_BUILT_IN, "java.lang", "String",
    456                           {"utils/String16.h"}, "::android::String16",
    457                           "readString16", "writeString16",
    458                           string_array_type, nullable_string_type);
    459   Add(string_type_);
    460 
    461   using ::android::aidl::kAidlReservedTypePackage;
    462   using ::android::aidl::kUtf8InCppStringClass;
    463 
    464   // This type is a Utf16 string in the parcel, but deserializes to
    465   // a std::string in Utf8 format when we use it in C++.
    466   Type* nullable_cpp_utf8_string_array = new ArrayType(
    467       ValidatableType::KIND_BUILT_IN,
    468       kAidlReservedTypePackage, StringPrintf("%s[]", kUtf8InCppStringClass),
    469       {"memory", "string", "vector"},
    470       "::std::unique_ptr<::std::vector<::std::unique_ptr<::std::string>>>",
    471       "readUtf8VectorFromUtf16Vector", "writeUtf8VectorAsUtf16Vector");
    472   Type* cpp_utf8_string_array = new ArrayType(
    473       ValidatableType::KIND_BUILT_IN,
    474       kAidlReservedTypePackage, StringPrintf("%s[]", kUtf8InCppStringClass),
    475       {"string", "vector"},
    476       "::std::vector<::std::string>",
    477       "readUtf8VectorFromUtf16Vector", "writeUtf8VectorAsUtf16Vector",
    478       kNoArrayType, nullable_cpp_utf8_string_array);
    479   Type* nullable_cpp_utf8_string_type = new Type(
    480       ValidatableType::KIND_BUILT_IN,
    481       kAidlReservedTypePackage, kUtf8InCppStringClass,
    482       {"string", "memory"}, "::std::unique_ptr<::std::string>",
    483       "readUtf8FromUtf16", "writeUtf8AsUtf16");
    484   Add(new Type(
    485       ValidatableType::KIND_BUILT_IN,
    486       kAidlReservedTypePackage, kUtf8InCppStringClass,
    487       {"string"}, "::std::string", "readUtf8FromUtf16", "writeUtf8AsUtf16",
    488       cpp_utf8_string_array, nullable_cpp_utf8_string_type));
    489 
    490   ibinder_type_ = new Type(ValidatableType::KIND_BUILT_IN, "android.os",
    491                            "IBinder", {"binder/IBinder.h"},
    492                            "::android::sp<::android::IBinder>", "readStrongBinder",
    493                            "writeStrongBinder");
    494   Add(ibinder_type_);
    495 
    496   Add(new BinderListType());
    497   Add(new StringListType());
    498   Add(new Utf8InCppStringListType());
    499 
    500   Type* fd_vector_type = new ArrayType(
    501       ValidatableType::KIND_BUILT_IN, kNoPackage, "FileDescriptor[]",
    502       {"nativehelper/ScopedFd.h", "vector"}, "::std::vector<::ScopedFd>",
    503       "readUniqueFileDescriptorVector", "writeUniqueFileDescriptorVector");
    504 
    505   Add(new Type(
    506       ValidatableType::KIND_BUILT_IN, kNoPackage, "FileDescriptor",
    507       {"nativehelper/ScopedFd.h"}, "::ScopedFd",
    508       "readUniqueFileDescriptor", "writeUniqueFileDescriptor",
    509       fd_vector_type));
    510 
    511   void_type_ = new class VoidType();
    512   Add(void_type_);
    513 }
    514 
    515 bool TypeNamespace::AddParcelableType(const AidlParcelable& p,
    516                                       const string& filename) {
    517   if (p.GetCppHeader().empty()) {
    518     LOG(ERROR) << "Parcelable " << p.GetCanonicalName()
    519                << " has no C++ header defined.";
    520     return false;
    521   }
    522   Add(new ParcelableType(p, filename));
    523   return true;
    524 }
    525 
    526 bool TypeNamespace::AddBinderType(const AidlInterface& b,
    527                                   const string& file_name) {
    528   Add(new BinderType(b, file_name));
    529   return true;
    530 }
    531 
    532 bool TypeNamespace::AddListType(const std::string& type_name) {
    533   const Type* contained_type = FindTypeByCanonicalName(type_name);
    534   if (!contained_type) {
    535     LOG(ERROR) << "Cannot create List<" << type_name << "> because contained "
    536                   "type cannot be found or is invalid.";
    537     return false;
    538   }
    539   if (contained_type->IsCppPrimitive()) {
    540     LOG(ERROR) << "Cannot create List<" << type_name << "> because contained "
    541                   "type is a primitive in Java and Java List cannot hold "
    542                   "primitives.";
    543     return false;
    544   }
    545 
    546   if (contained_type->CanonicalName() == kStringCanonicalName ||
    547       contained_type->CanonicalName() == kUtf8InCppStringCanonicalName ||
    548       contained_type == IBinderType()) {
    549     return true;
    550   }
    551 
    552   // TODO Support lists of parcelables b/23600712
    553 
    554   LOG(ERROR) << "aidl-cpp does not yet support List<" << type_name << ">";
    555   return false;
    556 }
    557 
    558 bool TypeNamespace::AddMapType(const std::string& /* key_type_name */,
    559                                const std::string& /* value_type_name */) {
    560   // TODO Support list types b/25242025
    561   LOG(ERROR) << "aidl does not implement support for typed maps!";
    562   return false;
    563 }
    564 
    565 bool TypeNamespace::IsValidPackage(const string& package) const {
    566   if (package.empty()) {
    567     return false;
    568   }
    569 
    570   auto pieces = Split(package, ".");
    571   for (const string& piece : pieces) {
    572     if (is_cpp_keyword(piece)) {
    573       return false;
    574     }
    575   }
    576 
    577   return true;
    578 }
    579 
    580 const ValidatableType* TypeNamespace::GetArgType(const AidlArgument& a,
    581     int arg_index,
    582     const std::string& filename) const {
    583   const string error_prefix = StringPrintf(
    584       "In file %s line %d parameter %s (%d):\n    ",
    585       filename.c_str(), a.GetLine(), a.GetName().c_str(), arg_index);
    586 
    587   // check that the name doesn't match a keyword
    588   if (is_cpp_keyword(a.GetName().c_str())) {
    589     cerr << error_prefix << "Argument name is a C++ keyword"
    590          << endl;
    591     return nullptr;
    592   }
    593 
    594   return ::android::aidl::TypeNamespace::GetArgType(a, arg_index, filename);
    595 }
    596 
    597 }  // namespace cpp
    598 }  // namespace aidl
    599 }  // namespace android
    600