X-Git-Url: http://plrg.eecs.uci.edu/git/?p=c11concurrency-benchmarks.git;a=blobdiff_plain;f=gdax-orderbook-hpp%2Fdemo%2Fdependencies%2Flibcds-2.3.2%2Fcds%2Fcontainer%2Fstriped_set%2Fboost_stable_vector.h;fp=gdax-orderbook-hpp%2Fdemo%2Fdependencies%2Flibcds-2.3.2%2Fcds%2Fcontainer%2Fstriped_set%2Fboost_stable_vector.h;h=53a8db6cbc38eebbe60e8c2888ce042a1130a767;hp=0000000000000000000000000000000000000000;hb=4223430d9168223029c7639149025c79e69b4f37;hpb=7ea7751a31c0388bf888052517be181a2989b113 diff --git a/gdax-orderbook-hpp/demo/dependencies/libcds-2.3.2/cds/container/striped_set/boost_stable_vector.h b/gdax-orderbook-hpp/demo/dependencies/libcds-2.3.2/cds/container/striped_set/boost_stable_vector.h new file mode 100644 index 0000000..53a8db6 --- /dev/null +++ b/gdax-orderbook-hpp/demo/dependencies/libcds-2.3.2/cds/container/striped_set/boost_stable_vector.h @@ -0,0 +1,284 @@ +/* + 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_BOOST_STABLE_VECTOR_ADAPTER_H +#define CDSLIB_CONTAINER_STRIPED_SET_BOOST_STABLE_VECTOR_ADAPTER_H + +#include +#if BOOST_VERSION < 104800 +# error "For boost::container::stable_vector you must use boost 1.48 or above" +#endif + +#include // ref +#include // std::lower_bound +#include // std::pair +#include +#include + +//@cond +namespace cds { namespace container { + namespace striped_set { + + // Copy policy for boost::container::stable_vector + template + struct copy_item_policy< boost::container::stable_vector< T, Alloc > > + { + typedef boost::container::stable_vector< T, Alloc > vector_type; + typedef typename vector_type::iterator iterator; + + void operator()( vector_type& vec, iterator itInsert, iterator itWhat ) + { + vec.insert( itInsert, *itWhat ); + } + }; + + // Swap policy for boost::container::stable_vector + template + struct swap_item_policy< boost::container::stable_vector< T, Alloc > > + { + typedef boost::container::stable_vector< T, Alloc > vector_type; + typedef typename vector_type::iterator iterator; + + void operator()( vector_type& vec, iterator itInsert, iterator itWhat ) + { + typename vector_type::value_type newVal; + itInsert = vec.insert( itInsert, newVal ); + std::swap( *itInsert, *itWhat ); + } + }; + + // Move policy for boost::container::stable_vector + template + struct move_item_policy< boost::container::stable_vector< T, Alloc > > + { + typedef boost::container::stable_vector< T, Alloc > vector_type; + typedef typename vector_type::iterator iterator; + + void operator()( vector_type& vec, iterator itInsert, iterator itWhat ) + { + vec.insert( itInsert, std::move( *itWhat )); + } + }; + + } // namespace striped_set +}} // namespace cds::container + +namespace cds { namespace intrusive { namespace striped_set { + /// boost::container::stable_vector adapter for hash set bucket + template + class adapt< boost::container::stable_vector, Options... > + { + public: + typedef boost::container::stable_vector container_type ; ///< underlying container type + + private: + /// Adapted container type + class adapted_container: public cds::container::striped_set::adapted_sequential_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 = true; + static bool const has_erase_with = true; + + private: + //@cond + typedef typename cds::opt::details::make_comparator_from_option_list< value_type, Options... >::type key_comparator; + + 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 + , cds::container::striped_set::move_item, cds::container::striped_set::move_item_policy + >::type copy_item; + + struct find_predicate + { + bool operator()( value_type const& i1, value_type const& i2) const + { + return key_comparator()( i1, i2 ) < 0; + } + + template + bool operator()( Q const& i1, value_type const& i2) const + { + return key_comparator()( i1, i2 ) < 0; + } + + template + bool operator()( value_type const& i1, Q const& i2) const + { + return key_comparator()( i1, i2 ) < 0; + } + }; + //@endcond + + private: + //@cond + container_type m_Vector; + //@endcond + + public: + template + bool insert( const Q& val, Func f ) + { + iterator it = std::lower_bound( m_Vector.begin(), m_Vector.end(), val, find_predicate()); + if ( it == m_Vector.end() || key_comparator()( val, *it ) != 0 ) { + value_type newItem( val ); + it = m_Vector.insert( it, newItem ); + f( *it ); + return true; + } + return false; + } + + template + bool emplace( Args&&... args ) + { + value_type val( std::forward(args)... ); + iterator it = std::lower_bound( m_Vector.begin(), m_Vector.end(), val, find_predicate()); + if ( it == m_Vector.end() || key_comparator()( val, *it ) != 0 ) { + it = m_Vector.emplace( it, std::move( val )); + return true; + } + return false; + } + + template + std::pair update( const Q& val, Func func, bool bAllowInsert ) + { + iterator it = std::lower_bound( m_Vector.begin(), m_Vector.end(), val, find_predicate()); + if ( it == m_Vector.end() || key_comparator()( val, *it ) != 0 ) { + // insert new + if ( !bAllowInsert ) + return std::make_pair( false, false ); + + value_type newItem( val ); + it = m_Vector.insert( it, newItem ); + func( true, *it, val ); + return std::make_pair( true, true ); + } + else { + // already exists + func( false, *it, val ); + return std::make_pair( true, false ); + } + } + + template + bool erase( const Q& key, Func f ) + { + iterator it = std::lower_bound( m_Vector.begin(), m_Vector.end(), key, find_predicate()); + if ( it == m_Vector.end() || key_comparator()( key, *it ) != 0 ) + return false; + + // key exists + f( *it ); + m_Vector.erase( it ); + return true; + } + + template + bool erase( const Q& key, Less pred, Func f ) + { + iterator it = std::lower_bound( m_Vector.begin(), m_Vector.end(), key, pred ); + if ( it == m_Vector.end() || pred( key, *it ) || pred( *it, key )) + return false; + + // key exists + f( *it ); + m_Vector.erase( it ); + return true; + } + + template + bool find( Q& val, Func f ) + { + iterator it = std::lower_bound( m_Vector.begin(), m_Vector.end(), val, find_predicate()); + if ( it == m_Vector.end() || key_comparator()( val, *it ) != 0 ) + return false; + + // key exists + f( *it, val ); + return true; + } + + template + bool find( Q& val, Less pred, Func f ) + { + iterator it = std::lower_bound( m_Vector.begin(), m_Vector.end(), val, pred ); + if ( it == m_Vector.end() || pred( val, *it ) || pred( *it, val )) + return false; + + // key exists + f( *it, val ); + return true; + } + + /// Clears the container + void clear() + { + m_Vector.clear(); + } + + iterator begin() { return m_Vector.begin(); } + const_iterator begin() const { return m_Vector.begin(); } + iterator end() { return m_Vector.end(); } + const_iterator end() const { return m_Vector.end(); } + + void move_item( adapted_container& /*from*/, iterator itWhat ) + { + iterator it = std::lower_bound( m_Vector.begin(), m_Vector.end(), *itWhat, find_predicate()); + assert( it == m_Vector.end() || key_comparator()( *itWhat, *it ) != 0 ); + + copy_item()( m_Vector, it, itWhat ); + } + + size_t size() const + { + return m_Vector.size(); + } + }; + + public: + typedef adapted_container type ; ///< Result of \p adapt metafunction + + }; +}}} // namespace cds::intrusive::striped_set +//@endcond + +#endif // #ifndef CDSLIB_CONTAINER_STRIPED_SET_BOOST_STABLE_VECTOR_ADAPTER_H