ilwisobject.h

#ifndef ILWISOBJECTIMPL_H
#define ILWISOBJECTIMPL_H

#include <QSharedData>
#include <QDateTime>
#include <QUrl>
#include <QDebug>
#include "Kernel_global.h"
#include "locker.h"
#include "identity.h"
#include "resource.h"
#include "numericrange.h"
#include "juliantime.h"
#include "prepareoptions.h"


class QSqlRecord;

namespace Ilwis {

class IlwisObjectFactory;
class ConnectorInterface;
class Resource;
class IlwisObject;
struct PrepareOptions;

typedef IlwisTypes (*IlwisTypeFunction)(const QString& resource);

class KERNELSHARED_EXPORT IlwisObject : public QObject, public Identity
{
    Q_OBJECT

    friend class IlwisObjectFactory; //  needs to set validity of object
    friend void addFactory(IlwisObjectFactory *);

public:
    enum ConnectorMode{cmINPUT=1, cmOUTPUT=2, cmEXTENDED=4};

    enum StoreMode{smMETADATA=1, smBINARYDATA=2};

    IlwisObject();

    IlwisObject(const Resource &source);

    virtual ~IlwisObject();

    virtual bool prepare();

    void setName(const QString& nm);

    void setCode(const QString &cd);

    QDateTime modifiedTime() const;


    void setModifiedTime(const Time& time);

    Time createTime() const;

    void setCreateTime(const Time& time);

    virtual QString toString();

    virtual void setConnector(ConnectorInterface *connector, int mode=cmINPUT | cmOUTPUT);

    virtual bool isEqual(const Ilwis::IlwisObject *obj) const;

    virtual bool isValid() const;

    virtual bool isReadOnly() const;

    virtual void setReadOnly(bool yesno);

    virtual bool hasChanged() const;

    virtual void changed(bool yesno) ;

    virtual IlwisTypes ilwisType() const = 0;

    virtual bool prepare(const QString& def);

    bool fromInternal(const QSqlRecord& rec);

    bool isAnonymous() const;

    virtual Resource source(int mode=cmINPUT) const;

    virtual bool store(int mode=smMETADATA | smBINARYDATA);

    void connectTo(const QUrl &url, const QString &format, const QString &fnamespace, ConnectorMode cmode);


    //TODO. Puzzeld, this method is not allowed as duplicate copies are illegal
    virtual IlwisObject *clone() ;

    virtual bool merge(const IlwisObject* obj, int options=0);
    bool isSystemObject() const;
    bool isInternalObject() const;

    template<typename T> static T create(const QString& def){
        T object;
        object.prepare(def);
        return object;
    }

    template<typename T> static T create(quint64 id){
        T object;
        object.prepare(id);
        return object;
    }

    static IlwisObject *create(const Resource& source,const PrepareOptions& options=PrepareOptions());

    static IlwisTypes findType(const QString &source);

    static QString type2Name(IlwisTypes t);

    static IlwisTypes name2Type(const QString &name);

    static void addTypeFunction(IlwisTypeFunction);

    static IlwisTypes name2ExtendedType(const QString &dname);

protected:
   QScopedPointer<ConnectorInterface>& connector(int mode=cmINPUT | cmOUTPUT);
   const QScopedPointer<ConnectorInterface> &connector(int mode=cmINPUT | cmOUTPUT) const;
   bool setValid(bool yesno);
   void copyTo(IlwisObject *obj);

   std::mutex _mutex;
   std::mutex _loadforstore;
private:

   bool _valid;
   bool _readOnly;
   bool _changed;
   Time _modifiedTime;
   Time _createTime;
   QScopedPointer<Ilwis::ConnectorInterface> _connector;
   QScopedPointer<Ilwis::ConnectorInterface> _outConnector;
   static QVector<IlwisTypeFunction> _typeFunctions;


};


}

bool operator==(const Ilwis::IlwisObject& obj1, const Ilwis::IlwisObject& obj2);
#define IVARIANT(o) qVariantFromValue(o)




#endif // ILWISOBJECTIMPL_H