ibrcommon/ibrcommon/data/File.cpp

Go to the documentation of this file.

/*
 * File.cpp
 *
 *  Created on: 20.11.2009
 *      Author: morgenro
 */

#include "ibrcommon/config.h"
#include "ibrcommon/data/File.h"
#include <sstream>
#include <errno.h>
#include <sys/stat.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>

namespace ibrcommon
{
        File::File()
         : _path(), _type(DT_UNKNOWN)
        {
        }

        File::File(const string path, const unsigned char t)
         : _path(path), _type(t)
        {
                resolveAbsolutePath();
                removeSlash();
        }

        File::File(const string path)
         : _path(path), _type(DT_UNKNOWN)
        {
                resolveAbsolutePath();
                removeSlash();
                update();
        }

        void File::removeSlash()
        {
                std::string::iterator iter = _path.end(); iter--;

                if ((*iter) == '/')
                {
                        _path.erase(iter);
                }
        }

        void File::resolveAbsolutePath()
        {
                std::string::iterator iter = _path.begin();

                if ((*iter) != '/')
                {
                        _path = "./" + _path;
                }
        }

        bool File::exists() const
        {
                struct stat st;
                if( stat(_path.c_str(), &st ) == 0)
                        return true;

                return false;
        }

        void File::update()
        {
                struct stat s;
                int type;

                if ( stat(_path.c_str(), &s) == 0 )
                {
                        type = s.st_mode & S_IFMT;

                        switch (type)
                        {
                                case S_IFREG:
                                        _type = DT_REG;
                                        break;

                                case S_IFLNK:
                                        _type = DT_LNK;
                                        break;

                                case S_IFDIR:
                                        _type = DT_DIR;
                                        break;

                                default:
                                        _type = DT_UNKNOWN;
                                        break;
                        }
                }
        }

        File::~File()
        {}

        unsigned char File::getType() const
        {
                return _type;
        }

        int File::getFiles(list<File> &files)
        {
                if (!isDirectory()) return -1;

                DIR *dp;
                struct dirent *dirp;
                if((dp = opendir(_path.c_str())) == NULL) {
                        return errno;
                }

                while ((dirp = readdir(dp)) != NULL)
                {
                        string name = string(dirp->d_name);
                        stringstream ss; ss << getPath() << "/" << name;
                        File file(ss.str(), dirp->d_type);
                        files.push_back(file);
                }
                closedir(dp);

                return 0;
        }

        bool File::isSystem() const
        {
                try {
                        if ((_path.substr(_path.length() - 2, 2) == "..") || (_path.substr(_path.length() - 1, 1) == ".")) return true;
                } catch (std::out_of_range) {
                        return false;
                }
                return false;
        }

        bool File::isDirectory() const
        {
                if (_type == DT_DIR) return true;
                return false;
        }

        string File::getPath() const
        {
                return _path;
        }

        File File::get(string filename) const
        {
                stringstream ss; ss << getPath() << "/" << filename;
                File file(ss.str());

                return file;
        }

        int File::remove(bool recursive)
        {
                int ret;

                if (isSystem()) return -1;
                if (_type == DT_UNKNOWN) return -1;

                if (isDirectory())
                {
                        if (recursive)
                        {
                                // container for all files
                                list<File> files;

                                // get all files in this directory
                                if ((ret = getFiles(files)) < 0)
                                        return ret;

                                for (list<File>::iterator iter = files.begin(); iter != files.end(); iter++)
                                {
                                        if (!(*iter).isSystem())
                                        {
                                                if ((ret = (*iter).remove(recursive)) < 0)
                                                        return ret;
                                        }
                                }
                        }

                        ::rmdir(getPath().c_str());
                }
                else
                {
			::remove(getPath().c_str());
                }

                return 0;
        }

        File File::getParent() const
        {
                size_t pos = _path.find_last_of('/');
                return File(_path.substr(0, pos));
        }

        void File::createDirectory(File &path)
        {
                if (!path.exists())
                {
                        File parent = path.getParent();
                        File::createDirectory(parent);

                        // create path
                        ::mkdir(path.getPath().c_str(), 0700);

                        // update file information
                        path.update();
                }
        }

        size_t File::size() const
        {
                struct stat filestatus;
                stat( getPath().c_str(), &filestatus );
                return filestatus.st_size;
        }

        TemporaryFile::TemporaryFile(const File &path, const std::string prefix)
         : File(tmpname(path, prefix))
        {
        }

        TemporaryFile::~TemporaryFile()
        {
        }

        std::string TemporaryFile::tmpname(const File &path, const std::string prefix)
        {
                std::string pattern = path.getPath() + "/" + prefix + "XXXXXXXX";
                char name[pattern.length()];
                ::strcpy(name, pattern.c_str());

                int fd = mkstemp(name);
                if (fd == -1) throw ibrcommon::IOException("Could not create a temporary name.");
                ::close(fd);

                return std::string(name);
        }

        locked_ifstream::locked_ifstream(File &file, ios_base::openmode mode)
#ifdef USE_FILE_LOCKING
         : _buf(NULL), _stream(NULL), _fd(0)
#endif
        {
                open(file, mode);
        }

        locked_ifstream::~locked_ifstream()
        {
                close();
        }

