file.h

Go to the documentation of this file.

/*
    FILE.H
    ------
    Copyright (c) 2016 Andrew Trotman
    Released under the 2-clause BSD license (See:https://en.wikipedia.org/wiki/BSD_licenses)
    
    Originally from the ATIRE codebase (where it was also written by Andrew Trotman)
*/
#pragma once

#include <stdio.h>
#include <errno.h>
#include <stddef.h>
#include <string.h>

#ifdef _MSC_VER
    #include <windows.h>
#endif

#include <string>
#include <vector>
#include <memory>
#include <stdexcept>

namespace JASS
    {
    /*
        CLASS FILE
        ----------
    */
    class file
        {
        public:
            /*
                CLASS FILE::FILE_READ_ONLY
                --------------------------
            */
            class file_read_only
                {
                friend class file;
                private:
#ifdef _MSC_VER
                    HANDLE hFile;                           
                    HANDLE hMapFile;                        
#endif
                    const void *file_contents;                              
                    size_t size;                                            

                public:
                    /*
                        FILE::FILE_READ_ONLY::FILE_READ_ONLY()
                        --------------------------------------
                    */
                    file_read_only():
                        file_contents(nullptr),
                        size(0)
                        {
                        /* Nothing */
                        }

                    /*
                        FILE::FILE_READ_ONLY::OPEN()
                        ----------------------------
                    */
                    size_t open(const std::string &filename);

                    /*
                        FILE::FILE_READ_ONLY::~FILE_READ_ONLY()
                        ---------------------------------------
                    */
                    ~file_read_only();

                    /*
                        FILE::FILE_READ_ONLY::READ_ENTIRE_FILE()
                        ----------------------------------------
                    */
                    size_t read_entire_file(const uint8_t *&into) const
                        {
                        into = reinterpret_cast<const uint8_t *>(file_contents);
                        return size;
                        }
                };

        protected:
            FILE *fp;                               
            size_t file_position;               
            size_t buffer_size;                 
            size_t buffer_used;                 
            std::unique_ptr<uint8_t []> buffer; 
            size_t bytes_written;               
            size_t bytes_read;                  

        public:
            /*
                FILE::FILE()
                ------------
            */
            file() = delete;

            /*
                FILE::FILE()
                ------------
            */
            file(FILE *fp) :
                fp(fp),
                file_position(0),
                buffer_size(10 * 1024 * 1024),                  // start with a buffer of this size
                buffer_used(0),
                buffer(std::make_unique<uint8_t []>(buffer_size)),
                bytes_written(0),
                bytes_read(0)
                {
                /* Nothing */
                }

            /*
                FILE::FILE()
                ------------
            */
            file(const char *filename, const char *mode) :
                file(nullptr)
                {
                /*
                    Open the given file in the given mode
                */
                #if defined(__STDC_LIB_EXT1__)
                    fopen_s(&fp, filename, mode);
                #else
                    fp = fopen(filename, mode);
                #endif
                }

            /*
                FILE::FILE()
                ------------
            */
            file(const std::string &filename, const std::string &mode) :
                file(filename.c_str(), mode.c_str())
                {
                /* Nothing */
                }

            /*
                FILE::~FILE()
                -------------
            */
            ~file()
                {
                flush();
                if (fp != nullptr && fp != stdin && fp != stdout && fp != stderr)
                    fclose(fp);
                }

            /*
                FILE::SETVBUF()
                ---------------
            */
            size_t setvbuf(size_t size)
                {
                buffer_size = size;
                buffer = std::make_unique<uint8_t []>(buffer_size);
                return buffer == NULL ? 0 : 1;
                }

            /*
                FILE::FLUSH()
                -------------
            */
            void flush(void)
                {
                if (buffer_used > 0)
                    {
                    /*
                        All physical output to the disk happens with this one line of code.  If this is
                        done with blocking I/O then this causes a bottleneck as we wait for the OS
                        to write to disk.
                    */
                    ::fwrite(buffer.get(), 1, buffer_used, fp);
                    buffer_used = 0;
                    }
                }

            /*
                FILE::READ()
                ------------
            */
            size_t read(void *data, size_t size)
                {
                /*
                    Keep track of the number of bytes we've been asked to write
                */
                bytes_read += size;

                /*
                    Flush the write cache
                */
                flush();

                /*
                    Take note of the new file position (at the end of the read)
                */
                file_position += size;      // this is where we'll be at the end of the read

                /*
                    And now perform the read
                */
                return ::fread(data, 1, size, fp);
                }

            /*
                FILE::READ()
                ------------
            */
            void read(std::vector<uint8_t> &buffer)
                {
                /*
                    Read from the file
                */
                size_t bytes_read = read(&buffer[0], buffer.size());

                /*
                    If we got a short read then resize the buffer to signal back to the caller that we failed to read (probably EOF).
                */
                if (bytes_read == 0)
                    buffer.resize(0);
                else if (bytes_read != buffer.size())
                    buffer.resize(bytes_read);
                }

            /*
                FILE::WRITE()
                -------------
            */
            size_t write(const void *data, size_t size)
                {
                uint8_t *from;
                size_t block_size;

                /*
                    Keep track of the total number of bytes we've been asked to write to the file
                */
                bytes_written += size;

                /*
                    Update the file pointer
                */
                file_position += size;

                if (buffer_used + size < buffer_size)
                    {
                    /*
                        The data fits in the internal buffers
                    */
                    memcpy(buffer.get() + buffer_used, data, (size_t)size);
                    buffer_used += size;
                    }
                else
                    {
                    /*
                        The data does not fit in the internal buffers so it is
                        necessary to flush the buffers and then do the write
                    */
                    from = (uint8_t *)data;
                    do
                        {
                        flush();
                        block_size = size <= buffer_size ? size : buffer_size;
                        memcpy(buffer.get(), from, (size_t)block_size);
                        buffer_used += block_size;
                        from += block_size;
                        size -= block_size;
                        }
                    while (size > 0);
                    }
                return 1;
                }

            /*
                FILE::WRITE()
                -------------
            */
            size_t write(const std::string &buffer)
                {
                return write(buffer.c_str(), buffer.size());
                }

            /*
                FILE::SIZE()
                ------------
            */
            size_t size(void) const;

            /*
                FILE::TELL()
                ------------
            */
            size_t tell(void)
                {
                return file_position;
                }

            /*
                FILE::SEEK()
                ------------
            */
            void seek(size_t offset)
                {
                /*
                    Empty the write buffer
                */
                flush();

                /*
                    Seek
                */
                #ifdef _MSC_VER
                    auto error = _fseeki64(fp, offset, SEEK_SET);
                #else
                    auto error = fseeko(fp, offset, SEEK_SET);
                #endif

                /*
                    Store the file file position
                */
                file_position = offset;

                /*
                    if error is non-zero then seek failed - which if a fatal error.
                */
                if (error != 0)
                    throw std::out_of_range("file::seek() failure");        // LCOV_EXCL_LINE   // This is highly unlikely to happen - its not clear why seek() can fail.
                }

            /*
                FILE::READ_ENTIRE_FILE()
                ------------------------
            */
            static size_t read_entire_file(const std::string &filename, std::string &into);

            /*
                FILE::READ_ENTIRE_FILE()
                ------------------------
            */
            static size_t read_entire_file(const std::string &filename, file_read_only &into)
                {
                return into.open(filename);
                }

            /*
                FILE::WRITE_ENTIRE_FILE()
                -------------------------
            */
            static bool write_entire_file(const std::string &filename, const std::string &buffer);
            
            /*
                FILE::BUFFER_TO_LIST()
                ----------------------
            */
            static void buffer_to_list(std::vector<uint8_t *> &line_list, std::string &buffer);
        
            /*
                FILE::IS_DIRECTORY()
                --------------------
            */
            static bool is_directory(const std::string &filename);

            /*
                FILE::MKSTEMP()
                ---------------
            */
            static std::string mkstemp(std::string prefix);

            /*
                FILE::UNITTEST()
                ----------------
            */
            static void unittest(void);
        } ;
    }