libnebular.cpp

Go to the documentation of this file.

#include "config.h"
#include "libnebular.hpp"
#include "libnebular-plugin.hpp"
#include "utils.hpp"
#include "libnebular-extra.templates.hpp"

#include <csetjmp>

#include <fstream>

#include <loki/Singleton.h>

#define LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT
#include <loki/Functor.h>

namespace libnebular{
    using namespace std;

    namespace bits{
        template Integer getHighestBitIndex<Integer>(Integer a);
        template Integer getContigLength<Integer>(Integer a);
        template bool areContig(Integer a);
        template bool areSubsetOf(Integer a, Integer b);
        template Integer generateContig<Integer>(Integer length);
    }

    Error::Error(const std::string& msg):
        runtime_error(msg)
    {}

    ThrowableError::ThrowableError(const std::string &msg):
        Error(std::string("<libnebular> ERROR: \n") + msg)
    {}


    // @note Programmer: There's special @c Loki::Pimpl implementation, but user dependence on "libLoki" would be overkill.
    class Log::Impl_{
    private:
        friend class Log;
        friend class LogListener;

        typedef Loki::SingletonHolder<
        Impl_
        > LogImplHolder;

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

        CallbackStr warningCallback;
        CallbackStr infoCallback;

        static Impl_ &get(){
            return LogImplHolder::Instance();
        }

    public:
        Impl_():
            warningCallback(LogListener::emptyCallbackFunctionStr),
            infoCallback(LogListener::emptyCallbackFunctionStr)
        {}

        ~Impl_() {}
    };

    void Log::warning(const std::string &message){
        Impl_::get().warningCallback(message);
    }

    void Log::info(const std::string &message){
        Impl_::get().infoCallback(message);
    }

    void LogListener::setWarningCallback(LogListener::CallbackFunctionStr newWarningCallback){
        Log::Impl_::get().warningCallback = newWarningCallback;
    }

    void LogListener::setWarningCallback(LogListener::CallbackStr newWarningCallback){
        Log::Impl_::get().warningCallback= newWarningCallback;
    }

    void LogListener::setInfoCallback(LogListener::CallbackFunctionStr newInfoCallback){
        Log::Impl_::get().infoCallback = newInfoCallback;
    }

    void LogListener::setInfoCallback(LogListener::CallbackStr newInfoCallback){
        Log::Impl_::get().infoCallback= newInfoCallback;
    }

    void LogListener::emptyCallbackFunctionStr(const std::string &){
    }

    NumberedStrings::NumberedStrings(Integer newNumStrings, const String *newTable):
        numStrings(newNumStrings),
        table(newTable)
    {}

    NumberedStrings::~NumberedStrings()
    {}

    Integer NumberedStrings::stringToIndex(const String &string) const{
        Integer index;
        for(
            index = 0;
            index < numStrings;
            index++
        ){
            if(String(table[index]) == string){
                return index;
            }
        }
        throw LIBNEBULAR_ERROR("Cannot convert string to index");
    }

    const String NumberedStrings::indexToString(Integer index) const{
        if(index >= 0 && index <= numStrings){
            return String(table[index]);
        }else{
            throw LIBNEBULAR_ERROR("Cannot convert index to string");
        }
    }

    // @class Picture
    // {

    class PictureHandler;

    class Picture::Impl_{
    private:
        friend class Picture;

        Picture &picture;
        boost::shared_ptr<PictureHandler> aHandler;


        Impl_(Picture &newPicture):
            picture(newPicture),
            aHandler(boost::shared_ptr<PictureHandler>())
        {}

        void attachChosenHandler(boost::shared_ptr<PictureHandler> newHandler){
            aHandler = newHandler;
            aHandler->setPicture(picture);
        }

        void attachHandlerByPluginTest(
            bool (PicHandlerMgr::* test)(Picture&) const
        ){
            Core::get().makePluginsRegistered();
            
            bool isFound = false;
            PluginIterator plugin;
            for(
                plugin = pluginBegin();
                plugin != pluginEnd();
                ++plugin
            ){
                isFound = ( (*plugin) .* test )(picture);

                if(isFound){
                    break;
                }
            }
            if(isFound){
                attachChosenHandler(
                    plugin->createPictureHandler()
                );
            }else{
                // We couldn't find appropriate handler
                throw LIBNEBULAR_ERROR("Couldn\'t find appropriate file handler");
            }
        }

        void detachFile(){
            boost::shared_ptr<PicturePropContainer> subtree =
                createSubtreeProxy<PicturePropContainer>(
                    picture,
                    "file/"
                );
            PicturePropContainer::PropKeyIterator key = subtree->propKeyBegin();
            while(key != subtree->propKeyEnd()){
                PicturePropContainer::PropKeyIterator prevKey = key;
                ++key;
                picture.unSet(*prevKey);
            }
        }

