include/util/systemio.hpp

Go to the documentation of this file.

// systemio.hpp -*- C++ -*-
// Copyright (C) 2011 Martin Trenkmann
#ifndef AITOOLS_UTIL_SYSTEMIO_HPP
#define AITOOLS_UTIL_SYSTEMIO_HPP

#include <limits.h> // PATH_MAX
#include <cstring>  // std::strncpy, std::strncat
#include <boost/filesystem.hpp>

#include "util/exception.hpp"

namespace bfs = boost::filesystem;

namespace aitools {
namespace util {

inline void
signal_error(const std::string& msg)
{
        std::perror(msg.c_str());
        throw_runtime_error(msg);
}

template <typename T>
void
signal_error(const std::string& msg, const T& obj)
{
        std::perror(msg.c_str());
        throw_runtime_error(msg, obj);
}

inline uint64_t
directory_size(const bfs::path& dir)
{
        uint64_t byte_size(0);
        const bfs::directory_iterator end;
        for (bfs::directory_iterator it(dir); it != end; ++it)
        {
                if (bfs::is_regular_file(it->path()))
                {
                        byte_size += bfs::file_size(it->path());
                }
                else if (bfs::is_directory(it->path()))
                {
                        byte_size += directory_size(it->path());
                }
        }
        return byte_size;
}

inline void
fclose(FILE* fs)
{
        if (fs == NULL) return;
        if (std::fclose(fs) == EOF)
        {
                signal_error("std::fclose failed");
        }
}

/* THIS DOES NOT WORK */
// The intent of this function was to provide a method to duplicate a FILE*
// object (C file stream), similar to the POSIX dup function for UNIX file
// discriptors. However, it is not possible to get a completely independent
// FILE* (own file position pointer etc.) pointing to the same file.
//
// http://stackoverflow.com/questions/1598586/duplicate-file-descriptor-with-its-own-file-offset
//
//inline FILE*
//fdup(FILE* fs, const char* mode)
//{
//      int fn(fileno(fs));
//      if (fn == -1)
//      {
//              signal_error("fileno failed");
//      }
//      fn = dup(fn);
//      if (fn == -1)
//      {
//              signal_error("dup failed");
//      }
//      FILE* fs_dup(fdopen(fn, mode));
//      if (fs_dup == NULL)
//      {
//              signal_error("fdopen failed");
//      }
//      return fs_dup;
//}

inline FILE*
fopen(const bfs::path& path, const std::string& mode)
{
        FILE* fs(std::fopen(path.string().c_str(), mode.c_str()));
        if (fs == NULL)
        {
                signal_error("std::fopen failed", path);
        }
        return fs;
}

inline void
fread(void* data, size_t size, size_t count, FILE* fs)
{
        assert(fs != NULL);
        assert(data != NULL);
        if (std::fread(data, size, count, fs) != count)
        {
                signal_error("std::fread failed");
        }
}

inline void
fseek(FILE* fs, long offset, int origin)
{
        assert(fs != NULL);
        if (std::fseek(fs, offset, origin) != 0)
        {
                signal_error("std::fseek failed");
        }
}

inline void
fwrite(const void* data, size_t size, size_t count, FILE* fs)
{
        assert(fs != NULL);
        assert(data != NULL);
        if (std::fwrite(data, size, count, fs) != count)
        {
                signal_error("std::fwrite failed");
        }
}

inline size_t
ftell(FILE* fs)
{
        assert(fs != NULL);
        const long offset(std::ftell(fs));
        if (offset == -1)
        {
                signal_error("std::ftell failed");
        }
        return offset;
}

inline void
rewind(FILE* fs)
{
        if (fs == NULL) return;
        std::rewind(fs);
}

inline FILE*
tmpfile()
{
        FILE* fs(std::tmpfile());
        if (fs == NULL)
        {
                signal_error("std::tmpfile failed");
        }
        return fs;
}

inline const bfs::path
tmpdir(const bfs::path& parent_dir)
{
        char tmpdir[PATH_MAX];
        const std::string pattern("/tmp_XXXXXX");
        const std::string parent_str(parent_dir.string());
        std::strncpy(tmpdir, parent_str.c_str(), parent_str.size() + 1);
        std::strncat(tmpdir, pattern.c_str(), pattern.size() + 1);
        if (mkdtemp(tmpdir) == NULL)
        {
                signal_error("mkdtemp failed");
        }
        return tmpdir;
}

} // namespace util

using util::signal_error;
using util::directory_size;
using util::fclose;
using util::fopen;
using util::fread;
using util::fseek;
using util::fwrite;
using util::ftell;
using util::rewind;
using util::tmpfile;
using util::tmpdir;

} // namespace aitools

#endif // AITOOLS_UTIL_SYSTEMIO_HPP

---