saj_returnCode
saj_LookupTypeSupportConstructorSignature(
JNIEnv* env,
jobject jtypeSupport,
gapi_char** result)
{
jfieldID fid;
jstring jresult;
saj_returnCode rc;
const char* data;
rc = SAJ_RETCODE_ERROR;
if(jtypeSupport != NULL)
{
fid = GET_CACHED(typeSupportConstructorSignature_fid);
if(fid != NULL)
{
jresult = (jstring)((*env)->GetObjectField(env, jtypeSupport, fid));
saj_exceptionCheck(env);
if(jresult != NULL){
data = (*env)->GetStringUTFChars(env, jresult, 0);
saj_exceptionCheck(env);
*result = gapi_string_dup(data);
(*env)->ReleaseStringUTFChars(env, jresult, data);
saj_exceptionCheck(env);
}
rc = SAJ_RETCODE_OK;
}
}
return rc;
}
saj_returnCode
checkJavaObject(
JNIEnv *env,
jobject java_object)
{
saj_returnCode rc;
jclass tempClass;
rc = SAJ_RETCODE_ERROR;
if(java_object != NULL){
/* make sure there is a reference to SajSuperClass */
if (GET_CACHED(gapiSuperClass_class) == NULL){
tempClass = (*env)->FindClass(env, "org/opensplice/dds/dcps/SajSuperClass");
saj_exceptionCheck(env);
SET_CACHED(gapiSuperClass_class, (*env)->NewGlobalRef(env, tempClass));
saj_exceptionCheck(env);
(*env)->DeleteLocalRef(env, tempClass);
saj_exceptionCheck(env);
}
/* Verify the java_object is an instance of SajSuperClass */
if((*env)->IsInstanceOf(env, java_object, GET_CACHED(gapiSuperClass_class))){
rc = SAJ_RETCODE_OK;
}
saj_exceptionCheck(env);
}
return rc;
}
PA_ADDRCAST
saj_read_gapi_address(
JNIEnv *env,
jobject java_object)
{
PA_ADDRCAST returnValue;
saj_returnCode rc;
returnValue = 0;
if(java_object != NULL){
rc = checkJavaObject(env, java_object);
if(rc == SAJ_RETCODE_OK){
if(GET_CACHED(sajSuperClassGapiPeer_fid) == NULL){
SET_CACHED(sajSuperClassGapiPeer_fid, (*env)->GetFieldID(env, GET_CACHED(gapiSuperClass_class), "gapiObject", "J"));
saj_exceptionCheck(env);
}
/* read field gapiObject from the object */
returnValue = (PA_ADDRCAST)(*env)->GetLongField(env, java_object, GET_CACHED(sajSuperClassGapiPeer_fid));
saj_exceptionCheck(env);
}
}
return returnValue;
}
saj_returnCode
saj_stringSequenceCopyIn(
JNIEnv *env,
jobjectArray stringArray,
gapi_stringSeq *out)
{
jobject javaString;
const gapi_char* vm_managed_c_string;
jsize arrayLength;
int i;
saj_returnCode rc;
assert(out != NULL);
assert(stringArray != NULL);
javaString = NULL;
vm_managed_c_string = NULL;
arrayLength = 0;
i = 0;
rc = SAJ_RETCODE_OK;
arrayLength = (*env)->GetArrayLength(env, stringArray);
saj_exceptionCheck(env);
if (stringArray != NULL)
{
out->_maximum = arrayLength;
out->_length = arrayLength;
/* allocate a buffer of the right size */
out->_buffer = gapi_stringSeq_allocbuf(arrayLength);
out->_release = FALSE;
/* fill the string buffer with strings */
for (i = 0; i < arrayLength && rc == SAJ_RETCODE_OK; i++)
{
/* get the java String from the array */
javaString = (*env)->GetObjectArrayElement(env, stringArray, i);
saj_exceptionCheck(env);
/* translate the java string to a c string */
vm_managed_c_string = (*env)->GetStringUTFChars(env, javaString, 0);
saj_exceptionCheck(env);
if(vm_managed_c_string != NULL)
{
/* copy the c sting to the buffer */
out->_buffer[i] = gapi_string_dup(vm_managed_c_string);
}
else
{
rc = SAJ_RETCODE_ERROR; /* VM has thrown an OutOfMemoryError */
}
/* release local references */
(*env)->ReleaseStringUTFChars(env, javaString, vm_managed_c_string);
saj_exceptionCheck(env);
}
}
return rc;
}
saj_returnCode
saj_statusCopyOutQosPolicyCountSeq(
JNIEnv *env,
gapi_qosPolicyCountSeq *src,
jobjectArray* dst)
{
saj_returnCode rc;
jclass cls;
unsigned int i;
jobject jcount;
rc = SAJ_RETCODE_OK;
assert(dst != NULL);
cls = GET_CACHED(qosPolicyCount_class);
*dst = (*env)->NewObjectArray(env, src->_length, cls, NULL);
saj_exceptionCheck(env);
for(i=0; (i<src->_length) && (rc == SAJ_RETCODE_OK); i++){
rc = saj_statusCopyOutQosPolicyCount(env,
&src->_buffer[i],
&jcount);
(*env)->SetObjectArrayElement(env, *dst, (jsize)i, jcount);
saj_exceptionCheck(env);
(*env)->DeleteLocalRef(env, jcount);
saj_exceptionCheck(env);
}
return rc;
}
saj_returnCode
saj_sampleInfoHolderCopyOut(
JNIEnv *env,
gapi_sampleInfo *src,
jobject *dst)
{
jobject sampleInfo;
jobject si;
assert (dst);
assert (*dst);
sampleInfo = (*env)->GetObjectField (env, *dst, GET_CACHED(sampleInfoHolder_value_fid));
saj_exceptionCheck(env);
si = sampleInfo;
if (saj_sampleInfoCopyOut (env, src, &sampleInfo) == SAJ_RETCODE_ERROR) {
return SAJ_RETCODE_ERROR;
}
if (sampleInfo != si) {
(*env)->SetObjectField (env, *dst, GET_CACHED(sampleInfoHolder_value_fid), sampleInfo);
saj_exceptionCheck(env);
}
return SAJ_RETCODE_OK;
}
saj_returnCode
saj_create_new_typed_java_object(
JNIEnv *env,
const char *classname,
jobject *new_java_object,
const char *constructorSignature,
jobject typeSupport)
{
jclass newClass;
jmethodID constructorId;
jobject newObject;
saj_returnCode rc;
assert(new_java_object != NULL);
rc = SAJ_RETCODE_ERROR;
newClass = (*env)->FindClass(env, classname);
saj_exceptionCheck(env);
if (newClass != NULL){
constructorId = (*env)->GetMethodID(env, newClass, "<init>", constructorSignature);
saj_exceptionCheck(env);
if (constructorId != NULL){
newObject = (*env)->NewObject(env, newClass, constructorId, typeSupport);
saj_exceptionCheck(env);
if(newObject != NULL){
*new_java_object = newObject;
rc = SAJ_RETCODE_OK;
}
}
}
return rc;
}
saj_returnCode
saj_timeCopyOut(
JNIEnv *env,
gapi_time_t *src,
jobject *dst)
{
assert(src);
assert(dst);
if (*dst == NULL) {
*dst = (*env)->NewObject (env, GET_CACHED(time_t_class),
GET_CACHED(time_t_constructor_mid),
src->sec, src->nanosec);
saj_exceptionCheck(env);
if (*dst == NULL) {
return SAJ_RETCODE_ERROR;
}
} else {
/* set the nanosec and sec fields of the java object */
(*env)->SetIntField(env, *dst, GET_CACHED(time_t_sec_fid), src->sec);
saj_exceptionCheck(env);
(*env)->SetIntField(env, *dst, GET_CACHED(time_t_nanosec_fid), src->nanosec);
saj_exceptionCheck(env);
}
return SAJ_RETCODE_OK;
}
saj_returnCode
saj_stringSequenceCopyOut(
JNIEnv *env,
gapi_stringSeq src,
jobjectArray *dst)
{
jclass stringArrCls;
jstring javaString;
gapi_unsigned_long i;
saj_returnCode rc;
gapi_unsigned_long seqLength;
assert(dst != NULL);
javaString = NULL;
rc = SAJ_RETCODE_OK;
seqLength = src._length;
stringArrCls = (*env)->FindClass(env, "java/lang/String");
saj_exceptionCheck(env);
assert(stringArrCls != NULL);
*dst = (*env)->NewObjectArray(env, seqLength, stringArrCls, NULL);
saj_exceptionCheck(env);
/* get the c strings from the buffer */
for (i = 0; i < seqLength && rc == SAJ_RETCODE_OK; i++)
{
javaString = (*env)->NewStringUTF(env, src._buffer[i]);
saj_exceptionCheck(env);
if (javaString != NULL)
{
/* store the string object in the string array */
(*env)->SetObjectArrayElement(env, *dst, i, javaString);
if ((*env)->ExceptionCheck(env) == JNI_TRUE)
{
rc = SAJ_RETCODE_ERROR;
}
}
else
{
rc = SAJ_RETCODE_ERROR;
}
(*env)->DeleteLocalRef(env, javaString);
saj_exceptionCheck(env);
}
return rc;
}
saj_returnCode
saj_EnumCopyIn(
JNIEnv *env,
jobject src,
gapi_unsigned_long *dst)
{
jclass enumClass;
jfieldID enumValue_fid;
jmethodID valueMethodId;
saj_returnCode rc;
jthrowable jexception = NULL;
assert(dst != NULL);
enumClass = NULL;
enumValue_fid = NULL;
rc = SAJ_RETCODE_OK;
if(src != NULL)
{
enumClass = (*env)->GetObjectClass(env, src);
saj_exceptionCheck(env);
/* get __value fieldid from the enum class */
enumValue_fid = (*env)->GetFieldID(env, enumClass, "__value", "I");
jexception = (*env)->ExceptionOccurred(env);
if (jexception)
{
/* clear the exception */
(*env)->ExceptionClear(env);
valueMethodId = (*env)->GetMethodID(env, enumClass, "value", "()I");
saj_exceptionCheck(env);
if(valueMethodId != NULL)
{
*dst = (*env)->CallIntMethod(env, src, valueMethodId);
} else
{
rc = SAJ_RETCODE_ERROR;
}
} else
{
*dst = (*env)->GetIntField(env, src, enumValue_fid);
saj_exceptionCheck(env);
}
}
return rc;
}
saj_returnCode saj_octetSequenceCopyOut(
JNIEnv *env,
gapi_octetSeq *src,
jbyteArray *dst)
{
saj_returnCode rc;
assert(dst != NULL);
rc = SAJ_RETCODE_ERROR;
/* create a new java byte array */
*dst = (*env)->NewByteArray(env, src->_length);
saj_exceptionCheck(env);
if (*dst != NULL)
{
(*env)->SetByteArrayRegion(
env, *dst, 0, src->_length, (jbyte *)src->_buffer);
if ((*env)->ExceptionCheck(env) == JNI_FALSE)
{
rc = SAJ_RETCODE_OK;
}
}
return rc;
}
saj_returnCode
saj_statusCopyOutSampleRejectedStatus(
JNIEnv *env,
gapi_sampleRejectedStatus* status,
jobject* jstatus)
{
jclass cls;
jmethodID mid;
saj_returnCode rc;
jobject jkind;
cls = GET_CACHED(sampleRejectedStatus_class);
mid = GET_CACHED(sampleRejectedStatus_constructor_mid);
rc = saj_statusCopyOutSampleRejectedStatusKind(env, status->last_reason,
&jkind);
if(rc == SAJ_RETCODE_OK){
*jstatus = (*env)->NewObject(env, cls, mid,
(jint)status->total_count,
(jint)status->total_count_change,
jkind,
(jlong)status->last_instance_handle);
saj_exceptionCheck(env);
}
return rc;
}
saj_returnCode
saj_LookupExistingConditionSeq(
JNIEnv *env,
gapi_conditionSeq *src,
jobjectArray *dst)
{
jclass classId;
saj_returnCode rc;
assert(dst != NULL);
classId = NULL;
rc = SAJ_RETCODE_ERROR;
/* find the class id of the sequence class */
classId = (*env)->FindClass(env, "DDS/Condition");
saj_exceptionCheck(env);
assert(classId != NULL);
rc = saj_gapiObjectBufferCopyOut(
env, classId, src->_length, src->_buffer, dst);
return rc;
}
saj_returnCode
saj_timeCopyIn(
JNIEnv *env,
jobject src,
gapi_time_t *dst)
{
assert (src);
assert (dst);
dst->sec = (*env)->GetIntField(env, src, GET_CACHED(time_t_sec_fid));
saj_exceptionCheck(env);
dst->nanosec = (*env)->GetIntField(env, src, GET_CACHED(time_t_nanosec_fid));
saj_exceptionCheck(env);
return SAJ_RETCODE_OK;
}
saj_returnCode
saj_statusCopyOutRequestedIncompatibleQosStatus(
JNIEnv *env,
gapi_requestedIncompatibleQosStatus* status,
jobject* jstatus)
{
jclass cls;
jmethodID mid;
jobjectArray jqosCount;
saj_returnCode rc;
cls = GET_CACHED(requestedIncompatibleQosStatus_class);
mid = GET_CACHED(requestedIncompatibleQosStatus_constructor_mid);
rc = saj_statusCopyOutQosPolicyCountSeq(env, &status->policies, &jqosCount);
if(rc == SAJ_RETCODE_OK){
*jstatus = (*env)->NewObject(env, cls, mid,
(jint)status->total_count,
(jint)status->total_count_change,
(jint)status->last_policy_id,
jqosCount);
saj_exceptionCheck(env);
}
return rc;
}
saj_returnCode
saj_LookupExistingDataReaderSeq(
JNIEnv *env,
gapi_dataReaderSeq *src,
jobjectArray *dst)
{
jclass classId;
saj_returnCode rc;
assert(dst != NULL);
classId = NULL;
rc = SAJ_RETCODE_ERROR;
/* find the class id of the sequence class */
classId = (*env)->FindClass(env, "org/opensplice/dds/dcps/DataReaderImpl");
saj_exceptionCheck(env);
assert(classId != NULL);
rc = saj_gapiObjectBufferCopyOut(
env, classId, src->_length, src->_buffer, dst);
return rc;
}
saj_returnCode saj_builtinTopicKeyCopyOut(
JNIEnv *env,
gapi_builtinTopicKey_t *src,
jintArray *dst)
{
saj_returnCode rc;
assert(dst != NULL);
rc = SAJ_RETCODE_ERROR;
/* create a new java byte array */
*dst = (*env)->NewIntArray(env, 3);
saj_exceptionCheck(env);
if (*dst != NULL)
{
(*env)->SetIntArrayRegion(
env, *dst, 0, 3, (jint *)src);
if ((*env)->ExceptionCheck(env) == JNI_FALSE)
{
rc = SAJ_RETCODE_OK;
}
}
return rc;
}
saj_returnCode saj_octetSequenceCopyIn(
JNIEnv *env,
jbyteArray jArray,
gapi_octetSeq *out)
{
jsize arrayLength;
jbyte *vmManagedByteArray;
saj_returnCode rc;
assert(out != NULL);
rc = SAJ_RETCODE_OK;
if (jArray != NULL)
{
arrayLength = (*env)->GetArrayLength(env, jArray);
saj_exceptionCheck(env);
out->_maximum = arrayLength;
out->_length = arrayLength;
/* allocate a buffer of the right size */
out->_buffer = gapi_octetSeq_allocbuf(arrayLength);
out->_release = FALSE;
vmManagedByteArray =
(*env)->GetPrimitiveArrayCritical(env, jArray, NULL);
if(vmManagedByteArray != NULL){
memcpy(out->_buffer, vmManagedByteArray, arrayLength);
/* don't copy the content of vmManagedByteArray to jArray */
(*env)->ReleasePrimitiveArrayCritical(
env, jArray, vmManagedByteArray, JNI_ABORT);
saj_exceptionCheck(env);
}
else
{
rc = SAJ_RETCODE_ERROR;
}
}
return rc;
}
saj_returnCode
saj_EnumCopyOut(
JNIEnv *env,
const char *classname,
gapi_unsigned_long src,
jobject *dst)
{
jclass enumClassId;
jmethodID from_intMethodId;
saj_returnCode rc;
char methodString[255];
assert(dst != NULL && classname != NULL);
assert(strlen(classname) < 249);
enumClassId = NULL;
from_intMethodId = NULL;
rc = SAJ_RETCODE_ERROR;
/* construct a method signature */
snprintf(methodString, 255, "(I)L%s;", classname);
enumClassId = (*env)->FindClass(env, classname);
saj_exceptionCheck(env);
if (enumClassId != NULL){
from_intMethodId = (*env)->GetStaticMethodID(
env, enumClassId, "from_int", methodString);
saj_exceptionCheck(env);
if (from_intMethodId != NULL){
*dst = (*env)->CallStaticObjectMethod(
env, enumClassId, from_intMethodId, src);
saj_exceptionCheck(env);
if(*dst != NULL){
rc = SAJ_RETCODE_OK;
}
}
}
return rc;
}
void
saj_listenerDataFree(
JNIEnv* env,
saj_listenerData ld)
{
if(ld != NULL) {
(*env)->DeleteGlobalRef(env, ld->jlistener);
saj_exceptionCheck(env);
os_free(ld);
}
}
saj_returnCode
saj_durationCopyIn(
JNIEnv *env,
jobject javaDuration,
gapi_duration_t *out)
{
saj_returnCode rc;
assert(out != NULL);
rc = SAJ_RETCODE_OK;
if(javaDuration != NULL){
out->sec = (*env)->GetIntField(env, javaDuration, GET_CACHED(duration_t_sec_fid));
saj_exceptionCheck(env);
out->nanosec = (*env)->GetIntField(env, javaDuration, GET_CACHED(duration_t_nanosec_fid));
saj_exceptionCheck(env);
}
return rc;
}
void
saj_destroy_weak_user_data(
JNIEnv *env,
saj_userData ud)
{
assert(env != NULL);
if(ud != NULL){
(*env)->DeleteWeakGlobalRef(env, ud->saj_object);
saj_exceptionCheck(env);
os_free(ud);
}
}
void
saj_write_gapi_address(
JNIEnv *env,
jobject java_object,
PA_ADDRCAST address)
{
saj_returnCode rc;
if(java_object != NULL){
rc = checkJavaObject(env, java_object);
if( rc == SAJ_RETCODE_OK){
if (GET_CACHED(sajSuperClassGapiPeer_fid) == NULL) {
SET_CACHED(sajSuperClassGapiPeer_fid, (*env)->GetFieldID(env, GET_CACHED(gapiSuperClass_class),
"gapiPeer",
"J"));
saj_exceptionCheck(env);
}
/* write value to java object */
(*env)->SetLongField(env, java_object, GET_CACHED(sajSuperClassGapiPeer_fid), address);
saj_exceptionCheck(env);
}
}
}
saj_listenerData
saj_listenerDataNew(
JNIEnv* env,
jobject jlistener)
{
saj_listenerData ld;
ld = NULL;
if(jlistener != NULL) {
ld = saj_listenerData(os_malloc(C_SIZEOF(saj_listenerData)));
ld->jlistener = (*env)->NewGlobalRef(env, jlistener);
saj_exceptionCheck(env);
}
return ld;
}
saj_returnCode
saj_gapiObjectBufferCopyOut(
JNIEnv *env,
jclass classId,
gapi_unsigned_long seqLength,
gapi_object *src,
jobjectArray *dst)
{
jobject object;
gapi_unsigned_long i;
saj_returnCode rc;
assert(dst != NULL);
assert((seqLength == 0) || (src != NULL));
object = NULL;
rc = SAJ_RETCODE_ERROR;
if(classId != NULL)
{
/* create a new object array */
*dst = (*env)->NewObjectArray(env, seqLength, classId, NULL);
saj_exceptionCheck(env);
if (*dst != NULL)
{
rc = SAJ_RETCODE_OK;
for (i = 0; i < seqLength && rc == SAJ_RETCODE_OK; i++)
{
/* find the reference to the already existing java object */
object = saj_read_java_address((gapi_object)src[i]);
assert(object != NULL);
(*env)->SetObjectArrayElement(env, *dst, i, object);
if ((*env)->ExceptionCheck(env) == JNI_TRUE)
{
/* ArrayIndexOutOfBoundsException or ArrayStoreException */
rc = SAJ_RETCODE_ERROR;
}
}
}
}
return rc;
}
saj_returnCode
saj_statusCopyOutSampleRejectedStatusKind(
JNIEnv *env,
gapi_sampleRejectedStatusKind kind,
jobject *jkind)
{
jclass cls;
jmethodID mid;
cls = GET_CACHED(sampleRejectedStatusKind_class);
mid = GET_CACHED(sampleRejectedStatusKind_fromInt_mid);
*jkind = (*env)->CallStaticObjectMethod(env, cls, mid, (jint)kind);
saj_exceptionCheck(env);
return SAJ_RETCODE_OK;
}
saj_returnCode
saj_statusCopyOutInconsistentTopicStatus(
JNIEnv *env,
gapi_inconsistentTopicStatus* status,
jobject* jstatus)
{
jclass cls;
jmethodID mid;
cls = GET_CACHED(inconsistentTopicStatus_class);
mid = GET_CACHED(inconsistentTopicStatus_constructor_mid);
*jstatus = (*env)->NewObject(env, cls, mid,
(jint)status->total_count,
(jint)status->total_count_change);
saj_exceptionCheck(env);
return SAJ_RETCODE_OK;
}
void
saj_write_weak_java_address(
JNIEnv *env,
gapi_object gapi_obj,
jobject java_object)
{
saj_userData ud;
assert(env != NULL);
assert(gapi_obj != NULL);
assert(java_object != NULL);
ud = os_malloc(C_SIZEOF(saj_userData));
ud->saj_object = (*env)->NewWeakGlobalRef(env, java_object);
saj_exceptionCheck(env);
ud->listenerData = NULL;
ud->statusConditionUserData = NULL;
gapi_object_set_user_data(gapi_obj, (void*)ud,NULL,NULL);
}
saj_returnCode
saj_statusCopyOutQosPolicyCount(
JNIEnv *env,
gapi_qosPolicyCount* status,
jobject* jstatus)
{
jclass cls;
jmethodID mid;
cls = GET_CACHED(qosPolicyCount_class);
mid = GET_CACHED(qosPolicyCount_constructor_mid);
*jstatus = (*env)->NewObject(env, cls, mid,
(jint)status->policy_id,
(jint)status->count);
saj_exceptionCheck(env);
return SAJ_RETCODE_OK;
}
void
saj_destroy_user_data(
JNIEnv *env,
saj_userData ud)
{
/*
* Because of multithread issues the supplied data might be NULL.
*/
if(ud != NULL){
if(ud->listenerData != NULL){
saj_listenerDataFree(env, ud->listenerData);
}
if(ud->statusConditionUserData != NULL){
saj_destroy_user_data(env, ud->statusConditionUserData);
}
(*env)->DeleteGlobalRef(env, ud->saj_object);
saj_exceptionCheck(env);
}
}
