ibrcommon/ibrcommon/data/BLOB.cpp

Go to the documentation of this file.

/*
 * BLOB.cpp
 *
 *  Created on: 15.12.2009
 *      Author: morgenro
 */

#include "ibrcommon/data/BLOB.h"
#include "ibrcommon/thread/MutexLock.h"
#include "ibrcommon/Exceptions.h"
#include "ibrcommon/Logger.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cassert>

namespace ibrcommon
{
        ibrcommon::Semaphore BLOB::_filelimit(128);

        File BLOB::tmppath;

        BLOB::BLOB()
         : _locked(false), _refcount(0)
        { }

        BLOB::~BLOB()
        {
        }

        BLOB::Reference::Reference(const Reference &ref)
         : ibrcommon::Mutex(MUTEX_ERRORCHECK), _blob(ref._blob)
        {
                _blob->increment();
        }

        BLOB::Reference::~Reference()
        {
                _blob->decrement();
                if (_blob->isUnbound())
                {
                        delete _blob;
                }
        }

        std::iostream& BLOB::Reference::operator* ()
        {
                assert(_blob->_locked);
                return _blob->__get_stream();
        }

        BLOB::Reference::Reference(BLOB *blob)
         : _blob(blob)
        {
                _blob->increment();
        }

        void BLOB::Reference::enter() throw (ibrcommon::MutexException)
        {
                // lock the stream
                _blob->enter();
                _blob->_locked = true;

                // open the stream
                _blob->open();
        }

        void BLOB::Reference::leave() throw (ibrcommon::MutexException)
        {
                _blob->_locked = false;

                // close the stream
                _blob->close();

                // unlock the stream
                _blob->leave();
        }

        void BLOB::Reference::trylock() throw (ibrcommon::MutexException)
        {
                // lock the stream
                _blob->trylock();
                _blob->_locked = true;

                // open the stream
                _blob->open();
        }

        size_t BLOB::Reference::getSize() const
        {
                return _blob->getSize();
        }

        void BLOB::Reference::clear()
        {
                assert(_blob->_locked);
                _blob->clear();
        }

        void BLOB::increment()
        {
                MutexLock l(_reflock);
                _refcount++;
        }

        void BLOB::decrement()
        {
                MutexLock l(_reflock);
                _refcount--;
        }

        bool BLOB::isUnbound()
        {
                MutexLock l(_reflock);
                if (_refcount == 0) return true;
                return false;
        }

        size_t BLOB::getSize()
        {
                assert(_locked);

                std::iostream &stream = this->__get_stream();

                // store current position
                size_t pos = stream.tellg();

                stream.seekg(0, std::ios_base::end);
                size_t size = stream.tellg();
                stream.seekg(pos);

                return size;
        }

        BLOB::Reference StringBLOB::create()
        {
                BLOB::Reference ref(new StringBLOB());
                return ref;
        }

        void StringBLOB::clear()
        {
                _stringstream.str("");
        }

        StringBLOB::StringBLOB()
         : BLOB(), _stringstream()
        {

        }

        StringBLOB::~StringBLOB()
        {
        }

        void StringBLOB::open()
        {
                // set pointer to the beginning of the stream and remove any error flags
                _stringstream.clear();
                _stringstream.seekp(0);
                _stringstream.seekg(0);
        }

        void StringBLOB::close()
        {
        }

        BLOB::Reference FileBLOB::create(const File &f)
        {
                BLOB::Reference ref(new FileBLOB(f));
                return ref;
        }

        void FileBLOB::clear()
        {
                throw ibrcommon::IOException("clear is not possible on a read only file");
        }

        FileBLOB::FileBLOB(const File &f)
         : BLOB(), _filestream(), _file(f)
        {
                if (!f.exists())
                {
                        throw ibrcommon::FileNotExistsException(f);
                }
        }

        FileBLOB::~FileBLOB()
        {
        }

        void FileBLOB::open()
        {
                BLOB::_filelimit.wait();

                // open the file
                _filestream.open(_file, ios::in|ios::binary);

                if (!_filestream.is_open())
                {
                        throw ibrcommon::CanNotOpenFileException(_file);
                }
        }

        void FileBLOB::close()
        {
                // close the file
                _filestream.close();

                BLOB::_filelimit.post();
        }

        BLOB::Reference TmpFileBLOB::create()
        {
                try {
                        BLOB::Reference ref(new TmpFileBLOB());
                        return ref;
                } catch (ibrcommon::IOException ex) {
                        return StringBLOB::create();
                }
        }

        void TmpFileBLOB::clear()
        {
                // close the file
                _filestream.close();

                // open temporary file
                _filestream.open(_tmpfile, ios::in | ios::out | ios::trunc | ios::binary );

                if (!_filestream.is_open())
                {
                        IBRCOMMON_LOGGER(error) << "can not open temporary file " << _tmpfile.getPath() << IBRCOMMON_LOGGER_ENDL;
                        throw ibrcommon::CanNotOpenFileException(_tmpfile);
                }
        }

        TmpFileBLOB::TmpFileBLOB()
         : BLOB(), _filestream()
        {
                // check if path is a directory
                if (!BLOB::tmppath.isDirectory())
                {
                        throw ibrcommon::IOException("BLOB::tmppath not initialized or path is not a directory.");
                }

                createtmpfile();
        }

        void TmpFileBLOB::createtmpfile()
        {
                _tmpfile = ibrcommon::TemporaryFile(BLOB::tmppath, "blob");
                _tmpfile.update();
        }

        TmpFileBLOB::~TmpFileBLOB()
        {
                // delete the file if the last reference is destroyed
                _tmpfile.remove();
        }

        void TmpFileBLOB::open()
        {
                BLOB::_filelimit.wait();

                // open temporary file
                _filestream.open(_tmpfile, ios::in | ios::out | ios::binary );

                if (!_filestream.is_open())
                {
                        IBRCOMMON_LOGGER(error) << "can not open temporary file " << _tmpfile.getPath() << IBRCOMMON_LOGGER_ENDL;
                        throw ibrcommon::CanNotOpenFileException(_tmpfile);
                }
        }

        void TmpFileBLOB::close()
        {
                // close the file
                _filestream.close();

                BLOB::_filelimit.post();
        }
}