Remove boost::hash_value() overloads.

Builds/VisualStudio2013/RippleD.vcxproj

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup Label="Globals">
-    <ProjectGuid>{B7F39ECD-473C-484D-BC34-31F8362506A5}</ProjectGuid>
+    <ProjectGuid>{26B7D9AC-1A80-8EF8-6703-D061F1BECB75}</ProjectGuid>
     <Keyword>Win32Proj</Keyword>
     <RootNamespace>RippleD</RootNamespace>
     <IgnoreWarnCompileDuplicatedFilename>true</IgnoreWarnCompileDuplicatedFilename>
@@ -3383,9 +3383,6 @@
     <ClCompile Include="..\..\src\ripple\types\impl\UintTypes.cpp">
       <ExcludedFromBuild>True</ExcludedFromBuild>
     </ClCompile>
-    <ClCompile Include="..\..\src\ripple\types\impl\base_uint.cpp">
-      <ExcludedFromBuild>True</ExcludedFromBuild>
-    </ClCompile>
     <ClCompile Include="..\..\src\ripple\types\impl\strHex.cpp">
       <ExcludedFromBuild>True</ExcludedFromBuild>
     </ClCompile>
@@ -4106,4 +4103,4 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
-</Project>
+</Project>

Builds/VisualStudio2013/RippleD.vcxproj.filters

@@ -4647,9 +4647,6 @@
     <ClCompile Include="..\..\src\ripple\types\impl\UintTypes.cpp">
       <Filter>ripple\types\impl</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\src\ripple\types\impl\base_uint.cpp">
-      <Filter>ripple\types\impl</Filter>
-    </ClCompile>
     <ClCompile Include="..\..\src\ripple\types\impl\strHex.cpp">
       <Filter>ripple\types\impl</Filter>
     </ClCompile>

src/beast/beast/container/hash_append.h

@@ -702,16 +702,6 @@ struct uhash
     }
 };
 
-struct call_hash_value
-{
-    template <class T>
-    std::size_t
-    operator()(T const& t) const noexcept
-    {
-        return hash_value(t);
-    }
-};
-
 } // beast
 
 #endif

src/beast/beast/http/URL.h

@@ -131,8 +131,6 @@ hash_append (Hasher& h, URL const& url)
     hash_append (h, url.toString());
 }
 
-extern std::size_t hash_value (beast::URL const& url);
-
 }
 
 //------------------------------------------------------------------------------
@@ -143,7 +141,7 @@ template <>
 struct hash <beast::URL>
 {
     std::size_t operator() (beast::URL const& v) const
-        { return beast::hash_value (v); }
+        { return v.toString().hash(); }
 };
 
 }

src/beast/beast/http/impl/URL.cpp

@@ -164,14 +164,4 @@ std::ostream& operator<< (std::ostream &os, URL const& url)
     return os;
 }
 
-//------------------------------------------------------------------------------
-
-std::size_t hash_value (URL const& v)
-{
-    return std::size_t (v.toString().hash());
 }
-
-}
-
-
-// boost::hash support

src/beast/beast/net/IPAddress.h

@@ -24,6 +24,8 @@
 #include <beast/net/IPAddressV6.h>
 #include <beast/container/hash_append.h>
 
+#include <boost/functional/hash.hpp>
+
 #include <cstdint>
 #include <ios>
 #include <string>
@@ -277,16 +279,6 @@ is_public (Address const& addr)
 
 //------------------------------------------------------------------------------
 
-/** boost::hash support. */
-inline
-std::size_t
-hash_value (Address const& addr)
-{
-    return (addr.is_v4 ())
-        ? hash_value (addr.to_v4())
-        : hash_value (addr.to_v6());
-}
-
 /** Returns the address represented as a string. */
 inline std::string to_string (Address const& addr)
 {
@@ -337,7 +329,19 @@ struct hash <beast::IP::Address>
     std::size_t
     operator() (beast::IP::Address const& addr) const
     {
-        return hash_value (addr);
+        return beast::uhash<>{} (addr);
+    }
+};
+}
+
+namespace boost {
+template <>
+struct hash <beast::IP::Address>
+{
+    std::size_t
+    operator() (beast::IP::Address const& addr) const
+    {
+        return beast::uhash<>{} (addr);
     }
 };
 }

