[Cpptool-cvs] CppParser/include/cpput assertenum.h,1.1.1.1,1.2 stringize.h,1.1.1.1,1.2

[Baptiste L. <bl...@us...>]

Update of /cvsroot/cpptool/CppParser/include/cpput
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv27491/include/cpput

Modified Files:
	assertenum.h stringize.h 
Log Message:
* fixed namespace resolution issue N1::N1

Index: assertenum.h
===================================================================
RCS file: /cvsroot/cpptool/CppParser/include/cpput/assertenum.h,v
retrieving revision 1.1.1.1
retrieving revision 1.2
diff -C2 -d -r1.1.1.1 -r1.2
*** assertenum.h	8 Jun 2004 20:23:19 -0000	1.1.1.1
--- assertenum.h	14 Jun 2004 23:08:12 -0000	1.2
***************
*** 44,51 ****
        template<class ExpectedEnumType
                ,class ActualEnumType
!               ,class EqualityComparator>
        unsigned int getSequenceDiffIndex( ExpectedEnumType expected, 
                                           ActualEnumType actual,
!                                          EqualityComparator comparator )
        {
           unsigned int diffIndex = 0;
--- 44,51 ----
        template<class ExpectedEnumType
                ,class ActualEnumType
!               ,class EqualityPredicate>
        unsigned int getSequenceDiffIndex( ExpectedEnumType expected, 
                                           ActualEnumType actual,
!                                          EqualityPredicate comparator )
        {
           unsigned int diffIndex = 0;
***************
*** 105,115 ****
     enum { noDifference = -1 };
  
!    template<class ExpectedSeqType
!            ,class ActualSeqType
!            ,class EqualityComparator>
!    void checkSequenceEqual( const ExpectedSeqType &expected,
!                             const ActualSeqType &actual,
!                             EqualityComparator comparator,
!                             const Message &message )
     {
        unsigned int diffIndex = Impl::getSequenceDiffIndex( expected.clone(), 
--- 105,119 ----
     enum { noDifference = -1 };
  
!    template<class ExpectedEnumerator
!            ,class ActualEnumerator
!            ,class ExpectedStringizer
!            ,class ActualStringizer
!            ,class EqualityPredicate>
!    void checkCustomHeterogeneousSequenceEqual( const ExpectedEnumerator &expected,
!                                                const ActualEnumerator &actual,
!                                                ExpectedStringizer expectedStringizer,
!                                                ActualStringizer actualStringizer,
!                                                EqualityPredicate comparator,
!                                                const Message &message )
     {
        unsigned int diffIndex = Impl::getSequenceDiffIndex( expected.clone(), 
***************
*** 119,125 ****
           return;
  
!       ExpectedSeqType common = enumSlice( expected, 0, diffIndex );
!       ExpectedSeqType expectedDiff = enumSlice( expected, diffIndex );
!       ActualSeqType actualDiff = enumSlice( actual, diffIndex );
  
        Message newMessage( message );
--- 123,129 ----
           return;
  
!       ExpectedEnumerator common = enumSlice( expected, 0, diffIndex );
!       ExpectedEnumerator expectedDiff = enumSlice( expected, diffIndex );
!       ActualEnumerator actualDiff = enumSlice( actual, diffIndex );
  
        Message newMessage( message );
***************
*** 127,178 ****
        newMessage.add( translate( "Divergence position (0 based): " ) + stringize(diffIndex) );
        if ( common.length() > 0 )
!          newMessage.add( translate( "Common:\n" ) + enumToString(common) );
!       newMessage.add( translate( "Expected:\n" ) + enumToString(expectedDiff) );
!       newMessage.add( translate( "Actual:\n" ) + enumToString(actualDiff) );
        fail( newMessage );
     }
  
!    template<class ExpectedSeqType
!            ,class ActualSeqType
!            ,class EqualityComparator>
!    void checkStlSequenceEqual( const ExpectedSeqType &expected,
!                                const ActualSeqType &actual,
!                                EqualityComparator comparator,
!                                const Message &message  = Message() )
     {
!       checkSequenceEqual( enumStl( expected ), enumStl( actual ), comparator, message );
     }
  
!    template<class ExpectedSeqType
!            ,class ActualSeqType>
!    void checkStlSequenceEqual( const ExpectedSeqType &expected,
!                                const ActualSeqType &actual,
!                                const Message &message  = Message() )
     {
!       checkSequenceEqual( enumStl( expected ), enumStl( actual ), message );
     }
  
  
!    template<class ExpectedSeqType
!            ,class ActualSeqType>
!    void checkSequenceEqual( const ExpectedSeqType &expected,
!                             const ActualSeqType &actual,
                              const Message &message  = Message() )
     {
!       DefaultComparator<ExpectedSeqType::Type
!                        ,ActualSeqType::Type> comparator;
!       checkSequenceEqual( expected, actual, comparator, message );
     }
  
!    template<class ExpectedSetType
!            ,class ActualSetType
             ,class EqualityPredicate>
!    void checkSetEqual( const ExpectedSetType &expected,
!                        const ActualSetType &actual,
!                        EqualityPredicate predicate,
!                        const Message &message )
     {
!       std::deque<ExpectedSetType::Type> missing;
!       std::deque<ActualSetType::Type> extraneous;
        Impl::getSetDifference( expected, actual,
                                missing, extraneous,
--- 131,233 ----
        newMessage.add( translate( "Divergence position (0 based): " ) + stringize(diffIndex) );
        if ( common.length() > 0 )
!          newMessage.add( translate( "Common:\n" ) + enumToStringCustom(common,  
!                                                                        expectedStringizer) );
!       newMessage.add( translate( "Expected:\n" ) + enumToStringCustom(expectedDiff, 
!                                                                       expectedStringizer) );
!       newMessage.add( translate( "Actual:\n" ) + enumToStringCustom(actualDiff, 
!                                                                     actualStringizer) );
        fail( newMessage );
     }
  
!    template<class EnumeratorType
!            ,class StringizerType
!            ,class EqualityPredicate>
!    void checkCustomSequenceEqual( const EnumeratorType &expected,
!                                   const EnumeratorType &actual,
!                                   StringizerType stringizer,
!                                   EqualityPredicate comparator,
!                                   const Message &message )
     {
!       checkCustomHeterogeneousSequenceEqual( expected, actual,
!                                              stringizer, stringizer,
!                                              comparator, message );
     }
  
!    template<class EnumeratorType
!            ,class StringizerType
!            ,class EqualityPredicate>
!    void checkCustomStringSequenceEqual( const EnumeratorType &expected,
!                                         const EnumeratorType &actual,
!                                         StringizerType stringizer,
!                                         const Message &message = Message() )
     {
!       DefaultComparator<EnumeratorType::Type,EnumeratorType::Type> comparator;
!       checkCustomHeterogeneousSequenceEqual( expected, actual,
!                                              stringizer, stringizer,
!                                              comparator, message );
!    }
! 
!    template<class ExpectedEnumerator
!            ,class ActualEnumerator
!            ,class EqualityPredicate>
!    void checkCustomEqualitySequenceEqual( const ExpectedEnumerator &expected,
!                                           const ActualEnumerator &actual,
!                                           EqualityPredicate comparator,
!                                           const Message &message = Message() )
!    {
!       typedef DefaultStringizer<CPPUT_DEDUCED_TYPENAME ExpectedEnumerator::Type> ExpectedStringizer;
!       typedef DefaultStringizer<CPPUT_DEDUCED_TYPENAME ActualEnumerator::Type> ActualStringizer;
!       checkCustomHeterogeneousSequenceEqual( expected, actual,
!                                              ExpectedStringizer(), ActualStringizer(),
!                                              comparator, message );
     }
  
  
!    template<class ExpectedEnumeratorType
!            ,class ActualEnumeratorType>
!    void checkSequenceEqual( const ExpectedEnumeratorType &expected,
!                             const ActualEnumeratorType &actual,
                              const Message &message  = Message() )
     {
!       DefaultComparator<ExpectedEnumeratorType::Type
!                        ,ActualEnumeratorType::Type> comparator;
!       checkCustomEqualitySequenceEqual( expected, actual, comparator, message );
     }
  
!    template<class ExpectedEnumeratorType
!            ,class ActualEnumeratorType
             ,class EqualityPredicate>
!    void checkCustomEqualityStlSequenceEqual( const ExpectedEnumeratorType &expected,
!                                              const ActualEnumeratorType &actual,
!                                              EqualityPredicate comparator,
!                                              const Message &message  = Message() )
     {
!       checkCustomEqualitySequenceEqual( enumStl( expected ), enumStl( actual ), 
!                                         comparator, message );
!    }
! 
!    template<class ExpectedEnumeratorType
!            ,class ActualEnumeratorType>
!    void checkStlSequenceEqual( const ExpectedEnumeratorType &expected,
!                                const ActualEnumeratorType &actual,
!                                const Message &message  = Message() )
!    {
!       checkSequenceEqual( enumStl( expected ), enumStl( actual ), message );
!    }
! 
!    template<class ExpectedEnumerator
!            ,class ActualEnumerator
!            ,class ExpectedStringizer
!            ,class ActualStringizer
!            ,class EqualityPredicate>
!    void checkCustomHeterogeneousSetEqual( const ExpectedEnumerator &expected,
!                                           const ActualEnumerator &actual,
!                                           ExpectedStringizer expectedStringizer,
!                                           ActualStringizer actualStringizer,
!                                           EqualityPredicate predicate,
!                                           const Message &message )
!    {
!       std::deque<ExpectedEnumerator::Type> missing;
!       std::deque<ActualEnumerator::Type> extraneous;
        Impl::getSetDifference( expected, actual,
                                missing, extraneous,
***************
*** 183,209 ****
        Message newMessage( message );
        newMessage.add( translate( "Sets do not contain the same items." ) );
!       newMessage.add( translate( "Actual:\n" ) + enumToString(actual) );
        if ( missing.size() > 0 )
!          newMessage.add( translate( "Missing:\n" ) + enumToString(enumStl(missing)) );
        if ( extraneous.size() > 0 )
!          newMessage.add( translate( "Extraneous:\n" ) + enumToString(enumStl(extraneous)) );
        fail( newMessage );
     }
  
!    template<class ExpectedSetType
!            ,class ActualSetType>
!    void checkSetEqual( const ExpectedSetType &expected,
!                        const ActualSetType &actual,
                         const Message &message = Message() )
     {
!       DefaultComparator<ExpectedSetType::Type
!                        ,ActualSetType::Type> comparator;
!       checkSetEqual( expected, actual, comparator, message );
     }
  
!    template<class ExpectedSetType
!            ,class ActualSetType>
!    void checkStlSetEqual( const ExpectedSetType &expected,
!                           const ActualSetType &actual,
                            const Message &message = Message() )
     {
--- 238,309 ----
        Message newMessage( message );
        newMessage.add( translate( "Sets do not contain the same items." ) );
!       newMessage.add( translate( "Actual:\n" ) + enumToStringCustom(actual,actualStringizer) );
        if ( missing.size() > 0 )
!          newMessage.add( translate( "Missing:\n" ) + enumToStringCustom(enumStl(missing),
!                                                                         expectedStringizer) );
        if ( extraneous.size() > 0 )
!          newMessage.add( translate( "Extraneous:\n" ) + enumToStringCustom(enumStl(extraneous), 
!                                                                            actualStringizer) );
        fail( newMessage );
     }
  
!    template<class ExpectedEnumerator
!            ,class ActualEnumerator
!            ,class ItemStringizer
!            ,class EqualityPredicate>
!    void checkCustomSetEqual( const ExpectedEnumerator &expected,
!                              const ActualEnumerator &actual,
!                              ItemStringizer itemStringizer,
!                              EqualityPredicate comparator,
!                              const Message &message = Message() )
!    {
!       checkCustomHeterogeneousSetEqual( expected, actual, 
!                                         itemStringizer, itemStringizer, 
!                                         comparator, message );
!    }
! 
!    template<class ExpectedEnumerator
!            ,class ActualEnumerator
!            ,class ItemStringizer>
!    void checkCustomStringSetEqual( const ExpectedEnumerator &expected,
!                                    const ActualEnumerator &actual,
!                                    ItemStringizer itemStringizer,
!                                    const Message &message = Message() )
!    {
!       DefaultComparator<CPPUT_DEDUCED_TYPENAME ExpectedEnumerator::Type
!                        ,CPPUT_DEDUCED_TYPENAME ActualEnumerator::Type> comparator;
!       checkCustomSetEqual( expected, actual, itemStringizer, comparator, message );
!    }
! 
!    template<class ExpectedEnumerator
!            ,class ActualEnumerator
!            ,class EqualityPredicate>
!    void checkCustomEqualitySetEqual( const ExpectedEnumerator &expected,
!                                      const ActualEnumerator &actual,
!                                      EqualityPredicate comparator,
!                                      const Message &message = Message() )
!    {
!       typedef DefaultStringizer<CPPUT_DEDUCED_TYPENAME ExpectedEnumerator::Type> ExpectedStringizer;
!       typedef DefaultStringizer<CPPUT_DEDUCED_TYPENAME ActualEnumerator::Type> ActualStringizer;
!       checkCustomHeterogeneousSetEqual( expected, actual, 
!                                         ExpectedStringizer(), ActualStringizer(),
!                                         comparator, message );
!    }
! 
!    template<class ExpectedEnumerator
!            ,class ActualEnumerator>
!    void checkSetEqual( const ExpectedEnumerator &expected,
!                        const ActualEnumerator &actual,
                         const Message &message = Message() )
     {
!       DefaultComparator<CPPUT_DEDUCED_TYPENAME ExpectedEnumerator::Type
!                        ,CPPUT_DEDUCED_TYPENAME ActualEnumerator::Type> comparator;
!       checkCustomEqualitySetEqual( expected, actual, comparator, message );
     }
  
!    template<class ExpectedStlSet
!            ,class ActualStlSet>
!    void checkStlSetEqual( const ExpectedStlSet &expected,
!                           const ActualStlSet &actual,
                            const Message &message = Message() )
     {
***************
*** 214,221 ****
             ,class ActualSetType
             ,class EqualityPredicate>
!    void checkStlSetEqual( const ExpectedSetType &expected,
!                           const ActualSetType &actual,
!                           EqualityPredicate predicate,
!                           const Message &message = Message() )
     {
        checkSetEqual( enumStl( expected ), enumStl( actual ), predicate, message );
--- 314,321 ----
             ,class ActualSetType
             ,class EqualityPredicate>
!    void checkCustomEqualityStlSetEqual( const ExpectedSetType &expected,
!                                         const ActualSetType &actual,
!                                         EqualityPredicate predicate,
!                                         const Message &message = Message() )
     {
        checkSetEqual( enumStl( expected ), enumStl( actual ), predicate, message );
***************
*** 223,231 ****
  
  
!    template<class EnumType>
!    std::string enumToString( const EnumType &enumerator,
!                              const std::string &separator = "; ",
!                              const std::string &begin = "{ ",
!                              const std::string &end = " }" )
     {
        EnumType enumToStringize = enumerator.clone();
--- 323,333 ----
  
  
!    template<class EnumType
!            ,class ItemStringizerType>
!    std::string enumToStringCustom( const EnumType &enumerator,
!                                    ItemStringizerType itemStringizer,
!                                    const std::string &separator = "; ",
!                                    const std::string &begin = "{ ",
!                                    const std::string &end = " }" )
     {
        EnumType enumToStringize = enumerator.clone();
***************
*** 233,237 ****
        while ( enumToStringize.hasNext() )
        {
!          std::string item = stringize( enumToStringize.next() );
           if ( !str.empty() )
              str += separator;
--- 335,339 ----
        while ( enumToStringize.hasNext() )
        {
!          std::string item = itemStringizer( enumToStringize.next() );
           if ( !str.empty() )
              str += separator;
***************
*** 241,244 ****
--- 343,360 ----
     }
  
+ 
+    template<class EnumType>
+    std::string enumToString( const EnumType &enumerator,
+                              const std::string &separator = "; ",
+                              const std::string &begin = "{ ",
+                              const std::string &end = " }" )
+    {
+       return enumToStringCustom( enumerator, 
+                                  DefaultStringizer<CPPUT_DEDUCED_TYPENAME EnumType::Type>(), 
+                                  separator, 
+                                  begin, 
+                                  end );
+    }
+ 
  } // namespace CppUT
  

Index: stringize.h
===================================================================
RCS file: /cvsroot/cpptool/CppParser/include/cpput/stringize.h,v
retrieving revision 1.1.1.1
retrieving revision 1.2
diff -C2 -d -r1.1.1.1 -r1.2
*** stringize.h	8 Jun 2004 20:23:21 -0000	1.1.1.1
--- stringize.h	14 Jun 2004 23:08:12 -0000	1.2
***************
*** 13,16 ****
--- 13,25 ----
  
  
+    template<class ValueType>
+    struct DefaultStringizer
+    {
+       std::string operator()( const ValueType &value ) const
+       {
+          return stringize( value );
+       }
+    };
+ 
  // ------------------- convertToString -------------------------------
  // User should overload convertToString() to support their own string types.