Any reason to call a member function of the object in QSBR? about junction HOT 9 OPEN

// K must integer type
template <typename K, typename V>
class LeapfrogMap {
   public:
    using ConcurrentMap = typename junction::ConcurrentMap_Leapfrog<K, V*>;
    using MapIterator = typename ConcurrentMap::Iterator;
    using MapMutator = typename ConcurrentMap::Mutator;

    LeapfrogMap() {}
    ~LeapfrogMap() {}

    // insert value only when not exist
    template <typename... Args>
    inline bool InsertOrFind(K key, V*& value, Args && ... args) {
        value = m_hashMap.get(key);
        if (!value) {
            turf::LockGuard<turf::Mutex> lock(m_mutex);
            MapMutator mutator = m_hashMap.insertOrFind(key);
            value = mutator.getValue();
            if (!value) {
                value = new V(std::forward<Args>(args)...);
                mutator.assignValue(value);
                return true;
            }
        }
        return false;
    }

    // upsert function
    inline void Insert(K key, V* value) {
        static_assert(std::is_integral<K>::value, "Key type must be integer.");

        MapMutator mutator = m_hashMap.insertOrFind(key);
        V* oldValue = mutator.exchangeValue(value);
        if (oldValue != nullptr && oldValue != value) {
            junction::DefaultQSBR.enqueue(&V::Destroy, oldValue);
        }
    }

    inline bool Get(K key, V*& value) {
        static_assert(std::is_integral<K>::value, "Key type must be integer.");

        value = m_hashMap.get(key);
        return value != nullptr;
    }

    inline void Delete(K key) {
        static_assert(std::is_integral<K>::value, "Key type must be integer.");

        V* oldValue = m_hashMap.erase(key);
        if (oldValue != nullptr) {
            junction::DefaultQSBR.enqueue(&V::Destroy, oldValue);
        }
    }

    // 遍历比较耗时
    inline void Clear() {
        static_assert(std::is_integral<K>::value, "Key type must be integer.");

        MapIterator mapIter(m_hashMap);
        while (mapIter.isValid()) {
            junction::DefaultQSBR.enqueue(&V::Destroy, mapIter.getValue());
            m_hashMap.erase(mapIter.getKey());
            mapIter.next();
        }
    }

    // 遍历比较耗时
    inline void DoFunc(std::function<void(K key, V* value)> func) {
        if (func == nullptr) {
            return;
        }

        static_assert(std::is_integral<K>::value, "Key type must be integer.");

        MapIterator mapIter(m_hashMap);
        while (mapIter.isValid()) {
            func(mapIter.getKey(), mapIter.getValue());
            mapIter.next();
        }
    }

    // 对指定Key执行一段逻辑，如果满足条件就删除
    inline void DoFuncThenDelete(const K& key, std::function<bool(V* value)> func) {
        if (func == nullptr) {
            return;
        }

        static_assert(std::is_integral<K>::value, "Key type must be integer.");

        V* value = m_hashMap.get(key);
        if (value != nullptr && func(value)) {
            V* oldValue = m_hashMap.erase(key);
            if (oldValue != nullptr) {
                junction::DefaultQSBR.enqueue(&V::Destroy, oldValue);
            }
        }
    }

   private:
    ConcurrentMap m_hashMap;
    turf::Mutex m_mutex;
};