feedc0de/boost_smart_ptr
1
0
Fork 0
forked from boostorg/smart_ptr
Code Pull Requests Activity

Add std::hash specializations for shared_ptr, local_shared_ptr, intrusive_ptr

Browse Source
This commit is contained in:
Peter Dimov
2020-06-02 05:59:23 +03:00
parent 09fdd5ebfd
commit 5a18ffdc56
8 changed files with 303 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
include/boost/smart_ptr/intrusive_ptr.hpp
View File

@ -385,4 +385,23 @@ template< class T > std::size_t hash_value( boost::intrusive_ptr<T> const & p )
} // namespace boost } // namespace boost
// std::hash
#if !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
namespace std
{
template<class T> struct hash< ::boost::intrusive_ptr<T> >
{
std::size_t operator()( ::boost::intrusive_ptr<T> const & v ) const BOOST_SP_NOEXCEPT
{
return hash_value( v );
}
};
} // namespace std
#endif // #if !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
#endif // #ifndef BOOST_SMART_PTR_INTRUSIVE_PTR_HPP_INCLUDED #endif // #ifndef BOOST_SMART_PTR_INTRUSIVE_PTR_HPP_INCLUDED

19
include/boost/smart_ptr/local_shared_ptr.hpp
View File

@ -688,4 +688,23 @@ template< class T > std::size_t hash_value( local_shared_ptr<T> const & p ) BOOS
} // namespace boost } // namespace boost
// std::hash
#if !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
namespace std
{
template<class T> struct hash< ::boost::local_shared_ptr<T> >
{
std::size_t operator()( ::boost::local_shared_ptr<T> const & v ) const BOOST_SP_NOEXCEPT
{
return hash_value( v );
}
};
} // namespace std
#endif // #if !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
#endif // #ifndef BOOST_SMART_PTR_LOCAL_SHARED_PTR_HPP_INCLUDED #endif // #ifndef BOOST_SMART_PTR_LOCAL_SHARED_PTR_HPP_INCLUDED

19
include/boost/smart_ptr/shared_ptr.hpp
View File

@ -1165,6 +1165,25 @@ template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p ) BOO
} // namespace boost } // namespace boost
// std::hash
#if !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
namespace std
{
template<class T> struct hash< ::boost::shared_ptr<T> >
{
std::size_t operator()( ::boost::shared_ptr<T> const & v ) const BOOST_SP_NOEXCEPT
{
return hash_value( v );
}
};
} // namespace std
#endif // #if !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
#include <boost/smart_ptr/detail/local_sp_deleter.hpp> #include <boost/smart_ptr/detail/local_sp_deleter.hpp>
namespace boost namespace boost

5
test/Jamfile
View File

@ -376,3 +376,8 @@ run owner_equal_to_test.cpp ;
run owner_equal_to_test2.cpp ; run owner_equal_to_test2.cpp ;
run owner_less_test2.cpp ; run owner_less_test2.cpp ;
run ip_hash_test2.cpp ;
run sp_hash_test4.cpp ;
run lsp_hash_test.cpp ;
run lsp_hash_test2.cpp ;

71
test/ip_hash_test2.cpp Normal file
View File

@ -0,0 +1,71 @@
// Copyright 2011, 2020 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#include <boost/intrusive_ptr.hpp>
#include <boost/functional/hash.hpp>
#include <boost/core/lightweight_test.hpp>
#include <boost/config.hpp>
#include <functional>
#if defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
int main() {}
#else
class base
{
private:
int use_count_;
base(base const &);
base & operator=(base const &);
protected:
base(): use_count_(0)
{
}
virtual ~base()
{
}
public:
long use_count() const
{
return use_count_;
}
inline friend void intrusive_ptr_add_ref(base * p)
{
++p->use_count_;
}
inline friend void intrusive_ptr_release(base * p)
{
if(--p->use_count_ == 0) delete p;
}
};
struct X: public base
{
};
int main()
{
boost::hash< boost::intrusive_ptr<X> > hasher;
std::hash< boost::intrusive_ptr<X> > hasher2;
boost::intrusive_ptr<X> p1, p2( new X );
BOOST_TEST_EQ( hasher( p1 ), hasher2( p1 ) );
BOOST_TEST_EQ( hasher( p2 ), hasher2( p2 ) );
return boost::report_errors();
}
#endif // #if defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)

66
test/lsp_hash_test.cpp Normal file
View File