src/beast/beast/net/IPAddressV4.h

@@ -23,6 +23,7 @@
 #include <beast/container/hash_append.h>
 
 #include <cstdint>
+#include <functional>
 #include <ios>
 #include <string>
 #include <utility>
@@ -164,10 +165,6 @@ bool is_public (AddressV4 const& addr);
 
 //------------------------------------------------------------------------------
 
-/** boost::hash support. */
-inline std::size_t hash_value (AddressV4 const& addr)
-    { return addr.value; }
-
 /** Returns the address represented as a string. */
 std::string to_string (AddressV4 const& addr);
 
@@ -197,7 +194,7 @@ template <>
 struct hash <beast::IP::AddressV4>
 {
     std::size_t operator() (beast::IP::AddressV4 const& addr) const
-        { return hash_value (addr); }
+        { return addr.value; }
 };
 }
 

src/beast/beast/net/IPAddressV6.h

@@ -22,6 +22,7 @@
 
 #include <cassert>
 #include <cstdint>
+#include <functional>
 #include <ios>
 #include <string>
 #include <utility>
@@ -78,10 +79,6 @@ hash_append(Hasher&, AddressV6 const&)
     assert(false);
 }
 
-/** boost::hash support. */
-inline std::size_t hash_value (AddressV6 const&)
-    { assert(false); return 0; }
-
 /** Returns the address represented as a string. */
 std::string to_string (AddressV6 const& addr);
 
@@ -104,7 +101,7 @@ template <>
 struct hash <beast::IP::AddressV6>
 {
     std::size_t operator() (beast::IP::AddressV6 const& addr) const
-        { return hash_value (addr); }
+        { assert(false); return 0; }
 };
 }
 

src/beast/beast/net/IPEndpoint.h

@@ -132,9 +132,6 @@ inline bool  is_public (Endpoint const& endpoint)
 
 //------------------------------------------------------------------------------
 
-/** boost::hash support. */
-std::size_t hash_value (Endpoint const& endpoint);
-
 /** Returns the endpoint represented as a string. */
 inline std::string to_string (Endpoint const& endpoint)
     { return endpoint.to_string(); }
@@ -161,7 +158,17 @@ template <>
 struct hash <beast::IP::Endpoint>
 {
     std::size_t operator() (beast::IP::Endpoint const& endpoint) const
-        { return hash_value (endpoint); }
+        { return beast::uhash<>{} (endpoint); }
+};
+}
+
+namespace boost {
+/** boost::hash support. */
+template <>
+struct hash <beast::IP::Endpoint>
+{
+    std::size_t operator() (beast::IP::Endpoint const& endpoint) const
+        { return beast::uhash<>{} (endpoint); }
 };
 }
 

src/beast/beast/net/impl/IPEndpoint.cpp

@@ -137,15 +137,6 @@ bool operator<  (Endpoint const& lhs, Endpoint const& rhs)
 
 //------------------------------------------------------------------------------
 
