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

                        const BLOB* getPointer() const;

                private:
                        BLOB *_blob;
                };

                class Provider
                {
                public:
                        virtual ~Provider() = 0;

                        virtual BLOB::Reference create() = 0;
                };

                static ibrcommon::BLOB::Reference create();

                static ibrcommon::BLOB::Reference open(const ibrcommon::File &f);

                static void changeProvider(BLOB::Provider *p, bool auto_delete = false);

        protected:
                class ProviderRef
                {
                public:
                        ProviderRef(Provider *provider, bool auto_delete);
                        virtual ~ProviderRef();

                        void change(Provider *p, bool auto_delete = true);

                        BLOB::Reference create();

                private:
                        Provider *_provider;
                        bool _auto_delete;
                };

                static ProviderRef provider;

                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 FileBLOB : public ibrcommon::BLOB
        {
        public:
                FileBLOB(const ibrcommon::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:
                std::fstream _filestream;
                File _file;
        };

        class MemoryBLOBProvider : public ibrcommon::BLOB::Provider
        {
        public:
                MemoryBLOBProvider();
                virtual ~MemoryBLOBProvider();
                BLOB::Reference create();

        private:
                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 FileBLOBProvider : public ibrcommon::BLOB::Provider
        {
        public:
                FileBLOBProvider(const File &path);
                virtual ~FileBLOBProvider();
                BLOB::Reference create();

        private:
                ibrcommon::File _tmppath;

                class TmpFileBLOB : public BLOB
                {
                public:
                        TmpFileBLOB(const File &path);
                        virtual ~TmpFileBLOB();

                        virtual void clear();

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

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

                        size_t __get_size();

                private:
                        std::fstream _filestream;
                        int _fd;
                        File _tmpfile;
                };
        };
}

#endif /* BLOB_H_ */