Webmaster  |  Imprint 

C++ Server Pages

Main  |  License  |  Documentation  |  Download 

/home/tommi/cxxtools/include/cxxtools/textbuffer.h

/*
 * Copyright (C) 2004-2009 Marc Boris Duerner
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * As a special exception, you may use this file as part of a free
 * software library without restriction. Specifically, if other files
 * instantiate templates or use macros or inline functions from this
 * file, or you compile this file and link it with other files to
 * produce an executable, this file does not by itself cause the
 * resulting executable to be covered by the GNU General Public
 * License. This exception does not however invalidate any other
 * reasons why the executable file might be covered by the GNU Library
 * General Public License.
 * 
 * This library 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
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
#ifndef cxxtools_TextBuffer_h
#define cxxtools_TextBuffer_h

#include <cxxtools/api.h>
#include <cxxtools/char.h>
#include <cxxtools/textcodec.h>
#include <cxxtools/conversionerror.h>
#include <iostream>

namespace cxxtools {


template <typename CharT, typename ByteT>
class BasicTextBuffer : public std::basic_streambuf<CharT>
{
    public:
        typedef ByteT extern_type;
        typedef CharT intern_type;
        typedef CharT char_type;
        typedef typename std::char_traits<CharT> traits_type;
        typedef typename traits_type::int_type int_type;
        typedef typename traits_type::pos_type pos_type;
        typedef typename traits_type::off_type off_type;
        typedef TextCodec<char_type, extern_type> CodecType;
        typedef MBState state_type;

    private:
        static const int _pbmax = 4;

        static const int _ebufmax = 256;
        extern_type _ebuf[_ebufmax];
        int _ebufsize;

        static const int _ibufmax = 256;
        intern_type _ibuf[_ibufmax];

        state_type _state;

        CodecType* _codec;

        std::basic_ios<extern_type>* _target;

    public:
        BasicTextBuffer(std::basic_ios<extern_type>* target, CodecType* codec)
        : _ebufsize(0)
        , _codec(codec) 
        , _target(target)
        {
            this->setg(0, 0, 0);
            this->setp(0, 0);
        }

        ~BasicTextBuffer() throw()
        {
            try
            {
                this->terminate();
            }
            catch(...) {}

            if(_codec && _codec->refs() == 0)
                delete _codec;
        }

        void attach(std::basic_ios<extern_type>& target)
        {
            this->terminate();
            _target = &target;
        }

        void detach()
        {
            this->terminate();
            _target = 0;
        }

        int terminate()
        {
            if( this->pptr() )
            {
                if( -1 == this->sync() )
                    return -1;

                if( _codec && ! _codec->always_noconv() )
                {
                    typename CodecType::result res = CodecType::error;
                    do
                    {
                        extern_type* next = 0;
                        res = _codec->unshift(_state, _ebuf, _ebuf + _ebufmax, next);
                        _ebufsize = next - _ebuf;

                        if(res == CodecType::error)
                        {
                            throw ConversionError("character conversion failed");
                        }
                        else if(res == CodecType::ok || res == CodecType::partial)
                        {
                            if(_ebufsize > 0)
                            {
                                _ebufsize -= _target->rdbuf()->sputn(_ebuf, _ebufsize);
                                if(_ebufsize)
                                    return -1;
                            }
                        }
                    }
                    while(res == CodecType::partial);
                }
            }

            this->setp(0, 0);
            this->setg(0, 0, 0);
            _ebufsize = 0;
            _state = state_type();
            return 0;
        }

        std::streamsize import()
        {
            if( _target )
            {
                std::streamsize n = _target->rdbuf()->in_avail();
                return do_underflow(n).second;
            }

            return this->in_avail();
        }

    protected:
        // inheritdoc
        virtual int sync()
        {
            if( this->pptr() )
            {
                // Try to write out the whole buffer to the underlying stream.
                // Fail if we can not make progress, because more characters
                // are needed to continue a multi-byte sequence.
                while( this->pptr() > this->pbase() )
                {
                    const char_type* p = this->pptr();

                    if( this->overflow( traits_type::eof() ) == traits_type::eof() )
                        return -1;

                    if( p == this->pptr() )
                        throw ConversionError("character conversion failed");
                }
            }

            return 0;
        }

        virtual std::streamsize showmanyc()
        {
            return 0;
        }

        // inheritdoc
        virtual int_type overflow( int_type ch = traits_type::eof() )
        {
            if( ! _target || this->gptr() )
                return traits_type::eof();

            if( ! this->pptr() )
            {
                this->setp( _ibuf, _ibuf + _ibufmax );
            }

            while( this->pptr() > this->pbase() )
            {
                const char_type* fromBegin = _ibuf;
                const char_type* fromEnd   = this->pptr();
                const char_type* fromNext  = fromBegin;
                extern_type* toBegin       = _ebuf + _ebufsize;
                extern_type* toEnd         = _ebuf + _ebufmax;
                extern_type* toNext        = toBegin;

                typename CodecType::result res = CodecType::noconv;
                if(_codec)
                    res = _codec->out(_state, fromBegin, fromEnd, fromNext, toBegin, toEnd, toNext);

                if(res == CodecType::noconv)
                {
                    size_t fromSize = fromEnd - fromBegin;
                    size_t toSize   = toEnd - toBegin;
                    size_t size     = toSize < fromSize ? toSize : fromSize;

                    this->copyChars( toBegin, fromBegin, size );

                    fromNext += size;
                    toNext += size;
                }

                _ebufsize += toNext - toBegin;
                size_t leftover = fromEnd - fromNext;
                if(leftover && fromNext > fromBegin)
                {
                    std::char_traits<char_type>::move(_ibuf, fromNext, leftover);
                }

                this->setp( _ibuf, _ibuf + _ibufmax );
                this->pbump( leftover );

                if(res == CodecType::error)
                    throw ConversionError("character conversion failed");

                if(res == CodecType::partial && _ebufsize == 0)
                    break;

                _ebufsize -= _target->rdbuf()->sputn(_ebuf, _ebufsize);
                if(_ebufsize)
                    return traits_type::eof();
            }

            if( ! traits_type::eq_int_type(ch, traits_type::eof()) )
            {
                *( this->pptr() ) = traits_type::to_char_type(ch);
                this->pbump(1);
            }

            return traits_type::not_eof(ch);
        }


        // inheritdoc
        virtual int_type underflow()
        {
            if( ! _target )
                return traits_type::eof();

            if( this->gptr() < this->egptr() )
                return traits_type::to_int_type( *this->gptr() );

            return do_underflow(_ebufmax).first;
        }


        std::pair<int_type, std::streamsize> do_underflow(std::streamsize size)
        {
            typedef std::pair<int_type, std::streamsize> ret_type;

            std::streamsize n = 0;

            if( this->pptr() )
            {
                if( -1 == this->terminate() )
                    return ret_type(traits_type::eof(), 0);
            }

            if( ! this->gptr() )
            {
                this->setg(_ibuf, _ibuf, _ibuf);
            }

            if( this->gptr() - this->eback() > _pbmax)
            {
                std::streamsize movelen = this->egptr() - this->gptr() + _pbmax;
                std::char_traits<char_type>::move( _ibuf,
                                                   this->gptr() - _pbmax,
                                                   movelen );
                this->setg(_ibuf, _ibuf + _pbmax, _ibuf + movelen);
            }

            bool atEof = false;
            const std::streamsize bufavail = _ebufmax - _ebufsize;
            size = bufavail < size ? bufavail : size;
            if(size)
            {
                n = _target->rdbuf()->sgetn( _ebuf + _ebufsize, size );
                _ebufsize += n;
                if(n == 0)
                    atEof = true;
            }

            const extern_type* fromBegin = _ebuf;
            const extern_type* fromEnd   = _ebuf + _ebufsize;
            const extern_type* fromNext  = fromBegin;
            char_type* toBegin           = this->egptr();
            char_type* toEnd             = _ibuf + _ibufmax;
            char_type* toNext            = toBegin;

            typename CodecType::result r = CodecType::noconv;
            if(_codec)
                r = _codec->in(_state, fromBegin, fromEnd, fromNext, toBegin, toEnd, toNext);

            if(r == CodecType::noconv)
            {
                // copy characters and advance fromNext and toNext
                int n =_ebufsize > _ibufmax ? _ibufmax : _ebufsize ;
                this->copyChars(toBegin, fromBegin, n);
                _ebufsize -= n;
                fromNext += n;
                toNext += n;
            }

            std::streamsize consumed = fromNext - fromBegin;
            if(consumed)
            {
                std::char_traits<extern_type>::move( _ebuf, _ebuf + consumed, _ebufsize );
                _ebufsize -= consumed;
            }

            std::streamsize generated = toNext - toBegin;
            if(generated)
            {
                this->setg(this->eback(),              // start of read buffer
                           this->gptr(),               // gptr position
                           this->egptr() + generated ); // end of read buffer
            }

            if(r == CodecType::error)
                throw ConversionError("character conversion failed");

            if( this->gptr() < this->egptr() )
                return ret_type(traits_type::to_int_type( *this->gptr() ), n);

            // fail if partial charactes are at the end of the stream
            if(r == CodecType::partial && atEof)
                throw ConversionError("character conversion failed");

            return ret_type(traits_type::eof(), 0);
        }

        template <typename T>
        void copyChars(T* s1, const T* s2, size_t n)
        {
            std::char_traits<T>::copy(s1, s2, n);
        }

        //TODO: signature like codecvt with ptr refs
        template <typename A, typename B>
        void copyChars(A* s1, const B* s2, size_t n)
        {
            while(n-- > 0)
            {
                *s1 = *s2;
                ++s1;
                ++s2;
            }
        }
};


class CXXTOOLS_API TextBuffer : public BasicTextBuffer<cxxtools::Char, char>
{
    public:
        typedef TextCodec<cxxtools::Char, char> Codec;

    public:
        TextBuffer(std::ios* buffer, Codec* codec);
};

} // namespace cxxtools

#endif

Copyright © 2008 The Tntnet Development Team

Tntnet 1.6