summaryrefslogtreecommitdiff
path: root/runtimes/nn/depend/libhidl/base/HidlSupport.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'runtimes/nn/depend/libhidl/base/HidlSupport.cpp')
-rw-r--r--runtimes/nn/depend/libhidl/base/HidlSupport.cpp283
1 files changed, 283 insertions, 0 deletions
diff --git a/runtimes/nn/depend/libhidl/base/HidlSupport.cpp b/runtimes/nn/depend/libhidl/base/HidlSupport.cpp
new file mode 100644
index 000000000..7481c74cc
--- /dev/null
+++ b/runtimes/nn/depend/libhidl/base/HidlSupport.cpp
@@ -0,0 +1,283 @@
+/*
+ * 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.
+ */
+#define LOG_TAG "HidlSupport"
+
+#include <hidl/HidlSupport.h>
+#include "Logging.h"
+
+#include <unordered_map>
+
+#if 0 // REF-ANN
+#include <android-base/parseint.h>
+#endif
+
+namespace android {
+namespace hardware {
+
+#if 0 // REF-ANN
+namespace details {
+bool debuggable() {
+#ifdef LIBHIDL_TARGET_DEBUGGABLE
+ return true;
+#else
+ return false;
+#endif
+}
+} // namespace details
+
+hidl_handle::hidl_handle() {
+ mHandle = nullptr;
+ mOwnsHandle = false;
+}
+
+hidl_handle::~hidl_handle() {
+ freeHandle();
+}
+
+hidl_handle::hidl_handle(const native_handle_t *handle) {
+ mHandle = handle;
+ mOwnsHandle = false;
+}
+
+// copy constructor.
+hidl_handle::hidl_handle(const hidl_handle &other) {
+ mOwnsHandle = false;
+ *this = other;
+}
+
+// move constructor.
+hidl_handle::hidl_handle(hidl_handle &&other) noexcept {
+ mOwnsHandle = false;
+ *this = std::move(other);
+}
+
+// assignment operators
+hidl_handle &hidl_handle::operator=(const hidl_handle &other) {
+ if (this == &other) {
+ return *this;
+ }
+ freeHandle();
+ if (other.mHandle != nullptr) {
+ mHandle = native_handle_clone(other.mHandle);
+ if (mHandle == nullptr) {
+ PLOG(FATAL) << "Failed to clone native_handle in hidl_handle";
+ }
+ mOwnsHandle = true;
+ } else {
+ mHandle = nullptr;
+ mOwnsHandle = false;
+ }
+ return *this;
+}
+
+hidl_handle &hidl_handle::operator=(const native_handle_t *native_handle) {
+ freeHandle();
+ mHandle = native_handle;
+ mOwnsHandle = false;
+ return *this;
+}
+
+hidl_handle &hidl_handle::operator=(hidl_handle &&other) noexcept {
+ if (this != &other) {
+ freeHandle();
+ mHandle = other.mHandle;
+ mOwnsHandle = other.mOwnsHandle;
+ other.mHandle = nullptr;
+ other.mOwnsHandle = false;
+ }
+ return *this;
+}
+
+void hidl_handle::setTo(native_handle_t* handle, bool shouldOwn) {
+ freeHandle();
+ mHandle = handle;
+ mOwnsHandle = shouldOwn;
+}
+
+const native_handle_t* hidl_handle::operator->() const {
+ return mHandle;
+}
+
+// implicit conversion to const native_handle_t*
+hidl_handle::operator const native_handle_t *() const {
+ return mHandle;
+}
+
+// explicit conversion
+const native_handle_t *hidl_handle::getNativeHandle() const {
+ return mHandle;
+}
+
+void hidl_handle::freeHandle() {
+ if (mOwnsHandle && mHandle != nullptr) {
+ // This can only be true if:
+ // 1. Somebody called setTo() with shouldOwn=true, so we know the handle
+ // wasn't const to begin with.
+ // 2. Copy/assignment from another hidl_handle, in which case we have
+ // cloned the handle.
+ // 3. Move constructor from another hidl_handle, in which case the original
+ // hidl_handle must have been non-const as well.
+ native_handle_t *handle = const_cast<native_handle_t*>(
+ static_cast<const native_handle_t*>(mHandle));
+ native_handle_close(handle);
+ native_handle_delete(handle);
+ mHandle = nullptr;
+ }
+}
+#endif
+
+static const char *const kEmptyString = "";
+
+hidl_string::hidl_string()
+ : mBuffer(kEmptyString),
+ mSize(0),
+ mOwnsBuffer(false) {
+}
+
+hidl_string::~hidl_string() {
+ clear();
+}
+
+hidl_string::hidl_string(const char *s) : hidl_string() {
+ if (s == nullptr) {
+ return;
+ }
+
+ copyFrom(s, strlen(s));
+}
+
+hidl_string::hidl_string(const char *s, size_t length) : hidl_string() {
+ copyFrom(s, length);
+}
+
+hidl_string::hidl_string(const hidl_string &other): hidl_string() {
+ copyFrom(other.c_str(), other.size());
+}
+
+hidl_string::hidl_string(const std::string &s) : hidl_string() {
+ copyFrom(s.c_str(), s.size());
+}
+
+hidl_string::hidl_string(hidl_string &&other) noexcept : hidl_string() {
+ moveFrom(std::forward<hidl_string>(other));
+}
+
+hidl_string &hidl_string::operator=(hidl_string &&other) noexcept {
+ if (this != &other) {
+ clear();
+ moveFrom(std::forward<hidl_string>(other));
+ }
+ return *this;
+}
+
+hidl_string &hidl_string::operator=(const hidl_string &other) {
+ if (this != &other) {
+ clear();
+ copyFrom(other.c_str(), other.size());
+ }
+
+ return *this;
+}
+
+hidl_string &hidl_string::operator=(const char *s) {
+ clear();
+
+ if (s == nullptr) {
+ return *this;
+ }
+
+ copyFrom(s, strlen(s));
+ return *this;
+}
+
+hidl_string &hidl_string::operator=(const std::string &s) {
+ clear();
+ copyFrom(s.c_str(), s.size());
+ return *this;
+}
+
+hidl_string::operator std::string() const {
+ return std::string(mBuffer, mSize);
+}
+
+std::ostream& operator<<(std::ostream& os, const hidl_string& str) {
+ os << str.c_str();
+ return os;
+}
+
+void hidl_string::copyFrom(const char *data, size_t size) {
+ // assume my resources are freed.
+
+ if (size > UINT32_MAX) {
+ LOG(FATAL) << "string size can't exceed 2^32 bytes: " << size;
+ }
+ char *buf = (char *)malloc(size + 1);
+ memcpy(buf, data, size);
+ buf[size] = '\0';
+ mBuffer = buf;
+
+ mSize = static_cast<uint32_t>(size);
+ mOwnsBuffer = true;
+}
+
+void hidl_string::moveFrom(hidl_string &&other) {
+ // assume my resources are freed.
+
+ mBuffer = std::move(other.mBuffer);
+ mSize = other.mSize;
+ mOwnsBuffer = other.mOwnsBuffer;
+
+ other.mOwnsBuffer = false;
+ other.clear();
+}
+
+void hidl_string::clear() {
+ if (mOwnsBuffer && (mBuffer != kEmptyString)) {
+ free(const_cast<char *>(static_cast<const char *>(mBuffer)));
+ }
+
+ mBuffer = kEmptyString;
+ mSize = 0;
+ mOwnsBuffer = false;
+}
+
+void hidl_string::setToExternal(const char *data, size_t size) {
+ if (size > UINT32_MAX) {
+ LOG(FATAL) << "string size can't exceed 2^32 bytes: " << size;
+ }
+ clear();
+
+ mBuffer = data;
+ mSize = static_cast<uint32_t>(size);
+ mOwnsBuffer = false;
+}
+
+const char *hidl_string::c_str() const {
+ return mBuffer;
+}
+
+size_t hidl_string::size() const {
+ return mSize;
+}
+
+bool hidl_string::empty() const {
+ return mSize == 0;
+}
+
+} // namespace hardware
+} // namespace android
+
+