-std::size_t hash_value (Endpoint const& endpoint)
-{
-    std::size_t seed (hash_value (endpoint.address ()));
-    // boost::hash_combine()
-    seed ^= (std::hash <Port> () (endpoint.port ()))
-        + 0x9e3779b9 + (seed << 6) + (seed >> 2);
-    return seed;
-}
-
 std::istream& operator>> (std::istream& is, Endpoint& endpoint)
 {
     // VFALCO TODO Support ipv6!

src/ripple/algorithm/api/CycledSet.h

@@ -21,6 +21,7 @@
 #define RIPPLE_TYPES_CYCLEDSET_H_INCLUDED
 
 #include <boost/unordered_set.hpp>
+#include <unordered_set>
 
 namespace ripple {
 
@@ -37,6 +38,9 @@ template <class Key,
 class CycledSet
 {
 private:
+    // HH This unordered_set can't be changed from boost until gcc allows for
+    //    stateful hash functions (or until rippled eliminates stateful hash
+    //    functions).
     typedef boost::unordered_set<
         Key, Hash, KeyEqual, Allocator>                     ContainerType;
     typedef typename ContainerType::iterator                iterator;

src/ripple/module/app/consensus/LedgerConsensus.cpp

@@ -1496,7 +1496,7 @@ class LedgerConsensusImp
         }
 
         // if any peers have taken a contrary position, process disputes
-        boost::unordered_set<uint256> found;
+        ripple::unordered_set<uint256> found;
 
         for (auto& it : mPeerPositions)
         {
@@ -1899,7 +1899,7 @@ class LedgerConsensusImp
 
     // Disputed transactions
     ripple::unordered_map<uint256, DisputedTx::pointer> mDisputes;
-    boost::unordered_set<uint256> mCompares;
+    ripple::unordered_set<uint256> mCompares;
 
     // Close time estimates
     std::map<std::uint32_t, int> mCloseTimes;

src/ripple/module/app/ledger/OrderBookDB.cpp

@@ -60,10 +60,10 @@ void OrderBookDB::setup (Ledger::ref ledger)
 }
 
 static void updateHelper (SLE::ref entry,
-    boost::unordered_set< uint256 >& seen,
+    ripple::unordered_set< uint256 >& seen,
     ripple::unordered_map< RippleAsset, std::vector<OrderBook::pointer> >& destMap,
     ripple::unordered_map< RippleAsset, std::vector<OrderBook::pointer> >& sourceMap,
-    boost::unordered_set< RippleAsset >& XRPBooks,
+    ripple::unordered_set< RippleAsset >& XRPBooks,
     int& books)
 {
     if ((entry->getType () == ltDIR_NODE) && (entry->isFieldPresent (sfExchangeRate)) &&
@@ -96,10 +96,10 @@ static void updateHelper (SLE::ref entry,
 
 void OrderBookDB::update (Ledger::pointer ledger)
 {
-    boost::unordered_set< uint256 > seen;
+    ripple::unordered_set< uint256 > seen;
     ripple::unordered_map< RippleAsset, std::vector<OrderBook::pointer> > destMap;
     ripple::unordered_map< RippleAsset, std::vector<OrderBook::pointer> > sourceMap;
-    boost::unordered_set< RippleAsset > XRPBooks;
+    ripple::unordered_set< RippleAsset > XRPBooks;
 
     WriteLog (lsDEBUG, OrderBookDB) << "OrderBookDB::update>";
 

src/ripple/module/app/ledger/OrderBookDB.h

@@ -89,7 +89,7 @@ class OrderBookDB
     AssetToOrderBook mDestMap;
 
     // does an order book to XRP exist
-    boost::unordered_set <RippleAsset> mXRPBooks;
+    ripple::unordered_set <RippleAsset> mXRPBooks;
 
     typedef RippleRecursiveMutex LockType;
     typedef std::lock_guard <LockType> ScopedLockType;

src/ripple/module/app/misc/AmendmentTableImpl.cpp

@@ -31,7 +31,7 @@ namespace ripple {
 
     typedef ripple::unordered_map<uint256, AmendmentState> amendmentMap_t;
     typedef std::pair<const uint256, AmendmentState> amendmentIt_t;
-    typedef boost::unordered_set<uint256> amendmentList_t;
+    typedef ripple::unordered_set<uint256> amendmentList_t;
 
     typedef RippleMutex LockType;
     typedef std::lock_guard <LockType> ScopedLockType;

src/ripple/module/app/misc/NetworkOPs.cpp

@@ -386,10 +386,10 @@ class NetworkOPsImp
     // InfoSub::Source
     //
     void subAccount (InfoSub::ref ispListener,
-                     const boost::unordered_set<RippleAddress>& vnaAccountIDs,
+                     const ripple::unordered_set<RippleAddress>& vnaAccountIDs,
                      std::uint32_t uLedgerIndex, bool rt);
     void unsubAccount (std::uint64_t uListener,
-                       const boost::unordered_set<RippleAddress>& vnaAccountIDs,
+                       const ripple::unordered_set<RippleAddress>& vnaAccountIDs,
                        bool rt);
 
     bool subLedger (InfoSub::ref ispListener, Json::Value& jvResult);
@@ -2617,7 +2617,7 @@ void NetworkOPsImp::pubAccountTransaction (Ledger::ref lpCurrent, const Accepted
 //
 
 void NetworkOPsImp::subAccount (InfoSub::ref isrListener,
-    const boost::unordered_set<RippleAddress>& vnaAccountIDs,
+    const ripple::unordered_set<RippleAddress>& vnaAccountIDs,
     std::uint32_t uLedgerIndex, bool rt)
 {
     SubInfoMapType& subMap = rt ? mSubRTAccount : mSubAccount;
@@ -2653,7 +2653,7 @@ void NetworkOPsImp::subAccount (InfoSub::ref isrListener,
 }
 
 void NetworkOPsImp::unsubAccount (std::uint64_t uSeq,
-                                  const boost::unordered_set<RippleAddress>& vnaAccountIDs,
+                                  const ripple::unordered_set<RippleAddress>& vnaAccountIDs,
                                   bool rt)
 {
     SubInfoMapType& subMap = rt ? mSubRTAccount : mSubAccount;

src/ripple/module/app/peers/UniqueNodeList.cpp

@@ -1025,7 +1025,7 @@ class UniqueNodeListImp
             }
         }
 
-        boost::unordered_set<std::string>   usUNL;
+        ripple::unordered_set<std::string>   usUNL;
 
         if (!vsnNodes.empty ())
         {
@@ -2025,7 +2025,7 @@ class UniqueNodeListImp
 
     // XXX Make this faster, make this the contents vector unsigned char or raw public key.
     // XXX Contents needs to based on score.
-    boost::unordered_set<std::string>   mUNL;
+    ripple::unordered_set<std::string>   mUNL;
 
     boost::posix_time::ptime        mtpScoreNext;       // When to start scoring.
     boost::posix_time::ptime        mtpScoreStart;      // Time currently started scoring.

src/ripple/module/app/shamap/SHAMap.cpp

@@ -114,11 +114,6 @@ void SHAMapNodeID::setMHash () const
     mHash = h;
 }
 
-std::size_t hash_value (const SHAMapNodeID& mn)
-{
-    return mn.getMHash ();
-}
-
 SHAMap::pointer SHAMap::snapShot (bool isMutable)
 {
     SHAMap::pointer ret = std::make_shared<SHAMap> (mType,

src/ripple/module/app/shamap/SHAMapNodeID.h

@@ -130,8 +130,6 @@ class SHAMapNodeID
     void setMHash () const;
 };
 
-extern std::size_t hash_value (SHAMapNodeID const& mn);
-
 inline std::ostream& operator<< (std::ostream& out, SHAMapNodeID const& node)
 {
     return out << node.getString ();

src/ripple/module/data/crypto/Base58Data.cpp

@@ -77,14 +77,4 @@ std::string CBase58Data::ToString () const
     return Base58::encodeWithCheck (vch);
 }
 
-std::size_t hash_value (const CBase58Data& b58)
-{
-    std::size_t seed = HashMaps::getInstance ().getNonce <size_t> ()
-                       + (b58.nVersion * HashMaps::goldenRatio);
-
-    boost::hash_combine (seed, b58.vchData);
-
-    return seed;
-}
-
 } // ripple