1 /* 2 * Copyright (C) 2016 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 METHOD_H_ 18 19 #define METHOD_H_ 20 21 #include <android-base/macros.h> 22 #include <hidl-util/Formatter.h> 23 #include <utils/Errors.h> 24 #include <functional> 25 #include <map> 26 #include <set> 27 #include <string> 28 #include <unordered_set> 29 #include <vector> 30 31 #include "DocComment.h" 32 #include "Location.h" 33 #include "Reference.h" 34 35 namespace android { 36 37 struct Annotation; 38 struct ConstantExpression; 39 struct Formatter; 40 struct ScalarType; 41 struct Type; 42 struct TypedVarVector; 43 44 enum MethodImplType { 45 IMPL_INTERFACE, 46 IMPL_PROXY, 47 IMPL_STUB, // overrides the code in onTransact; IMPL_STUB_IMPL will be ignored 48 IMPL_STUB_IMPL, // use this->method() instead of mImpl->method() 49 IMPL_PASSTHROUGH, 50 }; 51 52 using MethodImpl = std::map<MethodImplType, std::function<void(Formatter &)>>; 53 54 struct Method : DocCommentable { 55 Method(const char* name, std::vector<NamedReference<Type>*>* args, 56 std::vector<NamedReference<Type>*>* results, bool oneway, 57 std::vector<Annotation*>* annotations, const Location& location); 58 59 std::string name() const; 60 const std::vector<NamedReference<Type>*>& args() const; 61 const std::vector<NamedReference<Type>*>& results() const; isOnewayMethod62 bool isOneway() const { return mOneway; } 63 bool overridesCppImpl(MethodImplType type) const; 64 bool overridesJavaImpl(MethodImplType type) const; 65 void cppImpl(MethodImplType type, Formatter &out) const; 66 void javaImpl(MethodImplType type, Formatter &out) const; isHidlReservedMethod67 bool isHidlReserved() const { return mIsHidlReserved; } 68 bool isHiddenFromJava() const; 69 const std::vector<Annotation *> &annotations() const; 70 71 std::vector<Reference<Type>*> getReferences(); 72 std::vector<const Reference<Type>*> getReferences() const; 73 74 std::vector<Reference<Type>*> getStrongReferences(); 75 std::vector<const Reference<Type>*> getStrongReferences() const; 76 77 std::vector<ConstantExpression*> getConstantExpressions(); 78 std::vector<const ConstantExpression*> getConstantExpressions() const; 79 80 // Make a copy with the same name, args, results, oneway, annotations. 81 // Implementations, serial are not copied. 82 Method *copySignature() const; 83 84 void setSerialId(size_t serial); 85 size_t getSerialId() const; 86 87 // Fill implementation for HIDL reserved methods. mIsHidlReserved will be 88 // set to true. 89 void fillImplementation( 90 size_t serial, 91 MethodImpl cppImpl, 92 MethodImpl javaImpl); 93 94 void generateCppReturnType(Formatter &out, bool specifyNamespaces = true) const; 95 void generateCppSignature(Formatter &out, 96 const std::string &className = "", 97 bool specifyNamespaces = true) const; 98 99 bool hasEmptyCppArgSignature() const; 100 void emitCppArgSignature(Formatter &out, bool specifyNamespaces = true) const; 101 void emitCppResultSignature(Formatter &out, bool specifyNamespaces = true) const; 102 103 void emitJavaArgSignature(Formatter &out) const; 104 void emitJavaResultSignature(Formatter &out) const; 105 106 const NamedReference<Type>* canElideCallback() const; 107 108 void dumpAnnotations(Formatter &out) const; 109 110 bool deepIsJavaCompatible(std::unordered_set<const Type*>* visited) const; 111 112 const Location& location() const; 113 114 private: 115 std::string mName; 116 size_t mSerial = 0; 117 std::vector<NamedReference<Type>*>* mArgs; 118 std::vector<NamedReference<Type>*>* mResults; 119 bool mOneway; 120 std::vector<Annotation *> *mAnnotations; 121 122 bool mIsHidlReserved = false; 123 // The following fields have no meaning if mIsHidlReserved is false. 124 // hard-coded implementation for HIDL reserved methods. 125 MethodImpl mCppImpl; 126 MethodImpl mJavaImpl; 127 128 const Location mLocation; 129 130 DISALLOW_COPY_AND_ASSIGN(Method); 131 }; 132 133 struct TypedVarVector : public std::vector<NamedReference<Type>*> { 134 TypedVarVector() = default; 135 136 bool add(NamedReference<Type>* v); 137 138 private: 139 std::set<std::string> mNames; 140 }; 141 142 } // namespace android 143 144 #endif // METHOD_H_ 145 146