test_insert.h File Reference

#include "Prefix.h"
#include <utility>
#include <vector>
#include <cassert>
#include <climits>
#include "random_number.h"
#include "nc_alloc.h"
#include "ThrowCompare.h"

Include dependency graph for test_insert.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	container_tag
struct	sequence_container_tag
struct	associative_container_tag
struct	set_tag
struct	multiset_tag
struct	map_tag
struct	multimap_tag
struct	identity< _Tp >
struct	select1st< _Pair >
struct	test_insert_one< C >
struct	test_insert_n< C >
struct	test_insert_value< C >
struct	test_insert_noresize< C >
struct	test_insert_range< C, Iter >

Functions
template<class C , class Iter >
size_t	CountNewItems (const C &, const Iter &firstNew, const Iter &lastNew, sequence_container_tag)
template<class C , class Iter >
size_t	CountNewItems (const C &c, const Iter &firstNew, const Iter &lastNew, multimap_tag)
template<class C , class Iter >
size_t	CountNewItems (const C &c, const Iter &firstNew, const Iter &lastNew, multiset_tag)
template<class C , class Iter , class KeyOfValue >
size_t	CountUniqueItems_Aux (const C &original, Iter firstNew, Iter lastNew, const KeyOfValue &keyOfValue)
template<class C , class Iter >
EH_END_NAMESPACE size_t	CountUniqueItems (const C &original, const Iter &firstNew, const Iter &lastNew, set_tag)
template<class C , class Iter >
size_t	CountUniqueItems (const C &original, const Iter &firstNew, const Iter &lastNew, map_tag)
template<class C , class Iter >
size_t	CountNewItems (const C &original, const Iter &firstNew, const Iter &lastNew, map_tag)
template<class C , class Iter >
size_t	CountNewItems (const C &original, const Iter &firstNew, const Iter &lastNew, set_tag)
template<class C , class SrcIter >
void	VerifyInsertion (const C &original, const C &result, const SrcIter &firstNew, const SrcIter &lastNew, size_t, associative_container_tag)
template<class C , class SrcIter >
void	VerifyInsertion (const C &original, const C &result, const SrcIter &firstNew, const SrcIter &lastNew, size_t, set_tag)
template<class C , class SrcIter >
void	VerifyInsertion (const C &original, const C &result, const SrcIter &firstNew, const SrcIter &lastNew, size_t, multiset_tag)
template<class C , class SrcIter >
void	VerifyInsertion (const C &original, const C &result, const SrcIter &firstNew, const SrcIter &lastNew, size_t, map_tag)
template<class C , class SrcIter >
void	VerifyInsertion (const C &original, const C &result, const SrcIter &firstNew, const SrcIter &lastNew, size_t, multimap_tag)
template<class C , class SrcIter >
void	VerifyInsertion (const C &original, const C &result, const SrcIter &firstNew, const SrcIter &lastNew, size_t insPos, sequence_container_tag)
template<class C , class SrcIter >
void	VerifyInsertion (const C &original, const C &result, const SrcIter &firstNew, const SrcIter &lastNew, size_t insPos)
template<class C , class Value >
void	VerifyInsertN (const C &original, const C &result, size_t insCnt, const Value &val, size_t insPos)
template<class C >
void	prepare_insert_n (C &, size_t)
void	MakeRandomValue (bool &b)
template<class T >
void	MakeRandomValue (T &)
template<class C , class Position , class Iter >
void	do_insert_range (C &c_inst, Position offset, Iter first, Iter last, sequence_container_tag)
template<class C , class Position , class Iter >
void	do_insert_range (C &c, Position, Iter first, Iter last, associative_container_tag)
template<class C , class Position , class Iter >
void	do_insert_range (C &c, Position, Iter first, Iter last, multiset_tag)
template<class C , class Position , class Iter >
void	do_insert_range (C &c, Position, Iter first, Iter last, multimap_tag)
template<class C , class Position , class Iter >
void	do_insert_range (C &c, Position, Iter first, Iter last, set_tag)
template<class C , class Position , class Iter >
void	do_insert_range (C &c, Position, Iter first, Iter last, map_tag)
template<class C , class Iter >
test_insert_range< C, Iter >	insert_range_tester (const C &orig, const Iter &first, const Iter &last)
template<class C , class Iter >
test_insert_range< C, Iter >	insert_range_at_begin_tester (const C &orig, const Iter &first, const Iter &last)
template<class C , class Iter >
test_insert_range< C, Iter >	insert_range_at_end_tester (const C &orig, const Iter &first, const Iter &last)

Function Documentation

CountNewItems() [1/5]

template<class C , class Iter >

size_t CountNewItems	(	const C &	,
		const Iter &	firstNew,
		const Iter &	lastNew,
		sequence_container_tag
	)

