summaryrefslogtreecommitdiff
path: root/runtimes/nn/depend/libhidl/base/include
diff options
context:
space:
mode:
Diffstat (limited to 'runtimes/nn/depend/libhidl/base/include')
-rw-r--r--runtimes/nn/depend/libhidl/base/include/hidl/HidlInternal.h193
-rw-r--r--runtimes/nn/depend/libhidl/base/include/hidl/HidlSupport.h989
-rw-r--r--runtimes/nn/depend/libhidl/base/include/hidl/Status.h273
3 files changed, 0 insertions, 1455 deletions
diff --git a/runtimes/nn/depend/libhidl/base/include/hidl/HidlInternal.h b/runtimes/nn/depend/libhidl/base/include/hidl/HidlInternal.h
deleted file mode 100644
index 39f80f09b..000000000
--- a/runtimes/nn/depend/libhidl/base/include/hidl/HidlInternal.h
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
- * Copyright (C) 2016 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.
- */
-
-#ifndef ANDROID_HIDL_INTERNAL_H
-#define ANDROID_HIDL_INTERNAL_H
-
-#include <cstdint>
-#include <dirent.h>
-#include <functional>
-#include <string>
-#include <vector>
-#include <utility>
-
-namespace android {
-namespace hardware {
-namespace details {
-
-//Templated classes can use the below method
-//to avoid creating dependencies on liblog.
-void logAlwaysFatal(const char *message);
-
-// HIDL client/server code should *NOT* use this class.
-//
-// hidl_pointer wraps a pointer without taking ownership,
-// and stores it in a union with a uint64_t. This ensures
-// that we always have enough space to store a pointer,
-// regardless of whether we're running in a 32-bit or 64-bit
-// process.
-template<typename T>
-struct hidl_pointer {
- hidl_pointer()
- : _pad(0) {
- }
- hidl_pointer(T* ptr) : hidl_pointer() { mPointer = ptr; }
- hidl_pointer(const hidl_pointer<T>& other) : hidl_pointer() { mPointer = other.mPointer; }
- hidl_pointer(hidl_pointer<T>&& other) : hidl_pointer() { *this = std::move(other); }
-
- hidl_pointer &operator=(const hidl_pointer<T>& other) {
- mPointer = other.mPointer;
- return *this;
- }
- hidl_pointer &operator=(hidl_pointer<T>&& other) {
- mPointer = other.mPointer;
- other.mPointer = nullptr;
- return *this;
- }
- hidl_pointer &operator=(T* ptr) {
- mPointer = ptr;
- return *this;
- }
-
- operator T*() const {
- return mPointer;
- }
- explicit operator void*() const { // requires explicit cast to avoid ambiguity
- return mPointer;
- }
- T& operator*() const {
- return *mPointer;
- }
- T* operator->() const {
- return mPointer;
- }
- T &operator[](size_t index) {
- return mPointer[index];
- }
- const T &operator[](size_t index) const {
- return mPointer[index];
- }
-
-private:
- union {
- T* mPointer;
- uint64_t _pad;
- };
-};
-
-#define HAL_LIBRARY_PATH_SYSTEM_64BIT "/system/lib64/hw/"
-#define HAL_LIBRARY_PATH_VNDK_SP_64BIT "/system/lib64/vndk-sp/hw/"
-#define HAL_LIBRARY_PATH_VENDOR_64BIT "/vendor/lib64/hw/"
-#define HAL_LIBRARY_PATH_ODM_64BIT "/odm/lib64/hw/"
-#define HAL_LIBRARY_PATH_SYSTEM_32BIT "/system/lib/hw/"
-#define HAL_LIBRARY_PATH_VNDK_SP_32BIT "/system/lib/vndk-sp/hw/"
-#define HAL_LIBRARY_PATH_VENDOR_32BIT "/vendor/lib/hw/"
-#define HAL_LIBRARY_PATH_ODM_32BIT "/odm/lib/hw/"
-
-#if defined(__LP64__)
-#define HAL_LIBRARY_PATH_SYSTEM HAL_LIBRARY_PATH_SYSTEM_64BIT
-#define HAL_LIBRARY_PATH_VNDK_SP HAL_LIBRARY_PATH_VNDK_SP_64BIT
-#define HAL_LIBRARY_PATH_VENDOR HAL_LIBRARY_PATH_VENDOR_64BIT
-#define HAL_LIBRARY_PATH_ODM HAL_LIBRARY_PATH_ODM_64BIT
-#else
-#define HAL_LIBRARY_PATH_SYSTEM HAL_LIBRARY_PATH_SYSTEM_32BIT
-#define HAL_LIBRARY_PATH_VNDK_SP HAL_LIBRARY_PATH_VNDK_SP_32BIT
-#define HAL_LIBRARY_PATH_VENDOR HAL_LIBRARY_PATH_VENDOR_32BIT
-#define HAL_LIBRARY_PATH_ODM HAL_LIBRARY_PATH_ODM_32BIT
-#endif
-
-#if 0 // REF-ANN
-// ----------------------------------------------------------------------
-// Class that provides Hidl instrumentation utilities.
-struct HidlInstrumentor {
- // Event that triggers the instrumentation. e.g. enter of an API call on
- // the server/client side, exit of an API call on the server/client side
- // etc.
- enum InstrumentationEvent {
- SERVER_API_ENTRY = 0,
- SERVER_API_EXIT,
- CLIENT_API_ENTRY,
- CLIENT_API_EXIT,
- SYNC_CALLBACK_ENTRY,
- SYNC_CALLBACK_EXIT,
- ASYNC_CALLBACK_ENTRY,
- ASYNC_CALLBACK_EXIT,
- PASSTHROUGH_ENTRY,
- PASSTHROUGH_EXIT,
- };
-
- // Signature of the instrumentation callback function.
- using InstrumentationCallback = std::function<void(
- const InstrumentationEvent event,
- const char *package,
- const char *version,
- const char *interface,
- const char *method,
- std::vector<void *> *args)>;
-
- explicit HidlInstrumentor(
- const std::string &package,
- const std::string &insterface);
- virtual ~HidlInstrumentor();
-
- public:
- const std::vector<InstrumentationCallback>& getInstrumentationCallbacks() {
- return mInstrumentationCallbacks;
- }
- bool isInstrumentationEnabled() { return mEnableInstrumentation; }
-
- protected:
- // Set mEnableInstrumentation based on system property
- // hal.instrumentation.enable, register/de-register instrumentation
- // callbacks if mEnableInstrumentation is true/false.
- void configureInstrumentation(bool log=true);
- // Function that lookup and dynamically loads the hidl instrumentation
- // libraries and registers the instrumentation callback functions.
- //
- // The instrumentation libraries should be stored under any of the following
- // directories: HAL_LIBRARY_PATH_SYSTEM, HAL_LIBRARY_PATH_VNDK_SP,
- // HAL_LIBRARY_PATH_VENDOR and HAL_LIBRARY_PATH_ODM.
- // The name of instrumentation libraries should follow pattern:
- // ^profilerPrefix(.*).profiler.so$
- //
- // Each instrumentation library is expected to implement the instrumentation
- // function called HIDL_INSTRUMENTATION_FUNCTION.
- //
- // A no-op for user build.
- void registerInstrumentationCallbacks(
- std::vector<InstrumentationCallback> *instrumentationCallbacks);
-
- // Utility function to determine whether a give file is a instrumentation
- // library (i.e. the file name follow the expected pattern).
- bool isInstrumentationLib(const dirent *file);
-
- // A list of registered instrumentation callbacks.
- std::vector<InstrumentationCallback> mInstrumentationCallbacks;
- // Flag whether to enable instrumentation.
- bool mEnableInstrumentation;
- // Prefix to lookup the instrumentation libraries.
- std::string mInstrumentationLibPackage;
- // Used for dlsym to load the profiling method for given interface.
- std::string mInterfaceName;
-
-};
-#endif
-
-} // namespace details
-} // namespace hardware
-} // namespace android
-
-#endif // ANDROID_HIDL_INTERNAL_H
diff --git a/runtimes/nn/depend/libhidl/base/include/hidl/HidlSupport.h b/runtimes/nn/depend/libhidl/base/include/hidl/HidlSupport.h
deleted file mode 100644
index bc8d56ea7..000000000
--- a/runtimes/nn/depend/libhidl/base/include/hidl/HidlSupport.h
+++ /dev/null
@@ -1,989 +0,0 @@
-/*
- * Copyright (C) 2016 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.
- */
-
-#ifndef ANDROID_HIDL_SUPPORT_H
-#define ANDROID_HIDL_SUPPORT_H
-
-#include <cstring>
-
-#include <string>
-#include <iterator>
-#include <cutils/native_handle.h>
-#include <hidl/HidlInternal.h>
-#include <map>
-#include <stddef.h>
-#include <tuple>
-#include <type_traits>
-#include <utils/StrongPointer.h>
-#include <utils/RefBase.h>
-
-#if 0 // REF-ANN
-#include <algorithm>
-#include <array>
-#include <iterator>
-#include <cutils/native_handle.h>
-#include <hidl/HidlInternal.h>
-#include <hidl/Status.h>
-#include <map>
-#include <sstream>
-#include <stddef.h>
-#include <tuple>
-#include <type_traits>
-#include <utils/Errors.h>
-#include <utils/RefBase.h>
-#include <vector>
-#endif
-
-namespace android {
-
-// this file is included by all hidl interface, so we must forward declare the
-// IMemory and IBase types.
-namespace hidl {
-namespace memory {
-namespace V1_0 {
- struct IMemory;
-}; // namespace V1_0
-}; // namespace manager
-}; // namespace hidl
-
-namespace hidl {
-namespace base {
-namespace V1_0 {
- struct IBase;
-}; // namespace V1_0
-}; // namespace base
-}; // namespace hidl
-
-namespace hardware {
-
-#if 0 // REF-ANN
-namespace details {
-// Return true on userdebug / eng builds and false on user builds.
-bool debuggable();
-} // namespace details
-
-// hidl_death_recipient is a callback interfaced that can be used with
-// linkToDeath() / unlinkToDeath()
-struct hidl_death_recipient : public virtual RefBase {
- virtual void serviceDied(uint64_t cookie,
- const ::android::wp<::android::hidl::base::V1_0::IBase>& who) = 0;
-};
-
-// hidl_handle wraps a pointer to a native_handle_t in a hidl_pointer,
-// so that it can safely be transferred between 32-bit and 64-bit processes.
-// The ownership semantics for this are:
-// 1) The conversion constructor and assignment operator taking a const native_handle_t*
-// do not take ownership of the handle; this is because these operations are usually
-// just done for IPC, and cloning by default is a waste of resources. If you want
-// a hidl_handle to take ownership, call setTo(handle, true /*shouldOwn*/);
-// 2) The copy constructor/assignment operator taking a hidl_handle *DO* take ownership;
-// that is because it's not intuitive that this class encapsulates a native_handle_t
-// which needs cloning to be valid; in particular, this allows constructs like this:
-// hidl_handle copy;
-// foo->someHidlCall([&](auto incoming_handle) {
-// copy = incoming_handle;
-// });
-// // copy and its enclosed file descriptors will remain valid here.
-// 3) The move constructor does what you would expect; it only owns the handle if the
-// original did.
-struct hidl_handle {
- hidl_handle();
- ~hidl_handle();
-
- hidl_handle(const native_handle_t *handle);
-
- // copy constructor.
- hidl_handle(const hidl_handle &other);
-
- // move constructor.
- hidl_handle(hidl_handle &&other) noexcept;
-
- // assignment operators
- hidl_handle &operator=(const hidl_handle &other);
-
- hidl_handle &operator=(const native_handle_t *native_handle);
-
- hidl_handle &operator=(hidl_handle &&other) noexcept;
-
- void setTo(native_handle_t* handle, bool shouldOwn = false);
-
- const native_handle_t* operator->() const;
-
- // implicit conversion to const native_handle_t*
- operator const native_handle_t *() const;
-
- // explicit conversion
- const native_handle_t *getNativeHandle() const;
-private:
- void freeHandle();
-
- details::hidl_pointer<const native_handle_t> mHandle __attribute__ ((aligned(8)));
- bool mOwnsHandle __attribute ((aligned(8)));
-};
-#endif
-
-struct hidl_string {
- hidl_string();
- ~hidl_string();
-
- // copy constructor.
- hidl_string(const hidl_string &);
- // copy from a C-style string. nullptr will create an empty string
- hidl_string(const char *);
- // copy the first length characters from a C-style string.
- hidl_string(const char *, size_t length);
- // copy from an std::string.
- hidl_string(const std::string &);
-
- // move constructor.
- hidl_string(hidl_string &&) noexcept;
-
- const char *c_str() const;
- size_t size() const;
- bool empty() const;
-
- // copy assignment operator.
- hidl_string &operator=(const hidl_string &);
- // copy from a C-style string.
- hidl_string &operator=(const char *s);
- // copy from an std::string.
- hidl_string &operator=(const std::string &);
- // move assignment operator.
- hidl_string &operator=(hidl_string &&other) noexcept;
- // cast to std::string.
- operator std::string() const;
-
- void clear();
-
- // Reference an external char array. Ownership is _not_ transferred.
- // Caller is responsible for ensuring that underlying memory is valid
- // for the lifetime of this hidl_string.
- void setToExternal(const char *data, size_t size);
-
- // offsetof(hidl_string, mBuffer) exposed since mBuffer is private.
- static const size_t kOffsetOfBuffer;
-
-private:
- details::hidl_pointer<const char> mBuffer;
- uint32_t mSize; // NOT including the terminating '\0'.
- bool mOwnsBuffer; // if true then mBuffer is a mutable char *
-
- // copy from data with size. Assume that my memory is freed
- // (through clear(), for example)
- void copyFrom(const char *data, size_t size);
- // move from another hidl_string
- void moveFrom(hidl_string &&);
-};
-
-#define HIDL_STRING_OPERATOR(OP) \
- inline bool operator OP(const hidl_string &hs1, const hidl_string &hs2) { \
- return strcmp(hs1.c_str(), hs2.c_str()) OP 0; \
- } \
- inline bool operator OP(const hidl_string &hs, const char *s) { \
- return strcmp(hs.c_str(), s) OP 0; \
- } \
- inline bool operator OP(const char *s, const hidl_string &hs) { \
- return strcmp(hs.c_str(), s) OP 0; \
- }
-
-HIDL_STRING_OPERATOR(==)
-HIDL_STRING_OPERATOR(!=)
-HIDL_STRING_OPERATOR(<)
-HIDL_STRING_OPERATOR(<=)
-HIDL_STRING_OPERATOR(>)
-HIDL_STRING_OPERATOR(>=)
-
-#undef HIDL_STRING_OPERATOR
-
-// Send our content to the output stream
-std::ostream& operator<<(std::ostream& os, const hidl_string& str);
-
-
-// hidl_memory is a structure that can be used to transfer
-// pieces of shared memory between processes. The assumption
-// of this object is that the memory remains accessible as
-// long as the file descriptors in the enclosed mHandle
-// - as well as all of its cross-process dups() - remain opened.
-struct hidl_memory {
-
- hidl_memory() : mHandle(nullptr), mSize(0), mName("") {
- }
-
- /**
- * Creates a hidl_memory object, but doesn't take ownership of
- * the passed in native_handle_t; callers are responsible for
- * making sure the handle remains valid while this object is
- * used.
- */
- hidl_memory(const std::string &name, const native_handle_t *handle, size_t size)
-#if 0 // REF-ANN
- hidl_memory(const hidl_string &name, const native_handle_t *handle, size_t size)
-#endif
- : mHandle(handle),
- mSize(size),
- mName(name)
- {}
-
- // copy constructor
- hidl_memory(const hidl_memory& other) {
- *this = other;
- }
-
- // copy assignment
- hidl_memory &operator=(const hidl_memory &other) {
- if (this != &other) {
- mHandle = other.mHandle;
- mSize = other.mSize;
- mName = other.mName;
- }
-
- return *this;
- }
-
- // move constructor
- hidl_memory(hidl_memory&& other) noexcept {
- *this = std::move(other);
- }
-
- // move assignment
- hidl_memory &operator=(hidl_memory &&other) noexcept {
- if (this != &other) {
- mHandle = std::move(other.mHandle);
- mSize = other.mSize;
- mName = std::move(other.mName);
- other.mSize = 0;
- }
-
- return *this;
- }
-
-
- ~hidl_memory() {
- }
-
- const native_handle_t* handle() const {
- return mHandle;
- }
-
- const hidl_string &name() const {
- return mName;
- }
-
- uint64_t size() const {
- return mSize;
- }
-
- // offsetof(hidl_memory, mHandle) exposed since mHandle is private.
- static const size_t kOffsetOfHandle;
- // offsetof(hidl_memory, mName) exposed since mHandle is private.
- static const size_t kOffsetOfName;
-
-private:
- const native_handle_t *mHandle __attribute__ ((aligned(8))); // TODO-NNRT: This was hidl_handle.
- uint64_t mSize __attribute__ ((aligned(8)));
- hidl_string mName __attribute__ ((aligned(8)));
-#if 0 // REF-ANN
- hidl_handle mHandle __attribute__ ((aligned(8)));
- uint64_t mSize __attribute__ ((aligned(8)));
- hidl_string mName __attribute__ ((aligned(8)));
-#endif
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-template<typename T>
-struct hidl_vec {
- hidl_vec()
- : mBuffer(NULL),
- mSize(0),
- mOwnsBuffer(true) {
- static_assert(hidl_vec<T>::kOffsetOfBuffer == 0, "wrong offset");
- }
-
- // Note, does not initialize primitive types.
- hidl_vec(size_t size) : hidl_vec() { resize(size); }
-
- hidl_vec(const hidl_vec<T> &other) : hidl_vec() {
- *this = other;
- }
-
- hidl_vec(hidl_vec<T> &&other) noexcept
- : mOwnsBuffer(false) {
- *this = std::move(other);
- }
-
- hidl_vec(const std::initializer_list<T> list)
- : mOwnsBuffer(true) {
- if (list.size() > UINT32_MAX) {
-#if 0 // TODO-NNRT : Implement dummy logAlwaysFatal
- details::logAlwaysFatal("hidl_vec can't hold more than 2^32 elements.");
-#endif
- }
- mSize = static_cast<uint32_t>(list.size());
- mBuffer = new T[mSize];
-
- size_t idx = 0;
- for (auto it = list.begin(); it != list.end(); ++it) {
- mBuffer[idx++] = *it;
- }
- }
-
- hidl_vec(const std::vector<T> &other) : hidl_vec() {
- *this = other;
- }
-
- template <typename InputIterator,
- typename = typename std::enable_if<std::is_convertible<
- typename std::iterator_traits<InputIterator>::iterator_category,
- std::input_iterator_tag>::value>::type>
- hidl_vec(InputIterator first, InputIterator last) : mOwnsBuffer(true) {
- auto size = std::distance(first, last);
- if (size > static_cast<int64_t>(UINT32_MAX)) {
-#if 0 // TODO-NNRT : Implement dummy logAlwaysFatal
- details::logAlwaysFatal("hidl_vec can't hold more than 2^32 elements.");
-#endif
- }
- if (size < 0) {
-#if 0 // TODO-NNRT : Implement dummy logAlwaysFatal
- details::logAlwaysFatal("size can't be negative.");
-#endif
- }
- mSize = static_cast<uint32_t>(size);
- mBuffer = new T[mSize];
-
- size_t idx = 0;
- for (; first != last; ++first) {
- mBuffer[idx++] = static_cast<T>(*first);
- }
- }
-
- ~hidl_vec() {
- if (mOwnsBuffer) {
- delete[] mBuffer;
- }
- mBuffer = NULL;
- }
-
- // Reference an existing array, optionally taking ownership. It is the
- // caller's responsibility to ensure that the underlying memory stays
- // valid for the lifetime of this hidl_vec.
- void setToExternal(T *data, size_t size, bool shouldOwn = false) {
- if (mOwnsBuffer) {
- delete [] mBuffer;
- }
- mBuffer = data;
- if (size > UINT32_MAX) {
-#if 0 // TODO-NNRT : Implement dummy logAlwaysFatal
- details::logAlwaysFatal("external vector size exceeds 2^32 elements.");
-#endif
- }
- mSize = static_cast<uint32_t>(size);
- mOwnsBuffer = shouldOwn;
- }
-
- T *data() {
- return mBuffer;
- }
-
- const T *data() const {
- return mBuffer;
- }
-
- T *releaseData() {
- if (!mOwnsBuffer && mSize > 0) {
- resize(mSize);
- }
- mOwnsBuffer = false;
- return mBuffer;
- }
-
- hidl_vec &operator=(hidl_vec &&other) noexcept {
- if (mOwnsBuffer) {
- delete[] mBuffer;
- }
- mBuffer = other.mBuffer;
- mSize = other.mSize;
- mOwnsBuffer = other.mOwnsBuffer;
- other.mOwnsBuffer = false;
- return *this;
- }
-
- hidl_vec &operator=(const hidl_vec &other) {
- if (this != &other) {
- if (mOwnsBuffer) {
- delete[] mBuffer;
- }
- copyFrom(other, other.mSize);
- }
-
- return *this;
- }
-
- // copy from an std::vector.
- hidl_vec &operator=(const std::vector<T> &other) {
- if (mOwnsBuffer) {
- delete[] mBuffer;
- }
- copyFrom(other, other.size());
- return *this;
- }
-
- // cast to an std::vector.
- operator std::vector<T>() const {
- std::vector<T> v(mSize);
- for (size_t i = 0; i < mSize; ++i) {
- v[i] = mBuffer[i];
- }
- return v;
- }
-
- // equality check, assuming that T::operator== is defined.
- bool operator==(const hidl_vec &other) const {
- if (mSize != other.size()) {
- return false;
- }
- for (size_t i = 0; i < mSize; ++i) {
- if (!(mBuffer[i] == other.mBuffer[i])) {
- return false;
- }
- }
- return true;
- }
-
- // inequality check, assuming that T::operator== is defined.
- inline bool operator!=(const hidl_vec &other) const {
- return !((*this) == other);
- }
-
- size_t size() const {
- return mSize;
- }
-
- T &operator[](size_t index) {
- return mBuffer[index];
- }
-
- const T &operator[](size_t index) const {
- return mBuffer[index];
- }
-
- void resize(size_t size) {
- if (size > UINT32_MAX) {
-#if 0 // TODO-NNRT : Implement dummy logAlwaysFatal
- details::logAlwaysFatal("hidl_vec can't hold more than 2^32 elements.");
-#endif
- }
- T *newBuffer = new T[size];
-
- for (size_t i = 0; i < std::min(static_cast<uint32_t>(size), mSize); ++i) {
- newBuffer[i] = mBuffer[i];
- }
-
- if (mOwnsBuffer) {
- delete[] mBuffer;
- }
- mBuffer = newBuffer;
-
- mSize = static_cast<uint32_t>(size);
- mOwnsBuffer = true;
- }
-
- // offsetof(hidl_string, mBuffer) exposed since mBuffer is private.
- static const size_t kOffsetOfBuffer = offsetof(hidl_vec<T>, mBuffer);
-
-private:
- // Define std interator interface for walking the array contents
- template<bool is_const>
- class iter : public std::iterator<
- std::random_access_iterator_tag, /* Category */
- T,
- ptrdiff_t, /* Distance */
- typename std::conditional<is_const, const T *, T *>::type /* Pointer */,
- typename std::conditional<is_const, const T &, T &>::type /* Reference */>
- {
- using traits = std::iterator_traits<iter>;
- using ptr_type = typename traits::pointer;
- using ref_type = typename traits::reference;
- using diff_type = typename traits::difference_type;
- public:
- iter(ptr_type ptr) : mPtr(ptr) { }
- inline iter &operator++() { mPtr++; return *this; }
- inline iter operator++(int) { iter i = *this; mPtr++; return i; }
- inline iter &operator--() { mPtr--; return *this; }
- inline iter operator--(int) { iter i = *this; mPtr--; return i; }
- inline friend iter operator+(diff_type n, const iter &it) { return it.mPtr + n; }
- inline iter operator+(diff_type n) const { return mPtr + n; }
- inline iter operator-(diff_type n) const { return mPtr - n; }
- inline diff_type operator-(const iter &other) const { return mPtr - other.mPtr; }
- inline iter &operator+=(diff_type n) { mPtr += n; return *this; }
- inline iter &operator-=(diff_type n) { mPtr -= n; return *this; }
- inline ref_type operator*() const { return *mPtr; }
- inline ptr_type operator->() const { return mPtr; }
- inline bool operator==(const iter &rhs) const { return mPtr == rhs.mPtr; }
- inline bool operator!=(const iter &rhs) const { return mPtr != rhs.mPtr; }
- inline bool operator< (const iter &rhs) const { return mPtr < rhs.mPtr; }
- inline bool operator> (const iter &rhs) const { return mPtr > rhs.mPtr; }
- inline bool operator<=(const iter &rhs) const { return mPtr <= rhs.mPtr; }
- inline bool operator>=(const iter &rhs) const { return mPtr >= rhs.mPtr; }
- inline ref_type operator[](size_t n) const { return mPtr[n]; }
- private:
- ptr_type mPtr;
- };
-public:
- using iterator = iter<false /* is_const */>;
- using const_iterator = iter<true /* is_const */>;
-
- iterator begin() { return data(); }
- iterator end() { return data()+mSize; }
- const_iterator begin() const { return data(); }
- const_iterator end() const { return data()+mSize; }
-
-private:
- details::hidl_pointer<T> mBuffer;
- uint32_t mSize;
- bool mOwnsBuffer;
-
- // copy from an array-like object, assuming my resources are freed.
- template <typename Array>
- void copyFrom(const Array &data, size_t size) {
- mSize = static_cast<uint32_t>(size);
- mOwnsBuffer = true;
- if (mSize > 0) {
- mBuffer = new T[size];
- for (size_t i = 0; i < size; ++i) {
- mBuffer[i] = data[i];
- }
- } else {
- mBuffer = NULL;
- }
- }
-};
-
-
-#if 0 // REF-ANN
-////////////////////////////////////////////////////////////////////////////////
-
-namespace details {
-
- template<size_t SIZE1, size_t... SIZES>
- struct product {
- static constexpr size_t value = SIZE1 * product<SIZES...>::value;
- };
-
- template<size_t SIZE1>
- struct product<SIZE1> {
- static constexpr size_t value = SIZE1;
- };
-
- template<typename T, size_t SIZE1, size_t... SIZES>
- struct std_array {
- using type = std::array<typename std_array<T, SIZES...>::type, SIZE1>;
- };
-
- template<typename T, size_t SIZE1>
- struct std_array<T, SIZE1> {
- using type = std::array<T, SIZE1>;
- };
-
- template<typename T, size_t SIZE1, size_t... SIZES>
- struct accessor {
-
- using std_array_type = typename std_array<T, SIZE1, SIZES...>::type;
-
- explicit accessor(T *base)
- : mBase(base) {
- }
-
- accessor<T, SIZES...> operator[](size_t index) {
- return accessor<T, SIZES...>(
- &mBase[index * product<SIZES...>::value]);
- }
-
- accessor &operator=(const std_array_type &other) {
- for (size_t i = 0; i < SIZE1; ++i) {
- (*this)[i] = other[i];
- }
- return *this;
- }
-
- private:
- T *mBase;
- };
-
- template<typename T, size_t SIZE1>
- struct accessor<T, SIZE1> {
-
- using std_array_type = typename std_array<T, SIZE1>::type;
-
- explicit accessor(T *base)
- : mBase(base) {
- }
-
- T &operator[](size_t index) {
- return mBase[index];
- }
-
- accessor &operator=(const std_array_type &other) {
- for (size_t i = 0; i < SIZE1; ++i) {
- (*this)[i] = other[i];
- }
- return *this;
- }
-
- private:
- T *mBase;
- };
-
- template<typename T, size_t SIZE1, size_t... SIZES>
- struct const_accessor {
-
- using std_array_type = typename std_array<T, SIZE1, SIZES...>::type;
-
- explicit const_accessor(const T *base)
- : mBase(base) {
- }
-
- const_accessor<T, SIZES...> operator[](size_t index) const {
- return const_accessor<T, SIZES...>(
- &mBase[index * product<SIZES...>::value]);
- }
-
- operator std_array_type() {
- std_array_type array;
- for (size_t i = 0; i < SIZE1; ++i) {
- array[i] = (*this)[i];
- }
- return array;
- }
-
- private:
- const T *mBase;
- };
-
- template<typename T, size_t SIZE1>
- struct const_accessor<T, SIZE1> {
-
- using std_array_type = typename std_array<T, SIZE1>::type;
-
- explicit const_accessor(const T *base)
- : mBase(base) {
- }
-
- const T &operator[](size_t index) const {
- return mBase[index];
- }
-
- operator std_array_type() {
- std_array_type array;
- for (size_t i = 0; i < SIZE1; ++i) {
- array[i] = (*this)[i];
- }
- return array;
- }
-
- private:
- const T *mBase;
- };
-
-} // namespace details
-
-////////////////////////////////////////////////////////////////////////////////
-
-// A multidimensional array of T's. Assumes that T::operator=(const T &) is defined.
-template<typename T, size_t SIZE1, size_t... SIZES>
-struct hidl_array {
-
- using std_array_type = typename details::std_array<T, SIZE1, SIZES...>::type;
-
- hidl_array() = default;
-
- // Copies the data from source, using T::operator=(const T &).
- hidl_array(const T *source) {
- for (size_t i = 0; i < elementCount(); ++i) {
- mBuffer[i] = source[i];
- }
- }
-
- // Copies the data from the given std::array, using T::operator=(const T &).
- hidl_array(const std_array_type &array) {
- details::accessor<T, SIZE1, SIZES...> modifier(mBuffer);
- modifier = array;
- }
-
- T *data() { return mBuffer; }
- const T *data() const { return mBuffer; }
-
- details::accessor<T, SIZES...> operator[](size_t index) {
- return details::accessor<T, SIZES...>(
- &mBuffer[index * details::product<SIZES...>::value]);
- }
-
- details::const_accessor<T, SIZES...> operator[](size_t index) const {
- return details::const_accessor<T, SIZES...>(
- &mBuffer[index * details::product<SIZES...>::value]);
- }
-
- // equality check, assuming that T::operator== is defined.
- bool operator==(const hidl_array &other) const {
- for (size_t i = 0; i < elementCount(); ++i) {
- if (!(mBuffer[i] == other.mBuffer[i])) {
- return false;
- }
- }
- return true;
- }
-
- inline bool operator!=(const hidl_array &other) const {
- return !((*this) == other);
- }
-
- using size_tuple_type = std::tuple<decltype(SIZE1), decltype(SIZES)...>;
-
- static constexpr size_tuple_type size() {
- return std::make_tuple(SIZE1, SIZES...);
- }
-
- static constexpr size_t elementCount() {
- return details::product<SIZE1, SIZES...>::value;
- }
-
- operator std_array_type() const {
- return details::const_accessor<T, SIZE1, SIZES...>(mBuffer);
- }
-
-private:
- T mBuffer[elementCount()];
-};
-
-// An array of T's. Assumes that T::operator=(const T &) is defined.
-template<typename T, size_t SIZE1>
-struct hidl_array<T, SIZE1> {
-
- using std_array_type = typename details::std_array<T, SIZE1>::type;
-
- hidl_array() = default;
-
- // Copies the data from source, using T::operator=(const T &).
- hidl_array(const T *source) {
- for (size_t i = 0; i < elementCount(); ++i) {
- mBuffer[i] = source[i];
- }
- }
-
- // Copies the data from the given std::array, using T::operator=(const T &).
- hidl_array(const std_array_type &array) : hidl_array(array.data()) {}
-
- T *data() { return mBuffer; }
- const T *data() const { return mBuffer; }
-
- T &operator[](size_t index) {
- return mBuffer[index];
- }
-
- const T &operator[](size_t index) const {
- return mBuffer[index];
- }
-
- // equality check, assuming that T::operator== is defined.
- bool operator==(const hidl_array &other) const {
- for (size_t i = 0; i < elementCount(); ++i) {
- if (!(mBuffer[i] == other.mBuffer[i])) {
- return false;
- }
- }
- return true;
- }
-
- inline bool operator!=(const hidl_array &other) const {
- return !((*this) == other);
- }
-
- static constexpr size_t size() { return SIZE1; }
- static constexpr size_t elementCount() { return SIZE1; }
-
- // Copies the data to an std::array, using T::operator=(T).
- operator std_array_type() const {
- std_array_type array;
- for (size_t i = 0; i < SIZE1; ++i) {
- array[i] = mBuffer[i];
- }
- return array;
- }
-
-private:
- T mBuffer[SIZE1];
-};
-
-// ----------------------------------------------------------------------
-// Version functions
-struct hidl_version {
-public:
- constexpr hidl_version(uint16_t major, uint16_t minor) : mMajor(major), mMinor(minor) {}
-
- bool operator==(const hidl_version& other) const {
- return (mMajor == other.get_major() && mMinor == other.get_minor());
- }
-
- bool operator<(const hidl_version& other) const {
- return (mMajor < other.get_major() ||
- (mMajor == other.get_major() && mMinor < other.get_minor()));
- }
-
- bool operator>(const hidl_version& other) const {
- return other < *this;
- }
-
- bool operator<=(const hidl_version& other) const {
- return !(*this > other);
- }
-
- bool operator>=(const hidl_version& other) const {
- return !(*this < other);
- }
-
- constexpr uint16_t get_major() const { return mMajor; }
- constexpr uint16_t get_minor() const { return mMinor; }
-
-private:
- uint16_t mMajor;
- uint16_t mMinor;
-};
-
-inline android::hardware::hidl_version make_hidl_version(uint16_t major, uint16_t minor) {
- return hidl_version(major,minor);
-}
-
-///////////////////// toString functions
-
-std::string toString(const void *t);
-
-// toString alias for numeric types
-template<typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value, T>::type>
-inline std::string toString(T t) {
- return std::to_string(t);
-}
-
-namespace details {
-
-template<typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value, T>::type>
-inline std::string toHexString(T t, bool prefix = true) {
- std::ostringstream os;
- if (prefix) { os << std::showbase; }
- os << std::hex << t;
- return os.str();
-}
-
-template<>
-inline std::string toHexString(uint8_t t, bool prefix) {
- return toHexString(static_cast<int32_t>(t), prefix);
-}
-
-template<>
-inline std::string toHexString(int8_t t, bool prefix) {
- return toHexString(static_cast<int32_t>(t), prefix);
-}
-
-template<typename Array>
-std::string arrayToString(const Array &a, size_t size);
-
-template<size_t SIZE1>
-std::string arraySizeToString() {
- return std::string{"["} + toString(SIZE1) + "]";
-}
-
-template<size_t SIZE1, size_t SIZE2, size_t... SIZES>
-std::string arraySizeToString() {
- return std::string{"["} + toString(SIZE1) + "]" + arraySizeToString<SIZE2, SIZES...>();
-}
-
-template<typename T, size_t SIZE1>
-std::string toString(details::const_accessor<T, SIZE1> a) {
- return arrayToString(a, SIZE1);
-}
-
-template<typename Array>
-std::string arrayToString(const Array &a, size_t size) {
- using android::hardware::toString;
- std::string os;
- os += "{";
- for (size_t i = 0; i < size; ++i) {
- if (i > 0) {
- os += ", ";
- }
- os += toString(a[i]);
- }
- os += "}";
- return os;
-}
-
-template<typename T, size_t SIZE1, size_t SIZE2, size_t... SIZES>
-std::string toString(details::const_accessor<T, SIZE1, SIZE2, SIZES...> a) {
- return arrayToString(a, SIZE1);
-}
-
-} //namespace details
-
-inline std::string toString(const void *t) {
- return details::toHexString(reinterpret_cast<uintptr_t>(t));
-}
-
-// debug string dump. There will be quotes around the string!
-inline std::string toString(const hidl_string &hs) {
- return std::string{"\""} + hs.c_str() + "\"";
-}
-
-// debug string dump
-inline std::string toString(const hidl_handle &hs) {
- return toString(hs.getNativeHandle());
-}
-
-inline std::string toString(const hidl_memory &mem) {
- return std::string{"memory {.name = "} + toString(mem.name()) + ", .size = "
- + toString(mem.size())
- + ", .handle = " + toString(mem.handle()) + "}";
-}
-
-inline std::string toString(const sp<hidl_death_recipient> &dr) {
- return std::string{"death_recipient@"} + toString(dr.get());
-}
-
-// debug string dump, assuming that toString(T) is defined.
-template<typename T>
-std::string toString(const hidl_vec<T> &a) {
- std::string os;
- os += "[" + toString(a.size()) + "]";
- os += details::arrayToString(a, a.size());
- return os;
-}
-
-template<typename T, size_t SIZE1>
-std::string toString(const hidl_array<T, SIZE1> &a) {
- return details::arraySizeToString<SIZE1>()
- + details::toString(details::const_accessor<T, SIZE1>(a.data()));
-}
-
-template<typename T, size_t SIZE1, size_t SIZE2, size_t... SIZES>
-std::string toString(const hidl_array<T, SIZE1, SIZE2, SIZES...> &a) {
- return details::arraySizeToString<SIZE1, SIZE2, SIZES...>()
- + details::toString(details::const_accessor<T, SIZE1, SIZE2, SIZES...>(a.data()));
-}
-#endif
-
-} // namespace hardware
-} // namespace android
-
-
-#endif // ANDROID_HIDL_SUPPORT_H
diff --git a/runtimes/nn/depend/libhidl/base/include/hidl/Status.h b/runtimes/nn/depend/libhidl/base/include/hidl/Status.h
deleted file mode 100644
index f812ebbc9..000000000
--- a/runtimes/nn/depend/libhidl/base/include/hidl/Status.h
+++ /dev/null
@@ -1,273 +0,0 @@
-/*
- * 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.
- */
-
-#ifndef ANDROID_HARDWARE_BINDER_STATUS_H
-#define ANDROID_HARDWARE_BINDER_STATUS_H
-
-#include <cstdint>
-#include <sstream>
-
-#include <hidl/HidlInternal.h>
-#include <utils/Errors.h>
-#include <utils/StrongPointer.h>
-
-namespace android {
-namespace hardware {
-
-// An object similar in function to a status_t except that it understands
-// how exceptions are encoded in the prefix of a Parcel. Used like:
-//
-// Parcel data;
-// Parcel reply;
-// status_t status;
-// binder::Status remote_exception;
-// if ((status = data.writeInterfaceToken(interface_descriptor)) != OK ||
-// (status = data.writeInt32(function_input)) != OK) {
-// // We failed to write into the memory of our local parcel?
-// }
-// if ((status = remote()->transact(transaction, data, &reply)) != OK) {
-// // Something has gone wrong in the binder driver or libbinder.
-// }
-// if ((status = remote_exception.readFromParcel(reply)) != OK) {
-// // The remote didn't correctly write the exception header to the
-// // reply.
-// }
-// if (!remote_exception.isOk()) {
-// // The transaction went through correctly, but the remote reported an
-// // exception during handling.
-// }
-//
-class Status final {
-public:
- // Keep the exception codes in sync with android/os/Parcel.java.
- enum Exception {
- EX_NONE = 0,
- EX_SECURITY = -1,
- EX_BAD_PARCELABLE = -2,
- EX_ILLEGAL_ARGUMENT = -3,
- EX_NULL_POINTER = -4,
- EX_ILLEGAL_STATE = -5,
- EX_NETWORK_MAIN_THREAD = -6,
- EX_UNSUPPORTED_OPERATION = -7,
-
- // This is special and Java specific; see Parcel.java.
- EX_HAS_REPLY_HEADER = -128,
- // This is special, and indicates to C++ binder proxies that the
- // transaction has failed at a low level.
- EX_TRANSACTION_FAILED = -129,
- };
-
- // A more readable alias for the default constructor.
- static Status ok();
- // Authors should explicitly pick whether their integer is:
- // - an exception code (EX_* above)
- // - status_t
- //
- // Prefer a generic exception code when possible or a status_t
- // for low level transport errors. Service specific errors
- // should be at a higher level in HIDL.
- static Status fromExceptionCode(int32_t exceptionCode);
- static Status fromExceptionCode(int32_t exceptionCode,
- const char *message);
- static Status fromStatusT(status_t status);
-
- Status() = default;
- ~Status() = default;
-
- // Status objects are copyable and contain just simple data.
- Status(const Status& status) = default;
- Status(Status&& status) = default;
- Status& operator=(const Status& status) = default;
-
- // Set one of the pre-defined exception types defined above.
- void setException(int32_t ex, const char *message);
- // Setting a |status| != OK causes generated code to return |status|
- // from Binder transactions, rather than writing an exception into the
- // reply Parcel. This is the least preferable way of reporting errors.
- void setFromStatusT(status_t status);
-
- // Get information about an exception.
- int32_t exceptionCode() const { return mException; }
- const char *exceptionMessage() const { return mMessage.c_str(); }
- status_t transactionError() const {
- return mException == EX_TRANSACTION_FAILED ? mErrorCode : OK;
- }
-
- bool isOk() const { return mException == EX_NONE; }
-
- // For debugging purposes only
- std::string description() const;
-
-private:
- Status(int32_t exceptionCode, int32_t errorCode);
- Status(int32_t exceptionCode, int32_t errorCode, const char *message);
-
- // If |mException| == EX_TRANSACTION_FAILED, generated code will return
- // |mErrorCode| as the result of the transaction rather than write an
- // exception to the reply parcel.
- //
- // Otherwise, we always write |mException| to the parcel.
- // If |mException| != EX_NONE, we write |mMessage| as well.
- int32_t mException = EX_NONE;
- int32_t mErrorCode = 0;
- std::string mMessage;
-}; // class Status
-
-// For gtest output logging
-std::ostream& operator<< (std::ostream& stream, const Status& s);
-
-template<typename T> class Return;
-
-namespace details {
- class return_status {
- private:
- Status mStatus {};
- mutable bool mCheckedStatus = false;
-
- template <typename T, typename U>
- friend Return<U> StatusOf(const Return<T> &other);
- protected:
- void assertOk() const;
- public:
- return_status() {}
- return_status(Status s) : mStatus(s) {}
-
- return_status(const return_status &) = delete;
- return_status &operator=(const return_status &) = delete;
-
- return_status(return_status &&other) {
- *this = std::move(other);
- }
- return_status &operator=(return_status &&other);
-
- ~return_status();
-
- bool isOk() const {
- mCheckedStatus = true;
- return mStatus.isOk();
- }
-
- // Check if underlying error is DEAD_OBJECT.
- // Check mCheckedStatus only if this method returns true.
- bool isDeadObject() const {
- bool dead = mStatus.transactionError() == DEAD_OBJECT;
-
- // This way, if you only check isDeadObject your process will
- // only be killed for more serious unchecked errors
- if (dead) {
- mCheckedStatus = true;
- }
-
- return dead;
- }
-
- // For debugging purposes only
- std::string description() const {
- // Doesn't consider checked.
- return mStatus.description();
- }
- };
-} // namespace details
-
-template<typename T> class Return : public details::return_status {
-private:
- T mVal {};
-public:
- Return(T v) : details::return_status(), mVal{v} {}
- Return(Status s) : details::return_status(s) {}
-
- // move-able.
- // precondition: "this" has checked status
- // postcondition: other is safe to destroy after moving to *this.
- Return(Return &&other) = default;
- Return &operator=(Return &&) = default;
-
- ~Return() = default;
-
- operator T() const {
- assertOk();
- return mVal;
- }
-
- T withDefault(T t) {
- return isOk() ? mVal : t;
- }
-};
-
-template<typename T> class Return<sp<T>> : public details::return_status {
-private:
- sp<T> mVal {};
-public:
- Return(sp<T> v) : details::return_status(), mVal{v} {}
- Return(T* v) : details::return_status(), mVal{v} {}
- // Constructors matching a different type (that is related by inheritance)
- template<typename U> Return(sp<U> v) : details::return_status(), mVal{v} {}
- template<typename U> Return(U* v) : details::return_status(), mVal{v} {}
- Return(Status s) : details::return_status(s) {}
-
- // move-able.
- // precondition: "this" has checked status
- // postcondition: other is safe to destroy after moving to *this.
- Return(Return &&other) = default;
- Return &operator=(Return &&) = default;
-
- ~Return() = default;
-
- operator sp<T>() const {
- assertOk();
- return mVal;
- }
-
- sp<T> withDefault(sp<T> t) {
- return isOk() ? mVal : t;
- }
-};
-
-
-template<> class Return<void> : public details::return_status {
-public:
- Return() : details::return_status() {}
- Return(Status s) : details::return_status(s) {}
-
- // move-able.
- // precondition: "this" has checked status
- // postcondition: other is safe to destroy after moving to *this.
- Return(Return &&) = default;
- Return &operator=(Return &&) = default;
-
- ~Return() = default;
-};
-
-static inline Return<void> Void() {
- return Return<void>();
-}
-
-namespace details {
-// Create a Return<U> from the Status of Return<T>. The provided
-// Return<T> must have an error status and have it checked.
-template <typename T, typename U>
-Return<U> StatusOf(const Return<T> &other) {
- if (other.mStatus.isOk() || !other.mCheckedStatus) {
- details::logAlwaysFatal("cannot call statusOf on an OK Status or an unchecked status");
- }
- return Return<U>{other.mStatus};
-}
-} // namespace details
-
-} // namespace hardware
-} // namespace android
-
-#endif // ANDROID_HARDWARE_BINDER_STATUS_H