libnebular.hpp

Go to the documentation of this file.


#include "utils.hpp"

#include <stdexcept>
#include <istream>

// Because @c libnebular::String is <tt>typedef</tt>-ed to @c std::string
#include <string>

#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>

#ifndef NEBULAR_HPP_
#define NEBULAR_HPP_


namespace libnebular{
    typedef long long int Integer;

    typedef long double Real;

    typedef std::string String;

    namespace bits{
        const Integer HAVE_NOT = -1;
        const Integer ARE_NOT_CONTIG = HAVE_NOT;

        template <typename BitContainer>
        Integer getContigLength(BitContainer a);

        template <typename BitContainer>
        bool areContig(BitContainer a);

        template <typename BitContainer>
        bool areSubsetOf(BitContainer a, BitContainer b);

        template <typename BitContainer>
        BitContainer generateContig(Integer length);

        template <typename BitContainer>
        Integer getHighestBitIndex(BitContainer a);
    }

    class Blob{
    private:
        struct Impl_;
        boost::shared_ptr<Impl_> pimpl_;

        // Cut: Blob(const Blob &a);
        // Cut: Blob &operator=(const Blob &);

    public:
        char *getDataReadWrite();
        const char *getDataReadOnly() const;
        size_t getDataHash() const;
        Integer getDataRoom() const;
        void setDataSize(Integer newSize);
        Integer getDataSize() const;

        void mAlloc(Integer newSize);
        void attach(void *newMemory, Integer newDataRoom);
        void prepareForSize(Integer newDataSize);
        bool isCanBeReroomed() const;

        void assign(Integer newSize, const char* newData);
        bool isSubseqFromCurPos(std::istream &inStream) const;

        void cleanupData();

        void forsakeData();

        Blob(Integer newSize, const char* newData);
        Blob();
        ~Blob();

        static Blob createAndMAlloc(Integer newSize);
        static Blob createAndAttach(void *newMemory, Integer newDataRoom);
    };

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

    class PluginIterator;
    class PluginIteratorImpl_;

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

        struct Impl_;
        boost::shared_ptr<Impl_> pimpl_;

        friend PluginIterator pluginBegin();
        friend PluginIterator pluginEnd();

        // @note Language: Cannot use <tt>typedef</tt>-name in friend declaration.
        //
        // @note Language: Cannot forward-declare nested class in C++ (seems to be language flaw).
        //
        friend class PluginIteratorImpl_;
    public:
        Core();
        ~Core();

        void setPluginDir(const std::string &newPluginDir);
        void registerPlugins();
        bool isPluginRegDone() const;
        void makePluginsRegistered();

