tree 929e08d73e9fc168bba49c50cf62244ef4c607f6
parent 8db5f193b74512d052586bee00ed51bc79ba7a6a
author Sagar Srinivas <sagar.srinivas@ibm.com> 1711902928 -0500
committer sagar srinivas <sagar.srinivas@ibm.com> 1712052222 +0000

Use std::map.contains as per latest c++

This commit replaces occurrences of 'find' with
'contains' to access elements in a std::map
according to the latest C++ standard (since C++20).

However, contains() is not suitable in all situations
as in the case where we want to use the element contained
in the map using contains(), then it would do 2 searches
instead of 1 in the case where we use find() which fetches
the element from the map also.

Here are some relevant links to C++ documentation and
resources:

[1]: https://en.cppreference.com/w/cpp/container/map/find
[2]: https://en.cppreference.com/w/cpp/container/map/contains
[3]: https://wg21.link/N4861

Signed-off-by: Sagar Srinivas <sagar.srinivas@ibm.com>
Change-Id: If589e52026417c1c14a6a946e48826b749034e9a
