Qore dual class implementation (C++/Qore) and calling virtual method from C++ core - qore

Question

I need implement a class QoreFoo in C++ and its dual implementation for Qore script Foo via .qpp. QoreFoo is abstract class providing general API and real functionality is to be added in descendand class (in C++ or Qore). The Foo API calls from core, i.e.C++, need to be propagated to instantiated objects regardless where descendant class is used.
QoreFoo.h
# implement general API
class QoreFoo {
public:
virtual void bar(ExceptionSink *xsink)=0;
};
extern QoreFoo* current_foo;
// just assign instance of a descendant of QoreFoo
void QoreAssignFoo(QoreFoo* n_foo) {
current_foo = n_foo;
}
QoreFoo.cpp
QoreFoo* current_foo = 0;
any.cpp
if (current_foo)
current_foo.bar(xsink); // propagate call via overriden method
When I need implement C++ descendant that is trivial:
QoreFoo2.h
class QoreFoo2: QoreFoo {
void bar(ExceptionSink *xsink) {
# my stuff
printf("Hello World from C++");
}
};
usage.cpp
QoreAssignFoo(new QoreFoo2);
# wait for "Hello World from C++" when core calls current_foo.bar()
.....
But how to do it to propagate call to Qore script class? I think an extra class is needed to call dual class defined in .qpp and overriden in .q
QoreFooHelper.h
class QoreFooHelper: class QoreFoo {
private:
QoreObject* qo;
public:
QoreFooHelper(QoreObject* n_qo): qo(n_qo) {
}
void bar(ExceptionSink *xsink) {
// convert args if any
// call virtual function of Foo class, i.e. qo
qo->evalMethod("bar", 0, xsink);
}
QC_Foo.qpp
# implement assign instance function
nothing assignFoo(*Foo foo) {
QoreAssignFoo(foo->p);
}
#implement class for Qore script
qclass Foo [arg=QoreFooHelper* p]
Foo::constructor() {
assert(self->validInstanceOf(CID_FOO)); // is it correct test to test if inherited from ?
QoreFoo* f = new QoreFooHelper(self);
self->setPrivate(CID_FOO, f);
}
# probably useless as it generates function code
#nothing Foo::bar() {
#}
Test.q
class Foo2 inherits Foo {
nothing bar() {
# my stuff
printf("Hello world from Q");
}
}
Foo2 foo();
assignFoo(foo); # assign instance of Foo2
# wait for "Hello World from Q" message when core calls current_foo.bar()
....
Is this feasible solution or even does exist a better way, e.g. using qpp features or avoiding QoreFooHelper (but I need avoid overhead when fully implemented QoreFoo2 in C++) ?
If not then what is alternative option, e.g. passing callref or closure somehow and do real callback ?
Edit:
When defining Qore class in .qpp then qpp generates class definition QoreClass* initFoo() (add methods, constructors,etc.) and registers it into a namespace repository.
When new QoreObject is to be created then is constructed with QoreClass as parameter found in namespace repo.
.qpp defined constructor normally creates pure C++ QoreFoo instance and assigns as private property (self->setPrivate(CID_FOO, new QoreFoo())), i.e. link from Foo to QoreFoo is established and will be used when defining .qpp methods, where is operating with pure C++ stuff. .qpp generated appropriate C++ code into function "header". self is QoreObject instance.
I think the same is done in runtime for Foo3 script class.
Qpp helps implementing Qore stuff to call C++ stuff.
But I need opposite direction, calling Qore methods from C++, so I think I need call QoreObject::evalMethod(). As QoreObject does not
exist in normal C++ class so extra descendant QoreFooHelper is needed to implement it (with extra problem when passing general objects as parameters).

Answer 1

If the API you want to enforce is a Qore-language class API, then you need to implement your abstract class in Qore and not in C++.
If you have a C++ virtual class hierarchy that should be extended in Qore, then you should use qpp to implement your Qore class in C++ and then allow programmers to extend it naturally by subclassing your classes in Qore.
You can do it like this:
QoreFoo.h
class QoreFoo {
public:
DLLLOCAL QoreFoo(QoreObject* o) : obj(o) {
}
// other functions...
private:
QoreObject* obj; //!< The QoreObject this private data is associated with
};
QC_Foo.qpp
//! This class defines an abstract interface for ...
/**
*/
qclass Foo [arg=QoreFoo* foo; ns=Foo];
//! Constructor
/** Used by subclasses defined in Qore
*/
Foo::constructor() {
self->setPrivate(CID_FOO, new QoreFoo(self));
}
//! a method to ...
/**
*/
abstract nothing Foo::bar();
This allows class Foo to have some private data and an abstract Qore API that can be used by subclasses; subclasses in C++ (implemented with qpp) should declare Foo as a vparent as in the following example:
QoreFoo2.h
#include "qore/intern/QoreFoo.h"
class QoreFoo2 : public QoreFoo {
public:
DLLLOCAL QoreFoo2(QoreObject* o) : QoreFoo(o) {
}
DLLLOCAL void bar(ExceptionSink* xsink) {
printf("Hello World from C++");
}
// other functions...
};
QC_Foo2.qpp
#include "qore/intern/QoreFoo2.h"
//! This class ...
/**
*/
qclass Foo2 [arg=QoreFoo2* foo; ns=Foo; vparent=Foo];
//! Constructor
/** Used by subclasses defined in the Qore programming language.
*/
Foo2::constructor() {
self->setPrivate(CID_FOO2, new QoreFoo2(self));
}
//! a method to ...
/**
*/
nothing Foo2::bar() {
foo->bar();
}
Also the Foo class can be directly subclassed in Qore in the same way:
class Foo3 inherits Foo {
bar() {
print("Hello world from Q");
}
}
EDIT
#TMa if you want to call a Qore-language method from C++, then use QoreObject::evalMethodValue() as already mentioned - you are right that qpp does not generate this code for you.
If you want to make sure that the method is implemented in any Qore-language class that inherits the parent class, then make sure to define an abstract Qore method in your qpp file that defines the parent class.