Access to dynamic types

[phK3]

Disclaimer: This is a cross-post from this topic on the Julia dicourse.

I want to use CxxWrap.jl to create a Julia wrapper for a C++ library.

On the Julia side, I want to dispatch on the type of my arguments.
But when using CxxWrap, the Julia side only seems to know about the static return type (the one in the signature of the C++ function) and not about the dynamic return type (which can be a subtype of the static return type).

Is there a way to expose the dynamic return type to Julia?

Here’s the simplest MWE I could come up with:

// polymorphism.cpp

#include <jlcxx/jlcxx.hpp>
#include <iostream>

struct Parent {
    virtual std::string name() const { return "Parent"; }
    virtual ~Parent() = default;
};

struct DerivedA : public Parent {
    std::string name() const override { return "DerivedA"; }
};

struct DerivedB : public Parent {
    std::string name() const override { return "DerivedB"; }
};


Parent* make_a() { return new DerivedA(); }
Parent* make_b() { return new DerivedB(); }


JLCXX_MODULE define_julia_module(jlcxx::Module& mod)
{
    mod.add_type<Parent>("Parent")
        .method("name", &Parent::name);

    mod.add_type<DerivedA>("DerivedA", jlcxx::julia_base_type<Parent>())
        .method("name", &DerivedA::name);

    mod.add_type<DerivedB>("DerivedB", jlcxx::julia_base_type<Parent>())
        .method("name", &DerivedB::name);

    mod.method("make_a", &make_a);
    mod.method("make_b", &make_b);
}

and on the Julia side

# test.jl

using CxxWrap

@wrapmodule(() -> joinpath(@__DIR__, "build", "libpolymorphism"))

function __init__()
    @initcxx
end


a = make_a()
b = make_b() 

println("Type of a: ", typeof(a))  # CxxPtr{Parent}
println("Type of b: ", typeof(b))  # CxxPtr{Parent}

println("Name from a.name(): ", name(a))  # DerivedA
println("Name from b.name(): ", name(b))  # DerivedB

Ideally, I want typeof(a) to print CxxPtr{DerivedA} (and similarly for b).

Here’s the cmake file, in case you want to build the MWE yourself:

cmake_minimum_required(VERSION 3.10)
project(CxxWrapPolymorphicMWE)

find_package(JlCxx REQUIRED)

add_library(polymorphism SHARED src/polymorphism.cpp)
target_link_libraries(polymorphism PRIVATE JlCxx::cxxwrap_julia)

[barche]

First, you need to make sure the type hierarchy is defined in the jlcxx namespace:

namespace jlcxx
{
  template<> struct SuperType<DerivedA> { typedef Parent type; };
  template<> struct SuperType<DerivedB> { typedef Parent type; };
}

Then, in Julia checking the type works much like in C++, but using convert instead of dynamic_cast and then checking if the result is null:

julia> a = make_a()
CxxPtr{Parent}(Ptr{Parent}(0x00007f7ac6869310))

julia> b = make_b()
CxxPtr{Parent}(Ptr{Parent}(0x00007f7ac686c1d0))

julia> convert(CxxPtr{DerivedA}, a)
CxxPtr{DerivedA}(Ptr{DerivedA}(0x00007f7ac6869310))

julia> convert(CxxPtr{DerivedB}, a)
CxxPtr{DerivedB}(Ptr{DerivedB}(0x0000000000000000))

julia> convert(CxxPtr{DerivedB}, b)
CxxPtr{DerivedB}(Ptr{DerivedB}(0x00007f7ac686c1d0))

[phK3]

Thanks for your answer - the conversion works!

If I have a vector of Parent

l = [make_a(), make_b()]

(and let's say I don't create this vector myself in Julia, but calling some function on the C++ side returns it)
is it the best way to just manually convert each element in the list based on something like the name() function?

l2 = map(x -> name(x) == "DerivedA" ? convert(CxxPtr{DerivedA}, x) : convert(CxxPtr{DerivedB}, x), l)
#2-element Vector{CxxPtr}:
# CxxPtr{DerivedA}(Ptr{DerivedA} @0x000000001657bec0)
# CxxPtr{DerivedB}(Ptr{DerivedB} @0x0000000013df76b0)

