QoreClass.h

/* -*- mode: c++; indent-tabs-mode: nil -*- */
/*
    QoreClass.h
 
    Qore Programming Language
 
    Copyright (C) 2003 - 2024 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 qore_classid_t CID_ABSTRACTPOLLABLEIOOBJECT;
DLLEXPORT extern qore_classid_t CID_ABSTRACTPOLLABLEIOOBJECTBASE;
DLLEXPORT extern qore_classid_t CID_ABSTRACTPOLLOPERATION;
DLLEXPORT extern qore_classid_t CID_SOCKETPOLLOPERATIONBASE;
DLLEXPORT extern qore_classid_t CID_SOCKETPOLLOPERATION;
DLLEXPORT extern qore_classid_t CID_FILEPOLLOPERATIONBASE;
DLLEXPORT extern qore_classid_t CID_FILEPOLLOPERATION;
 
DLLEXPORT extern QoreClass* QC_ABSTRACTPOLLABLEIOOBJECT;
DLLEXPORT extern QoreClass* QC_ABSTRACTPOLLABLEIOOBJECTBASE;
DLLEXPORT extern QoreClass* QC_ABSTRACTPOLLOPERATION;
DLLEXPORT extern QoreClass* QC_CONDITION;
DLLEXPORT extern QoreClass* QC_COUNTER;
DLLEXPORT extern QoreClass* QC_FILEPOLLOPERATIONBASE;
DLLEXPORT extern QoreClass* QC_FILEPOLLOPERATION;
DLLEXPORT extern QoreClass* QC_HTTPCLIENT;
DLLEXPORT extern QoreClass* QC_MUTEX;
DLLEXPORT extern QoreClass* QC_QUEUE;
DLLEXPORT extern QoreClass* QC_PROGRAM;
DLLEXPORT extern QoreClass* QC_RWLOCK;
DLLEXPORT extern QoreClass* QC_SERIALIZABLE;
DLLEXPORT extern QoreClass* QC_SOCKETPOLLOPERATIONBASE;
DLLEXPORT extern QoreClass* QC_SOCKETPOLLOPERATION;
DLLEXPORT extern QoreClass* QC_SSLCERTIFICATE;
DLLEXPORT extern QoreClass* QC_SSLPRIVATEKEY;
 
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 QoreClassUserDataHolder {
public:
    DLLLOCAL QoreClassUserDataHolder(AbstractQoreClassUserData* d) : d(d) {
    }
 
    DLLLOCAL ~QoreClassUserDataHolder() {
        if (d) {
            d->doDeref();
        }
    }
 
    DLLLOCAL AbstractQoreClassUserData* release() {
        AbstractQoreClassUserData* rv = d;
        d = nullptr;
        return rv;
    }
 
    DLLLOCAL operator bool() const {
        return d ? true : false;
    }
 
    DLLLOCAL const AbstractQoreClassUserData* operator*() const {
        return d;
    }
 
    DLLLOCAL AbstractQoreClassUserData* operator*() {
        return d;
    }
 
    DLLLOCAL const AbstractQoreClassUserData* operator->() const {
        return d;
    }
 
    DLLLOCAL AbstractQoreClassUserData* operator->() {
        return d;
    }
 
private:
    AbstractQoreClassUserData* d;
};
 
 
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;
    friend class QoreBuiltinClass;
    friend class QoreParseClass;
 
public:
 
    DLLEXPORT QoreClass(std::string&& n_name, std::string&& ns_path, int64 n_domain = QDOM_DEFAULT);
 
 
    DLLEXPORT QoreClass(const char* n_name, const char* ns_path, int64 n_domain = QDOM_DEFAULT);
 
 
    DLLEXPORT QoreClass(const char* n_name, const char* ns_path, 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 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 const 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 QoreClass* getInjectedAsClass();
 
 
    DLLEXPORT const QoreClass* getInjectedAsClass() 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 void setLanguage(const char* lang);
 
 
    DLLEXPORT const char* getLanguage() const;
 
 
    DLLEXPORT void setRelaxedAbstractMatch();
 
 
    DLLEXPORT bool getRelaxedAbstractMatch() const;
 
 
    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 const char* getPath() 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 inHierarchyStrict(const QoreClass& cls, ClassAccess& n_access) const;
 
 
    DLLEXPORT bool hasTransientMember() const;
 
 
    DLLEXPORT const char* getModuleName() const;
 
 
    DLLEXPORT QoreValue setKeyValue(const std::string& key, QoreValue val);
 
 
    DLLEXPORT QoreValue setKeyValueIfNotSet(const std::string& key, QoreValue val);
 
 
    DLLEXPORT bool setKeyValueIfNotSet(const std::string& key, const char* str);
 
 
    DLLEXPORT QoreValue getReferencedKeyValue(const std::string& key) const;
 
 
    DLLEXPORT QoreValue getReferencedKeyValue(const char* key) const;
 
    DLLEXPORT bool hasParentClass() const;
 
    DLLEXPORT bool hasPublicMembersInHierarchy() const;
 
 
    DLLEXPORT AbstractQoreNode* getNewObjectExpression(QoreListNode* args = nullptr) const;
 
protected:
    DLLEXPORT virtual ~QoreClass();
 
    DLLEXPORT QoreClass();
 
private:
    QoreClass& operator=(const QoreClass&) = delete;
 
    class qore_class_private* priv;
};
 
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(QoreProgram* pgm, const char* name, const char* path, int64 n_domain = QDOM_DEFAULT);
 
    DLLEXPORT QoreBuiltinClass(const char* name, const char* path, int64 n_domain = QDOM_DEFAULT);
 
    DLLEXPORT QoreBuiltinClass(const QoreBuiltinClass& old);
 
    DLLEXPORT void setModulePublic(bool v);
 
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