        static Core &get();
    };

    class LogListener{
    public:
        typedef void (*CallbackFunctionStr)(const std::string&);

        static void setWarningCallback(CallbackFunctionStr newWarningCallback);
        static void setInfoCallback(CallbackFunctionStr newInfoCallback);

#if HAVE_LOKI_FUNCTOR_H
        typedef Loki::Functor<void, LOKI_TYPELIST_1(const std::string&)> CallbackStr;

        static void setWarningCallback(CallbackStr newWarningCallback);
        static void setInfoCallback(CallbackStr newWarningCallback);
#endif

        static void emptyCallbackFunctionStr(const std::string &message);
    };

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

        class Impl_;
        class DefaultImpl_;
        class SubtreeProxyImpl_;
        boost::shared_ptr<Impl_> pimpl_;

        template <class PicturePropContainerBased>
        friend boost::shared_ptr<PicturePropContainerBased>
        createSubtreeProxy(
            PicturePropContainer &realSubject,
            const String &subTreePrefix
        );

        friend void setDefault(
            PicturePropContainer &p,
            const String &key,
            const String &value
        );
    public:
        class PropKeyIterator: public std::iterator<
        std::forward_iterator_tag,
        const String
        >{
        private:
            struct Impl_;
            boost::shared_ptr<Impl_> pimpl_;

            friend class PicturePropContainer::DefaultImpl_;
        public:

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

            PropKeyIterator &operator++();
            PropKeyIterator operator++(int);
            bool operator!=(const PropKeyIterator &) const;
            bool operator==(const PropKeyIterator &) const;

            value_type &operator*();
            value_type *operator->();
        };
        PropKeyIterator propKeyBegin();
        PropKeyIterator propKeyEnd();

        template <typename Src> static String castToPropString(const Src &value);
        //
        // (There's no ability to explicitly instantiate @c castToPropString() for @c char[].)
        static String castToPropString(
            const char *value
        );

        template <typename Dest> static Dest castFromPropString(const String &value);

        template <typename R> void set(const String &key, const R &value);
        template <typename R> const R get(const String &key) const;
        template <typename R> void get(const String &key, R &value) const;

        void unSet(const String &key);

        bool isSet(const String &key) const;
        bool isDefault(const String &key) const;



        void move(const String &srcKey, const String &destKey);

        void acceptOpt(const String &acceptedKey);
        bool isSetAndTrue(const String& key) const;
        template <typename Value>
        void swap(const String &keyA, const String &keyB);

        template <typename Value>
        void copyFromIfSet(const String &key, const PicturePropContainer &src);
        void setDefaultIfNotSet(const String &key, const String &defaultValue);


        PicturePropContainer();
        virtual ~PicturePropContainer();

    };

    template<> String PicturePropContainer::castToPropString(const bool& arg);
    template<> bool PicturePropContainer::castFromPropString(const String& arg);

    template<> const String PicturePropContainer::get<>(const String &key) const;
    template<> void PicturePropContainer::set<>(const String &key, const String &value);
    template<> const Blob PicturePropContainer::get<>(const String &key) const;
    template<> void PicturePropContainer::set<>(const String &key, const Blob &value);

    class PictureProps: public PicturePropContainer{
    private:
        PictureProps(const PictureProps &);
        PictureProps &operator=(const PictureProps &);

        struct Impl_;
        boost::shared_ptr<Impl_> pimpl_;

    public:
        PictureProps();
        ~PictureProps();

        class PropBmInfo;
        class PropBmData;
        class PropBmPixelFormat;
        class PropBmPixelsPerLength;
        class PropBmMiscStorageParams;
        class PropBmMiscDisplayParams;
        class PropCalcBmDataSize;
        class PropCalcBmSizeLengthUnits;
        class PropCalcBmPixelMaskMisc;
        class PropCalcBmColorsUsed;

        template <typename T> void check();

        void setDefaults();
        void checkUnusedOpts();

        template <typename T> void calculate();


        void reproduce(PictureProps &src);

        void prepareReproduceBmInfo(PictureProps &src);

    };

#if !PROCESSED_BY_DOXYGEN

    template <> void PictureProps::check<PictureProps::PropBmInfo>();
    template <> void PictureProps::check<PictureProps::PropBmData>();
    template <> void PictureProps::check<PictureProps::PropBmPixelFormat>();
    template <> void PictureProps::check<PictureProps::PropBmPixelsPerLength>();
    template <> void PictureProps::check<PictureProps::PropBmMiscStorageParams>();
    template <> void PictureProps::check<PictureProps::PropBmMiscDisplayParams>();

    template <> void PictureProps::calculate<PictureProps::PropCalcBmSizeLengthUnits>();
    template <> void PictureProps::calculate<PictureProps::PropCalcBmPixelMaskMisc>();
    template <> void PictureProps::calculate<PictureProps::PropCalcBmDataSize>();

    template <> void PictureProps::calculate<PictureProps::PropCalcBmColorsUsed>();
#endif // PROCESSED_BY_DOXYGEN

    class Picture: public PictureProps{
    private:
        Picture(const Picture &);
        Picture &operator=(const Picture &);

        struct Impl_;
        boost::shared_ptr<Impl_> pimpl_;

    public:
        bool haveHandler() const;




        void attachHandlerByFileExt();
        void attachHandlerByContentMagic();
        void attachHandlerForWrite();
        void attachHandlerSomehow();
        void makeHandlerSomehowAttached();


        void readFileInfo();

        void readBm();

        void write();

        ~Picture();
        Picture();
        Picture(const String& newUrl);
    };

    template <class PicturePropContainerBased>
    boost::shared_ptr<PicturePropContainerBased>
    createSubtreeProxy(
        PicturePropContainer &realSubject,
        const String &subTreePrefix
    );
}

#include "libnebular.templates.hpp"

#endif //NEBULAR_HPP_

---