Definition at line 45 of file test_insert.h.

{
    size_t dist = 0;
#if 0 //def __SUNPRO_CC
    EH_DISTANCE( firstNew, lastNew, dist );
#else
    EH_DISTANCE( Iter(firstNew), Iter(lastNew), dist );
#endif
    return dist;
}

Referenced by CountNewItems(), and VerifyInsertion().

CountNewItems() [2/5]

template<class C , class Iter >

size_t CountNewItems	(	const C &	c,
		const Iter &	firstNew,
		const Iter &	lastNew,
		multimap_tag
	)

Definition at line 58 of file test_insert.h.

{
    return CountNewItems( c, firstNew, lastNew, sequence_container_tag() );
}

CountNewItems() [3/5]

template<class C , class Iter >

size_t CountNewItems	(	const C &	c,
		const Iter &	firstNew,
		const Iter &	lastNew,
		multiset_tag
	)

Definition at line 65 of file test_insert.h.

{
    return CountNewItems( c, firstNew, lastNew, sequence_container_tag() );
}

CountNewItems() [4/5]

template<class C , class Iter >

size_t CountNewItems	(	const C &	original,
		const Iter &	firstNew,
		const Iter &	lastNew,
		map_tag
	)

Definition at line 149 of file test_insert.h.

{
    return CountUniqueItems( original, firstNew, lastNew,
                             container_category( original ) );
}

CountNewItems() [5/5]

template<class C , class Iter >

size_t CountNewItems	(	const C &	original,
		const Iter &	firstNew,
		const Iter &	lastNew,
		set_tag
	)

Definition at line 157 of file test_insert.h.

{
    return CountUniqueItems( original, firstNew, lastNew,
                             container_category( original ) );
}

CountUniqueItems() [1/2]

template<class C , class Iter >

size_t CountUniqueItems	(	const C &	original,
		const Iter &	firstNew,
		const Iter &	lastNew,
		map_tag
	)

Definition at line 135 of file test_insert.h.

{
#ifdef EH_MULTI_CONST_TEMPLATE_ARG_BUG
    return CountUniqueItems_Aux( original, firstNew, lastNew,
                                 EH_SELECT1ST_HINT<C::value_type, C::key_type>() );
#else
    typedef typename C::value_type value_type;
    return CountUniqueItems_Aux( original, firstNew, lastNew,
                                 EH_STD::select1st<value_type>() );
#endif
}

CountUniqueItems() [2/2]

template<class C , class Iter >

EH_END_NAMESPACE size_t CountUniqueItems	(	const C &	original,
		const Iter &	firstNew,
		const Iter &	lastNew,
		set_tag
	)

Definition at line 126 of file test_insert.h.

{
    typedef typename C::value_type value_type;
    return CountUniqueItems_Aux( original, firstNew, lastNew,
                                 EH_STD::identity<value_type>() );
}

Referenced by CountNewItems().

CountUniqueItems_Aux()

template<class C , class Iter , class KeyOfValue >

size_t CountUniqueItems_Aux	(	const C &	original,
		Iter	firstNew,
		Iter	lastNew,
		const KeyOfValue &	keyOfValue
	)

Definition at line 76 of file test_insert.h.

{
  typedef typename C::key_type key;
  typedef typename C::const_iterator const_iter;
  typedef EH_STD::vector<key> key_list;
  typedef typename key_list::iterator key_iterator;
  key_list keys;
  size_t dist = 0;
#ifdef __SUNPRO_CC
  EH_DISTANCE( firstNew, lastNew, dist );
#else
  EH_DISTANCE( Iter(firstNew), Iter(lastNew), dist );
#endif
  keys.reserve( dist );
  for ( Iter x = firstNew; x != lastNew; ++x )
    keys.push_back( keyOfValue(*x) );
 
  EH_STD::sort( keys.begin(), keys.end() );
  key_iterator last = EH_STD::unique( keys.begin(), keys.end() );
 
    size_t cnt = 0;
    for ( key_iterator tmp = keys.begin(); tmp != last; ++tmp )
    {
        if ( const_iter(original.find( *tmp )) == const_iter(original.end()) )
            ++cnt;
    }
    return cnt;
}

Referenced by CountUniqueItems().

do_insert_range() [1/6]

template<class C , class Position , class Iter >

void do_insert_range	(	C &	c,
		Position	,
		Iter	first,
		Iter	last,
		associative_container_tag
	)

Definition at line 461 of file test_insert.h.

{
    c.insert( first, last );
}

do_insert_range() [2/6]

template<class C , class Position , class Iter >

void do_insert_range	(	C &	c,
		Position	,
		Iter	first,
		Iter	last,
		map_tag
	)

Definition at line 486 of file test_insert.h.

{
    c.insert( first, last );
}

