fmstream.h

/*
 * Copyright (c) 2013, Benichou Software
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the author nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Purpose: Provide read-write access to memory-mapped files on Windows and POSIX systems.
 *
 * $Id: fmstream.h 4 2013-09-24 14:03:10Z benichou $
 */

#ifndef FILE_MAPPING_STREAM_H_
#define FILE_MAPPING_STREAM_H_

#include <istream>

#if ((__cplusplus > 199711L) || (_HAS_CPP0X > 0)) && ((_MSC_VER >= 1600) || (__INTEL_COMPILER >= 1200))
#define _HAS_CPP11_ 1
#endif

class filemapping
{
public:
    static std::streamoff offset_granularity();
};

class filemappingbuf : public std::streambuf
{
public:
    filemappingbuf();

    virtual ~filemappingbuf();

#ifdef _HAS_CPP11_



    filemappingbuf(filemappingbuf&& rhs_buf);

    filemappingbuf& operator=(filemappingbuf&& rhs_buf);

    void swap(filemappingbuf& buf);
#endif // _HAS_CPP11_

    bool is_open() const;
    
    filemappingbuf* open(const char* path_name, std::ios_base::openmode mode, std::streamsize max_length = 0, std::streamoff offset = 0);

    filemappingbuf* close();

    void* pubseekptr(void* ptr, std::ios_base::openmode which = std::ios_base::in | std::ios_base::out);
    
    const void* data() const;

    void* data();

    std::streamsize size() const;

protected:
    virtual int sync();
    virtual std::streampos seekoff(std::streamoff off, std::ios_base::seekdir way, std::ios_base::openmode which);
    virtual std::streampos seekpos(std::streampos sp, std::ios_base::openmode which);
    virtual void* seekptr(void* ptr, std::ios_base::openmode which);

private:
    filemappingbuf(const filemappingbuf&);

    filemappingbuf& operator=(const filemappingbuf&);

private:
    char* m_pAddress;            
    std::streamsize m_MapLength; 
#ifdef _WIN32
    void* m_pFile;              
    void* m_pFileMapping;       
#else // If not Windows, this is a POSIX system !
    int m_fd;                    
#endif
};

class ifmstream : public std::istream
{
public:
    ifmstream();

    explicit ifmstream(const char* path_name, std::streamsize max_length = 0, std::streamoff offset = 0);

    virtual ~ifmstream() {}

#ifdef _HAS_CPP11_



    ifmstream(ifmstream&& rhs_stream);

    ifmstream& operator=(ifmstream&& rhs_stream);

    void swap(ifmstream& stream);
#endif // _HAS_CPP11_

    filemappingbuf* rdbuf() const;

    bool is_open() const;

    void open(const char* path_name, std::streamsize max_length = 0, std::streamoff offset = 0);

    void close();

    const void* ptellg();
    
    std::istream& pseekg(const void* ptr);
    
    const void* data() const;

    std::streamsize size() const;

private:
    ifmstream(const ifmstream&);

    ifmstream& operator=(const ifmstream&);

private:
    filemappingbuf m_rdbuf; 
};

class fmstream : public std::iostream
{
public:
    fmstream();

    explicit fmstream(const char* path_name, std::streamsize max_length = 0, std::streamoff offset = 0);

    virtual ~fmstream() {}

#ifdef _HAS_CPP11_



    fmstream(fmstream&& rhs_stream);

    fmstream& operator=(fmstream&& rhs_stream);

    void swap(fmstream& stream);
#endif // _HAS_CPP11_

    filemappingbuf* rdbuf() const;

    bool is_open() const;

    void open(const char* path_name, std::streamsize max_length = 0, std::streamoff offset = 0);

    void close();

    const void* ptellg();

    void* ptellp();

    std::istream& pseekg(const void* ptr);

    std::ostream& pseekp(void* ptr);

    const void* data() const;

    void* data();

    std::streamsize size() const;

private:
    fmstream(const fmstream&);

    fmstream& operator=(const fmstream&);

private:
    filemappingbuf m_rdbuf; 
};

#ifdef _HAS_CPP11_



void swap(filemappingbuf& lhs, filemappingbuf& rhs);

void swap(ifmstream& lhs, ifmstream& rhs);

void swap(fmstream& lhs, fmstream& rhs);
#endif // _HAS_CPP11_

#endif /* FILE_MAPPING_STREAM_H_ */