From: 3arthur6 Date: Sun, 14 Nov 2021 16:01:56 +0000 (+0100) Subject: Use more symbolic links for headers paths X-Git-Tag: upstream/1.0^2~6 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=47b9796540f51327826067a81959ec6beb776e0f;p=tools%2Fdynpart-tools.git Use more symbolic links for headers paths --- diff --git a/lib/include/android b/lib/include/android new file mode 120000 index 0000000..dc0a798 --- /dev/null +++ b/lib/include/android @@ -0,0 +1 @@ +../liblog/include/android/ \ No newline at end of file diff --git a/lib/include/android-base b/lib/include/android-base new file mode 120000 index 0000000..ca80c22 --- /dev/null +++ b/lib/include/android-base @@ -0,0 +1 @@ +../base/include/android-base/ \ No newline at end of file diff --git a/lib/include/android-base/chrono_utils.h b/lib/include/android-base/chrono_utils.h deleted file mode 100755 index 11fcf71..0000000 --- a/lib/include/android-base/chrono_utils.h +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Copyright (C) 2017 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 -#include - -#if __cplusplus > 201103L && !defined(__WIN32) // C++14 -using namespace std::chrono_literals; -#endif - -namespace android { -namespace base { - -// A std::chrono clock based on CLOCK_BOOTTIME. -class boot_clock { - public: - typedef std::chrono::nanoseconds duration; - typedef std::chrono::time_point time_point; - - static time_point now(); -}; - -class Timer { - public: - Timer() : start_(boot_clock::now()) {} - - std::chrono::milliseconds duration() const { - return std::chrono::duration_cast(boot_clock::now() - start_); - } - - private: - boot_clock::time_point start_; -}; - -std::ostream& operator<<(std::ostream& os, const Timer& t); - -} // namespace base -} // namespace android diff --git a/lib/include/android-base/cmsg.h b/lib/include/android-base/cmsg.h deleted file mode 100755 index e4197b1..0000000 --- a/lib/include/android-base/cmsg.h +++ /dev/null @@ -1,106 +0,0 @@ -/* - * Copyright (C) 2019 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 -#include - -#include -#include - -#include -#include -#include - -namespace android { -namespace base { - -#if !defined(_WIN32) - -// Helpers for sending and receiving file descriptors across Unix domain sockets. -// -// The cmsg(3) API is very hard to get right, with multiple landmines that can -// lead to death. Almost all of the uses of cmsg in Android make at least one of -// the following mistakes: -// -// - not aligning the cmsg buffer -// - leaking fds if more fds are received than expected -// - blindly dereferencing CMSG_DATA without checking the header -// - using CMSG_SPACE instead of CMSG_LEN for .cmsg_len -// - using CMSG_LEN instead of CMSG_SPACE for .msg_controllen -// - using a length specified in number of fds instead of bytes -// -// These functions wrap the hard-to-use cmsg API with an easier to use abstraction. - -// Send file descriptors across a Unix domain socket. -// -// Note that the write can return short if the socket type is SOCK_STREAM. When -// this happens, file descriptors are still sent to the other end, but with -// truncated data. For this reason, using SOCK_SEQPACKET or SOCK_DGRAM is recommended. -ssize_t SendFileDescriptorVector(borrowed_fd sock, const void* data, size_t len, - const std::vector& fds); - -// Receive file descriptors from a Unix domain socket. -// -// If more FDs (or bytes, for datagram sockets) are received than expected, -// -1 is returned with errno set to EMSGSIZE, and all received FDs are thrown away. -ssize_t ReceiveFileDescriptorVector(borrowed_fd sock, void* data, size_t len, size_t max_fds, - std::vector* fds); - -// Helper for SendFileDescriptorVector that constructs a std::vector for you, e.g.: -// SendFileDescriptors(sock, "foo", 3, std::move(fd1), std::move(fd2)) -template -ssize_t SendFileDescriptors(borrowed_fd sock, const void* data, size_t len, Args&&... sent_fds) { - // Do not allow implicit conversion to int: people might try to do something along the lines of: - // SendFileDescriptors(..., std::move(a_unique_fd)) - // and be surprised when the unique_fd isn't closed afterwards. - AssertType(std::forward(sent_fds)...); - std::vector fds; - Append(fds, std::forward(sent_fds)...); - return SendFileDescriptorVector(sock, data, len, fds); -} - -// Helper for ReceiveFileDescriptorVector that receives an exact number of file descriptors. -// If more file descriptors are received than requested, -1 is returned with errno set to EMSGSIZE. -// If fewer file descriptors are received than requested, -1 is returned with errno set to ENOMSG. -// In both cases, all arguments are cleared and any received FDs are thrown away. -template -ssize_t ReceiveFileDescriptors(borrowed_fd sock, void* data, size_t len, Args&&... received_fds) { - std::vector fds; - Append(fds, std::forward(received_fds)...); - - std::vector result; - ssize_t rc = ReceiveFileDescriptorVector(sock, data, len, fds.size(), &result); - if (rc == -1 || result.size() != fds.size()) { - int err = rc == -1 ? errno : ENOMSG; - for (unique_fd* fd : fds) { - fd->reset(); - } - errno = err; - return -1; - } - - for (size_t i = 0; i < fds.size(); ++i) { - *fds[i] = std::move(result[i]); - } - return rc; -} - -#endif - -} // namespace base -} // namespace android diff --git a/lib/include/android-base/collections.h b/lib/include/android-base/collections.h deleted file mode 100755 index be0683a..0000000 --- a/lib/include/android-base/collections.h +++ /dev/null @@ -1,60 +0,0 @@ -/* - * Copyright (C) 2019 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 - -namespace android { -namespace base { - -// Helpers for converting a variadic template parameter pack to a homogeneous collection. -// Parameters must be implictly convertible to the contained type (including via move/copy ctors). -// -// Use as follows: -// -// template -// std::vector CreateVector(Args&&... args) { -// std::vector result; -// Append(result, std::forward(args)...); -// return result; -// } -template -void Append(CollectionType& collection, T&& arg) { - collection.push_back(std::forward(arg)); -} - -template -void Append(CollectionType& collection, T&& arg, Args&&... args) { - collection.push_back(std::forward(arg)); - return Append(collection, std::forward(args)...); -} - -// Assert that all of the arguments in a variadic template parameter pack are of a given type -// after std::decay. -template -void AssertType(Arg&&) { - static_assert(std::is_same::type>::value); -} - -template -void AssertType(Arg&&, Args&&... args) { - static_assert(std::is_same::type>::value); - AssertType(std::forward(args)...); -} - -} // namespace base -} // namespace android diff --git a/lib/include/android-base/endian.h b/lib/include/android-base/endian.h deleted file mode 100755 index 8fa6365..0000000 --- a/lib/include/android-base/endian.h +++ /dev/null @@ -1,98 +0,0 @@ -/* - * Copyright (C) 2017 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 - -/* A cross-platform equivalent of bionic's . */ - -/* For __BIONIC__ and __GLIBC__ */ -#include - -#if defined(__BIONIC__) - -#include - -#elif defined(__GLIBC__) - -/* glibc's is like bionic's . */ -#include - -/* glibc keeps htons and htonl in . */ -#include - -/* glibc doesn't have the 64-bit variants. */ -#define htonq(x) htobe64(x) -#define ntohq(x) be64toh(x) - -/* glibc has different names to BSD for these. */ -#define betoh16(x) be16toh(x) -#define betoh32(x) be32toh(x) -#define betoh64(x) be64toh(x) -#define letoh16(x) le16toh(x) -#define letoh32(x) le32toh(x) -#define letoh64(x) le64toh(x) - -#else - -#if defined(__APPLE__) -/* macOS has some of the basics. */ -#include -#else -/* Windows has some of the basics as well. */ -#include -#include -/* winsock2.h *must* be included before the following four macros. */ -#define htons(x) __builtin_bswap16(x) -#define htonl(x) __builtin_bswap32(x) -#define ntohs(x) __builtin_bswap16(x) -#define ntohl(x) __builtin_bswap32(x) -#endif - -/* Neither macOS nor Windows have the rest. */ - -#define __LITTLE_ENDIAN 1234 -#define __BIG_ENDIAN 4321 -#define __BYTE_ORDER __LITTLE_ENDIAN - -#define htonq(x) __builtin_bswap64(x) - -#define ntohq(x) __builtin_bswap64(x) - -#define htobe16(x) __builtin_bswap16(x) -#define htobe32(x) __builtin_bswap32(x) -#define htobe64(x) __builtin_bswap64(x) - -#define betoh16(x) __builtin_bswap16(x) -#define betoh32(x) __builtin_bswap32(x) -#define betoh64(x) __builtin_bswap64(x) - -#define htole16(x) (x) -#define htole32(x) (x) -#define htole64(x) (x) - -#define letoh16(x) (x) -#define letoh32(x) (x) -#define letoh64(x) (x) - -#define be16toh(x) __builtin_bswap16(x) -#define be32toh(x) __builtin_bswap32(x) -#define be64toh(x) __builtin_bswap64(x) - -#define le16toh(x) (x) -#define le32toh(x) (x) -#define le64toh(x) (x) - -#endif diff --git a/lib/include/android-base/errno_restorer.h b/lib/include/android-base/errno_restorer.h deleted file mode 100755 index 1c8597c..0000000 --- a/lib/include/android-base/errno_restorer.h +++ /dev/null @@ -1,42 +0,0 @@ -/* - * Copyright (C) 2020 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 "errno.h" - -#include "android-base/macros.h" - -namespace android { -namespace base { - -class ErrnoRestorer { - public: - ErrnoRestorer() : saved_errno_(errno) {} - - ~ErrnoRestorer() { errno = saved_errno_; } - - // Allow this object to be used as part of && operation. - operator bool() const { return true; } - - private: - const int saved_errno_; - - DISALLOW_COPY_AND_ASSIGN(ErrnoRestorer); -}; - -} // namespace base -} // namespace android diff --git a/lib/include/android-base/errors.h b/lib/include/android-base/errors.h deleted file mode 100755 index 06f29fc..0000000 --- a/lib/include/android-base/errors.h +++ /dev/null @@ -1,43 +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. - */ - -// Portable error handling functions. This is only necessary for host-side -// code that needs to be cross-platform; code that is only run on Unix should -// just use errno and strerror() for simplicity. -// -// There is some complexity since Windows has (at least) three different error -// numbers, not all of which share the same type: -// * errno: for C runtime errors. -// * GetLastError(): Windows non-socket errors. -// * WSAGetLastError(): Windows socket errors. -// errno can be passed to strerror() on all platforms, but the other two require -// special handling to get the error string. Refer to Microsoft documentation -// to determine which error code to check for each function. - -#pragma once - -#include - -namespace android { -namespace base { - -// Returns a string describing the given system error code. |error_code| must -// be errno on Unix or GetLastError()/WSAGetLastError() on Windows. Passing -// errno on Windows has undefined behavior. -std::string SystemErrorCodeToString(int error_code); - -} // namespace base -} // namespace android diff --git a/lib/include/android-base/expected.h b/lib/include/android-base/expected.h deleted file mode 100755 index 9470344..0000000 --- a/lib/include/android-base/expected.h +++ /dev/null @@ -1,744 +0,0 @@ -/* - * Copyright (C) 2019 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 -#include -#include -#include -#include - -// android::base::expected is an Android implementation of the std::expected -// proposal. -// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0323r7.html -// -// Usage: -// using android::base::expected; -// using android::base::unexpected; -// -// expected safe_divide(double i, double j) { -// if (j == 0) return unexpected("divide by zero"); -// else return i / j; -// } -// -// void test() { -// auto q = safe_divide(10, 0); -// if (q) { printf("%f\n", q.value()); } -// else { printf("%s\n", q.error().c_str()); } -// } -// -// When the proposal becomes part of the standard and is implemented by -// libcxx, this will be removed and android::base::expected will be -// type alias to std::expected. -// - -namespace android { -namespace base { - -// Synopsis -template - class expected; - -template - class unexpected; -template - unexpected(E) -> unexpected; - -template - class bad_expected_access; - -template<> - class bad_expected_access; - -struct unexpect_t { - explicit unexpect_t() = default; -}; -inline constexpr unexpect_t unexpect{}; - -// macros for SFINAE -#define _ENABLE_IF(...) \ - , std::enable_if_t<(__VA_ARGS__)>* = nullptr - -// Define NODISCARD_EXPECTED to prevent expected from being -// ignored when used as a return value. This is off by default. -#ifdef NODISCARD_EXPECTED -#define _NODISCARD_ [[nodiscard]] -#else -#define _NODISCARD_ -#endif - -// Class expected -template -class _NODISCARD_ expected { - public: - using value_type = T; - using error_type = E; - using unexpected_type = unexpected; - - template - using rebind = expected; - - // constructors - constexpr expected() = default; - constexpr expected(const expected& rhs) = default; - constexpr expected(expected&& rhs) noexcept = default; - - template && - std::is_constructible_v && - !std::is_constructible_v&> && - !std::is_constructible_v&&> && - !std::is_constructible_v&> && - !std::is_constructible_v&&> && - !std::is_convertible_v&, T> && - !std::is_convertible_v&&, T> && - !std::is_convertible_v&, T> && - !std::is_convertible_v&&, T> && - !(!std::is_convertible_v || - !std::is_convertible_v) /* non-explicit */ - )> - // NOLINTNEXTLINE(google-explicit-constructor) - constexpr expected(const expected& rhs) { - if (rhs.has_value()) var_ = rhs.value(); - else var_ = unexpected(rhs.error()); - } - - template && - std::is_constructible_v && - !std::is_constructible_v&> && - !std::is_constructible_v&&> && - !std::is_constructible_v&> && - !std::is_constructible_v&&> && - !std::is_convertible_v&, T> && - !std::is_convertible_v&&, T> && - !std::is_convertible_v&, T> && - !std::is_convertible_v&&, T> && - (!std::is_convertible_v || - !std::is_convertible_v) /* explicit */ - )> - constexpr explicit expected(const expected& rhs) { - if (rhs.has_value()) var_ = rhs.value(); - else var_ = unexpected(rhs.error()); - } - - template && - std::is_constructible_v && - !std::is_constructible_v&> && - !std::is_constructible_v&&> && - !std::is_constructible_v&> && - !std::is_constructible_v&&> && - !std::is_convertible_v&, T> && - !std::is_convertible_v&&, T> && - !std::is_convertible_v&, T> && - !std::is_convertible_v&&, T> && - !(!std::is_convertible_v || - !std::is_convertible_v) /* non-explicit */ - )> - // NOLINTNEXTLINE(google-explicit-constructor) - constexpr expected(expected&& rhs) { - if (rhs.has_value()) var_ = std::move(rhs.value()); - else var_ = unexpected(std::move(rhs.error())); - } - - template && - std::is_constructible_v && - !std::is_constructible_v&> && - !std::is_constructible_v&&> && - !std::is_constructible_v&> && - !std::is_constructible_v&&> && - !std::is_convertible_v&, T> && - !std::is_convertible_v&&, T> && - !std::is_convertible_v&, T> && - !std::is_convertible_v&&, T> && - (!std::is_convertible_v || - !std::is_convertible_v) /* explicit */ - )> - constexpr explicit expected(expected&& rhs) { - if (rhs.has_value()) var_ = std::move(rhs.value()); - else var_ = unexpected(std::move(rhs.error())); - } - - template && - !std::is_same_v>, std::in_place_t> && - !std::is_same_v, std::remove_cv_t>> && - !std::is_same_v, std::remove_cv_t>> && - std::is_convertible_v /* non-explicit */ - )> - // NOLINTNEXTLINE(google-explicit-constructor,bugprone-forwarding-reference-overload) - constexpr expected(U&& v) : var_(std::in_place_index<0>, std::forward(v)) {} - - template && - !std::is_same_v>, std::in_place_t> && - !std::is_same_v, std::remove_cv_t>> && - !std::is_same_v, std::remove_cv_t>> && - !std::is_convertible_v /* explicit */ - )> - // NOLINTNEXTLINE(bugprone-forwarding-reference-overload) - constexpr explicit expected(U&& v) : var_(std::in_place_index<0>, T(std::forward(v))) {} - - template && - std::is_convertible_v /* non-explicit */ - )> - // NOLINTNEXTLINE(google-explicit-constructor) - constexpr expected(const unexpected& e) - : var_(std::in_place_index<1>, e.value()) {} - - template && - !std::is_convertible_v /* explicit */ - )> - constexpr explicit expected(const unexpected& e) - : var_(std::in_place_index<1>, E(e.value())) {} - - template && - std::is_convertible_v /* non-explicit */ - )> - // NOLINTNEXTLINE(google-explicit-constructor) - constexpr expected(unexpected&& e) - : var_(std::in_place_index<1>, std::move(e.value())) {} - - template && - !std::is_convertible_v /* explicit */ - )> - constexpr explicit expected(unexpected&& e) - : var_(std::in_place_index<1>, E(std::move(e.value()))) {} - - template - )> - constexpr explicit expected(std::in_place_t, Args&&... args) - : var_(std::in_place_index<0>, std::forward(args)...) {} - - template&, Args...> - )> - constexpr explicit expected(std::in_place_t, std::initializer_list il, Args&&... args) - : var_(std::in_place_index<0>, il, std::forward(args)...) {} - - template - )> - constexpr explicit expected(unexpect_t, Args&&... args) - : var_(unexpected_type(std::forward(args)...)) {} - - template&, Args...> - )> - constexpr explicit expected(unexpect_t, std::initializer_list il, Args&&... args) - : var_(unexpected_type(il, std::forward(args)...)) {} - - // destructor - ~expected() = default; - - // assignment - // Note: SFNAIE doesn't work here because assignment operator should be - // non-template. We could workaround this by defining a templated parent class - // having the assignment operator. This incomplete implementation however - // doesn't allow us to copy assign expected even when T is non-copy - // assignable. The copy assignment will fail by the underlying std::variant - // anyway though the error message won't be clear. - expected& operator=(const expected& rhs) = default; - - // Note for SFNAIE above applies to here as well - expected& operator=(expected&& rhs) noexcept( - std::is_nothrow_move_assignable_v&& std::is_nothrow_move_assignable_v) = default; - - template && - !std::is_same_v, std::remove_cv_t>> && - !std::conjunction_v, std::is_same>> && - std::is_constructible_v && std::is_assignable_v && - std::is_nothrow_move_constructible_v)> - expected& operator=(U&& rhs) { - var_ = T(std::forward(rhs)); - return *this; - } - - template - expected& operator=(const unexpected& rhs) { - var_ = rhs; - return *this; - } - - template && - std::is_move_assignable_v - )> - expected& operator=(unexpected&& rhs) { - var_ = std::move(rhs); - return *this; - } - - // modifiers - template - )> - T& emplace(Args&&... args) { - expected(std::in_place, std::forward(args)...).swap(*this); - return value(); - } - - template&, Args...> - )> - T& emplace(std::initializer_list il, Args&&... args) { - expected(std::in_place, il, std::forward(args)...).swap(*this); - return value(); - } - - // swap - template && - std::is_swappable_v && - (std::is_move_constructible_v || - std::is_move_constructible_v))>> - void swap(expected& rhs) noexcept( - std::is_nothrow_move_constructible_v && - std::is_nothrow_swappable_v && - std::is_nothrow_move_constructible_v && - std::is_nothrow_swappable_v) { - var_.swap(rhs.var_); - } - - // observers - constexpr const T* operator->() const { return std::addressof(value()); } - constexpr T* operator->() { return std::addressof(value()); } - constexpr const T& operator*() const& { return value(); } - constexpr T& operator*() & { return value(); } - constexpr const T&& operator*() const&& { return std::move(std::get(var_)); } - constexpr T&& operator*() && { return std::move(std::get(var_)); } - - constexpr explicit operator bool() const noexcept { return has_value(); } - constexpr bool has_value() const noexcept { return var_.index() == 0; } - constexpr bool ok() const noexcept { return has_value(); } - - constexpr const T& value() const& { return std::get(var_); } - constexpr T& value() & { return std::get(var_); } - constexpr const T&& value() const&& { return std::move(std::get(var_)); } - constexpr T&& value() && { return std::move(std::get(var_)); } - - constexpr const E& error() const& { return std::get(var_).value(); } - constexpr E& error() & { return std::get(var_).value(); } - constexpr const E&& error() const&& { return std::move(std::get(var_)).value(); } - constexpr E&& error() && { return std::move(std::get(var_)).value(); } - - template && - std::is_convertible_v - )> - constexpr T value_or(U&& v) const& { - if (has_value()) return value(); - else return static_cast(std::forward(v)); - } - - template && - std::is_convertible_v - )> - constexpr T value_or(U&& v) && { - if (has_value()) return std::move(value()); - else return static_cast(std::forward(v)); - } - - // expected equality operators - template - friend constexpr bool operator==(const expected& x, const expected& y); - template - friend constexpr bool operator!=(const expected& x, const expected& y); - - // Comparison with unexpected - template - friend constexpr bool operator==(const expected&, const unexpected&); - template - friend constexpr bool operator==(const unexpected&, const expected&); - template - friend constexpr bool operator!=(const expected&, const unexpected&); - template - friend constexpr bool operator!=(const unexpected&, const expected&); - - // Specialized algorithms - template - friend void swap(expected&, expected&) noexcept; - - private: - std::variant var_; -}; - -template -constexpr bool operator==(const expected& x, const expected& y) { - if (x.has_value() != y.has_value()) return false; - if (!x.has_value()) return x.error() == y.error(); - return *x == *y; -} - -template -constexpr bool operator!=(const expected& x, const expected& y) { - return !(x == y); -} - -// Comparison with unexpected -template -constexpr bool operator==(const expected& x, const unexpected& y) { - return !x.has_value() && (x.error() == y.value()); -} -template -constexpr bool operator==(const unexpected& x, const expected& y) { - return !y.has_value() && (x.value() == y.error()); -} -template -constexpr bool operator!=(const expected& x, const unexpected& y) { - return x.has_value() || (x.error() != y.value()); -} -template -constexpr bool operator!=(const unexpected& x, const expected& y) { - return y.has_value() || (x.value() != y.error()); -} - -template -class _NODISCARD_ expected { - public: - using value_type = void; - using error_type = E; - using unexpected_type = unexpected; - - // constructors - constexpr expected() = default; - constexpr expected(const expected& rhs) = default; - constexpr expected(expected&& rhs) noexcept = default; - - template && - std::is_convertible_v /* non-explicit */ - )> - // NOLINTNEXTLINE(google-explicit-constructor) - constexpr expected(const expected& rhs) { - if (!rhs.has_value()) var_ = unexpected(rhs.error()); - } - - template && - !std::is_convertible_v /* explicit */ - )> - constexpr explicit expected(const expected& rhs) { - if (!rhs.has_value()) var_ = unexpected(rhs.error()); - } - - template && - std::is_convertible_v /* non-explicit */ - )> - // NOLINTNEXTLINE(google-explicit-constructor) - constexpr expected(expected&& rhs) { - if (!rhs.has_value()) var_ = unexpected(std::move(rhs.error())); - } - - template && - !std::is_convertible_v /* explicit */ - )> - constexpr explicit expected(expected&& rhs) { - if (!rhs.has_value()) var_ = unexpected(std::move(rhs.error())); - } - - template && - std::is_convertible_v /* non-explicit */ - )> - // NOLINTNEXTLINE(google-explicit-constructor) - constexpr expected(const unexpected& e) - : var_(std::in_place_index<1>, e.value()) {} - - template && - !std::is_convertible_v /* explicit */ - )> - constexpr explicit expected(const unexpected& e) - : var_(std::in_place_index<1>, E(e.value())) {} - - template && - std::is_convertible_v /* non-explicit */ - )> - // NOLINTNEXTLINE(google-explicit-constructor) - constexpr expected(unexpected&& e) - : var_(std::in_place_index<1>, std::move(e.value())) {} - - template && - !std::is_convertible_v /* explicit */ - )> - constexpr explicit expected(unexpected&& e) - : var_(std::in_place_index<1>, E(std::move(e.value()))) {} - - template - constexpr explicit expected(std::in_place_t, Args&&...) {} - - template - )> - constexpr explicit expected(unexpect_t, Args&&... args) - : var_(unexpected_type(std::forward(args)...)) {} - - template&, Args...> - )> - constexpr explicit expected(unexpect_t, std::initializer_list il, Args&&... args) - : var_(unexpected_type(il, std::forward(args)...)) {} - - // destructor - ~expected() = default; - - // assignment - // Note: SFNAIE doesn't work here because assignment operator should be - // non-template. We could workaround this by defining a templated parent class - // having the assignment operator. This incomplete implementation however - // doesn't allow us to copy assign expected even when T is non-copy - // assignable. The copy assignment will fail by the underlying std::variant - // anyway though the error message won't be clear. - expected& operator=(const expected& rhs) = default; - - // Note for SFNAIE above applies to here as well - expected& operator=(expected&& rhs) noexcept(std::is_nothrow_move_assignable_v) = default; - - template - expected& operator=(const unexpected& rhs) { - var_ = rhs; - return *this; - } - - template && - std::is_move_assignable_v - )> - expected& operator=(unexpected&& rhs) { - var_ = std::move(rhs); - return *this; - } - - // modifiers - void emplace() { - var_ = std::monostate(); - } - - // swap - template> - > - void swap(expected& rhs) noexcept(std::is_nothrow_move_constructible_v) { - var_.swap(rhs.var_); - } - - // observers - constexpr explicit operator bool() const noexcept { return has_value(); } - constexpr bool has_value() const noexcept { return var_.index() == 0; } - constexpr bool ok() const noexcept { return has_value(); } - - constexpr void value() const& { if (!has_value()) std::get<0>(var_); } - - constexpr const E& error() const& { return std::get(var_).value(); } - constexpr E& error() & { return std::get(var_).value(); } - constexpr const E&& error() const&& { return std::move(std::get(var_)).value(); } - constexpr E&& error() && { return std::move(std::get(var_)).value(); } - - // expected equality operators - template - friend constexpr bool operator==(const expected& x, const expected& y); - - // Specialized algorithms - template - friend void swap(expected&, expected&) noexcept; - - private: - std::variant var_; -}; - -template -constexpr bool operator==(const expected& x, const expected& y) { - if (x.has_value() != y.has_value()) return false; - if (!x.has_value()) return x.error() == y.error(); - return true; -} - -template -constexpr bool operator==(const expected& x, const expected& y) { - if (x.has_value() != y.has_value()) return false; - if (!x.has_value()) return x.error() == y.error(); - return false; -} - -template -constexpr bool operator==(const expected& x, const expected& y) { - if (x.has_value() != y.has_value()) return false; - if (!x.has_value()) return x.error() == y.error(); - return false; -} - -template -class unexpected { - public: - // constructors - constexpr unexpected(const unexpected&) = default; - constexpr unexpected(unexpected&&) noexcept(std::is_nothrow_move_constructible_v) = default; - - template && - !std::is_same_v>, std::in_place_t> && - !std::is_same_v>, unexpected>)> - // NOLINTNEXTLINE(google-explicit-constructor,bugprone-forwarding-reference-overload) - constexpr unexpected(Err&& e) : val_(std::forward(e)) {} - - template&, Args...> - )> - constexpr explicit unexpected(std::in_place_t, std::initializer_list il, Args&&... args) - : val_(il, std::forward(args)...) {} - - template && - !std::is_constructible_v&> && - !std::is_constructible_v> && - !std::is_constructible_v&> && - !std::is_constructible_v> && - !std::is_convertible_v&, E> && - !std::is_convertible_v, E> && - !std::is_convertible_v&, E> && - !std::is_convertible_v, E> && - std::is_convertible_v /* non-explicit */ - )> - // NOLINTNEXTLINE(google-explicit-constructor) - constexpr unexpected(const unexpected& rhs) - : val_(rhs.value()) {} - - template && - !std::is_constructible_v&> && - !std::is_constructible_v> && - !std::is_constructible_v&> && - !std::is_constructible_v> && - !std::is_convertible_v&, E> && - !std::is_convertible_v, E> && - !std::is_convertible_v&, E> && - !std::is_convertible_v, E> && - !std::is_convertible_v /* explicit */ - )> - constexpr explicit unexpected(const unexpected& rhs) - : val_(E(rhs.value())) {} - - template && - !std::is_constructible_v&> && - !std::is_constructible_v> && - !std::is_constructible_v&> && - !std::is_constructible_v> && - !std::is_convertible_v&, E> && - !std::is_convertible_v, E> && - !std::is_convertible_v&, E> && - !std::is_convertible_v, E> && - std::is_convertible_v /* non-explicit */ - )> - // NOLINTNEXTLINE(google-explicit-constructor) - constexpr unexpected(unexpected&& rhs) - : val_(std::move(rhs.value())) {} - - template && - !std::is_constructible_v&> && - !std::is_constructible_v> && - !std::is_constructible_v&> && - !std::is_constructible_v> && - !std::is_convertible_v&, E> && - !std::is_convertible_v, E> && - !std::is_convertible_v&, E> && - !std::is_convertible_v, E> && - !std::is_convertible_v /* explicit */ - )> - constexpr explicit unexpected(unexpected&& rhs) - : val_(E(std::move(rhs.value()))) {} - - // assignment - constexpr unexpected& operator=(const unexpected&) = default; - constexpr unexpected& operator=(unexpected&&) noexcept(std::is_nothrow_move_assignable_v) = - default; - template - constexpr unexpected& operator=(const unexpected& rhs) { - val_ = rhs.value(); - return *this; - } - template - constexpr unexpected& operator=(unexpected&& rhs) { - val_ = std::forward(rhs.value()); - return *this; - } - - // observer - constexpr const E& value() const& noexcept { return val_; } - constexpr E& value() & noexcept { return val_; } - constexpr const E&& value() const&& noexcept { return std::move(val_); } - constexpr E&& value() && noexcept { return std::move(val_); } - - void swap(unexpected& other) noexcept(std::is_nothrow_swappable_v) { - std::swap(val_, other.val_); - } - - template - friend constexpr bool - operator==(const unexpected& e1, const unexpected& e2); - template - friend constexpr bool - operator!=(const unexpected& e1, const unexpected& e2); - - template - friend void swap(unexpected& x, unexpected& y) noexcept(noexcept(x.swap(y))); - - private: - E val_; -}; - -template -constexpr bool -operator==(const unexpected& e1, const unexpected& e2) { - return e1.value() == e2.value(); -} - -template -constexpr bool -operator!=(const unexpected& e1, const unexpected& e2) { - return e1.value() != e2.value(); -} - -template -void swap(unexpected& x, unexpected& y) noexcept(noexcept(x.swap(y))) { - x.swap(y); -} - -// TODO: bad_expected_access class - -#undef _ENABLE_IF -#undef _NODISCARD_ - -} // namespace base -} // namespace android diff --git a/lib/include/android-base/file.h b/lib/include/android-base/file.h deleted file mode 100755 index c622562..0000000 --- a/lib/include/android-base/file.h +++ /dev/null @@ -1,125 +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. - */ - -#pragma once - -#include -#include - -#include - -#include "android-base/macros.h" -#include "android-base/off64_t.h" -#include "android-base/unique_fd.h" - -#if !defined(_WIN32) && !defined(O_BINARY) -/** Windows needs O_BINARY, but Unix never mangles line endings. */ -#define O_BINARY 0 -#endif - -#if defined(_WIN32) && !defined(O_CLOEXEC) -/** Windows has O_CLOEXEC but calls it O_NOINHERIT for some reason. */ -#define O_CLOEXEC O_NOINHERIT -#endif - -class TemporaryFile { - public: - TemporaryFile(); - explicit TemporaryFile(const std::string& tmp_dir); - ~TemporaryFile(); - - // Release the ownership of fd, caller is reponsible for closing the - // fd or stream properly. - int release(); - // Don't remove the temporary file in the destructor. - void DoNotRemove() { remove_file_ = false; } - - int fd; - char path[1024]; - - private: - void init(const std::string& tmp_dir); - - bool remove_file_ = true; - - DISALLOW_COPY_AND_ASSIGN(TemporaryFile); -}; - -class TemporaryDir { - public: - TemporaryDir(); - ~TemporaryDir(); - // Don't remove the temporary dir in the destructor. - void DoNotRemove() { remove_dir_and_contents_ = false; } - - char path[1024]; - - private: - bool init(const std::string& tmp_dir); - - bool remove_dir_and_contents_ = true; - - DISALLOW_COPY_AND_ASSIGN(TemporaryDir); -}; - -namespace android { -namespace base { - -bool ReadFdToString(borrowed_fd fd, std::string* content); -bool ReadFileToString(const std::string& path, std::string* content, - bool follow_symlinks = false); - -bool WriteStringToFile(const std::string& content, const std::string& path, - bool follow_symlinks = false); -bool WriteStringToFd(const std::string& content, borrowed_fd fd); - -#if !defined(_WIN32) -bool WriteStringToFile(const std::string& content, const std::string& path, - mode_t mode, uid_t owner, gid_t group, - bool follow_symlinks = false); -#endif - -bool ReadFully(borrowed_fd fd, void* data, size_t byte_count); - -// Reads `byte_count` bytes from the file descriptor at the specified offset. -// Returns false if there was an IO error or EOF was reached before reading `byte_count` bytes. -// -// NOTE: On Linux/Mac, this function wraps pread, which provides atomic read support without -// modifying the read pointer of the file descriptor. On Windows, however, the read pointer does -// get modified. This means that ReadFullyAtOffset can be used concurrently with other calls to the -// same function, but concurrently seeking or reading incrementally can lead to unexpected -// behavior. -bool ReadFullyAtOffset(borrowed_fd fd, void* data, size_t byte_count, off64_t offset); - -bool WriteFully(borrowed_fd fd, const void* data, size_t byte_count); - -bool RemoveFileIfExists(const std::string& path, std::string* err = nullptr); - -#if !defined(_WIN32) -bool Realpath(const std::string& path, std::string* result); -bool Readlink(const std::string& path, std::string* result); -#endif - -std::string GetExecutablePath(); -std::string GetExecutableDirectory(); - -// Like the regular basename and dirname, but thread-safe on all -// platforms and capable of correctly handling exotic Windows paths. -std::string Basename(const std::string& path); -std::string Dirname(const std::string& path); - -} // namespace base -} // namespace android diff --git a/lib/include/android-base/format.h b/lib/include/android-base/format.h deleted file mode 100755 index 330040d..0000000 --- a/lib/include/android-base/format.h +++ /dev/null @@ -1,28 +0,0 @@ -/* - * Copyright (C) 2019 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 - -// We include fmtlib here as an alias, since libbase will have fmtlib statically linked already. -// It is accessed through its normal fmt:: namespace. -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wshadow" -#include -#pragma clang diagnostic pop -#include -#include -#include -#include diff --git a/lib/include/android-base/logging.h b/lib/include/android-base/logging.h deleted file mode 100755 index 26827fb..0000000 --- a/lib/include/android-base/logging.h +++ /dev/null @@ -1,464 +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. - */ - -#pragma once - -// -// Google-style C++ logging. -// - -// This header provides a C++ stream interface to logging. -// -// To log: -// -// LOG(INFO) << "Some text; " << some_value; -// -// Replace `INFO` with any severity from `enum LogSeverity`. -// -// To log the result of a failed function and include the string -// representation of `errno` at the end: -// -// PLOG(ERROR) << "Write failed"; -// -// The output will be something like `Write failed: I/O error`. -// Remember this as 'P' as in perror(3). -// -// To output your own types, simply implement operator<< as normal. -// -// By default, output goes to logcat on Android and stderr on the host. -// A process can use `SetLogger` to decide where all logging goes. -// Implementations are provided for logcat, stderr, and dmesg. -// -// By default, the process' name is used as the log tag. -// Code can choose a specific log tag by defining LOG_TAG -// before including this header. - -// This header also provides assertions: -// -// CHECK(must_be_true); -// CHECK_EQ(a, b) << z_is_interesting_too; - -// NOTE: For Windows, you must include logging.h after windows.h to allow the -// following code to suppress the evil ERROR macro: -#ifdef _WIN32 -// windows.h includes wingdi.h which defines an evil macro ERROR. -#ifdef ERROR -#undef ERROR -#endif -#endif - -#include -#include -#include - -#include "android-base/errno_restorer.h" -#include "android-base/macros.h" - -// Note: DO NOT USE DIRECTLY. Use LOG_TAG instead. -#ifdef _LOG_TAG_INTERNAL -#error "_LOG_TAG_INTERNAL must not be defined" -#endif -#ifdef LOG_TAG -#define _LOG_TAG_INTERNAL LOG_TAG -#else -#define _LOG_TAG_INTERNAL nullptr -#endif - -namespace android { -namespace base { - -enum LogSeverity { - VERBOSE, - DEBUG, - INFO, - WARNING, - ERROR, - FATAL_WITHOUT_ABORT, // For loggability tests, this is considered identical to FATAL. - FATAL, -}; - -enum LogId { - DEFAULT, - MAIN, - SYSTEM, - RADIO, - CRASH, -}; - -using LogFunction = std::function; -using AbortFunction = std::function; - -// Loggers for use with InitLogging/SetLogger. - -// Log to the kernel log (dmesg). -void KernelLogger(LogId, LogSeverity, const char*, const char*, unsigned int, const char*); -// Log to stderr in the full logcat format (with pid/tid/time/tag details). -void StderrLogger(LogId, LogSeverity, const char*, const char*, unsigned int, const char*); -// Log just the message to stdout/stderr (without pid/tid/time/tag details). -// The choice of stdout versus stderr is based on the severity. -// Errors are also prefixed by the program name (as with err(3)/error(3)). -// Useful for replacing printf(3)/perror(3)/err(3)/error(3) in command-line tools. -void StdioLogger(LogId, LogSeverity, const char*, const char*, unsigned int, const char*); - -void DefaultAborter(const char* abort_message); - -void SetDefaultTag(const std::string& tag); - -// The LogdLogger sends chunks of up to ~4000 bytes at a time to logd. It does not prevent other -// threads from writing to logd between sending each chunk, so other threads may interleave their -// messages. If preventing interleaving is required, then a custom logger that takes a lock before -// calling this logger should be provided. -class LogdLogger { - public: - explicit LogdLogger(LogId default_log_id = android::base::MAIN); - - void operator()(LogId, LogSeverity, const char* tag, const char* file, - unsigned int line, const char* message); - - private: - LogId default_log_id_; -}; - -// Configure logging based on ANDROID_LOG_TAGS environment variable. -// We need to parse a string that looks like -// -// *:v jdwp:d dalvikvm:d dalvikvm-gc:i dalvikvmi:i -// -// The tag (or '*' for the global level) comes first, followed by a colon and a -// letter indicating the minimum priority level we're expected to log. This can -// be used to reveal or conceal logs with specific tags. -#ifdef __ANDROID__ -#define INIT_LOGGING_DEFAULT_LOGGER LogdLogger() -#else -#define INIT_LOGGING_DEFAULT_LOGGER StderrLogger -#endif -void InitLogging(char* argv[], - LogFunction&& logger = INIT_LOGGING_DEFAULT_LOGGER, - AbortFunction&& aborter = DefaultAborter); -#undef INIT_LOGGING_DEFAULT_LOGGER - -// Replace the current logger. -void SetLogger(LogFunction&& logger); - -// Replace the current aborter. -void SetAborter(AbortFunction&& aborter); - -// A helper macro that produces an expression that accepts both a qualified name and an -// unqualified name for a LogSeverity, and returns a LogSeverity value. -// Note: DO NOT USE DIRECTLY. This is an implementation detail. -#define SEVERITY_LAMBDA(severity) ([&]() { \ - using ::android::base::VERBOSE; \ - using ::android::base::DEBUG; \ - using ::android::base::INFO; \ - using ::android::base::WARNING; \ - using ::android::base::ERROR; \ - using ::android::base::FATAL_WITHOUT_ABORT; \ - using ::android::base::FATAL; \ - return (severity); }()) - -#ifdef __clang_analyzer__ -// Clang's static analyzer does not see the conditional statement inside -// LogMessage's destructor that will abort on FATAL severity. -#define ABORT_AFTER_LOG_FATAL for (;; abort()) - -struct LogAbortAfterFullExpr { - ~LogAbortAfterFullExpr() __attribute__((noreturn)) { abort(); } - explicit operator bool() const { return false; } -}; -// Provides an expression that evaluates to the truthiness of `x`, automatically -// aborting if `c` is true. -#define ABORT_AFTER_LOG_EXPR_IF(c, x) (((c) && ::android::base::LogAbortAfterFullExpr()) || (x)) -// Note to the static analyzer that we always execute FATAL logs in practice. -#define MUST_LOG_MESSAGE(severity) (SEVERITY_LAMBDA(severity) == ::android::base::FATAL) -#else -#define ABORT_AFTER_LOG_FATAL -#define ABORT_AFTER_LOG_EXPR_IF(c, x) (x) -#define MUST_LOG_MESSAGE(severity) false -#endif -#define ABORT_AFTER_LOG_FATAL_EXPR(x) ABORT_AFTER_LOG_EXPR_IF(true, x) - -// Defines whether the given severity will be logged or silently swallowed. -#define WOULD_LOG(severity) \ - (UNLIKELY(::android::base::ShouldLog(SEVERITY_LAMBDA(severity), _LOG_TAG_INTERNAL)) || \ - MUST_LOG_MESSAGE(severity)) - -// Get an ostream that can be used for logging at the given severity and to the default -// destination. -// -// Notes: -// 1) This will not check whether the severity is high enough. One should use WOULD_LOG to filter -// usage manually. -// 2) This does not save and restore errno. -#define LOG_STREAM(severity) \ - ::android::base::LogMessage(__FILE__, __LINE__, SEVERITY_LAMBDA(severity), _LOG_TAG_INTERNAL, \ - -1) \ - .stream() - -// Logs a message to logcat on Android otherwise to stderr. If the severity is -// FATAL it also causes an abort. For example: -// -// LOG(FATAL) << "We didn't expect to reach here"; -#define LOG(severity) LOGGING_PREAMBLE(severity) && LOG_STREAM(severity) - -// Checks if we want to log something, and sets up appropriate RAII objects if -// so. -// Note: DO NOT USE DIRECTLY. This is an implementation detail. -#define LOGGING_PREAMBLE(severity) \ - (WOULD_LOG(severity) && \ - ABORT_AFTER_LOG_EXPR_IF((SEVERITY_LAMBDA(severity)) == ::android::base::FATAL, true) && \ - ::android::base::ErrnoRestorer()) - -// A variant of LOG that also logs the current errno value. To be used when -// library calls fail. -#define PLOG(severity) \ - LOGGING_PREAMBLE(severity) && \ - ::android::base::LogMessage(__FILE__, __LINE__, SEVERITY_LAMBDA(severity), \ - _LOG_TAG_INTERNAL, errno) \ - .stream() - -// Marker that code is yet to be implemented. -#define UNIMPLEMENTED(level) \ - LOG(level) << __PRETTY_FUNCTION__ << " unimplemented " - -// Check whether condition x holds and LOG(FATAL) if not. The value of the -// expression x is only evaluated once. Extra logging can be appended using << -// after. For example: -// -// CHECK(false == true) results in a log message of -// "Check failed: false == true". -#define CHECK(x) \ - LIKELY((x)) || ABORT_AFTER_LOG_FATAL_EXPR(false) || \ - ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::FATAL, _LOG_TAG_INTERNAL, \ - -1) \ - .stream() \ - << "Check failed: " #x << " " - -// clang-format off -// Helper for CHECK_xx(x,y) macros. -#define CHECK_OP(LHS, RHS, OP) \ - for (auto _values = ::android::base::MakeEagerEvaluator(LHS, RHS); \ - UNLIKELY(!(_values.lhs OP _values.rhs)); \ - /* empty */) \ - ABORT_AFTER_LOG_FATAL \ - ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::FATAL, _LOG_TAG_INTERNAL, -1) \ - .stream() \ - << "Check failed: " << #LHS << " " << #OP << " " << #RHS << " (" #LHS "=" << _values.lhs \ - << ", " #RHS "=" << _values.rhs << ") " -// clang-format on - -// Check whether a condition holds between x and y, LOG(FATAL) if not. The value -// of the expressions x and y is evaluated once. Extra logging can be appended -// using << after. For example: -// -// CHECK_NE(0 == 1, false) results in -// "Check failed: false != false (0==1=false, false=false) ". -#define CHECK_EQ(x, y) CHECK_OP(x, y, == ) -#define CHECK_NE(x, y) CHECK_OP(x, y, != ) -#define CHECK_LE(x, y) CHECK_OP(x, y, <= ) -#define CHECK_LT(x, y) CHECK_OP(x, y, < ) -#define CHECK_GE(x, y) CHECK_OP(x, y, >= ) -#define CHECK_GT(x, y) CHECK_OP(x, y, > ) - -// clang-format off -// Helper for CHECK_STRxx(s1,s2) macros. -#define CHECK_STROP(s1, s2, sense) \ - while (UNLIKELY((strcmp(s1, s2) == 0) != (sense))) \ - ABORT_AFTER_LOG_FATAL \ - ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::FATAL, \ - _LOG_TAG_INTERNAL, -1) \ - .stream() \ - << "Check failed: " << "\"" << (s1) << "\"" \ - << ((sense) ? " == " : " != ") << "\"" << (s2) << "\"" -// clang-format on - -// Check for string (const char*) equality between s1 and s2, LOG(FATAL) if not. -#define CHECK_STREQ(s1, s2) CHECK_STROP(s1, s2, true) -#define CHECK_STRNE(s1, s2) CHECK_STROP(s1, s2, false) - -// Perform the pthread function call(args), LOG(FATAL) on error. -#define CHECK_PTHREAD_CALL(call, args, what) \ - do { \ - int rc = call args; \ - if (rc != 0) { \ - errno = rc; \ - ABORT_AFTER_LOG_FATAL \ - PLOG(FATAL) << #call << " failed for " << (what); \ - } \ - } while (false) - -// CHECK that can be used in a constexpr function. For example: -// -// constexpr int half(int n) { -// return -// DCHECK_CONSTEXPR(n >= 0, , 0) -// CHECK_CONSTEXPR((n & 1) == 0), -// << "Extra debugging output: n = " << n, 0) -// n / 2; -// } -#define CHECK_CONSTEXPR(x, out, dummy) \ - (UNLIKELY(!(x))) \ - ? (LOG(FATAL) << "Check failed: " << #x out, dummy) \ - : - -// DCHECKs are debug variants of CHECKs only enabled in debug builds. Generally -// CHECK should be used unless profiling identifies a CHECK as being in -// performance critical code. -#if defined(NDEBUG) && !defined(__clang_analyzer__) -static constexpr bool kEnableDChecks = false; -#else -static constexpr bool kEnableDChecks = true; -#endif - -#define DCHECK(x) \ - if (::android::base::kEnableDChecks) CHECK(x) -#define DCHECK_EQ(x, y) \ - if (::android::base::kEnableDChecks) CHECK_EQ(x, y) -#define DCHECK_NE(x, y) \ - if (::android::base::kEnableDChecks) CHECK_NE(x, y) -#define DCHECK_LE(x, y) \ - if (::android::base::kEnableDChecks) CHECK_LE(x, y) -#define DCHECK_LT(x, y) \ - if (::android::base::kEnableDChecks) CHECK_LT(x, y) -#define DCHECK_GE(x, y) \ - if (::android::base::kEnableDChecks) CHECK_GE(x, y) -#define DCHECK_GT(x, y) \ - if (::android::base::kEnableDChecks) CHECK_GT(x, y) -#define DCHECK_STREQ(s1, s2) \ - if (::android::base::kEnableDChecks) CHECK_STREQ(s1, s2) -#define DCHECK_STRNE(s1, s2) \ - if (::android::base::kEnableDChecks) CHECK_STRNE(s1, s2) -#if defined(NDEBUG) && !defined(__clang_analyzer__) -#define DCHECK_CONSTEXPR(x, out, dummy) -#else -#define DCHECK_CONSTEXPR(x, out, dummy) CHECK_CONSTEXPR(x, out, dummy) -#endif - -// Temporary class created to evaluate the LHS and RHS, used with -// MakeEagerEvaluator to infer the types of LHS and RHS. -template -struct EagerEvaluator { - constexpr EagerEvaluator(LHS l, RHS r) : lhs(l), rhs(r) { - } - LHS lhs; - RHS rhs; -}; - -// Helper function for CHECK_xx. -template -constexpr EagerEvaluator MakeEagerEvaluator(LHS lhs, RHS rhs) { - return EagerEvaluator(lhs, rhs); -} - -// Explicitly instantiate EagerEvalue for pointers so that char*s aren't treated -// as strings. To compare strings use CHECK_STREQ and CHECK_STRNE. We rely on -// signed/unsigned warnings to protect you against combinations not explicitly -// listed below. -#define EAGER_PTR_EVALUATOR(T1, T2) \ - template <> \ - struct EagerEvaluator { \ - EagerEvaluator(T1 l, T2 r) \ - : lhs(reinterpret_cast(l)), \ - rhs(reinterpret_cast(r)) { \ - } \ - const void* lhs; \ - const void* rhs; \ - } -EAGER_PTR_EVALUATOR(const char*, const char*); -EAGER_PTR_EVALUATOR(const char*, char*); -EAGER_PTR_EVALUATOR(char*, const char*); -EAGER_PTR_EVALUATOR(char*, char*); -EAGER_PTR_EVALUATOR(const unsigned char*, const unsigned char*); -EAGER_PTR_EVALUATOR(const unsigned char*, unsigned char*); -EAGER_PTR_EVALUATOR(unsigned char*, const unsigned char*); -EAGER_PTR_EVALUATOR(unsigned char*, unsigned char*); -EAGER_PTR_EVALUATOR(const signed char*, const signed char*); -EAGER_PTR_EVALUATOR(const signed char*, signed char*); -EAGER_PTR_EVALUATOR(signed char*, const signed char*); -EAGER_PTR_EVALUATOR(signed char*, signed char*); - -// Data for the log message, not stored in LogMessage to avoid increasing the -// stack size. -class LogMessageData; - -// A LogMessage is a temporarily scoped object used by LOG and the unlikely part -// of a CHECK. The destructor will abort if the severity is FATAL. -class LogMessage { - public: - // LogId has been deprecated, but this constructor must exist for prebuilts. - LogMessage(const char* file, unsigned int line, LogId, LogSeverity severity, const char* tag, - int error); - LogMessage(const char* file, unsigned int line, LogSeverity severity, const char* tag, int error); - - ~LogMessage(); - - // Returns the stream associated with the message, the LogMessage performs - // output when it goes out of scope. - std::ostream& stream(); - - // The routine that performs the actual logging. - static void LogLine(const char* file, unsigned int line, LogSeverity severity, const char* tag, - const char* msg); - - private: - const std::unique_ptr data_; - - DISALLOW_COPY_AND_ASSIGN(LogMessage); -}; - -// Get the minimum severity level for logging. -LogSeverity GetMinimumLogSeverity(); - -// Set the minimum severity level for logging, returning the old severity. -LogSeverity SetMinimumLogSeverity(LogSeverity new_severity); - -// Return whether or not a log message with the associated tag should be logged. -bool ShouldLog(LogSeverity severity, const char* tag); - -// Allows to temporarily change the minimum severity level for logging. -class ScopedLogSeverity { - public: - explicit ScopedLogSeverity(LogSeverity level); - ~ScopedLogSeverity(); - - private: - LogSeverity old_; -}; - -} // namespace base -} // namespace android - -namespace std { // NOLINT(cert-dcl58-cpp) - -// Emit a warning of ostream<< with std::string*. The intention was most likely to print *string. -// -// Note: for this to work, we need to have this in a namespace. -// Note: using a pragma because "-Wgcc-compat" (included in "-Weverything") complains about -// diagnose_if. -// Note: to print the pointer, use "<< static_cast(string_pointer)" instead. -// Note: a not-recommended alternative is to let Clang ignore the warning by adding -// -Wno-user-defined-warnings to CPPFLAGS. -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wgcc-compat" -#define OSTREAM_STRING_POINTER_USAGE_WARNING \ - __attribute__((diagnose_if(true, "Unexpected logging of string pointer", "warning"))) -inline OSTREAM_STRING_POINTER_USAGE_WARNING -std::ostream& operator<<(std::ostream& stream, const std::string* string_pointer) { - return stream << static_cast(string_pointer); -} -#pragma clang diagnostic pop - -} // namespace std diff --git a/lib/include/android-base/macros.h b/lib/include/android-base/macros.h deleted file mode 100755 index 5abf514..0000000 --- a/lib/include/android-base/macros.h +++ /dev/null @@ -1,150 +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. - */ - -#pragma once - -#include // for size_t -#include // for TEMP_FAILURE_RETRY - -#include - -// bionic and glibc both have TEMP_FAILURE_RETRY, but eg Mac OS' libc doesn't. -#ifndef TEMP_FAILURE_RETRY -#define TEMP_FAILURE_RETRY(exp) \ - ({ \ - decltype(exp) _rc; \ - do { \ - _rc = (exp); \ - } while (_rc == -1 && errno == EINTR); \ - _rc; \ - }) -#endif - -// A macro to disallow the copy constructor and operator= functions -// This must be placed in the private: declarations for a class. -// -// For disallowing only assign or copy, delete the relevant operator or -// constructor, for example: -// void operator=(const TypeName&) = delete; -// Note, that most uses of DISALLOW_ASSIGN and DISALLOW_COPY are broken -// semantically, one should either use disallow both or neither. Try to -// avoid these in new code. -#define DISALLOW_COPY_AND_ASSIGN(TypeName) \ - TypeName(const TypeName&) = delete; \ - void operator=(const TypeName&) = delete - -// A macro to disallow all the implicit constructors, namely the -// default constructor, copy constructor and operator= functions. -// -// This should be used in the private: declarations for a class -// that wants to prevent anyone from instantiating it. This is -// especially useful for classes containing only static methods. -#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \ - TypeName() = delete; \ - DISALLOW_COPY_AND_ASSIGN(TypeName) - -// The arraysize(arr) macro returns the # of elements in an array arr. -// The expression is a compile-time constant, and therefore can be -// used in defining new arrays, for example. If you use arraysize on -// a pointer by mistake, you will get a compile-time error. -// -// One caveat is that arraysize() doesn't accept any array of an -// anonymous type or a type defined inside a function. In these rare -// cases, you have to use the unsafe ARRAYSIZE_UNSAFE() macro below. This is -// due to a limitation in C++'s template system. The limitation might -// eventually be removed, but it hasn't happened yet. - -// This template function declaration is used in defining arraysize. -// Note that the function doesn't need an implementation, as we only -// use its type. -template -char(&ArraySizeHelper(T(&array)[N]))[N]; // NOLINT(readability/casting) - -#define arraysize(array) (sizeof(ArraySizeHelper(array))) - -#define SIZEOF_MEMBER(t, f) sizeof(std::declval().f) - -// Changing this definition will cause you a lot of pain. A majority of -// vendor code defines LIKELY and UNLIKELY this way, and includes -// this header through an indirect path. -#define LIKELY( exp ) (__builtin_expect( (exp) != 0, true )) -#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false )) - -#define WARN_UNUSED __attribute__((warn_unused_result)) - -// A deprecated function to call to create a false use of the parameter, for -// example: -// int foo(int x) { UNUSED(x); return 10; } -// to avoid compiler warnings. Going forward we prefer ATTRIBUTE_UNUSED. -template -void UNUSED(const T&...) { -} - -// An attribute to place on a parameter to a function, for example: -// int foo(int x ATTRIBUTE_UNUSED) { return 10; } -// to avoid compiler warnings. -#define ATTRIBUTE_UNUSED __attribute__((__unused__)) - -// The FALLTHROUGH_INTENDED macro can be used to annotate implicit fall-through -// between switch labels: -// switch (x) { -// case 40: -// case 41: -// if (truth_is_out_there) { -// ++x; -// FALLTHROUGH_INTENDED; // Use instead of/along with annotations in -// // comments. -// } else { -// return x; -// } -// case 42: -// ... -// -// As shown in the example above, the FALLTHROUGH_INTENDED macro should be -// followed by a semicolon. It is designed to mimic control-flow statements -// like 'break;', so it can be placed in most places where 'break;' can, but -// only if there are no statements on the execution path between it and the -// next switch label. -// -// When compiled with clang, the FALLTHROUGH_INTENDED macro is expanded to -// [[clang::fallthrough]] attribute, which is analysed when performing switch -// labels fall-through diagnostic ('-Wimplicit-fallthrough'). See clang -// documentation on language extensions for details: -// http://clang.llvm.org/docs/LanguageExtensions.html#clang__fallthrough -// -// When used with unsupported compilers, the FALLTHROUGH_INTENDED macro has no -// effect on diagnostics. -// -// In either case this macro has no effect on runtime behavior and performance -// of code. -#ifndef FALLTHROUGH_INTENDED -#define FALLTHROUGH_INTENDED [[clang::fallthrough]] // NOLINT -#endif - -// Current ABI string -#if defined(__arm__) -#define ABI_STRING "arm" -#elif defined(__aarch64__) -#define ABI_STRING "arm64" -#elif defined(__i386__) -#define ABI_STRING "x86" -#elif defined(__x86_64__) -#define ABI_STRING "x86_64" -#elif defined(__mips__) && !defined(__LP64__) -#define ABI_STRING "mips" -#elif defined(__mips__) && defined(__LP64__) -#define ABI_STRING "mips64" -#endif diff --git a/lib/include/android-base/mapped_file.h b/lib/include/android-base/mapped_file.h deleted file mode 100755 index 8c37f43..0000000 --- a/lib/include/android-base/mapped_file.h +++ /dev/null @@ -1,93 +0,0 @@ -/* - * Copyright (C) 2018 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 - -#include - -#include "android-base/macros.h" -#include "android-base/off64_t.h" -#include "android-base/unique_fd.h" - -#if defined(_WIN32) -#include -#define PROT_READ 1 -#define PROT_WRITE 2 -using os_handle = HANDLE; -#else -#include -using os_handle = int; -#endif - -namespace android { -namespace base { - -/** - * A region of a file mapped into memory (for grepping: also known as MmapFile or file mapping). - */ -class MappedFile { - public: - /** - * Creates a new mapping of the file pointed to by `fd`. Unlike the underlying OS primitives, - * `offset` does not need to be page-aligned. If `PROT_WRITE` is set in `prot`, the mapping - * will be writable, otherwise it will be read-only. Mappings are always `MAP_SHARED`. - */ - static std::unique_ptr FromFd(borrowed_fd fd, off64_t offset, size_t length, - int prot); - - /** - * Same thing, but using the raw OS file handle instead of a CRT wrapper. - */ - static std::unique_ptr FromOsHandle(os_handle h, off64_t offset, size_t length, - int prot); - - /** - * Removes the mapping. - */ - ~MappedFile(); - - /** - * Not copyable but movable. - */ - MappedFile(MappedFile&& other); - MappedFile& operator=(MappedFile&& other); - - char* data() const { return base_ + offset_; } - size_t size() const { return size_; } - - private: - DISALLOW_IMPLICIT_CONSTRUCTORS(MappedFile); - - void Close(); - - char* base_; - size_t size_; - - size_t offset_; - -#if defined(_WIN32) - MappedFile(char* base, size_t size, size_t offset, HANDLE handle) - : base_(base), size_(size), offset_(offset), handle_(handle) {} - HANDLE handle_; -#else - MappedFile(char* base, size_t size, size_t offset) : base_(base), size_(size), offset_(offset) {} -#endif -}; - -} // namespace base -} // namespace android diff --git a/lib/include/android-base/memory.h b/lib/include/android-base/memory.h deleted file mode 100755 index 0277a03..0000000 --- a/lib/include/android-base/memory.h +++ /dev/null @@ -1,38 +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. - */ - -#pragma once - -namespace android { -namespace base { - -// Use memcpy for access to unaligned data on targets with alignment -// restrictions. The compiler will generate appropriate code to access these -// structures without generating alignment exceptions. -template -static inline T get_unaligned(const void* address) { - T result; - memcpy(&result, address, sizeof(T)); - return result; -} - -template -static inline void put_unaligned(void* address, T v) { - memcpy(address, &v, sizeof(T)); -} - -} // namespace base -} // namespace android diff --git a/lib/include/android-base/no_destructor.h b/lib/include/android-base/no_destructor.h deleted file mode 100755 index ce0dc9f..0000000 --- a/lib/include/android-base/no_destructor.h +++ /dev/null @@ -1,94 +0,0 @@ -#pragma once - -/* - * Copyright (C) 2019 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. - */ - -#include - -#include "android-base/macros.h" - -namespace android { -namespace base { - -// A wrapper that makes it easy to create an object of type T with static -// storage duration that: -// - is only constructed on first access -// - never invokes the destructor -// in order to satisfy the styleguide ban on global constructors and -// destructors. -// -// Runtime constant example: -// const std::string& GetLineSeparator() { -// // Forwards to std::string(size_t, char, const Allocator&) constructor. -// static const base::NoDestructor s(5, '-'); -// return *s; -// } -// -// More complex initialization with a lambda: -// const std::string& GetSessionNonce() { -// static const base::NoDestructor nonce([] { -// std::string s(16); -// crypto::RandString(s.data(), s.size()); -// return s; -// }()); -// return *nonce; -// } -// -// NoDestructor stores the object inline, so it also avoids a pointer -// indirection and a malloc. Also note that since C++11 static local variable -// initialization is thread-safe and so is this pattern. Code should prefer to -// use NoDestructor over: -// - A function scoped static T* or T& that is dynamically initialized. -// - A global base::LazyInstance. -// -// Note that since the destructor is never run, this *will* leak memory if used -// as a stack or member variable. Furthermore, a NoDestructor should never -// have global scope as that may require a static initializer. -template -class NoDestructor { - public: - // Not constexpr; just write static constexpr T x = ...; if the value should - // be a constexpr. - template - explicit NoDestructor(Args&&... args) { - new (storage_) T(std::forward(args)...); - } - - // Allows copy and move construction of the contained type, to allow - // construction from an initializer list, e.g. for std::vector. - explicit NoDestructor(const T& x) { new (storage_) T(x); } - explicit NoDestructor(T&& x) { new (storage_) T(std::move(x)); } - - NoDestructor(const NoDestructor&) = delete; - NoDestructor& operator=(const NoDestructor&) = delete; - - ~NoDestructor() = default; - - const T& operator*() const { return *get(); } - T& operator*() { return *get(); } - - const T* operator->() const { return get(); } - T* operator->() { return get(); } - - const T* get() const { return reinterpret_cast(storage_); } - T* get() { return reinterpret_cast(storage_); } - - private: - alignas(T) char storage_[sizeof(T)]; -}; - -} // namespace base -} // namespace android diff --git a/lib/include/android-base/off64_t.h b/lib/include/android-base/off64_t.h deleted file mode 100755 index e6b71b8..0000000 --- a/lib/include/android-base/off64_t.h +++ /dev/null @@ -1,22 +0,0 @@ -/* - * Copyright (C) 2018 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 - -#if defined(__APPLE__) -/** Mac OS has always had a 64-bit off_t, so it doesn't have off64_t. */ -typedef off_t off64_t; -#endif diff --git a/lib/include/android-base/parsebool.h b/lib/include/android-base/parsebool.h deleted file mode 100755 index b2bd021..0000000 --- a/lib/include/android-base/parsebool.h +++ /dev/null @@ -1,58 +0,0 @@ -/* - * Copyright (C) 2019 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 - -namespace android { -namespace base { - -// Parse the given string as yes or no inactivation of some sort. Return one of the -// ParseBoolResult enumeration values. -// -// The following values parse as true: -// -// 1 -// on -// true -// y -// yes -// -// -// The following values parse as false: -// -// 0 -// false -// n -// no -// off -// -// Anything else is a parse error. -// -// The purpose of this function is to have a single canonical parser for yes-or-no indications -// throughout the system. - -enum class ParseBoolResult { - kError, - kFalse, - kTrue, -}; - -ParseBoolResult ParseBool(std::string_view s); - -} // namespace base -} // namespace android diff --git a/lib/include/android-base/parsedouble.h b/lib/include/android-base/parsedouble.h deleted file mode 100755 index ccffba2..0000000 --- a/lib/include/android-base/parsedouble.h +++ /dev/null @@ -1,77 +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. - */ - -#pragma once - -#include -#include - -#include -#include - -namespace android { -namespace base { - -// Parse floating value in the string 's' and sets 'out' to that value if it exists. -// Optionally allows the caller to define a 'min' and 'max' beyond which -// otherwise valid values will be rejected. Returns boolean success. -template -static inline bool ParseFloatingPoint(const char* s, T* out, T min, T max) { - errno = 0; - char* end; - T result = strtox(s, &end); - if (errno != 0 || s == end || *end != '\0') { - return false; - } - if (result < min || max < result) { - return false; - } - if (out != nullptr) { - *out = result; - } - return true; -} - -// Parse double value in the string 's' and sets 'out' to that value if it exists. -// Optionally allows the caller to define a 'min' and 'max' beyond which -// otherwise valid values will be rejected. Returns boolean success. -static inline bool ParseDouble(const char* s, double* out, - double min = std::numeric_limits::lowest(), - double max = std::numeric_limits::max()) { - return ParseFloatingPoint(s, out, min, max); -} -static inline bool ParseDouble(const std::string& s, double* out, - double min = std::numeric_limits::lowest(), - double max = std::numeric_limits::max()) { - return ParseFloatingPoint(s.c_str(), out, min, max); -} - -// Parse float value in the string 's' and sets 'out' to that value if it exists. -// Optionally allows the caller to define a 'min' and 'max' beyond which -// otherwise valid values will be rejected. Returns boolean success. -static inline bool ParseFloat(const char* s, float* out, - float min = std::numeric_limits::lowest(), - float max = std::numeric_limits::max()) { - return ParseFloatingPoint(s, out, min, max); -} -static inline bool ParseFloat(const std::string& s, float* out, - float min = std::numeric_limits::lowest(), - float max = std::numeric_limits::max()) { - return ParseFloatingPoint(s.c_str(), out, min, max); -} - -} // namespace base -} // namespace android diff --git a/lib/include/android-base/parseint.h b/lib/include/android-base/parseint.h deleted file mode 100755 index be8b97b..0000000 --- a/lib/include/android-base/parseint.h +++ /dev/null @@ -1,136 +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. - */ - -#pragma once - -#include -#include -#include - -#include -#include -#include - -namespace android { -namespace base { - -// Parses the unsigned decimal or hexadecimal integer in the string 's' and sets -// 'out' to that value if it is specified. Optionally allows the caller to define -// a 'max' beyond which otherwise valid values will be rejected. Returns boolean -// success; 'out' is untouched if parsing fails. -template -bool ParseUint(const char* s, T* out, T max = std::numeric_limits::max(), - bool allow_suffixes = false) { - static_assert(std::is_unsigned::value, "ParseUint can only be used with unsigned types"); - while (isspace(*s)) { - s++; - } - - if (s[0] == '-') { - errno = EINVAL; - return false; - } - - int base = (s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) ? 16 : 10; - errno = 0; - char* end; - unsigned long long int result = strtoull(s, &end, base); - if (errno != 0) return false; - if (end == s) { - errno = EINVAL; - return false; - } - if (*end != '\0') { - const char* suffixes = "bkmgtpe"; - const char* suffix; - if ((!allow_suffixes || (suffix = strchr(suffixes, tolower(*end))) == nullptr) || - __builtin_mul_overflow(result, 1ULL << (10 * (suffix - suffixes)), &result)) { - errno = EINVAL; - return false; - } - } - if (max < result) { - errno = ERANGE; - return false; - } - if (out != nullptr) { - *out = static_cast(result); - } - return true; -} - -// TODO: string_view -template -bool ParseUint(const std::string& s, T* out, T max = std::numeric_limits::max(), - bool allow_suffixes = false) { - return ParseUint(s.c_str(), out, max, allow_suffixes); -} - -template -bool ParseByteCount(const char* s, T* out, T max = std::numeric_limits::max()) { - return ParseUint(s, out, max, true); -} - -// TODO: string_view -template -bool ParseByteCount(const std::string& s, T* out, T max = std::numeric_limits::max()) { - return ParseByteCount(s.c_str(), out, max); -} - -// Parses the signed decimal or hexadecimal integer in the string 's' and sets -// 'out' to that value if it is specified. Optionally allows the caller to define -// a 'min' and 'max' beyond which otherwise valid values will be rejected. Returns -// boolean success; 'out' is untouched if parsing fails. -template -bool ParseInt(const char* s, T* out, - T min = std::numeric_limits::min(), - T max = std::numeric_limits::max()) { - static_assert(std::is_signed::value, "ParseInt can only be used with signed types"); - while (isspace(*s)) { - s++; - } - - int base = (s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) ? 16 : 10; - errno = 0; - char* end; - long long int result = strtoll(s, &end, base); - if (errno != 0) { - return false; - } - if (s == end || *end != '\0') { - errno = EINVAL; - return false; - } - if (result < min || max < result) { - errno = ERANGE; - return false; - } - if (out != nullptr) { - *out = static_cast(result); - } - return true; -} - -// TODO: string_view -template -bool ParseInt(const std::string& s, T* out, - T min = std::numeric_limits::min(), - T max = std::numeric_limits::max()) { - return ParseInt(s.c_str(), out, min, max); -} - -} // namespace base -} // namespace android diff --git a/lib/include/android-base/parsenetaddress.h b/lib/include/android-base/parsenetaddress.h deleted file mode 100755 index 47f8b5f..0000000 --- a/lib/include/android-base/parsenetaddress.h +++ /dev/null @@ -1,35 +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. - */ - -#pragma once - -#include - -namespace android { -namespace base { - -// Parses |address| into |host| and |port|. -// -// If |address| doesn't contain a port number, the default value is taken from -// |port|. If |canonical_address| is non-null it will be set to "host:port" or -// "[host]:port" as appropriate. -// -// On failure, returns false and fills |error|. -bool ParseNetAddress(const std::string& address, std::string* host, int* port, - std::string* canonical_address, std::string* error); - -} // namespace base -} // namespace android diff --git a/lib/include/android-base/process.h b/lib/include/android-base/process.h deleted file mode 100755 index 69ed3fb..0000000 --- a/lib/include/android-base/process.h +++ /dev/null @@ -1,60 +0,0 @@ -/* - * Copyright (C) 2019 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 -#include - -#include -#include -#include - -namespace android { -namespace base { - -class AllPids { - class PidIterator { - public: - PidIterator(DIR* dir) : dir_(dir, closedir) { Increment(); } - PidIterator& operator++() { - Increment(); - return *this; - } - bool operator==(const PidIterator& other) const { return pid_ == other.pid_; } - bool operator!=(const PidIterator& other) const { return !(*this == other); } - long operator*() const { return pid_; } - // iterator traits - using difference_type = pid_t; - using value_type = pid_t; - using pointer = const pid_t*; - using reference = const pid_t&; - using iterator_category = std::input_iterator_tag; - - private: - void Increment(); - - pid_t pid_ = -1; - std::unique_ptr dir_; - }; - - public: - PidIterator begin() { return opendir("/proc"); } - PidIterator end() { return nullptr; } -}; - -} // namespace base -} // namespace android diff --git a/lib/include/android-base/properties.h b/lib/include/android-base/properties.h deleted file mode 100755 index 49f1f31..0000000 --- a/lib/include/android-base/properties.h +++ /dev/null @@ -1,101 +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. - */ - -#pragma once - -#include - -#include -#include -#include -#include - -struct prop_info; - -namespace android { -namespace base { - -// Returns the current value of the system property `key`, -// or `default_value` if the property is empty or doesn't exist. -std::string GetProperty(const std::string& key, const std::string& default_value); - -// Returns true if the system property `key` has the value "1", "y", "yes", "on", or "true", -// false for "0", "n", "no", "off", or "false", or `default_value` otherwise. -bool GetBoolProperty(const std::string& key, bool default_value); - -// Returns the signed integer corresponding to the system property `key`. -// If the property is empty, doesn't exist, doesn't have an integer value, or is outside -// the optional bounds, returns `default_value`. -template T GetIntProperty(const std::string& key, - T default_value, - T min = std::numeric_limits::min(), - T max = std::numeric_limits::max()); - -// Returns the unsigned integer corresponding to the system property `key`. -// If the property is empty, doesn't exist, doesn't have an integer value, or is outside -// the optional bound, returns `default_value`. -template T GetUintProperty(const std::string& key, - T default_value, - T max = std::numeric_limits::max()); - -// Sets the system property `key` to `value`. -bool SetProperty(const std::string& key, const std::string& value); - -// Waits for the system property `key` to have the value `expected_value`. -// Times out after `relative_timeout`. -// Returns true on success, false on timeout. -#if defined(__BIONIC__) -bool WaitForProperty(const std::string& key, const std::string& expected_value, - std::chrono::milliseconds relative_timeout = std::chrono::milliseconds::max()); -#endif - -// Waits for the system property `key` to be created. -// Times out after `relative_timeout`. -// Returns true on success, false on timeout. -#if defined(__BIONIC__) -bool WaitForPropertyCreation(const std::string& key, std::chrono::milliseconds relative_timeout = - std::chrono::milliseconds::max()); -#endif - -#if defined(__BIONIC__) && __cplusplus >= 201703L -// Cached system property lookup. For code that needs to read the same property multiple times, -// this class helps optimize those lookups. -class CachedProperty { - public: - explicit CachedProperty(const char* property_name); - - // Returns the current value of the underlying system property as cheaply as possible. - // The returned pointer is valid until the next call to Get. Because most callers are going - // to want to parse the string returned here and cached that as well, this function performs - // no locking, and is completely thread unsafe. It is the caller's responsibility to provide a - // lock for thread-safety. - // - // Note: *changed can be set to true even if the contents of the property remain the same. - const char* Get(bool* changed = nullptr); - - private: - std::string property_name_; - const prop_info* prop_info_; - std::optional cached_area_serial_; - std::optional cached_property_serial_; - char cached_value_[92]; - bool is_read_only_; - const char* read_only_property_; -}; -#endif - -} // namespace base -} // namespace android diff --git a/lib/include/android-base/result.h b/lib/include/android-base/result.h deleted file mode 100755 index 56a4f3e..0000000 --- a/lib/include/android-base/result.h +++ /dev/null @@ -1,235 +0,0 @@ -/* - * Copyright (C) 2017 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. - */ - -// This file contains classes for returning a successful result along with an optional -// arbitrarily typed return value or for returning a failure result along with an optional string -// indicating why the function failed. - -// There are 3 classes that implement this functionality and one additional helper type. -// -// Result either contains a member of type T that can be accessed using similar semantics as -// std::optional or it contains a ResultError describing an error, which can be accessed via -// Result::error(). -// -// ResultError is a type that contains both a std::string describing the error and a copy of errno -// from when the error occurred. ResultError can be used in an ostream directly to print its -// string value. -// -// Result is the correct return type for a function that either returns successfully or -// returns an error value. Returning {} from a function that returns Result is the -// correct way to indicate that a function without a return type has completed successfully. -// -// A successful Result is constructed implicitly from any type that can be implicitly converted -// to T or from the constructor arguments for T. This allows you to return a type T directly from -// a function that returns Result. -// -// Error and ErrnoError are used to construct a Result that has failed. The Error class takes -// an ostream as an input and are implicitly cast to a Result containing that failure. -// ErrnoError() is a helper function to create an Error class that appends ": " + strerror(errno) -// to the end of the failure string to aid in interacting with C APIs. Alternatively, an errno -// value can be directly specified via the Error() constructor. -// -// Errorf and ErrnoErrorf accept the format string syntax of the fmblib (https://fmt.dev). -// Errorf("{} errors", num) is equivalent to Error() << num << " errors". -// -// ResultError can be used in the ostream and when using Error/Errorf to construct a Result. -// In this case, the string that the ResultError takes is passed through the stream normally, but -// the errno is passed to the Result. This can be used to pass errno from a failing C function up -// multiple callers. Note that when the outer Result is created with ErrnoError/ErrnoErrorf then -// the errno from the inner ResultError is not passed. Also when multiple ResultError objects are -// used, the errno of the last one is respected. -// -// ResultError can also directly construct a Result. This is particularly useful if you have a -// function that return Result but you have a Result and want to return its error. In this -// case, you can return the .error() from the Result to construct the Result. - -// An example of how to use these is below: -// Result CalculateResult(const T& input) { -// U output; -// if (!SomeOtherCppFunction(input, &output)) { -// return Errorf("SomeOtherCppFunction {} failed", input); -// } -// if (!c_api_function(output)) { -// return ErrnoErrorf("c_api_function {} failed", output); -// } -// return output; -// } -// -// auto output = CalculateResult(input); -// if (!output) return Error() << "CalculateResult failed: " << output.error(); -// UseOutput(*output); - -#pragma once - -#include - -#include -#include - -#include "android-base/expected.h" -#include "android-base/format.h" - -namespace android { -namespace base { - -struct ResultError { - template - ResultError(T&& message, int code) : message_(std::forward(message)), code_(code) {} - - template - // NOLINTNEXTLINE(google-explicit-constructor) - operator android::base::expected() { - return android::base::unexpected(ResultError(message_, code_)); - } - - std::string message() const { return message_; } - int code() const { return code_; } - - private: - std::string message_; - int code_; -}; - -inline bool operator==(const ResultError& lhs, const ResultError& rhs) { - return lhs.message() == rhs.message() && lhs.code() == rhs.code(); -} - -inline bool operator!=(const ResultError& lhs, const ResultError& rhs) { - return !(lhs == rhs); -} - -inline std::ostream& operator<<(std::ostream& os, const ResultError& t) { - os << t.message(); - return os; -} - -class Error { - public: - Error() : errno_(0), append_errno_(false) {} - // NOLINTNEXTLINE(google-explicit-constructor) - Error(int errno_to_append) : errno_(errno_to_append), append_errno_(true) {} - - template - // NOLINTNEXTLINE(google-explicit-constructor) - operator android::base::expected() { - return android::base::unexpected(ResultError(str(), errno_)); - } - - template - Error& operator<<(T&& t) { - // NOLINTNEXTLINE(bugprone-suspicious-semicolon) - if constexpr (std::is_same_v>, ResultError>) { - errno_ = t.code(); - return (*this) << t.message(); - } - int saved = errno; - ss_ << t; - errno = saved; - return *this; - } - - const std::string str() const { - std::string str = ss_.str(); - if (append_errno_) { - if (str.empty()) { - return strerror(errno_); - } - return std::move(str) + ": " + strerror(errno_); - } - return str; - } - - Error(const Error&) = delete; - Error(Error&&) = delete; - Error& operator=(const Error&) = delete; - Error& operator=(Error&&) = delete; - - template - friend Error ErrorfImpl(const T&& fmt, const Args&... args); - - template - friend Error ErrnoErrorfImpl(const T&& fmt, const Args&... args); - - private: - Error(bool append_errno, int errno_to_append, const std::string& message) - : errno_(errno_to_append), append_errno_(append_errno) { - (*this) << message; - } - - std::stringstream ss_; - int errno_; - const bool append_errno_; -}; - -inline Error ErrnoError() { - return Error(errno); -} - -inline int ErrorCode(int code) { - return code; -} - -// Return the error code of the last ResultError object, if any. -// Otherwise, return `code` as it is. -template -inline int ErrorCode(int code, T&& t, const Args&... args) { - if constexpr (std::is_same_v>, ResultError>) { - return ErrorCode(t.code(), args...); - } - return ErrorCode(code, args...); -} - -template -inline Error ErrorfImpl(const T&& fmt, const Args&... args) { - return Error(false, ErrorCode(0, args...), fmt::format(fmt, args...)); -} - -template -inline Error ErrnoErrorfImpl(const T&& fmt, const Args&... args) { - return Error(true, errno, fmt::format(fmt, args...)); -} - -#define Errorf(fmt, ...) android::base::ErrorfImpl(FMT_STRING(fmt), ##__VA_ARGS__) -#define ErrnoErrorf(fmt, ...) android::base::ErrnoErrorfImpl(FMT_STRING(fmt), ##__VA_ARGS__) - -template -using Result = android::base::expected; - -// Macros for testing the results of functions that return android::base::Result. -// These also work with base::android::expected. - -#define CHECK_RESULT_OK(stmt) \ - do { \ - const auto& tmp = (stmt); \ - CHECK(tmp.ok()) << tmp.error(); \ - } while (0) - -#define ASSERT_RESULT_OK(stmt) \ - do { \ - const auto& tmp = (stmt); \ - ASSERT_TRUE(tmp.ok()) << tmp.error(); \ - } while (0) - -#define EXPECT_RESULT_OK(stmt) \ - do { \ - auto tmp = (stmt); \ - EXPECT_TRUE(tmp.ok()) << tmp.error(); \ - } while (0) - -// TODO: Maybe add RETURN_IF_ERROR() and ASSIGN_OR_RETURN() - -} // namespace base -} // namespace android diff --git a/lib/include/android-base/scopeguard.h b/lib/include/android-base/scopeguard.h deleted file mode 100755 index 5a224d6..0000000 --- a/lib/include/android-base/scopeguard.h +++ /dev/null @@ -1,67 +0,0 @@ -/* - * Copyright (C) 2014 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 // for std::move, std::forward - -namespace android { -namespace base { - -// ScopeGuard ensures that the specified functor is executed no matter how the -// current scope exits. -template -class ScopeGuard { - public: - ScopeGuard(F&& f) : f_(std::forward(f)), active_(true) {} - - ScopeGuard(ScopeGuard&& that) noexcept : f_(std::move(that.f_)), active_(that.active_) { - that.active_ = false; - } - - template - ScopeGuard(ScopeGuard&& that) : f_(std::move(that.f_)), active_(that.active_) { - that.active_ = false; - } - - ~ScopeGuard() { - if (active_) f_(); - } - - ScopeGuard() = delete; - ScopeGuard(const ScopeGuard&) = delete; - void operator=(const ScopeGuard&) = delete; - void operator=(ScopeGuard&& that) = delete; - - void Disable() { active_ = false; } - - bool active() const { return active_; } - - private: - template - friend class ScopeGuard; - - F f_; - bool active_; -}; - -template -ScopeGuard make_scope_guard(F&& f) { - return ScopeGuard(std::forward(f)); -} - -} // namespace base -} // namespace android diff --git a/lib/include/android-base/stringprintf.h b/lib/include/android-base/stringprintf.h deleted file mode 100755 index 93c56af..0000000 --- a/lib/include/android-base/stringprintf.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - * Copyright (C) 2011 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 -#include - -namespace android { -namespace base { - -// These printf-like functions are implemented in terms of vsnprintf, so they -// use the same attribute for compile-time format string checking. - -// Returns a string corresponding to printf-like formatting of the arguments. -std::string StringPrintf(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2))); - -// Appends a printf-like formatting of the arguments to 'dst'. -void StringAppendF(std::string* dst, const char* fmt, ...) - __attribute__((__format__(__printf__, 2, 3))); - -// Appends a printf-like formatting of the arguments to 'dst'. -void StringAppendV(std::string* dst, const char* format, va_list ap) - __attribute__((__format__(__printf__, 2, 0))); - -} // namespace base -} // namespace android diff --git a/lib/include/android-base/strings.h b/lib/include/android-base/strings.h deleted file mode 100755 index 14d534a..0000000 --- a/lib/include/android-base/strings.h +++ /dev/null @@ -1,94 +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. - */ - -#pragma once - -#include -#include -#include -#include - -namespace android { -namespace base { - -// Splits a string into a vector of strings. -// -// The string is split at each occurrence of a character in delimiters. -// -// The empty string is not a valid delimiter list. -std::vector Split(const std::string& s, - const std::string& delimiters); - -// Trims whitespace off both ends of the given string. -std::string Trim(const std::string& s); - -// Joins a container of things into a single string, using the given separator. -template -std::string Join(const ContainerT& things, SeparatorT separator) { - if (things.empty()) { - return ""; - } - - std::ostringstream result; - result << *things.begin(); - for (auto it = std::next(things.begin()); it != things.end(); ++it) { - result << separator << *it; - } - return result.str(); -} - -// We instantiate the common cases in strings.cpp. -extern template std::string Join(const std::vector&, char); -extern template std::string Join(const std::vector&, char); -extern template std::string Join(const std::vector&, const std::string&); -extern template std::string Join(const std::vector&, const std::string&); - -// Tests whether 's' starts with 'prefix'. -bool StartsWith(std::string_view s, std::string_view prefix); -bool StartsWith(std::string_view s, char prefix); -bool StartsWithIgnoreCase(std::string_view s, std::string_view prefix); - -// Tests whether 's' ends with 'suffix'. -bool EndsWith(std::string_view s, std::string_view suffix); -bool EndsWith(std::string_view s, char suffix); -bool EndsWithIgnoreCase(std::string_view s, std::string_view suffix); - -// Tests whether 'lhs' equals 'rhs', ignoring case. -bool EqualsIgnoreCase(std::string_view lhs, std::string_view rhs); - -// Removes `prefix` from the start of the given string and returns true (if -// it was present), false otherwise. -inline bool ConsumePrefix(std::string_view* s, std::string_view prefix) { - if (!StartsWith(*s, prefix)) return false; - s->remove_prefix(prefix.size()); - return true; -} - -// Removes `suffix` from the end of the given string and returns true (if -// it was present), false otherwise. -inline bool ConsumeSuffix(std::string_view* s, std::string_view suffix) { - if (!EndsWith(*s, suffix)) return false; - s->remove_suffix(suffix.size()); - return true; -} - -// Replaces `from` with `to` in `s`, once if `all == false`, or as many times as -// there are matches if `all == true`. -[[nodiscard]] std::string StringReplace(std::string_view s, std::string_view from, - std::string_view to, bool all); - -} // namespace base -} // namespace android diff --git a/lib/include/android-base/test_utils.h b/lib/include/android-base/test_utils.h deleted file mode 100755 index f3d7cb0..0000000 --- a/lib/include/android-base/test_utils.h +++ /dev/null @@ -1,86 +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. - */ - -#pragma once - -#include -#include - -#include -#include - -class CapturedStdFd { - public: - CapturedStdFd(int std_fd); - ~CapturedStdFd(); - - std::string str(); - - void Start(); - void Stop(); - void Reset(); - - private: - int fd() const; - - TemporaryFile temp_file_; - int std_fd_; - int old_fd_ = -1; - - DISALLOW_COPY_AND_ASSIGN(CapturedStdFd); -}; - -class CapturedStderr : public CapturedStdFd { - public: - CapturedStderr() : CapturedStdFd(STDERR_FILENO) {} -}; - -class CapturedStdout : public CapturedStdFd { - public: - CapturedStdout() : CapturedStdFd(STDOUT_FILENO) {} -}; - -#define ASSERT_MATCH(str, pattern) \ - do { \ - auto __s = (str); \ - if (!std::regex_search(__s, std::regex((pattern)))) { \ - FAIL() << "regex mismatch: expected " << (pattern) << " in:\n" << __s; \ - } \ - } while (0) - -#define ASSERT_NOT_MATCH(str, pattern) \ - do { \ - auto __s = (str); \ - if (std::regex_search(__s, std::regex((pattern)))) { \ - FAIL() << "regex mismatch: expected to not find " << (pattern) << " in:\n" << __s; \ - } \ - } while (0) - -#define EXPECT_MATCH(str, pattern) \ - do { \ - auto __s = (str); \ - if (!std::regex_search(__s, std::regex((pattern)))) { \ - ADD_FAILURE() << "regex mismatch: expected " << (pattern) << " in:\n" << __s; \ - } \ - } while (0) - -#define EXPECT_NOT_MATCH(str, pattern) \ - do { \ - auto __s = (str); \ - if (std::regex_search(__s, std::regex((pattern)))) { \ - ADD_FAILURE() << "regex mismatch: expected to not find " << (pattern) << " in:\n" << __s; \ - } \ - } while (0) diff --git a/lib/include/android-base/thread_annotations.h b/lib/include/android-base/thread_annotations.h deleted file mode 100755 index 53fe6da..0000000 --- a/lib/include/android-base/thread_annotations.h +++ /dev/null @@ -1,144 +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. - */ - -#pragma once - -#include - -#define THREAD_ANNOTATION_ATTRIBUTE__(x) __attribute__((x)) - -#define CAPABILITY(x) \ - THREAD_ANNOTATION_ATTRIBUTE__(capability(x)) - -#define SCOPED_CAPABILITY \ - THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable) - -#define SHARED_CAPABILITY(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(shared_capability(__VA_ARGS__)) - -#define GUARDED_BY(x) \ - THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x)) - -#define PT_GUARDED_BY(x) \ - THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x)) - -#define EXCLUSIVE_LOCKS_REQUIRED(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__)) - -#define SHARED_LOCKS_REQUIRED(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__)) - -#define ACQUIRED_BEFORE(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__)) - -#define ACQUIRED_AFTER(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__)) - -#define REQUIRES(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(requires_capability(__VA_ARGS__)) - -#define REQUIRES_SHARED(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(requires_shared_capability(__VA_ARGS__)) - -#define ACQUIRE(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(acquire_capability(__VA_ARGS__)) - -#define ACQUIRE_SHARED(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(acquire_shared_capability(__VA_ARGS__)) - -#define RELEASE(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(release_capability(__VA_ARGS__)) - -#define RELEASE_SHARED(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(release_shared_capability(__VA_ARGS__)) - -#define TRY_ACQUIRE(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_capability(__VA_ARGS__)) - -#define TRY_ACQUIRE_SHARED(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_shared_capability(__VA_ARGS__)) - -#define EXCLUDES(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__)) - -#define ASSERT_CAPABILITY(x) \ - THREAD_ANNOTATION_ATTRIBUTE__(assert_capability(x)) - -#define ASSERT_SHARED_CAPABILITY(x) \ - THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_capability(x)) - -#define RETURN_CAPABILITY(x) \ - THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x)) - -#define EXCLUSIVE_LOCK_FUNCTION(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__)) - -#define EXCLUSIVE_TRYLOCK_FUNCTION(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__)) - -#define SHARED_LOCK_FUNCTION(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__)) - -#define SHARED_TRYLOCK_FUNCTION(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__)) - -#define UNLOCK_FUNCTION(...) \ - THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__)) - -#define SCOPED_LOCKABLE \ - THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable) - -#define LOCK_RETURNED(x) \ - THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x)) - -#define NO_THREAD_SAFETY_ANALYSIS \ - THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis) - -namespace android { -namespace base { - -// A class to help thread safety analysis deal with std::unique_lock and condition_variable. -// -// Clang's thread safety analysis currently doesn't perform alias analysis, so movable types -// like std::unique_lock can't be marked with thread safety annotations. This helper allows -// for manual assertion of lock state in a scope. -// -// For example: -// -// std::mutex mutex; -// std::condition_variable cv; -// std::vector vec GUARDED_BY(mutex); -// -// int pop() { -// std::unique_lock lock(mutex); -// ScopedLockAssertion lock_assertion(mutex); -// cv.wait(lock, []() { -// ScopedLockAssertion lock_assertion(mutex); -// return !vec.empty(); -// }); -// -// int result = vec.back(); -// vec.pop_back(); -// return result; -// } -class SCOPED_CAPABILITY ScopedLockAssertion { - public: - ScopedLockAssertion(std::mutex& mutex) ACQUIRE(mutex) {} - ~ScopedLockAssertion() RELEASE() {} -}; - -} // namespace base -} // namespace android diff --git a/lib/include/android-base/threads.h b/lib/include/android-base/threads.h deleted file mode 100755 index dba1fc6..0000000 --- a/lib/include/android-base/threads.h +++ /dev/null @@ -1,30 +0,0 @@ -/* - * Copyright (C) 2018 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 - -namespace android { -namespace base { -uint64_t GetThreadId(); -} -} // namespace android - -#if defined(__GLIBC__) -// bionic has this Linux-specifix call, but glibc doesn't. -extern "C" int tgkill(int tgid, int tid, int sig); -#endif diff --git a/lib/include/android-base/unique_fd.h b/lib/include/android-base/unique_fd.h deleted file mode 100755 index c4a0aad..0000000 --- a/lib/include/android-base/unique_fd.h +++ /dev/null @@ -1,293 +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. - */ - -#pragma once - -#include -#include -#include - -#if !defined(_WIN32) -#include -#endif - -#include -#include -#include - -// DO NOT INCLUDE OTHER LIBBASE HEADERS! -// This file gets used in libbinder, and libbinder is used everywhere. -// Including other headers from libbase frequently results in inclusion of -// android-base/macros.h, which causes macro collisions. - -// Container for a file descriptor that automatically closes the descriptor as -// it goes out of scope. -// -// unique_fd ufd(open("/some/path", "r")); -// if (ufd.get() == -1) return error; -// -// // Do something useful, possibly including 'return'. -// -// return 0; // Descriptor is closed for you. -// -// unique_fd is also known as ScopedFd/ScopedFD/scoped_fd; mentioned here to help -// you find this class if you're searching for one of those names. - -#if defined(__BIONIC__) -#include -#endif - -namespace android { -namespace base { - -struct DefaultCloser { -#if defined(__BIONIC__) - static void Tag(int fd, void* old_addr, void* new_addr) { - if (android_fdsan_exchange_owner_tag) { - uint64_t old_tag = android_fdsan_create_owner_tag(ANDROID_FDSAN_OWNER_TYPE_UNIQUE_FD, - reinterpret_cast(old_addr)); - uint64_t new_tag = android_fdsan_create_owner_tag(ANDROID_FDSAN_OWNER_TYPE_UNIQUE_FD, - reinterpret_cast(new_addr)); - android_fdsan_exchange_owner_tag(fd, old_tag, new_tag); - } - } - static void Close(int fd, void* addr) { - if (android_fdsan_close_with_tag) { - uint64_t tag = android_fdsan_create_owner_tag(ANDROID_FDSAN_OWNER_TYPE_UNIQUE_FD, - reinterpret_cast(addr)); - android_fdsan_close_with_tag(fd, tag); - } else { - close(fd); - } - } -#else - static void Close(int fd) { - // Even if close(2) fails with EINTR, the fd will have been closed. - // Using TEMP_FAILURE_RETRY will either lead to EBADF or closing someone - // else's fd. - // http://lkml.indiana.edu/hypermail/linux/kernel/0509.1/0877.html - ::close(fd); - } -#endif -}; - -template -class unique_fd_impl final { - public: - unique_fd_impl() {} - - explicit unique_fd_impl(int fd) { reset(fd); } - ~unique_fd_impl() { reset(); } - - unique_fd_impl(const unique_fd_impl&) = delete; - void operator=(const unique_fd_impl&) = delete; - unique_fd_impl(unique_fd_impl&& other) noexcept { reset(other.release()); } - unique_fd_impl& operator=(unique_fd_impl&& s) noexcept { - int fd = s.fd_; - s.fd_ = -1; - reset(fd, &s); - return *this; - } - - void reset(int new_value = -1) { reset(new_value, nullptr); } - - int get() const { return fd_; } - -#if !defined(ANDROID_BASE_UNIQUE_FD_DISABLE_IMPLICIT_CONVERSION) - // unique_fd's operator int is dangerous, but we have way too much code that - // depends on it, so make this opt-in at first. - operator int() const { return get(); } // NOLINT -#endif - - bool operator>=(int rhs) const { return get() >= rhs; } - bool operator<(int rhs) const { return get() < rhs; } - bool operator==(int rhs) const { return get() == rhs; } - bool operator!=(int rhs) const { return get() != rhs; } - bool operator==(const unique_fd_impl& rhs) const { return get() == rhs.get(); } - bool operator!=(const unique_fd_impl& rhs) const { return get() != rhs.get(); } - - // Catch bogus error checks (i.e.: "!fd" instead of "fd != -1"). - bool operator!() const = delete; - - bool ok() const { return get() >= 0; } - - int release() __attribute__((warn_unused_result)) { - tag(fd_, this, nullptr); - int ret = fd_; - fd_ = -1; - return ret; - } - - private: - void reset(int new_value, void* previous_tag) { - int previous_errno = errno; - - if (fd_ != -1) { - close(fd_, this); - } - - fd_ = new_value; - if (new_value != -1) { - tag(new_value, previous_tag, this); - } - - errno = previous_errno; - } - - int fd_ = -1; - - // Template magic to use Closer::Tag if available, and do nothing if not. - // If Closer::Tag exists, this implementation is preferred, because int is a better match. - // If not, this implementation is SFINAEd away, and the no-op below is the only one that exists. - template - static auto tag(int fd, void* old_tag, void* new_tag) - -> decltype(T::Tag(fd, old_tag, new_tag), void()) { - T::Tag(fd, old_tag, new_tag); - } - - template - static void tag(long, void*, void*) { - // No-op. - } - - // Same as above, to select between Closer::Close(int) and Closer::Close(int, void*). - template - static auto close(int fd, void* tag_value) -> decltype(T::Close(fd, tag_value), void()) { - T::Close(fd, tag_value); - } - - template - static auto close(int fd, void*) -> decltype(T::Close(fd), void()) { - T::Close(fd); - } -}; - -using unique_fd = unique_fd_impl; - -#if !defined(_WIN32) - -// Inline functions, so that they can be used header-only. -template -inline bool Pipe(unique_fd_impl* read, unique_fd_impl* write, - int flags = O_CLOEXEC) { - int pipefd[2]; - -#if defined(__linux__) - if (pipe2(pipefd, flags) != 0) { - return false; - } -#else // defined(__APPLE__) - if (flags & ~(O_CLOEXEC | O_NONBLOCK)) { - return false; - } - if (pipe(pipefd) != 0) { - return false; - } - - if (flags & O_CLOEXEC) { - if (fcntl(pipefd[0], F_SETFD, FD_CLOEXEC) != 0 || fcntl(pipefd[1], F_SETFD, FD_CLOEXEC) != 0) { - close(pipefd[0]); - close(pipefd[1]); - return false; - } - } - if (flags & O_NONBLOCK) { - if (fcntl(pipefd[0], F_SETFL, O_NONBLOCK) != 0 || fcntl(pipefd[1], F_SETFL, O_NONBLOCK) != 0) { - close(pipefd[0]); - close(pipefd[1]); - return false; - } - } -#endif - - read->reset(pipefd[0]); - write->reset(pipefd[1]); - return true; -} - -template -inline bool Socketpair(int domain, int type, int protocol, unique_fd_impl* left, - unique_fd_impl* right) { - int sockfd[2]; - if (socketpair(domain, type, protocol, sockfd) != 0) { - return false; - } - left->reset(sockfd[0]); - right->reset(sockfd[1]); - return true; -} - -template -inline bool Socketpair(int type, unique_fd_impl* left, unique_fd_impl* right) { - return Socketpair(AF_UNIX, type, 0, left, right); -} - -// Using fdopen with unique_fd correctly is more annoying than it should be, -// because fdopen doesn't close the file descriptor received upon failure. -inline FILE* Fdopen(unique_fd&& ufd, const char* mode) { - int fd = ufd.release(); - FILE* file = fdopen(fd, mode); - if (!file) { - close(fd); - } - return file; -} - -// Using fdopendir with unique_fd correctly is more annoying than it should be, -// because fdopen doesn't close the file descriptor received upon failure. -inline DIR* Fdopendir(unique_fd&& ufd) { - int fd = ufd.release(); - DIR* dir = fdopendir(fd); - if (dir == nullptr) { - close(fd); - } - return dir; -} - -#endif // !defined(_WIN32) - -// A wrapper type that can be implicitly constructed from either int or unique_fd. -struct borrowed_fd { - /* implicit */ borrowed_fd(int fd) : fd_(fd) {} // NOLINT - template - /* implicit */ borrowed_fd(const unique_fd_impl& ufd) : fd_(ufd.get()) {} // NOLINT - - int get() const { return fd_; } - - bool operator>=(int rhs) const { return get() >= rhs; } - bool operator<(int rhs) const { return get() < rhs; } - bool operator==(int rhs) const { return get() == rhs; } - bool operator!=(int rhs) const { return get() != rhs; } - - private: - int fd_ = -1; -}; -} // namespace base -} // namespace android - -template -int close(const android::base::unique_fd_impl&) - __attribute__((__unavailable__("close called on unique_fd"))); - -template -FILE* fdopen(const android::base::unique_fd_impl&, const char* mode) - __attribute__((__unavailable__("fdopen takes ownership of the fd passed in; either dup the " - "unique_fd, or use android::base::Fdopen to pass ownership"))); - -template -DIR* fdopendir(const android::base::unique_fd_impl&) __attribute__(( - __unavailable__("fdopendir takes ownership of the fd passed in; either dup the " - "unique_fd, or use android::base::Fdopendir to pass ownership"))); diff --git a/lib/include/android-base/utf8.h b/lib/include/android-base/utf8.h deleted file mode 100755 index 1a414ec..0000000 --- a/lib/include/android-base/utf8.h +++ /dev/null @@ -1,104 +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. - */ - -#pragma once - -#ifdef _WIN32 -#include -#include -#else -// Bring in prototypes for standard APIs so that we can import them into the utf8 namespace. -#include // open -#include // fopen -#include // mkdir -#include // unlink -#endif - -namespace android { -namespace base { - -// Only available on Windows because this is only needed on Windows. -#ifdef _WIN32 -// Convert size number of UTF-16 wchar_t's to UTF-8. Returns whether the -// conversion was done successfully. -bool WideToUTF8(const wchar_t* utf16, const size_t size, std::string* utf8); - -// Convert a NULL-terminated string of UTF-16 characters to UTF-8. Returns -// whether the conversion was done successfully. -bool WideToUTF8(const wchar_t* utf16, std::string* utf8); - -// Convert a UTF-16 std::wstring (including any embedded NULL characters) to -// UTF-8. Returns whether the conversion was done successfully. -bool WideToUTF8(const std::wstring& utf16, std::string* utf8); - -// Convert size number of UTF-8 char's to UTF-16. Returns whether the conversion -// was done successfully. -bool UTF8ToWide(const char* utf8, const size_t size, std::wstring* utf16); - -// Convert a NULL-terminated string of UTF-8 characters to UTF-16. Returns -// whether the conversion was done successfully. -bool UTF8ToWide(const char* utf8, std::wstring* utf16); - -// Convert a UTF-8 std::string (including any embedded NULL characters) to -// UTF-16. Returns whether the conversion was done successfully. -bool UTF8ToWide(const std::string& utf8, std::wstring* utf16); - -// Convert a file system path, represented as a NULL-terminated string of -// UTF-8 characters, to a UTF-16 string representing the same file system -// path using the Windows extended-lengh path representation. -// -// See https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx#MAXPATH: -// ```The Windows API has many functions that also have Unicode versions to -// permit an extended-length path for a maximum total path length of 32,767 -// characters. To specify an extended-length path, use the "\\?\" prefix. -// For example, "\\?\D:\very long path".``` -// -// Returns whether the conversion was done successfully. -bool UTF8PathToWindowsLongPath(const char* utf8, std::wstring* utf16); -#endif - -// The functions in the utf8 namespace take UTF-8 strings. For Windows, these -// are wrappers, for non-Windows these just expose existing APIs. To call these -// functions, use: -// -// // anonymous namespace to avoid conflict with existing open(), unlink(), etc. -// namespace { -// // Import functions into anonymous namespace. -// using namespace android::base::utf8; -// -// void SomeFunction(const char* name) { -// int fd = open(name, ...); // Calls android::base::utf8::open(). -// ... -// unlink(name); // Calls android::base::utf8::unlink(). -// } -// } -namespace utf8 { - -#ifdef _WIN32 -FILE* fopen(const char* name, const char* mode); -int mkdir(const char* name, mode_t mode); -int open(const char* name, int flags, ...); -int unlink(const char* name); -#else -using ::fopen; -using ::mkdir; -using ::open; -using ::unlink; -#endif - -} // namespace utf8 -} // namespace base -} // namespace android diff --git a/lib/include/android/log.h b/lib/include/android/log.h deleted file mode 120000 index 736c448..0000000 --- a/lib/include/android/log.h +++ /dev/null @@ -1 +0,0 @@ -../../liblog/include/android/log.h \ No newline at end of file diff --git a/lib/include/log b/lib/include/log index 714065f..99656e0 120000 --- a/lib/include/log +++ b/lib/include/log @@ -1 +1 @@ -../liblog/include/log \ No newline at end of file +../liblog/include/log/ \ No newline at end of file diff --git a/lib/include/private b/lib/include/private new file mode 120000 index 0000000..88d73d2 --- /dev/null +++ b/lib/include/private @@ -0,0 +1 @@ +../libcutils/include/private/ \ No newline at end of file diff --git a/lib/include/private/android_filesystem_capability.h b/lib/include/private/android_filesystem_capability.h deleted file mode 120000 index f310b35..0000000 --- a/lib/include/private/android_filesystem_capability.h +++ /dev/null @@ -1 +0,0 @@ -../../libcutils/include/private/android_filesystem_capability.h \ No newline at end of file diff --git a/lib/include/private/android_filesystem_config.h b/lib/include/private/android_filesystem_config.h deleted file mode 120000 index f28a564..0000000 --- a/lib/include/private/android_filesystem_config.h +++ /dev/null @@ -1 +0,0 @@ -../../libcutils/include/private/android_filesystem_config.h \ No newline at end of file diff --git a/lib/include/private/android_logger.h b/lib/include/private/android_logger.h deleted file mode 120000 index f187a6d..0000000 --- a/lib/include/private/android_logger.h +++ /dev/null @@ -1 +0,0 @@ -../../liblog/include/private/android_logger.h \ No newline at end of file diff --git a/lib/include/private/canned_fs_config.h b/lib/include/private/canned_fs_config.h deleted file mode 120000 index 8f92b2d..0000000 --- a/lib/include/private/canned_fs_config.h +++ /dev/null @@ -1 +0,0 @@ -../../libcutils/include/private/canned_fs_config.h \ No newline at end of file diff --git a/lib/include/private/fs_config.h b/lib/include/private/fs_config.h deleted file mode 100644 index e9868a4..0000000 --- a/lib/include/private/fs_config.h +++ /dev/null @@ -1,4 +0,0 @@ -// TODO(b/63135587) remove this file after the transitive dependency -// from private/android_filesystem_config.h is resolved. All files that use -// libcutils/include/private/fs_config.h should include the file directly, not -// indirectly via private/android_filesystem_config.h. diff --git a/lib/include/sparse b/lib/include/sparse new file mode 120000 index 0000000..6a4ae0b --- /dev/null +++ b/lib/include/sparse @@ -0,0 +1 @@ +../libsparse/include/sparse/ \ No newline at end of file diff --git a/lib/include/sparse/sparse.h b/lib/include/sparse/sparse.h deleted file mode 100755 index 3d5fb0c..0000000 --- a/lib/include/sparse/sparse.h +++ /dev/null @@ -1,346 +0,0 @@ -/* - * Copyright (C) 2012 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 _LIBSPARSE_SPARSE_H_ -#define _LIBSPARSE_SPARSE_H_ - -#include -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -struct sparse_file; - -// The callbacks in sparse_file_callback() and sparse_file_foreach_chunk() take -// size_t as the length type (was `int` in past). This allows clients to keep -// their codes compatibile with both versions as needed. -#define SPARSE_CALLBACK_USES_SIZE_T - -/** - * sparse_file_new - create a new sparse file cookie - * - * @block_size - minimum size of a chunk - * @len - size of the expanded sparse file. - * - * Creates a new sparse_file cookie that can be used to associate data - * blocks. Can later be written to a file with a variety of options. - * block_size specifies the minimum size of a chunk in the file. The maximum - * size of the file is 2**32 * block_size (16TB for 4k block size). - * - * Returns the sparse file cookie, or NULL on error. - */ -struct sparse_file *sparse_file_new(unsigned int block_size, int64_t len); - -/** - * sparse_file_destroy - destroy a sparse file cookie - * - * @s - sparse file cookie - * - * Destroys a sparse file cookie. After destroy, all memory passed in to - * sparse_file_add_data can be freed by the caller - */ -void sparse_file_destroy(struct sparse_file *s); - -/** - * sparse_file_add_data - associate a data chunk with a sparse file - * - * @s - sparse file cookie - * @data - pointer to data block - * @len - length of the data block - * @block - offset in blocks into the sparse file to place the data chunk - * - * Associates a data chunk with a sparse file cookie. The region - * [block * block_size : block * block_size + len) must not already be used in - * the sparse file. If len is not a multiple of the block size the data - * will be padded with zeros. - * - * The data pointer must remain valid until the sparse file is closed or the - * data block is removed from the sparse file. - * - * Returns 0 on success, negative errno on error. - */ -int sparse_file_add_data(struct sparse_file *s, - void *data, unsigned int len, unsigned int block); - -/** - * sparse_file_add_fill - associate a fill chunk with a sparse file - * - * @s - sparse file cookie - * @fill_val - 32 bit fill data - * @len - length of the fill block - * @block - offset in blocks into the sparse file to place the fill chunk - * - * Associates a chunk filled with fill_val with a sparse file cookie. - * The region [block * block_size : block * block_size + len) must not already - * be used in the sparse file. If len is not a multiple of the block size the - * data will be padded with zeros. - * - * Returns 0 on success, negative errno on error. - */ -int sparse_file_add_fill(struct sparse_file *s, - uint32_t fill_val, unsigned int len, unsigned int block); - -/** - * sparse_file_add_file - associate a chunk of a file with a sparse file - * - * @s - sparse file cookie - * @filename - filename of the file to be copied - * @file_offset - offset into the copied file - * @len - length of the copied block - * @block - offset in blocks into the sparse file to place the file chunk - * - * Associates a chunk of an existing file with a sparse file cookie. - * The region [block * block_size : block * block_size + len) must not already - * be used in the sparse file. If len is not a multiple of the block size the - * data will be padded with zeros. - * - * Allows adding large amounts of data to a sparse file without needing to keep - * it all mapped. File size is limited by available virtual address space, - * exceptionally large files may need to be added in multiple chunks. - * - * Returns 0 on success, negative errno on error. - */ -int sparse_file_add_file(struct sparse_file *s, - const char *filename, int64_t file_offset, unsigned int len, - unsigned int block); - -/** - * sparse_file_add_file - associate a chunk of a file with a sparse file - * - * @s - sparse file cookie - * @filename - filename of the file to be copied - * @file_offset - offset into the copied file - * @len - length of the copied block - * @block - offset in blocks into the sparse file to place the file chunk - * - * Associates a chunk of an existing fd with a sparse file cookie. - * The region [block * block_size : block * block_size + len) must not already - * be used in the sparse file. If len is not a multiple of the block size the - * data will be padded with zeros. - * - * Allows adding large amounts of data to a sparse file without needing to keep - * it all mapped. File size is limited by available virtual address space, - * exceptionally large files may need to be added in multiple chunks. - * - * The fd must remain open until the sparse file is closed or the fd block is - * removed from the sparse file. - * - * Returns 0 on success, negative errno on error. - */ -int sparse_file_add_fd(struct sparse_file *s, - int fd, int64_t file_offset, unsigned int len, unsigned int block); - -/** - * sparse_file_write - write a sparse file to a file - * - * @s - sparse file cookie - * @fd - file descriptor to write to - * @gz - write a gzipped file - * @sparse - write in the Android sparse file format - * @crc - append a crc chunk - * - * Writes a sparse file to a file. If gz is true, the data will be passed - * through zlib. If sparse is true, the file will be written in the Android - * sparse file format. If sparse is false, the file will be written by seeking - * over unused chunks, producing a smaller file if the filesystem supports - * sparse files. If crc is true, the crc of the expanded data will be - * calculated and appended in a crc chunk. - * - * Returns 0 on success, negative errno on error. - */ -int sparse_file_write(struct sparse_file *s, int fd, bool gz, bool sparse, - bool crc); - -/** - * sparse_file_len - return the length of a sparse file if written to disk - * - * @s - sparse file cookie - * @sparse - write in the Android sparse file format - * @crc - append a crc chunk - * - * Returns the size a sparse file would be on disk if it were written in the - * specified format. If sparse is true, this is the size of the data in the - * sparse format. If sparse is false, this is the size of the normal - * non-sparse file. - */ -int64_t sparse_file_len(struct sparse_file *s, bool sparse, bool crc); - -/** - * sparse_file_block_size - * - * @s - sparse file cookie - */ -unsigned int sparse_file_block_size(struct sparse_file *s); - -/** - * sparse_file_callback - call a callback for blocks in sparse file - * - * @s - sparse file cookie - * @sparse - write in the Android sparse file format - * @crc - append a crc chunk - * @write - function to call for each block - * @priv - value that will be passed as the first argument to write - * - * Writes a sparse file by calling a callback function. If sparse is true, the - * file will be written in the Android sparse file format. If crc is true, the - * crc of the expanded data will be calculated and appended in a crc chunk. - * The callback 'write' will be called with data and length for each data, - * and with data==NULL to skip over a region (only used for non-sparse format). - * The callback should return negative on error, 0 on success. - * - * Returns 0 on success, negative errno on error. - */ -int sparse_file_callback(struct sparse_file *s, bool sparse, bool crc, - int (*write)(void *priv, const void *data, size_t len), void *priv); - -/** - * sparse_file_foreach_chunk - call a callback for data blocks in sparse file - * - * @s - sparse file cookie - * @sparse - write in the Android sparse file format - * @crc - append a crc chunk - * @write - function to call for each block - * @priv - value that will be passed as the first argument to write - * - * The function has the same behavior as 'sparse_file_callback', except it only - * iterates on blocks that contain data. - * - * Returns 0 on success, negative errno on error. - */ -int sparse_file_foreach_chunk(struct sparse_file *s, bool sparse, bool crc, - int (*write)(void *priv, const void *data, size_t len, unsigned int block, - unsigned int nr_blocks), - void *priv); -/** - * sparse_file_read - read a file into a sparse file cookie - * - * @s - sparse file cookie - * @fd - file descriptor to read from - * @sparse - read a file in the Android sparse file format - * @crc - verify the crc of a file in the Android sparse file format - * - * Reads a file into a sparse file cookie. If sparse is true, the file is - * assumed to be in the Android sparse file format. If sparse is false, the - * file will be sparsed by looking for block aligned chunks of all zeros or - * another 32 bit value. If crc is true, the crc of the sparse file will be - * verified. - * - * Returns 0 on success, negative errno on error. - */ -int sparse_file_read(struct sparse_file *s, int fd, bool sparse, bool crc); - -/** - * sparse_file_read_buf - read a buffer into a sparse file cookie - * - * @s - sparse file cookie - * @buf - buffer to read from - * @crc - verify the crc of a file in the Android sparse file format - * - * Reads a buffer into a sparse file cookie. The buffer must remain - * valid until the sparse file cookie is freed. If crc is true, the - * crc of the sparse file will be verified. - * - * Returns 0 on success, negative errno on error. - */ -int sparse_file_read_buf(struct sparse_file *s, char *buf, bool crc); - -/** - * sparse_file_import - import an existing sparse file - * - * @fd - file descriptor to read from - * @verbose - print verbose errors while reading the sparse file - * @crc - verify the crc of a file in the Android sparse file format - * - * Reads an existing sparse file into a sparse file cookie, recreating the same - * sparse cookie that was used to write it. If verbose is true, prints verbose - * errors when the sparse file is formatted incorrectly. - * - * Returns a new sparse file cookie on success, NULL on error. - */ -struct sparse_file *sparse_file_import(int fd, bool verbose, bool crc); - -/** - * sparse_file_import_buf - import an existing sparse file from a buffer - * - * @buf - buffer to read from - * @verbose - print verbose errors while reading the sparse file - * @crc - verify the crc of a file in the Android sparse file format - * - * Reads existing sparse file data into a sparse file cookie, recreating the same - * sparse cookie that was used to write it. If verbose is true, prints verbose - * errors when the sparse file is formatted incorrectly. - * - * Returns a new sparse file cookie on success, NULL on error. - */ -struct sparse_file *sparse_file_import_buf(char* buf, bool verbose, bool crc); - -/** - * sparse_file_import_auto - import an existing sparse or normal file - * - * @fd - file descriptor to read from - * @crc - verify the crc of a file in the Android sparse file format - * @verbose - whether to use verbose logging - * - * Reads an existing sparse or normal file into a sparse file cookie. - * Attempts to determine if the file is sparse or not by looking for the sparse - * file magic number in the first 4 bytes. If the file is not sparse, the file - * will be sparsed by looking for block aligned chunks of all zeros or another - * 32 bit value. If crc is true, the crc of the sparse file will be verified. - * - * Returns a new sparse file cookie on success, NULL on error. - */ -struct sparse_file *sparse_file_import_auto(int fd, bool crc, bool verbose); - -/** sparse_file_resparse - rechunk an existing sparse file into smaller files - * - * @in_s - sparse file cookie of the existing sparse file - * @max_len - maximum file size - * @out_s - array of sparse file cookies - * @out_s_count - size of out_s array - * - * Splits chunks of an existing sparse file into smaller sparse files such that - * each sparse file is less than max_len. Returns the number of sparse_files - * that would have been written to out_s if out_s were big enough. - */ -int sparse_file_resparse(struct sparse_file *in_s, unsigned int max_len, - struct sparse_file **out_s, int out_s_count); - -/** - * sparse_file_verbose - set a sparse file cookie to print verbose errors - * - * @s - sparse file cookie - * - * Print verbose sparse file errors whenever using the sparse file cookie. - */ -void sparse_file_verbose(struct sparse_file *s); - -/** - * sparse_print_verbose - function called to print verbose errors - * - * By default, verbose errors will print to standard error. - * sparse_print_verbose may be overridden to log verbose errors somewhere else. - * - */ -extern void (*sparse_print_verbose)(const char *fmt, ...); - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/make.sh b/make.sh index d6f2f62..b49ed58 100755 --- a/make.sh +++ b/make.sh @@ -35,13 +35,13 @@ case "$OSTYPE" in src="errors_windows.cpp utf8.cpp" ;; esac -$CC -std=c++17 -I../include -Iinclude ${CFLAGS} -c abi_compatibility.cpp chrono_utils.cpp file.cpp liblog_symbols.cpp logging.cpp mapped_file.cpp parsebool.cpp parsenetaddress.cpp process.cpp properties.cpp stringprintf.cpp strings.cpp threads.cpp test_utils.cpp ${src} +$CC -std=c++17 -I../include ${CFLAGS} -c abi_compatibility.cpp chrono_utils.cpp file.cpp liblog_symbols.cpp logging.cpp mapped_file.cpp parsebool.cpp parsenetaddress.cpp process.cpp properties.cpp stringprintf.cpp strings.cpp threads.cpp test_utils.cpp ${src} $AR rcs ../lib/libbase.a *.o rm -r *.o unset src cd ../libsparse -$CC -std=c++17 -I../include -Iinclude ${CFLAGS} -c backed_block.cpp output_file.cpp sparse.cpp sparse_crc32.cpp sparse_err.cpp sparse_read.cpp +$CC -std=c++17 -I../include ${CFLAGS} -c backed_block.cpp output_file.cpp sparse.cpp sparse_crc32.cpp sparse_err.cpp sparse_read.cpp $AR rcs ../lib/libsparse.a *.o rm -r *.o