Mercurial > hg > orthanc-java

comparison Plugin/NativeSDK.cpp @ 0:3ecef5782f2c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial commit
author Sebastien Jodogne <s.jodogne@gmail.com>
date Wed, 18 Oct 2023 17:59:44 +0200
parents
children c8f19e93ff99
comparison
equal deleted inserted replaced
-1:000000000000 0:3ecef5782f2c
1 /**
2 * SPDX-FileCopyrightText: 2023 Sebastien Jodogne, UCLouvain, Belgium
3 * SPDX-License-Identifier: GPL-3.0-or-later
4 */
5
6 /**
7 * Java plugin for Orthanc
8 * Copyright (C) 2023 Sebastien Jodogne, UCLouvain, Belgium
9 *
10 * This program is free software: you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License as
12 * published by the Free Software Foundation, either version 3 of the
13 * License, or (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program. If not, see <http://www.gnu.org/licenses/>.
22 **/
23
24
25
26 JNIEXPORT jint JNI_OrthancPluginCheckVersionAdvanced(JNIEnv* env, jobject sdkObject, jint arg0, jint arg1, jint arg2)
27 {
28 try
29 {
30 return OrthancPluginCheckVersionAdvanced(context_
31 , arg0, arg1, arg2);
32 }
33 catch (std::runtime_error& e)
34 {
35 JavaEnvironment::ThrowException(env, e.what());
36 return 0;
37 }
38 catch (...)
39 {
40 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
41 return 0;
42 }
43 }
44
45
46 JNIEXPORT jint JNI_OrthancPluginCheckVersion(JNIEnv* env, jobject sdkObject)
47 {
48 try
49 {
50 return OrthancPluginCheckVersion(context_
51 );
52 }
53 catch (std::runtime_error& e)
54 {
55 JavaEnvironment::ThrowException(env, e.what());
56 return 0;
57 }
58 catch (...)
59 {
60 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
61 return 0;
62 }
63 }
64
65
66 JNIEXPORT void JNI_OrthancPluginLogError(JNIEnv* env, jobject sdkObject, jstring arg0)
67 {
68 try
69 {
70 JavaString c_arg0(env, arg0);
71 OrthancPluginLogError(context_
72 , c_arg0.GetValue());
73 }
74 catch (std::runtime_error& e)
75 {
76 JavaEnvironment::ThrowException(env, e.what());
77 }
78 catch (...)
79 {
80 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
81 }
82 }
83
84
85 JNIEXPORT void JNI_OrthancPluginLogWarning(JNIEnv* env, jobject sdkObject, jstring arg0)
86 {
87 try
88 {
89 JavaString c_arg0(env, arg0);
90 OrthancPluginLogWarning(context_
91 , c_arg0.GetValue());
92 }
93 catch (std::runtime_error& e)
94 {
95 JavaEnvironment::ThrowException(env, e.what());
96 }
97 catch (...)
98 {
99 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
100 }
101 }
102
103
104 JNIEXPORT void JNI_OrthancPluginLogInfo(JNIEnv* env, jobject sdkObject, jstring arg0)
105 {
106 try
107 {
108 JavaString c_arg0(env, arg0);
109 OrthancPluginLogInfo(context_
110 , c_arg0.GetValue());
111 }
112 catch (std::runtime_error& e)
113 {
114 JavaEnvironment::ThrowException(env, e.what());
115 }
116 catch (...)
117 {
118 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
119 }
120 }
121
122
123 JNIEXPORT jbyteArray JNI_OrthancPluginGetDicomForInstance(JNIEnv* env, jobject sdkObject, jstring arg0)
124 {
125 try
126 {
127 JavaString c_arg0(env, arg0);
128 OrthancBytes b;
129 OrthancPluginErrorCode code = OrthancPluginGetDicomForInstance(context_, b.GetMemoryBuffer()
130 , c_arg0.GetValue());
131 if (code == OrthancPluginErrorCode_Success)
132 {
133 jbyteArray answer = env->NewByteArray(b.GetSize());
134 if (answer == NULL)
135 {
136 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
137 return NULL;
138 }
139 else
140 {
141 env->SetByteArrayRegion(answer, 0, b.GetSize(), reinterpret_cast<const jbyte*>(b.GetData()));
142 return answer;
143 }
144 }
145 else
146 {
147 JavaEnvironment::ThrowException(env, code);
148 return NULL;
149 }
150 }
151 catch (std::runtime_error& e)
152 {
153 JavaEnvironment::ThrowException(env, e.what());
154 return NULL;
155 }
156 catch (...)
157 {
158 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
159 return NULL;
160 }
161 }
162
163
164 JNIEXPORT jbyteArray JNI_OrthancPluginRestApiGet(JNIEnv* env, jobject sdkObject, jstring arg0)
165 {
166 try
167 {
168 JavaString c_arg0(env, arg0);
169 OrthancBytes b;
170 OrthancPluginErrorCode code = OrthancPluginRestApiGet(context_, b.GetMemoryBuffer()
171 , c_arg0.GetValue());
172 if (code == OrthancPluginErrorCode_Success)
173 {
174 jbyteArray answer = env->NewByteArray(b.GetSize());
175 if (answer == NULL)
176 {
177 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
178 return NULL;
179 }
180 else
181 {
182 env->SetByteArrayRegion(answer, 0, b.GetSize(), reinterpret_cast<const jbyte*>(b.GetData()));
183 return answer;
184 }
185 }
186 else
187 {
188 JavaEnvironment::ThrowException(env, code);
189 return NULL;
190 }
191 }
192 catch (std::runtime_error& e)
193 {
194 JavaEnvironment::ThrowException(env, e.what());
195 return NULL;
196 }
197 catch (...)
198 {
199 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
200 return NULL;
201 }
202 }
203
204
205 JNIEXPORT jbyteArray JNI_OrthancPluginRestApiGetAfterPlugins(JNIEnv* env, jobject sdkObject, jstring arg0)
206 {
207 try
208 {
209 JavaString c_arg0(env, arg0);
210 OrthancBytes b;
211 OrthancPluginErrorCode code = OrthancPluginRestApiGetAfterPlugins(context_, b.GetMemoryBuffer()
212 , c_arg0.GetValue());
213 if (code == OrthancPluginErrorCode_Success)
214 {
215 jbyteArray answer = env->NewByteArray(b.GetSize());
216 if (answer == NULL)
217 {
218 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
219 return NULL;
220 }
221 else
222 {
223 env->SetByteArrayRegion(answer, 0, b.GetSize(), reinterpret_cast<const jbyte*>(b.GetData()));
224 return answer;
225 }
226 }
227 else
228 {
229 JavaEnvironment::ThrowException(env, code);
230 return NULL;
231 }
232 }
233 catch (std::runtime_error& e)
234 {
235 JavaEnvironment::ThrowException(env, e.what());
236 return NULL;
237 }
238 catch (...)
239 {
240 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
241 return NULL;
242 }
243 }
244
245
246 JNIEXPORT jbyteArray JNI_OrthancPluginRestApiPost(JNIEnv* env, jobject sdkObject, jstring arg0, jbyteArray arg1)
247 {
248 try
249 {
250 JavaString c_arg0(env, arg0);
251 JavaBytes c_arg1(env, arg1);
252 OrthancBytes b;
253 OrthancPluginErrorCode code = OrthancPluginRestApiPost(context_, b.GetMemoryBuffer()
254 , c_arg0.GetValue(), c_arg1.GetData(), c_arg1.GetSize());
255 if (code == OrthancPluginErrorCode_Success)
256 {
257 jbyteArray answer = env->NewByteArray(b.GetSize());
258 if (answer == NULL)
259 {
260 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
261 return NULL;
262 }
263 else
264 {
265 env->SetByteArrayRegion(answer, 0, b.GetSize(), reinterpret_cast<const jbyte*>(b.GetData()));
266 return answer;
267 }
268 }
269 else
270 {
271 JavaEnvironment::ThrowException(env, code);
272 return NULL;
273 }
274 }
275 catch (std::runtime_error& e)
276 {
277 JavaEnvironment::ThrowException(env, e.what());
278 return NULL;
279 }
280 catch (...)
281 {
282 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
283 return NULL;
284 }
285 }
286
287
288 JNIEXPORT jbyteArray JNI_OrthancPluginRestApiPostAfterPlugins(JNIEnv* env, jobject sdkObject, jstring arg0, jbyteArray arg1)
289 {
290 try
291 {
292 JavaString c_arg0(env, arg0);
293 JavaBytes c_arg1(env, arg1);
294 OrthancBytes b;
295 OrthancPluginErrorCode code = OrthancPluginRestApiPostAfterPlugins(context_, b.GetMemoryBuffer()
296 , c_arg0.GetValue(), c_arg1.GetData(), c_arg1.GetSize());
297 if (code == OrthancPluginErrorCode_Success)
298 {
299 jbyteArray answer = env->NewByteArray(b.GetSize());
300 if (answer == NULL)
301 {
302 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
303 return NULL;
304 }
305 else
306 {
307 env->SetByteArrayRegion(answer, 0, b.GetSize(), reinterpret_cast<const jbyte*>(b.GetData()));
308 return answer;
309 }
310 }
311 else
312 {
313 JavaEnvironment::ThrowException(env, code);
314 return NULL;
315 }
316 }
317 catch (std::runtime_error& e)
318 {
319 JavaEnvironment::ThrowException(env, e.what());
320 return NULL;
321 }
322 catch (...)
323 {
324 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
325 return NULL;
326 }
327 }
328
329
330 JNIEXPORT void JNI_OrthancPluginRestApiDelete(JNIEnv* env, jobject sdkObject, jstring arg0)
331 {
332 try
333 {
334 JavaString c_arg0(env, arg0);
335 OrthancPluginErrorCode code = OrthancPluginRestApiDelete(context_
336 , c_arg0.GetValue());
337 if (code != OrthancPluginErrorCode_Success)
338 {
339 JavaEnvironment::ThrowException(env, code);
340 }
341 }
342 catch (std::runtime_error& e)
343 {
344 JavaEnvironment::ThrowException(env, e.what());
345 }
346 catch (...)
347 {
348 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
349 }
350 }
351
352
353 JNIEXPORT void JNI_OrthancPluginRestApiDeleteAfterPlugins(JNIEnv* env, jobject sdkObject, jstring arg0)
354 {
355 try
356 {
357 JavaString c_arg0(env, arg0);
358 OrthancPluginErrorCode code = OrthancPluginRestApiDeleteAfterPlugins(context_
359 , c_arg0.GetValue());
360 if (code != OrthancPluginErrorCode_Success)
361 {
362 JavaEnvironment::ThrowException(env, code);
363 }
364 }
365 catch (std::runtime_error& e)
366 {
367 JavaEnvironment::ThrowException(env, e.what());
368 }
369 catch (...)
370 {
371 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
372 }
373 }
374
375
376 JNIEXPORT jbyteArray JNI_OrthancPluginRestApiPut(JNIEnv* env, jobject sdkObject, jstring arg0, jbyteArray arg1)
377 {
378 try
379 {
380 JavaString c_arg0(env, arg0);
381 JavaBytes c_arg1(env, arg1);
382 OrthancBytes b;
383 OrthancPluginErrorCode code = OrthancPluginRestApiPut(context_, b.GetMemoryBuffer()
384 , c_arg0.GetValue(), c_arg1.GetData(), c_arg1.GetSize());
385 if (code == OrthancPluginErrorCode_Success)
386 {
387 jbyteArray answer = env->NewByteArray(b.GetSize());
388 if (answer == NULL)
389 {
390 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
391 return NULL;
392 }
393 else
394 {
395 env->SetByteArrayRegion(answer, 0, b.GetSize(), reinterpret_cast<const jbyte*>(b.GetData()));
396 return answer;
397 }
398 }
399 else
400 {
401 JavaEnvironment::ThrowException(env, code);
402 return NULL;
403 }
404 }
405 catch (std::runtime_error& e)
406 {
407 JavaEnvironment::ThrowException(env, e.what());
408 return NULL;
409 }
410 catch (...)
411 {
412 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
413 return NULL;
414 }
415 }
416
417
418 JNIEXPORT jbyteArray JNI_OrthancPluginRestApiPutAfterPlugins(JNIEnv* env, jobject sdkObject, jstring arg0, jbyteArray arg1)
419 {
420 try
421 {
422 JavaString c_arg0(env, arg0);
423 JavaBytes c_arg1(env, arg1);
424 OrthancBytes b;
425 OrthancPluginErrorCode code = OrthancPluginRestApiPutAfterPlugins(context_, b.GetMemoryBuffer()
426 , c_arg0.GetValue(), c_arg1.GetData(), c_arg1.GetSize());
427 if (code == OrthancPluginErrorCode_Success)
428 {
429 jbyteArray answer = env->NewByteArray(b.GetSize());
430 if (answer == NULL)
431 {
432 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
433 return NULL;
434 }
435 else
436 {
437 env->SetByteArrayRegion(answer, 0, b.GetSize(), reinterpret_cast<const jbyte*>(b.GetData()));
438 return answer;
439 }
440 }
441 else
442 {
443 JavaEnvironment::ThrowException(env, code);
444 return NULL;
445 }
446 }
447 catch (std::runtime_error& e)
448 {
449 JavaEnvironment::ThrowException(env, e.what());
450 return NULL;
451 }
452 catch (...)
453 {
454 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
455 return NULL;
456 }
457 }
458
459
460 JNIEXPORT jstring JNI_OrthancPluginLookupPatient(JNIEnv* env, jobject sdkObject, jstring arg0)
461 {
462 try
463 {
464 JavaString c_arg0(env, arg0);
465 OrthancString s(OrthancPluginLookupPatient(context_
466 , c_arg0.GetValue()));
467 if (s.GetValue() == NULL)
468 {
469 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
470 return NULL;
471 }
472 else
473 {
474 jstring t = env->NewStringUTF(s.GetValue());
475 if (t == NULL)
476 {
477 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
478 return NULL;
479 }
480 else
481 {
482 return t;
483 }
484 }
485 }
486 catch (std::runtime_error& e)
487 {
488 JavaEnvironment::ThrowException(env, e.what());
489 return NULL;
490 }
491 catch (...)
492 {
493 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
494 return NULL;
495 }
496 }
497
498
499 JNIEXPORT jstring JNI_OrthancPluginLookupStudy(JNIEnv* env, jobject sdkObject, jstring arg0)
500 {
501 try
502 {
503 JavaString c_arg0(env, arg0);
504 OrthancString s(OrthancPluginLookupStudy(context_
505 , c_arg0.GetValue()));
506 if (s.GetValue() == NULL)
507 {
508 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
509 return NULL;
510 }
511 else
512 {
513 jstring t = env->NewStringUTF(s.GetValue());
514 if (t == NULL)
515 {
516 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
517 return NULL;
518 }
519 else
520 {
521 return t;
522 }
523 }
524 }
525 catch (std::runtime_error& e)
526 {
527 JavaEnvironment::ThrowException(env, e.what());
528 return NULL;
529 }
530 catch (...)
531 {
532 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
533 return NULL;
534 }
535 }
536
537
538 JNIEXPORT jstring JNI_OrthancPluginLookupStudyWithAccessionNumber(JNIEnv* env, jobject sdkObject, jstring arg0)
539 {
540 try
541 {
542 JavaString c_arg0(env, arg0);
543 OrthancString s(OrthancPluginLookupStudyWithAccessionNumber(context_
544 , c_arg0.GetValue()));
545 if (s.GetValue() == NULL)
546 {
547 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
548 return NULL;
549 }
550 else
551 {
552 jstring t = env->NewStringUTF(s.GetValue());
553 if (t == NULL)
554 {
555 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
556 return NULL;
557 }
558 else
559 {
560 return t;
561 }
562 }
563 }
564 catch (std::runtime_error& e)
565 {
566 JavaEnvironment::ThrowException(env, e.what());
567 return NULL;
568 }
569 catch (...)
570 {
571 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
572 return NULL;
573 }
574 }
575
576
577 JNIEXPORT jstring JNI_OrthancPluginLookupSeries(JNIEnv* env, jobject sdkObject, jstring arg0)
578 {
579 try
580 {
581 JavaString c_arg0(env, arg0);
582 OrthancString s(OrthancPluginLookupSeries(context_
583 , c_arg0.GetValue()));
584 if (s.GetValue() == NULL)
585 {
586 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
587 return NULL;
588 }
589 else
590 {
591 jstring t = env->NewStringUTF(s.GetValue());
592 if (t == NULL)
593 {
594 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
595 return NULL;
596 }
597 else
598 {
599 return t;
600 }
601 }
602 }
603 catch (std::runtime_error& e)
604 {
605 JavaEnvironment::ThrowException(env, e.what());
606 return NULL;
607 }
608 catch (...)
609 {
610 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
611 return NULL;
612 }
613 }
614
615
616 JNIEXPORT jstring JNI_OrthancPluginLookupInstance(JNIEnv* env, jobject sdkObject, jstring arg0)
617 {
618 try
619 {
620 JavaString c_arg0(env, arg0);
621 OrthancString s(OrthancPluginLookupInstance(context_
622 , c_arg0.GetValue()));
623 if (s.GetValue() == NULL)
624 {
625 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
626 return NULL;
627 }
628 else
629 {
630 jstring t = env->NewStringUTF(s.GetValue());
631 if (t == NULL)
632 {
633 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
634 return NULL;
635 }
636 else
637 {
638 return t;
639 }
640 }
641 }
642 catch (std::runtime_error& e)
643 {
644 JavaEnvironment::ThrowException(env, e.what());
645 return NULL;
646 }
647 catch (...)
648 {
649 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
650 return NULL;
651 }
652 }
653
654
655 JNIEXPORT jstring JNI_OrthancPluginGetOrthancPath(JNIEnv* env, jobject sdkObject)
656 {
657 try
658 {
659 OrthancString s(OrthancPluginGetOrthancPath(context_
660 ));
661 if (s.GetValue() == NULL)
662 {
663 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
664 return NULL;
665 }
666 else
667 {
668 jstring t = env->NewStringUTF(s.GetValue());
669 if (t == NULL)
670 {
671 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
672 return NULL;
673 }
674 else
675 {
676 return t;
677 }
678 }
679 }
680 catch (std::runtime_error& e)
681 {
682 JavaEnvironment::ThrowException(env, e.what());
683 return NULL;
684 }
685 catch (...)
686 {
687 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
688 return NULL;
689 }
690 }
691
692
693 JNIEXPORT jstring JNI_OrthancPluginGetOrthancDirectory(JNIEnv* env, jobject sdkObject)
694 {
695 try
696 {
697 OrthancString s(OrthancPluginGetOrthancDirectory(context_
698 ));
699 if (s.GetValue() == NULL)
700 {
701 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
702 return NULL;
703 }
704 else
705 {
706 jstring t = env->NewStringUTF(s.GetValue());
707 if (t == NULL)
708 {
709 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
710 return NULL;
711 }
712 else
713 {
714 return t;
715 }
716 }
717 }
718 catch (std::runtime_error& e)
719 {
720 JavaEnvironment::ThrowException(env, e.what());
721 return NULL;
722 }
723 catch (...)
724 {
725 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
726 return NULL;
727 }
728 }
729
730
731 JNIEXPORT jstring JNI_OrthancPluginGetConfigurationPath(JNIEnv* env, jobject sdkObject)
732 {
733 try
734 {
735 OrthancString s(OrthancPluginGetConfigurationPath(context_
736 ));
737 if (s.GetValue() == NULL)
738 {
739 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
740 return NULL;
741 }
742 else
743 {
744 jstring t = env->NewStringUTF(s.GetValue());
745 if (t == NULL)
746 {
747 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
748 return NULL;
749 }
750 else
751 {
752 return t;
753 }
754 }
755 }
756 catch (std::runtime_error& e)
757 {
758 JavaEnvironment::ThrowException(env, e.what());
759 return NULL;
760 }
761 catch (...)
762 {
763 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
764 return NULL;
765 }
766 }
767
768
769 JNIEXPORT void JNI_OrthancPluginSetRootUri(JNIEnv* env, jobject sdkObject, jstring arg0)
770 {
771 try
772 {
773 JavaString c_arg0(env, arg0);
774 OrthancPluginSetRootUri(context_
775 , c_arg0.GetValue());
776 }
777 catch (std::runtime_error& e)
778 {
779 JavaEnvironment::ThrowException(env, e.what());
780 }
781 catch (...)
782 {
783 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
784 }
785 }
786
787
788 JNIEXPORT void JNI_OrthancPluginSetDescription(JNIEnv* env, jobject sdkObject, jstring arg0)
789 {
790 try
791 {
792 JavaString c_arg0(env, arg0);
793 OrthancPluginSetDescription(context_
794 , c_arg0.GetValue());
795 }
796 catch (std::runtime_error& e)
797 {
798 JavaEnvironment::ThrowException(env, e.what());
799 }
800 catch (...)
801 {
802 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
803 }
804 }
805
806
807 JNIEXPORT void JNI_OrthancPluginExtendOrthancExplorer(JNIEnv* env, jobject sdkObject, jstring arg0)
808 {
809 try
810 {
811 JavaString c_arg0(env, arg0);
812 OrthancPluginExtendOrthancExplorer(context_
813 , c_arg0.GetValue());
814 }
815 catch (std::runtime_error& e)
816 {
817 JavaEnvironment::ThrowException(env, e.what());
818 }
819 catch (...)
820 {
821 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
822 }
823 }
824
825
826 JNIEXPORT jstring JNI_OrthancPluginGetGlobalProperty(JNIEnv* env, jobject sdkObject, jint arg0, jstring arg1)
827 {
828 try
829 {
830 JavaString c_arg1(env, arg1);
831 OrthancString s(OrthancPluginGetGlobalProperty(context_
832 , arg0, c_arg1.GetValue()));
833 if (s.GetValue() == NULL)
834 {
835 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
836 return NULL;
837 }
838 else
839 {
840 jstring t = env->NewStringUTF(s.GetValue());
841 if (t == NULL)
842 {
843 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
844 return NULL;
845 }
846 else
847 {
848 return t;
849 }
850 }
851 }
852 catch (std::runtime_error& e)
853 {
854 JavaEnvironment::ThrowException(env, e.what());
855 return NULL;
856 }
857 catch (...)
858 {
859 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
860 return NULL;
861 }
862 }
863
864
865 JNIEXPORT void JNI_OrthancPluginSetGlobalProperty(JNIEnv* env, jobject sdkObject, jint arg0, jstring arg1)
866 {
867 try
868 {
869 JavaString c_arg1(env, arg1);
870 OrthancPluginErrorCode code = OrthancPluginSetGlobalProperty(context_
871 , arg0, c_arg1.GetValue());
872 if (code != OrthancPluginErrorCode_Success)
873 {
874 JavaEnvironment::ThrowException(env, code);
875 }
876 }
877 catch (std::runtime_error& e)
878 {
879 JavaEnvironment::ThrowException(env, e.what());
880 }
881 catch (...)
882 {
883 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
884 }
885 }
886
887
888 JNIEXPORT jint JNI_OrthancPluginGetCommandLineArgumentsCount(JNIEnv* env, jobject sdkObject)
889 {
890 try
891 {
892 return OrthancPluginGetCommandLineArgumentsCount(context_
893 );
894 }
895 catch (std::runtime_error& e)
896 {
897 JavaEnvironment::ThrowException(env, e.what());
898 return 0;
899 }
900 catch (...)
901 {
902 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
903 return 0;
904 }
905 }
906
907
908 JNIEXPORT jstring JNI_OrthancPluginGetCommandLineArgument(JNIEnv* env, jobject sdkObject, jint arg0)
909 {
910 try
911 {
912 OrthancString s(OrthancPluginGetCommandLineArgument(context_
913 , arg0));
914 if (s.GetValue() == NULL)
915 {
916 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
917 return NULL;
918 }
919 else
920 {
921 jstring t = env->NewStringUTF(s.GetValue());
922 if (t == NULL)
923 {
924 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
925 return NULL;
926 }
927 else
928 {
929 return t;
930 }
931 }
932 }
933 catch (std::runtime_error& e)
934 {
935 JavaEnvironment::ThrowException(env, e.what());
936 return NULL;
937 }
938 catch (...)
939 {
940 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
941 return NULL;
942 }
943 }
944
945
946 JNIEXPORT jint JNI_OrthancPluginGetExpectedDatabaseVersion(JNIEnv* env, jobject sdkObject)
947 {
948 try
949 {
950 return OrthancPluginGetExpectedDatabaseVersion(context_
951 );
952 }
953 catch (std::runtime_error& e)
954 {
955 JavaEnvironment::ThrowException(env, e.what());
956 return 0;
957 }
958 catch (...)
959 {
960 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
961 return 0;
962 }
963 }
964
965
966 JNIEXPORT jstring JNI_OrthancPluginGetConfiguration(JNIEnv* env, jobject sdkObject)
967 {
968 try
969 {
970 OrthancString s(OrthancPluginGetConfiguration(context_
971 ));
972 if (s.GetValue() == NULL)
973 {
974 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
975 return NULL;
976 }
977 else
978 {
979 jstring t = env->NewStringUTF(s.GetValue());
980 if (t == NULL)
981 {
982 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
983 return NULL;
984 }
985 else
986 {
987 return t;
988 }
989 }
990 }
991 catch (std::runtime_error& e)
992 {
993 JavaEnvironment::ThrowException(env, e.what());
994 return NULL;
995 }
996 catch (...)
997 {
998 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
999 return NULL;
1000 }
1001 }
1002
1003
1004 JNIEXPORT jbyteArray JNI_OrthancPluginBufferCompression(JNIEnv* env, jobject sdkObject, jbyteArray arg0, jint arg2, jbyte arg3)
1005 {
1006 try
1007 {
1008 JavaBytes c_arg0(env, arg0);
1009 OrthancBytes b;
1010 OrthancPluginErrorCode code = OrthancPluginBufferCompression(context_, b.GetMemoryBuffer()
1011 , c_arg0.GetData(), c_arg0.GetSize(), static_cast<OrthancPluginCompressionType>(arg2), arg3);
1012 if (code == OrthancPluginErrorCode_Success)
1013 {
1014 jbyteArray answer = env->NewByteArray(b.GetSize());
1015 if (answer == NULL)
1016 {
1017 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
1018 return NULL;
1019 }
1020 else
1021 {
1022 env->SetByteArrayRegion(answer, 0, b.GetSize(), reinterpret_cast<const jbyte*>(b.GetData()));
1023 return answer;
1024 }
1025 }
1026 else
1027 {
1028 JavaEnvironment::ThrowException(env, code);
1029 return NULL;
1030 }
1031 }
1032 catch (std::runtime_error& e)
1033 {
1034 JavaEnvironment::ThrowException(env, e.what());
1035 return NULL;
1036 }
1037 catch (...)
1038 {
1039 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1040 return NULL;
1041 }
1042 }
1043
1044
1045 JNIEXPORT jbyteArray JNI_OrthancPluginReadFile(JNIEnv* env, jobject sdkObject, jstring arg0)
1046 {
1047 try
1048 {
1049 JavaString c_arg0(env, arg0);
1050 OrthancBytes b;
1051 OrthancPluginErrorCode code = OrthancPluginReadFile(context_, b.GetMemoryBuffer()
1052 , c_arg0.GetValue());
1053 if (code == OrthancPluginErrorCode_Success)
1054 {
1055 jbyteArray answer = env->NewByteArray(b.GetSize());
1056 if (answer == NULL)
1057 {
1058 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
1059 return NULL;
1060 }
1061 else
1062 {
1063 env->SetByteArrayRegion(answer, 0, b.GetSize(), reinterpret_cast<const jbyte*>(b.GetData()));
1064 return answer;
1065 }
1066 }
1067 else
1068 {
1069 JavaEnvironment::ThrowException(env, code);
1070 return NULL;
1071 }
1072 }
1073 catch (std::runtime_error& e)
1074 {
1075 JavaEnvironment::ThrowException(env, e.what());
1076 return NULL;
1077 }
1078 catch (...)
1079 {
1080 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1081 return NULL;
1082 }
1083 }
1084
1085
1086 JNIEXPORT void JNI_OrthancPluginWriteFile(JNIEnv* env, jobject sdkObject, jstring arg0, jbyteArray arg1)
1087 {
1088 try
1089 {
1090 JavaString c_arg0(env, arg0);
1091 JavaBytes c_arg1(env, arg1);
1092 OrthancPluginErrorCode code = OrthancPluginWriteFile(context_
1093 , c_arg0.GetValue(), c_arg1.GetData(), c_arg1.GetSize());
1094 if (code != OrthancPluginErrorCode_Success)
1095 {
1096 JavaEnvironment::ThrowException(env, code);
1097 }
1098 }
1099 catch (std::runtime_error& e)
1100 {
1101 JavaEnvironment::ThrowException(env, e.what());
1102 }
1103 catch (...)
1104 {
1105 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1106 }
1107 }
1108
1109
1110 JNIEXPORT jstring JNI_OrthancPluginGetErrorDescription(JNIEnv* env, jobject sdkObject, jint arg0)
1111 {
1112 try
1113 {
1114 const char* s = OrthancPluginGetErrorDescription(context_
1115 , static_cast<OrthancPluginErrorCode>(arg0));
1116 if (s == NULL)
1117 {
1118 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1119 return NULL;
1120 }
1121 else
1122 {
1123 return env->NewStringUTF(s);
1124 }
1125 }
1126 catch (std::runtime_error& e)
1127 {
1128 JavaEnvironment::ThrowException(env, e.what());
1129 return NULL;
1130 }
1131 catch (...)
1132 {
1133 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1134 return NULL;
1135 }
1136 }
1137
1138
1139 JNIEXPORT jlong JNI_OrthancPluginUncompressImage(JNIEnv* env, jobject sdkObject, jbyteArray arg0, jint arg2)
1140 {
1141 try
1142 {
1143 JavaBytes c_arg0(env, arg0);
1144 OrthancPluginImage* answer = OrthancPluginUncompressImage(context_
1145 , c_arg0.GetData(), c_arg0.GetSize(), static_cast<OrthancPluginImageFormat>(arg2));
1146 if (answer == NULL)
1147 {
1148 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1149 return 0;
1150 }
1151 else
1152 {
1153 return reinterpret_cast<intptr_t>(answer);
1154 }
1155 }
1156 catch (std::runtime_error& e)
1157 {
1158 JavaEnvironment::ThrowException(env, e.what());
1159 return 0;
1160 }
1161 catch (...)
1162 {
1163 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1164 return 0;
1165 }
1166 }
1167
1168
1169 JNIEXPORT jbyteArray JNI_OrthancPluginCompressPngImage(JNIEnv* env, jobject sdkObject, jint arg0, jint arg1, jint arg2, jint arg3, jbyteArray arg4)
1170 {
1171 try
1172 {
1173 JavaBytes c_arg4(env, arg4);
1174 OrthancBytes b;
1175 OrthancPluginErrorCode code = OrthancPluginCompressPngImage(context_, b.GetMemoryBuffer()
1176 , static_cast<OrthancPluginPixelFormat>(arg0), arg1, arg2, arg3, c_arg4.GetData());
1177 if (code == OrthancPluginErrorCode_Success)
1178 {
1179 jbyteArray answer = env->NewByteArray(b.GetSize());
1180 if (answer == NULL)
1181 {
1182 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
1183 return NULL;
1184 }
1185 else
1186 {
1187 env->SetByteArrayRegion(answer, 0, b.GetSize(), reinterpret_cast<const jbyte*>(b.GetData()));
1188 return answer;
1189 }
1190 }
1191 else
1192 {
1193 JavaEnvironment::ThrowException(env, code);
1194 return NULL;
1195 }
1196 }
1197 catch (std::runtime_error& e)
1198 {
1199 JavaEnvironment::ThrowException(env, e.what());
1200 return NULL;
1201 }
1202 catch (...)
1203 {
1204 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1205 return NULL;
1206 }
1207 }
1208
1209
1210 JNIEXPORT jbyteArray JNI_OrthancPluginCompressJpegImage(JNIEnv* env, jobject sdkObject, jint arg0, jint arg1, jint arg2, jint arg3, jbyteArray arg4, jbyte arg5)
1211 {
1212 try
1213 {
1214 JavaBytes c_arg4(env, arg4);
1215 OrthancBytes b;
1216 OrthancPluginErrorCode code = OrthancPluginCompressJpegImage(context_, b.GetMemoryBuffer()
1217 , static_cast<OrthancPluginPixelFormat>(arg0), arg1, arg2, arg3, c_arg4.GetData(), arg5);
1218 if (code == OrthancPluginErrorCode_Success)
1219 {
1220 jbyteArray answer = env->NewByteArray(b.GetSize());
1221 if (answer == NULL)
1222 {
1223 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
1224 return NULL;
1225 }
1226 else
1227 {
1228 env->SetByteArrayRegion(answer, 0, b.GetSize(), reinterpret_cast<const jbyte*>(b.GetData()));
1229 return answer;
1230 }
1231 }
1232 else
1233 {
1234 JavaEnvironment::ThrowException(env, code);
1235 return NULL;
1236 }
1237 }
1238 catch (std::runtime_error& e)
1239 {
1240 JavaEnvironment::ThrowException(env, e.what());
1241 return NULL;
1242 }
1243 catch (...)
1244 {
1245 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1246 return NULL;
1247 }
1248 }
1249
1250
1251 JNIEXPORT jbyteArray JNI_OrthancPluginHttpGet(JNIEnv* env, jobject sdkObject, jstring arg0, jstring arg1, jstring arg2)
1252 {
1253 try
1254 {
1255 JavaString c_arg0(env, arg0);
1256 JavaString c_arg1(env, arg1);
1257 JavaString c_arg2(env, arg2);
1258 OrthancBytes b;
1259 OrthancPluginErrorCode code = OrthancPluginHttpGet(context_, b.GetMemoryBuffer()
1260 , c_arg0.GetValue(), c_arg1.GetValue(), c_arg2.GetValue());
1261 if (code == OrthancPluginErrorCode_Success)
1262 {
1263 jbyteArray answer = env->NewByteArray(b.GetSize());
1264 if (answer == NULL)
1265 {
1266 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
1267 return NULL;
1268 }
1269 else
1270 {
1271 env->SetByteArrayRegion(answer, 0, b.GetSize(), reinterpret_cast<const jbyte*>(b.GetData()));
1272 return answer;
1273 }
1274 }
1275 else
1276 {
1277 JavaEnvironment::ThrowException(env, code);
1278 return NULL;
1279 }
1280 }
1281 catch (std::runtime_error& e)
1282 {
1283 JavaEnvironment::ThrowException(env, e.what());
1284 return NULL;
1285 }
1286 catch (...)
1287 {
1288 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1289 return NULL;
1290 }
1291 }
1292
1293
1294 JNIEXPORT jbyteArray JNI_OrthancPluginHttpPost(JNIEnv* env, jobject sdkObject, jstring arg0, jbyteArray arg1, jstring arg3, jstring arg4)
1295 {
1296 try
1297 {
1298 JavaString c_arg0(env, arg0);
1299 JavaBytes c_arg1(env, arg1);
1300 JavaString c_arg3(env, arg3);
1301 JavaString c_arg4(env, arg4);
1302 OrthancBytes b;
1303 OrthancPluginErrorCode code = OrthancPluginHttpPost(context_, b.GetMemoryBuffer()
1304 , c_arg0.GetValue(), c_arg1.GetData(), c_arg1.GetSize(), c_arg3.GetValue(), c_arg4.GetValue());
1305 if (code == OrthancPluginErrorCode_Success)
1306 {
1307 jbyteArray answer = env->NewByteArray(b.GetSize());
1308 if (answer == NULL)
1309 {
1310 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
1311 return NULL;
1312 }
1313 else
1314 {
1315 env->SetByteArrayRegion(answer, 0, b.GetSize(), reinterpret_cast<const jbyte*>(b.GetData()));
1316 return answer;
1317 }
1318 }
1319 else
1320 {
1321 JavaEnvironment::ThrowException(env, code);
1322 return NULL;
1323 }
1324 }
1325 catch (std::runtime_error& e)
1326 {
1327 JavaEnvironment::ThrowException(env, e.what());
1328 return NULL;
1329 }
1330 catch (...)
1331 {
1332 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1333 return NULL;
1334 }
1335 }
1336
1337
1338 JNIEXPORT jbyteArray JNI_OrthancPluginHttpPut(JNIEnv* env, jobject sdkObject, jstring arg0, jbyteArray arg1, jstring arg3, jstring arg4)
1339 {
1340 try
1341 {
1342 JavaString c_arg0(env, arg0);
1343 JavaBytes c_arg1(env, arg1);
1344 JavaString c_arg3(env, arg3);
1345 JavaString c_arg4(env, arg4);
1346 OrthancBytes b;
1347 OrthancPluginErrorCode code = OrthancPluginHttpPut(context_, b.GetMemoryBuffer()
1348 , c_arg0.GetValue(), c_arg1.GetData(), c_arg1.GetSize(), c_arg3.GetValue(), c_arg4.GetValue());
1349 if (code == OrthancPluginErrorCode_Success)
1350 {
1351 jbyteArray answer = env->NewByteArray(b.GetSize());
1352 if (answer == NULL)
1353 {
1354 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
1355 return NULL;
1356 }
1357 else
1358 {
1359 env->SetByteArrayRegion(answer, 0, b.GetSize(), reinterpret_cast<const jbyte*>(b.GetData()));
1360 return answer;
1361 }
1362 }
1363 else
1364 {
1365 JavaEnvironment::ThrowException(env, code);
1366 return NULL;
1367 }
1368 }
1369 catch (std::runtime_error& e)
1370 {
1371 JavaEnvironment::ThrowException(env, e.what());
1372 return NULL;
1373 }
1374 catch (...)
1375 {
1376 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1377 return NULL;
1378 }
1379 }
1380
1381
1382 JNIEXPORT void JNI_OrthancPluginHttpDelete(JNIEnv* env, jobject sdkObject, jstring arg0, jstring arg1, jstring arg2)
1383 {
1384 try
1385 {
1386 JavaString c_arg0(env, arg0);
1387 JavaString c_arg1(env, arg1);
1388 JavaString c_arg2(env, arg2);
1389 OrthancPluginErrorCode code = OrthancPluginHttpDelete(context_
1390 , c_arg0.GetValue(), c_arg1.GetValue(), c_arg2.GetValue());
1391 if (code != OrthancPluginErrorCode_Success)
1392 {
1393 JavaEnvironment::ThrowException(env, code);
1394 }
1395 }
1396 catch (std::runtime_error& e)
1397 {
1398 JavaEnvironment::ThrowException(env, e.what());
1399 }
1400 catch (...)
1401 {
1402 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1403 }
1404 }
1405
1406
1407 JNIEXPORT jint JNI_OrthancPluginGetFontsCount(JNIEnv* env, jobject sdkObject)
1408 {
1409 try
1410 {
1411 return OrthancPluginGetFontsCount(context_
1412 );
1413 }
1414 catch (std::runtime_error& e)
1415 {
1416 JavaEnvironment::ThrowException(env, e.what());
1417 return 0;
1418 }
1419 catch (...)
1420 {
1421 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1422 return 0;
1423 }
1424 }
1425
1426
1427 JNIEXPORT jstring JNI_OrthancPluginGetFontName(JNIEnv* env, jobject sdkObject, jint arg0)
1428 {
1429 try
1430 {
1431 const char* s = OrthancPluginGetFontName(context_
1432 , arg0);
1433 if (s == NULL)
1434 {
1435 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1436 return NULL;
1437 }
1438 else
1439 {
1440 return env->NewStringUTF(s);
1441 }
1442 }
1443 catch (std::runtime_error& e)
1444 {
1445 JavaEnvironment::ThrowException(env, e.what());
1446 return NULL;
1447 }
1448 catch (...)
1449 {
1450 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1451 return NULL;
1452 }
1453 }
1454
1455
1456 JNIEXPORT jint JNI_OrthancPluginGetFontSize(JNIEnv* env, jobject sdkObject, jint arg0)
1457 {
1458 try
1459 {
1460 return OrthancPluginGetFontSize(context_
1461 , arg0);
1462 }
1463 catch (std::runtime_error& e)
1464 {
1465 JavaEnvironment::ThrowException(env, e.what());
1466 return 0;
1467 }
1468 catch (...)
1469 {
1470 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1471 return 0;
1472 }
1473 }
1474
1475
1476 JNIEXPORT void JNI_OrthancPluginRegisterErrorCode(JNIEnv* env, jobject sdkObject, jint arg0, jshort arg1, jstring arg2)
1477 {
1478 try
1479 {
1480 JavaString c_arg2(env, arg2);
1481 OrthancPluginErrorCode code = OrthancPluginRegisterErrorCode(context_
1482 , arg0, arg1, c_arg2.GetValue());
1483 if (code != OrthancPluginErrorCode_Success)
1484 {
1485 JavaEnvironment::ThrowException(env, code);
1486 }
1487 }
1488 catch (std::runtime_error& e)
1489 {
1490 JavaEnvironment::ThrowException(env, e.what());
1491 }
1492 catch (...)
1493 {
1494 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1495 }
1496 }
1497
1498
1499 JNIEXPORT void JNI_OrthancPluginRegisterDictionaryTag(JNIEnv* env, jobject sdkObject, jshort arg0, jshort arg1, jint arg2, jstring arg3, jint arg4, jint arg5)
1500 {
1501 try
1502 {
1503 JavaString c_arg3(env, arg3);
1504 OrthancPluginErrorCode code = OrthancPluginRegisterDictionaryTag(context_
1505 , arg0, arg1, static_cast<OrthancPluginValueRepresentation>(arg2), c_arg3.GetValue(), arg4, arg5);
1506 if (code != OrthancPluginErrorCode_Success)
1507 {
1508 JavaEnvironment::ThrowException(env, code);
1509 }
1510 }
1511 catch (std::runtime_error& e)
1512 {
1513 JavaEnvironment::ThrowException(env, e.what());
1514 }
1515 catch (...)
1516 {
1517 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1518 }
1519 }
1520
1521
1522 JNIEXPORT void JNI_OrthancPluginRegisterPrivateDictionaryTag(JNIEnv* env, jobject sdkObject, jshort arg0, jshort arg1, jint arg2, jstring arg3, jint arg4, jint arg5, jstring arg6)
1523 {
1524 try
1525 {
1526 JavaString c_arg3(env, arg3);
1527 JavaString c_arg6(env, arg6);
1528 OrthancPluginErrorCode code = OrthancPluginRegisterPrivateDictionaryTag(context_
1529 , arg0, arg1, static_cast<OrthancPluginValueRepresentation>(arg2), c_arg3.GetValue(), arg4, arg5, c_arg6.GetValue());
1530 if (code != OrthancPluginErrorCode_Success)
1531 {
1532 JavaEnvironment::ThrowException(env, code);
1533 }
1534 }
1535 catch (std::runtime_error& e)
1536 {
1537 JavaEnvironment::ThrowException(env, e.what());
1538 }
1539 catch (...)
1540 {
1541 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1542 }
1543 }
1544
1545
1546 JNIEXPORT jstring JNI_OrthancPluginDicomBufferToJson(JNIEnv* env, jobject sdkObject, jbyteArray arg0, jint arg2, jint arg3, jint arg4)
1547 {
1548 try
1549 {
1550 JavaBytes c_arg0(env, arg0);
1551 OrthancString s(OrthancPluginDicomBufferToJson(context_
1552 , c_arg0.GetData(), c_arg0.GetSize(), static_cast<OrthancPluginDicomToJsonFormat>(arg2), static_cast<OrthancPluginDicomToJsonFlags>(arg3), arg4));
1553 if (s.GetValue() == NULL)
1554 {
1555 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1556 return NULL;
1557 }
1558 else
1559 {
1560 jstring t = env->NewStringUTF(s.GetValue());
1561 if (t == NULL)
1562 {
1563 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
1564 return NULL;
1565 }
1566 else
1567 {
1568 return t;
1569 }
1570 }
1571 }
1572 catch (std::runtime_error& e)
1573 {
1574 JavaEnvironment::ThrowException(env, e.what());
1575 return NULL;
1576 }
1577 catch (...)
1578 {
1579 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1580 return NULL;
1581 }
1582 }
1583
1584
1585 JNIEXPORT jstring JNI_OrthancPluginDicomInstanceToJson(JNIEnv* env, jobject sdkObject, jstring arg0, jint arg1, jint arg2, jint arg3)
1586 {
1587 try
1588 {
1589 JavaString c_arg0(env, arg0);
1590 OrthancString s(OrthancPluginDicomInstanceToJson(context_
1591 , c_arg0.GetValue(), static_cast<OrthancPluginDicomToJsonFormat>(arg1), static_cast<OrthancPluginDicomToJsonFlags>(arg2), arg3));
1592 if (s.GetValue() == NULL)
1593 {
1594 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1595 return NULL;
1596 }
1597 else
1598 {
1599 jstring t = env->NewStringUTF(s.GetValue());
1600 if (t == NULL)
1601 {
1602 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
1603 return NULL;
1604 }
1605 else
1606 {
1607 return t;
1608 }
1609 }
1610 }
1611 catch (std::runtime_error& e)
1612 {
1613 JavaEnvironment::ThrowException(env, e.what());
1614 return NULL;
1615 }
1616 catch (...)
1617 {
1618 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1619 return NULL;
1620 }
1621 }
1622
1623
1624 JNIEXPORT jbyteArray JNI_OrthancPluginCreateDicom(JNIEnv* env, jobject sdkObject, jstring arg0, jlong arg1, jint arg2)
1625 {
1626 try
1627 {
1628 JavaString c_arg0(env, arg0);
1629 OrthancBytes b;
1630 OrthancPluginErrorCode code = OrthancPluginCreateDicom(context_, b.GetMemoryBuffer()
1631 , c_arg0.GetValue(), reinterpret_cast<OrthancPluginImage*>(static_cast<intptr_t>(arg1)), static_cast<OrthancPluginCreateDicomFlags>(arg2));
1632 if (code == OrthancPluginErrorCode_Success)
1633 {
1634 jbyteArray answer = env->NewByteArray(b.GetSize());
1635 if (answer == NULL)
1636 {
1637 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
1638 return NULL;
1639 }
1640 else
1641 {
1642 env->SetByteArrayRegion(answer, 0, b.GetSize(), reinterpret_cast<const jbyte*>(b.GetData()));
1643 return answer;
1644 }
1645 }
1646 else
1647 {
1648 JavaEnvironment::ThrowException(env, code);
1649 return NULL;
1650 }
1651 }
1652 catch (std::runtime_error& e)
1653 {
1654 JavaEnvironment::ThrowException(env, e.what());
1655 return NULL;
1656 }
1657 catch (...)
1658 {
1659 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1660 return NULL;
1661 }
1662 }
1663
1664
1665 JNIEXPORT jlong JNI_OrthancPluginCreateImage(JNIEnv* env, jobject sdkObject, jint arg0, jint arg1, jint arg2)
1666 {
1667 try
1668 {
1669 OrthancPluginImage* answer = OrthancPluginCreateImage(context_
1670 , static_cast<OrthancPluginPixelFormat>(arg0), arg1, arg2);
1671 if (answer == NULL)
1672 {
1673 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1674 return 0;
1675 }
1676 else
1677 {
1678 return reinterpret_cast<intptr_t>(answer);
1679 }
1680 }
1681 catch (std::runtime_error& e)
1682 {
1683 JavaEnvironment::ThrowException(env, e.what());
1684 return 0;
1685 }
1686 catch (...)
1687 {
1688 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1689 return 0;
1690 }
1691 }
1692
1693
1694 JNIEXPORT jlong JNI_OrthancPluginDecodeDicomImage(JNIEnv* env, jobject sdkObject, jbyteArray arg0, jint arg2)
1695 {
1696 try
1697 {
1698 JavaBytes c_arg0(env, arg0);
1699 OrthancPluginImage* answer = OrthancPluginDecodeDicomImage(context_
1700 , c_arg0.GetData(), c_arg0.GetSize(), arg2);
1701 if (answer == NULL)
1702 {
1703 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1704 return 0;
1705 }
1706 else
1707 {
1708 return reinterpret_cast<intptr_t>(answer);
1709 }
1710 }
1711 catch (std::runtime_error& e)
1712 {
1713 JavaEnvironment::ThrowException(env, e.what());
1714 return 0;
1715 }
1716 catch (...)
1717 {
1718 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1719 return 0;
1720 }
1721 }
1722
1723
1724 JNIEXPORT jstring JNI_OrthancPluginComputeMd5(JNIEnv* env, jobject sdkObject, jbyteArray arg0)
1725 {
1726 try
1727 {
1728 JavaBytes c_arg0(env, arg0);
1729 OrthancString s(OrthancPluginComputeMd5(context_
1730 , c_arg0.GetData(), c_arg0.GetSize()));
1731 if (s.GetValue() == NULL)
1732 {
1733 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1734 return NULL;
1735 }
1736 else
1737 {
1738 jstring t = env->NewStringUTF(s.GetValue());
1739 if (t == NULL)
1740 {
1741 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
1742 return NULL;
1743 }
1744 else
1745 {
1746 return t;
1747 }
1748 }
1749 }
1750 catch (std::runtime_error& e)
1751 {
1752 JavaEnvironment::ThrowException(env, e.what());
1753 return NULL;
1754 }
1755 catch (...)
1756 {
1757 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1758 return NULL;
1759 }
1760 }
1761
1762
1763 JNIEXPORT jstring JNI_OrthancPluginComputeSha1(JNIEnv* env, jobject sdkObject, jbyteArray arg0)
1764 {
1765 try
1766 {
1767 JavaBytes c_arg0(env, arg0);
1768 OrthancString s(OrthancPluginComputeSha1(context_
1769 , c_arg0.GetData(), c_arg0.GetSize()));
1770 if (s.GetValue() == NULL)
1771 {
1772 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1773 return NULL;
1774 }
1775 else
1776 {
1777 jstring t = env->NewStringUTF(s.GetValue());
1778 if (t == NULL)
1779 {
1780 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
1781 return NULL;
1782 }
1783 else
1784 {
1785 return t;
1786 }
1787 }
1788 }
1789 catch (std::runtime_error& e)
1790 {
1791 JavaEnvironment::ThrowException(env, e.what());
1792 return NULL;
1793 }
1794 catch (...)
1795 {
1796 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1797 return NULL;
1798 }
1799 }
1800
1801
1802 JNIEXPORT jstring JNI_OrthancPluginGenerateUuid(JNIEnv* env, jobject sdkObject)
1803 {
1804 try
1805 {
1806 OrthancString s(OrthancPluginGenerateUuid(context_
1807 ));
1808 if (s.GetValue() == NULL)
1809 {
1810 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1811 return NULL;
1812 }
1813 else
1814 {
1815 jstring t = env->NewStringUTF(s.GetValue());
1816 if (t == NULL)
1817 {
1818 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
1819 return NULL;
1820 }
1821 else
1822 {
1823 return t;
1824 }
1825 }
1826 }
1827 catch (std::runtime_error& e)
1828 {
1829 JavaEnvironment::ThrowException(env, e.what());
1830 return NULL;
1831 }
1832 catch (...)
1833 {
1834 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1835 return NULL;
1836 }
1837 }
1838
1839
1840 JNIEXPORT jlong JNI_OrthancPluginCreateFindMatcher(JNIEnv* env, jobject sdkObject, jbyteArray arg0)
1841 {
1842 try
1843 {
1844 JavaBytes c_arg0(env, arg0);
1845 OrthancPluginFindMatcher* answer = OrthancPluginCreateFindMatcher(context_
1846 , c_arg0.GetData(), c_arg0.GetSize());
1847 if (answer == NULL)
1848 {
1849 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1850 return 0;
1851 }
1852 else
1853 {
1854 return reinterpret_cast<intptr_t>(answer);
1855 }
1856 }
1857 catch (std::runtime_error& e)
1858 {
1859 JavaEnvironment::ThrowException(env, e.what());
1860 return 0;
1861 }
1862 catch (...)
1863 {
1864 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1865 return 0;
1866 }
1867 }
1868
1869
1870 JNIEXPORT jlong JNI_OrthancPluginGetPeers(JNIEnv* env, jobject sdkObject)
1871 {
1872 try
1873 {
1874 OrthancPluginPeers* answer = OrthancPluginGetPeers(context_
1875 );
1876 if (answer == NULL)
1877 {
1878 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1879 return 0;
1880 }
1881 else
1882 {
1883 return reinterpret_cast<intptr_t>(answer);
1884 }
1885 }
1886 catch (std::runtime_error& e)
1887 {
1888 JavaEnvironment::ThrowException(env, e.what());
1889 return 0;
1890 }
1891 catch (...)
1892 {
1893 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1894 return 0;
1895 }
1896 }
1897
1898
1899 JNIEXPORT jstring JNI_OrthancPluginAutodetectMimeType(JNIEnv* env, jobject sdkObject, jstring arg0)
1900 {
1901 try
1902 {
1903 JavaString c_arg0(env, arg0);
1904 const char* s = OrthancPluginAutodetectMimeType(context_
1905 , c_arg0.GetValue());
1906 if (s == NULL)
1907 {
1908 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1909 return NULL;
1910 }
1911 else
1912 {
1913 return env->NewStringUTF(s);
1914 }
1915 }
1916 catch (std::runtime_error& e)
1917 {
1918 JavaEnvironment::ThrowException(env, e.what());
1919 return NULL;
1920 }
1921 catch (...)
1922 {
1923 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1924 return NULL;
1925 }
1926 }
1927
1928
1929 JNIEXPORT void JNI_OrthancPluginSetMetricsValue(JNIEnv* env, jobject sdkObject, jstring arg0, jfloat arg1, jint arg2)
1930 {
1931 try
1932 {
1933 JavaString c_arg0(env, arg0);
1934 OrthancPluginSetMetricsValue(context_
1935 , c_arg0.GetValue(), arg1, static_cast<OrthancPluginMetricsType>(arg2));
1936 }
1937 catch (std::runtime_error& e)
1938 {
1939 JavaEnvironment::ThrowException(env, e.what());
1940 }
1941 catch (...)
1942 {
1943 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1944 }
1945 }
1946
1947
1948 JNIEXPORT jstring JNI_OrthancPluginGetTagName(JNIEnv* env, jobject sdkObject, jshort arg0, jshort arg1, jstring arg2)
1949 {
1950 try
1951 {
1952 JavaString c_arg2(env, arg2);
1953 OrthancString s(OrthancPluginGetTagName(context_
1954 , arg0, arg1, c_arg2.GetValue()));
1955 if (s.GetValue() == NULL)
1956 {
1957 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1958 return NULL;
1959 }
1960 else
1961 {
1962 jstring t = env->NewStringUTF(s.GetValue());
1963 if (t == NULL)
1964 {
1965 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
1966 return NULL;
1967 }
1968 else
1969 {
1970 return t;
1971 }
1972 }
1973 }
1974 catch (std::runtime_error& e)
1975 {
1976 JavaEnvironment::ThrowException(env, e.what());
1977 return NULL;
1978 }
1979 catch (...)
1980 {
1981 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1982 return NULL;
1983 }
1984 }
1985
1986
1987 JNIEXPORT jlong JNI_OrthancPluginCreateDicomInstance(JNIEnv* env, jobject sdkObject, jbyteArray arg0)
1988 {
1989 try
1990 {
1991 JavaBytes c_arg0(env, arg0);
1992 OrthancPluginDicomInstance* answer = OrthancPluginCreateDicomInstance(context_
1993 , c_arg0.GetData(), c_arg0.GetSize());
1994 if (answer == NULL)
1995 {
1996 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
1997 return 0;
1998 }
1999 else
2000 {
2001 return reinterpret_cast<intptr_t>(answer);
2002 }
2003 }
2004 catch (std::runtime_error& e)
2005 {
2006 JavaEnvironment::ThrowException(env, e.what());
2007 return 0;
2008 }
2009 catch (...)
2010 {
2011 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2012 return 0;
2013 }
2014 }
2015
2016
2017 JNIEXPORT jlong JNI_OrthancPluginTranscodeDicomInstance(JNIEnv* env, jobject sdkObject, jbyteArray arg0, jstring arg2)
2018 {
2019 try
2020 {
2021 JavaBytes c_arg0(env, arg0);
2022 JavaString c_arg2(env, arg2);
2023 OrthancPluginDicomInstance* answer = OrthancPluginTranscodeDicomInstance(context_
2024 , c_arg0.GetData(), c_arg0.GetSize(), c_arg2.GetValue());
2025 if (answer == NULL)
2026 {
2027 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2028 return 0;
2029 }
2030 else
2031 {
2032 return reinterpret_cast<intptr_t>(answer);
2033 }
2034 }
2035 catch (std::runtime_error& e)
2036 {
2037 JavaEnvironment::ThrowException(env, e.what());
2038 return 0;
2039 }
2040 catch (...)
2041 {
2042 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2043 return 0;
2044 }
2045 }
2046
2047
2048 JNIEXPORT jstring JNI_OrthancPluginGenerateRestApiAuthorizationToken(JNIEnv* env, jobject sdkObject)
2049 {
2050 try
2051 {
2052 OrthancString s(OrthancPluginGenerateRestApiAuthorizationToken(context_
2053 ));
2054 if (s.GetValue() == NULL)
2055 {
2056 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2057 return NULL;
2058 }
2059 else
2060 {
2061 jstring t = env->NewStringUTF(s.GetValue());
2062 if (t == NULL)
2063 {
2064 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
2065 return NULL;
2066 }
2067 else
2068 {
2069 return t;
2070 }
2071 }
2072 }
2073 catch (std::runtime_error& e)
2074 {
2075 JavaEnvironment::ThrowException(env, e.what());
2076 return NULL;
2077 }
2078 catch (...)
2079 {
2080 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2081 return NULL;
2082 }
2083 }
2084
2085
2086 JNIEXPORT jbyteArray JNI_OrthancPluginCreateDicom2(JNIEnv* env, jobject sdkObject, jstring arg0, jlong arg1, jint arg2, jstring arg3)
2087 {
2088 try
2089 {
2090 JavaString c_arg0(env, arg0);
2091 JavaString c_arg3(env, arg3);
2092 OrthancBytes b;
2093 OrthancPluginErrorCode code = OrthancPluginCreateDicom2(context_, b.GetMemoryBuffer()
2094 , c_arg0.GetValue(), reinterpret_cast<OrthancPluginImage*>(static_cast<intptr_t>(arg1)), static_cast<OrthancPluginCreateDicomFlags>(arg2), c_arg3.GetValue());
2095 if (code == OrthancPluginErrorCode_Success)
2096 {
2097 jbyteArray answer = env->NewByteArray(b.GetSize());
2098 if (answer == NULL)
2099 {
2100 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
2101 return NULL;
2102 }
2103 else
2104 {
2105 env->SetByteArrayRegion(answer, 0, b.GetSize(), reinterpret_cast<const jbyte*>(b.GetData()));
2106 return answer;
2107 }
2108 }
2109 else
2110 {
2111 JavaEnvironment::ThrowException(env, code);
2112 return NULL;
2113 }
2114 }
2115 catch (std::runtime_error& e)
2116 {
2117 JavaEnvironment::ThrowException(env, e.what());
2118 return NULL;
2119 }
2120 catch (...)
2121 {
2122 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2123 return NULL;
2124 }
2125 }
2126
2127
2128 JNIEXPORT void JNI_OrthancPluginFreeDicomInstance(JNIEnv* env, jobject sdkObject, jlong self)
2129 {
2130 try
2131 {
2132 OrthancPluginFreeDicomInstance(context_
2133 , reinterpret_cast<OrthancPluginDicomInstance*>(static_cast<intptr_t>(self))
2134 );
2135 }
2136 catch (std::runtime_error& e)
2137 {
2138 JavaEnvironment::ThrowException(env, e.what());
2139 }
2140 catch (...)
2141 {
2142 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2143 }
2144 }
2145
2146
2147 JNIEXPORT jstring JNI_OrthancPluginGetInstanceRemoteAet(JNIEnv* env, jobject sdkObject, jlong self)
2148 {
2149 try
2150 {
2151 const char* s = OrthancPluginGetInstanceRemoteAet(context_
2152 , reinterpret_cast<OrthancPluginDicomInstance*>(static_cast<intptr_t>(self))
2153 );
2154 if (s == NULL)
2155 {
2156 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2157 return NULL;
2158 }
2159 else
2160 {
2161 return env->NewStringUTF(s);
2162 }
2163 }
2164 catch (std::runtime_error& e)
2165 {
2166 JavaEnvironment::ThrowException(env, e.what());
2167 return NULL;
2168 }
2169 catch (...)
2170 {
2171 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2172 return NULL;
2173 }
2174 }
2175
2176
2177 JNIEXPORT jlong JNI_OrthancPluginGetInstanceSize(JNIEnv* env, jobject sdkObject, jlong self)
2178 {
2179 try
2180 {
2181 return OrthancPluginGetInstanceSize(context_
2182 , reinterpret_cast<OrthancPluginDicomInstance*>(static_cast<intptr_t>(self))
2183 );
2184 }
2185 catch (std::runtime_error& e)
2186 {
2187 JavaEnvironment::ThrowException(env, e.what());
2188 return 0;
2189 }
2190 catch (...)
2191 {
2192 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2193 return 0;
2194 }
2195 }
2196
2197
2198 JNIEXPORT jstring JNI_OrthancPluginGetInstanceJson(JNIEnv* env, jobject sdkObject, jlong self)
2199 {
2200 try
2201 {
2202 OrthancString s(OrthancPluginGetInstanceJson(context_
2203 , reinterpret_cast<OrthancPluginDicomInstance*>(static_cast<intptr_t>(self))
2204 ));
2205 if (s.GetValue() == NULL)
2206 {
2207 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2208 return NULL;
2209 }
2210 else
2211 {
2212 jstring t = env->NewStringUTF(s.GetValue());
2213 if (t == NULL)
2214 {
2215 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
2216 return NULL;
2217 }
2218 else
2219 {
2220 return t;
2221 }
2222 }
2223 }
2224 catch (std::runtime_error& e)
2225 {
2226 JavaEnvironment::ThrowException(env, e.what());
2227 return NULL;
2228 }
2229 catch (...)
2230 {
2231 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2232 return NULL;
2233 }
2234 }
2235
2236
2237 JNIEXPORT jstring JNI_OrthancPluginGetInstanceSimplifiedJson(JNIEnv* env, jobject sdkObject, jlong self)
2238 {
2239 try
2240 {
2241 OrthancString s(OrthancPluginGetInstanceSimplifiedJson(context_
2242 , reinterpret_cast<OrthancPluginDicomInstance*>(static_cast<intptr_t>(self))
2243 ));
2244 if (s.GetValue() == NULL)
2245 {
2246 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2247 return NULL;
2248 }
2249 else
2250 {
2251 jstring t = env->NewStringUTF(s.GetValue());
2252 if (t == NULL)
2253 {
2254 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
2255 return NULL;
2256 }
2257 else
2258 {
2259 return t;
2260 }
2261 }
2262 }
2263 catch (std::runtime_error& e)
2264 {
2265 JavaEnvironment::ThrowException(env, e.what());
2266 return NULL;
2267 }
2268 catch (...)
2269 {
2270 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2271 return NULL;
2272 }
2273 }
2274
2275
2276 JNIEXPORT jint JNI_OrthancPluginHasInstanceMetadata(JNIEnv* env, jobject sdkObject, jlong self, jstring arg0)
2277 {
2278 try
2279 {
2280 JavaString c_arg0(env, arg0);
2281 return OrthancPluginHasInstanceMetadata(context_
2282 , reinterpret_cast<OrthancPluginDicomInstance*>(static_cast<intptr_t>(self))
2283 , c_arg0.GetValue());
2284 }
2285 catch (std::runtime_error& e)
2286 {
2287 JavaEnvironment::ThrowException(env, e.what());
2288 return 0;
2289 }
2290 catch (...)
2291 {
2292 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2293 return 0;
2294 }
2295 }
2296
2297
2298 JNIEXPORT jstring JNI_OrthancPluginGetInstanceMetadata(JNIEnv* env, jobject sdkObject, jlong self, jstring arg0)
2299 {
2300 try
2301 {
2302 JavaString c_arg0(env, arg0);
2303 const char* s = OrthancPluginGetInstanceMetadata(context_
2304 , reinterpret_cast<OrthancPluginDicomInstance*>(static_cast<intptr_t>(self))
2305 , c_arg0.GetValue());
2306 if (s == NULL)
2307 {
2308 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2309 return NULL;
2310 }
2311 else
2312 {
2313 return env->NewStringUTF(s);
2314 }
2315 }
2316 catch (std::runtime_error& e)
2317 {
2318 JavaEnvironment::ThrowException(env, e.what());
2319 return NULL;
2320 }
2321 catch (...)
2322 {
2323 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2324 return NULL;
2325 }
2326 }
2327
2328
2329 JNIEXPORT jint JNI_OrthancPluginGetInstanceOrigin(JNIEnv* env, jobject sdkObject, jlong self)
2330 {
2331 try
2332 {
2333 return OrthancPluginGetInstanceOrigin(context_
2334 , reinterpret_cast<OrthancPluginDicomInstance*>(static_cast<intptr_t>(self))
2335 );
2336 }
2337 catch (std::runtime_error& e)
2338 {
2339 JavaEnvironment::ThrowException(env, e.what());
2340 return 0;
2341 }
2342 catch (...)
2343 {
2344 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2345 return 0;
2346 }
2347 }
2348
2349
2350 JNIEXPORT jstring JNI_OrthancPluginGetInstanceTransferSyntaxUid(JNIEnv* env, jobject sdkObject, jlong self)
2351 {
2352 try
2353 {
2354 OrthancString s(OrthancPluginGetInstanceTransferSyntaxUid(context_
2355 , reinterpret_cast<OrthancPluginDicomInstance*>(static_cast<intptr_t>(self))
2356 ));
2357 if (s.GetValue() == NULL)
2358 {
2359 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2360 return NULL;
2361 }
2362 else
2363 {
2364 jstring t = env->NewStringUTF(s.GetValue());
2365 if (t == NULL)
2366 {
2367 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
2368 return NULL;
2369 }
2370 else
2371 {
2372 return t;
2373 }
2374 }
2375 }
2376 catch (std::runtime_error& e)
2377 {
2378 JavaEnvironment::ThrowException(env, e.what());
2379 return NULL;
2380 }
2381 catch (...)
2382 {
2383 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2384 return NULL;
2385 }
2386 }
2387
2388
2389 JNIEXPORT jint JNI_OrthancPluginHasInstancePixelData(JNIEnv* env, jobject sdkObject, jlong self)
2390 {
2391 try
2392 {
2393 return OrthancPluginHasInstancePixelData(context_
2394 , reinterpret_cast<OrthancPluginDicomInstance*>(static_cast<intptr_t>(self))
2395 );
2396 }
2397 catch (std::runtime_error& e)
2398 {
2399 JavaEnvironment::ThrowException(env, e.what());
2400 return 0;
2401 }
2402 catch (...)
2403 {
2404 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2405 return 0;
2406 }
2407 }
2408
2409
2410 JNIEXPORT jint JNI_OrthancPluginGetInstanceFramesCount(JNIEnv* env, jobject sdkObject, jlong self)
2411 {
2412 try
2413 {
2414 return OrthancPluginGetInstanceFramesCount(context_
2415 , reinterpret_cast<OrthancPluginDicomInstance*>(static_cast<intptr_t>(self))
2416 );
2417 }
2418 catch (std::runtime_error& e)
2419 {
2420 JavaEnvironment::ThrowException(env, e.what());
2421 return 0;
2422 }
2423 catch (...)
2424 {
2425 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2426 return 0;
2427 }
2428 }
2429
2430
2431 JNIEXPORT jbyteArray JNI_OrthancPluginGetInstanceRawFrame(JNIEnv* env, jobject sdkObject, jlong self, jint arg0)
2432 {
2433 try
2434 {
2435 OrthancBytes b;
2436 OrthancPluginErrorCode code = OrthancPluginGetInstanceRawFrame(context_, b.GetMemoryBuffer()
2437 , reinterpret_cast<OrthancPluginDicomInstance*>(static_cast<intptr_t>(self))
2438 , arg0);
2439 if (code == OrthancPluginErrorCode_Success)
2440 {
2441 jbyteArray answer = env->NewByteArray(b.GetSize());
2442 if (answer == NULL)
2443 {
2444 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
2445 return NULL;
2446 }
2447 else
2448 {
2449 env->SetByteArrayRegion(answer, 0, b.GetSize(), reinterpret_cast<const jbyte*>(b.GetData()));
2450 return answer;
2451 }
2452 }
2453 else
2454 {
2455 JavaEnvironment::ThrowException(env, code);
2456 return NULL;
2457 }
2458 }
2459 catch (std::runtime_error& e)
2460 {
2461 JavaEnvironment::ThrowException(env, e.what());
2462 return NULL;
2463 }
2464 catch (...)
2465 {
2466 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2467 return NULL;
2468 }
2469 }
2470
2471
2472 JNIEXPORT jlong JNI_OrthancPluginGetInstanceDecodedFrame(JNIEnv* env, jobject sdkObject, jlong self, jint arg0)
2473 {
2474 try
2475 {
2476 OrthancPluginImage* answer = OrthancPluginGetInstanceDecodedFrame(context_
2477 , reinterpret_cast<OrthancPluginDicomInstance*>(static_cast<intptr_t>(self))
2478 , arg0);
2479 if (answer == NULL)
2480 {
2481 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2482 return 0;
2483 }
2484 else
2485 {
2486 return reinterpret_cast<intptr_t>(answer);
2487 }
2488 }
2489 catch (std::runtime_error& e)
2490 {
2491 JavaEnvironment::ThrowException(env, e.what());
2492 return 0;
2493 }
2494 catch (...)
2495 {
2496 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2497 return 0;
2498 }
2499 }
2500
2501
2502 JNIEXPORT jbyteArray JNI_OrthancPluginSerializeDicomInstance(JNIEnv* env, jobject sdkObject, jlong self)
2503 {
2504 try
2505 {
2506 OrthancBytes b;
2507 OrthancPluginErrorCode code = OrthancPluginSerializeDicomInstance(context_, b.GetMemoryBuffer()
2508 , reinterpret_cast<OrthancPluginDicomInstance*>(static_cast<intptr_t>(self))
2509 );
2510 if (code == OrthancPluginErrorCode_Success)
2511 {
2512 jbyteArray answer = env->NewByteArray(b.GetSize());
2513 if (answer == NULL)
2514 {
2515 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
2516 return NULL;
2517 }
2518 else
2519 {
2520 env->SetByteArrayRegion(answer, 0, b.GetSize(), reinterpret_cast<const jbyte*>(b.GetData()));
2521 return answer;
2522 }
2523 }
2524 else
2525 {
2526 JavaEnvironment::ThrowException(env, code);
2527 return NULL;
2528 }
2529 }
2530 catch (std::runtime_error& e)
2531 {
2532 JavaEnvironment::ThrowException(env, e.what());
2533 return NULL;
2534 }
2535 catch (...)
2536 {
2537 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2538 return NULL;
2539 }
2540 }
2541
2542
2543 JNIEXPORT jstring JNI_OrthancPluginGetInstanceAdvancedJson(JNIEnv* env, jobject sdkObject, jlong self, jint arg0, jint arg1, jint arg2)
2544 {
2545 try
2546 {
2547 OrthancString s(OrthancPluginGetInstanceAdvancedJson(context_
2548 , reinterpret_cast<OrthancPluginDicomInstance*>(static_cast<intptr_t>(self))
2549 , static_cast<OrthancPluginDicomToJsonFormat>(arg0), static_cast<OrthancPluginDicomToJsonFlags>(arg1), arg2));
2550 if (s.GetValue() == NULL)
2551 {
2552 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2553 return NULL;
2554 }
2555 else
2556 {
2557 jstring t = env->NewStringUTF(s.GetValue());
2558 if (t == NULL)
2559 {
2560 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
2561 return NULL;
2562 }
2563 else
2564 {
2565 return t;
2566 }
2567 }
2568 }
2569 catch (std::runtime_error& e)
2570 {
2571 JavaEnvironment::ThrowException(env, e.what());
2572 return NULL;
2573 }
2574 catch (...)
2575 {
2576 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2577 return NULL;
2578 }
2579 }
2580
2581
2582 JNIEXPORT void JNI_OrthancPluginFindAddAnswer(JNIEnv* env, jobject sdkObject, jlong self, jbyteArray arg0)
2583 {
2584 try
2585 {
2586 JavaBytes c_arg0(env, arg0);
2587 OrthancPluginErrorCode code = OrthancPluginFindAddAnswer(context_
2588 , reinterpret_cast<OrthancPluginFindAnswers*>(static_cast<intptr_t>(self))
2589 , c_arg0.GetData(), c_arg0.GetSize());
2590 if (code != OrthancPluginErrorCode_Success)
2591 {
2592 JavaEnvironment::ThrowException(env, code);
2593 }
2594 }
2595 catch (std::runtime_error& e)
2596 {
2597 JavaEnvironment::ThrowException(env, e.what());
2598 }
2599 catch (...)
2600 {
2601 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2602 }
2603 }
2604
2605
2606 JNIEXPORT void JNI_OrthancPluginFindMarkIncomplete(JNIEnv* env, jobject sdkObject, jlong self)
2607 {
2608 try
2609 {
2610 OrthancPluginErrorCode code = OrthancPluginFindMarkIncomplete(context_
2611 , reinterpret_cast<OrthancPluginFindAnswers*>(static_cast<intptr_t>(self))
2612 );
2613 if (code != OrthancPluginErrorCode_Success)
2614 {
2615 JavaEnvironment::ThrowException(env, code);
2616 }
2617 }
2618 catch (std::runtime_error& e)
2619 {
2620 JavaEnvironment::ThrowException(env, e.what());
2621 }
2622 catch (...)
2623 {
2624 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2625 }
2626 }
2627
2628
2629 JNIEXPORT void JNI_OrthancPluginFreeFindMatcher(JNIEnv* env, jobject sdkObject, jlong self)
2630 {
2631 try
2632 {
2633 OrthancPluginFreeFindMatcher(context_
2634 , reinterpret_cast<OrthancPluginFindMatcher*>(static_cast<intptr_t>(self))
2635 );
2636 }
2637 catch (std::runtime_error& e)
2638 {
2639 JavaEnvironment::ThrowException(env, e.what());
2640 }
2641 catch (...)
2642 {
2643 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2644 }
2645 }
2646
2647
2648 JNIEXPORT jint JNI_OrthancPluginFindMatcherIsMatch(JNIEnv* env, jobject sdkObject, jlong self, jbyteArray arg0)
2649 {
2650 try
2651 {
2652 JavaBytes c_arg0(env, arg0);
2653 return OrthancPluginFindMatcherIsMatch(context_
2654 , reinterpret_cast<OrthancPluginFindMatcher*>(static_cast<intptr_t>(self))
2655 , c_arg0.GetData(), c_arg0.GetSize());
2656 }
2657 catch (std::runtime_error& e)
2658 {
2659 JavaEnvironment::ThrowException(env, e.what());
2660 return 0;
2661 }
2662 catch (...)
2663 {
2664 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2665 return 0;
2666 }
2667 }
2668
2669
2670 JNIEXPORT jint JNI_OrthancPluginGetFindQuerySize(JNIEnv* env, jobject sdkObject, jlong self)
2671 {
2672 try
2673 {
2674 return OrthancPluginGetFindQuerySize(context_
2675 , reinterpret_cast<OrthancPluginFindQuery*>(static_cast<intptr_t>(self))
2676 );
2677 }
2678 catch (std::runtime_error& e)
2679 {
2680 JavaEnvironment::ThrowException(env, e.what());
2681 return 0;
2682 }
2683 catch (...)
2684 {
2685 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2686 return 0;
2687 }
2688 }
2689
2690
2691 JNIEXPORT jstring JNI_OrthancPluginGetFindQueryTagName(JNIEnv* env, jobject sdkObject, jlong self, jint arg0)
2692 {
2693 try
2694 {
2695 OrthancString s(OrthancPluginGetFindQueryTagName(context_
2696 , reinterpret_cast<OrthancPluginFindQuery*>(static_cast<intptr_t>(self))
2697 , arg0));
2698 if (s.GetValue() == NULL)
2699 {
2700 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2701 return NULL;
2702 }
2703 else
2704 {
2705 jstring t = env->NewStringUTF(s.GetValue());
2706 if (t == NULL)
2707 {
2708 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
2709 return NULL;
2710 }
2711 else
2712 {
2713 return t;
2714 }
2715 }
2716 }
2717 catch (std::runtime_error& e)
2718 {
2719 JavaEnvironment::ThrowException(env, e.what());
2720 return NULL;
2721 }
2722 catch (...)
2723 {
2724 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2725 return NULL;
2726 }
2727 }
2728
2729
2730 JNIEXPORT jstring JNI_OrthancPluginGetFindQueryValue(JNIEnv* env, jobject sdkObject, jlong self, jint arg0)
2731 {
2732 try
2733 {
2734 OrthancString s(OrthancPluginGetFindQueryValue(context_
2735 , reinterpret_cast<OrthancPluginFindQuery*>(static_cast<intptr_t>(self))
2736 , arg0));
2737 if (s.GetValue() == NULL)
2738 {
2739 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2740 return NULL;
2741 }
2742 else
2743 {
2744 jstring t = env->NewStringUTF(s.GetValue());
2745 if (t == NULL)
2746 {
2747 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
2748 return NULL;
2749 }
2750 else
2751 {
2752 return t;
2753 }
2754 }
2755 }
2756 catch (std::runtime_error& e)
2757 {
2758 JavaEnvironment::ThrowException(env, e.what());
2759 return NULL;
2760 }
2761 catch (...)
2762 {
2763 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2764 return NULL;
2765 }
2766 }
2767
2768
2769 JNIEXPORT void JNI_OrthancPluginFreeImage(JNIEnv* env, jobject sdkObject, jlong self)
2770 {
2771 try
2772 {
2773 OrthancPluginFreeImage(context_
2774 , reinterpret_cast<OrthancPluginImage*>(static_cast<intptr_t>(self))
2775 );
2776 }
2777 catch (std::runtime_error& e)
2778 {
2779 JavaEnvironment::ThrowException(env, e.what());
2780 }
2781 catch (...)
2782 {
2783 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2784 }
2785 }
2786
2787
2788 JNIEXPORT jint JNI_OrthancPluginGetImagePixelFormat(JNIEnv* env, jobject sdkObject, jlong self)
2789 {
2790 try
2791 {
2792 return OrthancPluginGetImagePixelFormat(context_
2793 , reinterpret_cast<OrthancPluginImage*>(static_cast<intptr_t>(self))
2794 );
2795 }
2796 catch (std::runtime_error& e)
2797 {
2798 JavaEnvironment::ThrowException(env, e.what());
2799 return 0;
2800 }
2801 catch (...)
2802 {
2803 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2804 return 0;
2805 }
2806 }
2807
2808
2809 JNIEXPORT jint JNI_OrthancPluginGetImageWidth(JNIEnv* env, jobject sdkObject, jlong self)
2810 {
2811 try
2812 {
2813 return OrthancPluginGetImageWidth(context_
2814 , reinterpret_cast<OrthancPluginImage*>(static_cast<intptr_t>(self))
2815 );
2816 }
2817 catch (std::runtime_error& e)
2818 {
2819 JavaEnvironment::ThrowException(env, e.what());
2820 return 0;
2821 }
2822 catch (...)
2823 {
2824 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2825 return 0;
2826 }
2827 }
2828
2829
2830 JNIEXPORT jint JNI_OrthancPluginGetImageHeight(JNIEnv* env, jobject sdkObject, jlong self)
2831 {
2832 try
2833 {
2834 return OrthancPluginGetImageHeight(context_
2835 , reinterpret_cast<OrthancPluginImage*>(static_cast<intptr_t>(self))
2836 );
2837 }
2838 catch (std::runtime_error& e)
2839 {
2840 JavaEnvironment::ThrowException(env, e.what());
2841 return 0;
2842 }
2843 catch (...)
2844 {
2845 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2846 return 0;
2847 }
2848 }
2849
2850
2851 JNIEXPORT jint JNI_OrthancPluginGetImagePitch(JNIEnv* env, jobject sdkObject, jlong self)
2852 {
2853 try
2854 {
2855 return OrthancPluginGetImagePitch(context_
2856 , reinterpret_cast<OrthancPluginImage*>(static_cast<intptr_t>(self))
2857 );
2858 }
2859 catch (std::runtime_error& e)
2860 {
2861 JavaEnvironment::ThrowException(env, e.what());
2862 return 0;
2863 }
2864 catch (...)
2865 {
2866 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2867 return 0;
2868 }
2869 }
2870
2871
2872 JNIEXPORT jlong JNI_OrthancPluginConvertPixelFormat(JNIEnv* env, jobject sdkObject, jlong self, jint arg0)
2873 {
2874 try
2875 {
2876 OrthancPluginImage* answer = OrthancPluginConvertPixelFormat(context_
2877 , reinterpret_cast<OrthancPluginImage*>(static_cast<intptr_t>(self))
2878 , static_cast<OrthancPluginPixelFormat>(arg0));
2879 if (answer == NULL)
2880 {
2881 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2882 return 0;
2883 }
2884 else
2885 {
2886 return reinterpret_cast<intptr_t>(answer);
2887 }
2888 }
2889 catch (std::runtime_error& e)
2890 {
2891 JavaEnvironment::ThrowException(env, e.what());
2892 return 0;
2893 }
2894 catch (...)
2895 {
2896 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2897 return 0;
2898 }
2899 }
2900
2901
2902 JNIEXPORT void JNI_OrthancPluginDrawText(JNIEnv* env, jobject sdkObject, jlong self, jint arg0, jstring arg1, jint arg2, jint arg3, jbyte arg4, jbyte arg5, jbyte arg6)
2903 {
2904 try
2905 {
2906 JavaString c_arg1(env, arg1);
2907 OrthancPluginErrorCode code = OrthancPluginDrawText(context_
2908 , reinterpret_cast<OrthancPluginImage*>(static_cast<intptr_t>(self))
2909 , arg0, c_arg1.GetValue(), arg2, arg3, arg4, arg5, arg6);
2910 if (code != OrthancPluginErrorCode_Success)
2911 {
2912 JavaEnvironment::ThrowException(env, code);
2913 }
2914 }
2915 catch (std::runtime_error& e)
2916 {
2917 JavaEnvironment::ThrowException(env, e.what());
2918 }
2919 catch (...)
2920 {
2921 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2922 }
2923 }
2924
2925
2926 JNIEXPORT void JNI_OrthancPluginFreeJob(JNIEnv* env, jobject sdkObject, jlong self)
2927 {
2928 try
2929 {
2930 OrthancPluginFreeJob(context_
2931 , reinterpret_cast<OrthancPluginJob*>(static_cast<intptr_t>(self))
2932 );
2933 }
2934 catch (std::runtime_error& e)
2935 {
2936 JavaEnvironment::ThrowException(env, e.what());
2937 }
2938 catch (...)
2939 {
2940 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2941 }
2942 }
2943
2944
2945 JNIEXPORT jstring JNI_OrthancPluginSubmitJob(JNIEnv* env, jobject sdkObject, jlong self, jint arg0)
2946 {
2947 try
2948 {
2949 OrthancString s(OrthancPluginSubmitJob(context_
2950 , reinterpret_cast<OrthancPluginJob*>(static_cast<intptr_t>(self))
2951 , arg0));
2952 if (s.GetValue() == NULL)
2953 {
2954 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2955 return NULL;
2956 }
2957 else
2958 {
2959 jstring t = env->NewStringUTF(s.GetValue());
2960 if (t == NULL)
2961 {
2962 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
2963 return NULL;
2964 }
2965 else
2966 {
2967 return t;
2968 }
2969 }
2970 }
2971 catch (std::runtime_error& e)
2972 {
2973 JavaEnvironment::ThrowException(env, e.what());
2974 return NULL;
2975 }
2976 catch (...)
2977 {
2978 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2979 return NULL;
2980 }
2981 }
2982
2983
2984 JNIEXPORT void JNI_OrthancPluginFreePeers(JNIEnv* env, jobject sdkObject, jlong self)
2985 {
2986 try
2987 {
2988 OrthancPluginFreePeers(context_
2989 , reinterpret_cast<OrthancPluginPeers*>(static_cast<intptr_t>(self))
2990 );
2991 }
2992 catch (std::runtime_error& e)
2993 {
2994 JavaEnvironment::ThrowException(env, e.what());
2995 }
2996 catch (...)
2997 {
2998 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
2999 }
3000 }
3001
3002
3003 JNIEXPORT jint JNI_OrthancPluginGetPeersCount(JNIEnv* env, jobject sdkObject, jlong self)
3004 {
3005 try
3006 {
3007 return OrthancPluginGetPeersCount(context_
3008 , reinterpret_cast<OrthancPluginPeers*>(static_cast<intptr_t>(self))
3009 );
3010 }
3011 catch (std::runtime_error& e)
3012 {
3013 JavaEnvironment::ThrowException(env, e.what());
3014 return 0;
3015 }
3016 catch (...)
3017 {
3018 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3019 return 0;
3020 }
3021 }
3022
3023
3024 JNIEXPORT jstring JNI_OrthancPluginGetPeerName(JNIEnv* env, jobject sdkObject, jlong self, jint arg0)
3025 {
3026 try
3027 {
3028 const char* s = OrthancPluginGetPeerName(context_
3029 , reinterpret_cast<OrthancPluginPeers*>(static_cast<intptr_t>(self))
3030 , arg0);
3031 if (s == NULL)
3032 {
3033 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3034 return NULL;
3035 }
3036 else
3037 {
3038 return env->NewStringUTF(s);
3039 }
3040 }
3041 catch (std::runtime_error& e)
3042 {
3043 JavaEnvironment::ThrowException(env, e.what());
3044 return NULL;
3045 }
3046 catch (...)
3047 {
3048 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3049 return NULL;
3050 }
3051 }
3052
3053
3054 JNIEXPORT jstring JNI_OrthancPluginGetPeerUrl(JNIEnv* env, jobject sdkObject, jlong self, jint arg0)
3055 {
3056 try
3057 {
3058 const char* s = OrthancPluginGetPeerUrl(context_
3059 , reinterpret_cast<OrthancPluginPeers*>(static_cast<intptr_t>(self))
3060 , arg0);
3061 if (s == NULL)
3062 {
3063 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3064 return NULL;
3065 }
3066 else
3067 {
3068 return env->NewStringUTF(s);
3069 }
3070 }
3071 catch (std::runtime_error& e)
3072 {
3073 JavaEnvironment::ThrowException(env, e.what());
3074 return NULL;
3075 }
3076 catch (...)
3077 {
3078 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3079 return NULL;
3080 }
3081 }
3082
3083
3084 JNIEXPORT jstring JNI_OrthancPluginGetPeerUserProperty(JNIEnv* env, jobject sdkObject, jlong self, jint arg0, jstring arg1)
3085 {
3086 try
3087 {
3088 JavaString c_arg1(env, arg1);
3089 const char* s = OrthancPluginGetPeerUserProperty(context_
3090 , reinterpret_cast<OrthancPluginPeers*>(static_cast<intptr_t>(self))
3091 , arg0, c_arg1.GetValue());
3092 if (s == NULL)
3093 {
3094 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3095 return NULL;
3096 }
3097 else
3098 {
3099 return env->NewStringUTF(s);
3100 }
3101 }
3102 catch (std::runtime_error& e)
3103 {
3104 JavaEnvironment::ThrowException(env, e.what());
3105 return NULL;
3106 }
3107 catch (...)
3108 {
3109 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3110 return NULL;
3111 }
3112 }
3113
3114
3115 JNIEXPORT void JNI_OrthancPluginAnswerBuffer(JNIEnv* env, jobject sdkObject, jlong self, jbyteArray arg0, jstring arg2)
3116 {
3117 try
3118 {
3119 JavaBytes c_arg0(env, arg0);
3120 JavaString c_arg2(env, arg2);
3121 OrthancPluginAnswerBuffer(context_
3122 , reinterpret_cast<OrthancPluginRestOutput*>(static_cast<intptr_t>(self))
3123 , c_arg0.GetData(), c_arg0.GetSize(), c_arg2.GetValue());
3124 }
3125 catch (std::runtime_error& e)
3126 {
3127 JavaEnvironment::ThrowException(env, e.what());
3128 }
3129 catch (...)
3130 {
3131 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3132 }
3133 }
3134
3135
3136 JNIEXPORT void JNI_OrthancPluginCompressAndAnswerPngImage(JNIEnv* env, jobject sdkObject, jlong self, jint arg0, jint arg1, jint arg2, jint arg3, jbyteArray arg4)
3137 {
3138 try
3139 {
3140 JavaBytes c_arg4(env, arg4);
3141 OrthancPluginCompressAndAnswerPngImage(context_
3142 , reinterpret_cast<OrthancPluginRestOutput*>(static_cast<intptr_t>(self))
3143 , static_cast<OrthancPluginPixelFormat>(arg0), arg1, arg2, arg3, c_arg4.GetData());
3144 }
3145 catch (std::runtime_error& e)
3146 {
3147 JavaEnvironment::ThrowException(env, e.what());
3148 }
3149 catch (...)
3150 {
3151 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3152 }
3153 }
3154
3155
3156 JNIEXPORT void JNI_OrthancPluginRedirect(JNIEnv* env, jobject sdkObject, jlong self, jstring arg0)
3157 {
3158 try
3159 {
3160 JavaString c_arg0(env, arg0);
3161 OrthancPluginRedirect(context_
3162 , reinterpret_cast<OrthancPluginRestOutput*>(static_cast<intptr_t>(self))
3163 , c_arg0.GetValue());
3164 }
3165 catch (std::runtime_error& e)
3166 {
3167 JavaEnvironment::ThrowException(env, e.what());
3168 }
3169 catch (...)
3170 {
3171 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3172 }
3173 }
3174
3175
3176 JNIEXPORT void JNI_OrthancPluginSendHttpStatusCode(JNIEnv* env, jobject sdkObject, jlong self, jshort arg0)
3177 {
3178 try
3179 {
3180 OrthancPluginSendHttpStatusCode(context_
3181 , reinterpret_cast<OrthancPluginRestOutput*>(static_cast<intptr_t>(self))
3182 , arg0);
3183 }
3184 catch (std::runtime_error& e)
3185 {
3186 JavaEnvironment::ThrowException(env, e.what());
3187 }
3188 catch (...)
3189 {
3190 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3191 }
3192 }
3193
3194
3195 JNIEXPORT void JNI_OrthancPluginSendUnauthorized(JNIEnv* env, jobject sdkObject, jlong self, jstring arg0)
3196 {
3197 try
3198 {
3199 JavaString c_arg0(env, arg0);
3200 OrthancPluginSendUnauthorized(context_
3201 , reinterpret_cast<OrthancPluginRestOutput*>(static_cast<intptr_t>(self))
3202 , c_arg0.GetValue());
3203 }
3204 catch (std::runtime_error& e)
3205 {
3206 JavaEnvironment::ThrowException(env, e.what());
3207 }
3208 catch (...)
3209 {
3210 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3211 }
3212 }
3213
3214
3215 JNIEXPORT void JNI_OrthancPluginSendMethodNotAllowed(JNIEnv* env, jobject sdkObject, jlong self, jstring arg0)
3216 {
3217 try
3218 {
3219 JavaString c_arg0(env, arg0);
3220 OrthancPluginSendMethodNotAllowed(context_
3221 , reinterpret_cast<OrthancPluginRestOutput*>(static_cast<intptr_t>(self))
3222 , c_arg0.GetValue());
3223 }
3224 catch (std::runtime_error& e)
3225 {
3226 JavaEnvironment::ThrowException(env, e.what());
3227 }
3228 catch (...)
3229 {
3230 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3231 }
3232 }
3233
3234
3235 JNIEXPORT void JNI_OrthancPluginSetCookie(JNIEnv* env, jobject sdkObject, jlong self, jstring arg0, jstring arg1)
3236 {
3237 try
3238 {
3239 JavaString c_arg0(env, arg0);
3240 JavaString c_arg1(env, arg1);
3241 OrthancPluginSetCookie(context_
3242 , reinterpret_cast<OrthancPluginRestOutput*>(static_cast<intptr_t>(self))
3243 , c_arg0.GetValue(), c_arg1.GetValue());
3244 }
3245 catch (std::runtime_error& e)
3246 {
3247 JavaEnvironment::ThrowException(env, e.what());
3248 }
3249 catch (...)
3250 {
3251 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3252 }
3253 }
3254
3255
3256 JNIEXPORT void JNI_OrthancPluginSetHttpHeader(JNIEnv* env, jobject sdkObject, jlong self, jstring arg0, jstring arg1)
3257 {
3258 try
3259 {
3260 JavaString c_arg0(env, arg0);
3261 JavaString c_arg1(env, arg1);
3262 OrthancPluginSetHttpHeader(context_
3263 , reinterpret_cast<OrthancPluginRestOutput*>(static_cast<intptr_t>(self))
3264 , c_arg0.GetValue(), c_arg1.GetValue());
3265 }
3266 catch (std::runtime_error& e)
3267 {
3268 JavaEnvironment::ThrowException(env, e.what());
3269 }
3270 catch (...)
3271 {
3272 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3273 }
3274 }
3275
3276
3277 JNIEXPORT void JNI_OrthancPluginStartMultipartAnswer(JNIEnv* env, jobject sdkObject, jlong self, jstring arg0, jstring arg1)
3278 {
3279 try
3280 {
3281 JavaString c_arg0(env, arg0);
3282 JavaString c_arg1(env, arg1);
3283 OrthancPluginErrorCode code = OrthancPluginStartMultipartAnswer(context_
3284 , reinterpret_cast<OrthancPluginRestOutput*>(static_cast<intptr_t>(self))
3285 , c_arg0.GetValue(), c_arg1.GetValue());
3286 if (code != OrthancPluginErrorCode_Success)
3287 {
3288 JavaEnvironment::ThrowException(env, code);
3289 }
3290 }
3291 catch (std::runtime_error& e)
3292 {
3293 JavaEnvironment::ThrowException(env, e.what());
3294 }
3295 catch (...)
3296 {
3297 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3298 }
3299 }
3300
3301
3302 JNIEXPORT void JNI_OrthancPluginSendMultipartItem(JNIEnv* env, jobject sdkObject, jlong self, jbyteArray arg0)
3303 {
3304 try
3305 {
3306 JavaBytes c_arg0(env, arg0);
3307 OrthancPluginErrorCode code = OrthancPluginSendMultipartItem(context_
3308 , reinterpret_cast<OrthancPluginRestOutput*>(static_cast<intptr_t>(self))
3309 , c_arg0.GetData(), c_arg0.GetSize());
3310 if (code != OrthancPluginErrorCode_Success)
3311 {
3312 JavaEnvironment::ThrowException(env, code);
3313 }
3314 }
3315 catch (std::runtime_error& e)
3316 {
3317 JavaEnvironment::ThrowException(env, e.what());
3318 }
3319 catch (...)
3320 {
3321 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3322 }
3323 }
3324
3325
3326 JNIEXPORT void JNI_OrthancPluginSendHttpStatus(JNIEnv* env, jobject sdkObject, jlong self, jshort arg0, jbyteArray arg1)
3327 {
3328 try
3329 {
3330 JavaBytes c_arg1(env, arg1);
3331 OrthancPluginSendHttpStatus(context_
3332 , reinterpret_cast<OrthancPluginRestOutput*>(static_cast<intptr_t>(self))
3333 , arg0, c_arg1.GetData(), c_arg1.GetSize());
3334 }
3335 catch (std::runtime_error& e)
3336 {
3337 JavaEnvironment::ThrowException(env, e.what());
3338 }
3339 catch (...)
3340 {
3341 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3342 }
3343 }
3344
3345
3346 JNIEXPORT void JNI_OrthancPluginCompressAndAnswerJpegImage(JNIEnv* env, jobject sdkObject, jlong self, jint arg0, jint arg1, jint arg2, jint arg3, jbyteArray arg4, jbyte arg5)
3347 {
3348 try
3349 {
3350 JavaBytes c_arg4(env, arg4);
3351 OrthancPluginCompressAndAnswerJpegImage(context_
3352 , reinterpret_cast<OrthancPluginRestOutput*>(static_cast<intptr_t>(self))
3353 , static_cast<OrthancPluginPixelFormat>(arg0), arg1, arg2, arg3, c_arg4.GetData(), arg5);
3354 }
3355 catch (std::runtime_error& e)
3356 {
3357 JavaEnvironment::ThrowException(env, e.what());
3358 }
3359 catch (...)
3360 {
3361 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3362 }
3363 }
3364
3365
3366 JNIEXPORT void JNI_OrthancPluginSetHttpErrorDetails(JNIEnv* env, jobject sdkObject, jlong self, jstring arg0, jbyte arg1)
3367 {
3368 try
3369 {
3370 JavaString c_arg0(env, arg0);
3371 OrthancPluginSetHttpErrorDetails(context_
3372 , reinterpret_cast<OrthancPluginRestOutput*>(static_cast<intptr_t>(self))
3373 , c_arg0.GetValue(), arg1);
3374 }
3375 catch (std::runtime_error& e)
3376 {
3377 JavaEnvironment::ThrowException(env, e.what());
3378 }
3379 catch (...)
3380 {
3381 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3382 }
3383 }
3384
3385
3386 JNIEXPORT void JNI_OrthancPluginStorageAreaCreate(JNIEnv* env, jobject sdkObject, jlong self, jstring arg0, jbyteArray arg1, jlong arg2, jint arg3)
3387 {
3388 try
3389 {
3390 JavaString c_arg0(env, arg0);
3391 JavaBytes c_arg1(env, arg1);
3392 OrthancPluginErrorCode code = OrthancPluginStorageAreaCreate(context_
3393 , reinterpret_cast<OrthancPluginStorageArea*>(static_cast<intptr_t>(self))
3394 , c_arg0.GetValue(), c_arg1.GetData(), arg2, static_cast<OrthancPluginContentType>(arg3));
3395 if (code != OrthancPluginErrorCode_Success)
3396 {
3397 JavaEnvironment::ThrowException(env, code);
3398 }
3399 }
3400 catch (std::runtime_error& e)
3401 {
3402 JavaEnvironment::ThrowException(env, e.what());
3403 }
3404 catch (...)
3405 {
3406 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3407 }
3408 }
3409
3410
3411 JNIEXPORT jbyteArray JNI_OrthancPluginStorageAreaRead(JNIEnv* env, jobject sdkObject, jlong self, jstring arg0, jint arg1)
3412 {
3413 try
3414 {
3415 JavaString c_arg0(env, arg0);
3416 OrthancBytes b;
3417 OrthancPluginErrorCode code = OrthancPluginStorageAreaRead(context_, b.GetMemoryBuffer()
3418 , reinterpret_cast<OrthancPluginStorageArea*>(static_cast<intptr_t>(self))
3419 , c_arg0.GetValue(), static_cast<OrthancPluginContentType>(arg1));
3420 if (code == OrthancPluginErrorCode_Success)
3421 {
3422 jbyteArray answer = env->NewByteArray(b.GetSize());
3423 if (answer == NULL)
3424 {
3425 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
3426 return NULL;
3427 }
3428 else
3429 {
3430 env->SetByteArrayRegion(answer, 0, b.GetSize(), reinterpret_cast<const jbyte*>(b.GetData()));
3431 return answer;
3432 }
3433 }
3434 else
3435 {
3436 JavaEnvironment::ThrowException(env, code);
3437 return NULL;
3438 }
3439 }
3440 catch (std::runtime_error& e)
3441 {
3442 JavaEnvironment::ThrowException(env, e.what());
3443 return NULL;
3444 }
3445 catch (...)
3446 {
3447 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3448 return NULL;
3449 }
3450 }
3451
3452
3453 JNIEXPORT void JNI_OrthancPluginStorageAreaRemove(JNIEnv* env, jobject sdkObject, jlong self, jstring arg0, jint arg1)
3454 {
3455 try
3456 {
3457 JavaString c_arg0(env, arg0);
3458 OrthancPluginErrorCode code = OrthancPluginStorageAreaRemove(context_
3459 , reinterpret_cast<OrthancPluginStorageArea*>(static_cast<intptr_t>(self))
3460 , c_arg0.GetValue(), static_cast<OrthancPluginContentType>(arg1));
3461 if (code != OrthancPluginErrorCode_Success)
3462 {
3463 JavaEnvironment::ThrowException(env, code);
3464 }
3465 }
3466 catch (std::runtime_error& e)
3467 {
3468 JavaEnvironment::ThrowException(env, e.what());
3469 }
3470 catch (...)
3471 {
3472 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3473 }
3474 }
3475
3476
3477 JNIEXPORT void JNI_OrthancPluginReconstructMainDicomTags(JNIEnv* env, jobject sdkObject, jlong self, jint arg0)
3478 {
3479 try
3480 {
3481 OrthancPluginErrorCode code = OrthancPluginReconstructMainDicomTags(context_
3482 , reinterpret_cast<OrthancPluginStorageArea*>(static_cast<intptr_t>(self))
3483 , static_cast<OrthancPluginResourceType>(arg0));
3484 if (code != OrthancPluginErrorCode_Success)
3485 {
3486 JavaEnvironment::ThrowException(env, code);
3487 }
3488 }
3489 catch (std::runtime_error& e)
3490 {
3491 JavaEnvironment::ThrowException(env, e.what());
3492 }
3493 catch (...)
3494 {
3495 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3496 }
3497 }
3498
3499
3500 JNIEXPORT void JNI_OrthancPluginWorklistAddAnswer(JNIEnv* env, jobject sdkObject, jlong self, jlong arg0, jbyteArray arg1)
3501 {
3502 try
3503 {
3504 JavaBytes c_arg1(env, arg1);
3505 OrthancPluginErrorCode code = OrthancPluginWorklistAddAnswer(context_
3506 , reinterpret_cast<OrthancPluginWorklistAnswers*>(static_cast<intptr_t>(self))
3507 , reinterpret_cast<OrthancPluginWorklistQuery*>(static_cast<intptr_t>(arg0)), c_arg1.GetData(), c_arg1.GetSize());
3508 if (code != OrthancPluginErrorCode_Success)
3509 {
3510 JavaEnvironment::ThrowException(env, code);
3511 }
3512 }
3513 catch (std::runtime_error& e)
3514 {
3515 JavaEnvironment::ThrowException(env, e.what());
3516 }
3517 catch (...)
3518 {
3519 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3520 }
3521 }
3522
3523
3524 JNIEXPORT void JNI_OrthancPluginWorklistMarkIncomplete(JNIEnv* env, jobject sdkObject, jlong self)
3525 {
3526 try
3527 {
3528 OrthancPluginErrorCode code = OrthancPluginWorklistMarkIncomplete(context_
3529 , reinterpret_cast<OrthancPluginWorklistAnswers*>(static_cast<intptr_t>(self))
3530 );
3531 if (code != OrthancPluginErrorCode_Success)
3532 {
3533 JavaEnvironment::ThrowException(env, code);
3534 }
3535 }
3536 catch (std::runtime_error& e)
3537 {
3538 JavaEnvironment::ThrowException(env, e.what());
3539 }
3540 catch (...)
3541 {
3542 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3543 }
3544 }
3545
3546
3547 JNIEXPORT jint JNI_OrthancPluginWorklistIsMatch(JNIEnv* env, jobject sdkObject, jlong self, jbyteArray arg0)
3548 {
3549 try
3550 {
3551 JavaBytes c_arg0(env, arg0);
3552 return OrthancPluginWorklistIsMatch(context_
3553 , reinterpret_cast<OrthancPluginWorklistQuery*>(static_cast<intptr_t>(self))
3554 , c_arg0.GetData(), c_arg0.GetSize());
3555 }
3556 catch (std::runtime_error& e)
3557 {
3558 JavaEnvironment::ThrowException(env, e.what());
3559 return 0;
3560 }
3561 catch (...)
3562 {
3563 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3564 return 0;
3565 }
3566 }
3567
3568
3569 JNIEXPORT jbyteArray JNI_OrthancPluginWorklistGetDicomQuery(JNIEnv* env, jobject sdkObject, jlong self)
3570 {
3571 try
3572 {
3573 OrthancBytes b;
3574 OrthancPluginErrorCode code = OrthancPluginWorklistGetDicomQuery(context_, b.GetMemoryBuffer()
3575 , reinterpret_cast<OrthancPluginWorklistQuery*>(static_cast<intptr_t>(self))
3576 );
3577 if (code == OrthancPluginErrorCode_Success)
3578 {
3579 jbyteArray answer = env->NewByteArray(b.GetSize());
3580 if (answer == NULL)
3581 {
3582 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_NotEnoughMemory);
3583 return NULL;
3584 }
3585 else
3586 {
3587 env->SetByteArrayRegion(answer, 0, b.GetSize(), reinterpret_cast<const jbyte*>(b.GetData()));
3588 return answer;
3589 }
3590 }
3591 else
3592 {
3593 JavaEnvironment::ThrowException(env, code);
3594 return NULL;
3595 }
3596 }
3597 catch (std::runtime_error& e)
3598 {
3599 JavaEnvironment::ThrowException(env, e.what());
3600 return NULL;
3601 }
3602 catch (...)
3603 {
3604 JavaEnvironment::ThrowException(env, OrthancPluginErrorCode_Plugin);
3605 return NULL;
3606 }
3607 }
3608
3609
3610 static void JNI_LoadNatives(std::vector<JNINativeMethod>& methods)
3611 {
3612 methods.clear();
3613
3614 methods.push_back((JNINativeMethod) {
3615 const_cast<char*>("OrthancPluginCheckVersionAdvanced"),
3616 const_cast<char*>("(III)I"),
3617 (void*) JNI_OrthancPluginCheckVersionAdvanced
3618 });
3619
3620 methods.push_back((JNINativeMethod) {
3621 const_cast<char*>("OrthancPluginCheckVersion"),
3622 const_cast<char*>("()I"),
3623 (void*) JNI_OrthancPluginCheckVersion
3624 });
3625
3626 methods.push_back((JNINativeMethod) {
3627 const_cast<char*>("OrthancPluginLogError"),
3628 const_cast<char*>("(Ljava/lang/String;)V"),
3629 (void*) JNI_OrthancPluginLogError
3630 });
3631
3632 methods.push_back((JNINativeMethod) {
3633 const_cast<char*>("OrthancPluginLogWarning"),
3634 const_cast<char*>("(Ljava/lang/String;)V"),
3635 (void*) JNI_OrthancPluginLogWarning
3636 });
3637
3638 methods.push_back((JNINativeMethod) {
3639 const_cast<char*>("OrthancPluginLogInfo"),
3640 const_cast<char*>("(Ljava/lang/String;)V"),
3641 (void*) JNI_OrthancPluginLogInfo
3642 });
3643
3644 methods.push_back((JNINativeMethod) {
3645 const_cast<char*>("OrthancPluginGetDicomForInstance"),
3646 const_cast<char*>("(Ljava/lang/String;)[B"),
3647 (void*) JNI_OrthancPluginGetDicomForInstance
3648 });
3649
3650 methods.push_back((JNINativeMethod) {
3651 const_cast<char*>("OrthancPluginRestApiGet"),
3652 const_cast<char*>("(Ljava/lang/String;)[B"),
3653 (void*) JNI_OrthancPluginRestApiGet
3654 });
3655
3656 methods.push_back((JNINativeMethod) {
3657 const_cast<char*>("OrthancPluginRestApiGetAfterPlugins"),
3658 const_cast<char*>("(Ljava/lang/String;)[B"),
3659 (void*) JNI_OrthancPluginRestApiGetAfterPlugins
3660 });
3661
3662 methods.push_back((JNINativeMethod) {
3663 const_cast<char*>("OrthancPluginRestApiPost"),
3664 const_cast<char*>("(Ljava/lang/String;[B)[B"),
3665 (void*) JNI_OrthancPluginRestApiPost
3666 });
3667
3668 methods.push_back((JNINativeMethod) {
3669 const_cast<char*>("OrthancPluginRestApiPostAfterPlugins"),
3670 const_cast<char*>("(Ljava/lang/String;[B)[B"),
3671 (void*) JNI_OrthancPluginRestApiPostAfterPlugins
3672 });
3673
3674 methods.push_back((JNINativeMethod) {
3675 const_cast<char*>("OrthancPluginRestApiDelete"),
3676 const_cast<char*>("(Ljava/lang/String;)V"),
3677 (void*) JNI_OrthancPluginRestApiDelete
3678 });
3679
3680 methods.push_back((JNINativeMethod) {
3681 const_cast<char*>("OrthancPluginRestApiDeleteAfterPlugins"),
3682 const_cast<char*>("(Ljava/lang/String;)V"),
3683 (void*) JNI_OrthancPluginRestApiDeleteAfterPlugins
3684 });
3685
3686 methods.push_back((JNINativeMethod) {
3687 const_cast<char*>("OrthancPluginRestApiPut"),
3688 const_cast<char*>("(Ljava/lang/String;[B)[B"),
3689 (void*) JNI_OrthancPluginRestApiPut
3690 });
3691
3692 methods.push_back((JNINativeMethod) {
3693 const_cast<char*>("OrthancPluginRestApiPutAfterPlugins"),
3694 const_cast<char*>("(Ljava/lang/String;[B)[B"),
3695 (void*) JNI_OrthancPluginRestApiPutAfterPlugins
3696 });
3697
3698 methods.push_back((JNINativeMethod) {
3699 const_cast<char*>("OrthancPluginLookupPatient"),
3700 const_cast<char*>("(Ljava/lang/String;)Ljava/lang/String;"),
3701 (void*) JNI_OrthancPluginLookupPatient
3702 });
3703
3704 methods.push_back((JNINativeMethod) {
3705 const_cast<char*>("OrthancPluginLookupStudy"),
3706 const_cast<char*>("(Ljava/lang/String;)Ljava/lang/String;"),
3707 (void*) JNI_OrthancPluginLookupStudy
3708 });
3709
3710 methods.push_back((JNINativeMethod) {
3711 const_cast<char*>("OrthancPluginLookupStudyWithAccessionNumber"),
3712 const_cast<char*>("(Ljava/lang/String;)Ljava/lang/String;"),
3713 (void*) JNI_OrthancPluginLookupStudyWithAccessionNumber
3714 });
3715
3716 methods.push_back((JNINativeMethod) {
3717 const_cast<char*>("OrthancPluginLookupSeries"),
3718 const_cast<char*>("(Ljava/lang/String;)Ljava/lang/String;"),
3719 (void*) JNI_OrthancPluginLookupSeries
3720 });
3721
3722 methods.push_back((JNINativeMethod) {
3723 const_cast<char*>("OrthancPluginLookupInstance"),
3724 const_cast<char*>("(Ljava/lang/String;)Ljava/lang/String;"),
3725 (void*) JNI_OrthancPluginLookupInstance
3726 });
3727
3728 methods.push_back((JNINativeMethod) {
3729 const_cast<char*>("OrthancPluginGetOrthancPath"),
3730 const_cast<char*>("()Ljava/lang/String;"),
3731 (void*) JNI_OrthancPluginGetOrthancPath
3732 });
3733
3734 methods.push_back((JNINativeMethod) {
3735 const_cast<char*>("OrthancPluginGetOrthancDirectory"),
3736 const_cast<char*>("()Ljava/lang/String;"),
3737 (void*) JNI_OrthancPluginGetOrthancDirectory
3738 });
3739
3740 methods.push_back((JNINativeMethod) {
3741 const_cast<char*>("OrthancPluginGetConfigurationPath"),
3742 const_cast<char*>("()Ljava/lang/String;"),
3743 (void*) JNI_OrthancPluginGetConfigurationPath
3744 });
3745
3746 methods.push_back((JNINativeMethod) {
3747 const_cast<char*>("OrthancPluginSetRootUri"),
3748 const_cast<char*>("(Ljava/lang/String;)V"),
3749 (void*) JNI_OrthancPluginSetRootUri
3750 });
3751
3752 methods.push_back((JNINativeMethod) {
3753 const_cast<char*>("OrthancPluginSetDescription"),
3754 const_cast<char*>("(Ljava/lang/String;)V"),
3755 (void*) JNI_OrthancPluginSetDescription
3756 });
3757
3758 methods.push_back((JNINativeMethod) {
3759 const_cast<char*>("OrthancPluginExtendOrthancExplorer"),
3760 const_cast<char*>("(Ljava/lang/String;)V"),
3761 (void*) JNI_OrthancPluginExtendOrthancExplorer
3762 });
3763
3764 methods.push_back((JNINativeMethod) {
3765 const_cast<char*>("OrthancPluginGetGlobalProperty"),
3766 const_cast<char*>("(ILjava/lang/String;)Ljava/lang/String;"),
3767 (void*) JNI_OrthancPluginGetGlobalProperty
3768 });
3769
3770 methods.push_back((JNINativeMethod) {
3771 const_cast<char*>("OrthancPluginSetGlobalProperty"),
3772 const_cast<char*>("(ILjava/lang/String;)V"),
3773 (void*) JNI_OrthancPluginSetGlobalProperty
3774 });
3775
3776 methods.push_back((JNINativeMethod) {
3777 const_cast<char*>("OrthancPluginGetCommandLineArgumentsCount"),
3778 const_cast<char*>("()I"),
3779 (void*) JNI_OrthancPluginGetCommandLineArgumentsCount
3780 });
3781
3782 methods.push_back((JNINativeMethod) {
3783 const_cast<char*>("OrthancPluginGetCommandLineArgument"),
3784 const_cast<char*>("(I)Ljava/lang/String;"),
3785 (void*) JNI_OrthancPluginGetCommandLineArgument
3786 });
3787
3788 methods.push_back((JNINativeMethod) {
3789 const_cast<char*>("OrthancPluginGetExpectedDatabaseVersion"),
3790 const_cast<char*>("()I"),
3791 (void*) JNI_OrthancPluginGetExpectedDatabaseVersion
3792 });
3793
3794 methods.push_back((JNINativeMethod) {
3795 const_cast<char*>("OrthancPluginGetConfiguration"),
3796 const_cast<char*>("()Ljava/lang/String;"),
3797 (void*) JNI_OrthancPluginGetConfiguration
3798 });
3799
3800 methods.push_back((JNINativeMethod) {
3801 const_cast<char*>("OrthancPluginBufferCompression"),
3802 const_cast<char*>("([BIB)[B"),
3803 (void*) JNI_OrthancPluginBufferCompression
3804 });
3805
3806 methods.push_back((JNINativeMethod) {
3807 const_cast<char*>("OrthancPluginReadFile"),
3808 const_cast<char*>("(Ljava/lang/String;)[B"),
3809 (void*) JNI_OrthancPluginReadFile
3810 });
3811
3812 methods.push_back((JNINativeMethod) {
3813 const_cast<char*>("OrthancPluginWriteFile"),
3814 const_cast<char*>("(Ljava/lang/String;[B)V"),
3815 (void*) JNI_OrthancPluginWriteFile
3816 });
3817
3818 methods.push_back((JNINativeMethod) {
3819 const_cast<char*>("OrthancPluginGetErrorDescription"),
3820 const_cast<char*>("(I)Ljava/lang/String;"),
3821 (void*) JNI_OrthancPluginGetErrorDescription
3822 });
3823
3824 methods.push_back((JNINativeMethod) {
3825 const_cast<char*>("OrthancPluginUncompressImage"),
3826 const_cast<char*>("([BI)J"),
3827 (void*) JNI_OrthancPluginUncompressImage
3828 });
3829
3830 methods.push_back((JNINativeMethod) {
3831 const_cast<char*>("OrthancPluginCompressPngImage"),
3832 const_cast<char*>("(IIII[B)[B"),
3833 (void*) JNI_OrthancPluginCompressPngImage
3834 });
3835
3836 methods.push_back((JNINativeMethod) {
3837 const_cast<char*>("OrthancPluginCompressJpegImage"),
3838 const_cast<char*>("(IIII[BB)[B"),
3839 (void*) JNI_OrthancPluginCompressJpegImage
3840 });
3841
3842 methods.push_back((JNINativeMethod) {
3843 const_cast<char*>("OrthancPluginHttpGet"),
3844 const_cast<char*>("(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)[B"),
3845 (void*) JNI_OrthancPluginHttpGet
3846 });
3847
3848 methods.push_back((JNINativeMethod) {
3849 const_cast<char*>("OrthancPluginHttpPost"),
3850 const_cast<char*>("(Ljava/lang/String;[BLjava/lang/String;Ljava/lang/String;)[B"),
3851 (void*) JNI_OrthancPluginHttpPost
3852 });
3853
3854 methods.push_back((JNINativeMethod) {
3855 const_cast<char*>("OrthancPluginHttpPut"),
3856 const_cast<char*>("(Ljava/lang/String;[BLjava/lang/String;Ljava/lang/String;)[B"),
3857 (void*) JNI_OrthancPluginHttpPut
3858 });
3859
3860 methods.push_back((JNINativeMethod) {
3861 const_cast<char*>("OrthancPluginHttpDelete"),
3862 const_cast<char*>("(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V"),
3863 (void*) JNI_OrthancPluginHttpDelete
3864 });
3865
3866 methods.push_back((JNINativeMethod) {
3867 const_cast<char*>("OrthancPluginGetFontsCount"),
3868 const_cast<char*>("()I"),
3869 (void*) JNI_OrthancPluginGetFontsCount
3870 });
3871
3872 methods.push_back((JNINativeMethod) {
3873 const_cast<char*>("OrthancPluginGetFontName"),
3874 const_cast<char*>("(I)Ljava/lang/String;"),
3875 (void*) JNI_OrthancPluginGetFontName
3876 });
3877
3878 methods.push_back((JNINativeMethod) {
3879 const_cast<char*>("OrthancPluginGetFontSize"),
3880 const_cast<char*>("(I)I"),
3881 (void*) JNI_OrthancPluginGetFontSize
3882 });
3883
3884 methods.push_back((JNINativeMethod) {
3885 const_cast<char*>("OrthancPluginRegisterErrorCode"),
3886 const_cast<char*>("(ISLjava/lang/String;)V"),
3887 (void*) JNI_OrthancPluginRegisterErrorCode
3888 });
3889
3890 methods.push_back((JNINativeMethod) {
3891 const_cast<char*>("OrthancPluginRegisterDictionaryTag"),
3892 const_cast<char*>("(SSILjava/lang/String;II)V"),
3893 (void*) JNI_OrthancPluginRegisterDictionaryTag
3894 });
3895
3896 methods.push_back((JNINativeMethod) {
3897 const_cast<char*>("OrthancPluginRegisterPrivateDictionaryTag"),
3898 const_cast<char*>("(SSILjava/lang/String;IILjava/lang/String;)V"),
3899 (void*) JNI_OrthancPluginRegisterPrivateDictionaryTag
3900 });
3901
3902 methods.push_back((JNINativeMethod) {
3903 const_cast<char*>("OrthancPluginDicomBufferToJson"),
3904 const_cast<char*>("([BIII)Ljava/lang/String;"),
3905 (void*) JNI_OrthancPluginDicomBufferToJson
3906 });
3907
3908 methods.push_back((JNINativeMethod) {
3909 const_cast<char*>("OrthancPluginDicomInstanceToJson"),
3910 const_cast<char*>("(Ljava/lang/String;III)Ljava/lang/String;"),
3911 (void*) JNI_OrthancPluginDicomInstanceToJson
3912 });
3913
3914 methods.push_back((JNINativeMethod) {
3915 const_cast<char*>("OrthancPluginCreateDicom"),
3916 const_cast<char*>("(Ljava/lang/String;JI)[B"),
3917 (void*) JNI_OrthancPluginCreateDicom
3918 });
3919
3920 methods.push_back((JNINativeMethod) {
3921 const_cast<char*>("OrthancPluginCreateImage"),
3922 const_cast<char*>("(III)J"),
3923 (void*) JNI_OrthancPluginCreateImage
3924 });
3925
3926 methods.push_back((JNINativeMethod) {
3927 const_cast<char*>("OrthancPluginDecodeDicomImage"),
3928 const_cast<char*>("([BI)J"),
3929 (void*) JNI_OrthancPluginDecodeDicomImage
3930 });
3931
3932 methods.push_back((JNINativeMethod) {
3933 const_cast<char*>("OrthancPluginComputeMd5"),
3934 const_cast<char*>("([B)Ljava/lang/String;"),
3935 (void*) JNI_OrthancPluginComputeMd5
3936 });
3937
3938 methods.push_back((JNINativeMethod) {
3939 const_cast<char*>("OrthancPluginComputeSha1"),
3940 const_cast<char*>("([B)Ljava/lang/String;"),
3941 (void*) JNI_OrthancPluginComputeSha1
3942 });
3943
3944 methods.push_back((JNINativeMethod) {
3945 const_cast<char*>("OrthancPluginGenerateUuid"),
3946 const_cast<char*>("()Ljava/lang/String;"),
3947 (void*) JNI_OrthancPluginGenerateUuid
3948 });
3949
3950 methods.push_back((JNINativeMethod) {
3951 const_cast<char*>("OrthancPluginCreateFindMatcher"),
3952 const_cast<char*>("([B)J"),
3953 (void*) JNI_OrthancPluginCreateFindMatcher
3954 });
3955
3956 methods.push_back((JNINativeMethod) {
3957 const_cast<char*>("OrthancPluginGetPeers"),
3958 const_cast<char*>("()J"),
3959 (void*) JNI_OrthancPluginGetPeers
3960 });
3961
3962 methods.push_back((JNINativeMethod) {
3963 const_cast<char*>("OrthancPluginAutodetectMimeType"),
3964 const_cast<char*>("(Ljava/lang/String;)Ljava/lang/String;"),
3965 (void*) JNI_OrthancPluginAutodetectMimeType
3966 });
3967
3968 methods.push_back((JNINativeMethod) {
3969 const_cast<char*>("OrthancPluginSetMetricsValue"),
3970 const_cast<char*>("(Ljava/lang/String;FI)V"),
3971 (void*) JNI_OrthancPluginSetMetricsValue
3972 });
3973
3974 methods.push_back((JNINativeMethod) {
3975 const_cast<char*>("OrthancPluginGetTagName"),
3976 const_cast<char*>("(SSLjava/lang/String;)Ljava/lang/String;"),
3977 (void*) JNI_OrthancPluginGetTagName
3978 });
3979
3980 methods.push_back((JNINativeMethod) {
3981 const_cast<char*>("OrthancPluginCreateDicomInstance"),
3982 const_cast<char*>("([B)J"),
3983 (void*) JNI_OrthancPluginCreateDicomInstance
3984 });
3985
3986 methods.push_back((JNINativeMethod) {
3987 const_cast<char*>("OrthancPluginTranscodeDicomInstance"),
3988 const_cast<char*>("([BLjava/lang/String;)J"),
3989 (void*) JNI_OrthancPluginTranscodeDicomInstance
3990 });
3991
3992 methods.push_back((JNINativeMethod) {
3993 const_cast<char*>("OrthancPluginGenerateRestApiAuthorizationToken"),
3994 const_cast<char*>("()Ljava/lang/String;"),
3995 (void*) JNI_OrthancPluginGenerateRestApiAuthorizationToken
3996 });
3997
3998 methods.push_back((JNINativeMethod) {
3999 const_cast<char*>("OrthancPluginCreateDicom2"),
4000 const_cast<char*>("(Ljava/lang/String;JILjava/lang/String;)[B"),
4001 (void*) JNI_OrthancPluginCreateDicom2
4002 });
4003
4004 methods.push_back((JNINativeMethod) {
4005 const_cast<char*>("OrthancPluginFreeDicomInstance"),
4006 const_cast<char*>("(J)V"),
4007 (void*) JNI_OrthancPluginFreeDicomInstance
4008 });
4009
4010 methods.push_back((JNINativeMethod) {
4011 const_cast<char*>("OrthancPluginGetInstanceRemoteAet"),
4012 const_cast<char*>("(J)Ljava/lang/String;"),
4013 (void*) JNI_OrthancPluginGetInstanceRemoteAet
4014 });
4015
4016 methods.push_back((JNINativeMethod) {
4017 const_cast<char*>("OrthancPluginGetInstanceSize"),
4018 const_cast<char*>("(J)J"),
4019 (void*) JNI_OrthancPluginGetInstanceSize
4020 });
4021
4022 methods.push_back((JNINativeMethod) {
4023 const_cast<char*>("OrthancPluginGetInstanceJson"),
4024 const_cast<char*>("(J)Ljava/lang/String;"),
4025 (void*) JNI_OrthancPluginGetInstanceJson
4026 });
4027
4028 methods.push_back((JNINativeMethod) {
4029 const_cast<char*>("OrthancPluginGetInstanceSimplifiedJson"),
4030 const_cast<char*>("(J)Ljava/lang/String;"),
4031 (void*) JNI_OrthancPluginGetInstanceSimplifiedJson
4032 });
4033
4034 methods.push_back((JNINativeMethod) {
4035 const_cast<char*>("OrthancPluginHasInstanceMetadata"),
4036 const_cast<char*>("(JLjava/lang/String;)I"),
4037 (void*) JNI_OrthancPluginHasInstanceMetadata
4038 });
4039
4040 methods.push_back((JNINativeMethod) {
4041 const_cast<char*>("OrthancPluginGetInstanceMetadata"),
4042 const_cast<char*>("(JLjava/lang/String;)Ljava/lang/String;"),
4043 (void*) JNI_OrthancPluginGetInstanceMetadata
4044 });
4045
4046 methods.push_back((JNINativeMethod) {
4047 const_cast<char*>("OrthancPluginGetInstanceOrigin"),
4048 const_cast<char*>("(J)I"),
4049 (void*) JNI_OrthancPluginGetInstanceOrigin
4050 });
4051
4052 methods.push_back((JNINativeMethod) {
4053 const_cast<char*>("OrthancPluginGetInstanceTransferSyntaxUid"),
4054 const_cast<char*>("(J)Ljava/lang/String;"),
4055 (void*) JNI_OrthancPluginGetInstanceTransferSyntaxUid
4056 });
4057
4058 methods.push_back((JNINativeMethod) {
4059 const_cast<char*>("OrthancPluginHasInstancePixelData"),
4060 const_cast<char*>("(J)I"),
4061 (void*) JNI_OrthancPluginHasInstancePixelData
4062 });
4063
4064 methods.push_back((JNINativeMethod) {
4065 const_cast<char*>("OrthancPluginGetInstanceFramesCount"),
4066 const_cast<char*>("(J)I"),
4067 (void*) JNI_OrthancPluginGetInstanceFramesCount
4068 });
4069
4070 methods.push_back((JNINativeMethod) {
4071 const_cast<char*>("OrthancPluginGetInstanceRawFrame"),
4072 const_cast<char*>("(JI)[B"),
4073 (void*) JNI_OrthancPluginGetInstanceRawFrame
4074 });
4075
4076 methods.push_back((JNINativeMethod) {
4077 const_cast<char*>("OrthancPluginGetInstanceDecodedFrame"),
4078 const_cast<char*>("(JI)J"),
4079 (void*) JNI_OrthancPluginGetInstanceDecodedFrame
4080 });
4081
4082 methods.push_back((JNINativeMethod) {
4083 const_cast<char*>("OrthancPluginSerializeDicomInstance"),
4084 const_cast<char*>("(J)[B"),
4085 (void*) JNI_OrthancPluginSerializeDicomInstance
4086 });
4087
4088 methods.push_back((JNINativeMethod) {
4089 const_cast<char*>("OrthancPluginGetInstanceAdvancedJson"),
4090 const_cast<char*>("(JIII)Ljava/lang/String;"),
4091 (void*) JNI_OrthancPluginGetInstanceAdvancedJson
4092 });
4093
4094 methods.push_back((JNINativeMethod) {
4095 const_cast<char*>("OrthancPluginFindAddAnswer"),
4096 const_cast<char*>("(J[B)V"),
4097 (void*) JNI_OrthancPluginFindAddAnswer
4098 });
4099
4100 methods.push_back((JNINativeMethod) {
4101 const_cast<char*>("OrthancPluginFindMarkIncomplete"),
4102 const_cast<char*>("(J)V"),
4103 (void*) JNI_OrthancPluginFindMarkIncomplete
4104 });
4105
4106 methods.push_back((JNINativeMethod) {
4107 const_cast<char*>("OrthancPluginFreeFindMatcher"),
4108 const_cast<char*>("(J)V"),
4109 (void*) JNI_OrthancPluginFreeFindMatcher
4110 });
4111
4112 methods.push_back((JNINativeMethod) {
4113 const_cast<char*>("OrthancPluginFindMatcherIsMatch"),
4114 const_cast<char*>("(J[B)I"),
4115 (void*) JNI_OrthancPluginFindMatcherIsMatch
4116 });
4117
4118 methods.push_back((JNINativeMethod) {
4119 const_cast<char*>("OrthancPluginGetFindQuerySize"),
4120 const_cast<char*>("(J)I"),
4121 (void*) JNI_OrthancPluginGetFindQuerySize
4122 });
4123
4124 methods.push_back((JNINativeMethod) {
4125 const_cast<char*>("OrthancPluginGetFindQueryTagName"),
4126 const_cast<char*>("(JI)Ljava/lang/String;"),
4127 (void*) JNI_OrthancPluginGetFindQueryTagName
4128 });
4129
4130 methods.push_back((JNINativeMethod) {
4131 const_cast<char*>("OrthancPluginGetFindQueryValue"),
4132 const_cast<char*>("(JI)Ljava/lang/String;"),
4133 (void*) JNI_OrthancPluginGetFindQueryValue
4134 });
4135
4136 methods.push_back((JNINativeMethod) {
4137 const_cast<char*>("OrthancPluginFreeImage"),
4138 const_cast<char*>("(J)V"),
4139 (void*) JNI_OrthancPluginFreeImage
4140 });
4141
4142 methods.push_back((JNINativeMethod) {
4143 const_cast<char*>("OrthancPluginGetImagePixelFormat"),
4144 const_cast<char*>("(J)I"),
4145 (void*) JNI_OrthancPluginGetImagePixelFormat
4146 });
4147
4148 methods.push_back((JNINativeMethod) {
4149 const_cast<char*>("OrthancPluginGetImageWidth"),
4150 const_cast<char*>("(J)I"),
4151 (void*) JNI_OrthancPluginGetImageWidth
4152 });
4153
4154 methods.push_back((JNINativeMethod) {
4155 const_cast<char*>("OrthancPluginGetImageHeight"),
4156 const_cast<char*>("(J)I"),
4157 (void*) JNI_OrthancPluginGetImageHeight
4158 });
4159
4160 methods.push_back((JNINativeMethod) {
4161 const_cast<char*>("OrthancPluginGetImagePitch"),
4162 const_cast<char*>("(J)I"),
4163 (void*) JNI_OrthancPluginGetImagePitch
4164 });
4165
4166 methods.push_back((JNINativeMethod) {
4167 const_cast<char*>("OrthancPluginConvertPixelFormat"),
4168 const_cast<char*>("(JI)J"),
4169 (void*) JNI_OrthancPluginConvertPixelFormat
4170 });
4171
4172 methods.push_back((JNINativeMethod) {
4173 const_cast<char*>("OrthancPluginDrawText"),
4174 const_cast<char*>("(JILjava/lang/String;IIBBB)V"),
4175 (void*) JNI_OrthancPluginDrawText
4176 });
4177
4178 methods.push_back((JNINativeMethod) {
4179 const_cast<char*>("OrthancPluginFreeJob"),
4180 const_cast<char*>("(J)V"),
4181 (void*) JNI_OrthancPluginFreeJob
4182 });
4183
4184 methods.push_back((JNINativeMethod) {
4185 const_cast<char*>("OrthancPluginSubmitJob"),
4186 const_cast<char*>("(JI)Ljava/lang/String;"),
4187 (void*) JNI_OrthancPluginSubmitJob
4188 });
4189
4190 methods.push_back((JNINativeMethod) {
4191 const_cast<char*>("OrthancPluginFreePeers"),
4192 const_cast<char*>("(J)V"),
4193 (void*) JNI_OrthancPluginFreePeers
4194 });
4195
4196 methods.push_back((JNINativeMethod) {
4197 const_cast<char*>("OrthancPluginGetPeersCount"),
4198 const_cast<char*>("(J)I"),
4199 (void*) JNI_OrthancPluginGetPeersCount
4200 });
4201
4202 methods.push_back((JNINativeMethod) {
4203 const_cast<char*>("OrthancPluginGetPeerName"),
4204 const_cast<char*>("(JI)Ljava/lang/String;"),
4205 (void*) JNI_OrthancPluginGetPeerName
4206 });
4207
4208 methods.push_back((JNINativeMethod) {
4209 const_cast<char*>("OrthancPluginGetPeerUrl"),
4210 const_cast<char*>("(JI)Ljava/lang/String;"),
4211 (void*) JNI_OrthancPluginGetPeerUrl
4212 });
4213
4214 methods.push_back((JNINativeMethod) {
4215 const_cast<char*>("OrthancPluginGetPeerUserProperty"),
4216 const_cast<char*>("(JILjava/lang/String;)Ljava/lang/String;"),
4217 (void*) JNI_OrthancPluginGetPeerUserProperty
4218 });
4219
4220 methods.push_back((JNINativeMethod) {
4221 const_cast<char*>("OrthancPluginAnswerBuffer"),
4222 const_cast<char*>("(J[BLjava/lang/String;)V"),
4223 (void*) JNI_OrthancPluginAnswerBuffer
4224 });
4225
4226 methods.push_back((JNINativeMethod) {
4227 const_cast<char*>("OrthancPluginCompressAndAnswerPngImage"),
4228 const_cast<char*>("(JIIII[B)V"),
4229 (void*) JNI_OrthancPluginCompressAndAnswerPngImage
4230 });
4231
4232 methods.push_back((JNINativeMethod) {
4233 const_cast<char*>("OrthancPluginRedirect"),
4234 const_cast<char*>("(JLjava/lang/String;)V"),
4235 (void*) JNI_OrthancPluginRedirect
4236 });
4237
4238 methods.push_back((JNINativeMethod) {
4239 const_cast<char*>("OrthancPluginSendHttpStatusCode"),
4240 const_cast<char*>("(JS)V"),
4241 (void*) JNI_OrthancPluginSendHttpStatusCode
4242 });
4243
4244 methods.push_back((JNINativeMethod) {
4245 const_cast<char*>("OrthancPluginSendUnauthorized"),
4246 const_cast<char*>("(JLjava/lang/String;)V"),
4247 (void*) JNI_OrthancPluginSendUnauthorized
4248 });
4249
4250 methods.push_back((JNINativeMethod) {
4251 const_cast<char*>("OrthancPluginSendMethodNotAllowed"),
4252 const_cast<char*>("(JLjava/lang/String;)V"),
4253 (void*) JNI_OrthancPluginSendMethodNotAllowed
4254 });
4255
4256 methods.push_back((JNINativeMethod) {
4257 const_cast<char*>("OrthancPluginSetCookie"),
4258 const_cast<char*>("(JLjava/lang/String;Ljava/lang/String;)V"),
4259 (void*) JNI_OrthancPluginSetCookie
4260 });
4261
4262 methods.push_back((JNINativeMethod) {
4263 const_cast<char*>("OrthancPluginSetHttpHeader"),
4264 const_cast<char*>("(JLjava/lang/String;Ljava/lang/String;)V"),
4265 (void*) JNI_OrthancPluginSetHttpHeader
4266 });
4267
4268 methods.push_back((JNINativeMethod) {
4269 const_cast<char*>("OrthancPluginStartMultipartAnswer"),
4270 const_cast<char*>("(JLjava/lang/String;Ljava/lang/String;)V"),
4271 (void*) JNI_OrthancPluginStartMultipartAnswer
4272 });
4273
4274 methods.push_back((JNINativeMethod) {
4275 const_cast<char*>("OrthancPluginSendMultipartItem"),
4276 const_cast<char*>("(J[B)V"),
4277 (void*) JNI_OrthancPluginSendMultipartItem
4278 });
4279
4280 methods.push_back((JNINativeMethod) {
4281 const_cast<char*>("OrthancPluginSendHttpStatus"),
4282 const_cast<char*>("(JS[B)V"),
4283 (void*) JNI_OrthancPluginSendHttpStatus
4284 });
4285
4286 methods.push_back((JNINativeMethod) {
4287 const_cast<char*>("OrthancPluginCompressAndAnswerJpegImage"),
4288 const_cast<char*>("(JIIII[BB)V"),
4289 (void*) JNI_OrthancPluginCompressAndAnswerJpegImage
4290 });
4291
4292 methods.push_back((JNINativeMethod) {
4293 const_cast<char*>("OrthancPluginSetHttpErrorDetails"),
4294 const_cast<char*>("(JLjava/lang/String;B)V"),
4295 (void*) JNI_OrthancPluginSetHttpErrorDetails
4296 });
4297
4298 methods.push_back((JNINativeMethod) {
4299 const_cast<char*>("OrthancPluginStorageAreaCreate"),
4300 const_cast<char*>("(JLjava/lang/String;[BJI)V"),
4301 (void*) JNI_OrthancPluginStorageAreaCreate
4302 });
4303
4304 methods.push_back((JNINativeMethod) {
4305 const_cast<char*>("OrthancPluginStorageAreaRead"),
4306 const_cast<char*>("(JLjava/lang/String;I)[B"),
4307 (void*) JNI_OrthancPluginStorageAreaRead
4308 });
4309
4310 methods.push_back((JNINativeMethod) {
4311 const_cast<char*>("OrthancPluginStorageAreaRemove"),
4312 const_cast<char*>("(JLjava/lang/String;I)V"),
4313 (void*) JNI_OrthancPluginStorageAreaRemove
4314 });
4315
4316 methods.push_back((JNINativeMethod) {
4317 const_cast<char*>("OrthancPluginReconstructMainDicomTags"),
4318 const_cast<char*>("(JI)V"),
4319 (void*) JNI_OrthancPluginReconstructMainDicomTags
4320 });
4321
4322 methods.push_back((JNINativeMethod) {
4323 const_cast<char*>("OrthancPluginWorklistAddAnswer"),
4324 const_cast<char*>("(JJ[B)V"),
4325 (void*) JNI_OrthancPluginWorklistAddAnswer
4326 });
4327
4328 methods.push_back((JNINativeMethod) {
4329 const_cast<char*>("OrthancPluginWorklistMarkIncomplete"),
4330 const_cast<char*>("(J)V"),
4331 (void*) JNI_OrthancPluginWorklistMarkIncomplete
4332 });
4333
4334 methods.push_back((JNINativeMethod) {
4335 const_cast<char*>("OrthancPluginWorklistIsMatch"),
4336 const_cast<char*>("(J[B)I"),
4337 (void*) JNI_OrthancPluginWorklistIsMatch
4338 });
4339
4340 methods.push_back((JNINativeMethod) {
4341 const_cast<char*>("OrthancPluginWorklistGetDicomQuery"),
4342 const_cast<char*>("(J)[B"),
4343 (void*) JNI_OrthancPluginWorklistGetDicomQuery
4344 });
4345 }