tree 7c1a5deed05bffbba96fc227982743c47c13a030
parent 97964dbc78e9b952b8b6c85aca5a5973cac6989c
author William <hicklin@users.noreply.github.com> 1690544752 +0100
committer GitHub <noreply@github.com> 1690544752 +0000
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsBcBAABCAAQBQJkw6pwCRBK7hj4Ov3rIwAAJWUIAFreHvFNO47q1sySA3qrCghP
 r5jSfiNp4rKqhTPV7u2VnLwDI0LaSN791CiUqWyxXg4FXD5J6zE2wJ/KiqenWBOP
 5gPjHGSebrPKGc97U6ziAB404Cc99EmGXjooxkbdU0ibNzfeCWxMCy0b+ABH+EHZ
 xJFeHuJXPGbHdk9vVbM+DrhQ1NMaJf+XRcOPZ/fU3sqpI7cflTTYydo9Cqq63kJc
 Z9vTWTT+Qch+VSpPlagdp4zbXTwJlSy6dhsA1/IslIGAwxx6hyRBPM0cGvXn/xdH
 rVHR87UOW/OkAije2l9OBicwL2bSqlk91UEh0QLBCXdfxm5wIAkwrwjzzVBdeDA=
 =BoBd
 -----END PGP SIGNATURE-----
 

Reverted the AttributePersistenceProvider and added a SafeAttributePersistenceProvider (#28302)

* Renamed AttributePersistenceProvider to SafeAttributePersistenceProvider. Reverted to the previous AttributePersistenceProvider. Updated the tests and examples that used the AttributePersistenceProvider.

* Restyled by whitespace

* Restyled by clang-format

* Restyled by gn

* Fixed the key generated for safe attributes.

Co-authored-by: Tennessee Carmel-Veilleux <tennessee.carmelveilleux@gmail.com>

* Apply documentation suggestions from code review

Co-authored-by: Boris Zbarsky <bzbarsky@apple.com>

* Removed unused aPath and import.

* Fixed some docs. Removed size from the SafeAttributePersistenceProvider::SafeReadValue method.

* Replaced the aType input var from the SafeAttributePersistenceProvider::SafeReadValue method with documentation on the expectet types.

* Replaced the SafeAttributePersistenceProvider::GetNullValueForNullableType logic with that used in NumericAttributeTraits::GetNullValue. Mode the GetNullValueForNullableType methods private and commented out the relevant unit tests.

* Restyled by clang-format

* Replaced the SafeAttributePersistenceProvider::GetNullValueForNullableType methods with NumericAttributeTraits.

* Apply documentation suggestions from code review

Co-authored-by: Boris Zbarsky <bzbarsky@apple.com>

* Restyled by clang-format

* Refactored SafeAttributePersistenceProvider reducing the number of templated functions.

Co-authored-by: Boris Zbarsky <bzbarsky@apple.com>

* Fixed minor bug in suggestions.

* Restyled by whitespace

---------

Co-authored-by: Restyled.io <commits@restyled.io>
Co-authored-by: Tennessee Carmel-Veilleux <tennessee.carmelveilleux@gmail.com>
Co-authored-by: Boris Zbarsky <bzbarsky@apple.com>