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>
#include <unistd.h>

#include <cstring>
#include <cerrno>

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 (const 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;
        }

        std::string File::getBasename() const
        {
                return std::string(basename(_path.c_str()));
        }

        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;
        }

        time_t File::lastaccess() const
        {
                struct stat filestatus;
                stat( getPath().c_str(), &filestatus );
                return filestatus.st_atime;
        }

        time_t File::lastmodify() const
        {
                struct stat filestatus;
                stat( getPath().c_str(), &filestatus );
                return filestatus.st_mtime;
        }

        time_t File::laststatchange() const
        {
                struct stat filestatus;
                stat( getPath().c_str(), &filestatus );
                return filestatus.st_ctime;
        }

        bool File::operator==(const ibrcommon::File &other) const
        {
                return (other._path == _path);
        }

        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 + "XXXXXX";
                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_fstreambuf::locked_fstreambuf()
         : in_buf_(new char[BUFF_SIZE]), out_buf_(new char[BUFF_SIZE]), _fd(NULL)
        {
                // Initialize get pointer.  This should be zero so that underflow is called upon first read.
                setg(0, 0, 0);
                setp(out_buf_, out_buf_);
        }

        locked_fstreambuf::locked_fstreambuf(File &file, char mode[]) //ios_base::openmode mode)
         : in_buf_(new char[BUFF_SIZE]), out_buf_(new char[BUFF_SIZE]), _fd(NULL)
        {
                open(file, mode);
        }

        locked_fstreambuf::~locked_fstreambuf()
        {
                // flush
                close();

                delete[] in_buf_;
                delete[] out_buf_;
        }

        void locked_fstreambuf::open(File &file, char mode[]) // ios_base::openmode mode)
        {
                _fd = fopen( file.getPath().c_str() , mode );
                if (_fd == NULL)
                {
                        //clear(ios_base::failbit);
                        std::cerr << "FILE ERROR: " << std::strerror(errno) << std::endl;
                        return;
                }

                flockfile(_fd);

                // Initialize get pointer.  This should be zero so that underflow is called upon first read.
                setg(0, 0, 0);
                setp(out_buf_, out_buf_);
        }

        bool locked_fstreambuf::is_open()
        {
                return (_fd != NULL);
        }

        void locked_fstreambuf::close()
        {
                if (is_open())
                {
                        funlockfile(_fd);
                        fclose (_fd);
                }
        }

        int locked_fstreambuf::sync()
        {
                int ret = std::char_traits<char>::eq_int_type(this->overflow(
                                std::char_traits<char>::eof()), std::char_traits<char>::eof()) ? -1
                                : 0;

                return ret;
        }

        int locked_fstreambuf::overflow(int c)
        {
                char *ibegin = out_buf_;
                char *iend = pptr();

                // mark the buffer as free
                setp(out_buf_, out_buf_ + BUFF_SIZE - 1);

                if (!std::char_traits<char>::eq_int_type(c, std::char_traits<char>::eof()))
                {
                        *iend++ = std::char_traits<char>::to_char_type(c);
                }

                // if there is nothing to store, just return
                if ((iend - ibegin) == 0)
                {
                        return std::char_traits<char>::not_eof(c);
                }

                size_t bytes = fwrite(out_buf_, 1, (iend - ibegin), _fd);

                if (bytes != BUFF_SIZE)
                {
                        // ERROR
                        std::cerr << "FILE WRITE ERROR: " << std::strerror(errno) << std::endl;
                        throw std::string("fail");
                }

                return std::char_traits<char>::not_eof(c);
        }

        int locked_fstreambuf::underflow()
        {
                size_t bytes = fread(in_buf_, 1, BUFF_SIZE, _fd);

                // end of stream
                if (bytes == 0)
                {
                        return std::char_traits<char>::eof();
                }

                // Since the input buffer content is now valid (or is new)
                // the get pointer should be initialized (or reset).
                setg(in_buf_, in_buf_, in_buf_ + bytes);

                return std::char_traits<char>::not_eof(in_buf_[0]);
        }

        locked_ifstream::locked_ifstream()
         : std::istream(&_buffer)
        { }

        locked_ifstream::locked_ifstream(File &file, ios_base::openmode mode)
         : std::istream(&_buffer), _buffer(file, "r")
        { }

        locked_ifstream::~locked_ifstream()
        { }

        void locked_ifstream::open(File &file, ios_base::openmode mode)
        {
                _buffer.open(file, "r");
        }

        bool locked_ifstream::is_open()
        {
                return _buffer.is_open();
        }

        void locked_ifstream::close()
        {
                _buffer.close();
        }

        locked_ofstream::locked_ofstream()
         : std::ostream(&_buffer)
        { }

        locked_ofstream::locked_ofstream(File &file, ios_base::openmode mode)
         : std::ostream(&_buffer), _buffer(file, "w")
        { }

        locked_ofstream::~locked_ofstream()
        { }

        void locked_ofstream::open(File &file, ios_base::openmode mode)
        {
                _buffer.open(file, "w");
        }

        bool locked_ofstream::is_open()
        {
                return _buffer.is_open();
        }

        void locked_ofstream::close()
        {
                _buffer.close();
        }
}