00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include "ppl_java_common.defs.hh"
00025
00026 namespace Parma_Polyhedra_Library {
00027
00028 namespace Interfaces {
00029
00030 namespace Java {
00031
00032
00033 Java_Class_Cache cached_classes;
00034 Java_FMID_Cache cached_FMIDs;
00035
00036 Java_Class_Cache::Java_Class_Cache() {
00037
00038 Boolean = NULL;
00039 Integer = NULL;
00040 Long = NULL;
00041 Iterator = NULL;
00042
00043 Artificial_Parameter = NULL;
00044 Artificial_Parameter_Sequence = NULL;
00045 Bounded_Integer_Type_Overflow = NULL;
00046 Bounded_Integer_Type_Representation = NULL;
00047 Bounded_Integer_Type_Width = NULL;
00048 By_Reference = NULL;
00049 Coefficient = NULL;
00050 Congruence = NULL;
00051 Constraint = NULL;
00052 Generator = NULL;
00053 Grid_Generator = NULL;
00054 Generator_Type = NULL;
00055 Grid_Generator_Type = NULL;
00056 Constraint_System = NULL;
00057 Congruence_System = NULL;
00058 Generator_System = NULL;
00059 Grid_Generator_System = NULL;
00060 Linear_Expression = NULL;
00061 Linear_Expression_Coefficient = NULL;
00062 Linear_Expression_Difference = NULL;
00063 Linear_Expression_Sum = NULL;
00064 Linear_Expression_Times = NULL;
00065 Linear_Expression_Unary_Minus = NULL;
00066 Linear_Expression_Variable = NULL;
00067 MIP_Problem_Status = NULL;
00068 Optimization_Mode = NULL;
00069 Pair = NULL;
00070 PIP_Problem_Control_Parameter_Name = NULL;
00071 PIP_Problem_Control_Parameter_Value = NULL;
00072 PIP_Problem_Status = NULL;
00073 Poly_Con_Relation = NULL;
00074 Poly_Gen_Relation = NULL;
00075 PPL_Object = NULL;
00076 Relation_Symbol = NULL;
00077 Variable = NULL;
00078 Variables_Set = NULL;
00079 }
00080
00081 void
00082 Java_Class_Cache::init_cache(JNIEnv* env, jclass& field, const char* name) {
00083 assert(env != NULL);
00084 if (field != NULL) {
00085 env->DeleteGlobalRef(field);
00086 }
00087 jclass jni_class = env->FindClass(name);
00088 CHECK_RESULT_ASSERT(env, jni_class);
00089 field = (jclass) env->NewGlobalRef(jni_class);
00090 CHECK_RESULT_ASSERT(env, field);
00091 }
00092
00093 void
00094 Java_Class_Cache::init_cache(JNIEnv* env) {
00095 assert(env != NULL);
00096
00097 init_cache(env, Boolean, "java/lang/Boolean");
00098 init_cache(env, Integer, "java/lang/Integer");
00099 init_cache(env, Long, "java/lang/Long");
00100 init_cache(env, Iterator, "java/util/Iterator");
00101
00102 init_cache(env, Artificial_Parameter,
00103 "parma_polyhedra_library/Artificial_Parameter");
00104 init_cache(env, Artificial_Parameter_Sequence,
00105 "parma_polyhedra_library/Artificial_Parameter_Sequence");
00106 init_cache(env, Bounded_Integer_Type_Overflow, "parma_polyhedra_library/Bounded_Integer_Type_Overflow");
00107 init_cache(env, Bounded_Integer_Type_Representation, "parma_polyhedra_library/Bounded_Integer_Type_Representation");
00108 init_cache(env, Bounded_Integer_Type_Width, "parma_polyhedra_library/Bounded_Integer_Type_Width");
00109 init_cache(env, By_Reference, "parma_polyhedra_library/By_Reference");
00110 init_cache(env, Coefficient, "parma_polyhedra_library/Coefficient");
00111 init_cache(env, Congruence, "parma_polyhedra_library/Congruence");
00112 init_cache(env, Constraint, "parma_polyhedra_library/Constraint");
00113 init_cache(env, Generator, "parma_polyhedra_library/Generator");
00114 init_cache(env, Grid_Generator, "parma_polyhedra_library/Grid_Generator");
00115 init_cache(env, Generator_Type, "parma_polyhedra_library/Generator_Type");
00116 init_cache(env, Grid_Generator_Type,
00117 "parma_polyhedra_library/Grid_Generator_Type");
00118 init_cache(env, Constraint_System,
00119 "parma_polyhedra_library/Constraint_System");
00120 init_cache(env, Congruence_System,
00121 "parma_polyhedra_library/Congruence_System");
00122 init_cache(env, Generator_System,
00123 "parma_polyhedra_library/Generator_System");
00124 init_cache(env, Grid_Generator_System,
00125 "parma_polyhedra_library/Grid_Generator_System");
00126 init_cache(env, Linear_Expression,
00127 "parma_polyhedra_library/Linear_Expression");
00128 init_cache(env, Linear_Expression_Coefficient,
00129 "parma_polyhedra_library/Linear_Expression_Coefficient");
00130 init_cache(env, Linear_Expression_Difference,
00131 "parma_polyhedra_library/Linear_Expression_Difference");
00132 init_cache(env, Linear_Expression_Sum,
00133 "parma_polyhedra_library/Linear_Expression_Sum");
00134 init_cache(env, Linear_Expression_Times,
00135 "parma_polyhedra_library/Linear_Expression_Times");
00136 init_cache(env, Linear_Expression_Unary_Minus,
00137 "parma_polyhedra_library/Linear_Expression_Unary_Minus");
00138 init_cache(env, Linear_Expression_Variable,
00139 "parma_polyhedra_library/Linear_Expression_Variable");
00140 init_cache(env, MIP_Problem_Status,
00141 "parma_polyhedra_library/MIP_Problem_Status");
00142 init_cache(env, Optimization_Mode,
00143 "parma_polyhedra_library/Optimization_Mode");
00144 init_cache(env, Pair, "parma_polyhedra_library/Pair");
00145 init_cache(env, PIP_Problem_Control_Parameter_Name,
00146 "parma_polyhedra_library/PIP_Problem_Control_Parameter_Name");
00147 init_cache(env, PIP_Problem_Control_Parameter_Value,
00148 "parma_polyhedra_library/PIP_Problem_Control_Parameter_Value");
00149 init_cache(env, PIP_Problem_Status,
00150 "parma_polyhedra_library/PIP_Problem_Status");
00151 init_cache(env, Poly_Con_Relation,
00152 "parma_polyhedra_library/Poly_Con_Relation");
00153 init_cache(env, Poly_Gen_Relation,
00154 "parma_polyhedra_library/Poly_Gen_Relation");
00155 init_cache(env, PPL_Object, "parma_polyhedra_library/PPL_Object");
00156 init_cache(env, Relation_Symbol, "parma_polyhedra_library/Relation_Symbol");
00157 init_cache(env, Variable, "parma_polyhedra_library/Variable");
00158 init_cache(env, Variables_Set, "parma_polyhedra_library/Variables_Set");
00159 }
00160
00161 void
00162 Java_Class_Cache::clear_cache(JNIEnv* env, jclass& field) {
00163 assert(env != NULL);
00164 if (field != NULL) {
00165 env->DeleteGlobalRef(field);
00166 field = NULL;
00167 }
00168 }
00169
00170 void
00171 Java_Class_Cache::clear_cache(JNIEnv* env) {
00172 assert(env != NULL);
00173
00174 clear_cache(env, Boolean);
00175 clear_cache(env, Integer);
00176 clear_cache(env, Long);
00177 clear_cache(env, Iterator);
00178
00179 clear_cache(env, Artificial_Parameter);
00180 clear_cache(env, Artificial_Parameter_Sequence);
00181 clear_cache(env, Bounded_Integer_Type_Overflow);
00182 clear_cache(env, Bounded_Integer_Type_Representation);
00183 clear_cache(env, Bounded_Integer_Type_Width);
00184 clear_cache(env, By_Reference);
00185 clear_cache(env, Coefficient);
00186 clear_cache(env, Congruence);
00187 clear_cache(env, Constraint);
00188 clear_cache(env, Generator);
00189 clear_cache(env, Grid_Generator);
00190 clear_cache(env, Generator_Type);
00191 clear_cache(env, Grid_Generator_Type);
00192 clear_cache(env, Constraint_System);
00193 clear_cache(env, Congruence_System);
00194 clear_cache(env, Generator_System);
00195 clear_cache(env, Grid_Generator_System);
00196 clear_cache(env, Linear_Expression);
00197 clear_cache(env, Linear_Expression_Coefficient);
00198 clear_cache(env, Linear_Expression_Difference);
00199 clear_cache(env, Linear_Expression_Sum);
00200 clear_cache(env, Linear_Expression_Times);
00201 clear_cache(env, Linear_Expression_Unary_Minus);
00202 clear_cache(env, Linear_Expression_Variable);
00203 clear_cache(env, MIP_Problem_Status);
00204 clear_cache(env, Optimization_Mode);
00205 clear_cache(env, PIP_Problem_Status);
00206 clear_cache(env, Pair);
00207 clear_cache(env, Poly_Con_Relation);
00208 clear_cache(env, Poly_Gen_Relation);
00209 clear_cache(env, PPL_Object);
00210 clear_cache(env, Relation_Symbol);
00211 clear_cache(env, Variable);
00212 clear_cache(env, Variables_Set);
00213 }
00214
00215 void
00216 handle_exception(JNIEnv* env, const std::overflow_error& e) {
00217 jclass newExcCls
00218 = env->FindClass("parma_polyhedra_library/Overflow_Error_Exception");
00219 CHECK_RESULT_ASSERT(env, newExcCls);
00220 jint ret = env->ThrowNew(newExcCls, e.what());
00221 CHECK_RESULT_ABORT(env, ret == 0);
00222 }
00223
00224 void
00225 handle_exception(JNIEnv* env, const std::invalid_argument& e) {
00226 jclass newExcCls
00227 = env->FindClass("parma_polyhedra_library/Invalid_Argument_Exception");
00228 CHECK_RESULT_ASSERT(env, newExcCls);
00229 jint ret = env->ThrowNew(newExcCls, e.what());
00230 CHECK_RESULT_ABORT(env, ret == 0);
00231 }
00232
00233 void
00234 handle_exception(JNIEnv* env, const std::logic_error& e) {
00235 jclass newExcCls
00236 = env->FindClass("parma_polyhedra_library/Logic_Error_Exception");
00237 CHECK_RESULT_ASSERT(env, newExcCls);
00238 jint ret = env->ThrowNew(newExcCls, e.what());
00239 CHECK_RESULT_ABORT(env, ret == 0);
00240 }
00241
00242 void
00243 handle_exception(JNIEnv* env, const std::length_error& e) {
00244 jclass newExcCls
00245 = env->FindClass("parma_polyhedra_library/Length_Error_Exception");
00246 CHECK_RESULT_ASSERT(env, newExcCls);
00247 jint ret = env->ThrowNew(newExcCls, e.what());
00248 CHECK_RESULT_ABORT(env, ret == 0);
00249 }
00250
00251 void
00252 handle_exception(JNIEnv* env, const std::domain_error& e) {
00253 jclass newExcCls
00254 = env->FindClass("parma_polyhedra_library/Domain_Error_Exception");
00255 CHECK_RESULT_ASSERT(env, newExcCls);
00256 jint ret = env->ThrowNew(newExcCls, e.what());
00257 CHECK_RESULT_ABORT(env, ret == 0);
00258 }
00259
00260 void
00261 handle_exception(JNIEnv* env, const std::bad_alloc&) {
00262 jclass newExcCls
00263 = env->FindClass("java/lang/RuntimeException");
00264 CHECK_RESULT_ASSERT(env, newExcCls);
00265 jint ret = env->ThrowNew(newExcCls, "Out of memory");
00266 CHECK_RESULT_ABORT(env, ret == 0);
00267 }
00268
00269 void
00270 handle_exception(JNIEnv* env, const std::exception& e) {
00271 jclass newExcCls = env->FindClass("java/lang/RuntimeException");
00272 CHECK_RESULT_ASSERT(env, newExcCls);
00273 jint ret = env->ThrowNew(newExcCls, e.what());
00274 CHECK_RESULT_ABORT(env, ret == 0);
00275 }
00276
00277 void
00278 handle_exception(JNIEnv* env, const timeout_exception&) {
00279 reset_timeout();
00280 jclass newExcCls
00281 = env->FindClass("parma_polyhedra_library/Timeout_Exception");
00282 CHECK_RESULT_ASSERT(env, newExcCls);
00283 jint ret = env->ThrowNew(newExcCls, "PPL timeout expired");
00284 CHECK_RESULT_ABORT(env, (ret == 0));
00285 }
00286
00287 void
00288 handle_exception(JNIEnv* env, const deterministic_timeout_exception&) {
00289 reset_deterministic_timeout();
00290 jclass newExcCls
00291 = env->FindClass("parma_polyhedra_library/Timeout_Exception");
00292 CHECK_RESULT_ASSERT(env, newExcCls);
00293 jint ret = env->ThrowNew(newExcCls, "PPL deterministic timeout expired");
00294 CHECK_RESULT_ABORT(env, (ret == 0));
00295 }
00296
00297 void
00298 handle_exception(JNIEnv* env) {
00299 jclass newExcCls = env->FindClass("java/lang/RuntimeException");
00300 CHECK_RESULT_ASSERT(env, newExcCls);
00301 jint ret = env->ThrowNew(newExcCls, "PPL bug: unknown exception raised");
00302 CHECK_RESULT_ABORT(env, ret == 0);
00303 }
00304
00305 #ifdef PPL_WATCHDOG_LIBRARY_ENABLED
00306
00307 Parma_Watchdog_Library::Watchdog* p_timeout_object = 0;
00308
00309 Weightwatch* p_deterministic_timeout_object = 0;
00310
00311 #endif // PPL_WATCHDOG_LIBRARY_ENABLED
00312
00313 void
00314 reset_timeout() {
00315 #ifdef PPL_WATCHDOG_LIBRARY_ENABLED
00316 if (p_timeout_object) {
00317 delete p_timeout_object;
00318 p_timeout_object = 0;
00319 abandon_expensive_computations = 0;
00320 }
00321 #endif // PPL_WATCHDOG_LIBRARY_ENABLED
00322 }
00323
00324 void
00325 reset_deterministic_timeout() {
00326 #ifdef PPL_WATCHDOG_LIBRARY_ENABLED
00327 if (p_deterministic_timeout_object) {
00328 delete p_deterministic_timeout_object;
00329 p_deterministic_timeout_object = 0;
00330 abandon_expensive_computations = 0;
00331 }
00332 #endif // PPL_WATCHDOG_LIBRARY_ENABLED
00333 }
00334
00335 jobject
00336 build_java_poly_gen_relation(JNIEnv* env, Poly_Gen_Relation& r) {
00337 jint j_value = 0;
00338 while (r != Poly_Gen_Relation::nothing()) {
00339 if (r.implies(Poly_Gen_Relation::subsumes())) {
00340 j_value += 1;
00341 r = r - Poly_Gen_Relation::subsumes();
00342 }
00343 }
00344 jobject ret = env->NewObject(cached_classes.Poly_Gen_Relation,
00345 cached_FMIDs.Poly_Gen_Relation_init_ID,
00346 j_value);
00347 CHECK_RESULT_THROW(env, ret);
00348 return ret;
00349 }
00350
00351 jobject
00352 build_java_poly_con_relation(JNIEnv* env, Poly_Con_Relation& r) {
00353 jint j_value = 0;
00354 while (r != Poly_Con_Relation::nothing()) {
00355 if (r.implies(Poly_Con_Relation::is_disjoint())) {
00356 j_value += 1;
00357 r = r - Poly_Con_Relation::is_disjoint();
00358 }
00359 else if (r.implies(Poly_Con_Relation::strictly_intersects())) {
00360 j_value += 2;
00361 r = r - Poly_Con_Relation::strictly_intersects();
00362 }
00363 else if (r.implies(Poly_Con_Relation::is_included())) {
00364 j_value += 4;
00365 r = r - Poly_Con_Relation::is_included();
00366 }
00367 else if (r.implies(Poly_Con_Relation::saturates())) {
00368 j_value += 8;
00369 r = r - Poly_Con_Relation::saturates();
00370 }
00371 }
00372 jobject ret = env->NewObject(cached_classes.Poly_Con_Relation,
00373 cached_FMIDs.Poly_Con_Relation_init_ID,
00374 j_value);
00375 CHECK_RESULT_THROW(env, ret);
00376 return ret;
00377 }
00378
00379
00380 Congruence
00381 build_cxx_congruence(JNIEnv* env, jobject j_congruence) {
00382 jobject j_mod
00383 = env->GetObjectField(j_congruence, cached_FMIDs.Congruence_mod_ID);
00384 jobject j_lhs
00385 = env->GetObjectField(j_congruence, cached_FMIDs.Congruence_lhs_ID);
00386 jobject j_rhs
00387 = env->GetObjectField(j_congruence, cached_FMIDs.Congruence_rhs_ID);
00388 PPL_DIRTY_TEMP_COEFFICIENT(ppl_modulus);
00389 ppl_modulus = build_cxx_coeff(env, j_mod);
00390 Linear_Expression lhs = build_cxx_linear_expression(env, j_lhs);
00391 Linear_Expression rhs = build_cxx_linear_expression(env, j_rhs);
00392 return (lhs %= rhs) / ppl_modulus;
00393 }
00394
00395 PIP_Tree_Node::Artificial_Parameter
00396 build_cxx_artificial_parameter(JNIEnv* env, jobject j_artificial_parameter) {
00397 jobject j_le
00398 = env->GetObjectField(j_artificial_parameter,
00399 cached_FMIDs.Artificial_Parameter_le_ID);
00400 jobject j_den
00401 = env->GetObjectField(j_artificial_parameter,
00402 cached_FMIDs.Artificial_Parameter_den_ID);
00403 PPL_DIRTY_TEMP_COEFFICIENT(ppl_den);
00404 ppl_den = build_cxx_coeff(env, j_den);
00405 Linear_Expression le = build_cxx_linear_expression(env, j_le);
00406 PIP_Tree_Node::Artificial_Parameter art_param(le, ppl_den);
00407 return art_param;
00408 }
00409
00410 jobject
00411 bool_to_j_boolean_class(JNIEnv* env, const bool value) {
00412 jobject ret = env->CallStaticObjectMethod(cached_classes.Boolean,
00413 cached_FMIDs.Boolean_valueOf_ID,
00414 value);
00415 CHECK_EXCEPTION_ASSERT(env);
00416 return ret;
00417 }
00418
00419 jobject
00420 j_long_to_j_long_class(JNIEnv* env, jlong jlong_value) {
00421 jobject ret = env->CallStaticObjectMethod(cached_classes.Long,
00422 cached_FMIDs.Long_valueOf_ID,
00423 jlong_value);
00424 CHECK_EXCEPTION_THROW(env);
00425 return ret;
00426 }
00427
00428 jlong
00429 j_long_class_to_j_long(JNIEnv* env, jobject j_long) {
00430 jlong ret = env->CallLongMethod(j_long, cached_FMIDs.Long_longValue_ID);
00431 CHECK_EXCEPTION_ASSERT(env);
00432 return ret;
00433 }
00434
00435 jobject
00436 j_int_to_j_integer(JNIEnv* env, jint jint_value) {
00437 jobject ret = env->CallStaticObjectMethod(cached_classes.Integer,
00438 cached_FMIDs.Integer_valueOf_ID,
00439 jint_value);
00440 CHECK_EXCEPTION_THROW(env);
00441 return ret;
00442 }
00443
00444 jint
00445 j_integer_to_j_int(JNIEnv* env, jobject j_integer) {
00446 jint ret = env->CallIntMethod(j_integer, cached_FMIDs.Integer_intValue_ID);
00447 CHECK_EXCEPTION_ASSERT(env);
00448 return ret;
00449 }
00450
00451 Variables_Set
00452 build_cxx_variables_set(JNIEnv* env, jobject j_v_set) {
00453
00454 jobject j_iter
00455 = env->CallObjectMethod(j_v_set, cached_FMIDs.Variables_Set_iterator_ID);
00456 CHECK_EXCEPTION_THROW(env);
00457
00458 jmethodID has_next_ID = cached_FMIDs.Variables_Set_Iterator_has_next_ID;
00459 jmethodID next_ID = cached_FMIDs.Variables_Set_Iterator_next_ID;
00460
00461 Variables_Set v_set;
00462 jobject j_variable;
00463 jboolean has_next_value = env->CallBooleanMethod(j_iter, has_next_ID);
00464 while (has_next_value) {
00465 j_variable = env->CallObjectMethod(j_iter, next_ID);
00466 CHECK_EXCEPTION_ASSERT(env);
00467 v_set.insert(build_cxx_variable(env, j_variable));
00468 has_next_value = env->CallBooleanMethod(j_iter, has_next_ID);
00469 CHECK_EXCEPTION_ASSERT(env);
00470 }
00471 return v_set;
00472 }
00473
00474 jobject
00475 build_java_variables_set(JNIEnv* env, const Variables_Set& v_set) {
00476 jobject j_vs = env->NewObject(cached_classes.Variables_Set,
00477 cached_FMIDs.Variables_Set_init_ID);
00478 CHECK_RESULT_THROW(env, j_vs);
00479 for (Variables_Set::const_iterator v_begin = v_set.begin(),
00480 v_end = v_set.end(); v_begin != v_end; ++v_begin) {
00481 Variable var(*v_begin);
00482 jobject j_variable = build_java_variable(env, var);
00483 env->CallBooleanMethod(j_vs,
00484 cached_FMIDs.Variables_Set_add_ID,
00485 j_variable);
00486 CHECK_EXCEPTION_THROW(env);
00487 }
00488 return j_vs;
00489 }
00490
00491 Bounded_Integer_Type_Overflow
00492 build_cxx_bounded_overflow(JNIEnv* env, jobject j_bounded_overflow) {
00493 jint bounded_overflow
00494 = env->CallIntMethod(j_bounded_overflow, cached_FMIDs.Bounded_Integer_Type_Overflow_ordinal_ID);
00495 CHECK_EXCEPTION_ASSERT(env);
00496 switch (bounded_overflow) {
00497 case 0:
00498 return OVERFLOW_WRAPS;
00499 case 1:
00500 return OVERFLOW_UNDEFINED;
00501 case 2:
00502 return OVERFLOW_IMPOSSIBLE;
00503 default:
00504 assert(false);
00505 throw std::runtime_error("PPL Java interface internal error");
00506 }
00507 }
00508
00509 Bounded_Integer_Type_Representation
00510 build_cxx_bounded_rep(JNIEnv* env, jobject j_bounded_rep) {
00511 jint bounded_rep
00512 = env->CallIntMethod(j_bounded_rep, cached_FMIDs.Bounded_Integer_Type_Representation_ordinal_ID);
00513 CHECK_EXCEPTION_ASSERT(env);
00514 switch (bounded_rep) {
00515 case 0:
00516 return UNSIGNED;
00517 case 1:
00518 return SIGNED_2_COMPLEMENT;
00519 default:
00520 assert(false);
00521 throw std::runtime_error("PPL Java interface internal error");
00522 }
00523 }
00524
00525 Bounded_Integer_Type_Width
00526 build_cxx_bounded_width(JNIEnv* env, jobject j_bounded_width) {
00527 jint bounded_width
00528 = env->CallIntMethod(j_bounded_width, cached_FMIDs.Bounded_Integer_Type_Width_ordinal_ID);
00529 CHECK_EXCEPTION_ASSERT(env);
00530 switch (bounded_width) {
00531 case 0:
00532 return BITS_8;
00533 case 1:
00534 return BITS_16;
00535 case 2:
00536 return BITS_32;
00537 case 3:
00538 return BITS_64;
00539 case 4:
00540 return BITS_128;
00541 default:
00542 assert(false);
00543 throw std::runtime_error("PPL Java interface internal error");
00544 }
00545 }
00546
00547 Relation_Symbol
00548 build_cxx_relsym(JNIEnv* env, jobject j_relsym) {
00549 jint rel_sym
00550 = env->CallIntMethod(j_relsym, cached_FMIDs.Relation_Symbol_ordinal_ID);
00551 CHECK_EXCEPTION_ASSERT(env);
00552 switch (rel_sym) {
00553 case 0:
00554 return LESS_THAN;
00555 case 1:
00556 return LESS_OR_EQUAL;
00557 case 2:
00558 return EQUAL;
00559 case 3:
00560 return GREATER_OR_EQUAL;
00561 case 4:
00562 return GREATER_THAN;
00563 default:
00564 assert(false);
00565 throw std::runtime_error("PPL Java interface internal error");
00566 }
00567 }
00568
00569 Optimization_Mode
00570 build_cxx_optimization_mode(JNIEnv* env, jobject j_opt_mode) {
00571 jint opt_mode
00572 = env->CallIntMethod(j_opt_mode, cached_FMIDs.Optimization_Mode_ordinal_ID);
00573 CHECK_EXCEPTION_ASSERT(env);
00574 switch (opt_mode) {
00575 case 0:
00576 return MINIMIZATION;
00577 case 1:
00578 return MAXIMIZATION;
00579 default:
00580 assert(false);
00581 throw std::runtime_error("PPL Java interface internal error");
00582 }
00583 }
00584
00585 jobject
00586 build_java_mip_status(JNIEnv* env, const MIP_Problem_Status& mip_status) {
00587 jfieldID fID;
00588 switch (mip_status) {
00589 case UNFEASIBLE_MIP_PROBLEM:
00590 fID = cached_FMIDs.MIP_Problem_Status_UNFEASIBLE_MIP_PROBLEM_ID;
00591 break;
00592 case UNBOUNDED_MIP_PROBLEM:
00593 fID = cached_FMIDs.MIP_Problem_Status_UNBOUNDED_MIP_PROBLEM_ID;
00594 break;
00595 case OPTIMIZED_MIP_PROBLEM:
00596 fID = cached_FMIDs.MIP_Problem_Status_OPTIMIZED_MIP_PROBLEM_ID;
00597 break;
00598 default:
00599 assert(false);
00600 throw std::runtime_error("PPL Java interface internal error");
00601 }
00602 return env->GetStaticObjectField(cached_classes.MIP_Problem_Status, fID);
00603 }
00604
00605 jobject
00606 build_java_pip_status(JNIEnv* env, const PIP_Problem_Status& pip_status) {
00607 jfieldID fID;
00608 switch (pip_status) {
00609 case UNFEASIBLE_PIP_PROBLEM:
00610 fID = cached_FMIDs.PIP_Problem_Status_UNFEASIBLE_PIP_PROBLEM_ID;
00611 break;
00612 case OPTIMIZED_PIP_PROBLEM:
00613 fID = cached_FMIDs.PIP_Problem_Status_OPTIMIZED_PIP_PROBLEM_ID;
00614 break;
00615 default:
00616 assert(false);
00617 throw std::runtime_error("PPL Java interface internal error");
00618 }
00619 return env->GetStaticObjectField(cached_classes.PIP_Problem_Status, fID);
00620 }
00621
00622 jobject
00623 build_java_optimization_mode(JNIEnv* env, const Optimization_Mode& opt_mode) {
00624 jfieldID fID;
00625 switch (opt_mode) {
00626 case MINIMIZATION:
00627 fID = cached_FMIDs.Optimization_Mode_MINIMIZATION_ID;
00628 break;
00629 case MAXIMIZATION:
00630 fID = cached_FMIDs.Optimization_Mode_MAXIMIZATION_ID;
00631 break;
00632 default:
00633 assert(false);
00634 throw std::runtime_error("PPL Java interface internal error");
00635 }
00636 return env->GetStaticObjectField(cached_classes.Optimization_Mode, fID);
00637 }
00638
00639 MIP_Problem::Control_Parameter_Name
00640 build_cxx_control_parameter_name(JNIEnv* env, jobject j_cp_name) {
00641 jclass cp_name_class = env->GetObjectClass(j_cp_name);
00642 CHECK_RESULT_ASSERT(env, cp_name_class);
00643 jmethodID cp_name_ordinal_id
00644 = env->GetMethodID(cp_name_class, "ordinal", "()I");
00645 CHECK_RESULT_ASSERT(env, cp_name_ordinal_id);
00646 jint cp_name = env->CallIntMethod(j_cp_name, cp_name_ordinal_id);
00647 CHECK_EXCEPTION_ASSERT(env);
00648 switch (cp_name) {
00649 case 0:
00650 return MIP_Problem::PRICING;
00651 default:
00652 assert(false);
00653 throw std::runtime_error("PPL Java interface internal error");
00654 }
00655 }
00656
00657 jobject
00658 build_java_control_parameter_name
00659 (JNIEnv* env,const MIP_Problem::Control_Parameter_Name& cp_name) {
00660 jclass j_cp_name_class
00661 = env->FindClass("parma_polyhedra_library/Control_Parameter_Name");
00662 CHECK_RESULT_ASSERT(env, j_cp_name_class);
00663 jfieldID cp_name_pricing_get_id
00664 = env->GetStaticFieldID(j_cp_name_class, "PRICING",
00665 "Lparma_polyhedra_library/Control_Parameter_Name;");
00666 CHECK_RESULT_ASSERT(env, cp_name_pricing_get_id);
00667 switch (cp_name) {
00668 case MIP_Problem::PRICING:
00669 return env->GetStaticObjectField(j_cp_name_class,
00670 cp_name_pricing_get_id);
00671 default:
00672 assert(false);
00673 throw std::runtime_error("PPL Java interface internal error");
00674 }
00675 }
00676
00677 MIP_Problem::Control_Parameter_Value
00678 build_cxx_control_parameter_value(JNIEnv* env, jobject j_cp_value) {
00679 jclass cp_value_class = env->GetObjectClass(j_cp_value);
00680 CHECK_RESULT_ASSERT(env, cp_value_class);
00681 jmethodID cp_value_ordinal_id
00682 = env->GetMethodID(cp_value_class, "ordinal", "()I");
00683 CHECK_RESULT_ASSERT(env, cp_value_ordinal_id);
00684 jint cp_value = env->CallIntMethod(j_cp_value, cp_value_ordinal_id);
00685 CHECK_EXCEPTION_ASSERT(env);
00686 switch (cp_value) {
00687 case 0:
00688 return MIP_Problem::PRICING_STEEPEST_EDGE_FLOAT;
00689 case 1:
00690 return MIP_Problem::PRICING_STEEPEST_EDGE_EXACT;
00691 case 2:
00692 return MIP_Problem::PRICING_TEXTBOOK;
00693 default:
00694 assert(false);
00695 throw std::runtime_error("PPL Java interface internal error");
00696 }
00697 }
00698
00699 jobject
00700 build_java_control_parameter_value
00701 (JNIEnv* env, const MIP_Problem::Control_Parameter_Value& cp_value) {
00702 jclass j_cp_value_class
00703 = env->FindClass("parma_polyhedra_library/Control_Parameter_Value");
00704 CHECK_RESULT_ASSERT(env, j_cp_value_class);
00705 const char* field_name;
00706 switch (cp_value) {
00707 case MIP_Problem::PRICING_STEEPEST_EDGE_FLOAT:
00708 field_name = "PRICING_STEEPEST_EDGE_FLOAT";
00709 break;
00710 case MIP_Problem::PRICING_STEEPEST_EDGE_EXACT:
00711 field_name = "PRICING_STEEPEST_EDGE_EXACT";
00712 break;
00713 case MIP_Problem::PRICING_TEXTBOOK:
00714 field_name = "PRICING_TEXTBOOK";
00715 break;
00716 default:
00717 assert(false);
00718 throw std::runtime_error("PPL Java interface internal error");
00719 }
00720 jfieldID fID = env->GetStaticFieldID(j_cp_value_class, field_name,
00721 "Lparma_polyhedra_library/Control_Parameter_Value;");
00722 CHECK_RESULT_ASSERT(env, fID);
00723 return env->GetStaticObjectField(j_cp_value_class, fID);
00724 }
00725
00726 PIP_Problem::Control_Parameter_Name
00727 build_cxx_pip_problem_control_parameter_name(JNIEnv* env, jobject j_cp_name) {
00728 jclass cp_name_class = env->GetObjectClass(j_cp_name);
00729 CHECK_RESULT_ASSERT(env, cp_name_class);
00730 jmethodID cp_name_ordinal_id
00731 = env->GetMethodID(cp_name_class, "ordinal", "()I");
00732 CHECK_RESULT_ASSERT(env, cp_name_ordinal_id);
00733 jint cp_name = env->CallIntMethod(j_cp_name, cp_name_ordinal_id);
00734 CHECK_EXCEPTION_ASSERT(env);
00735 switch (cp_name) {
00736 case 0:
00737 return PIP_Problem::CUTTING_STRATEGY;
00738 case 1:
00739 return PIP_Problem::PIVOT_ROW_STRATEGY;
00740 default:
00741 assert(false);
00742 throw std::runtime_error("PPL Java interface internal error");
00743 }
00744 }
00745
00746 jobject
00747 build_pip_problem_java_control_parameter_name
00748 (JNIEnv* env, const PIP_Problem::Control_Parameter_Name& cp_name) {
00749 jclass j_cp_name_class
00750 = env->FindClass("parma_polyhedra_library/PIP_Problem_Control_Parameter_Name");
00751 CHECK_RESULT_ASSERT(env, j_cp_name_class);
00752 jfieldID cp_name_cutting_strategy_get_id
00753 = env->GetStaticFieldID(j_cp_name_class, "CUTTING_STRATEGY",
00754 "Lparma_polyhedra_library/PIP_Problem_Control_Parameter_Name;");
00755 CHECK_RESULT_ASSERT(env, cp_name_cutting_strategy_get_id);
00756 jfieldID cp_name_pivot_row_strategy_get_id
00757 = env->GetStaticFieldID(j_cp_name_class, "PIVOT_ROW_STRATEGY",
00758 "Lparma_polyhedra_library/PIP_Problem_Control_Parameter_Name;");
00759 CHECK_RESULT_ASSERT(env, cp_name_pivot_row_strategy_get_id);
00760 switch (cp_name) {
00761 case PIP_Problem::CUTTING_STRATEGY:
00762 return env->GetStaticObjectField(j_cp_name_class,
00763 cp_name_cutting_strategy_get_id);
00764 case PIP_Problem::PIVOT_ROW_STRATEGY:
00765 return env->GetStaticObjectField(j_cp_name_class,
00766 cp_name_pivot_row_strategy_get_id);
00767 default:
00768 assert(false);
00769 throw std::runtime_error("PPL Java interface internal error");
00770 }
00771 }
00772
00773 PIP_Problem::Control_Parameter_Value
00774 build_cxx_pip_problem_control_parameter_value(JNIEnv* env, jobject j_cp_value) {
00775 jclass cp_value_class = env->GetObjectClass(j_cp_value);
00776 CHECK_RESULT_ASSERT(env, cp_value_class);
00777 jmethodID cp_value_ordinal_id
00778 = env->GetMethodID(cp_value_class, "ordinal", "()I");
00779 CHECK_RESULT_ASSERT(env, cp_value_ordinal_id);
00780 jint cp_value = env->CallIntMethod(j_cp_value, cp_value_ordinal_id);
00781 CHECK_EXCEPTION_ASSERT(env);
00782 switch (cp_value) {
00783 case 0:
00784 return PIP_Problem::CUTTING_STRATEGY_FIRST;
00785 case 1:
00786 return PIP_Problem::CUTTING_STRATEGY_DEEPEST;
00787 case 2:
00788 return PIP_Problem::CUTTING_STRATEGY_ALL;
00789 case 3:
00790 return PIP_Problem::PIVOT_ROW_STRATEGY_FIRST;
00791 case 4:
00792 return PIP_Problem::PIVOT_ROW_STRATEGY_MAX_COLUMN;
00793 default:
00794 assert(false);
00795 throw std::runtime_error("PPL Java interface internal error");
00796 }
00797 }
00798
00799 jobject
00800 build_java_pip_problem_control_parameter_value
00801 (JNIEnv* env, const PIP_Problem::Control_Parameter_Value& cp_value) {
00802 jclass j_cp_value_class
00803 = env->FindClass("parma_polyhedra_library/PIP_Problem_Control_Parameter_Value");
00804 CHECK_RESULT_ASSERT(env, j_cp_value_class);
00805 const char* field_name;
00806 switch (cp_value) {
00807 case PIP_Problem::CUTTING_STRATEGY_FIRST:
00808 field_name = "CUTTING_STRATEGY_FIRST";
00809 break;
00810 case PIP_Problem::CUTTING_STRATEGY_DEEPEST:
00811 field_name = "CUTTING_STRATEGY_DEEPEST";
00812 break;
00813 case PIP_Problem::CUTTING_STRATEGY_ALL:
00814 field_name = "CUTTING_STRATEGY_ALL";
00815 break;
00816 case PIP_Problem::PIVOT_ROW_STRATEGY_FIRST:
00817 field_name = "PIVOT_ROW_STRATEGY_FIRST";
00818 break;
00819 case PIP_Problem::PIVOT_ROW_STRATEGY_MAX_COLUMN:
00820 field_name = "PIVOT_ROW_STRATEGY_MAX_COLUMN";
00821 break;
00822 default:
00823 assert(false);
00824 throw std::runtime_error("PPL Java interface internal error");
00825 }
00826 jfieldID fID = env->GetStaticFieldID(j_cp_value_class, field_name,
00827 "Lparma_polyhedra_library/PIP_Problem_Control_Parameter_Value;");
00828 CHECK_RESULT_ASSERT(env, fID);
00829 return env->GetStaticObjectField(j_cp_value_class, fID);
00830 }
00831
00832 Constraint
00833 build_cxx_constraint(JNIEnv* env, jobject j_constraint) {
00834 jobject lhs_value
00835 = env->GetObjectField(j_constraint, cached_FMIDs.Constraint_lhs_ID);
00836 jobject rhs_value
00837 = env->GetObjectField(j_constraint, cached_FMIDs.Constraint_rhs_ID);
00838 jobject kind
00839 = env->GetObjectField(j_constraint, cached_FMIDs.Constraint_kind_ID);
00840 Linear_Expression first_le = build_cxx_linear_expression(env, lhs_value);
00841 Linear_Expression second_le = build_cxx_linear_expression(env, rhs_value);
00842 jint rel_sym
00843 = env->CallIntMethod(kind, cached_FMIDs.Relation_Symbol_ordinal_ID);
00844 CHECK_EXCEPTION_ASSERT(env);
00845 switch (rel_sym) {
00846 case 0:
00847 return Constraint(first_le < second_le);
00848 case 1:
00849 return Constraint(first_le <= second_le);
00850 case 2:
00851 return Constraint(first_le == second_le);
00852 case 3:
00853 return Constraint(first_le >= second_le);
00854 case 4:
00855 return Constraint(first_le > second_le);
00856 default:
00857 assert(false);
00858 throw std::runtime_error("PPL Java interface internal error");
00859 }
00860 }
00861
00862 Linear_Expression
00863 build_cxx_linear_expression(JNIEnv* env, jobject j_le) {
00864 jfieldID fID;
00865 jclass current_class = env->GetObjectClass(j_le);
00866
00867 if (env->IsAssignableFrom(current_class,
00868 cached_classes.Linear_Expression_Variable)) {
00869 jmethodID mID = cached_FMIDs.Linear_Expression_Variable_var_id_ID;
00870 jint var_id = env->CallIntMethod(j_le, mID);
00871 return Linear_Expression(Variable(var_id));
00872 }
00873
00874 if (env->IsAssignableFrom(current_class,
00875 cached_classes.Linear_Expression_Coefficient)) {
00876 fID = cached_FMIDs.Linear_Expression_Coefficient_coeff_ID;
00877 jobject ppl_coeff = env->GetObjectField(j_le, fID);
00878 return Linear_Expression(build_cxx_coeff(env, ppl_coeff));
00879 }
00880
00881 if (env->IsAssignableFrom(current_class,
00882 cached_classes.Linear_Expression_Sum)) {
00883 fID = cached_FMIDs.Linear_Expression_Sum_lhs_ID;
00884 jobject l_value = env->GetObjectField(j_le, fID);
00885 fID = cached_FMIDs.Linear_Expression_Sum_rhs_ID;
00886 jobject r_value = env->GetObjectField(j_le, fID);
00887 return build_cxx_linear_expression(env, l_value)
00888 + build_cxx_linear_expression(env, r_value);
00889 }
00890
00891 if (env->IsAssignableFrom(current_class,
00892 cached_classes.Linear_Expression_Times)) {
00893 fID = cached_FMIDs.Linear_Expression_Times_coeff_ID;
00894 jobject coeff_value = env->GetObjectField(j_le, fID);
00895 fID = cached_FMIDs.Linear_Expression_Times_lin_expr_ID;
00896 jobject le_value = env->GetObjectField(j_le, fID);
00897 return build_cxx_coeff(env, coeff_value)
00898 * build_cxx_linear_expression(env, le_value);
00899 }
00900
00901 if (env->IsAssignableFrom(current_class,
00902 cached_classes.Linear_Expression_Difference)) {
00903 fID = cached_FMIDs.Linear_Expression_Difference_lhs_ID;
00904 jobject l_value = env->GetObjectField(j_le,fID);
00905 fID = cached_FMIDs.Linear_Expression_Difference_rhs_ID;
00906 jobject r_value = env->GetObjectField(j_le, fID);
00907 return build_cxx_linear_expression(env, l_value)
00908 - build_cxx_linear_expression(env, r_value);
00909 }
00910
00911 if (env->IsAssignableFrom(current_class,
00912 cached_classes.Linear_Expression_Unary_Minus)) {
00913 fID = cached_FMIDs.Linear_Expression_Unary_Minus_arg_ID;
00914 jobject le_value = env->GetObjectField(j_le, fID);
00915 return -build_cxx_linear_expression(env, le_value);
00916 }
00917 assert(false);
00918 throw std::runtime_error("PPL Java interface internal error");
00919 }
00920
00921 Generator
00922 build_cxx_generator(JNIEnv* env, jobject j_generator) {
00923 jobject j_le
00924 = env->GetObjectField(j_generator, cached_FMIDs.Generator_le_ID);
00925 jobject generator_type
00926 = env->GetObjectField(j_generator, cached_FMIDs.Generator_gt_ID);
00927 jint generator_type_ordinal
00928 = env->CallIntMethod(generator_type,
00929 cached_FMIDs.Generator_Type_ordinal_ID);
00930 CHECK_EXCEPTION_ASSERT(env);
00931 switch (generator_type_ordinal) {
00932 case 0:
00933 return line(build_cxx_linear_expression(env, j_le));
00934 case 1:
00935 return ray(build_cxx_linear_expression(env, j_le));
00936 case 2:
00937 {
00938 jobject j_div
00939 = env->GetObjectField(j_generator, cached_FMIDs.Generator_div_ID);
00940 return point(build_cxx_linear_expression(env, j_le),
00941 build_cxx_coeff(env, j_div));
00942 }
00943 case 3:
00944 {
00945 jobject j_div
00946 = env->GetObjectField(j_generator, cached_FMIDs.Generator_div_ID);
00947 return closure_point(build_cxx_linear_expression(env, j_le),
00948 build_cxx_coeff(env, j_div));
00949 }
00950 default:
00951 assert(false);
00952 throw std::runtime_error("PPL Java interface internal error");
00953 }
00954 }
00955
00956 Grid_Generator
00957 build_cxx_grid_generator(JNIEnv* env, jobject j_grid_generator) {
00958 jobject j_le
00959 = env->GetObjectField(j_grid_generator, cached_FMIDs.Grid_Generator_le_ID);
00960 jobject grid_generator_type
00961 = env->GetObjectField(j_grid_generator, cached_FMIDs.Grid_Generator_gt_ID);
00962 jint grid_generator_type_ordinal
00963 = env->CallIntMethod(grid_generator_type,
00964 cached_FMIDs.Grid_Generator_Type_ordinal_ID);
00965 CHECK_EXCEPTION_ASSERT(env);
00966 switch (grid_generator_type_ordinal) {
00967 case 0:
00968 return grid_line(build_cxx_linear_expression(env, j_le));
00969 case 1:
00970 {
00971 jobject j_div = env->GetObjectField(j_grid_generator,
00972 cached_FMIDs.Grid_Generator_div_ID);
00973 return parameter(build_cxx_linear_expression(env, j_le),
00974 build_cxx_coeff(env, j_div));
00975 }
00976 case 2:
00977 {
00978 jobject j_div = env->GetObjectField(j_grid_generator,
00979 cached_FMIDs.Grid_Generator_div_ID);
00980 return grid_point(build_cxx_linear_expression(env, j_le),
00981 build_cxx_coeff(env, j_div));
00982 }
00983 default:
00984 assert(false);
00985 throw std::runtime_error("PPL Java interface internal error");
00986 }
00987 }
00988
00989 jobject
00990 build_java_linear_expression_coefficient(JNIEnv* env, const Coefficient& c) {
00991 jobject j_coeff = build_java_coeff(env, c);
00992 jobject ret
00993 = env->NewObject(cached_classes.Linear_Expression_Coefficient,
00994 cached_FMIDs.Linear_Expression_Coefficient_init_ID,
00995 j_coeff);
00996 CHECK_RESULT_THROW(env, ret);
00997 return ret;
00998 }
00999
01000 void
01001 set_generator(JNIEnv* env, jobject dst, jobject src) {
01002 jobject src_gt = env->GetObjectField(src, cached_FMIDs.Generator_gt_ID);
01003 env->SetObjectField(dst, cached_FMIDs.Generator_gt_ID, src_gt);
01004 jobject src_le = env->GetObjectField(src, cached_FMIDs.Generator_le_ID);
01005 env->SetObjectField(dst, cached_FMIDs.Generator_le_ID, src_le);
01006 jobject src_div = env->GetObjectField(src, cached_FMIDs.Generator_div_ID);
01007 env->SetObjectField(dst, cached_FMIDs.Generator_div_ID, src_div);
01008 }
01009
01010 void
01011 set_pair_element(JNIEnv* env, jobject dst_pair, int arg, jobject src) {
01012 switch (arg) {
01013 case 0:
01014 env->SetObjectField(dst_pair, cached_FMIDs.Pair_first_ID, src);
01015 break;
01016 case 1:
01017 env->SetObjectField(dst_pair, cached_FMIDs.Pair_second_ID, src);
01018 break;
01019 default:
01020 assert(false);
01021 throw std::runtime_error("PPL Java interface internal error: "
01022 "pair value not allowed");
01023 }
01024 }
01025
01026 jobject
01027 get_pair_element(JNIEnv* env, int arg, jobject j_pair) {
01028 switch (arg) {
01029 case 0:
01030 return env->GetObjectField(j_pair, cached_FMIDs.Pair_first_ID);
01031 case 1:
01032 return env->GetObjectField(j_pair, cached_FMIDs.Pair_second_ID);
01033 default:
01034 assert(false);
01035 throw std::runtime_error("PPL Java interface internal error: "
01036 "pair value not allowed");
01037 }
01038 }
01039
01040 jobject
01041 build_java_constraint(JNIEnv* env, const Constraint& c) {
01042 jobject lhs = build_linear_expression(env, c);
01043 jobject rhs
01044 = build_java_linear_expression_coefficient(env, -c.inhomogeneous_term());
01045 jfieldID fID;
01046 switch (c.type()) {
01047 case Constraint::EQUALITY:
01048 fID = cached_FMIDs.Relation_Symbol_EQUAL_ID;
01049 break;
01050 case Constraint::NONSTRICT_INEQUALITY:
01051 fID = cached_FMIDs.Relation_Symbol_GREATER_OR_EQUAL_ID;
01052 break;
01053 case Constraint::STRICT_INEQUALITY:
01054 fID = cached_FMIDs.Relation_Symbol_GREATER_THAN_ID;
01055 break;
01056 default:
01057 assert(false);
01058 throw std::runtime_error("PPL Java interface internal error");
01059 }
01060 jobject relation
01061 = env->GetStaticObjectField(cached_classes.Relation_Symbol, fID);
01062 jobject ret = env->NewObject(cached_classes.Constraint,
01063 cached_FMIDs.Constraint_init_ID,
01064 lhs, relation, rhs);
01065 CHECK_RESULT_THROW(env, ret);
01066 return ret;
01067 }
01068
01069 jobject
01070 build_java_congruence(JNIEnv* env, const Congruence& cg) {
01071 jobject j_mod = build_java_coeff(env, cg.modulus());
01072 jobject j_lhs = build_linear_expression(env, cg);
01073 jobject j_rhs
01074 = build_java_linear_expression_coefficient(env, -cg.inhomogeneous_term());
01075 jobject ret = env->NewObject(cached_classes.Congruence,
01076 cached_FMIDs.Congruence_init_ID,
01077 j_lhs, j_rhs, j_mod);
01078 CHECK_RESULT_THROW(env, ret);
01079 return ret;
01080 }
01081
01082 jobject
01083 build_java_generator(JNIEnv* env, const Generator& g) {
01084 jobject j_g_le = build_linear_expression(env, g);
01085 jobject ret;
01086 switch (g.type()) {
01087 case Generator::LINE:
01088 ret = env->CallStaticObjectMethod(cached_classes.Generator,
01089 cached_FMIDs.Generator_line_ID,
01090 j_g_le);
01091 break;
01092 case Generator::RAY:
01093 ret = env->CallStaticObjectMethod(cached_classes.Generator,
01094 cached_FMIDs.Generator_ray_ID,
01095 j_g_le);
01096 break;
01097 case Generator::POINT:
01098 {
01099 const Coefficient& divisor = g.divisor();
01100 jobject j_div = build_java_coeff(env, divisor);
01101 ret = env->CallStaticObjectMethod(cached_classes.Generator,
01102 cached_FMIDs.Generator_point_ID,
01103 j_g_le, j_div);
01104 break;
01105 }
01106 case Generator::CLOSURE_POINT:
01107 {
01108 const Coefficient& divisor = g.divisor();
01109 jobject j_div = build_java_coeff(env, divisor);
01110 ret = env->CallStaticObjectMethod(cached_classes.Generator,
01111 cached_FMIDs.Generator_closure_point_ID,
01112 j_g_le, j_div);
01113 break;
01114 }
01115 default:
01116 assert(false);
01117 throw std::runtime_error("PPL Java interface internal error");
01118 }
01119 CHECK_EXCEPTION_THROW(env);
01120 return ret;
01121 }
01122
01123 jobject
01124 build_java_grid_generator(JNIEnv* env, const Grid_Generator& g) {
01125 jobject j_g_le = build_linear_expression(env, g);
01126 jobject ret;
01127 switch (g.type()) {
01128 case Grid_Generator::LINE:
01129 ret = env->CallStaticObjectMethod(cached_classes.Grid_Generator,
01130 cached_FMIDs.Grid_Generator_grid_line_ID,
01131 j_g_le);
01132 break;
01133 case Grid_Generator::PARAMETER:
01134 {
01135 const Coefficient& divisor = g.divisor();
01136 jobject j_div = build_java_coeff(env, divisor);
01137 ret = env->CallStaticObjectMethod(cached_classes.Grid_Generator,
01138 cached_FMIDs.Grid_Generator_parameter_ID,
01139 j_g_le, j_div);
01140 break;
01141 }
01142 case Grid_Generator::POINT:
01143 {
01144 const Coefficient& divisor = g.divisor();
01145 jobject j_div = build_java_coeff(env, divisor);
01146 ret = env->CallStaticObjectMethod(cached_classes.Grid_Generator,
01147 cached_FMIDs.Grid_Generator_grid_point_ID,
01148 j_g_le, j_div);
01149 break;
01150 }
01151 default:
01152 assert(false);
01153 throw std::runtime_error("PPL Java interface internal error");
01154 }
01155 CHECK_EXCEPTION_THROW(env);
01156 return ret;
01157 }
01158
01159 jobject
01160 build_java_constraint_system(JNIEnv* env, const Constraint_System& cs) {
01161 jobject j_cs = env->NewObject(cached_classes.Constraint_System,
01162 cached_FMIDs.Constraint_System_init_ID);
01163 CHECK_RESULT_THROW(env, j_cs);
01164 for (Constraint_System::const_iterator v_begin = cs.begin(),
01165 v_end = cs.end(); v_begin != v_end; ++v_begin) {
01166 jobject j_constraint = build_java_constraint(env, *v_begin);
01167 env->CallBooleanMethod(j_cs,
01168 cached_FMIDs.Constraint_System_add_ID,
01169 j_constraint);
01170 CHECK_EXCEPTION_THROW(env);
01171 }
01172 return j_cs;
01173 }
01174
01175 jobject
01176 build_java_generator_system(JNIEnv* env, const Generator_System& gs) {
01177 jobject j_gs = env->NewObject(cached_classes.Generator_System,
01178 cached_FMIDs.Generator_System_init_ID);
01179 CHECK_RESULT_THROW(env, j_gs);
01180 for (Generator_System::const_iterator v_begin = gs.begin(),
01181 v_end = gs.end(); v_begin != v_end; ++v_begin) {
01182 jobject j_generator = build_java_generator(env, *v_begin);
01183 env->CallBooleanMethod(j_gs,
01184 cached_FMIDs.Generator_System_add_ID,
01185 j_generator);
01186 CHECK_EXCEPTION_THROW(env);
01187 }
01188 return j_gs;
01189 }
01190
01191 jobject
01192 build_java_grid_generator_system(JNIEnv* env,
01193 const Grid_Generator_System& gs) {
01194 jobject j_gs = env->NewObject(cached_classes.Grid_Generator_System,
01195 cached_FMIDs.Grid_Generator_System_init_ID);
01196 CHECK_RESULT_THROW(env, j_gs);
01197 for (Grid_Generator_System::const_iterator v_begin = gs.begin(),
01198 v_end = gs.end(); v_begin != v_end; ++v_begin) {
01199 jobject j_generator = build_java_grid_generator(env, *v_begin);
01200 env->CallBooleanMethod(j_gs,
01201 cached_FMIDs.Grid_Generator_System_add_ID,
01202 j_generator);
01203 CHECK_EXCEPTION_THROW(env);
01204 }
01205 return j_gs;
01206 }
01207
01208 jobject
01209 build_java_congruence_system(JNIEnv* env, const Congruence_System& cgs) {
01210 jobject j_cgs = env->NewObject(cached_classes.Congruence_System,
01211 cached_FMIDs.Congruence_System_init_ID);
01212 CHECK_RESULT_THROW(env, j_cgs);
01213 for (Congruence_System::const_iterator v_begin = cgs.begin(),
01214 v_end = cgs.end(); v_begin != v_end; ++v_begin) {
01215 jobject j_congruence = build_java_congruence(env,*v_begin);
01216 env->CallBooleanMethod(j_cgs,
01217 cached_FMIDs.Congruence_System_add_ID,
01218 j_congruence);
01219 CHECK_EXCEPTION_THROW(env);
01220 }
01221 return j_cgs;
01222 }
01223
01224 jobject
01225 build_java_artificial_parameter
01226 (JNIEnv* env, const PIP_Tree_Node::Artificial_Parameter& art) {
01227 jobject j_le = build_linear_expression(env, art);
01228 jobject j_den = build_java_coeff(env, art.denominator());
01229 jobject ret = env->NewObject(cached_classes.Artificial_Parameter,
01230 cached_FMIDs.Artificial_Parameter_init_ID,
01231 j_le, j_den);
01232 CHECK_RESULT_THROW(env, ret);
01233 return ret;
01234 }
01235
01236 }
01237
01238 }
01239
01240 }