manip.hpp

C++的一个好库。。。现在很流行

/*=============================================================================
    Copyright (c) 1999-2003 Jeremiah Willcock
    Copyright (c) 1999-2003 Jaakko J鋜vi
    Copyright (c) 2001-2003 Joel de Guzman
    Copyright (c) 2004 Peder Holt

    Use, modification and distribution is subject to the Boost Software
    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
    http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#ifndef FUSION_SEQUENCE_DETAIL_MANIP_HPP
#define FUSION_SEQUENCE_DETAIL_MANIP_HPP

#include <boost/config.hpp>
#include <iostream>
#include <string>
#include <vector>
#include <cctype>

// Tuple I/O manipulators

#include <boost/spirit/fusion/detail/config.hpp>

#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
FUSION_MSVC_ETI_WRAPPER(char_type)
FUSION_MSVC_ETI_WRAPPER(traits_type)
# define FUSION_GET_CHAR_TYPE(T) get_char_type<T>::type
# define FUSION_GET_TRAITS_TYPE(T) get_traits_type<T>::type
#else
# define FUSION_GET_CHAR_TYPE(T) typename T::char_type
# define FUSION_GET_TRAITS_TYPE(T) typename T::traits_type
#endif

#if defined (BOOST_NO_TEMPLATED_STREAMS)
#define FUSION_STRING_OF_STREAM(Stream) std::string
#else
#define FUSION_STRING_OF_STREAM(Stream)                                         \
    std::basic_string<                                                          \
        FUSION_GET_CHAR_TYPE(Stream)                                            \
      , FUSION_GET_TRAITS_TYPE(Stream)                                          \
    >
#endif

namespace boost { namespace fusion
{
    namespace detail
    {
        template <typename Tag>
        int get_xalloc_index(Tag* = 0)
        {
            // each Tag will have a unique index
            static int index = std::ios::xalloc();
            return index;
        }

        template <typename Stream, typename Tag, typename T>
        struct stream_data
        {
            struct arena
            {
                ~arena()
                {
                    for (
                        typename std::vector<T*>::iterator i = data.begin()
                      ; i != data.end()
                      ; ++i)
                    {
                        delete *i;
                    }
                }

                std::vector<T*> data;
            };

            static void attach(Stream& stream, T const& data);
            static T const* get(Stream& stream);
        };

        template <typename Stream, typename Tag, typename T>
        void stream_data<Stream,Tag,T>::attach(Stream& stream, T const& data)
        {
            static arena ar; // our arena
            ar.data.push_back(new T(data));
            stream.pword(get_xalloc_index<Tag>()) = ar.data.back();
        }

        template <typename Stream, typename Tag, typename T>
        T const* stream_data<Stream,Tag,T>::get(Stream& stream)
        {
            return (T const*)stream.pword(get_xalloc_index<Tag>());
        }

        template <class Tag, class Stream>
        class string_ios_manip
        {
        public:

            typedef FUSION_STRING_OF_STREAM(Stream) string_type;

            typedef stream_data<Stream, Tag, string_type> stream_data_t;

            string_ios_manip(Stream& str_);
            void set(string_type const& s);
            void print(char const* default_) const;
            void read(char const* default_) const;
        private:

            template <typename Char>
            void
            check_delim(Char c) const
            {
                if (!isspace(c))
                {
                    if (stream.get() != c)
                    {
                        stream.unget();
                        stream.setstate(std::ios::failbit);
                    }
                }
            }

            Stream& stream;
        };

        template <class Tag, class Stream>
        string_ios_manip<Tag,Stream>::string_ios_manip(Stream& str_)
            : stream(str_)
        {}

        template <class Tag, class Stream>
        void 
        string_ios_manip<Tag,Stream>::set(string_type const& s)
        {
            stream_data_t::attach(stream, s);
        }

        template <class Tag, class Stream>
        void 
        string_ios_manip<Tag,Stream>::print(char const* default_) const
        {
            // print a delimiter
            string_type const* p = stream_data_t::get(stream);
            if (p)
                stream << *p;
            else
                stream << default_;
        }

        template <class Tag, class Stream>
        void 
        string_ios_manip<Tag,Stream>::read(char const* default_) const
        {
            // read a delimiter
            string_type const* p = stream_data_t::get(stream);
            using namespace std;
            ws(stream);

            if (p)
            {
                typedef typename string_type::const_iterator iterator;
                for (iterator i = p->begin(); i != p->end(); ++i)
                    check_delim(*i);
            }
            else
            {
                while (*default_)
                    check_delim(*default_++);
            }
        }