memstream.h

Go to the documentation of this file.

#ifndef PhysicsTools_MVAComputer_memstream_h
#define PhysicsTools_MVAComputer_memstream_h
// -*- C++ -*-
//
// Package:     MVAComputer
//

//
// Author:  Christophe Saout <christophe.saout@cern.ch>
// Created:     Sat Apr 24 15:18 CEST 2007
//

#include <iostream>

namespace ext {

  // provide STL stream to read/write into memory buffers
  //
  // constructors both take pointer to a buffer and buffer size

  template <typename Item_t, typename Traits_t = std::char_traits<Item_t>, typename Allocator_t = std::allocator<Item_t> >
  class basic_omemstream : private std::basic_streambuf<Item_t, Traits_t>, public std::basic_ostream<Item_t, Traits_t> {
  public:
    typedef typename Traits_t::char_type char_type;
    typedef typename Traits_t::int_type int_type;
    typedef Traits_t traits_type;

    basic_omemstream(char_type *buf, size_t size)
        : std::basic_ostream<Item_t, Traits_t>(this), buffer(buf), cur(buf), last(buf + size) {
      this->exceptions(std::ios_base::badbit);
    }

    char_type *begin() const { return buffer; }
    char_type *end() const { return cur; }
    size_t size() const { return cur - buffer; }
    bool empty() const { return cur == buffer; }

  private:
    std::streamsize xsputn(char_type const *data, std::streamsize size) override {
      size_t n = std::min<size_t>(last - cur, size);
      traits_type::copy(cur, data, n);
      cur += n;
      return n;
    }

    int_type overflow(int_type c) override {
      if (!traits_type::eq_int_type(c, traits_type::eof())) {
        char_type t = traits_type::to_char_type(c);
        if (xsputn(&t, 1) < 1)
          return traits_type::eof();
      }

      return c;
    }

    int sync() override { return 0; }

    char_type *buffer, *cur, *last;
  };

  template <typename Item_t, typename Traits_t = std::char_traits<Item_t>, typename Allocator_t = std::allocator<Item_t> >
  class basic_imemstream : private std::basic_streambuf<Item_t, Traits_t>, public std::basic_istream<Item_t, Traits_t> {
  public:
    typedef typename Traits_t::char_type char_type;
    typedef typename Traits_t::int_type int_type;
    typedef Traits_t traits_type;

    basic_imemstream(const char_type *buf, size_t size) : std::basic_istream<Item_t, Traits_t>(this) {
      this->exceptions(std::ios_base::badbit);
      this->setg(const_cast<char_type *>(buf), const_cast<char_type *>(buf), const_cast<char_type *>(buf + size));
    }

  private:
    int_type underflow() override {
      if (this->gptr() && this->gptr() < this->egptr())
        return traits_type::to_int_type(*this->gptr());

      return traits_type::eof();
    }
  };

  typedef basic_omemstream<char> omemstream;
  typedef basic_omemstream<wchar_t> womemstream;
  typedef basic_imemstream<char> imemstream;
  typedef basic_imemstream<wchar_t> wimemstream;

}  // namespace ext

#endif  // PhysicsTools_MVAComputer_memstream_h