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;
}
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_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_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;
}
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_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_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;
}
/**
* Class: org_opensplice_dds_dcps_TopicImpl
* Method: jniGetAllDataDisposedTopicStatus
* Signature: ()LDDS/AllDataDisposedTopicStatus;
*/
JNIEXPORT jint JNICALL
SAJ_FUNCTION(jniGetAllDataDisposedTopicStatus)(
JNIEnv *env,
jobject jtopic,
jobject jstatusHolder)
{
gapi_topic topic;
jobject jstatus;
gapi_allDataDisposedTopicStatus status;
saj_returnCode rc;
gapi_returnCode_t result;
if(jstatusHolder){
topic = (gapi_topic) saj_read_gapi_address(env, jtopic);
result = gapi_topic_get_all_data_disposed_topic_status(topic, &status);
if(result == GAPI_RETCODE_OK){
rc = saj_statusCopyOutAllDataDisposedTopicStatus(env, &status, &jstatus);
if(rc == SAJ_RETCODE_OK){
(*env)->SetObjectField(env, jstatusHolder,
GET_CACHED(allDataDisposedTopicStatusHolder_value_fid), jstatus);
(*env)->DeleteLocalRef(env, jstatus);
} else {
result = GAPI_RETCODE_ERROR;
}
}
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
return (jint)result;
}
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;
}
/**
* Class: org_opensplice_dds_dcps_DataReaderViewImpl
* Method: jniGetQos
* Signature: (LDDS/DataReaderViewQosHolder;)V
*/
JNIEXPORT jint JNICALL
SAJ_FUNCTION(jniGetQos)(
JNIEnv *env,
jobject jdataReaderView,
jobject jqosHolder)
{
gapi_dataReaderViewQos* qos;
gapi_returnCode_t result;
saj_returnCode rc;
jobject jqos;
gapi_dataReaderView dataReaderView;
if(jqosHolder != NULL){
dataReaderView = (gapi_dataReaderView)saj_read_gapi_address(env, jdataReaderView);
jqos = NULL;
qos = gapi_dataReaderViewQos__alloc();
result = gapi_dataReaderView_get_qos(dataReaderView, qos);
if(result == GAPI_RETCODE_OK){
rc = saj_DataReaderViewQosCopyOut(env, qos, &jqos);
gapi_free(qos);
if(rc == SAJ_RETCODE_OK){
(*env)->SetObjectField(env, jqosHolder,
GET_CACHED(dataReaderViewQosHolder_value_fid), jqos);
(*env)->DeleteLocalRef(env, jqos);
} else {
result = GAPI_RETCODE_ERROR;
}
}
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
return (jint)result;
}
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;
}
void
saj_topicListenerOnInconsistentTopic(
void* listenerData,
gapi_topic topic,
const gapi_inconsistentTopicStatus *status)
{
saj_listenerData ld;
JNIEnv *env;
jobject jstatus;
jobject jtopic;
saj_returnCode rc;
ld = saj_listenerData(listenerData);
env = *(JNIEnv**)os_threadMemGet(OS_THREAD_JVM);
rc = saj_statusCopyOutInconsistentTopicStatus(env,
(gapi_inconsistentTopicStatus *)status, &jstatus);
if(rc == SAJ_RETCODE_OK){
jtopic = saj_read_java_address(topic);
(*env)->CallVoidMethod(
env, ld->jlistener,
GET_CACHED(listener_onInconsistentTopic_mid),
jtopic, jstatus);
}
}
/**
* Class: org_opensplice_dds_dcps_PublisherImpl
* Method: jniGetDefaultDatawriterQos
* Signature: (LDDS/DataWriterQosHolder;)V
*/
JNIEXPORT jint JNICALL
SAJ_FUNCTION(jniGetDefaultDatawriterQos)(
JNIEnv *env,
jobject jpublisher,
jobject jqosHolder)
{
saj_returnCode rc;
gapi_returnCode_t result;
jobject jqos;
gapi_publisher publisher;
gapi_dataWriterQos *qos;
jqos = NULL;
if(jqosHolder != NULL){
qos = gapi_dataWriterQos__alloc();
publisher = (gapi_publisher)saj_read_gapi_address(env, jpublisher);
result = gapi_publisher_get_default_datawriter_qos(publisher, qos);
if(result == GAPI_RETCODE_OK){
rc = saj_DataWriterQosCopyOut(env, qos, &jqos);
gapi_free(qos);
if (rc == SAJ_RETCODE_OK){
(*env)->SetObjectField(env, jqosHolder,
GET_CACHED(dataWriterQosHolder_value_fid), jqos);
} else {
result = GAPI_RETCODE_ERROR;
}
}
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
return (jint)result;
}
void
saj_dataReaderListenerOnRequestedIncompatibleQos(
void* listenerData,
gapi_dataReader dataReader,
const gapi_requestedIncompatibleQosStatus* status)
{
saj_listenerData ld;
JNIEnv *env;
jobject jstatus;
jobject jdataReader;
saj_returnCode rc;
ld = saj_listenerData(listenerData);
env = *(JNIEnv**)os_threadMemGet(OS_THREAD_JVM);
rc = saj_statusCopyOutRequestedIncompatibleQosStatus(env,
(gapi_requestedIncompatibleQosStatus *)status,
&jstatus);
if(rc == SAJ_RETCODE_OK) {
jdataReader = saj_read_java_address(dataReader);
(*env)->CallVoidMethod(env, ld->jlistener,
GET_CACHED(listener_onRequestedIncompatibleQos_mid),
jdataReader, jstatus);
}
}
/**
* Class: org_opensplice_dds_dcps_DataWriterImpl
* Method: jniGetOfferedIncompatibleQosStatus
* Signature: ()LDDS/OfferedIncompatibleQosStatus;
*/
JNIEXPORT jint JNICALL
SAJ_FUNCTION(jniGetOfferedIncompatibleQosStatus)(
JNIEnv *env,
jobject jdataWriter,
jobject jstatusHolder)
{
gapi_dataWriter dataWriter;
jobject jstatus;
gapi_offeredIncompatibleQosStatus* status;
saj_returnCode rc;
gapi_returnCode_t result;
if(jstatusHolder){
dataWriter = (gapi_dataWriter) saj_read_gapi_address(env, jdataWriter);
status = gapi_offeredIncompatibleQosStatus_alloc();
result = gapi_dataWriter_get_offered_incompatible_qos_status(dataWriter, status);
if(result == GAPI_RETCODE_OK){
rc = saj_statusCopyOutOfferedIncompatibleQosStatus(env, status, &jstatus);
if(rc == SAJ_RETCODE_OK){
(*env)->SetObjectField(env, jstatusHolder,
GET_CACHED(offeredIncompatibleQosStatusHolder_value_fid), jstatus);
(*env)->DeleteLocalRef(env, jstatus);
} else {
result = GAPI_RETCODE_ERROR;
}
}
gapi_free(status);
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
return (jint)result;
}
/**
* Class: org_opensplice_dds_dcps_DataWriterImpl
* Method: jniGetPublicationMatchStatus
* Signature: ()LDDS/PublicationMatchStatus;
*/
JNIEXPORT jint JNICALL
SAJ_FUNCTION(jniGetPublicationMatchedStatus)(
JNIEnv *env,
jobject jdataWriter,
jobject jstatusHolder)
{
gapi_dataWriter dataWriter;
jobject jstatus;
gapi_publicationMatchedStatus status;
saj_returnCode rc;
gapi_returnCode_t result;
if(jstatusHolder){
dataWriter = (gapi_dataWriter) saj_read_gapi_address(env, jdataWriter);
result = gapi_dataWriter_get_publication_matched_status(dataWriter, &status);
if(result == GAPI_RETCODE_OK){
rc = saj_statusCopyOutPublicationMatchStatus(env, &status, &jstatus);
if(rc == SAJ_RETCODE_OK){
(*env)->SetObjectField(env, jstatusHolder,
GET_CACHED(publicationMatchedStatusHolder_value_fid), jstatus);
(*env)->DeleteLocalRef(env, jstatus);
} else {
result = GAPI_RETCODE_ERROR;
}
}
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
return (jint)result;
}
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;
}
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;
}
/**
* Class: DDS_WaitSet
* Method: jniWait
* Signature: (LDDS/ConditionSeqHolder;LDDS/Duration_t;)I
*/
JNIEXPORT jint JNICALL
SAJ_FUNCTION(jniWait)(
JNIEnv *env,
jobject jwaitSet,
jobject jseqHolder,
jobject jduration)
{
gapi_waitSet waitSet;
gapi_conditionSeq *conditionSeq;
gapi_duration_t duration;
jobjectArray jConditionSeq;
saj_returnCode rc;
gapi_returnCode_t result;
if(jseqHolder != NULL){
jConditionSeq = NULL;
waitSet = (gapi_waitSet) saj_read_gapi_address(env, jwaitSet);
rc = saj_durationCopyIn(env, jduration, &duration);
if(rc == SAJ_RETCODE_OK){
conditionSeq = gapi_conditionSeq__alloc();
if(conditionSeq){
conditionSeq->_maximum = 0;
conditionSeq->_length = 0;
conditionSeq->_release = 0;
conditionSeq->_buffer = NULL;
result = gapi_waitSet_wait(waitSet, conditionSeq, &duration);
if((result == GAPI_RETCODE_OK) || (result == GAPI_RETCODE_TIMEOUT)){
rc = saj_LookupExistingConditionSeq(env, conditionSeq, &jConditionSeq);
if ( rc == SAJ_RETCODE_OK){
(*env)->SetObjectField(
env,
jseqHolder,
GET_CACHED(conditionSeqHolder_value_fid),
jConditionSeq);
} else {
result = GAPI_RETCODE_ERROR;
}
}
gapi_free(conditionSeq);
} else {
result = GAPI_RETCODE_OUT_OF_RESOURCES;
}
} else {
result = GAPI_RETCODE_ERROR;
}
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
return (jint)result;
}
saj_returnCode
saj_statusCopyOutOfferedDeadlineMissedStatus(
JNIEnv *env,
gapi_offeredDeadlineMissedStatus* status,
jobject* jstatus)
{
jclass cls;
jmethodID mid;
cls = GET_CACHED(offeredDeadlineMissedStatus_class);
mid = GET_CACHED(offeredDeadlineMissedStatus_constructor_mid);
*jstatus = (*env)->NewObject(env, cls, mid,
(jint)status->total_count,
(jint)status->total_count_change,
(jlong)status->last_instance_handle);
saj_exceptionCheck(env);
return SAJ_RETCODE_OK;
}
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;
}
saj_returnCode
saj_statusCopyOutSubscriptionMatchStatus(
JNIEnv *env,
gapi_subscriptionMatchedStatus* status,
jobject* jstatus)
{
jclass cls;
jmethodID mid;
cls = GET_CACHED(subscriptionMatchStatus_class);
mid = GET_CACHED(subscriptionMatchStatus_constructor_mid);
*jstatus = (*env)->NewObject(env, cls, mid,
(jint)status->total_count,
(jint)status->total_count_change,
(jint)status->current_count,
(jint)status->current_count_change,
(jlong)status->last_publication_handle);
saj_exceptionCheck(env);
return SAJ_RETCODE_OK;
}
saj_returnCode
saj_statusCopyOutLivelinessChangedStatus(
JNIEnv *env,
gapi_livelinessChangedStatus* status,
jobject* jstatus)
{
jclass cls;
jmethodID mid;
cls = GET_CACHED(livelinessChangedStatus_class);
mid = GET_CACHED(livelinessChangedStatus_constructor_mid);
*jstatus = (*env)->NewObject(env, cls, mid,
(jint)status->alive_count,
(jint)status->not_alive_count,
(jint)status->alive_count_change,
(jint)status->not_alive_count_change,
(jlong)status->last_publication_handle);
saj_exceptionCheck(env);
return SAJ_RETCODE_OK;
}
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);
}
}
}
/**
* Class: DDS_WaitSet
* Method: jniGetConditions
* Signature: (LDDS/ConditionSeqHolder;)I
*/
JNIEXPORT jint JNICALL
SAJ_FUNCTION(jniGetConditions)(
JNIEnv *env,
jobject jwaitSet,
jobject jseqHolder)
{
gapi_waitSet waitSet;
gapi_conditionSeq *seq;
jobjectArray jSeq;
saj_returnCode rc;
gapi_returnCode_t result;
if(jseqHolder != NULL){
waitSet = (gapi_waitSet) saj_read_gapi_address(env, jwaitSet);
seq = gapi_conditionSeq__alloc();
if(seq){
seq->_maximum = 0;
seq->_length = 0;
seq->_release = 0;
seq->_buffer = NULL;
result = gapi_waitSet_get_conditions(waitSet, seq);
if (result == GAPI_RETCODE_OK){
rc = saj_LookupExistingConditionSeq(env, seq, &jSeq);
if (rc == SAJ_RETCODE_OK){
(*env)->SetObjectField(
env,
jseqHolder,
GET_CACHED(conditionSeqHolder_value_fid),
jSeq
);
} else {
result = GAPI_RETCODE_ERROR;
}
}
gapi_free(seq);
} else {
result = GAPI_RETCODE_OUT_OF_RESOURCES;
}
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
return (jint)result;
}
void
saj_dataReaderListenerOnDataAvailable(
void* listenerData,
gapi_dataReader dataReader)
{
saj_listenerData ld;
JNIEnv *env;
jobject jdataReader;
ld = saj_listenerData(listenerData);
env = *(JNIEnv**)os_threadMemGet(OS_THREAD_JVM);
jdataReader = saj_read_java_address(dataReader);
(*env)->CallVoidMethod(env, ld->jlistener,
GET_CACHED(listener_onDataAvailable_mid),
jdataReader);
}
void
saj_extTopicListenerOnAllDataDisposed(
void* listenerData,
gapi_topic topic)
{
saj_listenerData ld;
JNIEnv *env;
jobject jtopic;
ld = saj_listenerData(listenerData);
env = *(JNIEnv**)os_threadMemGet(OS_THREAD_JVM);
jtopic = saj_read_java_address(topic);
(*env)->CallVoidMethod(env, ld->jlistener,
GET_CACHED(listener_onAllDataDisposed_mid),
jtopic);
}
/**
* Class: org_opensplice_dds_dcps_SubscriberImpl
* Method: jniGetDatareaders
* Signature: (LDDS/DataReaderSeqHolder;III)I
*/
JNIEXPORT jint JNICALL
SAJ_FUNCTION(jniGetDatareaders)(
JNIEnv *env,
jobject jsubscriber,
jobject jseqHolder,
jint jsampleStates,
jint jviewStates,
jint jinstanceStates)
{
gapi_subscriber subscriber;
gapi_returnCode_t grc;
gapi_dataReaderSeq *readerSeq;
saj_returnCode rc;
jobjectArray jreaderSeq;
jint jresult;
if(jseqHolder != NULL){
readerSeq = gapi_dataReaderSeq__alloc();
if (readerSeq)
{
subscriber = (gapi_subscriber)saj_read_gapi_address(env, jsubscriber);
grc = gapi_subscriber_get_datareaders(subscriber, readerSeq,
(const gapi_sampleStateMask)jsampleStates,
(const gapi_viewStateMask)jviewStates,
(const gapi_instanceStateMask)jinstanceStates);
if(grc == GAPI_RETCODE_OK){
rc = saj_LookupExistingDataReaderSeq(env, readerSeq, &jreaderSeq);
if(rc == SAJ_RETCODE_OK){
(*env)->SetObjectField(env, jseqHolder,
GET_CACHED(dataReaderSeqHolder_value_fid), jreaderSeq);
}
gapi_free(readerSeq);
}
jresult = (jint)grc;
} else {
jresult = (jint)GAPI_RETCODE_OUT_OF_RESOURCES;
}
} else {
jresult = (jint)GAPI_RETCODE_BAD_PARAMETER;
}
return jresult;
}
/**
* Class: org_opensplice_dds_dcps_MultiTopicImpl
* Method: jniGetExpressionParameters
* Signature: ()[Ljava/lang/String;
*/
JNIEXPORT jint JNICALL
SAJ_FUNCTION(jniGetExpressionParameters)(
JNIEnv *env,
jobject jmultiTopic,
jobject jseqHolder)
{
gapi_multiTopic multiTopic;
gapi_stringSeq *seq;
jobjectArray jseq;
saj_returnCode rc;
gapi_returnCode_t result;
if(jseqHolder){
multiTopic = (gapi_multiTopic) saj_read_gapi_address(env, jmultiTopic);
seq = gapi_stringSeq__alloc();
if(seq){
seq->_maximum = 0;
seq->_length = 0;
seq->_release = 0;
seq->_buffer = NULL;
result = gapi_multiTopic_get_expression_parameters(multiTopic, seq);
if(result == GAPI_RETCODE_OK){
rc = saj_stringSequenceCopyOut(env, *seq, &jseq);
if(rc == SAJ_RETCODE_OK){
(*env)->SetObjectField(env, jseqHolder, GET_CACHED(stringSeqHolder_stringSeq_fid), jseq);
(*env)->DeleteLocalRef(env, jseq);
} else {
result = GAPI_RETCODE_ERROR;
}
}
gapi_free(seq);
} else {
result = GAPI_RETCODE_OUT_OF_RESOURCES;
}
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
return (jint)result;
}
