File.hpp

/*
 *  Copyright 2011, 2012 Lukas Jirkovsky
 *
 *  This file is part of FotoSHOCKcore.
 *
 *  FotoSHOCKcore is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License as published by
 *  the Free Software Foundation, version 3 of the License.
 *
 *  FotoSHOCKcore 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 Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with FotoSHOCKcore.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef FILE_H
#define FILE_H

#include "IOException.hpp"

#include <string>
#include <cstdio>
#include <cerrno>

namespace FotoSHOCKcore {
namespace IO {

class File {
    public:

        File (const char* path, const char* mode) throw (IOException) {
            file = std::fopen (path, mode);
            if (file == 0) {
                std::string msg("Unable to open the file ");
                msg += path;
                msg += " with mode: ";
                msg += mode;
                throw IOException(msg.c_str(), __FILE__, __LINE__);
            }
        }


        void close() throw (IOException) {
            // it is not necessary to check for file != 0, as it is guaranteed by the constructor
            errno = 0;
            if (std::fclose (file)) {
                // there are several possible errors, handle some of them
                std::string msg;
                switch (errno) {
                    case EBADF:
                        msg = "Bad file descriptor.";
                        break;
                    case EIO:
                        msg = "An I/O error occurred while closing the file.";
                        break;
                    default:
                        msg = "An error ocured while closing the file.";
                        break;
                }
                throw IOException(msg.c_str(), __FILE__, __LINE__);
            }
            file = 0;
        }


        ~File() {
            // close the handle in case it is not closed yet
            if (file) {
                errno = 0;
                if (std::fclose (file)) {
                    // there are several possible errors, handle some of them
                    switch (errno) {
                        case EBADF:
                            std::fprintf(stderr, "Bad file descriptor.");
                            break;
                        case EIO:
                            std::fprintf(stderr, "An I/O error occurred while closing the file.");
                            break;
                        default:
                            std::fprintf(stderr, "An error ocured while closing the file.");
                            break;
                    }
                }
            }
        }


        FILE* get() {
            return file;
        }

    private:
        FILE* file;

        // this class should never be copied or assigned
        File (const File&);
        File& operator= (const File&);
};

}
}

#endif