ibrcommon/ibrcommon/data/BLOB.h

Go to the documentation of this file.

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

#ifndef BLOB_H_
#define BLOB_H_

#include "ibrcommon/thread/Mutex.h"
#include "ibrcommon/thread/MutexLock.h"
#include "ibrcommon/data/File.h"
#include "ibrcommon/thread/Semaphore.h"
#include <iostream>
#include <sstream>
#include <fstream>

namespace ibrcommon
{
        class CanNotOpenFileException : public ibrcommon::IOException
        {
        public:
                CanNotOpenFileException(ibrcommon::File f) throw() : IOException("Could not open file " + f.getPath() + ".")
                {
                };
        };

        class BLOB : public Mutex
        {
        private:
                bool _locked;

        public:
                static File tmppath;

                static ibrcommon::Semaphore _filelimit;

                static std::ostream& copy(std::ostream &output, std::istream &input, const size_t size, const size_t buffer_size = 0x1000);

                virtual ~BLOB();

                virtual void clear() = 0;

                virtual void open() = 0;
                virtual void close() = 0;

                class iostream
                {
                private:
                        BLOB *_blob;
                        ibrcommon::MutexLock lock;
                        std::iostream &_stream;

                public:
                        iostream(BLOB *blob)
                         : _blob(blob), lock(*blob), _stream(blob->__get_stream())
                        {
                                _blob->open();
                        }

                        virtual ~iostream()
                        {
                                _blob->close();
                        };

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

                        size_t size()
                        {
                                return _blob->__get_size();
                        };

                        void clear()
                        {
                                _blob->clear();
                        }
                };

                class Reference : public Mutex
                {
                public:
                        Reference(BLOB *blob);
                        Reference(const Reference &ref);
                        virtual ~Reference();

                        std::iostream& operator*() __attribute__ ((deprecated));
                        BLOB::iostream iostream();

                        virtual void enter() throw (ibrcommon::MutexException);

                        virtual void leave() throw (ibrcommon::MutexException);

                        virtual void trylock() throw (ibrcommon::MutexException);

                        void clear() __attribute__ ((deprecated));

                        size_t getSize() const __attribute__ ((deprecated));

                private:
                        BLOB *_blob;
                };

        protected:
                BLOB();
                size_t _refcount;
                Mutex _reflock;

                virtual size_t __get_size() = 0;
                virtual std::iostream &__get_stream() = 0;

        private:
                BLOB(const BLOB &ref); // forbidden copy constructor
        };

        class StringBLOB : public BLOB
        {
        public:
                static BLOB::Reference create();
                virtual ~StringBLOB();

                virtual void clear();

                virtual void open();
                virtual void close();

        protected:
                std::iostream &__get_stream()
                {
                        return _stringstream;
                }

                size_t __get_size();

        private:
                StringBLOB();
                std::stringstream _stringstream;
        };

        class FileBLOB : public BLOB
        {
        public:
                static BLOB::Reference create(const File &f);
                virtual ~FileBLOB();

                virtual void clear();

                virtual void open();
                virtual void close();

        protected:
                std::iostream &__get_stream()
                {
                        return _filestream;
                }

                size_t __get_size();

        private:
                FileBLOB(const File &f);
                std::fstream _filestream;
                File _file;
        };

        class TmpFileBLOB : public BLOB
        {
        public:
                static BLOB::Reference create();
                virtual ~TmpFileBLOB();

                virtual void clear();

                virtual void open();
                virtual void close();

        protected:
                std::iostream &__get_stream()
                {
                        return _filestream;
                }

                size_t __get_size();

        private:
                TmpFileBLOB();
                void createtmpfile();
                std::fstream _filestream;
                int _fd;
                File _tmpfile;
        };
}

#endif /* BLOB_H_ */