buf_stream.hh

// This file is a part of Aurelia.
// Copyright (C) 2010  Valentin David
// Copyright (C) 2010  University of Bergen
//
// This program 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 3 of the License, or
// (at your option) any later version.
//
// This program 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, see <http://www.gnu.org/licenses/>.

#ifndef __BUF_STREAM_HH
# define __BUF_STREAM_HH

# include <forward_list>
# include <istream>
# include <sstream>
# include "hash/hash_addr.hh"

namespace aurelia {

struct rc_char {
  int refs;
  char c;
  rc_char(char c): refs(0), c(c){}
  rc_char(const rc_char& other): refs(other.refs), c(other.c) {}
};

struct buf_stream;

struct buf_stream_iterator {
private:
  buf_stream* s;
  std::forward_list<rc_char>::iterator i;
  int pos;

  friend class buf_stream;
  explicit buf_stream_iterator(buf_stream* s,
                               const std::forward_list<rc_char>::iterator& i,
                               int pos);
public:
  unsigned hash() const;

  int get_pos() const {
    return pos;
  }

  bool operator==(const buf_stream_iterator& other) const;

  bool operator!=(const buf_stream_iterator& other) const {
    return !(*this == other);
  }

  bool operator<(const buf_stream_iterator& other) const {
    return pos < other.pos;
  }

  ~buf_stream_iterator();

  buf_stream_iterator& operator++();

  buf_stream_iterator(const buf_stream_iterator&);
  buf_stream_iterator(buf_stream_iterator&&);

  char operator*() const {
    return (*i).c;
  }

  bool eof() const;

  buf_stream_iterator& operator=(const buf_stream_iterator& other) {
    return *this = buf_stream_iterator(other);
  }

  buf_stream_iterator& operator=(buf_stream_iterator&& other);

  bool eat(const std::string& s) {
    std::string::const_iterator i = s.begin();
    buf_stream_iterator t(*this);
    while (!t.eof() && (i != s.end())) {
      if (*i != *t)
        return false;
      ++i;
      ++t;
    }
    if (i != s.end())
      return false;
    *this = t;
    return true;
  }
};

struct buf_stream {
private:
  std::istream* real_stream;
  std::forward_list<rc_char> buf;
  int start;
  unsigned _hash;
#ifndef NDEBUG
  int size;
#endif

public:
  buf_stream(const buf_stream&) = delete;
  buf_stream(buf_stream&&) = delete;

#ifndef NDEBUG
  int buffer_start() const {
    return start;
  }

  //Testing method
  int buffer_size() const {
    return size;
  }
#endif

  explicit buf_stream(std::istream& s): real_stream(&s)
                                      , start(0)
#ifndef NDEBUG
                                      , size(0)
#endif
  {
    _hash = hash_addr(s);
  }

  unsigned hash() const {
    return _hash;
  }

  buf_stream& operator=(const buf_stream&) = delete;
  buf_stream& operator=(buf_stream&&) = delete;

  buf_stream_iterator begin() {
    std::forward_list<rc_char>::iterator i = buf.begin();
    if (i == buf.end()) {
      char c = real_stream->get();
#ifndef NDEBUG
      size++,
#endif
      buf.push_front(rc_char(c));
    }
    return buf_stream_iterator(this, buf.begin(), start);
  }

  buf_stream_iterator end() {
    std::forward_list<rc_char>::iterator i = buf.end();
    return buf_stream_iterator(this, i, -1);
  }

  std::forward_list<rc_char>::iterator buf_end() {
    return buf.end();
  }

  void cleanup () {
    std::forward_list<rc_char>::iterator i = buf.begin();
    while (i != buf.end()) {
      if ((*i++).refs == 0) {
        start++;
#ifndef NDEBUG
        size--;
#endif
        buf.pop_front();
      }
      else return ;
    }
  }

  bool is_end(const std::forward_list<rc_char>::iterator& i) const {
    return i == buf.end();
  }

  void next(std::forward_list<rc_char>::iterator& i) {
    std::forward_list<rc_char>::iterator next = i;
    ++next;
    if (next == buf.end()) {
      char c = real_stream->get();
      if (!real_stream->good()) {
        i = next;
        return ;
      }
      buf.insert_after(i,rc_char(c));
#ifndef NDEBUG
      size++;
#endif
      ++i;
      return ;
    }
    i = next;
  }
};

buf_stream_iterator::buf_stream_iterator(buf_stream* s,
                                         const std::forward_list<rc_char>
                                         ::iterator& i, int pos)
  : s(s), i(i), pos(pos) {
  if (pos != -1)
    (*i).refs++;
}
buf_stream_iterator::buf_stream_iterator(const buf_stream_iterator& other)
  : s(other.s), i(other.i), pos(other.pos) {
  if (!(s->is_end(i)))
    (*i).refs++;
}

  buf_stream_iterator::buf_stream_iterator(buf_stream_iterator&& other)
  : s(other.s), i(s->buf_end()), pos(other.pos) {
  std::swap(i, other.i);
  other.pos = -1;
  }

buf_stream_iterator::~buf_stream_iterator()
{
  if (!s->is_end(i)) {
    if (--((*i).refs) == 0)
      s->cleanup();
  }
}

buf_stream_iterator& buf_stream_iterator::operator++() {
  std::forward_list<rc_char>::iterator prev(i);
  s->next(i);
  pos++;
  if (!s->is_end(i)) {
    (*i).refs++;
  }
  if (--((*prev).refs) == 0)
    s->cleanup();
  return *this;
}

bool buf_stream_iterator::eof() const {
  return (s->is_end(i));
}

  buf_stream_iterator& buf_stream_iterator::operator=
  (buf_stream_iterator&& other) {
    std::swap(s, other.s);
    std::swap(pos, other.pos);
    std::swap(i, other.i);
    return *this;
  }

unsigned buf_stream_iterator::hash() const {
  unsigned hash = (unsigned)pos;
  hash = (hash << 11) | (hash >> 21);
  hash ^= s->hash();
  return hash;
}

bool buf_stream_iterator::operator==(const buf_stream_iterator& other) const {
  if (pos == -1) {
    return s->is_end(other.i);
  }
  if (other.pos == -1) {
    return s->is_end(i);
  }
  return (s == other.s) && (pos == other.pos);
}

typedef buf_stream_iterator stream;

  std::string stream_range_to_string(stream begin, const stream& end) {
    std::stringstream ret;
    while (begin != end) {
      ret << *begin;
      ++begin;
    }
    return ret.str();
  }

  template <typename Stream>
  Stream& operator<<(Stream& s, const stream& i) {
    s << "(stream:" <<  i.get_pos() << ")";
    return s;
  }
}

#endif