TextStream.h

/*
 * Copyright (C) 2004-2013 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 Pt_TextStream_h
#define Pt_TextStream_h

#include <Pt/Api.h>
#include <Pt/String.h>
#include <Pt/TextBuffer.h>
#include <Pt/IOStream.h>

namespace Pt {

template <typename CharT, typename ByteT>
class BasicTextIStream : public BasicIStream<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 std::basic_istream<extern_type> StreamType;

        typedef TextCodec<char_type, extern_type> CodecType;

    public:
        BasicTextIStream(StreamType& is, CodecType* codec)
        : BasicIStream<intern_type>(0)
        , _tbuffer( is, codec )
        { 
            this->setBuffer(&_tbuffer); 
        }

        explicit BasicTextIStream(CodecType* codec)
        : BasicIStream<intern_type>(0)
        , _tbuffer(codec )
        { 
            this->setBuffer(&_tbuffer); 
        }

        ~BasicTextIStream()
        {  }

        CodecType* codec()
        { 
            return _tbuffer.codec(); 
        }

        void setCodec(CodecType* codec)
        {           
            _tbuffer.setCodec(codec);
        }

        void attach(StreamType& is)
        {
            _tbuffer.attach(is);
        }
        
        void detach()
        {
            _tbuffer.detach();
        }

        void discard()
        {
            _tbuffer.discard();
        }

        void reset()
        {
            _tbuffer.reset();
        }

        void reset(StreamType& is)
        {
            _tbuffer.reset(is);
        }

        BasicTextBuffer<intern_type, extern_type>& textBuffer()
        { return _tbuffer; }

    private:
        BasicTextBuffer<intern_type, extern_type> _tbuffer;
};


template <typename CharT, typename ByteT>
class BasicTextOStream : public BasicOStream<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 std::basic_ostream<extern_type> StreamType;

        typedef TextCodec<char_type, extern_type> CodecType;

    public:
        BasicTextOStream(StreamType& os, CodecType* codec)
        : BasicOStream<intern_type>(0)
        , _tbuffer( os , codec )
        { 
            this->setBuffer(&_tbuffer); 
        }

        explicit BasicTextOStream(CodecType* codec)
        : BasicOStream<intern_type>(0)
        , _tbuffer( codec )
        { 
            this->setBuffer(&_tbuffer); 
        }

        ~BasicTextOStream()
        {  }

        CodecType* codec()
        { 
            return _tbuffer.codec(); 
        }

        void setCodec(CodecType* codec)
        {           
            _tbuffer.setCodec(codec);
        }

        void attach(StreamType& os)
        {
            _tbuffer.attach(os);
        }

        void detach()
        {
            _tbuffer.detach();
        }

        void discard()
        {
            _tbuffer.discard();
        }

        void reset()
        {
            _tbuffer.reset();
        }

        void reset(StreamType& os)
        {
            _tbuffer.reset(os);
        }

        BasicTextBuffer<intern_type, extern_type>& textBuffer()
        { return _tbuffer; }

    private:
        BasicTextBuffer<intern_type, extern_type> _tbuffer;
};

template <typename CharT, typename ByteT>
class BasicTextStream : public BasicIOStream<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 std::basic_iostream<extern_type> StreamType;

        typedef TextCodec<char_type, extern_type> CodecType;

    public:
        BasicTextStream(StreamType& ios, CodecType* codec)
        : BasicIOStream<intern_type>(0)
        , _tbuffer( ios, codec)
        { 
            this->setBuffer(&_tbuffer); 
        }

        explicit BasicTextStream(CodecType* codec)
        : BasicIOStream<intern_type>(0)
        , _tbuffer(codec)
        { 
            this->setBuffer(&_tbuffer); 
        }

        ~BasicTextStream()
        { }

        CodecType* codec()
        { 
            return _tbuffer.codec(); 
        }

        void setCodec(CodecType* codec)
        {           
            _tbuffer.setCodec(codec);
        }

        void attach(StreamType& ios)
        {
            _tbuffer.attach(ios);
        }

        void detach()
        {
            _tbuffer.detach();
        }

        void discard()
        {
            _tbuffer.discard();
        }

        void reset()
        {
            _tbuffer.reset();
        }

        void reset(StreamType& ios)
        {
            _tbuffer.reset(ios);
        }

        BasicTextBuffer<intern_type, extern_type>& textBuffer()
        { return _tbuffer; }

    private:
        BasicTextBuffer<intern_type, extern_type> _tbuffer;
};

typedef BasicTextIStream<Char, char>  TextIStream;

typedef BasicTextOStream<Char, char>  TextOStream;

typedef BasicTextStream<Char, char> TextStream;


//
//    @ingroup Unicode
//*/
//class PT_API TextIStream : public BasicTextIStream<Char, char>
//{
//    public:
//        typedef TextCodec<Pt::Char, char> Codec;
//
//    public:
//        /** @brief Constructor
//
//            The stream will read bytes from \a is and use the codec \a codec
//            for character conversion. The codec will be destroyed by the
//            buffer of this stream if the codec was constructed with a
//            refcount of 0.
//        */
//        TextIStream(std::istream& is, Codec* codec);
//
//        explicit TextIStream(Codec* codec);
//
//        ~TextIStream();
//};
//
//
//
//    @ingroup Unicode
//*/
//class PT_API TextOStream : public BasicTextOStream<Char, char>
//{
//    public:
//        typedef TextCodec<Pt::Char, char> Codec;
//
//    public:
//        /** @brief Constructor
//
//            The stream will write bytes to \a os and use the codec \a codec
//            for character conversion. The codec will be destroyed by the
//            buffer of this stream if the codec was constructed with a
//            refcount of 0.
//        */
//        TextOStream(std::ostream& os, Codec* codec);
//
//        explicit TextOStream(Codec* codec);
//
//        ~TextOStream();
//};
//
//
//
//    @ingroup Unicode
//*/
//class PT_API TextStream : public BasicTextStream<Char, char>
//{
//    public:
//        typedef TextCodec<Pt::Char, char> Codec;
//
//    public:
//        /** @brief Constructor
//
//            The stream will write or write bytes to \a ios and use the codec
//            \a codec for character conversion. The codec will be destroyed
//            by the buffer of this stream if the codec was constructed with a
//            refcount of 0.
//        */
//        TextStream(std::iostream& ios, Codec* codec);
//
//        explicit TextStream(Codec* codec);
//
//        ~TextStream();
//};

} // namespace Pt

#endif // Pt_TextStream_h