connectorfactory.h

#ifndef CONNECTORFACTORY_H
#define CONNECTORFACTORY_H

#include "Kernel_global.h"
#include <QScopedPointer>
#include <QHash>

namespace Ilwis {

class ConnectorInterface;
class CatalogExplorer;

typedef std::function<Ilwis::CatalogExplorer*(const Ilwis::Resource &resource,const PrepareOptions& options)> createCatalogExplorer;

//typedef ConnectorInterface* (*ConnectorCreate)(const IlwisResource &resource);
//-----------------------------------------------------------------------------------------
struct ConnectorFilter{
    ConnectorFilter(quint64 types, const QString& provider) : _objectTypes(types), _provider(provider) {}
    quint64 _objectTypes;
    QString _provider;
};

struct ConnectorFormatSelector{
    ConnectorFormatSelector(const QString& format, const QString& provider=sUNDEF) : _format(format), _provider(provider) {}

    QString _format;
    QString _provider;

};

KERNELSHARED_EXPORT uint qHash(const ConnectorFilter& resource );
KERNELSHARED_EXPORT bool operator==(const ConnectorFilter& filter1, const ConnectorFilter& filter2 );
KERNELSHARED_EXPORT bool operator<(const ConnectorFilter& filter1, const ConnectorFilter& filter2 );

KERNELSHARED_EXPORT uint qHash(const ConnectorFormatSelector& resource );
KERNELSHARED_EXPORT bool operator==(const ConnectorFormatSelector& filter1, const ConnectorFormatSelector& filter2 );
KERNELSHARED_EXPORT bool operator<(const ConnectorFormatSelector& filter1, const ConnectorFormatSelector& filter2 );


class KERNELSHARED_EXPORT ConnectorFactory : public AbstractFactory
{
    friend class ConnectorInterface;

public:
    ConnectorFactory();

    void addCreator(quint64 objecttypes, const QString &provider, ConnectorCreate);
    void addCreator(const QString& format, const QString &provider, ConnectorCreate);

    template<class T=ConnectorInterface> T *createFromResource(const Resource& resource, const QString &provider,const PrepareOptions& options=PrepareOptions()) const{
        ConnectorFilter filter(resource.ilwisType(), provider);
        auto iter = _creatorsPerObject.find(filter);
        if ( iter == _creatorsPerObject.end())
            return 0;
        ConnectorCreate createConnector = iter.value();
        if ( createConnector ) {
            ConnectorInterface *cif =  createConnector(resource, true, options);
            if ( cif && cif->canUse(resource))
                return dynamic_cast<T *>(cif);
            delete cif;
        }
        kernel()->issues()->log(TR(ERR_COULDNT_CREATE_OBJECT_FOR_2).arg("Connector",resource.name()));
        return 0;

    }

    template<class T=ConnectorInterface> QList<T*> connectorsForResource(const Resource& resource, const QString &provider="*",const PrepareOptions& options=PrepareOptions()) const{
        ConnectorFilter filter(resource.ilwisType(), provider);
        QList<T*> results;
        for(auto key : _creatorsPerObject.keys()){
            if ( filter == key) {
                ConnectorCreate createConnector = _creatorsPerObject[key];
                if ( createConnector ) {
                    ConnectorInterface *cif =  createConnector(resource, true, options);
                    if ( cif && cif->canUse(resource)){
                        T* conn =  dynamic_cast<T *>(cif);
                        if ( conn)
                            results.push_back(conn);
                    }else
                        delete cif;
                }
            }
        }
        return results;

    }

    template<class T=ConnectorInterface> T *createFromFormat(const Resource& resource, const QString &format, const QString& provider=sUNDEF,const PrepareOptions& options=PrepareOptions()) const{
        ConnectorFormatSelector filter(format, provider);
        auto iter = _creatorsPerFormat.find(filter);
        if ( iter == _creatorsPerFormat.end())
            return 0;
        ConnectorCreate createConnector = iter.value();
        if ( createConnector ) {
            ConnectorInterface *cif =  createConnector(resource, false, options);
            if ( cif){
                cif->format(format);
                return dynamic_cast<T *>(cif);
            }
        }


        kernel()->issues()->log(TR(ERR_COULDNT_CREATE_OBJECT_FOR_2).arg("Connector",resource.name()));
        return 0;
    }

    template<class T=ConnectorInterface> T *createContainerConnector(const Resource& resource, const QString &provider=sUNDEF,const PrepareOptions& options=PrepareOptions()) const{
        for(auto iter=_creatorsPerObject.begin(); iter != _creatorsPerObject.end(); ++iter){
            if ( !hasType(iter.key()._objectTypes, resource.ilwisType()))
                continue;
            ConnectorCreate createConnector = iter.value();
            if ( createConnector && ( iter.key()._provider == provider || provider == sUNDEF)) {
                ConnectorInterface *cif =  createConnector(resource, true, options);
                if ( cif && cif->canUse(resource))
                    return dynamic_cast<T *>(cif);
                delete cif;
            }
        }
        kernel()->issues()->log(TR(ERR_COULDNT_CREATE_OBJECT_FOR_2).arg("Connector",resource.name()));
        return 0;

    }

     std::vector<CatalogExplorer*> explorersForResource(const Resource& resource, const QString &provider=sUNDEF,const PrepareOptions& options=PrepareOptions()) const;

    static std::nullptr_t registerCatalogExplorer(createCatalogExplorer func);

protected:
    QHash<ConnectorFilter, ConnectorCreate > _creatorsPerObject;
    QHash<ConnectorFormatSelector, ConnectorCreate > _creatorsPerFormat;
    static std::vector<createCatalogExplorer> _explorers;
};
}


#endif // CONNECTORFACTORY_H