#include <TestClassSimpleContainers.h>

Collaboration diagram for TestClassSimpleContainers:

Public Member Functions
	TestClassSimpleContainers ()

	~TestClassSimpleContainers ()

void	setNonZero ()

bool	operator== (const TestClassSimpleContainers &rhs) const

bool	operator!= (const TestClassSimpleContainers &rhs) const

std::ostream &	streamOut (std::ostream &os) const

Public Attributes
std::vector< int >	m_vector_of_int

std::list< double >	m_list_of_double

std::map< std::string, long >	m_map_of_string_to_long

std::set< unsigned short >	m_set_of_ushort

std::deque< float >	m_deque_of_float

Detailed Description

Definition at line 16 of file TestClassSimpleContainers.h.

Constructor & Destructor Documentation

◆ TestClassSimpleContainers()

TestClassSimpleContainers::TestClassSimpleContainers ( )

inline

Definition at line 19 of file TestClassSimpleContainers.h.

                              :
     m_vector_of_int(),
     m_list_of_double(),
     m_map_of_string_to_long(),
     m_set_of_ushort(),
     m_deque_of_float()
   {}

◆ ~TestClassSimpleContainers()

TestClassSimpleContainers::~TestClassSimpleContainers ( )

inline

Definition at line 27 of file TestClassSimpleContainers.h.

27 {}

Member Function Documentation

◆ operator!=()

bool TestClassSimpleContainers::operator!= ( const TestClassSimpleContainers & rhs ) const

inline

Definition at line 155 of file TestClassSimpleContainers.h.

 {
   return ( ( (*this) == rhs ) ? false : true );
 }

◆ operator==()

bool TestClassSimpleContainers::operator== ( const TestClassSimpleContainers & rhs ) const

inline

Definition at line 100 of file TestClassSimpleContainers.h.

 {
   // Check first the sizes of the containers
   if ( m_vector_of_int.size() != rhs.m_vector_of_int.size() ) return false;
   if ( m_list_of_double.size() != rhs.m_list_of_double.size() ) return false;
   if ( m_map_of_string_to_long.size() != rhs.m_map_of_string_to_long.size() ) return false;
   if ( m_set_of_ushort.size() != rhs.m_set_of_ushort.size() ) return false;/*
                                                                              if ( m_deque_of_float.size() != rhs.m_deque_of_float.size() ) return false;*/
  
   // Check element by element.
   std::vector< int >::const_iterator this_i_vector_of_int = m_vector_of_int.begin();
   std::vector< int >::const_iterator rhs_i_vector_of_int = rhs.m_vector_of_int.begin();
   while ( this_i_vector_of_int != m_vector_of_int.end() ) {
     if ( *this_i_vector_of_int != *rhs_i_vector_of_int ) return false;
     ++this_i_vector_of_int;
     ++rhs_i_vector_of_int;
   }
  
   std::list< double >::const_iterator this_i_list_of_double = m_list_of_double.begin();
   std::list< double >::const_iterator rhs_i_list_of_double = rhs.m_list_of_double.begin();
   while ( this_i_list_of_double != m_list_of_double.end() ) {
     if ( *this_i_list_of_double != *rhs_i_list_of_double ) return false;
     ++this_i_list_of_double;
     ++rhs_i_list_of_double;
   }
  
   std::map< std::string, long >::const_iterator this_i_map_of_string_to_long = m_map_of_string_to_long.begin();
   std::map< std::string, long >::const_iterator rhs_i_map_of_string_to_long = rhs.m_map_of_string_to_long.begin();
   while ( this_i_map_of_string_to_long != m_map_of_string_to_long.end() ) {
     if ( this_i_map_of_string_to_long->first != rhs_i_map_of_string_to_long->first ||
          this_i_map_of_string_to_long->second != rhs_i_map_of_string_to_long->second ) return false;
     ++this_i_map_of_string_to_long;
     ++rhs_i_map_of_string_to_long;
   }
  
   std::set< unsigned short >::const_iterator this_i_set_of_ushort = m_set_of_ushort.begin();
   std::set< unsigned short >::const_iterator rhs_i_set_of_ushort = rhs.m_set_of_ushort.begin();
   while ( this_i_set_of_ushort != m_set_of_ushort.end() ) {
     if ( *this_i_set_of_ushort != *rhs_i_set_of_ushort ) return false;
     ++this_i_set_of_ushort;
     ++rhs_i_set_of_ushort;
   }
  
   std::deque< float >::const_iterator this_i_deque_of_float = m_deque_of_float.begin();
   std::deque< float >::const_iterator rhs_i_deque_of_float = rhs.m_deque_of_float.begin();
   while ( this_i_deque_of_float != m_deque_of_float.end() ) {
     if ( *this_i_deque_of_float != *rhs_i_deque_of_float ) return false;
     ++this_i_deque_of_float;
     ++rhs_i_deque_of_float;
   }
  
   return true;
 }

◆ setNonZero()

void TestClassSimpleContainers::setNonZero ( )

inline

Definition at line 43 of file TestClassSimpleContainers.h.

 {
   m_vector_of_int.clear();
   m_vector_of_int.push_back( 1 );
   m_list_of_double.clear();
   m_list_of_double.push_back( 2 );
   m_list_of_double.push_back( 3 );
   m_map_of_string_to_long.clear();
   m_map_of_string_to_long.insert( std::make_pair( std::string( "key1" ), 4L ) );
   m_map_of_string_to_long.insert( std::make_pair( std::string( "key2" ), 5L ) );
   m_set_of_ushort.clear();
   m_set_of_ushort.insert( 6 );
   m_set_of_ushort.insert( 7 );
   m_set_of_ushort.insert( 8 );
   m_deque_of_float.clear();
   m_deque_of_float.push_back( 9 );
   m_deque_of_float.push_front( 10 );
 }

◆ streamOut()

std::ostream & TestClassSimpleContainers::streamOut ( std::ostream & os ) const

inline

Definition at line 63 of file TestClassSimpleContainers.h.

 {
   os << "m_vector_of_int( " << m_vector_of_int.size() << " ) :";
   for ( std::vector< int >::const_iterator i = m_vector_of_int.begin();
         i != m_vector_of_int.end(); ++i ) {
     os << " " << *i;
   }
   os << std::endl;
   os << "m_list_of_double( " << m_list_of_double.size() << " ) :";
   for ( std::list< double >::const_iterator i = m_list_of_double.begin();
         i != m_list_of_double.end(); ++i ) {
     os << " " << *i;
   }
   os << std::endl;
   os << "m_map_of_string_to_long( " << m_map_of_string_to_long.size() << " ) :";
   for ( std::map< std::string, long >::const_iterator i = m_map_of_string_to_long.begin();
         i != m_map_of_string_to_long.end(); ++i ) {
     os << " (" << i->first << "," << i->second << ")";
   }
   os << std::endl;
   os << "m_set_of_ushort( " << m_set_of_ushort.size() << " ) :";
   for ( std::set< unsigned short >::const_iterator i = m_set_of_ushort.begin();
         i != m_set_of_ushort.end(); ++i ) {
     os << " " << *i;
   }
  
   os << std::endl;
   os << "m_deque_of_float( " << m_deque_of_float.size() << " ) :";
   for ( std::deque< float >::const_iterator i = m_deque_of_float.begin();
         i != m_deque_of_float.end(); ++i ) {
     os << " " << *i;
   }
  
   return os;
 }