Stringizer.hpp

/* ***** BEGIN LICENSE BLOCK *****
 * FW4SPL - Copyright (C) IRCAD, 2009-2017.
 * Distributed under the terms of the GNU Lesser General Public License (LGPL) as
 * published by the Free Software Foundation.
 * ****** END LICENSE BLOCK ****** */

#ifndef __FWTOOLS_STRINGIZER_HPP__
#define __FWTOOLS_STRINGIZER_HPP__

#include "fwTools/config.hpp"
#include "fwTools/TypeInfo.hpp"

#include <fwCore/Demangler.hpp>

#include  <boost/lexical_cast.hpp>
#include  <boost/mpl/if.hpp>
#include  <boost/type_traits/is_arithmetic.hpp>

#include <string>
#include <type_traits>
#include <typeinfo>

namespace fwTools
{

namespace
{
struct NumericCast
{
    //------------------------------------------------------------------------------

    template<class T>
    static std::string eval(const T& t)
    {
        // note boost::lexical_cast with char is a ASCII-code conversion
        // instead numerical casting. We provide fix with specialization
        return ::boost::lexical_cast<std::string>(t);
    }
};

struct Default
{
    //------------------------------------------------------------------------------

    template<class T>
    static std::string eval(const T& t)
    {
        return "No getString for " + ::fwCore::Demangler(typeid(t)).getClassname();
    }
};
}

// inline mandatory to be supported in multi compilation unit and avoid conflict when linking
// function doesn't exist code is rewritted
template<class T>
inline std::string getString(const T& t)
{
    typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<  std::is_arithmetic<T>::value,
                                                      NumericCast,
                                                      Default
                                                      >::type Choice;

    return Choice::eval(t);
}

template<class T1, class T2>
inline std::string getString(const std::pair<T1, T2>& t)
{
    std::string res = ("[");
    res += getString(t.first) + "," + getString(t.second) + "]";
    return res;
}

template<class ForwardIterator>
inline std::string getString(ForwardIterator begin, ForwardIterator end)
{
    std::string result("[");
    if (begin != end)
    {
        result += getString( *begin );
        while (++begin != end)
        {
            result += "," + getString( *begin );
        }
    }
    result += "]";
    return result;
}

template<>
FWTOOLS_API std::string getString(const std::string& aString);

template<>
FWTOOLS_API std::string getString(const std::type_info& ti);

template<>
FWTOOLS_API std::string getString(const TypeInfo& ti);

// char are numerically casted
template<>
FWTOOLS_API std::string getString(const signed char& c);

// char are numerically casted // signed char and char doesn't are the same :/ !!!!
template<>
FWTOOLS_API std::string getString(const char& c);

// char are numerically casted
template<>
FWTOOLS_API std::string getString(const unsigned char& c);

template<>
FWTOOLS_API std::string getString(const std::string& aString);


}

#endif // __FWTOOLS_STRINGIZER_HPP__