@ -0,0 +1,66 @@
// Copyright 2011, 2020 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#include <boost/smart_ptr/local_shared_ptr.hpp>
#include <boost/functional/hash.hpp>
#include <boost/core/lightweight_test.hpp>
int main()
{
{
boost::hash< boost::local_shared_ptr<int> > hasher;
boost::local_shared_ptr<int> p1, p2( p1 ), p3( new int ), p4( p3 ), p5( new int );
BOOST_TEST_EQ( p1, p2 );
BOOST_TEST_EQ( hasher( p1 ), hasher( p2 ) );
BOOST_TEST_NE( p1, p3 );
BOOST_TEST_NE( hasher( p1 ), hasher( p3 ) );
BOOST_TEST_EQ( p3, p4 );
BOOST_TEST_EQ( hasher( p3 ), hasher( p4 ) );
BOOST_TEST_NE( p3, p5 );
BOOST_TEST_NE( hasher( p3 ), hasher( p5 ) );
}
{
boost::hash< boost::local_shared_ptr<int[]> > hasher;
boost::local_shared_ptr<int[]> p1, p2( p1 ), p3( new int[1] ), p4( p3 ), p5( new int[1] );
BOOST_TEST_EQ( p1, p2 );
BOOST_TEST_EQ( hasher( p1 ), hasher( p2 ) );
BOOST_TEST_NE( p1, p3 );
BOOST_TEST_NE( hasher( p1 ), hasher( p3 ) );
BOOST_TEST_EQ( p3, p4 );
BOOST_TEST_EQ( hasher( p3 ), hasher( p4 ) );
BOOST_TEST_NE( p3, p5 );
BOOST_TEST_NE( hasher( p3 ), hasher( p5 ) );
}
{
boost::hash< boost::local_shared_ptr<int[1]> > hasher;
boost::local_shared_ptr<int[1]> p1, p2( p1 ), p3( new int[1] ), p4( p3 ), p5( new int[1] );
BOOST_TEST_EQ( p1, p2 );
BOOST_TEST_EQ( hasher( p1 ), hasher( p2 ) );
BOOST_TEST_NE( p1, p3 );
BOOST_TEST_NE( hasher( p1 ), hasher( p3 ) );
BOOST_TEST_EQ( p3, p4 );
BOOST_TEST_EQ( hasher( p3 ), hasher( p4 ) );
BOOST_TEST_NE( p3, p5 );
BOOST_TEST_NE( hasher( p3 ), hasher( p5 ) );
}
return boost::report_errors();
}

52
test/lsp_hash_test2.cpp Normal file
View File

@ -0,0 +1,52 @@
// Copyright 2011, 2020 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#include <boost/smart_ptr/local_shared_ptr.hpp>
#include <boost/functional/hash.hpp>
#include <boost/core/lightweight_test.hpp>
#include <boost/config.hpp>
#include <functional>
#if defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
int main() {}
#else
int main()
{
{
boost::hash< boost::local_shared_ptr<int> > hasher;
std::hash< boost::local_shared_ptr<int> > hasher2;
boost::local_shared_ptr<int> p1, p2( new int );
BOOST_TEST_EQ( hasher( p1 ), hasher2( p1 ) );
BOOST_TEST_EQ( hasher( p2 ), hasher2( p2 ) );
}
{
boost::hash< boost::local_shared_ptr<int[]> > hasher;
std::hash< boost::local_shared_ptr<int[]> > hasher2;
boost::local_shared_ptr<int[]> p1, p2( new int[1] );
BOOST_TEST_EQ( hasher( p1 ), hasher2( p1 ) );
BOOST_TEST_EQ( hasher( p2 ), hasher2( p2 ) );
}
{
boost::hash< boost::local_shared_ptr<int[1]> > hasher;
std::hash< boost::local_shared_ptr<int[1]> > hasher2;
boost::local_shared_ptr<int[1]> p1, p2( new int[1] );
BOOST_TEST_EQ( hasher( p1 ), hasher2( p1 ) );
BOOST_TEST_EQ( hasher( p2 ), hasher2( p2 ) );
}
return boost::report_errors();
}
#endif // #if defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)

52
test/sp_hash_test4.cpp Normal file
View File

@ -0,0 +1,52 @@
// Copyright 2011, 2020 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#include <boost/shared_ptr.hpp>
#include <boost/functional/hash.hpp>
#include <boost/core/lightweight_test.hpp>
#include <boost/config.hpp>
#include <functional>
#if defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
int main() {}
#else
int main()
{
{
boost::hash< boost::shared_ptr<int> > hasher;
std::hash< boost::shared_ptr<int> > hasher2;
boost::shared_ptr<int> p1, p2( new int );
BOOST_TEST_EQ( hasher( p1 ), hasher2( p1 ) );
BOOST_TEST_EQ( hasher( p2 ), hasher2( p2 ) );
}
{
boost::hash< boost::shared_ptr<int[]> > hasher;
std::hash< boost::shared_ptr<int[]> > hasher2;
boost::shared_ptr<int[]> p1, p2( new int[1] );
BOOST_TEST_EQ( hasher( p1 ), hasher2( p1 ) );
BOOST_TEST_EQ( hasher( p2 ), hasher2( p2 ) );
}
{
boost::hash< boost::shared_ptr<int[1]> > hasher;
std::hash< boost::shared_ptr<int[1]> > hasher2;
boost::shared_ptr<int[1]> p1, p2( new int[1] );
BOOST_TEST_EQ( hasher( p1 ), hasher2( p1 ) );
BOOST_TEST_EQ( hasher( p2 ), hasher2( p2 ) );
}
return boost::report_errors();
}
#endif // #if defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)