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;
}
