gapi_returnCode_t
gapi_dataReader_delete_readcondition (
gapi_dataReader _this,
const gapi_readCondition a_condition)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
_DataReader datareader;
_ReadCondition readCondition = NULL;
c_bool contains;
if (_this && a_condition) {
datareader = gapi_dataReaderClaim(_this, &result);
if (datareader != NULL) {
readCondition = gapi_readConditionClaim(a_condition, NULL);
if (readCondition != NULL ) {
contains = u_readerContainsQuery(U_READER_GET(datareader),
U_QUERY_GET(readCondition));
if (contains) {
_ReadConditionFree(readCondition);
} else {
result = GAPI_RETCODE_PRECONDITION_NOT_MET;
_EntityRelease(readCondition);
}
} else {
result = GAPI_RETCODE_ALREADY_DELETED;
}
_EntityRelease(datareader);
} else {
result = GAPI_RETCODE_ALREADY_DELETED;
}
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
return result;
}
gapi_dataReaderView
gapi_dataReader_create_view (
gapi_dataReader _this,
const gapi_dataReaderViewQos *qos)
{
_DataReader datareader = NULL;
_DataReaderView view = NULL;
gapi_dataReaderViewQos *viewQos;
gapi_context context;
GAPI_CONTEXT_SET(context, _this, GAPI_METHOD_CREATE_VIEW);
datareader = gapi_dataReaderClaim(_this, NULL);
if ( datareader && _EntityEnabled(datareader)) {
if ( qos == GAPI_DATAVIEW_QOS_DEFAULT ) {
viewQos = (gapi_dataReaderViewQos *)&datareader->_defDataReaderViewQos;
} else {
viewQos = (gapi_dataReaderViewQos *)qos;
}
if (gapi_dataReaderViewQosIsConsistent(viewQos,&context) == GAPI_RETCODE_OK) {
view = _DataReaderViewNew (viewQos, datareader);
if ( view ) {
_ENTITY_REGISTER_OBJECT(_Entity(datareader), (_Object)view);
}
}
}
_EntityRelease(datareader);
return (gapi_dataReaderView)_EntityRelease(view);
}
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;
}
void
_DataReaderTriggerNotify (
_DataReader _this)
{
_Status status;
gapi_listener_DataAvailableListener callback;
void *listenerData;
gapi_object handle;
assert(_this);
status = _Entity(_this)->status;
callback = status->callbackInfo.on_data_available;
listenerData = status->callbackInfo.listenerData;
if ( callback && listenerData ) {
if (u_dataReaderDataAvailableTest(U_DATAREADER_GET(_this))) {
handle = _EntityHandle(_this);
_EntitySetBusy(_this);
_EntityRelease(_this);
callback(listenerData, handle);
gapi_objectClearBusy(handle);
(void)gapi_dataReaderClaim(handle, NULL);
}
}
}
gapi_returnCode_t
gapi_dataReader_wait_for_historical_data (
gapi_dataReader _this,
const gapi_duration_t *max_wait)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
_DataReader datareader;
c_time c_time_max_wait;
u_result uResult;
datareader = gapi_dataReaderClaim(_this, &result);
if (datareader) {
if ( !max_wait || !gapi_validDuration(max_wait)) {
result = GAPI_RETCODE_BAD_PARAMETER;
} else if (!_EntityEnabled(datareader)) {
result = GAPI_RETCODE_NOT_ENABLED;
} else {
kernelCopyInDuration(max_wait, &c_time_max_wait);
uResult = u_dataReaderWaitForHistoricalData(
U_DATAREADER_GET(datareader),
c_time_max_wait);
result = kernelResultToApiResult(uResult);
}
_EntityRelease(datareader);
}
return result;
}
/* Entity
* get_entity();
*/
gapi_entity
gapi_statusCondition_get_entity(
gapi_statusCondition _this)
{
_StatusCondition statuscondition;
_Entity entity = NULL;
statuscondition = gapi_statusConditionClaim(_this, NULL);
if ( statuscondition != NULL ) {
entity = _ConditionEntity(_Condition(statuscondition));
_EntityClaim(entity);
}
_EntityRelease(statuscondition);
return (gapi_entity)_EntityRelease(entity);
}
/* ReturnCode_t
* set_query_parameters(
* in StringSeq query_parameters);
*/
gapi_returnCode_t
gapi_queryCondition_set_query_parameters(
gapi_queryCondition _this,
const gapi_stringSeq *query_parameters)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
_QueryCondition querycondition = (_QueryCondition)_this;
querycondition = gapi_queryConditionClaim(_this, &result);
if (querycondition != NULL && gapi_sequence_is_valid(query_parameters)) {
u_query uQuery = ((_ReadCondition)querycondition)->uQuery;
result = gapi_expressionSetQueryArgs(querycondition->expression,
uQuery,
query_parameters);
if (result == GAPI_RETCODE_OK) {
/* Store new params for later retrieval */
gapi_free(querycondition->query_parameters);
querycondition->query_parameters = gapi_stringSeq_dup(query_parameters);
}
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
_EntityRelease(querycondition);
return result;
}
/* DomainParticipant
* get_participant();
*/
gapi_domainParticipant
gapi_topicDescription_get_participant (
gapi_topicDescription _this)
{
_TopicDescription topicDescription;
_Topic topic;
_DomainParticipant participant = NULL;
topicDescription = gapi_topicDescriptionClaim(_this, NULL);
if ( topicDescription != NULL ) {
/* all entities except for content filtered topics have a reference
* to a user layer entity. So except for content filtered topics
* entities get their participant from the user layer entity.
* Content filters instead do this via the related topic.
*/
if (_ObjectGetKind(_Object(topicDescription)) == OBJECT_KIND_CONTENTFILTEREDTOPIC) {
topic = _ContentFilteredTopicGetRelatedTopic(_ContentFilteredTopic(topicDescription));
participant = _EntityParticipant(_Entity(topic));
} else {
participant = _EntityParticipant(_Entity(topicDescription));
}
}
_EntityRelease(topicDescription);
return (gapi_domainParticipant)_EntityHandle(participant);
}
gapi_returnCode_t
gapi_subscriber_set_default_datareader_qos (
gapi_subscriber _this,
const gapi_dataReaderQos *qos)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
_Subscriber subscriber = (_Subscriber)_this;
gapi_context context;
GAPI_CONTEXT_SET(context, _this, GAPI_METHOD_SET_DEFAULT_DATAREADER_QOS);
subscriber = gapi_subscriberClaim(_this, &result);
if (result == GAPI_RETCODE_OK) {
if (qos == GAPI_SUBSCRIBER_QOS_DEFAULT) {
qos = &gapi_dataReaderQosDefault;
}
result = gapi_dataReaderQosIsConsistent(qos, &context);
if (result == GAPI_RETCODE_OK) {
gapi_dataReaderQosCopy (qos, &subscriber->_defDataReaderQos);
}
_EntityRelease(subscriber);
}
return result;
}
gapi_returnCode_t
gapi_dataReader_set_default_datareaderview_qos (
gapi_dataReader _this,
const gapi_dataReaderViewQos *qos)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
_DataReader dataReader = (_DataReader)_this;
gapi_context context;
GAPI_CONTEXT_SET(context, _this, GAPI_METHOD_SET_DEFAULT_DATAREADERVIEW_QOS);
dataReader = gapi_dataReaderClaim(_this, &result);
if ( dataReader ) {
if ( qos ) {
result = gapi_dataReaderViewQosIsConsistent(qos, &context);
if ( result == GAPI_RETCODE_OK ) {
gapi_dataReaderViewQosCopy (qos, &dataReader->_defDataReaderViewQos);
}
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
_EntityRelease(dataReader);
}
return result;
}
/* ReturnCode_t
* get_matched_subscription_data(
* inout SubscriptionBuiltinTopicData subscription_data,
* in InstanceHandle_t subscription_handle);
*/
gapi_returnCode_t
gapi_dataWriter_get_matched_subscription_data (
gapi_dataWriter _this,
gapi_subscriptionBuiltinTopicData *subscription_data,
const gapi_instanceHandle_t subscription_handle)
{
gapi_returnCode_t result;
_DataWriter datawriter;
datawriter = gapi_dataWriterClaim(_this, &result);
if (datawriter != NULL) {
if (_EntityEnabled(datawriter)) {
result = _DataWriter_get_matched_subscription_data (
datawriter,
subscription_data,
subscription_handle);
} else {
result=GAPI_RETCODE_NOT_ENABLED;
}
}
_EntityRelease(datawriter);
return result;
}
gapi_dataReader
gapi_subscriber_lookup_datareader (
gapi_subscriber _this,
const gapi_char *topic_name)
{
_Subscriber subscriber;
gapi_dataReader handle = NULL;
u_dataReader found;
c_iter iter;
subscriber = gapi_subscriberClaim(_this, NULL);
if (subscriber) {
iter = u_subscriberLookupReaders(U_SUBSCRIBER_GET(subscriber),
topic_name);
if (iter) {
found = c_iterTakeFirst(iter);
if (found) {
handle = u_entityGetUserData(u_entity(found));
}
c_iterFree(iter);
}
_EntityRelease(subscriber);
}
return handle;
}
/* ReturnCode_t
* get_message(
* out String message);
*/
gapi_returnCode_t
gapi_errorInfo_get_message(
gapi_errorInfo _this,
gapi_string *message)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
_ErrorInfo errorinfo;
errorinfo = gapi_errorInfoClaim(_this, &result);
if (errorinfo->valid) {
if (*message != NULL) {
gapi_free(*message);
}
if (errorinfo->message != NULL) {
(*message) = gapi_string_dup(errorinfo->message);
} else {
(*message) = NULL;
}
} else {
result = GAPI_RETCODE_NO_DATA;;
}
_EntityRelease(errorinfo);
return result;
}
/* ReturnCode_t
* set_listener(
* in DataWriterListener a_listener,
* in StatusMask mask);
*/
gapi_returnCode_t
gapi_dataWriter_set_listener (
gapi_dataWriter _this,
const struct gapi_dataWriterListener *a_listener,
const gapi_statusMask mask)
{
gapi_returnCode_t result = GAPI_RETCODE_ERROR;
_DataWriter datawriter;
datawriter = gapi_dataWriterClaim(_this, &result);
if ( datawriter != NULL ) {
_Status status;
if ( a_listener ) {
datawriter->listener = *a_listener;
} else {
memset(&datawriter->listener, 0, sizeof(datawriter->listener));
}
status = _EntityStatus(datawriter);
if ( _StatusSetListener(status,
(struct gapi_listener *)a_listener,
mask) )
{
result = GAPI_RETCODE_OK;
}
}
_EntityRelease(datawriter);
return result;
}
gapi_returnCode_t
gapi_publisher_set_listener (
gapi_publisher _this,
const struct gapi_publisherListener *a_listener,
const gapi_statusMask mask)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
_Publisher publisher;
publisher = gapi_publisherClaim(_this, &result);
if ( publisher != NULL ) {
_Status status;
if ( a_listener ) {
publisher->_Listener = *a_listener;
} else {
memset(&publisher->_Listener, 0, sizeof(publisher->_Listener));
}
status = _EntityStatus(publisher);
if ( _StatusSetListener(status,
(struct gapi_listener *)a_listener,
mask) )
{
result = GAPI_RETCODE_OK;
}
}
_EntityRelease(publisher);
return result;
}
gapi_returnCode_t
gapi_publisher_set_default_datawriter_qos (
gapi_publisher _this,
const gapi_dataWriterQos *qos)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
_Publisher publisher;
gapi_context context;
GAPI_CONTEXT_SET(context, _this, GAPI_METHOD_SET_DEFAULT_DATAWRITER_QOS);
publisher = gapi_publisherClaim(_this, &result);
if (result == GAPI_RETCODE_OK) {
if (qos == GAPI_DATAWRITER_QOS_DEFAULT) {
qos = &gapi_dataWriterQosDefault;
}
result = gapi_dataWriterQosIsConsistent(qos, &context);
if (result == GAPI_RETCODE_OK) {
gapi_dataWriterQosCopy (qos, &publisher->_defDataWriterQos);
}
_EntityRelease(publisher);
}
return result;
}
gapi_returnCode_t
gapi_fooDataReaderView_return_loan (
gapi_fooDataReaderView _this,
void *data_buffer,
void *info_buffer)
{
_DataReaderView datareaderview;
gapi_returnCode_t result = GAPI_RETCODE_OK;
datareaderview = gapi_dataReaderViewClaim(_this, &result);
if (datareaderview == NULL) {
return result;
} else if (data_buffer == NULL || info_buffer == NULL) {
result = GAPI_RETCODE_BAD_PARAMETER;
} else {
result = gapi_loanRegistry_deregister(datareaderview->loanRegistry,
data_buffer,
info_buffer);
}
_EntityRelease(datareaderview);
return result;
}
gapi_dataWriter
gapi_publisher_lookup_datawriter (
gapi_publisher _this,
const gapi_char *topic_name)
{
_Publisher publisher;
u_writer found;
gapi_dataWriter handle = NULL;
c_iter iter;
if (topic_name) {
publisher = gapi_publisherClaim(_this, NULL);
if (publisher) {
iter = u_publisherLookupWriters(U_PUBLISHER_GET(publisher), topic_name);
if (iter) {
found = c_iterTakeFirst(iter);
if (found) {
handle = u_entityGetUserData(u_entity(found));
}
c_iterFree(iter);
}
_EntityRelease(publisher);
}
}
return handle;
}
gapi_returnCode_t
gapi_fooDataWriter_dispose_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_writerDispose (U_WRITER_GET(datawriter),
&data,
timestamp,
handle);
_EntityRelease(datawriter);
result = kernelResultToApiResult(r);
}
}
}
return result;
}
/* InstanceHandle_t
* lookup_instance(
* in Data instance);
*/
gapi_instanceHandle_t
gapi_fooDataReaderView_lookup_instance (
gapi_fooDataReaderView _this,
const gapi_foo *instance_data)
{
_DataReaderView datareaderview;
gapi_instanceHandle_t handle = GAPI_HANDLE_NIL;
datareaderview = gapi_dataReaderViewClaim(_this, NULL);
if ( datareaderview && instance_data ) {
readerViewCopyInInfo rData;
u_result uResult;
rData.reader = datareaderview->datareader;
rData.data = (void *)instance_data;
uResult = u_dataViewLookupInstance(
U_DATAREADERVIEW_GET(datareaderview),
&rData,
_DataReaderViewCopyIn,
&handle);
}
_EntityRelease(datareaderview);
return handle;
}
gapi_returnCode_t
gapi_subscriber_set_listener (
gapi_subscriber _this,
const struct gapi_subscriberListener *a_listener,
const gapi_statusMask mask)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
_Subscriber subscriber = (_Subscriber)_this;
subscriber = gapi_subscriberClaim(_this, &result);
if ( (subscriber != NULL) ) {
_Status status;
if ( a_listener ) {
subscriber->_Listener = *a_listener;
} else {
memset(&subscriber->_Listener, 0, sizeof(subscriber->_Listener));
}
status = _EntityStatus(subscriber);
if ( _StatusSetListener(status,
(struct gapi_listener *)a_listener,
mask) )
{
result = GAPI_RETCODE_OK;
}
_EntityRelease(subscriber);
}
return result;
}
gapi_returnCode_t
gapi_dataWriter_wait_for_acknowledgments (
gapi_dataWriter _this,
const gapi_duration_t *max_wait
)
{
_DataWriter datawriter;
u_result uResult;
gapi_returnCode_t result;
c_time timeout;
datawriter = gapi_dataWriterClaim(_this, NULL);
if ( datawriter != NULL ) {
kernelCopyInDuration(max_wait, &timeout);
uResult = u_writerWaitForAcknowledgments(
u_writer(_EntityUEntity(datawriter)),
timeout);
result = kernelResultToApiResult(uResult);
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
_EntityRelease(datawriter);
return result;
}
gapi_returnCode_t
gapi_publisher_delete_contained_entities (
gapi_publisher _this)
{
_Publisher publisher;
_DataWriter dataWriter;
gapi_dataWriter handle;
gapi_returnCode_t result = GAPI_RETCODE_OK;
c_iter writers;
u_writer w;
void *userData;
publisher = gapi_publisherClaim(_this, &result);
if ( publisher != NULL ) {
/* delete all datawriters in the datawriterSet */
writers = u_publisherLookupWriters(U_PUBLISHER_GET(publisher),NULL);
w = c_iterTakeFirst(writers);
while (w) {
handle = u_entityGetUserData(u_entity(w));
dataWriter = gapi_dataWriterClaimNB(handle,&result);
if (dataWriter) {
userData = _ObjectGetUserData(_Object(dataWriter));
_DataWriterFree(dataWriter);
}
w = c_iterTakeFirst(writers);
}
c_iterFree(writers);
_EntityRelease(publisher);
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
return result;
}
/* DataReader
* get_datareader();
*/
gapi_dataReader
gapi_dataReaderView_get_datareader(
gapi_dataReaderView _this)
{
_DataReader datareader = NULL;
_DataReaderView dataReaderView;
dataReaderView = gapi_dataReaderViewClaim(_this, NULL);
if ( dataReaderView != NULL ) {
datareader = _DataReaderViewDataReader(dataReaderView);
}
_EntityRelease(dataReaderView);
return (gapi_dataReader)_EntityRelease(datareader);
}
/* Topic
* get_topic();
*/
gapi_topic
gapi_dataWriter_get_topic (
gapi_dataWriter _this)
{
_DataWriter datawriter;
_Topic topic = NULL;
datawriter = gapi_dataWriterClaim(_this, NULL);
if ( datawriter != NULL ) {
topic = (_Topic)datawriter->topic;
_EntityClaim(topic);
}
_EntityRelease(datawriter);
return (gapi_topic)_EntityRelease(topic);
}
/* ReadCondition
* create_readcondition(
* in SampleStateMask sample_states,
* in ViewStateMask view_states,
* in InstanceStateMask instance_states);
*/
gapi_readCondition
gapi_dataReaderView_create_readcondition (
gapi_dataReaderView _this,
const gapi_sampleStateMask sample_states,
const gapi_viewStateMask view_states,
const gapi_instanceStateMask instance_states)
{
_DataReaderView datareaderview;
_ReadCondition readCondition = NULL;
datareaderview = gapi_dataReaderViewClaim(_this, NULL);
if ( datareaderview && _EntityEnabled(datareaderview) &&
gapi_stateMasksValid(sample_states, view_states, instance_states) ) {
_DataReader datareader;
datareader = _DataReaderViewDataReader(datareaderview);
readCondition = _ReadConditionNew ( sample_states,
view_states,
instance_states,
datareader,
datareaderview);
_EntityRelease(datareader);
if ( readCondition != NULL ) {
gapi_deleteEntityAction deleteAction;
void *actionArg;
if ( _ObjectGetDeleteAction(_Object(readCondition),
&deleteAction, &actionArg) ) {
_ObjectSetDeleteAction(_Object(readCondition),
deleteAction,
actionArg);
}
_ENTITY_REGISTER_OBJECT(_Entity(datareaderview),
(_Object)readCondition);
}
}
_EntityRelease(datareaderview);
return (gapi_readCondition)_EntityRelease(readCondition);
}
gapi_returnCode_t
gapi_publisher_set_qos (
gapi_publisher _this,
const gapi_publisherQos *qos)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
u_result uResult;
_Publisher publisher;
v_publisherQos publisherQos;
gapi_context context;
gapi_publisherQos *existing_qos;
GAPI_CONTEXT_SET(context, _this, GAPI_METHOD_SET_QOS);
publisher = gapi_publisherClaim(_this, &result);
if ( publisher && qos ) {
result = gapi_publisherQosIsConsistent(qos, &context);
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
if ((result == GAPI_RETCODE_OK ) && (_EntityEnabled(publisher))) {
existing_qos = gapi_publisherQos__alloc();
uResult = _PublisherGetQos(publisher, existing_qos);
result = kernelResultToApiResult(uResult);
if(result == GAPI_RETCODE_OK)
{
result = gapi_publisherQosCheckMutability(
qos,
existing_qos,
&context);
}
gapi_free(existing_qos);
}
if ( result == GAPI_RETCODE_OK ) {
publisherQos = u_publisherQosNew(NULL);
if (publisherQos) {
if ( copyPublisherQosIn(qos, publisherQos) ) {
uResult = u_entitySetQoS(_EntityUEntity(publisher),
(v_qos)(publisherQos) );
result = kernelResultToApiResult(uResult);
u_publisherQosFree(publisherQos);
} else {
result = GAPI_RETCODE_OUT_OF_RESOURCES;
}
} else {
result = GAPI_RETCODE_OUT_OF_RESOURCES;
}
}
_EntityRelease(publisher);
return result;
}
/* ReturnCode_t
* delete_contained_entities();
*/
gapi_returnCode_t
gapi_dataReaderView_delete_contained_entities (
gapi_dataReaderView _this)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
_DataReaderView datareaderview;
gapi_context context;
_Condition condition = NULL;
c_iter entities;
u_entity e;
u_result ur;
GAPI_CONTEXT_SET(context, _this, GAPI_METHOD_DELETE_CONTAINED_ENTITIES);
if ( _this != NULL ) {
datareaderview = gapi_dataReaderViewClaim(_this, &result);
if ( datareaderview != NULL ) {
if (!gapi_loanRegistry_is_empty(datareaderview->loanRegistry)) {
result = GAPI_RETCODE_PRECONDITION_NOT_MET;
} else {
entities = u_readerLookupQueries(U_READER_GET(datareaderview));
e = c_iterTakeFirst(entities);
while (e) {
condition = u_entityGetUserData(e);
if (condition) {
_ObjectReadClaimNotBusy(_Object(condition));
_ConditionFree(condition);
} else {
if (e == u_entity(datareaderview->uQuery)) {
datareaderview->uQuery = NULL;
ur = u_queryFree(u_query(e));
if (ur == U_RESULT_OK) {
result = GAPI_RETCODE_OK;
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
} else {
assert(condition);
result = GAPI_RETCODE_BAD_PARAMETER;
}
}
e = c_iterTakeFirst(entities);
}
c_iterFree(entities);
}
_EntityRelease(datareaderview);
} else {
result = GAPI_RETCODE_ALREADY_DELETED;
}
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
return result;
}
gapi_returnCode_t
gapi_dataReader_delete_view (
gapi_dataReader _this,
gapi_dataReaderView a_view)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
_DataReader datareader;
_DataReaderView view = NULL;
c_bool contains;
gapi_context context;
GAPI_CONTEXT_SET(context, _this, GAPI_METHOD_DELETE_DATAREADER);
datareader = gapi_dataReaderClaim(_this, &result);
if ( datareader != NULL ) {
view = gapi_dataReaderViewClaim(a_view, NULL);
if ( view != NULL ) {
contains = u_dataReaderContainsView(U_DATAREADER_GET(datareader),
U_DATAREADERVIEW_GET(view));
if (contains) {
if (_DataReaderViewPrepareDelete(view,&context)) {
_DataReaderViewFree(view);
view = NULL;
} else {
result = GAPI_RETCODE_PRECONDITION_NOT_MET;
}
} else {
result = GAPI_RETCODE_PRECONDITION_NOT_MET;
}
_EntityRelease(view);
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
_EntityRelease(datareader);
} else {
result = GAPI_RETCODE_ALREADY_DELETED;
}
return result;
}
gapi_returnCode_t
gapi_dataReader_set_qos (
gapi_dataReader _this,
const gapi_dataReaderQos *qos)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
u_result uResult;
_DataReader dataReader;
v_readerQos dataReaderQos;
gapi_context context;
GAPI_CONTEXT_SET(context, _this, GAPI_METHOD_SET_QOS);
dataReader = gapi_dataReaderClaim(_this, &result);
if ( dataReader ) {
if ( qos ) {
result = gapi_dataReaderQosIsConsistent(qos, &context);
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
}
if (( result == GAPI_RETCODE_OK ) && (_EntityEnabled(dataReader))){
gapi_dataReaderQos * existing_qos = gapi_dataReaderQos__alloc();
result = gapi_dataReaderQosCheckMutability(qos,
_DataReaderGetQos(dataReader,
existing_qos),
&context);
gapi_free(existing_qos);
}
if ( result == GAPI_RETCODE_OK ) {
dataReaderQos = u_readerQosNew(NULL);
if (dataReaderQos) {
if ( gapi_kernelReaderQosCopyIn(qos, dataReaderQos) ) {
uResult = u_entitySetQoS(_EntityUEntity(dataReader),
(v_qos)(dataReaderQos) );
result = kernelResultToApiResult(uResult);
u_readerQosFree(dataReaderQos);
} else {
result = GAPI_RETCODE_OUT_OF_RESOURCES;
}
} else {
result = GAPI_RETCODE_OUT_OF_RESOURCES;
}
}
_EntityRelease(dataReader);
return result;
}
