Added the Julia support for the StdDequeIterator

.github/workflows/test-linux-mac.yml

@@ -0,0 +1,67 @@
+name: test-linux-mac
+on:
+  push:
+    branches-ignore:
+      - prerelease
+  pull_request:
+    branches-ignore:
+      - prerelease
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  test:
+    name: Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ matrix.arch }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        version:
+          - "1.6"
+          - "1.10"
+          - "nightly"
+        os:
+          - macos-13
+          - ubuntu-latest
+        arch:
+          - x64
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: julia-actions/setup-julia@latest
+        with:
+          version: ${{ matrix.version }}
+          arch: ${{ matrix.arch }}
+      - name: Build libcxxwrap
+        continue-on-error: true
+        run: |
+          mkdir libcxxwrap && cd libcxxwrap
+
+          body="${{github.event.pull_request.body}}"
+          first_line=$(echo "$body" | sed -n '1p')
+          if [[ "$first_line" == *"#"* ]]; then
+            IFS='#' read -r left right <<< "$first_line"
+
+            repo_url=$(echo "$left" | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//')
+            branch=$(echo "$right" | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//')
+          else
+            repo_url="$first_line"
+            branch="main"
+          fi
+          echo "repo_url: '$repo_url'"
+          echo "branch: '$branch'"
+          git clone --branch "$branch" --single-branch "$repo_url" .
+          echo "done cloning"
+
+          if [[ "$OSTYPE" != "darwin"* ]]; then
+            rm -f /opt/hostedtoolcache/julia/1.6*/x64/lib/julia/libstdc++.so.6
+          fi
+          mkdir build && cd build
+          cmake -DCMAKE_INSTALL_PREFIX=$HOME/install -DAPPEND_OVERRIDES_TOML=ON -DOVERRIDE_VERSION_TO_JLL=ON -DCMAKE_BUILD_TYPE=Debug ..
+          VERBOSE=ON cmake --build . --config Debug --target install
+          cd ../..
+      - uses: julia-actions/julia-buildpkg@latest
+      - uses: julia-actions/julia-runtest@latest

.github/workflows/test-win.yml

@@ -0,0 +1,76 @@
+name: test-win
+on:
+  push:
+    branches-ignore:
+      - prerelease
+  pull_request:
+    branches-ignore:
+      - prerelease
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  test:
+    name: Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ matrix.arch }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        version:
+          - "1.7"
+          - "1.10"
+          - "nightly"
+        os:
+          - windows-latest
+        arch:
+          - x64
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: julia-actions/setup-julia@latest
+        with:
+          version: ${{ matrix.version }}
+          arch: ${{ matrix.arch }}
+      - name: Clone libcxxwrap
+        continue-on-error: true
+        run: |
+          mkdir libcxxwrap && cd libcxxwrap
+
+          body="${{github.event.pull_request.body}}"
+          first_line=$(echo "$body" | sed -n '1p')
+          if [[ "$first_line" == *"#"* ]]; then
+            IFS='#' read -r left right <<< "$first_line"
+
+            repo_url=$(echo "$left" | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//')
+            branch=$(echo "$right" | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//')
+          else
+            repo_url="$first_line"
+            branch="main"
+          fi
+          echo "repo_url: '$repo_url'"
+          echo "branch: '$branch'"
+          git clone --branch "$branch" --single-branch "$repo_url" .
+          echo "done cloning"
+      - name: Config 32bit
+        continue-on-error: true
+        if: ${{ matrix.arch == 'x86'}}
+        run: |
+          cd libcxxwrap && mkdir build && cd build
+          cmake -G "Visual Studio 17 2022" -A Win32 -DOVERRIDES_PATH=$HOMEDRIVE/$HOMEPATH/.julia/artifacts/Overrides.toml -DOVERRIDE_ROOT=./ -DAPPEND_OVERRIDES_TOML=ON ..
+      - name: Config 64bit
+        continue-on-error: true
+        if: ${{ matrix.arch == 'x64'}}
+        run: |
+          cd libcxxwrap && mkdir build && cd build
+          cmake -G "Visual Studio 17 2022" -A x64 -DOVERRIDES_PATH=$HOMEDRIVE/$HOMEPATH/.julia/artifacts/Overrides.toml -DOVERRIDE_ROOT=./ -DAPPEND_OVERRIDES_TOML=ON ..
+      - name: Build libcxxwrap
+        continue-on-error: true
+        run: |
+          cd libcxxwrap/build
+          cmake --build . --config Release
+
+      - uses: julia-actions/julia-buildpkg@latest
+      - uses: julia-actions/julia-runtest@latest

Project.toml

@@ -1,7 +1,7 @@
 name = "CxxWrap"
 uuid = "1f15a43c-97ca-5a2a-ae31-89f07a497df4"
 authors = ["Bart Janssens <[email protected]>"]
-version = "0.14.0"
+version = "0.15.1"
 
 [deps]
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
@@ -11,7 +11,7 @@ libcxxwrap_julia_jll = "3eaa8342-bff7-56a5-9981-c04077f7cee7"
 [compat]
 MacroTools = "0.5.9"
 julia = "1.6"
-libcxxwrap_julia_jll = "0.11.0"
+libcxxwrap_julia_jll = "0.12.3"
 
 [extras]
 BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"

README.md

@@ -1,7 +1,5 @@
 # CxxWrap
 
-![test](https://github.com/JuliaInterop/CxxWrap.jl/workflows/test/badge.svg)
-
 This package aims to provide a Boost.Python-like wrapping for C++ types and functions to Julia.
 The idea is to write the code for the Julia wrapper in C++, and then use a one-liner on the Julia side to make the wrapped C++ library available there.
 
@@ -179,11 +177,11 @@ CppTypes.set(w, "hello")
 ```
 
 The manually added constructor using the `constructor` function also creates a finalizer.
-This can be disabled by adding the argument `false`:
+This can be disabled by adding the argument `jlcxx::finalize_policy::no`:
 
 ```c++
 types.add_type<World>("World")
-  .constructor<const std::string&>(false);
+  .constructor<const std::string&>(jlcxx::finalize_policy::no);
 ```
 
 The `add_type` function actually builds two Julia types related to `World`.
@@ -296,6 +294,29 @@ auto multi_vector_base = mod.add_type<Parametric<TypeVar<1>>>("MultiVectorBase")
 auto vector_base = mod.add_type<Parametric<TypeVar<1>>>("VectorBase", multi_vector_base.dt());
 ```
 
+### Conversion
+
+Conversion to the base type happens automatically, or can be forced by calling convert, e.g.
+
+```julia
+convert(A,b)
+```
+
+Where we have `b::B` and `B <: A`
+
+For the equivalent of a C++ `dynamic_cast`, we need to use pointers because the conversion may fail, i.e:
+
+```julia
+convert(CxxPtr{B},CxxPtr(a))
+```
+
+This is equivalent to the C++ code:
+```c++
+dynamic_cast<B*>(&a);
+```
+
+Use `isnull` on the result to check if the conversion was successful or not.
+
 See the test at [`examples/inheritance.cpp`](https://github.com/JuliaInterop/libcxxwrap-julia/tree/master/examples/inheritance.cpp) and [`test/inheritance.jl`](test/inheritance.jl).
 
 ## Enum types
@@ -385,7 +406,8 @@ There is also an `apply_combination` method to make applying all combinations of
 
 Full example and test including non-type parameters at: [`examples/parametric.cpp`](https://github.com/JuliaInterop/libcxxwrap-julia/tree/master/examples/parametric.cpp) and [`test/parametric.jl`](test/parametric.jl).
 
-## Constructors and destructors
+## Memory management
+### Constructors and destructors
 
 The default constructor and any manually added constructor using the `constructor` function will automatically create a Julia object that has a finalizer attached that calls delete to free the memory.
 To write a C++ function that returns a new object that can be garbage-collected in Julia, use the `jlcxx::create` function:
@@ -405,6 +427,13 @@ wvec = cpp_function_returning_vector()
 julia_array = copy.(wvec)
 ```
 
+### Return values
+If a wrapped C++ function returns an object by value, the wrapped object gets a finalizer
+and is owned by Julia. The same holds if a smart pointer such as `shared_ptr` (automatically
+wrapped in a `SharedPtr`) is returned by value. In contrast to that, if a reference or raw
+pointer is returned from C++, then the default assumption is that the pointed-to object
+lifetime is managed by C++.
+
 ## Call operator overload
 
 Since Julia supports overloading the function call operator `()`, this can be used to wrap `operator()` by just omitting the method name:
@@ -648,10 +677,10 @@ The behavior of the macro can be customized by adding methods to `CxxWrap.refere
 ## Exceptions
 
 When directly adding a regular free C++ function as a method, it will be called directly using `ccall` and any exception will abort the Julia program.
-To avoid this, you can force wrapping it in an `std::function` to intercept the exception automatically by setting the `force_convert` argument to `method` to true:
+To avoid this, you can force wrapping it in an `std::function` to intercept the exception automatically by setting the `jlcxx::calling_policy` argument to `std_function`:
 
 ```c++
-mod.method("test_exception", test_exception, true);
+mod.method("test_exception", test_exception, jlcxx::calling_policy::std_function);
 ```
 
 Member functions and lambdas are automatically wrapped in an `std::function` and so any exceptions thrown there are always intercepted and converted to a Julia exception.
@@ -902,6 +931,10 @@ mod.method("getSecondaryWorldVector", [](const World* p)->const std::vector<Worl
 
 Linking wrappers using STL support requires adding `JlCxx::cxxwrap_julia_stl` to the `target_link_libraries` command in `CMakeLists.txt`.
 
+### Working with `StdString`
+
+The `StdString` implements the Julia string interface and interprets `std::string` data as UTF-8 data. Since C++ strings do not require the use of the null-character to denote the end of a string the `StdString` constructors usually rely on the `ncodeunits` to determin the size of the string. When constructing a `StdString` from a `Cstring`, `Base.CodeUnits`, or `Vector{UInt8}` the first null-character present will denote the end of the string.
+
 ## Release procedure
 
 Often, new releases of `CxxWrap` also require a new release of the C++ component `libcxxwrap-julia`, and a rebuild of its JLL package. To make sure everything is tested properly, the following procedure should be followed for each release that requires changing both the Julia and the C++ component:
@@ -964,6 +997,10 @@ Often, new releases of `CxxWrap` also require a new release of the C++ component
 ## Breaking changes in v0.13
 * Automatic dereferencing of smart pointers was removed, so some code may require adding the dereferencing operator `[]` explicitly. See [PR #338](https://github.com/JuliaInterop/CxxWrap.jl/pull/338).
 
+## Breaking changes in v0.15
+* This release is based on `libcxxwrap-julia` 0.12, which is binary incompatible with previous versions, so JLLs should be rebuilt to use CxxWrap 0.15
+* The `constructor` method now takes a `jlcxx::finalize_policy` instead of a `bool`, e.g. `.constructor<Foo>(false)` becomes `.constructor<Foo>(jlcxx::finalize_policy::no)`
+
 ## References
 * [JuliaCon 2020 Talk: Julia and C++: a technical overview of CxxWrap.jl](https://www.youtube.com/watch?v=u7IaXwKSUU0)
 * [JuliaCon 2020 Workshop: Wrapping a C++ library using CxxWrap.jl](https://www.youtube.com/watch?v=VoXmXtqLhdo)