do_insert_range() [3/6]

template<class C , class Position , class Iter >

void do_insert_range	(	C &	c,
		Position	,
		Iter	first,
		Iter	last,
		multimap_tag
	)

Definition at line 474 of file test_insert.h.

{
    c.insert( first, last );
}

do_insert_range() [4/6]

template<class C , class Position , class Iter >

void do_insert_range	(	C &	c,
		Position	,
		Iter	first,
		Iter	last,
		multiset_tag
	)

Definition at line 468 of file test_insert.h.

{
    c.insert( first, last );
}

do_insert_range() [5/6]

template<class C , class Position , class Iter >

void do_insert_range	(	C &	c,
		Position	,
		Iter	first,
		Iter	last,
		set_tag
	)

Definition at line 480 of file test_insert.h.

{
    c.insert( first, last );
}

do_insert_range() [6/6]

template<class C , class Position , class Iter >

void do_insert_range	(	C &	c_inst,
		Position	offset,
		Iter	first,
		Iter	last,
		sequence_container_tag
	)

Definition at line 451 of file test_insert.h.

{
    typedef typename C::iterator CIter;
    CIter pos = c_inst.begin();
    EH_STD::advance( pos, offset );
    c_inst.insert( pos, first, last );
}

Referenced by test_insert_range< C, Iter >::operator()().

insert_range_at_begin_tester()

template<class C , class Iter >

test_insert_range< C, Iter > insert_range_at_begin_tester	(	const C &	orig,
		const Iter &	first,
		const Iter &	last
	)

Definition at line 541 of file test_insert.h.

{
  return test_insert_range<C, Iter>( orig, first, last , 0);
}

Referenced by test_bit_vector(), test_deque(), test_list(), test_rope(), test_string(), and test_vector().

insert_range_at_end_tester()

template<class C , class Iter >

test_insert_range< C, Iter > insert_range_at_end_tester	(	const C &	orig,
		const Iter &	first,
		const Iter &	last
	)

Definition at line 547 of file test_insert.h.

{
  return test_insert_range<C, Iter>( orig, first, last , (int)orig.size());
}

Referenced by test_bit_vector(), test_deque(), test_list(), test_rope(), test_string(), and test_vector().

insert_range_tester()

template<class C , class Iter >

test_insert_range< C, Iter > insert_range_tester	(	const C &	orig,
		const Iter &	first,
		const Iter &	last
	)

Definition at line 535 of file test_insert.h.

{
    return test_insert_range<C, Iter>( orig, first, last );
}

Referenced by test_bit_vector(), test_deque(), test_hash_map(), test_hash_multimap(), test_hash_multiset(), test_hash_set(), test_list(), test_map(), test_multimap(), test_multiset(), test_rope(), test_set(), test_slist(), test_string(), and test_vector().

MakeRandomValue() [1/2]

void MakeRandomValue ( bool &  b )

inline

Definition at line 322 of file test_insert.h.

{ b = bool(random_number(2) != 0); }

Referenced by test_insert_n< C >::test_insert_n(), test_insert_noresize< C >::test_insert_noresize(), test_insert_one< C >::test_insert_one(), and test_insert_value< C >::test_insert_value().

MakeRandomValue() [2/2]

template<class T >

void MakeRandomValue ( T &  )

inline

Definition at line 325 of file test_insert.h.

{}

prepare_insert_n()

template<class C >

void prepare_insert_n	(	C &	,
		size_t
	)

Definition at line 318 of file test_insert.h.

{}

Referenced by test_insert_one< C >::operator()(), and test_insert_n< C >::operator()().

VerifyInsertion() [1/7]

template<class C , class SrcIter >

void VerifyInsertion ( const C &  original, const C &  result, const SrcIter &  firstNew, const SrcIter &  lastNew, size_t  insPos  )

inline

Definition at line 281 of file test_insert.h.

{
    EH_ASSERT( result.size() == original.size() +
            CountNewItems( original, firstNew, lastNew,
                           container_category(original) ) );
    VerifyInsertion( original, result, firstNew, lastNew, insPos,
                     container_category(original) );
}

VerifyInsertion() [2/7]

template<class C , class SrcIter >

void VerifyInsertion	(	const C &	original,
		const C &	result,
		const SrcIter &	firstNew,
		const SrcIter &	lastNew,
		size_t	insPos,
		sequence_container_tag
	)

Definition at line 254 of file test_insert.h.

{
    typename C::const_iterator p1 = original.begin();
    typename C::const_iterator p2 = result.begin();
    SrcIter tmp(firstNew);
 
    for ( size_t n = 0; n < insPos; n++, ++p1, ++p2)
        EH_ASSERT( *p1 == *p2 );
 
    for (; tmp != lastNew; ++p2, ++tmp ) {
        EH_ASSERT(p2 != result.end());
        EH_ASSERT(*p2 == *tmp);
    }
 
    for (;  p2 != result.end(); ++p1, ++p2 )
        EH_ASSERT( *p1 == *p2 );
    EH_ASSERT( p1 == original.end() );
}

