gapi_instanceHandle_t _DataWriterRegisterInstance ( _DataWriter _this, const void *instanceData, c_time timestamp) { u_instanceHandle handle; u_result uResult; writerInfo wData; writerInfo *pData = NULL; gapi_instanceHandle_t result = GAPI_HANDLE_NIL; if ( instanceData ) { wData.writer = _this; wData.data = (void *)instanceData; pData = &wData; } uResult = u_writerRegisterInstance(U_WRITER_GET(_this), (void *)pData, timestamp, &handle); if(uResult == U_RESULT_OK){ result = (gapi_instanceHandle_t)handle; } return result; }
gapi_returnCode_t _DataWriterUnregisterInstance ( _DataWriter _this, const void *instanceData, const gapi_instanceHandle_t handle, c_time timestamp) { gapi_returnCode_t result = GAPI_RETCODE_OK; u_writer w; u_result uResult; writerInfo wData; writerInfo *pData = NULL; w = U_WRITER_GET(_this); if ( instanceData ) { wData.writer = _this; wData.data = (void *)instanceData; pData = &wData; } uResult = u_writerUnregisterInstance(w, pData, timestamp, (u_instanceHandle)handle); result = kernelResultToApiResult(uResult); return result; }
gapi_returnCode_t gapi_publisher_delete_datawriter ( gapi_publisher _this, const gapi_dataWriter a_datawriter) { gapi_returnCode_t result = GAPI_RETCODE_OK; _Publisher publisher; _DataWriter datawriter; c_bool contains; publisher = gapi_publisherClaim(_this, &result); if ( publisher ) { datawriter = gapi_dataWriterClaimNB(a_datawriter, NULL); if ( datawriter ) { contains = u_publisherContainsWriter(U_PUBLISHER_GET(publisher), U_WRITER_GET(datawriter)); if (contains) { result = _DataWriterFree(datawriter); if ( result != GAPI_RETCODE_OK ) { _EntityRelease(datawriter); } } else { _EntityRelease(datawriter); result = GAPI_RETCODE_PRECONDITION_NOT_MET; } } else { result = GAPI_RETCODE_BAD_PARAMETER; } _EntityRelease(publisher); } return result; }
gapi_returnCode_t gapi_fooDataWriter_writedispose_w_timestamp ( gapi_fooDataWriter _this, const gapi_foo *instance_data, const gapi_instanceHandle_t handle, const gapi_time_t *source_timestamp) { gapi_returnCode_t result = GAPI_RETCODE_BAD_PARAMETER; _DataWriter datawriter; writerInfo data; c_time timestamp; u_result r; if ( instance_data != NULL ) { result = kernelCopyInTime(source_timestamp, ×tamp); if ( result == GAPI_RETCODE_OK ) { datawriter = gapi_dataWriterReadClaim(_this, &result); if ( datawriter != NULL ) { data.writer = datawriter; data.data = (void *)instance_data; r = u_writerWriteDispose (U_WRITER_GET(datawriter), &data, timestamp, handle); _EntityReadRelease(datawriter); result = kernelResultToApiResult(r); } } } return result; }
gapi_returnCode_t gapi_fooDataWriter_writedispose ( gapi_fooDataWriter _this, const gapi_foo *instance_data, const gapi_instanceHandle_t handle) { gapi_returnCode_t result = GAPI_RETCODE_BAD_PARAMETER; _DataWriter datawriter; writerInfo data; u_result r; if ( instance_data != NULL ) { datawriter = gapi_dataWriterReadClaim(_this, &result); if ( datawriter != NULL ) { data.writer = datawriter; data.data = (void *)instance_data; r = u_writerWriteDispose(U_WRITER_GET(datawriter), &data, C_TIME_INVALID, handle); _EntityReadRelease(datawriter); result = kernelResultToApiResult(r); } } return result; }
gapi_instanceHandle_t gapi_fooDataWriter_lookup_instance ( gapi_dataWriter _this, const gapi_foo * instance_data) { _DataWriter datawriter; u_result uResult; writerInfo data; gapi_instanceHandle_t handle = GAPI_HANDLE_NIL; if (instance_data) { datawriter = gapi_dataWriterReadClaim(_this, NULL); if (datawriter) { data.writer = datawriter; data.data = (void *)instance_data; uResult = u_writerLookupInstance(U_WRITER_GET(datawriter), &data, &handle); _EntityReadRelease(datawriter); } } return handle; }
static gapi_returnCode_t _DataWriter_get_matched_subscriptions ( _DataWriter _this, gapi_instanceHandleSeq *subscription_handles) { u_result uResult; uResult = u_writerGetMatchedSubscriptions( U_WRITER_GET(_this), copy_matched_subscription, subscription_handles); return kernelResultToApiResult(uResult); }
static gapi_returnCode_t _DataWriter_get_offered_incompatible_qos_status ( _DataWriter _this, gapi_offeredIncompatibleQosStatus *status) { u_result uResult; uResult = u_writerGetIncompatibleQosStatus( U_WRITER_GET(_this), TRUE, copy_IncompatibleQosStatus, status); return kernelResultToApiResult(uResult); }
static gapi_returnCode_t _DataWriter_get_publication_matched_status ( _DataWriter _this, gapi_publicationMatchedStatus *status) { u_result uResult; uResult = u_writerGetPublicationMatchStatus( U_WRITER_GET(_this), TRUE, copy_publication_matched_status, status); return kernelResultToApiResult(uResult); }
static gapi_returnCode_t _DataWriter_get_matched_subscription_data ( _DataWriter _this, gapi_subscriptionBuiltinTopicData *subscription_data, const gapi_instanceHandle_t subscription_handle) { u_result uResult; uResult = u_writerGetMatchedSubscriptionData( U_WRITER_GET(_this), subscription_handle, gapi_subscriptionBuiltinTopicData__copyOut, subscription_data); return kernelResultToApiResult(uResult); }
static gapi_returnCode_t _DataWriter_get_liveliness_lost_status ( _DataWriter _this, gapi_livelinessLostStatus *status) { u_result uResult; uResult = u_writerGetLivelinessLostStatus( U_WRITER_GET(_this), TRUE, copy_liveliness_lost_status, status); return kernelResultToApiResult(uResult); }
static gapi_returnCode_t _DataWriter_get_offered_deadline_missed_status ( _DataWriter _this, gapi_offeredDeadlineMissedStatus *status) { u_result uResult; uResult = u_writerGetDeadlineMissedStatus( U_WRITER_GET(_this), TRUE, copy_deadline_missed_status, status); return kernelResultToApiResult(uResult); }
/* Publisher * get_publisher(); */ gapi_publisher gapi_dataWriter_get_publisher ( gapi_dataWriter _this) { _DataWriter datawriter; gapi_publisher publisher = NULL; u_publisher uPublisher; datawriter = gapi_dataWriterClaim(_this, NULL); if ( datawriter != NULL ) { uPublisher = u_writerPublisher(U_WRITER_GET(datawriter)); publisher = u_entityGetUserData(u_entity(uPublisher)); _EntityRelease(datawriter); } return publisher; }
gapi_dataWriterQos * _DataWriterGetQos ( _DataWriter dataWriter, gapi_dataWriterQos * qos) { v_writerQos dataWriterQos; u_writer uWriter; assert(dataWriter); uWriter = U_WRITER_GET(dataWriter); if ( u_entityQoS(u_entity(uWriter), (v_qos*)&dataWriterQos) == U_RESULT_OK ) { copyWriterQosOut(dataWriterQos, qos); u_writerQosFree(dataWriterQos); } return qos; }
gapi_returnCode_t _DataWriterGetKeyValue ( _DataWriter _this, void *instance, const gapi_instanceHandle_t handle) { gapi_returnCode_t result; u_writer w; u_result uResult; PREPEND_COPYOUTCACHE(_this->copy_cache,instance, NULL); w = U_WRITER_GET(_this); uResult = u_writerCopyKeysFromInstanceHandle(w, (u_instanceHandle)handle, (u_writerAction)_this->copy_out, instance); result = kernelResultToApiResult(uResult); REMOVE_COPYOUTCACHE(_this->copy_cache,instance); return result; }
/* ReturnCode_t * assert_liveliness(); */ gapi_returnCode_t gapi_dataWriter_assert_liveliness ( gapi_dataWriter _this) { gapi_returnCode_t result; u_result uResult; _DataWriter datawriter; datawriter = gapi_dataWriterClaim(_this, &result); if (datawriter != NULL) { if (_EntityEnabled(datawriter)) { uResult = u_writerAssertLiveliness(U_WRITER_GET(datawriter)); result = kernelResultToApiResult(uResult); } else { result=GAPI_RETCODE_NOT_ENABLED; } } _EntityRelease(datawriter); return result; }
gapi_returnCode_t _DataWriterFree ( _DataWriter _this) { gapi_returnCode_t result = GAPI_RETCODE_OK; _Status status; u_writer w; assert(_this); status = _EntityStatus(_this); _TopicDescriptionDecUse(_TopicDescription(_this->topic)); _StatusSetListener(status, NULL, 0); _EntityClaim(status); _StatusDeinit(status); w = U_WRITER_GET(_this); _EntityDispose (_Entity(_this)); u_writerFree(w); return result; }
u_writer DJA_DCPSUtilityBridge_us_createDataWriter( DLRL_Exception* exception, void* userData, DK_TopicInfo* topicInfo, void** ls_writer) { /* JNI thread env */ JNIEnv* env = NULL; DJA_CachedJNITypedTopic* typedTopicCachedData = NULL; /* java data writer & topic entities */ jobject jdataWriter = NULL; jobject jtopic = NULL; jobject ls_publisher = NULL; DK_CacheAdmin* cache = NULL; DK_ObjectHomeAdmin* home = NULL; gapi_dataWriter gapiWriter = NULL; _DataWriter _writer = NULL; gapi_returnCode_t result = GAPI_RETCODE_OK; u_writer uwriter = NULL; DLRL_INFO(INF_ENTER); assert(exception); assert(userData); assert(topicInfo); home = DK_TopicInfo_us_getOwner(topicInfo);/* no duplicate done */ env = (JNIEnv*)userData; typedTopicCachedData = (DJA_CachedJNITypedTopic*)DK_TopicInfo_us_getTopicUserData(topicInfo); /* typedTopicCachedData may be NULL */ cache = DK_ObjectHomeAdmin_us_getCache(home); /* get java object */ jtopic = (jobject)DK_TopicInfo_us_getLSTopic(topicInfo); ls_publisher = jtopic ? (jobject)DK_CacheAdmin_us_getLSPublisher(cache) : NULL; DLRL_INFO(INF_CALLBACK, "objectHome->createDataWriter(publisher, topic)"); jdataWriter = jtopic ? (*env)->CallStaticObjectMethod(env, cachedJNI.dcpsUtil_class, cachedJNI.dcpsUtil_createDataWriter_mid, ls_publisher, jtopic) : NULL; DLRL_JavaException_PROPAGATE(env, exception); if(!jdataWriter){ DLRL_Exception_THROW(exception, DLRL_DCPS_ERROR, "Creation of data writer failed! " "Check DCPS error log file for (possibly) more " "information."); } if(typedTopicCachedData) { DJA_Initialisation_loadTypedWriterCache(exception, env, typedTopicCachedData, jdataWriter); DLRL_Exception_PROPAGATE(exception); } DLRL_INFO(INF_DCPS, "saj_read_gapi_address(datawriter)"); gapiWriter = jdataWriter? (gapi_dataWriter)saj_read_gapi_address(env, jdataWriter) : NULL; if(!gapiWriter){ DLRL_Exception_THROW(exception, DLRL_DCPS_ERROR, "Unable to create the DCPS DataWriter entity. " "Check DCPS error log file for (possibly) more " "information."); } _writer = gapi_dataWriterClaim(gapiWriter, &result); DLRL_Exception_PROPAGATE_GAPI_RESULT(exception, result, "Unable to claim data writer handle"); uwriter = U_WRITER_GET(_writer); if(uwriter) { /* now create a proxy to this user layer topic which can be used by the DLRL * in a safe manner, as the user layer topic returned by the _TopicUtopic * operation is owned by the gapi. */ uwriter = u_writer(DK_DCPSUtility_ts_createProxyUserEntity(exception, u_entity(uwriter))); } _EntityRelease(_writer);/* before the propagate */ DLRL_Exception_PROPAGATE(exception);/* after the release */ if(!uwriter){ DLRL_Exception_THROW(exception, DLRL_DCPS_ERROR, "Unable to create the DCPS DataWriter entity. " "Check DCPS error log file for (possibly) more " "information."); } *ls_writer = (void*)(*(env))->NewGlobalRef (env, jdataWriter); if (!(*ls_writer)) { u_entityFree(u_entity(uwriter)); uwriter = NULL; DLRL_Exception_THROW(exception, DLRL_OUT_OF_MEMORY, "Not enough memory to complete operation."); } DLRL_Exception_EXIT(exception); if(exception->exceptionID != DLRL_NO_EXCEPTION){ /* return null if an exception occured, clean the data reader if it existed (later an exception will be set when JNI raises an exception as well */ uwriter = NULL; } if(jdataWriter){ (*env)->DeleteLocalRef(env, jdataWriter); } DLRL_INFO(INF_EXIT); return uwriter; }