file_io.cpp

/*
# file io

# ifstream

# ofstream

# fstream
*/

#include "common.hpp"

void ios_write_fail(std::string path) {
    throw std::ios_base::failure("Error: Could not write to file: " + path);
}

void ios_read_fail(std::string path) {
    throw std::ios_base::failure("Error: Could not read file: " + path);
}

/**
Read entire file into a string at once.
*/
void read_file(std::ifstream &ifs, std::string &data_read) {
    ifs.seekg(0, std::ios::end);
    auto size = ifs.tellg();
    data_read.resize(size);
    ifs.seekg(0);
    ifs.read(&data_read[0], size);
    ifs.close();
}

int main() {
    std::string path("fileio.tmp");
    std::string data("ab\n\nc\n");

    // Write to file.
    {
        std::ofstream ofs(path);
        if (ofs) {
            ofs << data;
            ofs.close();
        } else {
            ios_write_fail(path);
        }
    }

    /*
    # Read entire file at once

    http://stackoverflow.com/questions/2602013/read-whole-ascii-file-into-c-stdstring

    Best way seems to be to get file size, allocate, and read manually.
    */
    {
        std::ifstream ifs(path);
        if (ifs) {
            std::string data_read;
            read_file(ifs, data_read);
            assert(data_read == data);
        } else {
            ios_read_fail(path);
        }
    }

    /*
    # Copy file to another

    # cp

    # rdbuf

    http://stackoverflow.com/questions/2141749/what-does-ifstreamrdbuf-actually-do
    */
    {
        std::string data = "abc\ndef\n";
        std::string src_path = "src.tmp";
        std::string dst_path = "dst.tmp";
        // Create input file.
        {
            std::ofstream src(src_path, std::ios::binary);
            src << data;
            // 2 times 4 Gb.
            //for (int i = 0; i < 2; i++) {
            //for (int j = 0; j < 0xFFFFFFFF; j++) {
            //src << std::hex << j;
            //}
            //}
            src.close();
        }
        // Copy.
        std::ifstream src(src_path, std::ios::binary);
        std::ofstream dst(dst_path,   std::ios::binary);
        dst << src.rdbuf();
        src.close();
        dst.close();
        // Check copy.
        {
            std::ifstream dst(dst_path, std::ios::binary);
            std::string data_read;
            read_file(dst, data_read);
            assert(data_read == data);
            src.close();
        }
    }

    /*
    # Compare two files larger than memory.

    TODO is there an easier way than reading each?
    */
    {
    }

    // # Append to file
    {
        std::ofstream ofs(path);

        if (ofs) {
            ofs << data;
            ofs.close();
        } else {
            ios_write_fail(path);
        }

        /*
        # open

        # Reopen

        Can be used to reopen ofstream with new properties.

        Also consider clearing error flags if there can be any.
        */
        //ofs.clear()
        ofs.open(path, std::ios::app);
        if (ofs) {
            ofs << data;
            ofs.close();
        } else {
            ios_write_fail(path);
        }

        std::ifstream ifs(path);
        if (ifs) {
            std::string data_read;
            read_file(ifs, data_read);
            assert(data_read == data + data);
        } else {
            ios_read_fail(path);
        }
    }

    /*
    # binary io

    Use ios::binary, and the binary functions write and read.
    */
    {
        // TODO
        //std::string path("binary.tmp");
        //std::vector<int> data{0x123, 0x456};
        //std::vector<int>::size_type size = data.size();
        //std::vector<int> data_read(size);
        //std::ofstream ofs(path, std::ios::binary);
        //if (ofs) {
        //ofs.write(&data[0], size);
        //ofs.close();
        //} else {
        //ios_write_fail(path);
        //}

        //std::ifstream ifs(path);
        //if (ifs) {
        //std::string data_read;
        //read_file(ifs, data_read);
        //assert(data_read == data);
        //} else {
        //ios_read_fail(path);
        //}
    }

    /*
    # error handling

    # is_open vs bool cast

    `is_open` false implies `operator bool()` false, but the converse is false: `operator bool()` is more strict.

    <http://stackoverflow.com/questions/14920457/c-difference-between-casting-ifstream-to-bool-and-using-ifstreamis-open>

    IO functions do not raise exceptions by default, but may be turned on.

    The best standard exception to raise is probably `std::ios_base::failure`.

    Relevant standard exceptions:

    http://en.cppreference.com/w/cpp/io/ios_base/failure

    SO thread:

    http://stackoverflow.com/questions/9670396/exception-handling-and-opening-a-file
    */
    {
        std::string path("i_dont_exist.tmp");
        std::ifstream ifs(path);
        if (ifs) {
            assert(false);
        } else {
            try {
                //throw std::ios_base::failure("Error: Could not write to file: " + path);
            } catch (std::ios_base::failure e) {
                std::clog << e.what() << std::endl;
            }
        }
    }

    // # ios::in: flag automatically set for ifstream, but not fstream
    //http://stackoverflow.com/questions/7463410/is-iosin-needed-for-ifstreams-opened-in-binary-mode
}