---

more/io/buffer.h

Go to the documentation of this file.

//  Copyright (C) 2001  Petter Urkedal (petter.urkedal@matfys.lth.se)
//
//  This file 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 file 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
//
//  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 General
//  Public License.
//
//  $Id: buffer.h,v 1.1 2002/05/30 18:01:37 petter_urkedal Exp $

#include <more/io/readline.h>
#include <more/gen/utility.h>
#include <algorithm>
#include <stdexcept>
#include <cstdlib>


#ifndef MORE_BUFFER_H
#define MORE_BUFFER_H

namespace more {
namespace io {

  /** \class buffer buffer.h more/io/buffer.h
   **
   ** A stream buffer with arbitary lookahead.  The main purpose of
   ** this class is to provide arbitrary lookahead. This is done by a
   ** mechanism similar to the std::vector implementation, namely the
   ** buffer space is at least doubled each time it need to be
   ** expanded, in order to provide amortized constant operations.
   ** This buffer can be used for both input and output, though
   ** usually not at the same time. An exception could be duplex
   ** sound, since in that case, the length of the output is the same
   ** as that of the input.  Due to the buffering, the overhead of
   ** having both input and output when only one is used is
   ** negligible. */
  template<typename T>
    struct buffer : gen::noncopyable
    {
        typedef std::size_t size_type;
        typedef std::ptrdiff_t difference;
        typedef T value_type;

        /** The item source interface. */
        struct driver
        {
            typedef buffer::difference difference;
            typedef buffer::size_type size_type;
            typedef buffer::value_type value_type;

            /** Overload to provide input. If overloaded this function
             * shall shall fill a range [first, stop), where first <= stop
             * < last, with items and return stop.  Return 0 to indicate
             * end of input.  The default is to return last, which gives a
             * infinite sequence of junk (default constructed, or
             * previously assigned) elements, which is suitable for a pure
             * output stream. */
            virtual T* read(T* first, T* last) { return last; }

            /** Overload to receive output. If overloaded write [first, last)
             * to the tied output channel. The default is to do nothing, which
             * is suitable for a pure input stream. */
            virtual void write(T* first, T* last) {}

            /** Shall return true on error. */
            virtual bool is_error() { return false; }

            virtual ~driver() {}
        };

      private:
        static size_type const n_buf_init = 512;

      public:
        /** Construct an optionally install a driver.  If \a
            is_interactive is true, the buffer will not read more
            characters from the driver than strictly requested. */
        explicit buffer(driver* drv = 0, bool is_interactive = false)
            : m_drv(drv? drv : new driver),
              m_alloc(0), m_begin(0), m_cur(0), m_stop(0), m_end(0),
              have_eof(false)/*, m_super(0)*/,
              m_is_interactive(is_interactive)
        {
            lookahead(1);
        }

        /** Deletes the tied driver and destructs the buffer. */
        ~buffer()
        {
            sync();
            delete[] m_alloc;
            delete m_drv;
//          delete m_super;
        }

//      void push(driver* drv) {
//          buffer* b = new buffer(drv);
//          swap(*b);
//          m_super = b;
//      }

//      void pop() {
//          if (!m_super)
//              throw std::logic_error("This is the toplevel buffer.");
//          buffer* b = m_super;
//          swap(*b);
//          delete b;
//      }

        /** Sync and clears the buffer and ties the buffer to the given driver.
         * The remaining output sequence is first written, and any unread
         * input is discarded as the buffer is reset.  Then the old driver
         * is returns and must be deleted by the callee, and the new driver
         * installed. */
        driver* install(driver* b)
        {
            driver* old = m_drv;
            this->~buffer();
            new ((void*)this) buffer(b);
            return old;
        }

        /** Write out any buffered characters. */
        void sync() {
            if (m_begin != m_cur)
                m_drv->write(m_begin, m_cur);
        }

        /** Returns a reference to item number \a n counting from the
         *  current position, with no checks.
         *  \pre There is at least n+1 items lookahead. */
        T& at(size_type n) { return m_cur[n]; }
        T const& at(size_type n) const { return m_cur[n]; }

        /** Returns a pointer to the current buffer position, with no checks.
         *  It is valid to dereference any element within the current lookahead.
         *  The pointer is invalidated by a call to any non-const method which
         *  is not also overloaded with a const method. */
        T* data() { return m_cur; }
        T const* data() const { return m_cur; }

        /** Returns an array of at least \a n items starting at the
         *  current item.
         *  \pre There is at least \a n items left in the input sequence. */
        T* data(size_type n)
        {
            if (lookahead(n) >= n)
                return m_cur;
            else
                throw std::length_error("more::io::buffer::data: "
                                        "Too few items in input sequence.");
        }

        /** Get \a n items in the form of an array.
         *  That is, advance the current position with \a n, and return a
         *  pointer to the start of the region advanced over.
         *  \pre There is at least \a n items left in the input sequence.
         *  \post there is at least 1 item lookahead unless \c is_eof(). */
        T* get_n(size_type n)
        {
            if (lookahead(n+1) >= n) {
                m_cur += n;
                return m_cur - n;
            }
            else
                throw std::length_error("more::io::buffer::data: "
                                        "Too few items in input sequence.");
        }

