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

Commit 5f062569 authored by Casey Dahlin's avatar Casey Dahlin
Browse files

Use templates for write*Vector methods 



Change-Id: I86223bd54940ebe3e8f090b7786ddfa3ee57195e
Test: AIDL integration tests still pass
Bug: None
Signed-off-by: default avatarCasey Dahlin <sadmac@google.com>
parent 41e50f99

libs/binder/Parcel.cpp

+46 −150
Original line number Diff line number Diff line
@@ -750,43 +750,23 @@ restart_write: 
    return NULL;

}



status_t Parcel::writeByteVector(const std::vector<int8_t>& val)

{

    status_t status;

    if (val.size() > std::numeric_limits<int32_t>::max()) {

        status = BAD_VALUE;

        return status;

    }



    status = writeInt32(val.size());

    if (status != OK) {

        return status;

    }



    void* data = writeInplace(val.size());

    if (!data) {

        status = BAD_VALUE;

        return status;

    }



    memcpy(data, val.data(), val.size());

    return status;

}

namespace {



status_t Parcel::writeInt32Vector(const std::vector<int32_t>& val)

{

template<typename T, typename U>

status_t unsafeWriteTypedVector(const std::vector<T>& val, Parcel* p,

                                status_t(Parcel::*write_func)(U)) {

    if (val.size() > std::numeric_limits<int32_t>::max()) {

        return BAD_VALUE;

    }



    status_t status = writeInt32(val.size());

    status_t status = p->writeInt32(val.size());



    if (status != OK) {

        return status;

    }



    for (const auto& item : val) {

        status = writeInt32(item);

        status = (p->*write_func)(item);



        if (status != OK) {

            return status;
@@ -796,142 +776,76 @@ status_t Parcel::writeInt32Vector(const std::vector<int32_t>& val) 
    return OK;

}



status_t Parcel::writeInt64Vector(const std::vector<int64_t>& val)

{

    if (val.size() > std::numeric_limits<int32_t>::max()) {

        return BAD_VALUE;

    }



    status_t status = writeInt32(val.size());



    if (status != OK) {

        return status;

template<typename T>

status_t writeTypedVector(const std::vector<T>& val, Parcel* p,

                          status_t(Parcel::*write_func)(const T&)) {

    return unsafeWriteTypedVector(val, p, write_func);

}



    for (const auto& item : val) {

        status = writeInt64(item);



        if (status != OK) {

            return status;

        }

template<typename T>

status_t writeTypedVector(const std::vector<T>& val, Parcel* p,

                          status_t(Parcel::*write_func)(T)) {

    return unsafeWriteTypedVector(val, p, write_func);

}



    return OK;

}

}  // namespace



status_t Parcel::writeFloatVector(const std::vector<float>& val)

status_t Parcel::writeByteVector(const std::vector<int8_t>& val)

{

    status_t status;

    if (val.size() > std::numeric_limits<int32_t>::max()) {

        return BAD_VALUE;

    }



    status_t status = writeInt32(val.size());



    if (status != OK) {

        status = BAD_VALUE;

        return status;

    }



    for (const auto& item : val) {

        status = writeFloat(item);



    status = writeInt32(val.size());

    if (status != OK) {

        return status;

    }

    }



    return OK;

}



status_t Parcel::writeDoubleVector(const std::vector<double>& val)

{

    if (val.size() > std::numeric_limits<int32_t>::max()) {

        return BAD_VALUE;

    }



    status_t status = writeInt32(val.size());



    if (status != OK) {

    void* data = writeInplace(val.size());

    if (!data) {

        status = BAD_VALUE;

        return status;

    }



    for (const auto& item : val) {

        status = writeDouble(item);



        if (status != OK) {

    memcpy(data, val.data(), val.size());

    return status;

}

    }



    return OK;

status_t Parcel::writeInt32Vector(const std::vector<int32_t>& val)

{

    return writeTypedVector(val, this, &Parcel::writeInt32);

}



status_t Parcel::writeBoolVector(const std::vector<bool>& val)

status_t Parcel::writeInt64Vector(const std::vector<int64_t>& val)

{

    if (val.size() > std::numeric_limits<int32_t>::max()) {

        return BAD_VALUE;

    return writeTypedVector(val, this, &Parcel::writeInt64);

}



    status_t status = writeInt32(val.size());



    if (status != OK) {

        return status;

status_t Parcel::writeFloatVector(const std::vector<float>& val)

{

    return writeTypedVector(val, this, &Parcel::writeFloat);

}



    for (const auto& item : val) {

        status = writeBool(item);



        if (status != OK) {

            return status;

        }

status_t Parcel::writeDoubleVector(const std::vector<double>& val)

{

    return writeTypedVector(val, this, &Parcel::writeDouble);

}



    return OK;

status_t Parcel::writeBoolVector(const std::vector<bool>& val)

{

    return writeTypedVector(val, this, &Parcel::writeBool);

}



status_t Parcel::writeCharVector(const std::vector<char16_t>& val)

{

    if (val.size() > std::numeric_limits<int32_t>::max()) {

        return BAD_VALUE;

    }



    status_t status = writeInt32(val.size());



    if (status != OK) {

        return status;

    }



    for (const auto& item : val) {

        status = writeChar(item);



        if (status != OK) {

            return status;

        }

    }



    return OK;

    return writeTypedVector(val, this, &Parcel::writeChar);

}



status_t Parcel::writeString16Vector(const std::vector<String16>& val)

{

    if (val.size() > std::numeric_limits<int32_t>::max()) {

        return BAD_VALUE;

    }



    status_t status = writeInt32(val.size());



    if (status != OK) {

        return status;

    }



    for (const auto& item : val) {

        status = writeString16(item);



        if (status != OK) {

            return status;

        }

    }



    return OK;

    return writeTypedVector(val, this, &Parcel::writeString16);

}



status_t Parcel::writeInt32(int32_t val)
@@ -1080,25 +994,7 @@ status_t Parcel::writeStrongBinder(const sp<IBinder>& val) 


status_t Parcel::writeStrongBinderVector(const std::vector<sp<IBinder>>& val)

{

    if (val.size() > std::numeric_limits<int32_t>::max()) {

        return BAD_VALUE;

    }



    status_t status = writeInt32(val.size());



    if (status != OK) {

        return status;

    }



    for (const auto& item : val) {

        status = writeStrongBinder(item);



        if (status != OK) {

            return status;

        }

    }



    return OK;

    return writeTypedVector(val, this, &Parcel::writeStrongBinder);

}



status_t Parcel::readStrongBinderVector(std::vector<sp<IBinder>>* val) const {