dlib C++ Library - vectorstream.h

// Copyright (C) 2012 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#ifndef DLIB_VECTORStREAM_Hh_
#define DLIB_VECTORStREAM_Hh_
#include "vectorstream_abstract.h"
#include <cstring>
#include <iostream>
#include <streambuf>
#include <vector>
#include <cstdio>
#include "../algs.h"
#include "../assert.h"
#ifdef _MSC_VER
// Disable the warning about inheriting from std::iostream 'via dominance' since this warning is a warning about
// visual studio conforming to the standard and is ignorable. See http://connect.microsoft.com/VisualStudio/feedback/details/733720/inheriting-from-std-fstream-produces-c4250-warning
// for further details if interested.
#pragma warning(disable : 4250)
#endif // _MSC_VER
namespace dlib
{
 class vectorstream : public std::iostream
 {
 template<typename CharType>
 class vector_streambuf : public std::streambuf
 {
 typedef typename std::vector<CharType>::size_type size_type;
 size_type read_pos = 0; // buffer[read_pos] == next byte to read from buffer
 public:
 std::vector<CharType>& buffer;
 vector_streambuf(
 std::vector<CharType>& buffer_
 ) :
 read_pos(0),
 buffer(buffer_) 
 {}
 void seekg(size_type pos)
 {
 read_pos = pos;
 }
 pos_type seekpos(pos_type pos, std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out)
 {
 return seekoff(pos - pos_type(off_type(0)), std::ios_base::beg, mode);
 }
 pos_type seekoff(off_type off, std::ios_base::seekdir dir,
 std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out )
 {
 DLIB_CASSERT(mode == std::ios_base::in, "vectorstream does not support std::ios_base::out");
 switch (dir)
 {
 case std::ios_base::beg:
 read_pos = off;
 break;
 case std::ios_base::cur:
 read_pos += off;
 break;
 case std::ios_base::end:
 read_pos = buffer.size() + off;
 break;
 default:
 break;
 }
 return pos_type(read_pos);
 }
 // ------------------------ OUTPUT FUNCTIONS ------------------------
 int_type overflow ( int_type c)
 {
 if (c != EOF) buffer.push_back(static_cast<char>(c));
 return c;
 }
 std::streamsize xsputn ( const char* s, std::streamsize num)
 {
 buffer.insert(buffer.end(), s, s+num);
 return num;
 }
 // ------------------------ INPUT FUNCTIONS ------------------------
 int_type underflow( 
 )
 {
 if (read_pos < buffer.size())
 return static_cast<unsigned char>(buffer[read_pos]);
 else
 return EOF;
 }
 int_type uflow( 
 )
 { 
 if (read_pos < buffer.size())
 return static_cast<unsigned char>(buffer[read_pos++]);
 else
 return EOF;
 }
 int_type pbackfail(
 int_type c
 )
 { 
 // if they are trying to push back a character that they didn't read last
 // that is an error
 const auto prev = read_pos-1;
 if (c != EOF && prev < buffer.size() && 
 c != static_cast<unsigned char>(buffer[prev]))
 {
 return EOF;
 }
 read_pos = prev;
 return 1;
 }
 std::streamsize xsgetn (
 char* s, 
 std::streamsize n
 )
 { 
 if (read_pos < buffer.size())
 {
 const size_type num = std::min<size_type>(n, buffer.size()-read_pos);
 std::memcpy(s, &buffer[read_pos], num);
 read_pos += num;
 return num;
 }
 return 0;
 }
 };
 public:
 vectorstream (
 std::vector<char>& buffer
 ) : std::iostream(0),
 buf1(buffer),
 buf2(dummy2),
 buf3(dummy3)
 {
 rdbuf(&buf1);
 }
 
 vectorstream (
 std::vector<int8_t>& buffer
 ) : std::iostream(0),
 buf1(dummy1),
 buf2(buffer),
 buf3(dummy3)
 {
 rdbuf(&buf2);
 }
 
 vectorstream (
 std::vector<uint8_t>& buffer
 ) : std::iostream(0),
 buf1(dummy1),
 buf2(dummy2),
 buf3(buffer)
 {
 rdbuf(&buf3);
 }
 
 vectorstream(const vectorstream& ori) = delete;
 vectorstream(vectorstream&& item) = delete;
 
 private:
 std::vector<char> dummy1;
 std::vector<int8_t> dummy2;
 std::vector<uint8_t> dummy3;
 vector_streambuf<char> buf1;
 vector_streambuf<int8_t> buf2;
 vector_streambuf<uint8_t> buf3;
 };
}
#endif // DLIB_VECTORStREAM_Hh_