| /* |
| * 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. |
| */ |
| |
| #pragma once |
| |
| #include <string> |
| #include <vector> |
| |
| #include "ast_java.h" |
| #include "type_namespace.h" |
| |
| namespace android { |
| namespace aidl { |
| namespace java { |
| |
| class JavaTypeNamespace; |
| |
| class Type : public ValidatableType { |
| public: |
| // WriteToParcel flags |
| enum { PARCELABLE_WRITE_RETURN_VALUE = 0x0001 }; |
| |
| // defaultValue is by default set to "null" because that is the default value |
| // for most of the types like class and array. default values for built-in |
| // types like int, double, boolean, etc. are explicitly set via BasicType |
| Type(const JavaTypeNamespace* types, const std::string& name, int kind, bool canWriteToParcel); |
| Type(const JavaTypeNamespace* types, const std::string& package, const std::string& name, |
| int kind, bool canWriteToParcel, const std::string& declFile = "", int declLine = -1); |
| virtual ~Type() = default; |
| |
| bool CanWriteToParcel() const override { return m_canWriteToParcel; } |
| |
| const ValidatableType* ArrayType() const override { return m_array_type.get(); } |
| const ValidatableType* NullableType() const override { return nullptr; } |
| |
| virtual std::string JavaType() const { return m_javaType; } |
| virtual std::string InstantiableName() const; |
| |
| // The namespace where this type is defined in |
| const JavaTypeNamespace* GetTypeNamespace() const { return m_types; } |
| |
| protected: |
| Expression* BuildWriteToParcelFlags(int flags) const; |
| |
| const JavaTypeNamespace* m_types; |
| |
| std::unique_ptr<Type> m_array_type; |
| |
| private: |
| Type(); |
| Type(const Type&); |
| |
| std::string m_javaType; |
| std::string m_declFile; |
| bool m_canWriteToParcel; |
| }; |
| |
| class BasicArrayType : public Type { |
| public: |
| BasicArrayType(const JavaTypeNamespace* types, const std::string& name, |
| const std::string& writeArrayParcel, |
| const std::string& createArrayParcel, |
| const std::string& readArrayParcel); |
| |
| const ValidatableType* NullableType() const override { return this; } |
| |
| private: |
| std::string m_writeArrayParcel; |
| std::string m_createArrayParcel; |
| std::string m_readArrayParcel; |
| }; |
| |
| class BasicType : public Type { |
| public: |
| BasicType(const JavaTypeNamespace* types, const std::string& name, |
| const std::string& marshallParcel, const std::string& unmarshallParcel, |
| const std::string& writeArrayParcel, const std::string& createArrayParcel, |
| const std::string& readArrayParcel); |
| |
| private: |
| std::string m_marshallParcel; |
| std::string m_unmarshallParcel; |
| }; |
| |
| class FileDescriptorArrayType : public Type { |
| public: |
| explicit FileDescriptorArrayType(const JavaTypeNamespace* types); |
| |
| const ValidatableType* NullableType() const override { return this; } |
| }; |
| |
| class FileDescriptorType : public Type { |
| public: |
| explicit FileDescriptorType(const JavaTypeNamespace* types); |
| }; |
| |
| class ParcelFileDescriptorArrayType : public Type { |
| public: |
| explicit ParcelFileDescriptorArrayType(const JavaTypeNamespace* types); |
| |
| const ValidatableType* NullableType() const override { return this; } |
| }; |
| |
| class ParcelFileDescriptorType : public Type { |
| public: |
| explicit ParcelFileDescriptorType(const JavaTypeNamespace* types); |
| |
| const ValidatableType* NullableType() const override { return this; } |
| }; |
| |
| class BooleanArrayType : public Type { |
| public: |
| explicit BooleanArrayType(const JavaTypeNamespace* types); |
| const ValidatableType* NullableType() const override { return this; } |
| }; |
| |
| class BooleanType : public Type { |
| public: |
| explicit BooleanType(const JavaTypeNamespace* types); |
| }; |
| |
| class CharArrayType : public Type { |
| public: |
| explicit CharArrayType(const JavaTypeNamespace* types); |
| const ValidatableType* NullableType() const override { return this; } |
| }; |
| |
| class CharType : public Type { |
| public: |
| explicit CharType(const JavaTypeNamespace* types); |
| }; |
| |
| class StringArrayType : public Type { |
| public: |
| explicit StringArrayType(const JavaTypeNamespace* types); |
| |
| const ValidatableType* NullableType() const override { return this; } |
| }; |
| |
| class StringType : public Type { |
| public: |
| StringType(const JavaTypeNamespace* types, const std::string& package, |
| const std::string& class_name); |
| |
| std::string JavaType() const override { return "java.lang.String"; } |
| const ValidatableType* NullableType() const override { return this; } |
| }; |
| |
| class CharSequenceType : public Type { |
| public: |
| explicit CharSequenceType(const JavaTypeNamespace* types); |
| }; |
| |
| class RemoteExceptionType : public Type { |
| public: |
| explicit RemoteExceptionType(const JavaTypeNamespace* types); |
| }; |
| |
| class RuntimeExceptionType : public Type { |
| public: |
| explicit RuntimeExceptionType(const JavaTypeNamespace* types); |
| }; |
| |
| class IBinderArrayType : public Type { |
| public: |
| explicit IBinderArrayType(const JavaTypeNamespace* types); |
| const ValidatableType* NullableType() const override { return this; } |
| }; |
| |
| class IBinderType : public Type { |
| public: |
| explicit IBinderType(const JavaTypeNamespace* types); |
| const ValidatableType* NullableType() const override { return this; } |
| }; |
| |
| class IInterfaceType : public Type { |
| public: |
| explicit IInterfaceType(const JavaTypeNamespace* types); |
| }; |
| |
| class BinderType : public Type { |
| public: |
| explicit BinderType(const JavaTypeNamespace* types); |
| }; |
| |
| class BinderProxyType : public Type { |
| public: |
| explicit BinderProxyType(const JavaTypeNamespace* types); |
| }; |
| |
| class ParcelType : public Type { |
| public: |
| explicit ParcelType(const JavaTypeNamespace* types); |
| const ValidatableType* NullableType() const override { return this; } |
| }; |
| |
| class ParcelableInterfaceType : public Type { |
| public: |
| explicit ParcelableInterfaceType(const JavaTypeNamespace* types); |
| }; |
| |
| class MapType : public Type { |
| public: |
| explicit MapType(const JavaTypeNamespace* types); |
| const ValidatableType* NullableType() const override { return this; } |
| }; |
| |
| class ListType : public Type { |
| public: |
| explicit ListType(const JavaTypeNamespace* types); |
| |
| std::string InstantiableName() const override; |
| const ValidatableType* NullableType() const override { return this; } |
| }; |
| |
| class UserDataArrayType : public Type { |
| public: |
| UserDataArrayType(const JavaTypeNamespace* types, const std::string& package, |
| const std::string& name, bool builtIn, |
| bool canWriteToParcel, const std::string& declFile = "", |
| int declLine = -1); |
| |
| const ValidatableType* NullableType() const override { return this; } |
| }; |
| |
| class UserDataType : public Type { |
| public: |
| UserDataType(const JavaTypeNamespace* types, const std::string& package, |
| const std::string& name, bool builtIn, bool canWriteToParcel, |
| const std::string& declFile = "", int declLine = -1); |
| |
| const ValidatableType* NullableType() const override { return this; } |
| }; |
| |
| class InterfaceType : public Type { |
| public: |
| InterfaceType(const JavaTypeNamespace* types, const std::string& package, const std::string& name, |
| bool builtIn, const std::string& declFile, int declLine, const Type* stub, |
| const Type* proxy, const Type* defaultImpl); |
| |
| const ValidatableType* NullableType() const override { return this; } |
| const Type* GetStub() const { return stub_; } |
| const Type* GetProxy() const { return proxy_; } |
| const Type* GetDefaultImpl() const { return defaultImpl_; } |
| |
| private: |
| const Type* stub_; |
| const Type* proxy_; |
| const Type* defaultImpl_; |
| }; |
| |
| class ClassLoaderType : public Type { |
| public: |
| explicit ClassLoaderType(const JavaTypeNamespace* types); |
| }; |
| |
| class GenericListType : public Type { |
| public: |
| GenericListType(const JavaTypeNamespace* types, const Type* arg); |
| |
| std::string InstantiableName() const override; |
| std::string JavaType() const override { |
| return "java.util.List<" + m_contained_type->JavaType() + ">"; |
| } |
| |
| const ValidatableType* NullableType() const override { return this; } |
| |
| private: |
| const Type* m_contained_type; |
| }; |
| |
| class JavaTypeNamespace : public LanguageTypeNamespace<Type> { |
| public: |
| JavaTypeNamespace() = default; |
| virtual ~JavaTypeNamespace() = default; |
| |
| void Init() override; |
| bool AddParcelableType(const AidlParcelable& p, |
| const std::string& filename) override; |
| bool AddBinderType(const AidlInterface& b, |
| const std::string& filename) override; |
| bool AddListType(const std::string& contained_type_name) override; |
| bool AddMapType(const std::string& key_type_name, |
| const std::string& value_type_name) override; |
| |
| const Type* BoolType() const { return m_bool_type; } |
| const Type* IntType() const { return m_int_type; } |
| const Type* StringType() const { return m_string_type; } |
| const Type* TextUtilsType() const { return m_text_utils_type; } |
| const Type* RemoteExceptionType() const { return m_remote_exception_type; } |
| const Type* RuntimeExceptionType() const { return m_runtime_exception_type; } |
| const Type* IBinderType() const { return m_ibinder_type; } |
| const Type* IInterfaceType() const { return m_iinterface_type; } |
| const Type* BinderNativeType() const { return m_binder_native_type; } |
| const Type* BinderProxyType() const { return m_binder_proxy_type; } |
| const Type* ParcelType() const { return m_parcel_type; } |
| const Type* ParcelableInterfaceType() const { |
| return m_parcelable_interface_type; |
| } |
| const Type* ContextType() const { return m_context_type; } |
| const Type* ClassLoaderType() const { return m_classloader_type; } |
| |
| private: |
| const Type* m_bool_type{nullptr}; |
| const Type* m_int_type{nullptr}; |
| const Type* m_string_type{nullptr}; |
| const Type* m_text_utils_type{nullptr}; |
| const Type* m_remote_exception_type{nullptr}; |
| const Type* m_runtime_exception_type{nullptr}; |
| const Type* m_ibinder_type{nullptr}; |
| const Type* m_iinterface_type{nullptr}; |
| const Type* m_binder_native_type{nullptr}; |
| const Type* m_binder_proxy_type{nullptr}; |
| const Type* m_parcel_type{nullptr}; |
| const Type* m_parcelable_interface_type{nullptr}; |
| const Type* m_context_type{nullptr}; |
| const Type* m_classloader_type{nullptr}; |
| |
| DISALLOW_COPY_AND_ASSIGN(JavaTypeNamespace); |
| }; |
| |
| extern Expression* NULL_VALUE; |
| extern Expression* THIS_VALUE; |
| extern Expression* SUPER_VALUE; |
| extern Expression* TRUE_VALUE; |
| extern Expression* FALSE_VALUE; |
| |
| } // namespace java |
| } // namespace aidl |
| } // namespace android |