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

namespace ibrcommon
{
        File BLOB::tmppath;

        BLOB::BLOB(std::iostream &stream)
         : _stream(stream), _refcount(0)
        { }

        BLOB::~BLOB()
        {
        }

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

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

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

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

        void BLOB::Reference::enter()
        {
                // lock the stream
                _blob->enter();

                // set pointer to the beginning of the stream and remove any error flags
                (**this).clear();
                (**this).seekp(0);
                (**this).seekg(0);
        }

        void BLOB::Reference::leave()
        {
                // clean up stream
                (**this).clear();

                // set pointer to the beginning of the stream and remove any error flags
                (**this).seekp(0);
                (**this).seekg(0);

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

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

        void BLOB::Reference::clear()
        {
                _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() const
        {
                // 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), _stringstream()
        {

        }

        StringBLOB::~StringBLOB()
        {
        }

        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), _filestream(), _file(f)
        {
                if (!f.exists())
                {
                        throw ibrcommon::FileNotExistsException(f);
                }

                // open the file
                _filestream.open(f.getPath().c_str(), ios::in|ios::binary);

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

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

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

        void TmpFileBLOB::clear()
        {
                enter();
                _filestream.close();
                _tmpfile.remove();
                _filestream.open(_tmpfile.getPath().c_str(), ios::in|ios::out|ios::binary|ios::trunc);
                leave();
        }

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

                // create temporary filename
                _tmpfile = getTmpFile();

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

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

        File TmpFileBLOB::getTmpFile()
        {
                char *name;

                if ( (name = tempnam( BLOB::tmppath.getPath().c_str(), NULL )) == NULL )
                        throw ibrcommon::IOException("Could not create a temporary name.");

                string filename(name);
                free(name);

                return File(filename);
        }

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

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

---