void JPObjectType::setArrayValues(jarray a, HostRef* values) { jobjectArray array = (jobjectArray)a; JPCleaner cleaner; try { // Optimize what I can ... // TODO also optimize array.array ... if (JPEnv::getHost()->isSequence(values)) { int len = JPEnv::getHost()->getSequenceLength(values); for (int i = 0; i < len; i++) { HostRef* v = JPEnv::getHost()->getSequenceItem(values, i); JPEnv::getJava()->SetObjectArrayElement(array, i, convertToJava(v).l); delete v; } } else { RAISE(JPypeException, "Unable to convert to Object array"); } } RETHROW_CATCH( ; );
void JPObjectType::setArrayItem(jarray a, int ndx, HostRef* val) { jobjectArray array = (jobjectArray)a; JPCleaner cleaner; jvalue v = convertToJava(val); cleaner.addLocal(v.l); JPEnv::getJava()->SetObjectArrayElement(array, ndx, v.l); }
void JPObjectType::setStaticValue(jclass c, jfieldID fid, HostRef* obj) { TRACE_IN("JPObjectType::setStaticValue"); JPCleaner cleaner; jobject val = convertToJava(obj).l; cleaner.addLocal(val); JPEnv::getJava()->SetStaticObjectField(c, fid, val); TRACE_OUT; }
void JPDoubleType::setArrayRange(JPJavaFrame& frame, jarray a, int start, int length, vector<HostRef*>& vals) { JPPrimitiveArrayAccessor<array_t, type_t*> accessor(frame, a, &JPJavaFrame::GetDoubleArrayElements, &JPJavaFrame::ReleaseDoubleArrayElements); type_t* val = accessor.get(); for (int i = 0; i < length; i++) { HostRef* pv = vals[i]; val[start+i] = field(convertToJava(pv)); } accessor.commit(); }
void JPObjectType::setArrayRange(jarray a, int start, int length, vector<HostRef*>& vals) { jobjectArray array = (jobjectArray)a; JPCleaner cleaner; jvalue v; for (int i = 0; i < length; i++) { HostRef* pv = vals[i]; v = convertToJava(pv); cleaner.addLocal(v.l); JPEnv::getJava()->SetObjectArrayElement(array, i+start, v.l); } }
void JPByteType::setArrayValues(jarray a, HostRef* values) { jbyteArray array = (jbyteArray)a; jbyte* val = NULL; jboolean isCopy; JPCleaner cleaner; try { val = JPEnv::getJava()->GetByteArrayElements(array, &isCopy); bool converted = true; // Optimize what I can ... if (JPEnv::getHost()->isByteString(values)) { // Strings are also jbyte[] long len; char* data; JPEnv::getHost()->getRawByteString(values, &data, len); memcpy(val, data, len); converted = true; } // TODO also optimize array.array ... else if (JPEnv::getHost()->isSequence(values)) { int len = JPEnv::getHost()->getSequenceLength(values); for (int i = 0; i < len; i++) { HostRef* v = JPEnv::getHost()->getSequenceItem(values, i); val[i] = convertToJava(v).b; delete v; } converted = true; } else { RAISE(JPypeException, "Unable to convert to Byte array"); } JPEnv::getJava()->ReleaseByteArrayElements(array, val, JNI_COMMIT); } RETHROW_CATCH( if (val != NULL) { JPEnv::getJava()->ReleaseByteArrayElements(array, val, JNI_ABORT); } );
jobject JPObjectType::convertToJavaObject(HostRef* obj) { jvalue v = convertToJava(obj); return v.l; }
void JPDoubleType::setArrayItem(JPJavaFrame& frame, jarray a, int ndx , HostRef* obj) { array_t array = (array_t)a; type_t val = field(convertToJava(obj)); frame.SetDoubleArrayRegion(array, ndx, 1, &val); }
void JPDoubleType::setInstanceValue(JPJavaFrame& frame, jobject c, jfieldID fid, HostRef* obj) { type_t val = field(convertToJava(obj)); frame.SetDoubleField(c, fid, val); }
void JPDoubleType::setStaticValue(JPJavaFrame& frame, jclass c, jfieldID fid, HostRef* obj) { type_t val = field(convertToJava(obj)); frame.SetStaticDoubleField(c, fid, val); }