[Pytorch] New version of the presets

pytorch/src/gen/java/org/bytedeco/pytorch/BlockArrayRef.java

@@ -41,8 +41,7 @@ public class BlockArrayRef extends Pointer {
 
   /** Construct an ArrayRef from a single element. */
   // TODO Make this explicit
-  public BlockArrayRef(@ByPtrRef Block OneElt) { super((Pointer)null); allocate(OneElt); }
-  private native void allocate(@ByPtrRef Block OneElt);
+
 
   /** Construct an ArrayRef from a pointer and length. */
   public BlockArrayRef(@Cast("torch::jit::Block**") PointerPointer data, @Cast("size_t") long length) { super((Pointer)null); allocate(data, length); }

pytorch/src/gen/java/org/bytedeco/pytorch/DimnameArrayRef.java

@@ -59,6 +59,8 @@ public class DimnameArrayRef extends Pointer {
   // The enable_if stuff here makes sure that this isn't used for
   // std::vector<bool>, because ArrayRef can't work on a std::vector<bool>
   // bitfield.
+  public DimnameArrayRef(@ByRef DimnameVector vec) { super((Pointer)null); allocate(vec); }
+  private native void allocate(@ByRef DimnameVector vec);
 
   /** Construct an ArrayRef from a std::array */
 

pytorch/src/gen/java/org/bytedeco/pytorch/DoubleArrayRef.java

@@ -67,6 +67,8 @@ public class DoubleArrayRef extends Pointer {
   // The enable_if stuff here makes sure that this isn't used for
   // std::vector<bool>, because ArrayRef can't work on a std::vector<bool>
   // bitfield.
+  public DoubleArrayRef(@ByRef DoubleVector vec) { super((Pointer)null); allocate(vec); }
+  private native void allocate(@ByRef DoubleVector vec);
 
   /** Construct an ArrayRef from a std::array */
 

pytorch/src/gen/java/org/bytedeco/pytorch/IValueArrayRef.java

@@ -59,6 +59,8 @@ public class IValueArrayRef extends Pointer {
   // The enable_if stuff here makes sure that this isn't used for
   // std::vector<bool>, because ArrayRef can't work on a std::vector<bool>
   // bitfield.
+  public IValueArrayRef(@ByRef IValueVector vec) { super((Pointer)null); allocate(vec); }
+  private native void allocate(@ByRef IValueVector vec);
 
   /** Construct an ArrayRef from a std::array */
 

pytorch/src/gen/java/org/bytedeco/pytorch/LongArrayRef.java

@@ -67,6 +67,8 @@ public class LongArrayRef extends Pointer {
   // The enable_if stuff here makes sure that this isn't used for
   // std::vector<bool>, because ArrayRef can't work on a std::vector<bool>
   // bitfield.
+  public LongArrayRef(@ByRef LongVector vec) { super((Pointer)null); allocate(vec); }
+  private native void allocate(@ByRef LongVector vec);
 
   /** Construct an ArrayRef from a std::array */
 

pytorch/src/gen/java/org/bytedeco/pytorch/SavedVariableArrayRef.java

@@ -59,6 +59,8 @@ public class SavedVariableArrayRef extends Pointer {
   // The enable_if stuff here makes sure that this isn't used for
   // std::vector<bool>, because ArrayRef can't work on a std::vector<bool>
   // bitfield.
+  public SavedVariableArrayRef(@ByRef SavedVariableVector vec) { super((Pointer)null); allocate(vec); }
+  private native void allocate(@ByRef SavedVariableVector vec);
 
   /** Construct an ArrayRef from a std::array */
 

pytorch/src/gen/java/org/bytedeco/pytorch/ScalarTypeArrayRef.java

@@ -59,6 +59,8 @@ public class ScalarTypeArrayRef extends Pointer {
   // The enable_if stuff here makes sure that this isn't used for
   // std::vector<bool>, because ArrayRef can't work on a std::vector<bool>
   // bitfield.
+  public ScalarTypeArrayRef(@ByRef ScalarTypeVector vec) { super((Pointer)null); allocate(vec); }
+  private native void allocate(@ByRef ScalarTypeVector vec);
 
   /** Construct an ArrayRef from a std::array */
 

pytorch/src/gen/java/org/bytedeco/pytorch/SizeTArrayRef.java

@@ -59,6 +59,8 @@ public class SizeTArrayRef extends Pointer {
   // The enable_if stuff here makes sure that this isn't used for
   // std::vector<bool>, because ArrayRef can't work on a std::vector<bool>
   // bitfield.
+  public SizeTArrayRef(@ByRef SizeTVector vec) { super((Pointer)null); allocate(vec); }
+  private native void allocate(@ByRef SizeTVector vec);
 
   /** Construct an ArrayRef from a std::array */
 

pytorch/src/gen/java/org/bytedeco/pytorch/StrideArrayRef.java

@@ -59,6 +59,8 @@ public class StrideArrayRef extends Pointer {
   // The enable_if stuff here makes sure that this isn't used for
   // std::vector<bool>, because ArrayRef can't work on a std::vector<bool>
   // bitfield.
+  public StrideArrayRef(@ByRef StrideVector vec) { super((Pointer)null); allocate(vec); }
+  private native void allocate(@ByRef StrideVector vec);
 
   /** Construct an ArrayRef from a std::array */
 

pytorch/src/gen/java/org/bytedeco/pytorch/StringArrayRef.java

@@ -59,6 +59,8 @@ public class StringArrayRef extends Pointer {
   // The enable_if stuff here makes sure that this isn't used for
   // std::vector<bool>, because ArrayRef can't work on a std::vector<bool>
   // bitfield.
+  public StringArrayRef(@ByRef StringVector vec) { super((Pointer)null); allocate(vec); }
+  private native void allocate(@ByRef StringVector vec);
 
   /** Construct an ArrayRef from a std::array */
 

pytorch/src/gen/java/org/bytedeco/pytorch/SymIntArrayRef.java

@@ -59,6 +59,8 @@ public class SymIntArrayRef extends Pointer {
   // The enable_if stuff here makes sure that this isn't used for
   // std::vector<bool>, because ArrayRef can't work on a std::vector<bool>
   // bitfield.
+  public SymIntArrayRef(@ByRef SymIntVector vec) { super((Pointer)null); allocate(vec); }
+  private native void allocate(@ByRef SymIntVector vec);
 
   /** Construct an ArrayRef from a std::array */
 

pytorch/src/gen/java/org/bytedeco/pytorch/SymbolArrayRef.java

@@ -59,6 +59,8 @@ public class SymbolArrayRef extends Pointer {
   // The enable_if stuff here makes sure that this isn't used for
   // std::vector<bool>, because ArrayRef can't work on a std::vector<bool>
   // bitfield.
+  public SymbolArrayRef(@ByRef SymbolVector vec) { super((Pointer)null); allocate(vec); }
+  private native void allocate(@ByRef SymbolVector vec);
 
   /** Construct an ArrayRef from a std::array */
 

pytorch/src/gen/java/org/bytedeco/pytorch/TensorArrayRef.java

@@ -59,6 +59,8 @@ public class TensorArrayRef extends Pointer {
   // The enable_if stuff here makes sure that this isn't used for
   // std::vector<bool>, because ArrayRef can't work on a std::vector<bool>
   // bitfield.
+  public TensorArrayRef(@ByRef TensorVector vec) { super((Pointer)null); allocate(vec); }
+  private native void allocate(@ByRef TensorVector vec);
 
   /** Construct an ArrayRef from a std::array */
 

pytorch/src/gen/java/org/bytedeco/pytorch/TensorIndexArrayRef.java

@@ -59,12 +59,12 @@ public class TensorIndexArrayRef extends Pointer {
   // The enable_if stuff here makes sure that this isn't used for
   // std::vector<bool>, because ArrayRef can't work on a std::vector<bool>
   // bitfield.
-  public TensorIndexArrayRef(@ByRef TensorIndexVector Vec) { super((Pointer)null); allocate(Vec); }
-  private native void allocate(@ByRef TensorIndexVector Vec);
 
   /** Construct an ArrayRef from a std::array */
 
   /** Construct an ArrayRef from a C array. */
+  public TensorIndexArrayRef(@ByRef TensorIndexVector vec) { super((Pointer)null); allocate(vec); }
+  private native void allocate(@ByRef TensorIndexVector vec);
 
   /** Construct an ArrayRef from a std::initializer_list. */
   /* implicit */

pytorch/src/gen/java/org/bytedeco/pytorch/TypeArrayRef.java

@@ -59,6 +59,8 @@ public class TypeArrayRef extends Pointer {
   // The enable_if stuff here makes sure that this isn't used for
   // std::vector<bool>, because ArrayRef can't work on a std::vector<bool>
   // bitfield.
+  public TypeArrayRef(@ByRef TypeVector vec) { super((Pointer)null); allocate(vec); }
+  private native void allocate(@ByRef TypeVector vec);
 
   /** Construct an ArrayRef from a std::array */
 

pytorch/src/gen/java/org/bytedeco/pytorch/ValueArrayRef.java

@@ -41,8 +41,7 @@ public class ValueArrayRef extends Pointer {
 
   /** Construct an ArrayRef from a single element. */
   // TODO Make this explicit
-  public ValueArrayRef(@ByPtrRef Value OneElt) { super((Pointer)null); allocate(OneElt); }
-  private native void allocate(@ByPtrRef Value OneElt);
+
 
   /** Construct an ArrayRef from a pointer and length. */
   public ValueArrayRef(@Cast("torch::jit::Value**") PointerPointer data, @Cast("size_t") long length) { super((Pointer)null); allocate(data, length); }
@@ -64,6 +63,8 @@ public class ValueArrayRef extends Pointer {
   // The enable_if stuff here makes sure that this isn't used for
   // std::vector<bool>, because ArrayRef can't work on a std::vector<bool>
   // bitfield.
+  public ValueArrayRef(@ByRef ValueVector vec) { super((Pointer)null); allocate(vec); }
+  private native void allocate(@ByRef ValueVector vec);
 
   /** Construct an ArrayRef from a std::array */
 

pytorch/src/gen/java/org/bytedeco/pytorch/global/torch.java

@@ -5672,7 +5672,7 @@ public class torch extends org.bytedeco.pytorch.presets.torch {
 @Namespace("ska::detailv3") @MemberGetter public static native byte min_lookups();
 public static final byte min_lookups = min_lookups();
 
-
+@Namespace("ska::detailv3") public static native byte log2(@Cast("uint64_t") long value);
 
 @Namespace("ska::detailv3") public static native @Cast("uint64_t") long next_power_of_two(@Cast("uint64_t") long i);
 

pytorch/src/main/java/org/bytedeco/pytorch/presets/torch.java

@@ -749,16 +749,6 @@ public void map(InfoMap infoMap) {
         )).put(new Info("c10::ArrayRef<at::Tag>::vec()").skip() // Is there any way to make this work ?
         );
 
-        infoMap
-            .put(new Info("c10::ArrayRef<torch::Tensor>(std::vector<torch::Tensor,A>&)").javaText(
-                "public TensorArrayRef(@ByRef TensorVector Vec) { super((Pointer)null); allocate(Vec); }\n"
-                + "private native void allocate(@ByRef TensorVector Vec);"))
-
-            .put(new Info("c10::ArrayRef<at::indexing::TensorIndex>(std::vector<at::indexing::TensorIndex,A>&)").javaText(
-                "public TensorIndexArrayRef(@ByRef TensorIndexVector Vec) { super((Pointer)null); allocate(Vec); }\n"
-                + "private native void allocate(@ByRef TensorIndexVector Vec);"))
-        ;
-
 
         //// c10::List
         for (ArrayInfo ai : new ArrayInfo[]{
@@ -948,7 +938,7 @@ public void map(InfoMap infoMap) {
         }) {
             infoMap.put(new Info(template("torch::jit::List", t[1])).pointerTypes(t[0]))
                    .put(new Info(template("torch::jit::ListIterator", t[1])).pointerTypes(t[0] + "Iterator"))
-                   .put(new Info(template("torch::jit::List", t[1]) + "::map").skip()); // Could map if needed
+                   .put(new Info(template("torch::jit::List", t[1]) + "::map").skip()) // Could map if needed
             ;
         }
         infoMap.put(new Info("torch::jit::TreeList::const_iterator").cast().pointerTypes("TreeRef"));
@@ -1843,7 +1833,8 @@ We need either to put an annotation info on each member, or javaName("@NoOffset
             // are parsed after complex_math.h and Parser would set the qualified names to the first
             // matching cppName it finds in infoMap.
         }
-        infoMap.put(new Info("c10_complex_math::pow(c10::complex<T>&, c10::complex<U>&)").javaText(
+        infoMap.put(new Info("ska::detailv3::log2").javaNames("log2")) // Same reason
+               .put(new Info("c10_complex_math::pow(c10::complex<T>&, c10::complex<U>&)").javaText(
                    "@Namespace(\"c10_complex_math\") public static native @ByVal @Name(\"pow<double,float>\") DoubleComplex pow(@Const @ByRef DoubleComplex x, @Const @ByRef FloatComplex y);\n"
                    + "@Namespace(\"c10_complex_math\") public static native @ByVal @Name(\"pow<float,double>\") DoubleComplex pow(@Const @ByRef FloatComplex x, @Const @ByRef DoubleComplex y);\n"
                ))
@@ -2327,7 +2318,8 @@ void mapArrayRef(InfoMap infoMap) {
                 String mainName = cppNames[n++] = template("c10::ArrayRef", vt);
                 cppNames[n++] = template("at::ArrayRef", vt);
                 cppNames[n++] = template("torch::ArrayRef", vt);
-                infoMap.put(new Info(mainName + "(const " + vt + "&)").skip());// Causes SIGSEGV since it just make a pointer to the value
+                infoMap.put(new Info(mainName + "(const " + vt + "&)").skip())// Causes SIGSEGV since it just make a pointer to the value
+                       .put(new Info(mainName + "(" + vt + "&)").skip());// Parser removes const for non-investigated reasons for some elementTypes (eg Block*)
                 // With the following info, any operator<<
                 //infoMap.put(new Info(template("c10::operator <<", vt)).javaNames("shiftLeft"));
             }
@@ -2359,6 +2351,14 @@ void mapArrayRef(InfoMap infoMap) {
             infoMap.put(info);
             infoMap.put(new Info(cppNamesRIterator).skip());
 
+            // Add templated constructor taking a std::vector, if the vector class has been mapped.
+            // Relies on the fact that std::vector info are created before.
+            Info vectorInfo = infoMap.getFirst(template("std::vector", elementTypes[0]), false);
+            if (vectorInfo != null && !elementTypes[0].equals("bool"))
+                infoMap.put(new Info(template(cppNames[0], template("std::allocator", elementTypes[0])) + "(" + elementTypes[0] + "*)")
+                    .javaText(
+                        "public " + baseJavaName + "ArrayRef(@ByRef " + baseJavaName + "Vector vec) { super((Pointer)null); allocate(vec); }\n"
+                        + "private native void allocate(@ByRef " + baseJavaName + "Vector vec);"));
         }
 
         void mapList(InfoMap infoMap) {