QoreObject.h

/* -*- mode: c++; indent-tabs-mode: nil -*- */
/*
    QoreObject.h
 
    thread-safe object definition
 
    Qore Programming Language
 
    Copyright (C) 2003 - 2023 Qore Technologies, s.r.o.
 
    Permission is hereby granted, free of charge, to any person obtaining a
    copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation
    the rights to use, copy, modify, merge, publish, distribute, sublicense,
    and/or sell copies of the Software, and to permit persons to whom the
    Software is furnished to do so, subject to the following conditions:
 
    The above copyright notice and this permission notice shall be included in
    all copies or substantial portions of the Software.
 
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    DEALINGS IN THE SOFTWARE.
 
    Note that the Qore library is released under a choice of three open-source
    licenses: MIT (as above), LGPL 2+, or GPL 2+; see README-LICENSE for more
    information.
*/
 
#ifndef _QORE_QOREOBJECT_H
 
#define _QORE_QOREOBJECT_H
 
class AutoVLock;
class VRMutex;
class BuiltinCopy;
class BuiltinNormalMethodVariantBase;
class BuiltinCopyVariantBase;
class QoreExternalMethodVariant;
class QoreProgram;
class ReferenceNode;
class QoreTypeSafeReferenceHelper;
 
 
class QoreObject : public AbstractQoreNode {
    friend class qore_object_private;
    friend class ObjectRSetHelper;
    friend class ObjectRSet;
    friend class qore_object_dereference_helper;
 
public:
 
    DLLEXPORT QoreObject(const QoreClass* oc, QoreProgram* p);
 
 
    DLLEXPORT QoreObject(const QoreClass* oc, QoreProgram* p, AbstractPrivateData* data);
 
    DLLEXPORT bool hasMember(const char* mem, ExceptionSink* xsink) const;
 
 
    DLLEXPORT virtual bool getAsBoolImpl() const;
 
 
    DLLEXPORT virtual int getAsString(QoreString &str, int foff, ExceptionSink* xsink) const;
 
 
    DLLEXPORT virtual QoreString* getAsString(bool& del, int foff, ExceptionSink* xsink) const;
 
    DLLEXPORT virtual AbstractQoreNode* realCopy() const;
 
 
    DLLEXPORT virtual bool is_equal_soft(const AbstractQoreNode* v, ExceptionSink* xsink) const;
 
 
    DLLEXPORT virtual bool is_equal_hard(const AbstractQoreNode* v, ExceptionSink* xsink) const;
 
    DLLEXPORT virtual const char* getTypeName() const;
 
    DLLLOCAL static const char* getStaticTypeName() {
        return "object";
    }
 
