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