X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=gdax-orderbook-hpp%2Fdemo%2Fdependencies%2Flibcds-2.3.2%2Fcds%2Fcontainer%2Fstriped_set%2Fstd_hash_set.h;fp=gdax-orderbook-hpp%2Fdemo%2Fdependencies%2Flibcds-2.3.2%2Fcds%2Fcontainer%2Fstriped_set%2Fstd_hash_set.h;h=ae7ff738bf2a752d7aea9c52503351187a0a0845;hb=4223430d9168223029c7639149025c79e69b4f37;hp=0000000000000000000000000000000000000000;hpb=7ea7751a31c0388bf888052517be181a2989b113;p=c11concurrency-benchmarks.git diff --git a/gdax-orderbook-hpp/demo/dependencies/libcds-2.3.2/cds/container/striped_set/std_hash_set.h b/gdax-orderbook-hpp/demo/dependencies/libcds-2.3.2/cds/container/striped_set/std_hash_set.h new file mode 100644 index 0000000..ae7ff73 --- /dev/null +++ b/gdax-orderbook-hpp/demo/dependencies/libcds-2.3.2/cds/container/striped_set/std_hash_set.h @@ -0,0 +1,201 @@ +/* + This file is a part of libcds - Concurrent Data Structures library + + (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2017 + + Source code repo: http://github.com/khizmax/libcds/ + Download: http://sourceforge.net/projects/libcds/files/ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef CDSLIB_CONTAINER_STRIPED_SET_STD_HASH_SET_ADAPTER_H +#define CDSLIB_CONTAINER_STRIPED_SET_STD_HASH_SET_ADAPTER_H + +#include +#include + +//@cond +namespace cds { namespace container { + namespace striped_set { + + // Copy policy for std::unordered_set + template + struct copy_item_policy< std::unordered_set< T, Hash, Pred, Alloc > > + { + typedef std::unordered_set< T, Hash, Pred, Alloc > set_type; + typedef typename set_type::iterator iterator; + + void operator()( set_type& set, iterator itWhat ) + { + set.insert( *itWhat ); + } + }; + + template + struct swap_item_policy< std::unordered_set< T, Hash, Pred, Alloc > >: public copy_item_policy< std::unordered_set< T, Hash, Pred, Alloc > > + {}; + + // Move policy for std::unordered_set + template + struct move_item_policy< std::unordered_set< T, Hash, Pred, Alloc > > + { + typedef std::unordered_set< T, Hash, Pred, Alloc > set_type; + typedef typename set_type::iterator iterator; + + void operator()( set_type& set, iterator itWhat ) + { + set.insert( std::move( *itWhat )); + } + }; + + } // namespace striped_set +}} // namespace cds::container + +namespace cds { namespace intrusive { namespace striped_set { + /// std::unordered_set adapter for hash set bucket + template + class adapt< std::unordered_set, Options... > + { + public: + typedef std::unordered_set container_type ; ///< underlying container type + + private: + /// Adapted container type + class adapted_container: public cds::container::striped_set::adapted_container + { + public: + typedef typename container_type::value_type value_type ; ///< value type stored in the container + typedef typename container_type::iterator iterator ; ///< container iterator + typedef typename container_type::const_iterator const_iterator ; ///< container const iterator + + static bool const has_find_with = false; + static bool const has_erase_with = false; + + private: + //@cond + typedef typename cds::opt::select< + typename cds::opt::value< + typename cds::opt::find_option< + cds::opt::copy_policy< cds::container::striped_set::move_item > + , Options... + >::type + >::copy_policy + , cds::container::striped_set::copy_item, cds::container::striped_set::copy_item_policy + , cds::container::striped_set::swap_item, cds::container::striped_set::swap_item_policy // not defined + , cds::container::striped_set::move_item, cds::container::striped_set::move_item_policy + >::type copy_item; + //@endcond + + private: + //@cond + container_type m_Set; + //@endcond + + public: + template + bool insert( const Q& val, Func f ) + { + std::pair res = m_Set.insert( value_type(val)); + if ( res.second ) + f( const_cast(*res.first)); + return res.second; + } + + template + bool emplace( Args&&... args ) + { + std::pair res = m_Set.emplace( std::forward(args)... ); + return res.second; + } + + template + std::pair update( const Q& val, Func func, bool bAllowInsert ) + { + if ( bAllowInsert ) { + std::pair res = m_Set.insert( value_type(val)); + func( res.second, const_cast(*res.first), val ); + return std::make_pair( true, res.second ); + } + else { + auto it = m_Set.find( value_type(val)); + if ( it == m_Set.end()) + return std::make_pair( false, false ); + + func( false, const_cast(*it), val ); + return std::make_pair( true, false ); + } + } + + template + bool erase( const Q& key, Func f ) + { + const_iterator it = m_Set.find( value_type(key)); + if ( it == m_Set.end()) + return false; + f( const_cast(*it)); + m_Set.erase( it ); + return true; + } + + template + bool find( Q& val, Func f ) + { + iterator it = m_Set.find( value_type(val)); + if ( it == m_Set.end()) + return false; + f( const_cast(*it), val ); + return true; + } + + /// Clears the container + void clear() + { + m_Set.clear(); + } + + iterator begin() { return m_Set.begin(); } + const_iterator begin() const { return m_Set.begin(); } + iterator end() { return m_Set.end(); } + const_iterator end() const { return m_Set.end(); } + + void move_item( adapted_container& /*from*/, iterator itWhat ) + { + assert( m_Set.find( *itWhat ) == m_Set.end()); + copy_item()( m_Set, itWhat ); + } + + size_t size() const + { + return m_Set.size(); + } + }; + + public: + typedef adapted_container type ; ///< Result of \p adapt metafunction + }; +}}} // namespace cds::intrusive::striped_set + + +//@endcond + +#endif // #ifndef CDSLIB_CONTAINER_STRIPED_SET_STD_HASH_SET_ADAPTER_H