jni_util.hpp File Reference

#include <jni.h>
#include <concepts>
#include <queue>
#include <span>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
#include "wpi/util/ConvertUTF.hpp"
#include "wpi/util/SafeThread.hpp"
#include "wpi/util/SmallString.hpp"
#include "wpi/util/SmallVector.hpp"
#include "wpi/util/StringExtras.hpp"
#include "wpi/util/mutex.hpp"
#include "wpi/util/print.hpp"
#include "wpi/util/raw_ostream.hpp"
#include "wpi/util/string.hpp"

Go to the source code of this file.

Classes
class	wpi::util::java::JClass
	Finds a class and keeps it as a global reference. More...
struct	wpi::util::java::JClassInit
class	wpi::util::java::JGlobal< T >
class	wpi::util::java::JLocal< T >
	Container class for cleaning up Java local references. More...
class	wpi::util::java::JStringRef
	Java string (jstring) reference. More...
struct	wpi::util::java::detail::ArrayHelper< T >
struct	wpi::util::java::detail::copy_cv< CvSrc, Dest >
class	wpi::util::java::detail::JSpanBase< T, IsCritical, Size >
	Helper class for working with JNI arrays. More...
struct	wpi::util::java::detail::ConvertIntArray< T >
class	wpi::util::java::JCallbackThread< T >
	Generic callback thread implementation. More...
class	wpi::util::java::JCallbackManager< T >
class	wpi::util::java::JSingletonCallbackManager< T >
class	wpi::util::java::JException
	Finds an exception class and keep it as a global reference. More...
struct	wpi::util::java::JExceptionInit

Namespaces
namespace	wpi
namespace	wpi::util
namespace	wpi::util::java
	Java Native Interface (JNI) utility functions.
namespace	wpi::util::java::detail

Concepts
concept	wpi::util::java::detail::JArrayType

Macros
#define	WPI_JNI_ARRAYHELPER(T, F)
#define	WPI_JNI_MAKEJARRAY(T, F)

Typedefs
template<typename CvSrc, typename Dest>
using	wpi::util::java::detail::copy_cv_t = typename copy_cv<CvSrc, Dest>::type
template<typename T, size_t Extent = std::dynamic_extent>
using	wpi::util::java::JSpan = detail::JSpanBase<T, false, Extent>
template<typename T, size_t Extent = std::dynamic_extent>
using	wpi::util::java::CriticalJSpan = detail::JSpanBase<T, true, Extent>

Functions
std::string	wpi::util::java::GetJavaStackTrace (JNIEnv *env, std::string *func=nullptr, std::string_view excludeFuncPrefix={})
	Gets a Java stack trace.
jstring	wpi::util::java::MakeJString (JNIEnv *env, std::string_view str)
	Convert a UTF8 string into a jstring.
template<typename T>
jintArray	wpi::util::java::MakeJIntArray (JNIEnv *env, std::span< const T > arr)
	Convert a span to a jintArray.
template<typename T>
jintArray	wpi::util::java::MakeJIntArray (JNIEnv *env, std::span< T > arr)
	Convert a span to a jintArray.
template<typename T>
jintArray	wpi::util::java::MakeJIntArray (JNIEnv *env, const SmallVectorImpl< T > &arr)
	Convert a SmallVector to a jintArray.
template<typename T>
jintArray	wpi::util::java::MakeJIntArray (JNIEnv *env, const std::vector< T > &arr)
	Convert a std::vector to a jintArray.
jbyteArray	wpi::util::java::MakeJByteArray (JNIEnv *env, std::span< const uint8_t > str)
	Convert a span into a jbyteArray.
jbooleanArray	wpi::util::java::MakeJBooleanArray (JNIEnv *env, std::span< const int > arr)
	Convert an array of integers into a jbooleanArray.
jbooleanArray	wpi::util::java::MakeJBooleanArray (JNIEnv *env, std::span< const bool > arr)
	Convert an array of booleans into a jbooleanArray.
template<class T> requires (sizeof(typename T::value_type) == sizeof(jlong) && std::integral<typename T::value_type>)
jlongArray	wpi::util::java::MakeJLongArray (JNIEnv *env, const T &arr)
jobjectArray	wpi::util::java::MakeJStringArray (JNIEnv *env, std::span< const std::string > arr)
	Convert an array of std::string into a jarray of jstring.
jobjectArray	wpi::util::java::MakeJStringArray (JNIEnv *env, std::span< std::string_view > arr)
	Convert an array of std::string into a jarray of jstring.
std::string	wpi::util::java::GetJavaStackTrace (JNIEnv *env, std::string_view skipPrefix)

Variables
template<typename From, typename To>
constexpr bool	wpi::util::java::detail::is_qualification_convertible_v

Macro Definition Documentation

WPI_JNI_ARRAYHELPER

#define WPI_JNI_ARRAYHELPER	(		T,
			F )

Value:

  template <>                                                                 \
  struct ArrayHelper<T> {                                                     \
    using jarray_type = T##Array;                                             \
    static T* GetArrayElements(JNIEnv* env, jarray_type jarr) {               \
      return env->Get##F##ArrayElements(jarr, nullptr);                       \
    }                                                                         \
    static void ReleaseArrayElements(JNIEnv* env, jarray_type jarr, T* elems, \
                                     jint mode) {                             \
      env->Release##F##ArrayElements(jarr, elems, mode);                      \
    }                                                                         \
  };

WPI_JNI_MAKEJARRAY

#define WPI_JNI_MAKEJARRAY	(		T,
			F )

Value:

  inline T##Array MakeJ##F##Array(JNIEnv* env, std::span<const T> arr) { \
    T##Array jarr = env->New##F##Array(arr.size());                      \
    if (!jarr) {                                                         \
      return nullptr;                                                    \
    }                                                                    \
    env->Set##F##ArrayRegion(jarr, 0, arr.size(), arr.data());           \
    return jarr;                                                         \
  }