ilwisdata.h

#ifndef ILWISDATA_H
#define ILWISDATA_H

#include <QUrl>
#include <QStringList>
#include <typeinfo>
#include <mutex>
//#include "ilwis.h"
#include "errorobject.h"
#include "prepareoptions.h"
#include "ilwisobject.h"
#include "resource.h"
#include "mastercatalog.h"


namespace Ilwis {
typedef std::shared_ptr<IlwisObject> ESPIlwisObject;

template<class T> class IlwisData {
public:
    template<class C> friend class IlwisData;

    IlwisData() {}
    IlwisData(const QString& name, IlwisTypes tp=itANY, const PrepareOptions& options=PrepareOptions()){
        prepare(name, tp, options);
    }
    IlwisData(const Resource& resource1,const PrepareOptions& options=PrepareOptions()){
        prepare(resource1, options);
    }


    IlwisData(T *data) {
        set(data);
    }

    IlwisData(const ESPIlwisObject& impl) {
        _implementation = impl;
    }

    template<typename K> IlwisData(const IlwisData<K>& obj) {
       _implementation = std::dynamic_pointer_cast<T>(obj._implementation);
    }

    IlwisData(const IlwisData& obj) {
       _implementation = obj._implementation;
    }



    ~IlwisData() {
        if (_implementation.get()!= 0  ) // there is always one extra reference in the registerd objects, so 2 means last object will disappear
            if ( _implementation.use_count() == 2)
                mastercatalog()->unregister(_implementation.get()->id());
    }

    void set(T *data) {
        removeCurrent();
        if ( data != nullptr) {
            if (!mastercatalog()->isRegistered(data->id())) {
                _implementation.reset(data);
                mastercatalog()->registerObject(_implementation);
            }
            else {
                _implementation = mastercatalog()->get(data->id());
            }
        }else {
            _implementation.reset();
        }
    }

    template<typename K> IlwisData<T>& assign(const IlwisData<K>& obj) {
        if ( _implementation && obj->ilwisType() == _implementation->ilwisType())
            set(static_cast<T *>(obj._implementation.get())) ;
        else
            set(dynamic_cast<T *>(obj._implementation.get())) ;
        return *this;
    }

    template<typename K> IlwisData<T>& operator=(const IlwisData<K>& obj) {
         return assign(obj);
    }

    IlwisData& operator=(const IlwisData& obj) {
         return assign(obj);
    }

    T *operator->() {
        T* p =  static_cast<T *>(_implementation.get());
        if (!p)
            throw ErrorObject(TR("Using unitialized object"));
        return p;
    }

    T *operator->() const{
        T* p =  static_cast<T *>(_implementation.get());
        if (!p)
            throw ErrorObject(TR("Using unitialized object"));
        return p;
    }

    T *ptr() const {
        return operator->();
    }

    template<class C=IlwisObject> IlwisData<C> get() const {
        if (_implementation.get() == 0)
            throw ErrorObject(TR("Using unitialized object"));
        if ( hasType(_implementation->ilwisType(),itILWISOBJECT)) {
            IlwisData<C> obj;
            obj._implementation = std::static_pointer_cast<C>(_implementation);
            return  obj;
        }
        return IlwisData<C>();
    }
    bool prepare() {
        removeCurrent();
        auto type = kernel()->demangle(typeid(T).name());

        IlwisTypes tp = IlwisObject::name2Type(type);
        Resource res;
        res.prepare();
        res.setIlwisType(tp);
        tp = IlwisObject::name2ExtendedType(type);
        if ( tp != itUNKNOWN)
            res.setExtendedType(tp);
        QString name = QString("%1%2").arg(ANONYMOUS_PREFIX).arg(res.id());
        QUrl url(QString("ilwis://internalcatalog/%1").arg(name));
        res.setName(name);
        res.setUrl(url);
        return prepare(res);

    }

    bool prepare(const QString& name, IlwisTypes tp=itANY,const PrepareOptions& options=PrepareOptions()){
        if ( name.left(11) == ANONYMOUS_PREFIX) { // internal objects are not in the catalog
            QString sid = name.mid(11);
            bool ok;
            quint64 id = sid.toLongLong(&ok);
            if (ok){
                ESPIlwisObject data = mastercatalog()->get(id);
                if ( data.get() != 0) {
                    removeCurrent();
                    _implementation = data;
                    return true;
                }

            }
            return ERROR1(ERR_COULDNT_CREATE_OBJECT_FOR_1,name);

        }
        if ( name.indexOf(NAME_ALIAS) == 0) {
            QString sid = name.mid(SZ_NAME_ALIAS);
            bool ok;
            quint64 id = sid.toLongLong(&ok);
            if (ok){
                ESPIlwisObject data = mastercatalog()->get(id);
                if ( data.get() != 0) {
                    removeCurrent();
                    _implementation = data;
                    return true;
                }

            }
            return ERROR1(ERR_COULDNT_CREATE_OBJECT_FOR_1,name);

        }
        if ( tp == itANY) {
            auto type = kernel()->demangle(typeid(T).name());
            tp = IlwisObject::name2Type(type);
        }
        auto resource = mastercatalog()->name2Resource(name,tp );
        if (resource.isValid()) {
            if (!mastercatalog()->isRegistered(resource.id())) {
                T *data = static_cast<T *>(IlwisObject::create(resource, options));
                if ( data == 0) {
                    _implementation.reset((T*)0);
                    removeCurrent();
                    return ERROR1("Couldnt create ilwisobject %1",name);
                }
                bool ok = data->prepare();
                if ( !ok){
                    delete data;
                    return false;
                }

                data->changed(false);
                removeCurrent();
                _implementation = ESPIlwisObject(data);
                mastercatalog()->registerObject(_implementation);
            } else {
                _implementation = mastercatalog()->get(resource.id());
            }
            return true;
        } else {
            if(tp != itUNKNOWN && prepare(Resource(name, tp)))
                return true;
        }
        return ERROR1(ERR_COULDNT_CREATE_OBJECT_FOR_1,name);

    }

    bool prepare(const Resource& resource1,const PrepareOptions& options=PrepareOptions()){
        if (resource1.isValid()) {
            quint64 id = iUNDEF;
            if ( mastercatalog()->usesContainers(resource1.url())) // containers dont make sense for services
                mastercatalog()->addContainer(resource1.container());
            id = mastercatalog()->url2id(resource1.url(), resource1.ilwisType());
            Resource resource = mastercatalog()->id2Resource(id);
            if (!resource.isValid())
                resource = resource1;
            if (!mastercatalog()->isRegistered(resource.id())) {
                T *data = static_cast<T *>(IlwisObject::create(resource, options));
                if ( data == 0) {
                    _implementation.reset((T*)0);
                    removeCurrent();
                    return ERROR1("Couldnt create ilwisobject %1",resource.name());
                }
                bool ok = data->prepare();
                if ( !ok){
                    delete data;
                    return false;
                }
                data->changed(false);
                removeCurrent();
                _implementation = ESPIlwisObject(data);
                mastercatalog()->registerObject(_implementation);
            } else {
                _implementation = mastercatalog()->get(resource.id());
            }
            return true;
        } else {
            ERROR1(ERR_COULDNT_CREATE_OBJECT_FOR_1,resource1.name());
        }
        return false;

    }

    bool prepare(const quint64& iid,const PrepareOptions& options=PrepareOptions()){
        Resource resource = mastercatalog()->id2Resource(iid);
        if (!mastercatalog()->isRegistered(iid)) {
            T *data = static_cast<T *>(IlwisObject::create(resource, options));
            if ( data != 0)
                data->prepare();
            else {
                _implementation.reset((T*)0);
                removeCurrent();
                return ERROR1("Couldnt create ilwisobject %1",resource.name());
            }
            removeCurrent();
            _implementation = ESPIlwisObject(data);
        } else
            _implementation = mastercatalog()->get(iid);
        if ( _implementation.get() == 0) {
            return ERROR0("Corrupted object registration");
        }
        mastercatalog()->registerObject(_implementation);
        return true;

    }


    bool isValid() const {
        return _implementation.get() != 0;
    }


private:
    void removeCurrent() {
        if ( _implementation && _implementation->id() != i64UNDEF) {
            ESPIlwisObject obj= mastercatalog()->get( _implementation->id() );
            if(obj.use_count() <= 3) { // current _impl + one in the lookup + the one just created
                 mastercatalog()->unregister(_implementation->id());
            }
        }
    }

    ESPIlwisObject _implementation;
};

template<class T> bool operator==(const IlwisData<T>& d1, const IlwisData<T>& d2) {
    return d1->id() == d2->id();
}

template<class T> bool operator!=(const IlwisData<T>& d1, const IlwisData<T>& d2) {
    return d1->id() != d2->id();
}

typedef Ilwis::IlwisData<Ilwis::IlwisObject> IIlwisObject;

}

Q_DECLARE_METATYPE(Ilwis::IIlwisObject)

template<class C> QDataStream & operator << ( QDataStream & s, const Ilwis::IlwisData<C> & obj ){
    if ( obj.isValid() == false)
        return s;

    obj->store(s, obj->serializationOptions());

    return s;
}

template<class C> QDataStream & operator >> ( QDataStream & s, Ilwis::IlwisData<C> & obj ){
    if ( obj.isValid() == false)
        obj.prepare();
    obj->load(s);

    return s;
}


#endif // ILWISDATA_H