file.h

Go to the documentation of this file.

#pragma once
/*
 *  This file is part of the gobelijn software.
 *  Gobelijn is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by the
 *  Free Software Foundation, either version 3 of the License, or any later
 *  version. Gobelijn is distributed in the hope that it will be useful, but
 *  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 *  or FITNESS FOR A PARTICULAR PURPOSE.
 *  See the GNU General Public License for details. You should have received
 *  a copy of the GNU General Public License along with the software. If not,
 *  see <http://www.gnu.org/licenses/>.
 *
 *  Copyright 2016, 2018, Jan Broeckhove, Universiteit Antwerpen.
 */
#include <cstdio>
#include <exception>
#include <string>

namespace Raii {

class FileError : public std::exception
{
};
class OpenError : public FileError
{
};
class CloseError : public FileError
{
};
class ReadError : public FileError
{
};
class WriteError : public FileError
{
};

class File
{
public:
        // Explicitly delete the usual constructors/assignment operators.
        File() = delete;
        File(const File&) = delete;
        File& operator=(const File&) = delete;

        File(const char* path, const char* mode) : m_file(std::fopen(path, mode))
        {
                if (m_file == nullptr) {
                        throw OpenError();
                }
        }

        File(File&& other) noexcept
                : m_file(other.m_file)
        {
                other.m_file = nullptr;
        }

        File& operator=(File&& other)
        {
                m_file = other.m_file;
                other.m_file = nullptr;
                return *this;
        }

        ~File()
        {
                // Close the file, and hope that everything goes well. Don't throw an
                // exception in the destructor, because that's dangerous and bad practice.
                // If the user wants to handle exceptions, then they should use 'File::Close'.
                CloseImpl();
        }

        void Close()
        {
                if (!CloseImpl()) {
                        throw CloseError();
                }
        }

        bool IsOpen() const { return m_file != nullptr; }

        int ReadChar()
        {
                if (!IsOpen()) {
                        throw ReadError();
                }
                int result = std::fgetc(m_file);
                if (std::ferror(m_file)) {
                        throw ReadError();
                }
                return result;
        }

        void WriteChar(char Value) {
                if (!IsOpen())
                        // File has been closed. Throw an exception.
                        throw WriteError();
                if (std::fputc(Value, m_file) == EOF) {
                        throw WriteError();
                }
        }

private:
        bool CloseImpl()
        {
                if (!IsOpen())
                        // File has been closed already. Do nothing.
                        return true;
                bool result = (std::fclose(m_file) == 0);
                if (result) {
                        // Set the file handle to 'nullptr' if everything went  well.
                        m_file = nullptr;
                }
                return result;
        }

        std::FILE* m_file;
};

} // namespace Raii