stringize.h

Go to the documentation of this file.

// Defines the convertToString() & stringize() function use by assertions to output a value.
#ifndef CPPUT_STRINGIZE_H_INCLUDED
# define CPPUT_STRINGIZE_H_INCLUDED

# include <cpput/config.h>
# include <string>
# include <cpptl/stringtools.h>

/* How to:
 * - define a conversion function for a string type:
 *   overload the function std::string getStdString( MyStringType )
 *
 *   namespace CppUT { 
 *   inline std::string getStdString( const MyStringType &s ) {
 *      return s.str();
 *   } }
 *
 */



// 1) Is it a string ?
// std::string convertToString( ptr ) => Yes, convert to string & add quotes.
// NoToStringConversion convertToString( .. )
// stringize( impl::stringize( value, convertToString( ptr ) ) );
// 2) Is there an overloaded toString() function for that type
// std::string toString( ptr ); => Yes, convert to string using the function
// NoToStringConversion toString( ... );
// 3) Fall back DefaultStringizer.


namespace CppUT {

   template<class ValueType>
   struct DefaultStringizer
   {
      std::string operator()( const ValueType &value ) const
      {
         return stringize( value );
      }
   };

   template<class ValueType>
   struct RefStringizer
   {
      std::string operator()( ValueType value ) const
      {
         return stringize( value );
      }
   };

   template<class ValueType>
   struct DerefStringizer
   {
      std::string operator()( ValueType value ) const
      {
         return stringize( *value );
      }
   };

// ------------------- convertToString -------------------------------
// User should overload getStdString() to support their own string types.
//
// IMPORTANT: to handle compiler that do not support function template ordering
// (CPPTL_NO_FUNCTION_TEMPLATE_ORDERING), such as vc++ 6.0.
// getStdString() must never be called with a 'by value' parameter.
// Passing by value would result in undefined behavior for non string type parameter
// 'eaten' by NotConvertibleToStdString convertToString( ... ).
// In practice, this means that a templated function accepting const ref parameters
// should be the caller. For example:
//
// template<class StringType1, class StringType2>
// void checkRegExMatched( const StringType1 &pattern,   // <= the const ref here ensure that
//                         const StringType2 &str )      // convertToString will only be passed reference.
// {
//    RegEx regex( CppUT::convertToString(&pattern ) );
//    CppUT::checkTrue( regex.matched( CppUT::convertToString( &str ) ) );
// }

   struct NotConvertibleToStdString {};

   inline std::string getStdString( const char *cstr )
   {
      return std::string( cstr );
   }

   inline std::string getStdString( const std::string &s )
   {
      return s;
   }

   inline std::string getStdString( const CppTL::ConstString &s )
   {
      return s.c_str();
   }

#ifdef CPPTL_NO_FUNCTION_TEMPLATE_ORDERING

   inline NotConvertibleToStdString getStdString( ... )
   {
      return NotConvertibleToStdString();
   }
#else

   template<class T>
   inline NotConvertibleToStdString getStdString( const T & )
   {
      return NotConvertibleToStdString();
   }
#endif

   template <class StringType>
   inline std::string convertToString( const StringType &s )
   {
      return getStdString( s );  // if you get a compilation error on this call, then getStdString() has not been overloaded for your string type.
   }


// ------------------- stringize -------------------------------
// If CPPUT_NO_DEFAULT_STRINGIZE is defined, the user is expected 
// to provide a function which accept the following types:
// template<class T>
// std::string defaultStringize( const T &value );

   struct NoToStringOverload {};

#ifdef CPPTL_NO_FUNCTION_TEMPLATE_ORDERING
   inline NoToStringOverload toString( ... )
   {
      return NoToStringOverload();
   }
#else
   template<class T>
   inline NoToStringOverload toString( const T & )
   {
      return NoToStringOverload();
   }
#endif

   namespace Impl {

      template<typename ValueType>
      std::string toStringStringize( const ValueType &value, NoToStringOverload )
      {
         return defaultStringize( value );
      }

      template<typename ValueType>
      std::string toStringStringize( const ValueType &value, const std::string &str )
      {
         return str;
      }

      template<typename ValueType>
      std::string stringize( const ValueType &value, NotConvertibleToStdString )
      {
         return toStringStringize( value, toString( value ) );
      }

      template<typename ValueType>
      std::string stringize( const ValueType &value, const std::string &str )
      {
         return CppTL::quoteString( str ).c_str();
      }

   } // namespace Impl


   template<typename ValueType>
   std::string stringize( const ValueType &value )
   {
      return Impl::stringize( value, getStdString(&value) );
   }

} // namespace CPPUT


# ifndef CPPUT_NO_DEFAULT_STRINGIZE

#  ifndef CPPTL_NO_SSTREAM
#   include <sstream>
#  else // standard stream are not available, use the deprecated one
#   include <strstream>
#  endif

namespace CppUT {

   template<typename ValueType>
   std::string defaultStringize( const ValueType &value )
   {
#  ifndef CPPTL_NO_SSTREAM
         std::ostringstream os;
         os  <<  value;
         return os.str();
#  else // standard stream are not available, use the deprecated one
         std::ostrstream os;
         os  <<  value;
         return std::string( os.str(), os.pcount() );
#  endif
   }

} // namespace CPPUT

# endif


#endif // CPPUT_STRINGIZE_H_INCLUDED