        /** Increment the current position and return reference to the
         *  new previous item.
         *  \pre \c !is_eof()
         *  \post It is guaranteed to be one character lookahead so that
         *  peek() is valid, unless is_eof(). */
        T& get()
        {
            if (lookahead(2) < 1)
                throw std::length_error("more::io::buffer::get: "
                                        "Too few items in input sequence.");
            ++m_cur;
            return m_cur[-1];
        }

        /** Returns a reference to the current item without incrementing it.
         *  \pre is_eof() is false.
         */
        T& peek() { return *m_cur; }
        T const& peek() const { return *m_cur; }

        /** Attemt to assure at least n items lookahead, returns the actual
         * number. */
        size_type lookahead(size_type n)
        {
            if (m_cur + n > m_stop)
                extend(n);
            return m_stop - m_cur;
        }

        /** Returns true if the buffer is tied to an input function,
         * and there is no more input. */
        bool is_eof() { return m_cur >= m_stop; }

        /** True if the driver says so. */
        bool is_error() { return m_drv->is_error(); }

        /** Swaps drivers, contents and states of the two buffers. */
        void swap(buffer& b)
        {
            std::iter_swap(m_drv, b.m_drv);
            std::iter_swap(m_alloc, b.m_alloc);
            std::iter_swap(m_begin, b.m_begin);
            std::iter_swap(m_cur, b.m_cur);
            std::iter_swap(m_stop, b.m_stop);
            std::iter_swap(m_end, b.m_end);
            std::swap(have_eof, b.have_eof);
//          std::swap(m_super, b.m_super);
        }

      protected:
        /** Set a fixed buffer. If the buffer provides input, it is assumed
         * that the range provided already contains a bufferfull of data. */
        void set_fixed(T* first, T* end, bool have_eof = false)
        {
            delete[] m_alloc;
            m_alloc = 0;
            m_begin = first;
            m_cur = first;
            m_stop = end;
            m_end = end;
            if (have_eof) ++m_end;
        }

      private:
        void extend(size_type n);

        driver* m_drv;
        T* m_alloc;
        T* m_begin;
        T* m_cur;
        T* m_stop;
        T* m_end;
        bool have_eof;
//      buffer* m_super;
        bool m_is_interactive;
    };

  template<typename Char, typename Traits>
    typename buffer<Char>::driver*
    new_isdriver(std::basic_string<Char, Traits> const& str, bool want_eof);

  template<typename Char, typename Traits>
    typename buffer<Char>::driver*
    new_osdriver(std::basic_string<Char, Traits>& str);

  /** Allocates a driver for input from the file with named name, or
      stdin if name=0. */
  template<typename Char>
    typename buffer<Char>::driver*
    new_ifdriver(char const* name, bool want_eof);

  /** Allocates a driver for output to file named name. */
  template<typename Char>
    typename buffer<Char>::driver*
    new_ofdriver(char const* name);

  template<typename Char>
    struct readline_driver {};

  template<>
    struct readline_driver<char> : buffer<char>::driver
    {
        readline_driver(char* prompt, bool want_eof, char* sep = "\n");
        ~readline_driver();
        void set_prompt(char* prompt) { m_prompt = prompt; }
      protected:
        char* read(char* first, char* last);
      private:
        char* m_prompt;
        char* m_pending;
        bool m_want_eof;
        char* m_sep;
        bool m_toggle;
    };

  template<>
    struct readline_driver<wchar_t> : buffer<wchar_t>::driver
    {
        readline_driver(char* prompt, bool want_eof, wchar_t* sep = L"\n");
        ~readline_driver();
        void set_prompt(char* prompt) { m_prompt = prompt; }
      protected:
        wchar_t* read(wchar_t* first, wchar_t* last);
      private:
        char* m_prompt;
        wchar_t* m_pending;
        wchar_t* m_alloc;
        bool m_want_eof;
        wchar_t* m_sep;
        bool m_toggle;
    };

  /** Return a readline driver for a buffer.  This is the same as the
   *  other overload with <tt>sep = "\n"</tt> or <tt>sep = L"\n"</tt>
   *  as appropriate. */
  template<typename Char>
    inline typename buffer<Char>::driver*
    new_readline_driver(char* prompt, bool want_eof = false)
    {
        return new readline_driver<Char>(prompt, want_eof);
    }

  /** Return readline driver for a buffer.  A \a sep is inserted in
   *  front of each line, including the first.  Reading over these
   *  characters causes a prompt.  \a sep is typically a newline, and
   *  serve as dummy lookahead character(s) which allows the prompt to
   *  be delayed until the program skips over white-spaces for the
   *  purpose of reading something.  The driver will be free by the
   *  buffer.  */
  template<typename Char>
    inline typename buffer<Char>::driver*
    new_readline_driver(char* prompt, bool want_eof, Char* sep)
    {
        return new readline_driver<Char>(prompt, want_eof, sep);
    }

}}

#include <more/bits/buffer.tcc>

#endif

---