// $Id$
//
// Copyright (C) 2008
// Fraunhofer Institute for Open Communication Systems (FOKUS)
// Competence Center NETwork research (NET), St. Augustin, GERMANY
//     Stefan Bund <g0dil@berlios.de>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

/** \file
    \brief String non-inline template implementation  */

//#include "String.ih"

// Custom includes
#include <boost/range.hpp>
#include <sstream>
#include <boost/lexical_cast.hpp>
#include <boost/shared_ptr.hpp>

#define prefix_
//-/////////////////////////////////////////////////////////////////////////////////////////////////

template <class ForwardReadableRange>
prefix_ std::string senf::stringJoin(ForwardReadableRange const & range, std::string sep)
{
    typename boost::range_const_iterator<ForwardReadableRange>::type i (boost::begin(range));
    typename boost::range_const_iterator<ForwardReadableRange>::type const i_end (boost::end(range));
    std::stringstream ss;

    if (i != i_end) {
        for (;;) {
            ss << *i;
            if ( ++i != i_end ) ss << sep;
            else                break;
        }
    }

    return ss.str();
}

// Copied from boost/lexical_cast.hpp
namespace senf {
namespace detail {
    template<typename Target>
    class lexical_stream
    {
    private:
        typedef char char_type;

    public:
        lexical_stream()
        {
            stream.unsetf(std::ios::skipws);
            if (std::numeric_limits<Target>::is_specialized)
                stream.precision(std::numeric_limits<Target>::digits10 + 1);
        }
        template <class Source>
        bool operator<<(const Source &input)
        {
            if (std::numeric_limits<Source>::is_specialized)
                stream.precision(std::numeric_limits<Source>::digits10 + 1);
            return !(stream << input).fail();
        }
        template<typename InputStreamable>
        bool operator>>(InputStreamable &output)
        {
            return !boost::is_pointer<InputStreamable>::value &&
                   stream >> output &&
                   stream.get() == std::char_traits<char_type>::eof();
        }
        bool operator>>(std::string &output)
        {
            output = stream.str();
            return true;
        }
        bool operator>>(std::wstring &output)
        {
            output = stream.str();
            return true;
        }
    private:
        std::basic_stringstream<char_type> stream;
    };

    template <class Target>
    class lexical_caster
    {
    public:
        lexical_caster() : interpreter_ (new senf::detail::lexical_stream<Target>()) {}
        template <class Source>
        Target operator()(Source const & arg) const
            {
                Target result;
                if (!((*interpreter_) << arg && (*interpreter_) >> result))
                    boost::throw_exception(boost::bad_lexical_cast(typeid(Source), typeid(Target)));
                return result;
            }

        template <class Mod>
        lexical_caster const & operator[](Mod mod) const
            {
                (*interpreter_) << mod;
                return *this;
            }

    private:
        boost::shared_ptr< senf::detail::lexical_stream<Target> > interpreter_;
    };
}}

template <class Target, class Source>
prefix_ Target senf::lexical_cast(Source const & arg)
{
    senf::detail::lexical_stream<Target> interpreter;
    Target result;

    if (!(interpreter << arg && interpreter >> result))
        boost::throw_exception(boost::bad_lexical_cast(typeid(Source), typeid(Target)));
    return result;
}

template <class Target>
prefix_ senf::detail::lexical_caster<Target> senf::lexical_cast()
{
    return detail::lexical_caster<Target>();
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#undef prefix_


// Local Variables:
// mode: c++
// fill-column: 100
// comment-column: 40
// c-file-style: "senf"
// indent-tabs-mode: nil
// ispell-local-dictionary: "american"
// compile-command: "scons -u test"
// End: