swiftiply 0.6.1.1 → 1.0.0

data/ext/splaytree/swiftcore/splay_set.h

@@ -0,0 +1,575 @@
+//  splay_set.h -- implementation af a STL complatible set/multiset based on a splay tree.
+//  
+//  Copyright (c) 2004 Ralf Mattethat, Danish Technological Institute, Informatics
+//
+//  Permission to copy, use, modify, sell and distribute this software
+//  is granted provided this copyright notice appears in all copies.
+//  This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+//  Please send questions, comments, complaints, performance data, etc to  
+//  ralf.mattethat@teknologisk.dk
+
+#ifndef SPLAY_SET_H_RMA13022003
+#define SPLAY_SET_H_RMA13022003
+
+#include "splay_tree.h"
+
+#include <functional>
+
+/*	Requirements for element type
+	* must be copy-constructible
+	* destructor must not throw exception
+
+	Methods marked with note A only throws an exception if operator== or operator< 
+	or the used predicate throws an exception
+
+	iterators are only invalidated, if the element pointed to by the iterator 
+	is deleted. The same goes for element references
+*/
+
+namespace swiftcore
+{
+
+	template <typename T, typename Compare = std::less<T>, typename Allocator = std::allocator<T> >
+	class splay_set
+	{
+		// extract the keypart of a value of type T
+		struct KeyPart : public std::unary_function<T,T>
+		{
+			const T& operator()( const T& x ) const { return x; }
+		};
+	    
+		typedef detail::splay_tree<T, T, KeyPart, Compare, Allocator> Rep_type;
+
+	public:
+		// container
+		typedef typename Rep_type::key_type				key_type;
+		typedef typename Rep_type::value_type			value_type;
+		typedef Compare									key_compare;
+		typedef Compare									value_compare;
+		typedef typename Rep_type::reference			reference;
+		typedef typename Rep_type::const_reference		const_reference;
+		typedef typename Rep_type::size_type			size_type;
+		typedef typename Rep_type::difference_type		difference_type;
+
+		typedef typename Rep_type::allocator_type		allocator_type;
+		typedef typename Rep_type::pointer				pointer;
+		typedef typename Rep_type::const_pointer		const_pointer;
+
+		// container
+		typedef typename Rep_type::const_iterator		const_iterator;
+		typedef typename Rep_type::iterator				iterator;
+
+
+		// reversible container
+		typedef std::reverse_iterator<const_iterator>	const_reverse_iterator;
+		typedef std::reverse_iterator<iterator>			reverse_iterator;
+
+		/////////////////////////////////////////////////////////////////
+		// construct/copy/destroy:
+			
+		// container	| complexity : constant		| exception : 
+		explicit splay_set( const Compare& comp = Compare(), const allocator_type& a = Allocator() )
+			: rep_( comp, a )
+
+		{ }
+
+		// associative sequence		| complexity : linear/NlogN	| exception :
+		template <typename InputIterator>
+		splay_set( InputIterator first, InputIterator last, const Compare& comp = Compare(), const allocator_type& a = Allocator() )
+			: rep_( comp, a )
+		{ insert( first, last ); }
+
+		// container	| complexity : linear		| exception :
+		splay_set( const splay_set& x )
+			: rep_( x.rep_.key_comp(), x.rep_.get_allocator() )
+		{ insert( x.begin(), x.end() ); }
+
+		// container	| complexity : linear		| exception : nothrow
+		~splay_set()	{ }
+
+		// container	| complexity : linear		| exception : strong
+		splay_set& operator= ( const splay_set& rhs )
+		{
+			splay_set temp( rhs );
+			swap( temp );
+			return *this;
+		}
+
+		//				| complexity : constant		| exception : nothrow
+		allocator_type get_allocator() const { return rep_.get_allocator(); }
+
+
+		/////////////////////////////////////////////////////////////////
+		// iterators:
+		
+		// container	| complexity : constant		| exception : nothrow
+		iterator		begin()			{ return rep_.begin(); }
+		const_iterator	begin()	const	{ return rep_.begin(); }
+		iterator		end()			{ return rep_.end(); }
+		const_iterator	end()	const	{ return rep_.end(); }
+
+		// reversible container	| complexity : constant		| exception : nothrow
+		reverse_iterator		rbegin()		{ return reverse_iterator( end() ); }
+		const_reverse_iterator	rbegin() const	{ return const_reverse_iterator( end() ); }
+		reverse_iterator		rend()			{ return reverse_iterator( begin() ); }
+		const_reverse_iterator	rend()	 const	{ return const_reverse_iterator( begin() ); }
+
+
+		/////////////////////////////////////////////////////////////////
+		// capacity:
+		
+		// container	| complexity : constant		| exception : nothrow
+		bool empty() const			{ return rep_.empty(); }
+
+		// container	| complexity : constant		| exception : nothrow
+		size_type size() const		{ return rep_.size(); }
+
+		// container	| complexity : constant		| exception : nothrow
+		size_type max_size() const	{ return rep_.max_size(); }
+
+
+		/////////////////////////////////////////////////////////////////
+		// modifiers:
+		
+		// associative sequence		| complexity : logarithmic			| exception : strong
+		std::pair<iterator, bool> insert( const value_type& x )
+		{
+			return rep_.insert_unique( x );
+		}
+
+		// associative sequence		| complexity : constant/logarithmic	| exception : strong
+		iterator insert( iterator position, const value_type& x )
+		{
+			return rep_.insert_unique( position, x );
+		}
+
+		// associative sequence		| complexity : linear/NlogN			| exception : weak
+		template <typename InputIterator>
+		void insert( InputIterator first, InputIterator last )
+		{
+			rep_.insert_unique( first, last );
+		}
+	    
+		// associative sequence		| complexity : logarithmic			| exception : strong, note A
+		size_type erase( const key_type& x )
+		{
+			return rep_.erase( x );
+		}
+
+		// associative sequence		| complexity : constant				| exception : nothrow
+		void erase( iterator position )
+		{
+			rep_.erase( position );
+		}
+
+		// associative sequence		| complexity : d logN				| exception : nothrow
+		void erase( iterator first, iterator last )
+		{
+			rep_.erase( first, last );
+		}
+
+		// associative sequence		| complexity : linear				| exception : nothrow
+		void clear()
+		{
+			rep_.clear();
+		}
+
+		// container				| complexity : constant				| exception : nothrow
+		void swap( splay_set& x )
+		{
+			rep_.swap( x.rep_ );
+		}
+
+
+		/////////////////////////////////////////////////////////////////
+		// observers:
+		
+		// associative sequence		| complexity : constant		| exception : nothrow
+		key_compare key_comp()		const	{ return rep_.key_comp(); }
+		value_compare value_comp()	const	{ return rep_.key_comp(); }
+
+
+		/////////////////////////////////////////////////////////////////
+		// set operations:
+		
+ 		// associative sequence		| complexity : logarithmic		| exception : strong, note A
+		iterator find( const key_type& x )
+		{
+			return rep_.find( x );
+		}
+	 
+		// associative sequence		| complexity : logarithmic		| exception : strong, note A
+		const_iterator find( const key_type& x ) const
+		{
+			return rep_.find( x );
+ 		}
+
+		// associative sequence		| complexity : logarithmic		| exception : strong, note A
+		size_type count( const key_type& x ) const
+		{
+			return rep_.count( x );
+		}
+
+		// associative sequence		| complexity : logarithmic		| exception : strong, note A
+		iterator lower_bound( const key_type& x )
+		{
+			return rep_.lower_bound( x );
+		}
+
+		// associative sequence		| complexity : logarithmic		| exception : strong, note A
+		const_iterator lower_bound( const key_type& x ) const
+		{
+			return rep_.lower_bound( x );
+		}
+
+		// associative sequence		| complexity : logarithmic		| exception : strong, note A
+		iterator upper_bound( const key_type& x )
+		{
+			return rep_.upper_bound( x );
+		}
+
+		// associative sequence		| complexity : logarithmic		| exception : strong, note A
+		const_iterator upper_bound( const key_type& x ) const
+		{
+			return rep_.upper_bound( x );
+		}
+
+		// associative sequence		| complexity : logarithmic		| exception : strong, note A
+		std::pair<iterator, iterator> equal_range( const key_type& x )
+		{
+			return rep_.equal_range( x );
+		}
+
+		// associative sequence		| complexity : logarithmic		| exception : strong, note A
+		std::pair<const_iterator, const_iterator> equal_range( const key_type& x ) const
+		{
+			return rep_.equal_range( x );
+		}
+
+	private:
+		Rep_type rep_;
+	};
+
+	template <typename T, typename Compare = std::less<T>, typename Allocator = std::allocator<T> >
+	class splay_multiset
+	{
+		// extract the keypart of a value of type T
+		struct KeyPart : public std::unary_function<T,T>
+		{
+			const T& operator()( const T& x ) const { return x; }
+		};
+	    
+		typedef detail::splay_tree<T, T, KeyPart, Compare, Allocator> Rep_type;
+
+	public:
+		// container
+		typedef typename Rep_type::key_type				key_type;
+		typedef typename Rep_type::value_type			value_type;
+		typedef Compare									key_compare;
+		typedef Compare									value_compare;
+		typedef typename Rep_type::reference			reference;
+		typedef typename Rep_type::const_reference		const_reference;
+		typedef typename Rep_type::size_type			size_type;
+		typedef typename Rep_type::difference_type		difference_type;
+
+		typedef typename Rep_type::allocator_type		allocator_type;
+		typedef typename Rep_type::pointer				pointer;
+		typedef typename Rep_type::const_pointer		const_pointer;
+
+		// container
+		typedef typename Rep_type::const_iterator		const_iterator;
+		typedef typename Rep_type::iterator				iterator;
+
+
+		// reversible container
+		typedef std::reverse_iterator<const_iterator>	const_reverse_iterator;
+		typedef std::reverse_iterator<iterator>			reverse_iterator;
+
+		/////////////////////////////////////////////////////////////////
+		// construct/copy/destroy:
+			
+		// container	| complexity : constant		| exception : 
+		explicit splay_multiset( const Compare& comp = Compare(), const allocator_type& a = Allocator() )
+			: rep_( comp, a )
+		{ }
+
+		// associative sequence		| complexity : linear/NlogN	| exception : 
+		template <typename InputIterator>
+		splay_multiset( InputIterator first, InputIterator last, const Compare& comp = Compare(), const allocator_type& a = Allocator() )
+			: rep_( comp, a )
+		{ insert( first, last ); }
+
+		// container	| complexity : linear		| exception :
+		splay_multiset( const splay_multiset& x )
+			: rep_( x.rep_.key_comp(), x.rep_.get_allocator() )
+		{ insert( x.begin(), x.end() ); }
+
+		// container	| complexity : linear		| exception : nothrow
+		~splay_multiset()	{ }
+
+		// container	| complexity : linear		| exception : strong
+		splay_multiset& operator= ( const splay_multiset& rhs )
+		{
+			splay_multiset temp( rhs );
+			swap( temp );
+			return *this;
+		}
+
+		//				| complexity : constant		| exception : nothrow
+		allocator_type get_allocator() const { return rep_.get_allocator(); }
+
+
+		/////////////////////////////////////////////////////////////////
+		// iterators:
+		
+		// container	| complexity : constant		| exception : nothrow
+		iterator		begin()			{ return rep_.begin(); }
+		const_iterator	begin()	const	{ return rep_.begin(); }
+		iterator		end()			{ return rep_.end(); }
+		const_iterator	end()	const	{ return rep_.end(); }
+
+		// reversible container	| complexity : constant		| exception : nothrow
+		reverse_iterator		rbegin()		{ return reverse_iterator( end() ); }
+		const_reverse_iterator	rbegin() const	{ return const_reverse_iterator( end() ); }
+		reverse_iterator		rend()			{ return reverse_iterator( begin() ); }
+		const_reverse_iterator	rend()	 const	{ return const_reverse_iterator( begin() ); }
+
+
+		/////////////////////////////////////////////////////////////////
+		// capacity:
+		
+		// container	| complexity : constant		| exception : nothrow
+		bool empty() const			{ return rep_.empty(); }
+
+		// container	| complexity : constant		| exception : nothrow
+		size_type size() const		{ return rep_.size(); }
+
+		// container	| complexity : constant		| exception : nothrow
+		size_type max_size() const	{ return rep_.max_size(); }
+
+
+		/////////////////////////////////////////////////////////////////
+		// modifiers:
+		
+		// associative sequence		| complexity : logarithmic			| exception : strong
+		iterator insert( const value_type& x )
+		{
+			return rep_.insert_equal( x );
+		}
+
+		// associative sequence		| complexity : constant/logarithmic	| exception : strong
+		iterator insert( iterator position, const value_type& x )
+		{
+			return rep_.insert_equal( position, x );
+		}
+
+		// associative sequence		| complexity : linear/NlogN			| exception : weak
+		template <typename InputIterator>
+		void insert( InputIterator first, InputIterator last )
+		{
+			rep_.insert_equal( first, last );
+		}
+	    
+		// associative sequence		| complexity : logarithmic			| exception : strong, note A
+		size_type erase( const key_type& x )
+		{
+			return rep_.erase( x );
+		}
+
+		// associative sequence		| complexity : constant				| exception : nothrow
+		void erase( iterator position )
+		{
+			rep_.erase( position );
+		}
+
+		// associative sequence		| complexity : d logN				| exception : nothrow
+		void erase( iterator first, iterator last )
+		{
+			rep_.erase( first, last );
+		}
+
+		// associative sequence		| complexity : linear				| exception : nothrow
+		void clear()
+		{
+			rep_.clear();
+		}
+
+		// container				| complexity : constant				| exception : nothrow
+		void swap( splay_multiset& x )
+		{
+			rep_.swap( x.rep_ );
+		}
+
+
+		/////////////////////////////////////////////////////////////////
+		// observers:
+		
+		// associative sequence		| complexity : constant		| exception : nothrow
+		key_compare key_comp()		const	{ return rep_.key_comp(); }
+		value_compare value_comp()	const	{ return rep_.key_comp(); }
+
+
+		/////////////////////////////////////////////////////////////////
+		// set operations:
+		
+ 		// associative sequence		| complexity : logarithmic		| exception : strong, note A
+		iterator find( const key_type& x )
+		{
+			return rep_.find( x );
+		}
+	 
+		// associative sequence		| complexity : logarithmic		| exception : strong, note A
+		const_iterator find( const key_type& x ) const
+		{
+			return rep_.find( x );
+ 		}
+
+		// associative sequence		| complexity : logarithmic		| exception : strong, note A
+		size_type count( const key_type& x ) const
+		{
+			return rep_.count( x );
+		}
+
+		// associative sequence		| complexity : logarithmic		| exception : strong, note A
+		iterator lower_bound( const key_type& x )
+		{
+			return rep_.lower_bound( x );
+		}
+
+		// associative sequence		| complexity : logarithmic		| exception : strong, note A
+		const_iterator lower_bound( const key_type& x ) const
+		{
+			return rep_.lower_bound( x );
+		}
+
+		// associative sequence		| complexity : logarithmic		| exception : strong, note A
+		iterator upper_bound( const key_type& x )
+		{
+			return rep_.upper_bound( x );
+		}
+
+		// associative sequence		| complexity : logarithmic		| exception : strong, note A
+		const_iterator upper_bound( const key_type& x ) const
+		{
+			return rep_.upper_bound( x );
+		}
+
+		// associative sequence		| complexity : logarithmic		| exception : strong, note A
+		std::pair<iterator, iterator> equal_range( const key_type& x )
+		{
+			return rep_.equal_range( x );
+		}
+
+		// associative sequence		| complexity : logarithmic		| exception : strong, note A
+		std::pair<const_iterator, const_iterator> equal_range( const key_type& x ) const
+		{
+			return rep_.equal_range( x );
+		}
+
+	private:
+		Rep_type rep_;
+	};
+
+	// container	| complexity : linear		| exception : strong, note A
+	template <typename T, typename Compare, typename Allocator>
+	inline bool operator == ( const splay_set<T, Compare, Allocator>& lhs, const splay_set<T, Compare, Allocator>& rhs )
+	{
+		return lhs.size() == rhs.size() && std::equal( lhs.begin(), lhs.end(), rhs.begin() );
+	}
+
+	// container	| complexity : linear		| exception : strong, note A
+	template <typename T, typename Compare, typename Allocator>
+	inline bool operator < ( const splay_set<T, Compare, Allocator>& lhs, const splay_set<T, Compare, Allocator>& rhs )
+	{
+		return std::lexicographical_compare( lhs.begin(), lhs.end(), rhs.begin(), rhs.end() );
+	}
+
+	// container	| complexity : linear		| exception : strong, note A
+	template <typename T, typename Compare, typename Allocator>
+	inline bool operator != ( const splay_set<T, Compare, Allocator>& lhs, const splay_set<T, Compare, Allocator>& rhs )
+	{
+		return !( lhs == rhs );
+	}
+
+	// container	| complexity : linear		| exception : strong, note A
+	template <typename T, typename Compare, typename Allocator>
+	inline bool operator > ( const splay_set<T, Compare, Allocator>& lhs, const splay_set<T, Compare, Allocator>& rhs )
+	{
+		return rhs < lhs;
+	}
+
+	// container	| complexity : linear		| exception : strong, note A
+	template <typename T, typename Compare, typename Allocator>
+	inline bool operator <= ( const splay_set<T, Compare, Allocator>& lhs, const splay_set<T, Compare, Allocator>& rhs )
+	{
+		return !( rhs < lhs );
+	}
+
+	// container	| complexity : linear		| exception : strong, note A
+	template <typename T, typename Compare, typename Allocator>
+	inline bool operator >= ( const splay_set<T, Compare, Allocator>& lhs, const splay_set<T, Compare, Allocator>& rhs )
+	{
+		return !( lhs < rhs );
+	}
+
+	// container	| complexity : constant		| exception : nothrow
+	template <typename T, typename Compare, typename Allocator>
+	inline void swap( splay_set<T, Compare, Allocator>& x, splay_set<T, Compare, Allocator>& y )
+	{
+		x.swap( y );
+	}
+
+	// container	| complexity : linear		| exception : strong, note A
+	template <typename T, typename Compare, typename Allocator>
+	inline bool operator == ( const splay_multiset<T, Compare, Allocator>& lhs, const splay_multiset<T, Compare, Allocator>& rhs )
+	{
+		return lhs.size() == rhs.size() && std::equal( lhs.begin(), lhs.end(), rhs.begin() );
+	}
+
+	// container	| complexity : linear		| exception : strong, note A
+	template <typename T, typename Compare, typename Allocator>
+	inline bool operator < ( const splay_multiset<T, Compare, Allocator>& lhs, const splay_multiset<T, Compare, Allocator>& rhs )
+	{
+		return std::lexicographical_compare( lhs.begin(), lhs.end(), rhs.begin(), rhs.end() );
+	}
+
+	// container	| complexity : linear		| exception : strong, note A
+	template <typename T, typename Compare, typename Allocator>
+	inline bool operator != ( const splay_multiset<T, Compare, Allocator>& lhs, const splay_multiset<T, Compare, Allocator>& rhs )
+	{
+		return !( lhs == rhs );
+	}
+
+	// container	| complexity : linear		| exception : strong, note A
+	template <typename T, typename Compare, typename Allocator>
+	inline bool operator > ( const splay_multiset<T, Compare, Allocator>& lhs, const splay_multiset<T, Compare, Allocator>& rhs )
+	{
+		return rhs < lhs;
+	}
+
+	// container	| complexity : linear		| exception : strong, note A
+	template <typename T, typename Compare, typename Allocator>
+	inline bool operator <= ( const splay_multiset<T, Compare, Allocator>& lhs, const splay_multiset<T, Compare, Allocator>& rhs )
+	{
+		return !( rhs < lhs );
+	}
+
+	// container	| complexity : linear		| exception : strong, note A
+	template <typename T, typename Compare, typename Allocator>
+	inline bool operator >= ( const splay_multiset<T, Compare, Allocator>& lhs, const splay_multiset<T, Compare, Allocator>& rhs )
+	{
+		return !( lhs < rhs );
+	}
+
+	// container	| complexity : constant		| exception : nothrow
+	template <typename T, typename Compare, typename Allocator>
+	inline void swap( splay_multiset<T, Compare, Allocator>& x, splay_multiset<T, Compare, Allocator>& y )
+	{
+		x.swap( y );
+	}
+
+}	// namespace swiftcore
+
+#endif // SPLAY_SET_H_RMA13022003