Serializable unordered set

Serializable unordered set 可序列化哈希set

#include <boost/algorithm/string/predicate.hpp>
#include <boost/exception/diagnostic_information.hpp>
#include <boost/exception_ptr.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/config.hpp>
#include <boost/unordered_set.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/version.hpp>
#include <boost/serialization/split_member.hpp>
#include <boost/serialization/collections_save_imp.hpp>
#include <boost/serialization/collections_load_imp.hpp>
#include <boost/serialization/utility.hpp>
#include <boost/serialization/split_free.hpp>

#include <boost/thread/shared_mutex.hpp>
#include <boost/thread/locks.hpp>

namespace boost {
    namespace serialization {

        template<class Archive, typename TArgs >
        inline void save(Archive & ar, boost::unordered_set<TArgs> const&t, unsigned) {
            boost::serialization::stl::save_collection<Archive, boost::unordered_set<TArgs> >(ar, t);
        };

        template<class Archive, typename TArgs >
        inline void load(Archive & ar, boost::unordered_set<TArgs> &t, unsigned) {
            boost::serialization::stl::load_collection<Archive,
                boost::unordered_set<TArgs>,
                boost::serialization::stl::archive_input_set<Archive, boost::unordered_set<TArgs> >,
                boost::serialization::stl::no_reserve_imp<boost::unordered_set<TArgs> >
            >(ar, t);
        };

        // split non-intrusive serialization function member into separate
        // non intrusive save/load member functions
        template <class Archive, typename TArgs>
        inline void serialize(Archive & ar, boost::unordered_set<TArgs> &t, unsigned file_version) {
            boost::serialization::split_free(ar, t, file_version);
        };
    }
};

template<typename DataType>
class Serializable_unordered_set : boost::noncopyable
{

    friend class boost::serialization::access;
    // When the class Archive corresponds to an output archive, the
    // & operator is defined similar to <<.  Likewise, when the class Archive
    // is a type of input archive the & operator is defined similar to >>.
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version) {
        ar & m_unordered_set;
    }

private:
        boost::unordered_set<DataType > m_unordered_set;
        mutable boost::shared_mutex m_mtx_protect;

public:

    Serializable_unordered_set()
    {
    }

    void SetMap(boost::unordered_set<DataType>& newset)
    {
        m_unordered_set = newset;
    }

    void insert(DataType t) {
        boost::unique_lock< boost::shared_mutex > lock(m_mtx_protect);
        m_unordered_set.insert(t);
    }

    bool exist(DataType ky)
    {
        boost::shared_lock< boost::shared_mutex > lock(m_mtx_protect);
        if (m_unordered_set.find(ky) != m_unordered_set.end())
            return true;
        return false;
    }

    void serialize_to(string file_path) {
        boost::shared_lock< boost::shared_mutex > lock(m_mtx_protect);
        std::ofstream fout(file_path.c_str());
        boost::archive::text_oarchive oa(fout);
        oa << m_unordered_set;
        fout.close();
    }

    void deserialize_from(std::string file_path) {
        boost::unique_lock< boost::shared_mutex > lock(m_mtx_protect);
        std::ifstream file_in(file_path.c_str());
        boost::archive::text_iarchive ia(file_in);
        ia >> m_unordered_set; //recover from file
        file_in.close();
    }
};
typedef std::shared_ptr<Serializable_unordered_set<int>> hashset_int_SPtr;