A type with template of a template as a base class isn't generated

[domcir]

Hi

I've been trying to use a template whcih inherits from a templatted classes from boost but it's not recognised by the javactp tool at all and a corresponding class isn't generated in Java. The class MyTemplate2 is recognised in the java file but isn't generated in jni at all.

Let me know if you need any additional details.

Thanks
Dominik

The following class is extracted:

class MessageClass{
private:
        int _number{0};
        A _a{A(0)};
    public:
        int i1{0};
        MessageClass(int i); // { this->_number=i; }
        int getNumber() { return this->_number; }
        A getA() { return this->_a; }
        SafeValue2<C, double, SafeValueInitializer<C,double>,  SafeValueComparators<double>> getSafeValue2() { return SafeValue2<C, double, SafeValueInitializer<C,double>,  SafeValueComparators<double>>{1.0}; }
};

The type declaration:

template<
            class Tag,
            class Storage,
            class Initializer,
            class Comparators
        >
        struct SafeValue2 : private boost::totally_ordered1<
								SafeValue2<
							   		Tag,
								 	Storage,
									Initializer,
									Comparators
								>,
                               boost::equality_comparable<
							   		SafeValue2<
										Tag,
										Storage,
										Initializer,
										Comparators
									>,
								bool>
							>
        {
            using storage_type     = Storage;
            using initializer_type = Initializer;
            using comparator_type  = Comparators;
            constexpr explicit SafeValue2(storage_type k111):
                m_val{initializer_type()(k111)}
            {
            }

            constexpr SafeValue2() : m_val{initializer_type()}
            {
            }

            constexpr explicit operator storage_type() const
            {
                return this->val();
            }
            constexpr bool operator==(SafeValue2 rhs) const noexcept
            {
                return comparator_type::equal_to(m_val, rhs.m_val);
            }
            constexpr bool operator==(bool rhs) const noexcept { return this->operator bool() == rhs; }

            constexpr bool operator<(SafeValue2 v) const noexcept { return comparator_type::less(m_val, v.m_val); }
            constexpr storage_type val() const
            {
                return initializer_type::access(m_val);
            }
            constexpr explicit operator bool() const noexcept { return !initializer_type::is_null(m_val); }
            constexpr bool     operator!() const noexcept { return !(this->operator bool()); }

          private:
            storage_type m_val;
        };

With Configuration

public class MessageConfig implements InfoMapper {
    public void map(InfoMap infoMap) {

        .put(new Info("MyTemplate<double>").pointerTypes("MyTemplateDouble"))
        .put(new Info("MyTemplate<int>").pointerTypes("MyTemplateInt"))
        .put(new Info("SafeValue<C,int>").pointerTypes("MyTemplateSafeValue"))
        .put(new Info("MyTemplate2<int,TestUsing>").pointerTypes("MyTemplate2").define())
        .put(new Info("SafeValue2<C, double, SafeValueInitializer<C,double>, SafeValueComparators<double> >").pointerTypes("SF").define())
        ;
    }
}

[domcir]

The formatting of the code doesn't work correctly...

[saudet]

Things like boost::totally_ordered1 and boost::equality_comparable are going to be hard to support, but you can skip over them if you don't particularly need to map them. Other than that, you'll need to be careful about the white spaces in the names you pass to Info:
https://github.com/bytedeco/javacpp/wiki/Mapping-Recipes#creating-instances-of-c-templates

[domcir]

Hi

I managed to isolate my issue to this:

namespace NA{
    namespace NB{
        namespace NT{
            class mytype{
            };
        }
        enum class MyEnumType
        {
            UNKNOWN=0, //Unknown
            TEST=1, //Call
        };
        template<class T, class K, class J = int>
        class MyClass{
            private:
                T _m;
                K _k;
                J _j;
        };
        
    }
}

namespace NA{
    namespace NC{
        using MyEnumType = NB::MyEnumType;
        using MyType = NB::MyClass<NB::NT::mytype, double>;
        class CB{
            public:
                int a{0};
                MyEnumType _mt;
                CB(int i, MyEnumType mt) : a(i), _mt(mt) { }
        };
        class CC{
            public:
                MyType _mc;
                CC(MyType mc) : _mc(mc) { }
        };
    }
}

with the definition as:
.put(new Info("NA::NB::MyEnumType").enumerate().javaNames("MyEnumType"))
.put(new Info("NA::NB::MyClass<NT::mytype, double>").pointerTypes("MyType").define())

The MyEnumType isn't recognised correctly. It's seen by Java as NA::NB::MyEnumType and NA::NC::MyEnumType.
I've been observing the same behaviour to some of my template classes but I couldn't reproduce it with a simple example.
Also how could I hide the java class of "mytype" as it doesn't do much and it shouldn't be exposed to Java. Do I need to remove it to a separate header file or can I use some kind of ignore\skip function.

Thanks,
Dominik

[domcir]

Hi

For ignoring the mytype defintiion I can use https://github.com/bytedeco/javacpp/wiki/Mapping-Recipes#skipping-lines-from-header-files.

I still think there is an issue with the naminspaces for MyEnumType.

Thanks
Dominik

[saudet]

With complicated namespaces like that, we sometimes need to be redundant. Something like this should work:

   .put(new Info("NA::NB::MyEnumType", "NA::NC::MyEnumType", "MyEnumType").enumerate().javaNames("MyEnumType"))

[saudet]

Is all this working for your use case? Or is there still a problem?

[domcir]

With complicated namespaces like that, we sometimes need to be redundant. Something like this should work:

   .put(new Info("NA::NB::MyEnumType", "NA::NC::MyEnumType", "MyEnumType").enumerate().javaNames("MyEnumType"))

this one did the trick, thank you!

[domcir]

Is all this working for your use case? Or is there still a problem?

Yes all good, thanks!