Make iterators const if possible

Author: cngzhnp

hazelcast/include/hazelcast/client/iexecutor_service.h

@@ -208,8 +208,8 @@ class HAZELCAST_API iexecutor_service : public proxy::ProxyImpl
     void execute_on_members(const HazelcastSerializable& command,
                             const std::vector<member>& members)
     {
-        for (std::vector<member>::const_iterator it = members.begin();
-             it != members.end();
+        for (std::vector<member>::const_iterator it = members.cbegin();
+             it != members.cend();
              ++it) {
             submit_to_member<HazelcastSerializable, executor_marker>(command,
                                                                      *it);
@@ -241,8 +241,8 @@ class HAZELCAST_API iexecutor_service : public proxy::ProxyImpl
     {
         std::vector<member> memberList =
           get_context().get_client_cluster_service().get_member_list();
-        for (std::vector<member>::const_iterator it = memberList.begin();
-             it != memberList.end();
+        for (std::vector<member>::const_iterator it = memberList.cbegin();
+             it != memberList.cend();
              ++it) {
             submit_to_member<HazelcastSerializable, executor_marker>(command,
                                                                      *it);

hazelcast/include/hazelcast/client/imap.h

@@ -1063,7 +1063,7 @@ class HAZELCAST_API imap : public proxy::IMapImpl
             resultFutures.push_back(
               put_all_internal(partitionId, std::move(partitionEntry.second)));
         }
-        return boost::when_all(resultFutures.begin(), resultFutures.end())
+        return boost::when_all(resultFutures.cbegin(), resultFutures.cend())
           .then(boost::launch::sync,
                 [](boost::future<boost::csbl::vector<
                      boost::future<protocol::ClientMessage>>> futures) {
@@ -1308,8 +1308,8 @@ class HAZELCAST_API imap : public proxy::IMapImpl
       query::iteration_type iteration_type,
       std::vector<std::pair<K, boost::optional<V>>> entries)
     {
-        std::sort(entries.begin(),
-                  entries.end(),
+        std::sort(entries.cbegin(),
+                  entries.cend(),
                   [&](const std::pair<K, boost::optional<V>>& lhs,
                       const std::pair<K, boost::optional<V>>& rhs) {
                       auto comparator = predicate.getComparator();

hazelcast/include/hazelcast/client/internal/config/ConfigUtils.h

@@ -37,7 +37,7 @@ class ConfigUtils
       const std::string& item_name)
     {
         auto candidate = config_patterns.find(item_name);
-        if (candidate != config_patterns.end()) {
+        if (candidate != config_patterns.cend()) {
             return &candidate->second;
         }
         auto size = config_patterns.size();
@@ -50,7 +50,7 @@ class ConfigUtils
           config_pattern_matcher.matches(keys, item_name);
         if (configPatternKey) {
             candidate = config_patterns.find(*configPatternKey);
-            if (candidate != config_patterns.end()) {
+            if (candidate != config_patterns.cend()) {
                 return &candidate->second;
             }
         }

hazelcast/include/hazelcast/client/internal/nearcache/impl/store/BaseHeapNearCacheRecordStore.h

@@ -77,8 +77,8 @@ class BaseHeapNearCacheRecordStore
           entries = ANCRS::records_->entry_set();
         for (typename std::vector<std::pair<std::shared_ptr<KS>,
                                             std::shared_ptr<R>>>::const_iterator
-               it = entries.begin();
-             it != entries.end();
+               it = entries.cbegin();
+             it != entries.cend();
              ++it) {
             const std::pair<std::shared_ptr<KS>, std::shared_ptr<R>>& entry =
               (*it);

hazelcast/include/hazelcast/client/internal/nearcache/impl/store/HeapNearCacheRecordMap.h

@@ -127,8 +127,8 @@ class HeapNearCacheRecordMap
         }
         int actualEvictedCount = 0;
         for (typename std::vector<std::shared_ptr<C>>::const_iterator it =
-               eviction_candidates->begin();
-             it != eviction_candidates->end();
+               eviction_candidates->cbegin();
+             it != eviction_candidates->cend();
              ++it) {
             const std::shared_ptr<C>& evictionCandidate = *it;
             if (util::SynchronizedMap<std::shared_ptr<KS>, R>::remove(

hazelcast/include/hazelcast/client/map/NearCachedClientMapProxy.h

@@ -404,7 +404,7 @@ class NearCachedClientMapProxy
                         std::move(entry.second));
                       bool marked = false;
                       auto foundEntry = markers->find(key);
-                      if (foundEntry != markers->end()) {
+                      if (foundEntry != markers->cend()) {
                           marked = foundEntry->second;
                           markers->erase(foundEntry);
                       }
@@ -601,8 +601,8 @@ class NearCachedClientMapProxy
 
     void unmark_remaining_marked_keys(MARKER_MAP& markers)
     {
-        for (MARKER_MAP::const_iterator it = markers.begin();
-             it != markers.end();
+        for (MARKER_MAP::const_iterator it = markers.cbegin();
+             it != markers.cend();
              ++it) {
             if (it->second) {
                 key_state_marker_->force_unmark(*it->first);

hazelcast/include/hazelcast/client/pipelining.h

@@ -117,7 +117,7 @@ class pipelining : public std::enable_shared_from_this<pipelining<E>>
     {
         std::vector<boost::optional<E>> result;
         result.reserve(futures_.size());
-        auto result_futures = when_all(futures_.begin(), futures_.end());
+        auto result_futures = when_all(futures_.cbegin(), futures_.cend());
         for (auto& f : result_futures.get()) {
             result.emplace_back(f.get());
         }
@@ -163,8 +163,8 @@ class pipelining : public std::enable_shared_from_this<pipelining<E>>
             }
 
             if (!outStandingFutures.empty()) {
-                boost::when_any(outStandingFutures.begin(),
-                                outStandingFutures.end())
+                boost::when_any(outStandingFutures.cbegin(),
+                                outStandingFutures.cend())
                   .get();
             }
         }

hazelcast/include/hazelcast/client/protocol/ClientMessageBuilder.h

@@ -103,7 +103,7 @@ class ClientMessageBuilder
         bool result = false;
 
         auto found = partial_messages_.find(fragmentation_id);
-        if (partial_messages_.end() != found) {
+        if (partial_messages_.cend() != found) {
             found->second->append(std::move(msg));
             if (is_end_fragment) {
                 // remove from message from map

hazelcast/include/hazelcast/client/proxy/SerializingProxy.h

@@ -97,7 +97,7 @@ class HAZELCAST_API SerializingProxy
     inline boost::future<std::unordered_map<K, V>> to_object_map(
       std::vector<boost::future<EntryVector>>& futures)
     {
-        return boost::when_all(futures.begin(), futures.end())
+        return boost::when_all(futures.cbegin(), futures.cend())
           .then(boost::launch::sync,
                 [this](
                   boost::future<boost::csbl::vector<boost::future<EntryVector>>>

hazelcast/include/hazelcast/client/serialization/pimpl/data_output.h

@@ -216,12 +216,12 @@ const std::vector<byte>& data_output::to_byte_array() const
 
 void data_output::append_bytes(const std::vector<byte>& bytes)
 {
-    output_stream_.insert(output_stream_.end(), bytes.begin(), bytes.end());
+    output_stream_.insert(output_stream_.cend(), bytes.cbegin(), bytes.cend());
 }
 
 void data_output::write_zero_bytes(size_t number_of_bytes)
 {
-    output_stream_.insert(output_stream_.end(), number_of_bytes, 0);
+    output_stream_.insert(output_stream_.cend(), number_of_bytes, 0);
 }
 
 size_t data_output::position() const