risingwave_jni_core/
macros.rs

1// Copyright 2025 RisingWave Labs
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15// Utils
16/// A macro that splits the input by comma and calls the callback `$macro` with the split result.
17/// The each part of the split result is within a bracket, and the callback `$macro` can have its
18/// first parameter as `{$({$($args:tt)+})*}` to match the split result.
19///
20/// ```
21/// macro_rules! call_split_by_comma {
22///     ({$({$($args:tt)+})*}) => {
23///         [$(
24///            stringify! {$($args)+}
25///         ),*]
26///     };
27///     ($($input:tt)*) => {{
28///         risingwave_jni_core::split_by_comma! {
29///             {$($input)*},
30///             call_split_by_comma
31///         }
32///     }};
33/// }
34///
35/// let expected_result = [
36///     "hello",
37///     "my friend",
38/// ];
39///
40/// assert_eq!(expected_result, {call_split_by_comma!(hello, my friend)});
41/// ```
42#[macro_export]
43macro_rules! split_by_comma {
44    // Entry of macro. Put input as the first parameter and initialize empty
45    // second and third parameter.
46    (
47        {$($input:tt)*},
48        $macro:path $(,$args:tt)*
49    ) => {
50        $crate::split_by_comma! {
51            {$($input)*},
52            {}, // previous splits
53            {}, // current split
54            $macro $(,$args)*
55        }
56    };
57    // When the first token is comma, move the tokens of current split to the
58    // list of previous splits with a bracket wrapped, and then clear the current
59    // split.
60    (
61        {
62            ,
63            $($rest:tt)*
64        },
65        {
66            $(
67                {$($prev_split:tt)*}
68            )*
69        },
70        {
71            $($current_split:tt)*
72        },
73        $macro:path $(,$args:tt)*
74    ) => {
75        $crate::split_by_comma! {
76            {
77                $($rest)*
78            },
79            {
80                $(
81                    {$($prev_split)*}
82                )*
83                {
84                    $($current_split)*
85                }
86            },
87            {},
88            $macro $(,$args)*
89        }
90    };
91    // Do the same as the previous match when we just reach the end of input,
92    // with the content of last split not added to the list of previous split yet.
93    (
94        {},
95        {
96            $(
97                {$($prev_split:tt)*}
98            )*
99        },
100        {
101            $($current_split:tt)+
102        },
103        $macro:path $(,$args:tt)*
104    ) => {
105        $crate::split_by_comma! {
106            {},
107            {
108                $(
109                    {$($prev_split)*}
110                )*
111                {
112                    $($current_split)+
113                }
114            },
115            {},
116            $macro $(,$args)*
117        }
118    };
119    // For a token that is not comma, add to the list of current staging split.
120    (
121        {
122            $first:tt
123            $($rest:tt)*
124        },
125        {
126            $(
127                {$($prev_split:tt)*}
128            )*
129        },
130        {
131            $($current_split:tt)*
132        },
133        $macro:path $(,$args:tt)*
134    ) => {
135        $crate::split_by_comma! {
136            {
137                $($rest)*
138            },
139            {
140                $(
141                    {$($prev_split)*}
142                )*
143            },
144            {
145                $($current_split)* $first
146            },
147            $macro $(,$args)*
148        }
149    };
150    // When all split result are added to the list, call the callback `$macro` with the result.
151    (
152        {},
153        {
154            $(
155                {$($prev_split:tt)*}
156            )*
157        },
158        {},
159        $macro:path $(,$args:tt)*
160    ) => {
161        $macro! {
162            {
163                $(
164                    {$($prev_split)*}
165                )*
166            }
167            $(,$args)*
168        }
169    };
170}
171// End of utils part
172
173/// Generate the dot separated java class name to the slash separated name.
174///
175/// ```
176/// assert_eq!(
177///     "java/lang/String",
178///     risingwave_jni_core::gen_class_name!(java.lang.String)
179/// );
180/// assert_eq!(
181///     "java/lang/String",
182///     risingwave_jni_core::gen_class_name!(String)
183/// );
184/// ```
185#[macro_export]
186macro_rules! gen_class_name {
187    // A single part class name will be prefixed with `java.lang.`
188    ($single_part_class:ident $($param_name:ident)?) => {
189        $crate::gen_class_name! { @inner java.lang.$single_part_class }
190    };
191    ($($class:ident).+ $($param_name:ident)?) => {
192        $crate::gen_class_name! { @inner $($class).+ }
193    };
194    (@inner $last:ident) => {
195        stringify! {$last}
196    };
197    (@inner $first:ident . $($rest:ident).+) => {
198        concat! {stringify! {$first}, "/", $crate::gen_class_name! {@inner $($rest).+} }
199    }
200}
201
202/// Generate the type signature of a single type
203/// ```
204/// use risingwave_jni_core::gen_jni_type_sig;
205/// assert_eq!("Z", gen_jni_type_sig!(boolean));
206/// assert_eq!("B", gen_jni_type_sig!(byte));
207/// assert_eq!("C", gen_jni_type_sig!(char));
208/// assert_eq!("S", gen_jni_type_sig!(short));
209/// assert_eq!("I", gen_jni_type_sig!(int));
210/// assert_eq!("J", gen_jni_type_sig!(long));
211/// assert_eq!("F", gen_jni_type_sig!(float));
212/// assert_eq!("D", gen_jni_type_sig!(double));
213/// assert_eq!("V", gen_jni_type_sig!(void));
214/// assert_eq!("Ljava/lang/Class;", gen_jni_type_sig!(Class<?>));
215/// assert_eq!("Ljava/lang/String;", gen_jni_type_sig!(String));
216/// assert_eq!("[B", gen_jni_type_sig!(byte[]));
217/// ```
218#[macro_export]
219macro_rules! gen_jni_type_sig {
220    (boolean $($param_name:ident)?) => {
221        "Z"
222    };
223    (byte $($param_name:ident)?) => {
224        "B"
225    };
226    (char $($param_name:ident)?) => {
227        "C"
228    };
229    (short $($param_name:ident)?) => {
230        "S"
231    };
232    (int $($param_name:ident)?) => {
233        "I"
234    };
235    (long $($param_name:ident)?) => {
236        "J"
237    };
238    (float $($param_name:ident)?) => {
239        "F"
240    };
241    (double $($param_name:ident)?) => {
242        "D"
243    };
244    (void) => {
245        "V"
246    };
247    (Class $(< ? >)? $($param_name:ident)?) => {
248        $crate::gen_jni_type_sig! { java.lang.Class }
249    };
250    ($($class_part:ident).+ $($param_name:ident)?) => {
251        concat! {"L", $crate::gen_class_name! {$($class_part).+}, ";"}
252    };
253    ($($class_part:ident).+ [] $($param_name:ident)?) => {
254        concat! { "[", $crate::gen_jni_type_sig! {$($class_part).+}}
255    };
256    ($($invalid:tt)*) => {
257        compile_error!(concat!("unsupported type `", stringify!($($invalid)*), "`"))
258    };
259}
260
261/// Cast a `JValueGen` to a concrete type by the given type
262///
263/// ```
264/// use jni::objects::JValue;
265/// use jni::sys::JNI_TRUE;
266/// use risingwave_jni_core::cast_jvalue;
267/// assert_eq!(cast_jvalue!({boolean}, JValue::Bool(JNI_TRUE)), true);
268/// assert_eq!(cast_jvalue!({byte}, JValue::Byte(10 as i8)), 10);
269/// assert_eq!(cast_jvalue!({char}, JValue::Char('c' as u16)), 'c' as u16);
270/// assert_eq!(cast_jvalue!({double}, JValue::Double(3.14)), 3.14);
271/// assert_eq!(cast_jvalue!({float}, JValue::Float(3.14)), 3.14);
272/// assert_eq!(cast_jvalue!({int}, JValue::Int(10)), 10);
273/// assert_eq!(cast_jvalue!({long}, JValue::Long(10)), 10);
274/// assert_eq!(cast_jvalue!({short}, JValue::Short(10)), 10);
275/// cast_jvalue!({void}, JValue::Void);
276/// let null = jni::objects::JObject::null();
277/// let _: &jni::objects::JObject<'_> = cast_jvalue!({String}, JValue::Object(&null));
278/// let _: jni::objects::JByteArray<'_> = cast_jvalue!({byte[]}, jni::objects::JValueOwned::Object(null));
279/// ```
280#[macro_export]
281macro_rules! cast_jvalue {
282    ({ boolean }, $value:expr) => {{ $value.z().expect("should be bool") }};
283    ({ byte }, $value:expr) => {{ $value.b().expect("should be byte") }};
284    ({ char }, $value:expr) => {{ $value.c().expect("should be char") }};
285    ({ double }, $value:expr) => {{ $value.d().expect("should be double") }};
286    ({ float }, $value:expr) => {{ $value.f().expect("should be float") }};
287    ({ int }, $value:expr) => {{ $value.i().expect("should be int") }};
288    ({ long }, $value:expr) => {{ $value.j().expect("should be long") }};
289    ({ short }, $value:expr) => {{ $value.s().expect("should be short") }};
290    ({ void }, $value:expr) => {{ $value.v().expect("should be void") }};
291    ({ byte[] }, $value:expr) => {{
292        let obj = $value.l().expect("should be object");
293        unsafe { jni::objects::JByteArray::from_raw(obj.into_raw()) }
294    }};
295    ({ $($class:tt)+ }, $value:expr) => {{ $value.l().expect("should be object") }};
296}
297
298/// Cast a `JValueGen` to a concrete type by the given type
299///
300/// ```
301/// use jni::sys::JNI_TRUE;
302/// use risingwave_jni_core::{cast_jvalue, to_jvalue};
303/// assert_eq!(
304///     cast_jvalue!({ boolean }, to_jvalue!({ boolean }, JNI_TRUE)),
305///     true
306/// );
307/// assert_eq!(cast_jvalue!({ byte }, to_jvalue!({ byte }, 10)), 10);
308/// assert_eq!(
309///     cast_jvalue!({ char }, to_jvalue!({ char }, 'c')),
310///     'c' as u16
311/// );
312/// assert_eq!(cast_jvalue!({ double }, to_jvalue!({ double }, 3.14)), 3.14);
313/// assert_eq!(cast_jvalue!({ float }, to_jvalue!({ float }, 3.14)), 3.14);
314/// assert_eq!(cast_jvalue!({ int }, to_jvalue!({ int }, 10)), 10);
315/// assert_eq!(cast_jvalue!({ long }, to_jvalue!({ long }, 10)), 10);
316/// assert_eq!(cast_jvalue!({ short }, to_jvalue!({ short }, 10)), 10);
317/// cast_jvalue!(
318///     { String },
319///     to_jvalue!({ String }, &jni::objects::JObject::null())
320/// );
321/// ```
322#[macro_export]
323macro_rules! to_jvalue {
324    ({ boolean $($param_name:ident)? }, $value:expr) => {{ jni::objects::JValue::Bool($value as _) }};
325    ({ byte $($param_name:ident)? }, $value:expr) => {{ jni::objects::JValue::Byte($value as _) }};
326    ({ char $($param_name:ident)? }, $value:expr) => {{ jni::objects::JValue::Char($value as _) }};
327    ({ double $($param_name:ident)? }, $value:expr) => {{ jni::objects::JValue::Double($value as _) }};
328    ({ float $($param_name:ident)? }, $value:expr) => {{ jni::objects::JValue::Float($value as _) }};
329    ({ int $($param_name:ident)? }, $value:expr) => {{ jni::objects::JValue::Int($value as _) }};
330    ({ long $($param_name:ident)? }, $value:expr) => {{ jni::objects::JValue::Long($value as _) }};
331    ({ short $($param_name:ident)? }, $value:expr) => {{ jni::objects::JValue::Short($value as _) }};
332    ({ void }, $value:expr) => {{
333        compile_error! {concat! {"unlike to pass void value: ", stringify! {$value} }}
334    }};
335    ({ $($class:ident)+ $([])? $($param_name:ident)? }, $value:expr) => {{ jni::objects::JValue::Object($value as _) }};
336}
337
338/// Generate the jni signature of a given function
339/// ```
340/// use risingwave_jni_core::gen_jni_sig;
341/// assert_eq!(gen_jni_sig!(boolean f(int, short, byte[])), "(IS[B)Z");
342/// assert_eq!(
343///     gen_jni_sig!(boolean f(int, short, byte[], java.lang.String)),
344///     "(IS[BLjava/lang/String;)Z"
345/// );
346/// assert_eq!(
347///     gen_jni_sig!(boolean f(int, java.lang.String)),
348///     "(ILjava/lang/String;)Z"
349/// );
350/// assert_eq!(gen_jni_sig!(public static native int defaultVnodeCount()), "()I");
351/// assert_eq!(
352///     gen_jni_sig!(long hummockIteratorNew(byte[] readPlan)),
353///     "([B)J"
354/// );
355/// assert_eq!(gen_jni_sig!(long hummockIteratorNext(long pointer)), "(J)J");
356/// assert_eq!(
357///     gen_jni_sig!(void hummockIteratorClose(long pointer)),
358///     "(J)V"
359/// );
360/// assert_eq!(gen_jni_sig!(byte[] rowGetKey(long pointer)), "(J)[B");
361/// assert_eq!(
362///     gen_jni_sig!(java.sql.Timestamp rowGetTimestampValue(long pointer, int index)),
363///     "(JI)Ljava/sql/Timestamp;"
364/// );
365/// assert_eq!(
366///     gen_jni_sig!(String rowGetStringValue(long pointer, int index)),
367///     "(JI)Ljava/lang/String;"
368/// );
369/// assert_eq!(
370///     gen_jni_sig!(static native Object rowGetArrayValue(long pointer, int index, Class clazz)),
371///     "(JILjava/lang/Class;)Ljava/lang/Object;"
372/// );
373/// ```
374#[macro_export]
375macro_rules! gen_jni_sig {
376    // handle the result of `split_by_comma`
377    ({$({$($args:tt)+})*}, {return {$($ret:tt)*}}) => {{
378        concat! {
379            "(", $($crate::gen_jni_type_sig!{ $($args)+ },)* ")",
380            $crate::gen_jni_type_sig! {$($ret)+}
381        }
382    }};
383    ({$($ret:tt)*}, {$($args:tt)*}) => {{
384        $crate::split_by_comma! {
385            {$($args)*},
386            $crate::gen_jni_sig,
387            {return {$($ret)*}}
388        }
389    }};
390    // handle the result of `split_extract_plain_native_methods`
391    ({{$func_name:ident, {$($ret:tt)*}, {$($args:tt)*}}}) => {{
392        $crate::gen_jni_sig! {
393            {$($ret)*}, {$($args)*}
394        }
395    }};
396    ($($input:tt)*) => {{
397        $crate::split_extract_plain_native_methods! {{$($input)*;}, $crate::gen_jni_sig}
398    }}
399}
400
401#[macro_export]
402macro_rules! for_all_plain_native_methods {
403    ($macro:path $(,$args:tt)*) => {
404        $macro! {
405            {
406                public static native void tracingSlf4jEvent(String threadName, String name, int level, String message, String stackTrace);
407
408                public static native boolean tracingSlf4jEventEnabled(int level);
409
410                public static native int defaultVnodeCount();
411
412                static native long iteratorNewStreamChunk(long pointer);
413
414                static native boolean iteratorNext(long pointer);
415
416                static native void iteratorClose(long pointer);
417
418                static native long newStreamChunkFromPayload(byte[] streamChunkPayload);
419
420                static native long newStreamChunkFromPretty(String str);
421
422                static native void streamChunkClose(long pointer);
423
424                static native byte[] iteratorGetKey(long pointer);
425
426                static native int iteratorGetOp(long pointer);
427
428                static native boolean iteratorIsNull(long pointer, int index);
429
430                static native short iteratorGetInt16Value(long pointer, int index);
431
432                static native int iteratorGetInt32Value(long pointer, int index);
433
434                static native long iteratorGetInt64Value(long pointer, int index);
435
436                static native float iteratorGetFloatValue(long pointer, int index);
437
438                static native double iteratorGetDoubleValue(long pointer, int index);
439
440                static native boolean iteratorGetBooleanValue(long pointer, int index);
441
442                static native String iteratorGetStringValue(long pointer, int index);
443
444                static native java.time.LocalDateTime iteratorGetTimestampValue(long pointer, int index);
445
446                static native java.time.OffsetDateTime iteratorGetTimestamptzValue(long pointer, int index);
447
448                static native java.math.BigDecimal iteratorGetDecimalValue(long pointer, int index);
449
450                static native java.time.LocalTime iteratorGetTimeValue(long pointer, int index);
451
452                static native java.time.LocalDate iteratorGetDateValue(long pointer, int index);
453
454                static native String iteratorGetIntervalValue(long pointer, int index);
455
456                static native String iteratorGetJsonbValue(long pointer, int index);
457
458                static native byte[] iteratorGetByteaValue(long pointer, int index);
459
460                // TODO: object or object array?
461                static native Object iteratorGetArrayValue(long pointer, int index, Class<?> clazz);
462
463                public static native boolean sendCdcSourceMsgToChannel(long channelPtr, byte[] msg);
464
465                public static native boolean sendCdcSourceErrorToChannel(long channelPtr, String errorMsg);
466
467                public static native void cdcSourceSenderClose(long channelPtr);
468
469                public static native com.risingwave.java.binding.JniSinkWriterStreamRequest
470                    recvSinkWriterRequestFromChannel(long channelPtr);
471
472                public static native boolean sendSinkWriterResponseToChannel(long channelPtr, byte[] msg);
473
474                public static native boolean sendSinkWriterErrorToChannel(long channelPtr, String msg);
475
476                public static native byte[] recvSinkCoordinatorRequestFromChannel(long channelPtr);
477
478                public static native boolean sendSinkCoordinatorResponseToChannel(long channelPtr, byte[] msg);
479            }
480            $(,$args)*
481        }
482    };
483}
484
485/// Given the plain text of a list native methods, split the methods by semicolon (;), extract
486/// the return type, argument list and name of the methods and pass the result to the callback
487/// `$macro` with the extracted result as the first parameter. The result can be matched with
488/// pattern `{$({$func_name:ident, {$($ret:tt)*}, {$($args:tt)*}})*}`
489///
490/// ```
491/// macro_rules! call_split_extract_plain_native_methods {
492///     ({$({$func_name:ident, {$($ret:tt)*}, {$($args:tt)*}})*}) => {
493///         [$(
494///             (stringify! {$func_name}, stringify!{$($ret)*}, stringify!{($($args)*)})
495///         ),*]
496///     };
497///     ($($input:tt)*) => {{
498///         risingwave_jni_core::split_extract_plain_native_methods! {
499///             {$($input)*},
500///             call_split_extract_plain_native_methods
501///         }
502///     }}
503/// }
504/// assert_eq!([
505///     ("f", "int", "(int param1, boolean param2)"),
506///     ("f2", "boolean[]", "()"),
507///     ("f3", "java.lang.String", "(byte[] param)")
508/// ], call_split_extract_plain_native_methods!(
509///     int f(int param1, boolean param2);
510///     boolean[] f2();
511///     java.lang.String f3(byte[] param);
512/// ))
513/// ```
514#[macro_export]
515macro_rules! split_extract_plain_native_methods {
516    (
517        {$($input:tt)*},
518        $macro:path
519        $(,$extra_args:tt)*
520    ) => {{
521        $crate::split_extract_plain_native_methods! {
522            {$($input)*},
523            {},
524            $macro
525            $(,$extra_args)*
526        }
527    }};
528    (
529        {
530            $(public)? static native $($first:tt)*
531        },
532        {
533            $($second:tt)*
534        },
535        $macro:path
536        $(,$extra_args:tt)*
537    ) => {
538        $crate::split_extract_plain_native_methods! {
539            {
540                $($first)*
541            },
542            {
543                $($second)*
544            },
545            $macro
546            $(,$extra_args)*
547        }
548    };
549    (
550        {
551            $($ret:tt).+ $func_name:ident($($args:tt)*); $($rest:tt)*
552        },
553        {
554            $({$prev_func_name:ident, {$($prev_ret:tt)*}, {$($prev_args:tt)*}})*
555        },
556        $macro:path
557        $(,$extra_args:tt)*
558    ) => {
559        $crate::split_extract_plain_native_methods! {
560            {$($rest)*},
561            {
562                $({$prev_func_name, {$($prev_ret)*}, {$($prev_args)*}})*
563                {$func_name, {$($ret).+}, {$($args)*}}
564            },
565            $macro
566            $(,$extra_args)*
567        }
568    };
569    (
570        {
571            $($ret:tt).+ [] $func_name:ident($($args:tt)*); $($rest:tt)*
572        },
573        {
574            $({$prev_func_name:ident, {$($prev_ret:tt)*}, {$($prev_args:tt)*}})*
575        },
576        $macro:path
577        $(,$extra_args:tt)*
578    ) => {
579        $crate::split_extract_plain_native_methods! {
580            {$($rest)*},
581            {
582                $({$prev_func_name, {$($prev_ret)*}, {$($prev_args)*}})*
583                {$func_name, {$($ret).+ []}, {$($args)*}}
584            },
585            $macro
586            $(,$extra_args)*
587        }
588    };
589    (
590        {},
591        {
592            $({$func_name:ident, {$($ret:tt)*}, {$($args:tt)*}})*
593        },
594        $macro:path
595        $(,$extra_args:tt)*
596    ) => {
597        $macro! {
598            {
599                $({$func_name, {$($ret)*}, {$($args)*}})*
600            }
601            $(,$extra_args)*
602        }
603    };
604    ($($invalid:tt)*) => {
605        compile_error!(concat!("unable to split extract `", stringify!($($invalid)*), "`"))
606    };
607}
608
609/// Pass the information of all native methods to the callback `$macro`. The input can be matched
610/// with pattern `{$({$func_name:ident, {$($ret:tt)*}, {$($args:tt)*}})*}`
611#[macro_export]
612macro_rules! for_all_native_methods {
613    ($macro:path $(,$args:tt)*) => {{
614        $crate::for_all_plain_native_methods! {
615            $crate::for_all_native_methods,
616            $macro
617            $(,$args)*
618        }
619    }};
620    (
621        {
622            $({$func_name:ident, {$($ret:tt)*}, {$($args:tt)*}})*
623        },
624        $macro:path
625        $(,$extra_args:tt)*
626    ) => {{
627        $macro! {
628            {$({$func_name, {$($ret)*}, {$($args)*}})*}
629            $(,$extra_args)*
630        }
631    }};
632    (
633        {$($input:tt)*},
634        $macro:path
635        $(,$extra_args:tt)*
636    ) => {{
637        $crate::split_extract_plain_native_methods! {
638            {$($input)*},
639            $crate::for_all_native_methods,
640            $macro
641            $(,$extra_args)*
642        }
643    }};
644}
645
646/// Convert the argument value list when invoking a method to a list of `JValue` by the argument type list in the signature
647/// ```
648/// use risingwave_jni_core::convert_args_list;
649/// use jni::objects::{JObject, JValue};
650/// use jni::sys::JNI_TRUE;
651/// let list: [JValue<'static, 'static>; 3] = convert_args_list!(
652///     {boolean first, int second, byte third},
653///     {true, 10, 20}
654/// );
655/// match &list[0] {
656///     JValue::Bool(b) => assert_eq!(*b, JNI_TRUE),
657///     value => unreachable!("wrong value: {:?}", value),
658/// }
659/// match &list[1] {
660///     JValue::Int(v) => assert_eq!(*v, 10),
661///     value => unreachable!("wrong value: {:?}", value),
662/// }
663/// match &list[2] {
664///     JValue::Byte(v) => assert_eq!(*v, 20),
665///     value => unreachable!("wrong value: {:?}", value),
666/// }
667/// ```
668#[macro_export]
669macro_rules! convert_args_list {
670    (
671        {
672            {$($first_args:tt)+}
673            $({$($args:tt)+})*
674        },
675        {
676            {$first_value:expr}
677            $({$value:expr})*
678        },
679        {
680            $({$converted:expr})*
681        }) => {
682        $crate::convert_args_list! {
683            {$({$($args)+})*},
684            {$({$value})*},
685            {
686                $({$converted})*
687                {
688                    $crate::to_jvalue! {
689                        {$($first_args)+},
690                        {$first_value}
691                    }
692                }
693            }
694        }
695    };
696    ({$($args:tt)+}, {}, {$({$converted:expr})*}) => {
697        compile_error! {concat!{"trailing argument not passed: ", stringify!{$($args)+}}}
698    };
699    ({}, {$($value:tt)+}, {$({$converted:expr})*}) => {
700        compile_error! {concat!{"trailing extra value passed: ", stringify!{$($value)+}}}
701    };
702    ({}, {}, {$({$converted:expr})*}) => {
703        [$(
704            $converted
705        ),*]
706    };
707    ({$($args:tt)*}, {$($value:expr),*}) => {{
708        $crate::split_by_comma! {
709            {$($args)*},
710            $crate::convert_args_list,
711            {$({$value})*},
712            {}
713        }
714    }};
715    ($($invalid:tt)*) => {
716        compile_error!(concat!("failed to convert `", stringify!($($invalid)*), "`"))
717    };
718}
719
720#[macro_export]
721macro_rules! call_static_method {
722    (
723        {{$func_name:ident, {$($ret:tt)*}, {$($args:tt)*}}},
724        {$($class:ident).+},
725        {$env:expr} $(, $method_args:expr)*
726    ) => {{
727        $crate::call_static_method! {
728            $env,
729            $crate::gen_class_name!($($class).+),
730            stringify! {$func_name},
731            {{$($ret)*}, {$($args)*}}
732            $(, $method_args)*
733        }
734    }};
735    ($env:expr, {$($class:ident).+}, {$($method:tt)*} $(, $args:expr)*) => {{
736        $crate::split_extract_plain_native_methods! {
737            {$($method)*;},
738            $crate::call_static_method,
739            {$($class).+},
740            {$env} $(, $args)*
741        }
742    }};
743    (
744        $env:expr,
745        $class_name:expr,
746        $func_name:expr,
747        {{$($ret:tt)*}, {$($args:tt)*}}
748        $(, $method_args:expr)*
749    ) => {{
750        $env.call_static_method(
751            $class_name,
752            $func_name,
753            $crate::gen_jni_sig! { {$($ret)+}, {$($args)*}},
754            &{
755                $crate::convert_args_list! {
756                    {$($args)*},
757                    {$($method_args),*}
758                }
759            },
760        ).map(|jvalue| {
761            $crate::cast_jvalue! {
762                {$($ret)*},
763                jvalue
764            }
765        })
766    }};
767}
768
769#[macro_export]
770macro_rules! call_method {
771    (
772        {{$func_name:ident, {$($ret:tt)*}, {$($args:tt)*}}},
773        $env:expr, $obj:expr $(, $method_args:expr)*
774    ) => {{
775        $env.call_method(
776            $obj,
777            stringify!{$func_name},
778            $crate::gen_jni_sig! { {$($ret)+}, {$($args)*}},
779            &{
780                $crate::convert_args_list! {
781                    {$($args)*},
782                    {$($method_args),*}
783                }
784            },
785        ).map(|jvalue| {
786            $crate::cast_jvalue! {
787                {$($ret)*},
788                jvalue
789            }
790        })
791    }};
792    ($env:expr, $obj:expr, {$($method:tt)*} $(, $args:expr)*) => {{
793        $crate::split_extract_plain_native_methods! {
794            {$($method)*;},
795            $crate::call_method,
796            $env, $obj $(, $args)*
797        }
798    }};
799}
800
801#[macro_export]
802macro_rules! gen_native_method_entry {
803    (
804        $class_prefix:ident, $func_name:ident, {$($ret:tt)+}, {$($args:tt)*}
805    ) => {{
806        {
807            let fn_ptr = $crate::paste! {[<$class_prefix $func_name> ]} as *mut c_void;
808            let sig = $crate::gen_jni_sig! { {$($ret)+}, {$($args)*}};
809            jni::NativeMethod {
810                name: jni::strings::JNIString::from(stringify! {$func_name}),
811                sig: jni::strings::JNIString::from(sig),
812                fn_ptr,
813            }
814        }
815    }};
816}
817
818#[cfg(test)]
819mod tests {
820    use std::fmt::Formatter;
821
822    #[test]
823    fn test_for_all_gen() {
824        macro_rules! gen_array {
825            (test) => {{
826                for_all_native_methods! {
827                    {
828                        public static native int defaultVnodeCount();
829                        static native long hummockIteratorNew(byte[] readPlan);
830                        public static native byte[] rowGetKey(long pointer);
831                    },
832                    gen_array
833                }
834            }};
835            (all) => {{
836                for_all_native_methods! {
837                    gen_array
838                }
839            }};
840            ({$({ $func_name:ident, {$($ret:tt)+}, {$($args:tt)*} })*}) => {{
841                [
842                    $(
843                        (stringify! {$func_name}, gen_jni_sig! { {$($ret)+}, {$($args)*}}),
844                    )*
845                ]
846            }};
847        }
848        let sig: [(_, _); 3] = gen_array!(test);
849        assert_eq!(
850            sig,
851            [
852                ("defaultVnodeCount", "()I"),
853                ("hummockIteratorNew", "([B)J"),
854                ("rowGetKey", "(J)[B")
855            ]
856        );
857
858        let sig = gen_array!(all);
859        assert!(!sig.is_empty());
860    }
861
862    #[test]
863    fn test_all_native_methods() {
864        // This test shows the signature of all native methods
865        let expected = expect_test::expect![[r#"
866            [
867                tracingSlf4jEvent                        (Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;)V,
868                tracingSlf4jEventEnabled                 (I)Z,
869                defaultVnodeCount                        ()I,
870                iteratorNewStreamChunk                   (J)J,
871                iteratorNext                             (J)Z,
872                iteratorClose                            (J)V,
873                newStreamChunkFromPayload                ([B)J,
874                newStreamChunkFromPretty                 (Ljava/lang/String;)J,
875                streamChunkClose                         (J)V,
876                iteratorGetKey                           (J)[B,
877                iteratorGetOp                            (J)I,
878                iteratorIsNull                           (JI)Z,
879                iteratorGetInt16Value                    (JI)S,
880                iteratorGetInt32Value                    (JI)I,
881                iteratorGetInt64Value                    (JI)J,
882                iteratorGetFloatValue                    (JI)F,
883                iteratorGetDoubleValue                   (JI)D,
884                iteratorGetBooleanValue                  (JI)Z,
885                iteratorGetStringValue                   (JI)Ljava/lang/String;,
886                iteratorGetTimestampValue                (JI)Ljava/time/LocalDateTime;,
887                iteratorGetTimestamptzValue              (JI)Ljava/time/OffsetDateTime;,
888                iteratorGetDecimalValue                  (JI)Ljava/math/BigDecimal;,
889                iteratorGetTimeValue                     (JI)Ljava/time/LocalTime;,
890                iteratorGetDateValue                     (JI)Ljava/time/LocalDate;,
891                iteratorGetIntervalValue                 (JI)Ljava/lang/String;,
892                iteratorGetJsonbValue                    (JI)Ljava/lang/String;,
893                iteratorGetByteaValue                    (JI)[B,
894                iteratorGetArrayValue                    (JILjava/lang/Class;)Ljava/lang/Object;,
895                sendCdcSourceMsgToChannel                (J[B)Z,
896                sendCdcSourceErrorToChannel              (JLjava/lang/String;)Z,
897                cdcSourceSenderClose                     (J)V,
898                recvSinkWriterRequestFromChannel         (J)Lcom/risingwave/java/binding/JniSinkWriterStreamRequest;,
899                sendSinkWriterResponseToChannel          (J[B)Z,
900                sendSinkWriterErrorToChannel             (JLjava/lang/String;)Z,
901                recvSinkCoordinatorRequestFromChannel    (J)[B,
902                sendSinkCoordinatorResponseToChannel     (J[B)Z,
903            ]
904        "#]];
905
906        struct MethodInfo {
907            name: &'static str,
908            sig: &'static str,
909        }
910
911        impl std::fmt::Debug for MethodInfo {
912            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
913                write!(f, "{:40} {}", self.name, self.sig)
914            }
915        }
916
917        macro_rules! gen_all_native_method_info {
918            () => {{
919                $crate::for_all_native_methods! {
920                    gen_all_native_method_info
921                }
922            }};
923            ({$({$func_name:ident, {$($ret:tt)*}, {$($args:tt)*}})*}) => {
924                [$(
925                    (
926                        MethodInfo {
927                            name: stringify! {$func_name},
928                            sig: $crate::gen_jni_sig! {
929                                {$($ret)*}, {$($args)*}
930                            },
931                        }
932                    )
933                ),*]
934            }
935        }
936        let info = gen_all_native_method_info!();
937        expected.assert_debug_eq(&info);
938    }
939}
risingwave_jni_core/macros.rs

risingwave_jni_core/
macros.rs