        void locked_ifstream::open(File &file, ios_base::openmode mode)
        {
#ifdef USE_FILE_LOCKING
                _fd = ::open(file.getPath().c_str(), locked_fstream::getopts(mode));

                flock lock = { F_RDLCK, SEEK_SET, 0, 0, 0 };
                fcntl(_fd, F_SETLKW, &lock);

                _buf = new __gnu_cxx::stdio_filebuf<char>(_fd, mode);
                _stream = new std::istream(_buf);
#else
                _stream.open(file.getPath().c_str(), mode);
#endif
        }

        bool locked_ifstream::is_open()
        {
#ifdef USE_FILE_LOCKING
                return (_stream != NULL);
#else
                return _stream.is_open();
#endif
        }

        void locked_ifstream::close()
        {
                if (!is_open()) return;

#ifdef USE_FILE_LOCKING
                flock lock1 = { F_UNLCK, SEEK_SET, 0, 0, 0 };
                fcntl(_fd, F_SETLKW, &lock1);

                delete _stream; _stream = NULL;
                delete _buf; _buf = NULL;
		::close(_fd);
#else
                _stream.close();
#endif
        }

        std::istream& locked_ifstream::operator*()
        {
                if (!is_open()) throw ibrcommon::IOException("no file open");
#ifdef USE_FILE_LOCKING
                return *_stream;
#else
                return _stream;
#endif
        }

        locked_ofstream::locked_ofstream(File &file, ios_base::openmode mode)
#ifdef USE_FILE_LOCKING
         : _buf(NULL), _stream(NULL), _fd(0)
#endif
        {
                open(file, mode);
        }

        locked_ofstream::~locked_ofstream()
        {
                close();
        }

        void locked_ofstream::open(File &file, ios_base::openmode mode)
        {
#ifdef USE_FILE_LOCKING
                _fd = ::open(file.getPath().c_str(), locked_fstream::getopts(mode));

                flock lock = { F_WRLCK, SEEK_SET, 0, 0, 0 };
                fcntl(_fd, F_SETLKW, &lock);

                _buf = new __gnu_cxx::stdio_filebuf<char>(_fd, mode);
                _stream = new std::ostream(_buf);

                if (mode & ios_base::ate)
                {
                        _stream->seekp(0, ios::end);
                }
#else
                _stream.open(file.getPath().c_str(), mode);
#endif
        }

        bool locked_ofstream::is_open()
        {
#ifdef USE_FILE_LOCKING
                return (_stream != NULL);
#else
                return _stream.is_open();
#endif
        }

        void locked_ofstream::close()
        {
#ifdef USE_FILE_LOCKING
                if (!is_open()) return;

                flock lock1 = { F_UNLCK, SEEK_SET, 0, 0, 0 };
                fcntl(_fd, F_SETLKW, &lock1);

                delete _stream; _stream = NULL;
                delete _buf; _buf = NULL;
		::close(_fd);
#else
                _stream.close();
#endif
        }

        std::ostream& locked_ofstream::operator*()
        {
                if (!is_open()) throw ibrcommon::IOException("no file open");
#ifdef USE_FILE_LOCKING
                return *_stream;
#else
                return _stream;
#endif
        }

        locked_fstream::locked_fstream()
#ifdef USE_FILE_LOCKING
         : _buf(NULL), _stream(NULL), _fd(0)
#endif
        {
        }

        locked_fstream::locked_fstream(File &file, ios_base::openmode mode)
#ifdef USE_FILE_LOCKING
         : _buf(NULL), _stream(NULL), _fd(0)
#endif
        {
                open(file, mode);
        }

        locked_fstream::~locked_fstream()
        {
                close();
        }

        void locked_fstream::open(File &file, ios_base::openmode mode)
        {
#ifdef USE_FILE_LOCKING
                _fd = ::open(file.getPath().c_str(), locked_fstream::getopts(mode));

                flock lock = { F_WRLCK, SEEK_SET, 0, 0, 0 };
                fcntl(_fd, F_SETLKW, &lock);

                _buf = new __gnu_cxx::stdio_filebuf<char>(_fd, mode);
                _stream = new std::iostream(_buf);

                if (mode & ios_base::ate)
                {
                        _stream->seekp(0, ios::end);
                }
#else
                _stream.open(file.getPath().c_str(), mode);
#endif
        }

        bool locked_fstream::is_open()
        {
#ifdef USE_FILE_LOCKING
                return (_stream != NULL);
#else
                return _stream.is_open();
#endif
        }

        void locked_fstream::close()
        {
                if (!is_open()) return;

#ifdef USE_FILE_LOCKING
                flock lock1 = { F_UNLCK, SEEK_SET, 0, 0, 0 };
                fcntl(_fd, F_SETLKW, &lock1);

                delete _stream; _stream = NULL;
                delete _buf; _buf = NULL;
		::close(_fd);
#else
                _stream.close();
#endif
        }

        std::iostream& locked_fstream::operator*()
        {
                if (!is_open()) throw ibrcommon::IOException("no file open");
#ifdef USE_FILE_LOCKING
                return *_stream;
#else
                return _stream;
#endif
        }

#ifdef USE_FILE_LOCKING
        unsigned int locked_fstream::getopts(ios_base::openmode mode)
        {
                unsigned int ret = 0;
                if (mode & ios_base::app) ret += O_APPEND;
                if (mode & ios_base::trunc) ret += O_TRUNC;

                if (mode & (ios_base::in | ios_base::out)) ret += O_RDWR;
                else
                {
                        if (mode & ios_base::in) ret += O_RDONLY;
                        else if (mode & ios_base::out) ret += O_WRONLY;
                }

                // No translation for this!
                //if (mode & ios_base::binary) ret += 0;

                return ret;
        }
#endif

}