    DLLLOCAL static qore_type_t getStaticTypeCode() {
        return NT_OBJECT;
    }
 
 
    DLLEXPORT bool validInstanceOf(qore_classid_t cid) const;
 
 
    DLLEXPORT bool validInstanceOf(const QoreClass& qc) const;
 
 
    DLLEXPORT bool validInstanceOfStrict(const QoreClass& qc) const;
 
 
    DLLEXPORT void setValue(const char* key, QoreValue val, ExceptionSink* xsink);
 
 
    DLLEXPORT QoreListNode* getMemberList(ExceptionSink* xsink) const;
 
 
    DLLEXPORT void deleteMemberValue(const QoreString* key, ExceptionSink* xsink);
 
 
    DLLEXPORT void deleteMemberValue(const char* key, ExceptionSink* xsink);
 
 
    DLLEXPORT void removeMember(const QoreString* key, ExceptionSink* xsink);
 
 
    DLLEXPORT void removeMember(const char* key, ExceptionSink* xsink);
 
 
    DLLEXPORT QoreValue takeMember(const QoreString* key, ExceptionSink* xsink);
 
 
    DLLEXPORT QoreValue takeMember(const char* key, ExceptionSink* xsink);
 
 
    DLLEXPORT int size(ExceptionSink* xsink) const;
 
 
    DLLEXPORT bool compareSoft(const QoreObject* obj, ExceptionSink* xsink) const;
 
 
    DLLEXPORT bool compareHard(const QoreObject* obj, ExceptionSink* xsink) const;
 
 
    DLLEXPORT QoreValue getReferencedMemberNoMethod(const char* mem, ExceptionSink* xsink) const;
 
 
    DLLEXPORT ReferenceNode* getReferenceToMember(const char* mem, ExceptionSink* xsink);
 
 
    DLLEXPORT int64 getMemberAsBigInt(const char* mem, bool& found, ExceptionSink* xsink) const;
 
 
    DLLEXPORT QoreHashNode* copyData(ExceptionSink* xsink) const;
 
 
    DLLEXPORT void setPrivate(qore_classid_t key, AbstractPrivateData* pd);
 
 
    DLLEXPORT AbstractPrivateData* getReferencedPrivateData(qore_classid_t key, ExceptionSink* xsink) const;
 
 
    template <class T>
    DLLLOCAL T* getReferencedPrivateData(qore_classid_t key, ExceptionSink* xsink) const {
        AbstractPrivateData* rv = getReferencedPrivateData(key, xsink);
        assert(!rv || dynamic_cast<T*>(rv));
        return reinterpret_cast<T*>(rv);
    }
 
 
    DLLEXPORT AbstractPrivateData* tryGetReferencedPrivateData(qore_classid_t key, ExceptionSink* xsink) const;
 
 
    template <class T>
    DLLLOCAL T* tryGetReferencedPrivateData(qore_classid_t key, ExceptionSink* xsink) const {
        AbstractPrivateData* rv = tryGetReferencedPrivateData(key, xsink);
        assert(!rv || dynamic_cast<T*>(rv));
        return reinterpret_cast<T*>(rv);
    }
 
 
    DLLEXPORT QoreValue evalMethod(const QoreString* name, const QoreListNode* args, ExceptionSink* xsink);
 
 
    DLLEXPORT QoreValue evalMethod(const char* name, const QoreListNode* args, ExceptionSink* xsink);
 
 
    DLLEXPORT QoreValue evalMethod(const QoreMethod& method, const QoreListNode* args, ExceptionSink* xsink);
 
 
    DLLEXPORT QoreValue evalMethod(const char* name, const QoreClass* class_ctx, const QoreListNode* args,
            ExceptionSink* xsink);
 
 
    DLLEXPORT QoreValue evalMethod(const QoreMethod& method, const QoreClass* class_ctx, const QoreListNode* args, ExceptionSink* xsink);
 
 
    DLLEXPORT void doDelete(ExceptionSink* xsink);
 
 
    DLLEXPORT const QoreClass* getClass(qore_classid_t cid) const;
 
 
    DLLEXPORT const QoreClass* getClass(qore_classid_t cid, bool& priv) const;
 
 
    DLLEXPORT ClassAccess getClassAccess(const QoreClass& cls) const;
 
 
    DLLEXPORT const QoreClass* getClass() const;
 
 
    DLLEXPORT const char* getClassName() const;
 
 
    DLLEXPORT const QoreClass* getSurfaceClass() const;
 
 
    DLLEXPORT const char* getSurfaceClassName() const;
 
 
    DLLEXPORT bool isValid() const;
 
 
    DLLEXPORT QoreProgram* getProgram() const;
 
 
    DLLEXPORT bool isSystemObject() const;
 
 
    DLLEXPORT void tRef() const;
 
 
    DLLEXPORT void tDeref();
 
    DLLEXPORT void realRef();
 
    DLLEXPORT void realDeref(ExceptionSink* xsink);
 
 
    DLLEXPORT QoreValue getMemberValueNoMethod(const QoreString* key, AutoVLock* vl, ExceptionSink* xsink) const;
 
 
    DLLEXPORT QoreValue getMemberValueNoMethod(const char* key, AutoVLock* vl, ExceptionSink* xsink) const;
 
 
    DLLEXPORT QoreValue getMemberValueNoMethod(const char* key, const QoreClass* cls, AutoVLock* vl,
            ExceptionSink* xsink) const;
 
 
    DLLEXPORT int editMemberValue(const char* key, const QoreClass* cls, QoreTypeSafeReferenceHelper& ref, bool for_remove = false) const;
 
 
    DLLEXPORT QoreValue getReferencedMemberNoMethod(const char* key, const QoreClass* cls, ExceptionSink* xsink) const;
 
 
    DLLEXPORT int setMemberValue(const char* key, const QoreClass* cls, const QoreValue val, ExceptionSink* xsink);
 
 
    DLLEXPORT int setMemberValue(const char* key, const QoreClass* cls, const QoreValue val,
            QoreTypeSafeReferenceHelper& ref);
 
 
    DLLEXPORT void externalDelete(qore_classid_t key, ExceptionSink* xsink);
 
    DLLEXPORT QoreValue evalMethodVariant(const QoreMethod& method, const QoreExternalMethodVariant* variant,
            const QoreListNode* args, ExceptionSink* xsink);
 
 
    DLLEXPORT QoreValue evalMethodVariant(const QoreMethod& method, const QoreClass* class_ctx,
                const QoreExternalMethodVariant* variant, const QoreListNode* args, ExceptionSink* xsink);
 
 
    DLLEXPORT static QoreValue evalStaticMethod(const QoreMethod& method, const QoreListNode* args, ExceptionSink* xsink);
 
 
    DLLEXPORT static QoreValue evalStaticMethod(const QoreMethod& method, const QoreClass* class_ctx,
            const QoreListNode* args, ExceptionSink* xsink);
 
 
    DLLEXPORT static QoreValue evalStaticMethodVariant(const QoreMethod& method,
            const QoreExternalMethodVariant* variant, const QoreListNode* args, ExceptionSink* xsink);
 
 
    DLLEXPORT static QoreValue evalStaticMethodVariant(const QoreMethod& method, const QoreClass* class_ctx,
            const QoreExternalMethodVariant* variant, const QoreListNode* args, ExceptionSink* xsink);
 
 
    DLLEXPORT QoreValue evalMember(const QoreString* member, ExceptionSink* xsink);
 
 
    DLLEXPORT QoreValue evalMember(const char* member, ExceptionSink* xsink);
 
 
    DLLLOCAL QoreObject* objectRefSelf() const {
        ref();
        return const_cast<QoreObject*>(this);
    }
 
    DLLLOCAL int getStatus() const;
 
    DLLLOCAL class KeyNode* getReferencedPrivateDataNode(qore_classid_t key);
 
 
    DLLLOCAL AbstractPrivateData* getAndClearPrivateData(qore_classid_t key, ExceptionSink* xsink);
 
 
    DLLLOCAL QoreValue evalBuiltinMethodWithPrivateData(const QoreMethod& method,
            const BuiltinNormalMethodVariantBase* meth, const QoreListNode* args, ExceptionSink* xsink);
 
    DLLLOCAL void evalCopyMethodWithPrivateData(const QoreClass &thisclass, const BuiltinCopyVariantBase* meth,
            QoreObject* self, ExceptionSink* xsink);
 
 
    DLLLOCAL void addPrivateDataToString(QoreString* str, ExceptionSink* xsink) const;
 
 
    DLLLOCAL void obliterate(ExceptionSink* xsink);
 
 
    DLLLOCAL void defaultSystemDestructor(qore_classid_t classID, ExceptionSink* xsink);
 
    // returns a new hash consisting of just the members of value_list
    DLLLOCAL QoreHashNode* getSlice(const QoreListNode* value_list, ExceptionSink* xsink) const;
 
    DLLLOCAL QoreObject(const QoreClass* oc, QoreProgram* p, QoreHashNode* d);
 
    DLLLOCAL bool hasMemberNotification() const;
 
    DLLLOCAL void execMemberNotification(const char* member, ExceptionSink* xsink);
 
protected:
 
    DLLEXPORT virtual bool derefImpl(ExceptionSink* xsink);
 
 
    DLLLOCAL virtual QoreValue evalImpl(bool& needs_deref, ExceptionSink* xsink) const;
 
    DLLLOCAL virtual void customRef() const;
 
    DLLLOCAL virtual void customDeref(ExceptionSink* xsink);
 
    DLLLOCAL virtual ~QoreObject();
 
private:
    class qore_object_private* priv;
 
    DLLLOCAL QoreObject(const QoreObject&);
 
    DLLLOCAL QoreObject& operator=(const QoreObject&);
};
 
 
class QoreObjectWeakRefHolder {
public:
    DLLLOCAL QoreObjectWeakRefHolder() {
    }
 
    DLLLOCAL QoreObjectWeakRefHolder(QoreObject* obj) : obj(obj) {
        if (obj) {
            obj->tRef();
        }
    }
 
    DLLLOCAL ~QoreObjectWeakRefHolder() {
        discard();
    }
 
    DLLLOCAL QoreObject* release() {
        QoreObject* rv = obj;
        obj = nullptr;
        return rv;
    }
 
    DLLLOCAL void reset(QoreObject* obj = nullptr) {
        discard();
        this->obj = obj;
    }
 
    DLLLOCAL QoreObject* operator*() {
        return obj;
    }
 
    DLLLOCAL const QoreObject* operator*() const {
        return obj;
    }
 
    DLLLOCAL QoreObject* operator->() {
        return obj;
    }
 
    DLLLOCAL const QoreObject* operator->() const {
        return obj;
    }
 
    DLLLOCAL operator bool() {
        return (bool)obj;
    }
 
    DLLLOCAL operator bool() const {
        return (bool)obj;
    }
 
private:
    QoreObject* obj = nullptr;
 
    DLLLOCAL void discard() {
        if (obj) {
            obj->tDeref();
        }
    }
 
    void* operator new(size_t) = delete;
    QoreObjectWeakRefHolder(const QoreObjectWeakRefHolder& old) = delete;
    QoreObjectWeakRefHolder& operator=(QoreObjectWeakRefHolder& orig) = delete;
};
 
template <class T>
class PrivateDataRefHolder : public ReferenceHolder<T> {
public:
    DLLLOCAL PrivateDataRefHolder(ExceptionSink* xsink) : ReferenceHolder<T>(xsink) {
    }
 
    DLLLOCAL PrivateDataRefHolder(const QoreObject* o, qore_classid_t cid, ExceptionSink* xsink) : ReferenceHolder<T>(reinterpret_cast<T*>(o->getReferencedPrivateData(cid, xsink)), xsink) {
    }
 
    DLLLOCAL void operator=(T *nv) {
        if (this->p)
            this->p->deref(this->xsink);
        this->p = nv;
    }
};
 
template <class T>
class TryPrivateDataRefHolder : public ReferenceHolder<T> {
public:
    DLLLOCAL TryPrivateDataRefHolder(const QoreObject* o, qore_classid_t cid, ExceptionSink* xsink) : ReferenceHolder<T>(reinterpret_cast<T*>(o->tryGetReferencedPrivateData(cid, xsink)), xsink) {
    }
 
    DLLLOCAL void operator=(T *nv) {
        if (this->p)
            this->p->deref(this->xsink);
        this->p = nv;
    }
};
 
class QorePrivateObjectAccessHelper {
public:
    DLLLOCAL QorePrivateObjectAccessHelper(ExceptionSink* xs) : xsink(xs), ptr(0) {
    }
 
    DLLLOCAL operator bool() const {
        return (bool)ptr;
    }
 
private:
    DLLLOCAL QorePrivateObjectAccessHelper(const QorePrivateObjectAccessHelper&) = delete;
    DLLLOCAL QorePrivateObjectAccessHelper& operator=(const QorePrivateObjectAccessHelper&) = delete;
    DLLLOCAL void* operator new(size_t) = delete;
 
protected:
    ExceptionSink* xsink;
    void* ptr;
};
 
#endif