E:/prg/sdlpp/include/sdlpp_llio.h

#ifndef H_SDLPP_LLIO
#define H_SDLPP_LLIO

#include <iosfwd>                           
#include <boost/iostreams/categories.hpp>
#include <boost/iostreams/positioning.hpp>
#include <boost/iostreams/concepts.hpp>
#include <boost/iostreams/stream.hpp>
#include <boost/iostreams/stream_buffer.hpp>
#include <boost/shared_ptr.hpp>

namespace io = boost::iostreams;

namespace SDLPP {

struct seekable_source_tag : virtual io::device_tag, virtual io::input_seekable { };
typedef boost::shared_ptr<std::ifstream> ifstream_ptr;

class block_source
{
  ifstream_ptr         m_File;
  std::streamsize      m_TotalBytes;
  std::streamsize    m_BasePosition;

  //block_source(const block_source&) {}
  //block_source& operator= (const block_source& rhs) { return *this; }
public:
  typedef char                 char_type;
  typedef seekable_source_tag  category;

  block_source(std::ifstream* f, unsigned bytes)
    : m_File(f),
      m_TotalBytes(bytes),
      m_BasePosition(f->tellg())
  {}

  //virtual ~block_source() { delete m_File; }

  std::streamsize read(char* s, std::streamsize n)
  {
    std::streamsize pos=m_File->tellg();
    std::streamsize consumed=pos-m_BasePosition;
    std::streamsize left=m_TotalBytes-consumed;
    n=Min(n,left);
    m_File->read(s,n);
    return m_File->gcount();
  }

  std::streamsize seek(std::streamsize off, std::ios_base::seekdir way)
  {
    std::streamsize abs_offset=m_BasePosition+off;
    if (way==std::ios_base::cur) abs_offset=std::streamsize(m_File->tellg())+off;
    if (way==std::ios_base::end) abs_offset=m_BasePosition+m_TotalBytes+off;
    return abs_seek(abs_offset) - m_BasePosition;
  }

private:
  std::streamsize abs_seek(std::streamsize abs_offset)
  {
    abs_offset=Max(abs_offset,m_BasePosition);
    abs_offset=Min(abs_offset,m_BasePosition+m_TotalBytes);
    m_File->seekg(abs_offset);
    return m_File->tellg();
  }
};

class block_stream : public io::stream<block_source>
{
  block_source m_Source;
public:
  block_stream(std::ifstream* f, unsigned bytes)
    : m_Source(f,bytes)
  {
    open(m_Source);
  }
};

} // namespace SDLPP


#endif // H_SDLPP_LLIO

---