steal_buf.h

//                                                                             
//  Copyright (C) 2008-2012  Artyom Beilis (Tonkikh) <artyomtnk@yahoo.com>     
//                                                                             
//  See accompanying file COPYING.TXT file for licensing details.
//
#ifndef CPPCMS_STEAL_BUF_H
#define CPPCMS_STEAL_BUF_H

#include <streambuf>
#include <ostream>
#include <istream>
#include <stdio.h>
#include <string>
#include <string.h>
#include <stdlib.h>

namespace cppcms {
namespace util {


        class const_char_buf : public std::streambuf {
        public:
                const_char_buf()
                {
                        range(0,0);
                }
                const_char_buf(char const *begin,char const *end)
                {
                        range(begin,end);
                }
                void range(char const *cbegin,char const *cend)
                {
                        char *begin = const_cast<char*>(cbegin);
                        char *end   = const_cast<char*>(cend);
                        setg(begin,begin,end);
                }
                char const *begin() const
                {
                        return eback();
                }
                char const *end() const
                {
                        return egptr();
                }
        };

        class const_char_istream : public std::istream {
        public:
                const_char_istream() : std::istream(0) 
                {
                        init(&buf_);
                }
                const_char_istream(char const *begin,char const *end) : std::istream(0) 
                {
                        buf_.range(begin,end);
                        init(&buf_);
                }
                char const *begin() const
                {
                        return buf_.begin();
                }
                char const *end() const
                {
                        return buf_.end();
                }
                void range(char const *begin,char const *end)
                {
                        buf_.range(begin,end);
                        clear();
                }
        private:
                const_char_buf buf_;
        };

        template<size_t OnStackSize = 128>
        class stackbuf : public std::streambuf {
                stackbuf(stackbuf const &);
                void operator=(stackbuf const &);
        public:
                char *begin()
                {
                        return pbase();
                }
                char *end()
                {
                        return pptr();
                }
                char *c_str()
                {
                        *pptr() = 0;
                        return begin();
                }
                std::string str()
                {
                        return std::string(begin(),size_t(end()-begin()));
                }
                stackbuf() 
                {
                        init();
                }
                ~stackbuf()
                {
                        free(on_heap_);
                }
        protected:

                int overflow(int c)
                {
                        size_t current_size;
                        size_t new_size;
                        if(pbase() == on_stack_) {
                                current_size = OnStackSize;
                                new_size = OnStackSize * 2;
                                on_heap_ = (char *)malloc(new_size + 1);
                                if(!on_heap_)
                                        throw std::bad_alloc();
                                memcpy(on_heap_,on_stack_,current_size);
                        }
                        else {
                                current_size = pptr() - pbase();
                                new_size = current_size * 2;
                                char *new_ptr = (char *)realloc(on_heap_,new_size + 1);
                                if(!new_ptr)
                                        throw std::bad_alloc();
                                on_heap_ = new_ptr;

                        }
                        setp(on_heap_,on_heap_ + new_size);
                        pbump(current_size);
                        if(c!=EOF)
                                sputc(c);
                        return 0;
                }
        private:
                void init()
                {
                        on_heap_ = 0;
                        setp(on_stack_,on_stack_+OnStackSize);
                }
                char *on_heap_;
                char on_stack_[OnStackSize + 1];
        };


        template<size_t Size = 128>
        class steal_buffer : public stackbuf<Size> {
        public:
                steal_buffer(std::ostream &out) 
                {
                        stolen_ = 0;
                        stream_ = 0;
                        steal(out);
                }
                steal_buffer() 
                {
                        stolen_ = 0;
                        stream_ = 0;
                }
                void steal(std::ostream &out)
                {
                        release();
                        stolen_ = out.rdbuf(this);
                        stream_ = &out;
                }
                void release()
                {
                        if(stream_ && stolen_) {
                                stream_->rdbuf(stolen_);
                        }
                        stream_ = 0;
                        stolen_ = 0;
                }
                ~steal_buffer()
                {
                        release();
                }
        private:
                std::streambuf *stolen_;
                std::ostream *stream_;
        };

        template<size_t Size = 128>
        class stackstream : public std::ostream {
        public:
                stackstream() : std::ostream(0)
                {
                        rdbuf(&buf_);
                }
                char *begin()
                {
                        return buf_.begin();
                }
                char *end()
                {
                        return buf_.end();
                }
                char *c_str()
                {
                        return buf_.c_str();
                }
                std::string str()
                {
                        return buf_.str();
                }
        private:
                stackbuf<Size> buf_;
        };

        template<typename Filter,int BufferSize=128>
        class filterbuf : public std::streambuf {
        public:
                filterbuf() : output_(0), output_stream_(0)
                {
                        setp(buffer_,buffer_+BufferSize);
                }
                filterbuf(std::ostream &out) : output_(0), output_stream_(0)
                {
                        setp(buffer_,buffer_+BufferSize);
                        steal(out);
                }
                ~filterbuf()
                {
                        try {
                                release();
                        }
                        catch(...) {}
                }
                void steal(std::ostream &out)
                {
                        release();
                        output_stream_ = &out;
                        output_ = out.rdbuf(this);
                }
                int release()
                {
                        int r=0;
                        if(output_stream_) {
                                if(write()!=0)
                                        r=-1;
                                output_stream_->rdbuf(output_);
                                output_=0;
                                output_stream_=0;
                        }
                        return r;
                }
        protected:
                int overflow(int c)
                {
                        if(write()!=0)
                                return -1;
                        if(c!=EOF) {
                                *pptr()=c;
                                pbump(1);
                        }
                        return 0;
                }
        private:
                int write()
                {
                        if(static_cast<Filter*>(this)->convert(pbase(),pptr(),output_)!=0) {
                                output_stream_->setstate(std::ios_base::failbit);
                                return -1;
                        }
                        setp(buffer_,buffer_ + BufferSize);
                        return 0;
                }
                char buffer_[BufferSize];
                std::streambuf *output_;
                std::ostream *output_stream_;
        };
        
        template<typename Filter>
        class filterbuf<Filter,0> : public std::streambuf {
        public:
                filterbuf() : output_(0), output_stream_(0)
                {
                }
                filterbuf(std::ostream &out) : output_(0), output_stream_(0)
                {
                        steal(out);
                }
                ~filterbuf()
                {
                        release();
                }
                void steal(std::ostream &out)
                {
                        release();
                        output_stream_ = &out;
                        output_ = out.rdbuf(this);
                }
                int release()
                {
                        int r=0;
                        if(output_stream_) {
                                output_stream_->rdbuf(output_);
                                output_=0;
                                output_stream_=0;
                        }
                        return r;
                }
        protected:
                int overflow(int c)
                {
                        if(c!=EOF) {
                                char tmp=c;
                                if(write(&tmp,&tmp+1)!=0)
                                        return -1;
                        }
                        return 0;
                }
                std::streamsize xsputn(char const *s,std::streamsize size)
                {
                        if(write(s,s+size)!=0)
                                return -1;
                        return size;
                }
        private:
                int write(char const *begin,char const *end)
                {
                        if(static_cast<Filter*>(this)->convert(begin,end,output_)!=0) {
                                output_stream_->setstate(std::ios_base::failbit);
                                return -1;
                        }
                        return 0;
                }
                std::streambuf *output_;
                std::ostream *output_stream_;
        };
        
} // util
} // cppcms

#endif