Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 59329831 authored by Tomasz Wasilczyk's avatar Tomasz Wasilczyk Committed by Automerger Merge Worker
Browse files

Merge "Deprecate function declarations, not definitions." am: 302b92a5 am:... 

Merge "Deprecate function declarations, not definitions." am: 302b92a5 am: 00f15937 am: 6188e714 am: 5cb4f885 am: 35585416 am: 3802f5a0

Original change: https://android-review.googlesource.com/c/platform/frameworks/native/+/2640609



Change-Id: I5fde840be9d1d8fd20f0fe82a920ff9c5d3322e2
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents fb07ace9 3802f5a0

libs/binder/include/binder/Parcel.h

+14 −7
Original line number Original line Diff line number Diff line
@@ -266,7 +266,8 @@ public: 
    status_t            writeEnumVector(const std::optional<std::vector<T>>& val)

    status_t            writeEnumVector(const std::optional<std::vector<T>>& val)

            { return writeData(val); }

            { return writeData(val); }

    template<typename T, std::enable_if_t<std::is_enum_v<T> && std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    template<typename T, std::enable_if_t<std::is_enum_v<T> && std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    status_t            writeEnumVector(const std::unique_ptr<std::vector<T>>& val) __attribute__((deprecated("use std::optional version instead")))

    [[deprecated("use std::optional version instead")]] //

    status_t            writeEnumVector(const std::unique_ptr<std::vector<T>>& val)

            { return writeData(val); }

            { return writeData(val); }

    // Write an Enum vector with underlying type != int8_t.

    // Write an Enum vector with underlying type != int8_t.

    template<typename T, std::enable_if_t<std::is_enum_v<T> && !std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    template<typename T, std::enable_if_t<std::is_enum_v<T> && !std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>
@@ -276,17 +277,20 @@ public: 
    status_t            writeEnumVector(const std::optional<std::vector<T>>& val)

    status_t            writeEnumVector(const std::optional<std::vector<T>>& val)

            { return writeData(val); }

            { return writeData(val); }

    template<typename T, std::enable_if_t<std::is_enum_v<T> && !std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    template<typename T, std::enable_if_t<std::is_enum_v<T> && !std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    status_t            writeEnumVector(const std::unique_ptr<std::vector<T>>& val) __attribute__((deprecated("use std::optional version instead")))

    [[deprecated("use std::optional version instead")]] //

    status_t            writeEnumVector(const std::unique_ptr<std::vector<T>>& val)

            { return writeData(val); }

            { return writeData(val); }





    template<typename T>

    template<typename T>

    status_t            writeParcelableVector(const std::optional<std::vector<std::optional<T>>>& val)

    status_t            writeParcelableVector(const std::optional<std::vector<std::optional<T>>>& val)

            { return writeData(val); }

            { return writeData(val); }

    template<typename T>

    template<typename T>

    status_t            writeParcelableVector(const std::unique_ptr<std::vector<std::unique_ptr<T>>>& val) __attribute__((deprecated("use std::optional version instead")))

    [[deprecated("use std::optional version instead")]] //

    status_t            writeParcelableVector(const std::unique_ptr<std::vector<std::unique_ptr<T>>>& val)

            { return writeData(val); }

            { return writeData(val); }

    template<typename T>

    template<typename T>

    status_t            writeParcelableVector(const std::shared_ptr<std::vector<std::unique_ptr<T>>>& val) __attribute__((deprecated("use std::optional version instead")))

    [[deprecated("use std::optional version instead")]] //

    status_t            writeParcelableVector(const std::shared_ptr<std::vector<std::unique_ptr<T>>>& val)

            { return writeData(val); }

            { return writeData(val); }

    template<typename T>

    template<typename T>

    status_t            writeParcelableVector(const std::shared_ptr<std::vector<std::optional<T>>>& val)

    status_t            writeParcelableVector(const std::shared_ptr<std::vector<std::optional<T>>>& val)
@@ -422,7 +426,8 @@ public: 
    status_t            readEnumVector(std::vector<T>* val) const

    status_t            readEnumVector(std::vector<T>* val) const

            { return readData(val); }

            { return readData(val); }

    template<typename T, std::enable_if_t<std::is_enum_v<T> && std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    template<typename T, std::enable_if_t<std::is_enum_v<T> && std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    status_t            readEnumVector(std::unique_ptr<std::vector<T>>* val) const __attribute__((deprecated("use std::optional version instead")))

    [[deprecated("use std::optional version instead")]] //

    status_t            readEnumVector(std::unique_ptr<std::vector<T>>* val) const

            { return readData(val); }

            { return readData(val); }

    template<typename T, std::enable_if_t<std::is_enum_v<T> && std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    template<typename T, std::enable_if_t<std::is_enum_v<T> && std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    status_t            readEnumVector(std::optional<std::vector<T>>* val) const

    status_t            readEnumVector(std::optional<std::vector<T>>* val) const
@@ -432,7 +437,8 @@ public: 
    status_t            readEnumVector(std::vector<T>* val) const

    status_t            readEnumVector(std::vector<T>* val) const

            { return readData(val); }

            { return readData(val); }

    template<typename T, std::enable_if_t<std::is_enum_v<T> && !std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    template<typename T, std::enable_if_t<std::is_enum_v<T> && !std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    status_t            readEnumVector(std::unique_ptr<std::vector<T>>* val) const __attribute__((deprecated("use std::optional version instead")))

    [[deprecated("use std::optional version instead")]] //

    status_t            readEnumVector(std::unique_ptr<std::vector<T>>* val) const

            { return readData(val); }

            { return readData(val); }

    template<typename T, std::enable_if_t<std::is_enum_v<T> && !std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    template<typename T, std::enable_if_t<std::is_enum_v<T> && !std::is_same_v<typename std::underlying_type_t<T>,int8_t>, bool> = 0>

    status_t            readEnumVector(std::optional<std::vector<T>>* val) const

    status_t            readEnumVector(std::optional<std::vector<T>>* val) const
@@ -443,8 +449,9 @@ public: 
                            std::optional<std::vector<std::optional<T>>>* val) const

                            std::optional<std::vector<std::optional<T>>>* val) const

            { return readData(val); }

            { return readData(val); }

    template<typename T>

    template<typename T>

    [[deprecated("use std::optional version instead")]] //

    status_t            readParcelableVector(

    status_t            readParcelableVector(

                            std::unique_ptr<std::vector<std::unique_ptr<T>>>* val) const __attribute__((deprecated("use std::optional version instead")))

                            std::unique_ptr<std::vector<std::unique_ptr<T>>>* val) const

            { return readData(val); }

            { return readData(val); }

    template<typename T>

    template<typename T>

    status_t            readParcelableVector(std::vector<T>* val) const

    status_t            readParcelableVector(std::vector<T>* val) const