libnebular-plugin.hpp

Go to the documentation of this file.

#include "libnebular.hpp"

#ifndef NEBULAR_PLUGIN_HPP_
#define NEBULAR_PLUGIN_HPP_


namespace libnebular{
    void setDefault(
        PicturePropContainer &p,
        const String &key,
        const String &value
    );

    class ThrowableError: public Error{
    public:
        ThrowableError(const std::string& msg = "");
    };

#if __GNUC__





#define LIBNEBULAR_ERROR(x) libnebular::ThrowableError( \
    std::string() +                                                     \
    "In function \"" + __PRETTY_FUNCTION__ +                                \
    "\", file \"" + __FILE__ +                                              \
    "\" at line " + lexicalCastToStdString(__LINE__) +                      \
    ": \n" + x                                                              \
)
#else
#error Please redefine LIBNEBULAR_ERROR macro to use your analogue of GCC "__PRETTY_FUNCTION__"
#endif

    class Log{
    private:
        struct Impl_;

        friend class LogListener;

    public:
        static void warning(const std::string &message);
        static void info(const std::string &message);

        template <typename T> static const String getWrongValueMsg(
            const String &key,
            const T &value,
            const String &shouldBe,
            const String &where,
            const String &wrongnessType
        );

        Log();
        ~Log();
    };

    class NumberedStrings{
    private:
        Integer numStrings;
        const String *table;
    public:
        NumberedStrings(Integer newNumStrings, const String *newTable);
        ~NumberedStrings();

        Integer stringToIndex(const String &string) const;
        const String indexToString(Integer number) const;
    };

    // For "get"-ter returning @c PictureHandler
    class PictureHandler;

    class PicHandlerMgr{
    private:
        PicHandlerMgr(const PicHandlerMgr &);
        PicHandlerMgr &operator=(const PicHandlerMgr &);

    protected:
        static void determineFileExt(Picture &);
        static bool haveContentMagic(Picture &pictureFile, const Blob &magicData, Integer magicFileOffset);

        PicHandlerMgr();

    public:

        virtual ~PicHandlerMgr();





        bool virtual isHandleableByFileExt(Picture &pictureFile) const = 0;
        bool virtual isHandleableByContentMagic(Picture &pictureFile) const = 0;
        bool virtual isWriteable(Picture &picture) const = 0;

        boost::shared_ptr<PictureHandler> virtual createPictureHandler() const = 0;
    };

    class PictureHandler{
    protected:
        boost::shared_ptr<Picture> pic;

        PictureHandler(const PictureHandler &);
        PictureHandler &operator=(const PictureHandler&);
    public:

        void virtual setPicture(Picture &newPic) = 0;

        PictureHandler();
        virtual ~PictureHandler();

        void virtual readFileInfo() = 0;
        void virtual readBm() = 0;
        void virtual write() = 0;
    };

    class PluginIterator: public std::iterator<
        std::forward_iterator_tag,
        PicHandlerMgr
        >{
    private:
        typedef PluginIteratorImpl_ Impl_;
        friend class PluginIteratorImpl_;
        boost::shared_ptr<Impl_> pimpl_;

        friend PluginIterator pluginBegin();
        friend PluginIterator pluginEnd();
    public:

        PluginIterator();
        ~PluginIterator();
        PluginIterator(const PluginIterator &);
        PluginIterator &operator=(const PluginIterator &);

        PluginIterator& operator++();
        PluginIterator operator++(int);

        bool operator!=(const PluginIterator &) const;
        bool operator==(const PluginIterator &) const;

        value_type &operator*();
        value_type *operator->();
    };
    PluginIterator pluginBegin();
    PluginIterator pluginEnd();

#if HAVE_LOKI_FUNCTOR_H
#if HAVE_CSETJMP

    class RawCExceptionLongJmp{
    private:
        jmp_buf aJmpBuf;
        Loki::Functor< void > cleanupCode;
        boost::shared_ptr<std::exception> anException;
        bool isEnabled;
        Loki::Functor< void, LOKI_TYPELIST_1(boost::shared_ptr<const std::exception>) > currExactThrow;
        template <typename CurrException> static void exactThrow(boost::shared_ptr<const std::exception>);

    public:
        RawCExceptionLongJmp(
            Loki::Functor< void > newCleanupCode =
            Loki::Functor< void >()
        );
        ~RawCExceptionLongJmp();

        template <typename Return> Return run(Loki::Functor<Return> code);

        template <typename CurrException> void doThrow(const CurrException &newException);
    };

#endif // HAVE_CSETJMP
#endif // HAVE_LOKI_FUNCTOR_H

}


#include "libnebular-plugin.templates.hpp"

#endif // NEBULAR_PLUGIN_HPP_

---