利用SFINAE 机制判断类型是否具有Reset成员

#include <type_traits>
#include <iostream>
#include <vector>
#include <map>
#include <mutex>
#include <stdint.h>
template <typename T, typename = void>
struct has_reset : std::false_type {};

template <typename T>
struct has_reset<T, decltype((void) std::declval<T>().Reset(), void())> : std::true_type {};

// template <typename T>
// struct has_reset<T,std::void_t<decltype(std::declval<T>().Reset())>> : std::true_type {};

struct TSomeData{
    int  data1;
    int  data2;
    char data3;
    void Reset() {}
};

struct TSomeData2{
    int  data1;
    int  data2;
    char data3;
};

template <typename T>
class DataCache{
     public:
          DataCache()=default;
          ~DataCache()=default;
          int32_t Push(uint32_t id, const T& data)
          {
               std::lock_guard<std::mutex> lock(mutex_);
               data_map_[id]=data;
               is_update_ = true;
               return 0;
          }
          int32_t GetAll(std::vector<T> &data)
          {
               data.clear();
               {
                    std::lock_guard<std::mutex> lock(mutex_);
                    if(is_update_ == false)
                    {
                         return 0;
                    }
                    for(auto it=data_map_.begin();it!=data_map_.end();++it)
                    {
                         data.push_back(it->second);
                         std::cout << "GET ALL ,try reset." << std::endl;
                         Reset(it->second, std::integral_constant<bool,has_reset<T>::value>{});
                    }
                    is_update_ = false;
                    return data_map_.size();
               }
               
               return 0;
          }
     private:
          void Reset(T& obj, std::true_type)
          {
               obj.Reset();
               std::cout << "Reset data" << std::endl;
          }
          void Reset(T& obj, std::false_type)
          {
               //do nothing
               std::cout << "No reset function" << std::endl;
          }
     private:
          std::map<uint32_t, T> data_map_;  // key: id, value: data
          bool                  is_update_;
          std::mutex     mutex_;
};

int main(int argc,char* argv[])
{
    DataCache<TSomeData> cache;
    cache.Push(1, TSomeData());
    std::vector<TSomeData> data;
    cache.GetAll(data);

    DataCache<TSomeData2> cache2;
    cache2.Push(1, TSomeData2());
    std::vector<TSomeData2> data2;
    cache2.GetAll(data2);

    return 0;
}