Or is there a better approach?

[barche]

To be sure, you would have to check the timing, but i think using convert and checking if the pointer is C_NULL is for sure more robust and probably faster.

[phK3]

Thanks for your reply!

Checking for the null pointer seems to be much faster than checking for a string value (results may differ for other attributes).

Here are the corresponding conversion functions:

f_string(x) = begin
           if name(x) == "DerivedA"
               convert(CxxPtr{DerivedA}, x)
           else
               convert(CxxPtr{DerivedB}, x)
           end
end

f_null(x) = begin
           ptr = convert(CxxPtr{DerivedA}, x)
           if ptr == C_NULL
               ptr = convert(CxxPtr{DerivedB}, x)
           end
           ptr
end

And the result for the timing

l = [ifelse(rand() > 0.5, make_a(), make_b()) for i in 1:100];

@benchmark f_string.($l)
BenchmarkTools.Trial: 10000 samples with 1 evaluation per sample.
 Range (min … max):  28.408 μs …  22.821 ms  ┊ GC (min … max): 0.00% … 47.59%
 Time  (median):     29.801 μs               ┊ GC (median):    0.00%
 Time  (mean ± σ):   34.616 μs ± 318.241 μs  ┊ GC (mean ± σ):  6.30% ±  0.68%

    ▆█▆▄▃▂    ▃▅▄▁                                              
  ▂▆███████▆▆▇████▆▅▃▃▅▇███▆▅▄▃▃▃▃▃▂▂▂▂▂▂▂▂▂▂▂▁▂▁▁▁▁▁▁▁▁▁▁▁▁▁▁ ▃
  28.4 μs         Histogram: frequency by time         34.8 μs <

 Memory estimate: 8.06 KiB, allocs estimate: 304.


@benchmark f_null.($l)
BenchmarkTools.Trial: 10000 samples with 4 evaluations per sample.
 Range (min … max):  7.118 μs … 283.916 μs  ┊ GC (min … max): 0.00% … 95.28%
 Time  (median):     7.270 μs               ┊ GC (median):    0.00%
 Time  (mean ± σ):   7.418 μs ±   3.576 μs  ┊ GC (mean ± σ):  0.66% ±  1.34%

   ▂▅▇███▇▆▅▄▃▂▂▁  ▁▁               ▁        ▁                ▂
  ▇████████████████████▇▇▆▇▇▆▄▅▂▆▇████▇▆▅▆▇██████▇▆▇▅▅▅▆▅▅▅▅▆ █
  7.12 μs      Histogram: log(frequency) by time      8.57 μs <

 Memory estimate: 3.38 KiB, allocs estimate: 104.

Since this fixes my problem, I'm closing the issue.

[phK3]

Sorry I have to re-open this - but this does not seem to work for const pointers.

Just add the following methods to the example above

const Parent* make_const_a() { return new const DerivedA(); }
const Parent* make_const_b() { return new const DerivedB(); }

const DerivedA* asDerivedA(const Parent* p) {
    return dynamic_cast<const DerivedA*>(p);
}

const DerivedB* asDerivedB(const Parent* p) {
    return dynamic_cast<const DerivedB*>(p);
}

Then just using Julia's convert throws the following error:

a_const = make_const_a()
# ConstCxxPtr{Parent}(Ptr{Parent} @0x000000001ecc49f0)

convert(ConstCxxPtr{DerivedA}, a_const)
#ERROR: MethodError: Cannot `convert` an object of type 
#  ConstCxxPtr{Parent} to an object of type 
#  ConstCxxPtr{DerivedA}
#The function `convert` exists, but no method is defined for this combination of argument types.
# ...

I could add code for the conversion on the C++ side using

const DerivedA* asDerivedA(const Parent* p) {
    return dynamic_cast<const DerivedA*>(p);
}

const DerivedB* asDerivedB(const Parent* p) {
    return dynamic_cast<const DerivedB*>(p);
}

But is this the best solution?

[barche]

It seems the merging of the PR auto-closed this. Can you check with the main branch if it is solved for you now?

[phK3]

Yes, it works.

Thank you!