VerifyInsertion() [3/7]

template<class C , class SrcIter >

void VerifyInsertion ( const C &  original, const C &  result, const SrcIter &  firstNew, const SrcIter &  lastNew, size_t  , associative_container_tag    )

inline

Definition at line 165 of file test_insert.h.

{
    typedef typename C::const_iterator DstIter;
    DstIter first1 = original.begin();
    DstIter first2 = result.begin();
 
    DstIter* from_orig = new DstIter[original.size()];
    DstIter* last_from_orig = from_orig;
 
    // fbp : for hashed containers, the following is needed :
    while ( first2 != result.end() )
    {
        EH_STD::pair<DstIter, DstIter> p = EH_STD::mismatch( first1, original.end(), first2 );
        if ( p.second != result.end() )
        {
            SrcIter srcItem = EH_STD::find( SrcIter(firstNew), SrcIter(lastNew), *p.second );
 
            if (srcItem == lastNew)
            {
                // not found in input range, probably re-ordered from the orig
                DstIter* tmp;
                tmp = EH_STD::find( from_orig, last_from_orig, p.first );
 
                // if already here, exclude
                if (tmp != last_from_orig)
                {
                    EH_STD::copy(tmp+1, last_from_orig, tmp);
                    last_from_orig--;
                }
                else
                {
                    // register re-ordered element
                    DstIter dstItem;
                    dstItem = EH_STD::find( first1, original.end(), *p.first );
                    EH_ASSERT( dstItem != original.end() );
                    *last_from_orig = dstItem;
                    last_from_orig++;
                    ++p.first;
                }
            }
            ++p.second;
        }
        first1 = p.first;
        first2 = p.second;
    }
 
    delete [] from_orig;
}

Referenced by test_insert_one< C >::operator()(), test_insert_value< C >::operator()(), test_insert_noresize< C >::operator()(), test_insert_range< C, Iter >::operator()(), and VerifyInsertion().

VerifyInsertion() [4/7]

template<class C , class SrcIter >

void VerifyInsertion ( const C &  original, const C &  result, const SrcIter &  firstNew, const SrcIter &  lastNew, size_t  , map_tag    )

inline

Definition at line 236 of file test_insert.h.

{
    VerifyInsertion( original, result, firstNew, lastNew,
                     size_t(0), associative_container_tag() );
}

VerifyInsertion() [5/7]

template<class C , class SrcIter >

void VerifyInsertion ( const C &  original, const C &  result, const SrcIter &  firstNew, const SrcIter &  lastNew, size_t  , multimap_tag    )

inline

Definition at line 245 of file test_insert.h.

{
    VerifyInsertion( original, result, firstNew, lastNew,
                     size_t(0), associative_container_tag() );
}

VerifyInsertion() [6/7]

template<class C , class SrcIter >

void VerifyInsertion ( const C &  original, const C &  result, const SrcIter &  firstNew, const SrcIter &  lastNew, size_t  , multiset_tag    )

inline

Definition at line 227 of file test_insert.h.

{
    VerifyInsertion( original, result, firstNew, lastNew,
                     size_t(0), associative_container_tag() );
}

VerifyInsertion() [7/7]

template<class C , class SrcIter >

void VerifyInsertion ( const C &  original, const C &  result, const SrcIter &  firstNew, const SrcIter &  lastNew, size_t  , set_tag    )

inline

Definition at line 218 of file test_insert.h.

{
    VerifyInsertion( original, result, firstNew, lastNew,
                     size_t(0), associative_container_tag() );
}

VerifyInsertN()

template<class C , class Value >

void VerifyInsertN	(	const C &	original,
		const C &	result,
		size_t	insCnt,
		const Value &	val,
		size_t	insPos
	)

Definition at line 293 of file test_insert.h.

{
    typename C::const_iterator p1 = original.begin();
    typename C::const_iterator p2 = result.begin();
  (void)val;    //*TY 02/06/2000 - to suppress unused variable warning under nondebug build
 
    for ( size_t n = 0; n < insPos; n++ )
        EH_ASSERT( *p1++ == *p2++ );
 
    while ( insCnt-- > 0 )
    {
        EH_ASSERT(p2 != result.end());
        EH_ASSERT(*p2 == val );
        ++p2;
    }
 
    while ( p2 != result.end() ) {
        EH_ASSERT( *p1 == *p2 );
        ++p1; ++p2;
    }
    EH_ASSERT( p1 == original.end() );
}

Referenced by test_insert_n< C >::operator()().