Fix unused parameter warnings for all components

hazelcast/include/hazelcast/client/impl/EntryEventHandler.h

@@ -85,10 +85,10 @@ class EntryEventHandler : public BaseType
 
 private:
     void fire_map_wide_event(
-      const boost::optional<serialization::pimpl::data>& key,
-      const boost::optional<serialization::pimpl::data>& value,
-      const boost::optional<serialization::pimpl::data>& old_value,
-      const boost::optional<serialization::pimpl::data>& merging_value,
+      const boost::optional<serialization::pimpl::data>& /* key */,
+      const boost::optional<serialization::pimpl::data>& /* value */,
+      const boost::optional<serialization::pimpl::data>& /* old_value */,
+      const boost::optional<serialization::pimpl::data>& /* merging_value */,
       int32_t event_type,
       boost::uuids::uuid uuid,
       int32_t number_of_affected_entries)
@@ -114,7 +114,7 @@ class EntryEventHandler : public BaseType
       const boost::optional<serialization::pimpl::data>& merging_value,
       int32_t event_type,
       boost::uuids::uuid uuid,
-      int32_t number_of_affected_entries)
+      int32_t /* number_of_affected_entries */)
     {
         typed_data eventKey, val, oldVal, mergingVal;
         if (include_value_) {

hazelcast/include/hazelcast/client/internal/eviction/EvictableStore.h

@@ -64,8 +64,8 @@ class EvictableStore
      */
     virtual int evict(
       std::vector<std::shared_ptr<EvictionCandidate<MAPKEY, MAPVALUE, A, E>>>*
-        eviction_candidates,
-      EvictionListener<A, E>* eviction_listener)
+        /* eviction_candidates */,
+      EvictionListener<A, E>* /* eviction_listener */)
     {
         assert(0);
         return 0;

hazelcast/include/hazelcast/client/internal/eviction/EvictionListener.h

@@ -54,9 +54,9 @@ class EvictionListener
      * @param wasExpired           {@code true} if the entry was evicted due to
      * expiration, {@code false} otherwise
      */
-    virtual void on_evict(const std::shared_ptr<A>& evicted_entry_accessor,
-                          const std::shared_ptr<E>& evicted_entry,
-                          bool was_expired)
+    virtual void on_evict(const std::shared_ptr<A>& /* evicted_entry_accessor */,
+                          const std::shared_ptr<E>& /* evicted_entry */,
+                          bool /* was_expired */)
     {
         assert(0);
     }

hazelcast/include/hazelcast/client/internal/eviction/EvictionPolicyComparator.h

@@ -70,8 +70,8 @@ class EvictionPolicyComparator : util::Comparator<EvictableEntryView<K, V>>
      *
      * @return the result of comparison
      */
-    int compare(const EvictableEntryView<K, V>* e1,
-                const EvictableEntryView<K, V>* e2) const override
+    int compare(const EvictableEntryView<K, V>* /* e1 */,
+                const EvictableEntryView<K, V>* /* e2 */) const override
     {
         assert(0);
         return 0;

hazelcast/include/hazelcast/client/internal/eviction/EvictionPolicyEvaluator.h

@@ -78,7 +78,7 @@ class EvictionPolicyEvaluator
     virtual std::unique_ptr<std::vector<
       std::shared_ptr<eviction::EvictionCandidate<MAPKEY, MAPVALUE, A, E>>>>
     evaluate(util::Iterable<EvictionCandidate<MAPKEY, MAPVALUE, A, E>>&
-               eviction_candidates) const
+               /* eviction_candidates */) const
     {
         assert(0);
         return std::unique_ptr<std::vector<std::shared_ptr<

hazelcast/include/hazelcast/client/internal/eviction/EvictionStrategy.h

@@ -70,11 +70,11 @@ class EvictionStrategy
      *
      * @return evicted entry count
      */
-    virtual int evict(S* evictable_store,
+    virtual int evict(S* /* evictable_store*/,
                       EvictionPolicyEvaluator<MAPKEY, MAPVALUE, A, E>*
-                        eviction_policy_evaluator,
-                      EvictionChecker* eviction_checker,
-                      EvictionListener<A, E>* eviction_listener)
+                        /* eviction_policy_evaluator*/,
+                      EvictionChecker* /* eviction_checker*/,
+                      EvictionListener<A, E>* /* eviction_listener */)
     {
         assert(0);
         return 0;

hazelcast/include/hazelcast/client/internal/eviction/impl/comparator/RandomEvictionPolicyComparator.h

@@ -38,8 +38,8 @@ template<typename A, typename E>
 class RandomEvictionPolicyComparator : public EvictionPolicyComparator<A, E>
 {
 public:
-    int compare(const EvictableEntryView<A, E>* e1,
-                const EvictableEntryView<A, E>* e2) const override
+    int compare(const EvictableEntryView<A, E>* /* e1 */,
+                const EvictableEntryView<A, E>* /* e2 */) const override
     {
         return 0;
     }

hazelcast/include/hazelcast/client/internal/eviction/impl/strategy/AbstractEvictionStrategy.h

@@ -97,10 +97,10 @@ class AbstractEvictionStrategy
      * @return evicted entry count
      */
 protected:
-    virtual int evict_internal(S* evictable_store,
+    virtual int evict_internal(S* /* evictable_store */,
                                EvictionPolicyEvaluator<MAPKEY, MAPVALUE, A, E>*
-                                 eviction_policy_evaluator,
-                               EvictionListener<A, E>* eviction_listener)
+                                 /* eviction_policy_evaluator */,
+                               EvictionListener<A, E>* /* eviction_listener */)
     {
         assert(0);
         return 0;

hazelcast/include/hazelcast/client/internal/nearcache/NearCache.h

@@ -114,7 +114,7 @@ class NearCache : public BaseNearCache
      * @param key the key of the requested value
      * @return the value associated with the given <code>key</code>
      */
-    virtual std::shared_ptr<V> get(const std::shared_ptr<K>& key)
+    virtual std::shared_ptr<V> get(const std::shared_ptr<K>& /* key */)
     {
         assert(0);
         return std::shared_ptr<V>();
@@ -126,8 +126,8 @@ class NearCache : public BaseNearCache
      * @param key   the key of the value will be stored
      * @param value the value will be stored
      */
-    virtual void put(const std::shared_ptr<K>& key,
-                     const std::shared_ptr<V>& value)
+    virtual void put(const std::shared_ptr<K>& /* key */,
+                     const std::shared_ptr<V>& /* value */)
     {
         assert(0);
     }
@@ -151,7 +151,7 @@ class NearCache : public BaseNearCache
      *
      * @param key the key of the value will be invalidated
      */
-    virtual bool invalidate(const std::shared_ptr<K>& key)
+    virtual bool invalidate(const std::shared_ptr<K>& /* key */)
     {
         assert(0);
         return false;

hazelcast/include/hazelcast/client/internal/nearcache/NearCacheRecord.h

@@ -59,29 +59,29 @@ class NearCacheRecord
      *
      * @param value the value for this {@link NearCacheRecord}
      */
-    virtual void set_value(const std::shared_ptr<V>& value) { assert(0); }
+    virtual void set_value(const std::shared_ptr<V>& /* value */) { assert(0); }
 
     /**
      * Sets the creation time of this {@link Evictable} in milliseconds.
      *
      * @param time the creation time for this {@link Evictable} in milliseconds
      */
-    virtual void set_creation_time(int64_t time) = 0;
+    virtual void set_creation_time(int64_t /* time */) = 0;
 
     /**
      * Sets the access time of this {@link Evictable} in milliseconds.
      *
      * @param time the latest access time of this {@link Evictable} in
      * milliseconds
      */
-    virtual void set_access_time(int64_t time) = 0;
+    virtual void set_access_time(int64_t /* time */) = 0;
 
     /**
      * Sets the access hit count of this {@link Evictable}.
      *
      * @param hit the access hit count for this {@link Evictable}
      */
-    virtual void set_access_hit(int32_t hit) = 0;
+    virtual void set_access_hit(int32_t /* hit */) = 0;
 
     /**
      * Increases the access hit count of this {@link Evictable} by {@code 1}.
@@ -102,7 +102,7 @@ class NearCacheRecord
      * @param now                 current time in milliseconds
      * @return {@code true} if exceeds max idle seconds, otherwise {@code false}
      */
-    virtual bool is_idle_at(int64_t max_idle_milli_seconds, int64_t now) = 0;
+    virtual bool is_idle_at(int64_t /* max_idle_milli_seconds */, int64_t /* now */) = 0;
 
     /**
      * @return last known invalidation sequence at time of this records'
@@ -114,19 +114,19 @@ class NearCacheRecord
      * @param sequence last known invalidation sequence at time of this records'
      * creation
      */
-    virtual void set_invalidation_sequence(int64_t sequence) = 0;
+    virtual void set_invalidation_sequence(int64_t /* sequence */) = 0;
 
     /**
      * @param uuid last known uuid of invalidation source at time of this
      * records' creation
      */
-    virtual void set_uuid(boost::uuids::uuid uuid) = 0;
+    virtual void set_uuid(boost::uuids::uuid /* uuid */) = 0;
 
     /**
      * @return {@code true} if supplied uuid equals existing one, otherwise and
      * when one of supplied or existing is null returns {@code false}
      */
-    virtual bool has_same_uuid(boost::uuids::uuid that_uuid) const = 0;
+    virtual bool has_same_uuid(boost::uuids::uuid /* that_uuid */) const = 0;
 };
 } // namespace nearcache
 } // namespace internal

hazelcast/include/hazelcast/client/internal/nearcache/impl/NearCacheRecordStore.h

@@ -60,7 +60,7 @@ class NearCacheRecordStore : public spi::InitializingObject
      * @param key the key from which to get the associated value.
      * @return the value associated with the given {@code key}.
      */
-    virtual std::shared_ptr<V> get(const std::shared_ptr<K>& key)
+    virtual std::shared_ptr<V> get(const std::shared_ptr<K>& /* key */)
     {
         assert(0);
         return std::shared_ptr<V>();
@@ -72,8 +72,8 @@ class NearCacheRecordStore : public spi::InitializingObject
      * @param key   the key to which the given value will be associated.
      * @param value the value that will be associated with the key.
      */
-    virtual void put(const std::shared_ptr<K>& key,
-                     const std::shared_ptr<V>& value)
+    virtual void put(const std::shared_ptr<K>& /* key */,
+                     const std::shared_ptr<V>& /* value */)
     {
         assert(0);
     }
@@ -97,7 +97,7 @@ class NearCacheRecordStore : public spi::InitializingObject
      *
      * @param key the key of the value will be invalidated
      */
-    virtual bool invalidate(const std::shared_ptr<K>& key)
+    virtual bool invalidate(const std::shared_ptr<K>& /* key */)
     {
         assert(0);
         return false;
@@ -133,8 +133,8 @@ class NearCacheRecordStore : public spi::InitializingObject
      * {@code candidates}.
      */
     virtual const std::shared_ptr<V> select_to_save(
-      const std::shared_ptr<V>& value,
-      const std::shared_ptr<serialization::pimpl::data>& value_data) const
+      const std::shared_ptr<V>& /* value */,
+      const std::shared_ptr<serialization::pimpl::data>& /* value_data */) const
     {
         assert(0);
         return std::shared_ptr<V>();