        void detachBmSansData(){
            boost::shared_ptr<PicturePropContainer> subtree =
                createSubtreeProxy<PicturePropContainer>(
                    picture,
                    "bm/"
                );
            PicturePropContainer::PropKeyIterator key = subtree->propKeyBegin();
            while(key != subtree->propKeyEnd()){
                PicturePropContainer::PropKeyIterator prevKey = key;
                ++key;
                if(*prevKey != "bm/data"){
                    picture.unSet(*prevKey);
                }
            }
        }

    public:
        ~Impl_() {}

    };

    bool Picture::haveHandler() const{
        return (!isEmpty(pimpl_->aHandler));
    }

    // @name attachHandlerGroup
    // {

    void Picture::attachHandlerByFileExt(){
        pimpl_->attachHandlerByPluginTest(&PicHandlerMgr::isHandleableByFileExt);
        move("opt/file/url-extension", "file/url-extension");
    }
    void Picture::attachHandlerByContentMagic(){
        pimpl_->attachHandlerByPluginTest(&PicHandlerMgr::isHandleableByContentMagic);
    }
    void Picture::attachHandlerForWrite(){
        pimpl_->attachHandlerByPluginTest(&PicHandlerMgr::isWriteable);
        move("opt/file/mimetype", "file/mimetype");
    }
    void Picture::attachHandlerSomehow(){
        attachHandlerByContentMagic();
    }
    void Picture::makeHandlerSomehowAttached(){
        if(!haveHandler()){
            attachHandlerSomehow();
        }
    }

    // @}

    void Picture::readFileInfo(){
        pimpl_->detachFile();
        pimpl_->detachBmSansData();
        setDefaults();

        makeHandlerSomehowAttached();

        pimpl_->aHandler->readFileInfo();

        move("opt/file/url", "file/url");

        check<PropBmInfo>();
        checkUnusedOpts();
        set("file/loaded-info", true);
    }

    void Picture::readBm(){
        if(
            !isSet("file/loaded-info") ||
            !get<bool>("file/loaded-info")
        ){
            readFileInfo();
        }

        pimpl_->aHandler->readBm();

        check<PropBmData>();
        checkUnusedOpts();
        set("file/loaded-bm-data", true);
    }

    void Picture::write(){
        attachHandlerForWrite();

        pimpl_->detachFile();

        check<PropBmInfo>();
        check<PropBmData>();

        pimpl_->aHandler->write();

        move("opt/file/url", "file/url");
        checkUnusedOpts();
    }

    Picture::~Picture() {}
    Picture::Picture():
        pimpl_( new Impl_(*this) )
    {}

    Picture::Picture(const String& newUrl):
        pimpl_( new Impl_(*this) )
    {
        const String urlPropName = "opt/file/url";
        set(urlPropName, newUrl);
    }

    // }

    // @class PictureHandler
    // {
    PictureHandler::PictureHandler() {}

    void PictureHandler::setPicture(Picture &newPic){
        pic = boost::shared_ptr<Picture>(
            &newPic,
            null_deleter()
        );
    }

    PictureHandler::~PictureHandler(){
    }

    // @class PicHandlerMgr
    // {
    void PicHandlerMgr::determineFileExt(Picture &pic){
        const String url = pic.get<String>("opt/file/url");
        size_t dotPos = url.rfind(".");
        if(dotPos != String::npos){
            pic.set("opt/file/url-extension",
                url.substr(dotPos+1)
            );
        }else{
            pic.set<String>("opt/file/url-extension",
            ""
            );
        }
    }

    bool PicHandlerMgr::haveContentMagic(Picture &pictureFile, const Blob &magicData, Integer magicFileOffset){
        ifstream inStream(
            (pictureFile.get<String>("opt/file/url")).c_str(),
            ios::binary
        );
        if(inStream.fail()){
            throw LIBNEBULAR_ERROR("Failed to open file \"" + pictureFile.get<String>("opt/file/url") + "\"");
        }
        inStream.exceptions(ios::failbit | ios::badbit | ios::eofbit);
        inStream.seekg(magicFileOffset, ios::beg);
        return magicData.isSubseqFromCurPos(inStream);
    }

    PicHandlerMgr::PicHandlerMgr() {}
    PicHandlerMgr::~PicHandlerMgr() {}

    // }


    RawCExceptionLongJmp::RawCExceptionLongJmp(
        Loki::Functor< void > newCleanupCode// = Loki::Functor< void >()
    ):
        cleanupCode(newCleanupCode),
        isEnabled(false)
    {}

    RawCExceptionLongJmp::~RawCExceptionLongJmp() {}

}

---