[ create a new paste ] login | about

Link: http://codepad.org/dV4Ge6Xe    [ raw code | fork ]

C++, pasted on Sep 4:
#pragma once
// Copyright (c) 2011, Alf P. Steinbach


//--------------------------------------------------------- Dependencies:

#include <assert.h>
#include <string>
#include <sstream>
//#include "platform_adaption.h"


//--------------------------------------------------------- Interface:

namespace progrock{ namespace cppx{

    namespace narrow {
        using std::string;
        using std::ostringstream;

        template< class Type >
        string stringFrom( Type const& v )
        {
            ostringstream   stream;

            stream << v;
            return stream.str();
        }

        template<>
        inline string stringFrom( string const& s )
        {
            return s;
        }

        class S
        {
        private:
            string      s_;

            template< class Type >
            string stringFrom( Type const& v )
            {
                return narrow::stringFrom( v );
            }

            static char const* stringFrom( char const* s )
            {
                assert( s != 0 );
                return s;
            }

        public:
            template< class Type >
            S& operator<<( Type const& v )
            {
                s_ += stringFrom( v );
                return *this;
            }

            string const& str() const { return s_; }
            operator string const& () const { return str(); }

            char const* cStr() const { return s_.c_str(); }
            operator char const* () const { return cStr(); }
        };
    }  // namespace narrow

    namespace wide {
        using std::wstring;
        using std::wostringstream;

        template< class Type >
        wstring stringFrom( Type const& v )
        {
            wostringstream  stream;
            stream << v;
            return stream.str();
        }

        template<>
        inline wstring stringFrom( wstring const& s )
        {
            return s;
        }

        class S
        {
        private:
            wstring     s_;

            template< class Type >
            wstring stringFrom( Type const& v )
            {
                return wide::stringFrom( v );
            }

            static wchar_t const* stringFrom( wchar_t const* s )
            {
                assert( s != 0 );
                return s;
            }

        public:
            template< class Type >
            S& operator<<( Type const& v )
            {
                s_ += stringFrom( v );
                return *this;
            }

            wstring const& str() const { return s_; }
            operator wstring const& () const { return str(); }

            wchar_t const* cStr() const { return s_.c_str(); }
            operator wchar_t const* () const { return cStr(); }
        };
    }  // namespace wide

} }  // namespace progrock::cppx


Create a new paste based on this one


Comments: