QoreClass.h

/* -*- mode: c++; indent-tabs-mode: nil -*- */
/*
    QoreClass.h

    Qore Programming Language

    Copyright (C) 2003 - 2020 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_QORECLASS_H

#define _QORE_QORECLASS_H

#include <cstdarg>
#include <memory>
#include <string>

// all qore class IDs
DLLEXPORT extern qore_classid_t CID_AUTOGATE;
DLLEXPORT extern qore_classid_t CID_AUTOLOCK;
DLLEXPORT extern qore_classid_t CID_AUTOREADLOCK;
DLLEXPORT extern qore_classid_t CID_AUTOWRITELOCK;
DLLEXPORT extern qore_classid_t CID_CONDITION;
DLLEXPORT extern qore_classid_t CID_COUNTER;
DLLEXPORT extern qore_classid_t CID_DATASOURCE;
DLLEXPORT extern qore_classid_t CID_DATASOURCEPOOL;
DLLEXPORT extern qore_classid_t CID_FILE;
DLLEXPORT extern qore_classid_t CID_FTPCLIENT;
DLLEXPORT extern qore_classid_t CID_GATE;
DLLEXPORT extern qore_classid_t CID_GETOPT;
DLLEXPORT extern qore_classid_t CID_HTTPCLIENT;
DLLEXPORT extern qore_classid_t CID_MUTEX;
DLLEXPORT extern qore_classid_t CID_PROGRAM;
DLLEXPORT extern qore_classid_t CID_PROGRAMDEBUG;
DLLEXPORT extern qore_classid_t CID_QUEUE;
DLLEXPORT extern qore_classid_t CID_RWLOCK;
DLLEXPORT extern qore_classid_t CID_SSLCERTIFICATE;
DLLEXPORT extern qore_classid_t CID_SSLPRIVATEKEY;
DLLEXPORT extern qore_classid_t CID_SEQUENCE;
DLLEXPORT extern qore_classid_t CID_SOCKET;
DLLEXPORT extern qore_classid_t CID_TERMIOS;
DLLEXPORT extern qore_classid_t CID_INPUTSTREAM;
DLLEXPORT extern qore_classid_t CID_OUTPUTSTREAM;
DLLEXPORT extern qore_classid_t CID_INPUTSTREAMBASE;
DLLEXPORT extern qore_classid_t CID_OUTPUTSTREAMBASE;
DLLEXPORT extern qore_classid_t CID_PROGRAM;
DLLEXPORT extern qore_classid_t CID_SERIALIZABLE;

DLLEXPORT extern QoreClass* QC_QUEUE;
DLLEXPORT extern QoreClass* QC_HTTPCLIENT;
DLLEXPORT extern QoreClass* QC_SSLCERTIFICATE;
DLLEXPORT extern QoreClass* QC_SSLPRIVATEKEY;
DLLEXPORT extern QoreClass* QC_PROGRAM;
DLLEXPORT extern QoreClass* QC_SERIALIZABLE;

class BCList;
class BCSMList;
class BCAList;
class QoreObject;
class QoreClass;
class BCEAList;
class ParamList;
class QoreMemberInfo;
class BuiltinMethod;
class AbstractQoreFunctionVariant;
class AbstractFunctionSignature;
class UserMethod;
class BCANode;
class qore_method_private;
class MethodFunctionBase;
class NamedScope;
class ConstantList;
class MethodVariantBase;

class QoreExternalVariant;
class QoreExternalMethodVariant;
class QoreExternalNormalMember;
class QoreExternalStaticMember;
class QoreExternalProgramLocation;
class QoreExternalMethodFunction;
class QoreExternalMemberVarBase;
class QoreExternalStaticMember;
class QoreExternalNormalMember;
class QoreExternalConstant;


enum method_type_e {
    MT_None = 0, // not a method function/variant
    MT_Normal = 1,
    MT_Static = 2,
    MT_Constructor = 3,
    MT_Destructor = 4,
    MT_Copy = 5,
    MT_Pseudo = 6,
};


class QoreMethod {
    friend class StaticMethodCallNode;
    friend class QoreObject;
    friend class qore_class_private;
    friend class qore_method_private;
    friend class BCList;

private:
    class qore_method_private* priv;

    DLLLOCAL QoreMethod(const QoreMethod&);

    DLLLOCAL QoreMethod& operator=(const QoreMethod&);

public:

    DLLEXPORT bool isUser() const;


    DLLEXPORT bool isBuiltin() const;


    DLLEXPORT bool isPrivate() const;

    DLLEXPORT ClassAccess getAccess() const;


    DLLEXPORT bool isStatic() const;


    DLLEXPORT const char* getName() const;


    DLLEXPORT const std::string& getNameStr() const;

    DLLEXPORT const QoreClass* getClass() const;

    DLLEXPORT const char* getClassName() const;

    DLLEXPORT bool existsVariant(const type_vec_t& paramTypeInfo) const;

    /* returns the return type information for the method if it is available and if
        there is only one return type (there can be more return types if the method is
        overloaded)
    */
    DLLEXPORT const QoreTypeInfo* getUniqueReturnTypeInfo() const;


    DLLEXPORT QoreValue execManaged(QoreObject* self, const QoreListNode* args, ExceptionSink* xsink) const;


    DLLEXPORT method_type_e getMethodType() const;


    DLLEXPORT const QoreExternalMethodFunction* getFunction() const;

    DLLLOCAL QoreMethod(const QoreClass* p_class, MethodFunctionBase* n_func, bool n_static = false);

    DLLLOCAL bool inMethod(const QoreObject* self) const;
    DLLLOCAL QoreMethod* copy(const QoreClass* p_class) const;
    DLLLOCAL void assign_class(const QoreClass* p_class);
    // non-exported destructor
    DLLLOCAL ~QoreMethod();
};


class AbstractQoreClassUserData {
public:
    DLLEXPORT virtual ~AbstractQoreClassUserData();

    virtual AbstractQoreClassUserData* copy() const = 0;

    virtual void doDeref() = 0;
};


class QoreClass {
    friend class BCList;
    friend class BCNode;
    friend class BCSMList;
    friend class qore_object_private;
    friend class qore_class_private;
    friend class QoreObject;
    friend class BCANode;
    friend class qore_method_private;
    friend class QoreMethodIterator;
    friend class QoreStaticMethodIterator;
    friend class ConstructorMethodFunction;

public:

    DLLEXPORT QoreClass(std::string&& n_name, int64 n_domain = QDOM_DEFAULT);


    DLLEXPORT QoreClass(const char* n_name, int64 n_domain = QDOM_DEFAULT);


    DLLEXPORT explicit QoreClass(const char* n_name, int n_domain);


    DLLEXPORT QoreClass(const char* n_name, int64 n_domain, const QoreTypeInfo* n_typeInfo);


    DLLEXPORT QoreClass(const QoreClass& old);


    DLLEXPORT virtual QoreClass* copyImport();


    DLLEXPORT virtual QoreClass* copy();


    DLLEXPORT QoreProgram* getProgram() const;


    DLLEXPORT void addMethod(const char* n_name, q_method_n_t meth, ClassAccess access = Public, int64 n_flags = QCF_NO_FLAGS, int64 n_domain = QDOM_DEFAULT, const QoreTypeInfo* returnTypeInfo = 0, unsigned num_params = 0, ...);


    DLLEXPORT void addMethod(const void* ptr, const char* n_name, q_external_method_t meth, ClassAccess access = Public, int64 n_flags = QCF_NO_FLAGS, int64 n_domain = QDOM_DEFAULT, const QoreTypeInfo* returnTypeInfo = 0, const type_vec_t& n_typeList = type_vec_t(), const arg_vec_t& defaultArgList = arg_vec_t(), const name_vec_t& n_names = name_vec_t());

    DLLEXPORT void addStaticMethod(const char* n_name, q_func_n_t meth, ClassAccess access = Public, int64 n_flags = QCF_NO_FLAGS, int64 n_domain = QDOM_DEFAULT, const QoreTypeInfo* returnTypeInfo = 0, unsigned num_params = 0, ...);


    DLLEXPORT void addStaticMethod(const void* ptr, const char* n_name, q_external_static_method_t meth, ClassAccess access = Public, int64 n_flags = QCF_NO_FLAGS, int64 n_domain = QDOM_DEFAULT, const QoreTypeInfo* returnTypeInfo = 0, const type_vec_t& n_typeList = type_vec_t(), const arg_vec_t& defaultArgList = arg_vec_t(), const name_vec_t& n_names = name_vec_t());

    DLLEXPORT void addAbstractMethod(const char* n_name, ClassAccess access = Public, int64 n_flags = QCF_NO_FLAGS, const QoreTypeInfo* returnTypeInfo = 0, unsigned num_params = 0, ...);

    DLLEXPORT void addAbstractMethod(const char* n_name, ClassAccess access, int64 n_flags, const QoreTypeInfo* returnTypeInfo, const type_vec_t& n_typeList, const arg_vec_t& defaultArgList = arg_vec_t(), const name_vec_t& n_names = name_vec_t());


    DLLEXPORT void setDestructor(q_destructor_t m);


    DLLEXPORT void setDestructor(const void* ptr, q_external_destructor_t m);

    DLLEXPORT void addConstructor(q_constructor_n_t meth, ClassAccess access = Public, int64 n_flags = QCF_NO_FLAGS, int64 n_domain = QDOM_DEFAULT, unsigned num_params = 0, ...);


    DLLEXPORT void addConstructor(const void* ptr, q_external_constructor_t meth, ClassAccess access = Public, int64 n_flags = QCF_NO_FLAGS, int64 n_domain = QDOM_DEFAULT, const type_vec_t& n_typeList = type_vec_t(), const arg_vec_t& defaultArgList = arg_vec_t(), const name_vec_t& n_names = name_vec_t());


    DLLEXPORT void setSystemConstructor(q_system_constructor_t m);


    DLLEXPORT void setCopy(q_copy_t m);


    DLLEXPORT void setCopy(const void* ptr, q_external_copy_t m);


    DLLEXPORT void setDeleteBlocker(q_delete_blocker_t m);


    DLLEXPORT void setSerializer(q_serializer_t m);


    DLLEXPORT void setDeserializer(q_deserializer_t m);


    DLLEXPORT q_serializer_t getSerializer() const;


    DLLEXPORT q_deserializer_t getDeserializer() const;

    DLLEXPORT void setFinal();


    DLLEXPORT bool isPrivateMember(const char* str) const;


    DLLEXPORT bool isPublicOrPrivateMember(const char* str, bool& priv) const;


    DLLEXPORT QoreObject* execConstructor(const QoreListNode* args, ExceptionSink* xsink) const;


    DLLEXPORT QoreObject* execConstructor(const QoreClass& obj_cls, const QoreListNode* args, bool allow_abstract,
        ExceptionSink* xsink) const;


    DLLEXPORT QoreObject* execConstructorVariant(const QoreExternalMethodVariant* mv, const QoreListNode *args, ExceptionSink* xsink) const;


    DLLEXPORT QoreObject* execSystemConstructor(int code = 0, ...) const;


    DLLEXPORT QoreObject* execCopy(QoreObject* old, ExceptionSink* xsink) const;


    DLLEXPORT QoreListNode* getMethodList() const;


    DLLEXPORT QoreListNode* getStaticMethodList() const;


    DLLEXPORT QoreClass* getClass(qore_classid_t cid) const;


    DLLEXPORT const QoreClass* getClass(qore_classid_t cid, bool& priv) const;


    DLLEXPORT const QoreClass* getClass(const QoreClass& qc, bool& priv) const;

    DLLEXPORT int numMethods() const;

    DLLEXPORT int numStaticMethods() const;

    DLLEXPORT int numUserMethods() const;

    DLLEXPORT int numStaticUserMethods() const;

    DLLEXPORT bool hasCopy() const;

    DLLEXPORT qore_classid_t getID() const;

    DLLEXPORT bool isSystem() const;


    DLLEXPORT bool isModulePublic() const;


    DLLEXPORT bool isAbstract() const;


    DLLEXPORT bool isFinal() const;


    DLLEXPORT bool isInjected() const;


    DLLEXPORT bool isPseudoClass() const;


    DLLEXPORT qore_type_t getPseudoClassType() const;


    DLLEXPORT QoreValue evalPseudoMethod(const QoreValue n, const char* nme, const QoreListNode* args, ExceptionSink* xsink) const;


    DLLEXPORT QoreValue evalPseudoMethod(const QoreMethod* m, const QoreExternalMethodVariant* variant, const QoreValue n, const QoreListNode* args, ExceptionSink* xsink) const;

    DLLEXPORT void setSystem();

    DLLEXPORT bool hasMemberGate() const;

    DLLEXPORT bool hasMethodGate() const;

    DLLEXPORT bool hasMemberNotification() const;


    DLLEXPORT int64 getDomain() const;

    DLLEXPORT const char* getName() const;


    DLLEXPORT const QoreMethod* findMethod(const char* nme) const;


    DLLEXPORT const QoreMethod* findStaticMethod(const char* nme) const;


    DLLEXPORT const QoreMethod* findMethod(const char* nme, ClassAccess& access) const;


    DLLEXPORT const QoreMethod* findStaticMethod(const char* nme, ClassAccess& access) const;


    DLLEXPORT const QoreMethod* findLocalMethod(const char* name) const;


    DLLEXPORT const QoreMethod* findLocalStaticMethod(const char* name) const;


    DLLEXPORT void addBuiltinBaseClass(QoreClass* qc);


    DLLEXPORT void addDefaultBuiltinBaseClass(QoreClass* qc);


    DLLEXPORT void addBuiltinVirtualBaseClass(QoreClass* qc);


    DLLEXPORT void addBaseClass(QoreClass* qc, bool virt = false);


    DLLEXPORT void setSynchronousClass();


    DLLEXPORT const QoreMethod* getConstructor() const;


    DLLEXPORT const QoreMethod* getSystemConstructor() const;


    DLLEXPORT const QoreMethod* getDestructor() const;


    DLLEXPORT const QoreMethod* getCopyMethod() const;


    DLLEXPORT const QoreMethod* getMemberGateMethod() const;


    DLLEXPORT const QoreMethod* getMethodGate() const;


    DLLEXPORT const QoreMethod* getMemberNotificationMethod() const;

    DLLEXPORT const QoreTypeInfo* getTypeInfo() const;

    DLLEXPORT const QoreTypeInfo* getOrNothingTypeInfo() const;

    DLLEXPORT void addMember(const char* mem, ClassAccess access, const QoreTypeInfo* n_typeInfo, QoreValue initial_value = QoreValue());


    DLLEXPORT void setUserData(const void* ptr);


    DLLEXPORT const void* getUserData() const;


    DLLEXPORT void setManagedUserData(AbstractQoreClassUserData* cud);


    DLLEXPORT AbstractQoreClassUserData* getManagedUserData() const;


    template <typename T>
    DLLLOCAL T* getManagedUserData() const {
        return static_cast<T*>(getManagedUserData());
    }

    DLLEXPORT void recheckBuiltinMethodHierarchy();


    DLLEXPORT const QoreExternalMethodVariant* findUserMethodVariant(const char* name, const QoreMethod*& method, const type_vec_t& argTypeList) const;


    DLLEXPORT void addBuiltinConstant(const char* name, QoreValue value, ClassAccess access = Public, const QoreTypeInfo* typeInfo = nullptr);


    DLLEXPORT void addBuiltinStaticVar(const char* name, QoreValue value, ClassAccess access = Public, const QoreTypeInfo* typeInfo = nullptr);


    DLLEXPORT void rescanParents();


    DLLEXPORT void setPublicMemberFlag();


    DLLEXPORT void setGateAccessFlag();


    DLLEXPORT const QoreExternalNormalMember* findLocalMember(const char* name) const;


    DLLEXPORT const QoreExternalStaticMember* findLocalStaticMember(const char* name) const;


    DLLEXPORT std::string getNamespacePath(bool anchored = false) const;


    DLLEXPORT bool isEqual(const QoreClass& cls) const;


    DLLEXPORT BinaryNode* getBinaryHash() const;


    DLLEXPORT int runtimeCheckInstantiateClass(ExceptionSink* xsink) const;


    DLLEXPORT const QoreExternalConstant* findConstant(const char* name) const;


    DLLEXPORT const QoreNamespace* getNamespace() const;


    DLLEXPORT bool inHierarchy(const QoreClass& cls, ClassAccess& n_access) const;


    DLLEXPORT bool hasTransientMember() const;


    DLLEXPORT const char* getModuleName() const;

    // used when parsing, finds committed non-static methods within the entire class hierarchy (local class plus base classes)
    DLLLOCAL const QoreMethod* parseFindCommittedMethod(const char* nme);

    // returns 0 for success, -1 for error
    DLLLOCAL int parseAddBaseClassArgumentList(BCAList* bcal);
    // only called when parsing, sets the name of the class
    DLLLOCAL void setName(const char* n);

    DLLLOCAL qore_classid_t getIDForMethod() const;
    // get base class list to add virtual class indexes for private data
    DLLLOCAL BCSMList* getBCSMList() const;
    // returns true if the class has a delete_blocker function (somewhere in the hierarchy)
    DLLLOCAL bool has_delete_blocker() const;

    DLLLOCAL bool parseHasPublicMembersInHierarchy() const;
    DLLLOCAL bool runtimeHasPublicMembersInHierarchy() const;

    // returns true if the class has one or more parent classes
    DLLLOCAL bool hasParentClass() const;
    DLLLOCAL bool hasPrivateCopyMethod() const;
    // returns the status including the pending variant (if any)
    DLLLOCAL bool parseHasPrivateCopyMethod() const;
    DLLLOCAL const QoreMethod* parseGetConstructor() const;
    // returns true if the class implements a "methodGate" method, also in pending uncommitted methods
    DLLLOCAL bool parseHasMethodGate() const;
    // called when there is an empty public member declaration or a "no_public" declaration
    DLLLOCAL void parseSetEmptyPublicMemberDeclaration();
    // unsets the public member flag for builtin classes
    DLLLOCAL void unsetPublicMemberFlag();

protected:
    DLLEXPORT virtual ~QoreClass();

    DLLEXPORT QoreClass();

private:
    QoreClass& operator=(const QoreClass&) = delete;

    class qore_class_private* priv;

    DLLLOCAL void insertMethod(QoreMethod* o);
    DLLLOCAL void insertStaticMethod(QoreMethod* o);
    DLLLOCAL QoreValue evalMethodGate(QoreObject* self, const char* nme, const QoreListNode* args, ExceptionSink* xsink) const;
    DLLLOCAL const QoreMethod* parseResolveSelfMethodIntern(const char* nme);


    DLLLOCAL QoreValue evalMethod(QoreObject* self, const char* method_name, const QoreListNode* args, ExceptionSink* xsink) const;

    // This function must only be called from QoreObject
    DLLLOCAL void execMemberNotification(QoreObject* self, const char* mem, ExceptionSink* xsink) const;
    // This function must only be called from QoreObject and BCList
    DLLLOCAL bool execDeleteBlocker(QoreObject* self, ExceptionSink* xsink) const;
    // This function must only be called from QoreObject
    DLLLOCAL void execDestructor(QoreObject* self, ExceptionSink* xsink) const;
};

class QoreMethodIterator {
private:
    void* priv;

public:
    DLLEXPORT QoreMethodIterator(const QoreClass& qc);
    DLLEXPORT ~QoreMethodIterator();
    DLLEXPORT bool next();
    DLLEXPORT const QoreMethod* getMethod() const;
};

class QoreStaticMethodIterator {
private:
    void* priv;

public:
    DLLEXPORT QoreStaticMethodIterator(const QoreClass& qc);
    DLLEXPORT ~QoreStaticMethodIterator();
    DLLEXPORT bool next();
    DLLEXPORT const QoreMethod* getMethod() const;
};


class QoreClassHolder {
public:
    DLLLOCAL QoreClassHolder(QoreClass* c) : c(c) {
    }

    DLLEXPORT ~QoreClassHolder();

    DLLLOCAL operator QoreClass*() const {
        return c;
    }

    DLLLOCAL QoreClass* release() {
        auto rv = c;
        c = 0;
        return rv;
    }

private:
    QoreClass* c;
};

class QoreBuiltinClass : public QoreClass {
public:
    DLLEXPORT QoreBuiltinClass(const char* name, int64 n_domain = QDOM_DEFAULT);

    DLLEXPORT QoreBuiltinClass(const QoreBuiltinClass& old);

protected:
    DLLEXPORT QoreBuiltinClass();
};


class QoreParentClassIterator final {
public:
    DLLEXPORT QoreParentClassIterator(const QoreClass& cls);

    DLLEXPORT ~QoreParentClassIterator();

    DLLEXPORT bool next();

    DLLEXPORT bool valid() const;

    DLLEXPORT const QoreClass& getParentClass() const;

    DLLEXPORT ClassAccess getAccess() const;

private:
    std::unique_ptr<class qore_parent_class_iterator_private> priv;
};


class QoreClassMemberIterator final {
public:
    DLLEXPORT QoreClassMemberIterator(const QoreClass& cls);

    DLLEXPORT ~QoreClassMemberIterator();

    DLLEXPORT bool next();

    DLLEXPORT bool valid() const;

    DLLEXPORT const QoreExternalNormalMember& getMember() const;

    DLLEXPORT const char* getName() const;

private:
    std::unique_ptr<class qore_class_member_iterator_private> priv;
};


class QoreClassStaticMemberIterator final {
public:
    DLLEXPORT QoreClassStaticMemberIterator(const QoreClass& cls);

    DLLEXPORT ~QoreClassStaticMemberIterator();

    DLLEXPORT bool next();

    DLLEXPORT bool valid() const;

    DLLEXPORT const QoreExternalStaticMember& getMember() const;

    DLLEXPORT const char* getName() const;

private:
    std::unique_ptr<class qore_class_static_member_iterator_private> priv;
};


class QoreClassConstantIterator final {
public:
    DLLEXPORT QoreClassConstantIterator(const QoreClass& cls);

    DLLEXPORT ~QoreClassConstantIterator();

    DLLEXPORT bool next();

    DLLEXPORT bool valid() const;

    DLLEXPORT const QoreExternalConstant& get() const;

private:
    std::unique_ptr<class qore_class_constant_iterator> priv;
};


class QoreClassHierarchyIterator final {
public:
    DLLEXPORT QoreClassHierarchyIterator(const QoreClass& cls);

    DLLEXPORT ~QoreClassHierarchyIterator();

    DLLEXPORT bool next();

    DLLEXPORT bool valid() const;

    DLLEXPORT const QoreClass& get() const;


    DLLEXPORT bool isVirtual() const;

private:
    std::unique_ptr<class qore_class_hierarchy_iterator> priv;
};


class QoreClassDestructorHierarchyIterator {
public:
    DLLEXPORT QoreClassDestructorHierarchyIterator(const QoreClass* cls);

    DLLEXPORT ~QoreClassDestructorHierarchyIterator();

    DLLEXPORT bool next();

    DLLEXPORT bool valid() const;

    DLLEXPORT const QoreClass* get() const;


    DLLEXPORT bool isVirtual() const;

private:
    class qore_class_destructor_hierarchy_iterator* priv;
};

DLLEXPORT const char* get_access_string(ClassAccess access);

#endif // _QORE_QORECLASS_H