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;
}
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_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_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_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_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;
}
gapi_returnCode_t
gapi_publisher_get_qos (
gapi_publisher _this,
gapi_publisherQos *qos)
{
_Publisher publisher;
gapi_returnCode_t result;
publisher = gapi_publisherClaim(_this, &result);
if ( publisher && qos ) {
_PublisherGetQos(publisher, qos);
}
_EntityRelease(publisher);
return result ;
}
gapi_domainParticipant
gapi_publisher_get_participant (
gapi_publisher _this)
{
_Publisher publisher;
_DomainParticipant participant = NULL;
publisher = gapi_publisherClaim(_this, NULL);
if ( publisher != NULL ) {
participant = _EntityParticipant(_Entity(publisher));
}
_EntityRelease(publisher);
return (gapi_domainParticipant)_EntityHandle(participant);
}
struct gapi_publisherListener
gapi_publisher_get_listener (
gapi_publisher _this)
{
_Publisher publisher;
struct gapi_publisherListener listener;
publisher = gapi_publisherClaim(_this, NULL);
if ( publisher != NULL ) {
listener = publisher->_Listener;
} else {
memset(&listener, 0, sizeof(listener));
}
_EntityRelease(publisher);
return listener;
}
gapi_returnCode_t
gapi_publisher_get_default_datawriter_qos (
gapi_publisher _this,
gapi_dataWriterQos *qos)
{
_Publisher publisher;
gapi_returnCode_t result;
publisher = gapi_publisherClaim(_this, &result);
if (result == GAPI_RETCODE_OK) {
if (qos) {
gapi_dataWriterQosCopy (&publisher->_defDataWriterQos, qos);
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
_EntityRelease(publisher);
}
return result;
}
gapi_returnCode_t
gapi_publisher_end_coherent_changes (
gapi_publisher _this)
{
_Publisher publisher;
gapi_returnCode_t result = GAPI_RETCODE_BAD_PARAMETER;
u_result uResult;
publisher = gapi_publisherClaim(_this, &result);
if ( publisher != NULL ) {
if ( _EntityEnabled(publisher)) {
uResult = u_publisherCoherentEnd(U_PUBLISHER_GET(publisher));
result = kernelResultToApiResult(uResult);
} else {
result = GAPI_RETCODE_NOT_ENABLED;
}
}
_EntityRelease(publisher);
return result;
}
gapi_returnCode_t
gapi_publisher_copy_from_topic_qos (
gapi_publisher _this,
gapi_dataWriterQos *a_datawriter_qos,
const gapi_topicQos *a_topic_qos)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
_Publisher publisher;
publisher = gapi_publisherClaim(_this, &result);
if ( publisher != NULL ) {
if ( (a_topic_qos != GAPI_TOPIC_QOS_DEFAULT) &&
(a_datawriter_qos != GAPI_DATAWRITER_QOS_DEFAULT) ) {
gapi_mergeTopicQosWithDataWriterQos(a_topic_qos, a_datawriter_qos);
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
}
_EntityRelease(publisher);
return result;
}
gapi_dataWriter
gapi_publisher_create_datawriter (
gapi_publisher _this,
const gapi_topic a_topic,
const gapi_dataWriterQos *qos,
const struct gapi_dataWriterListener *a_listener,
const gapi_statusMask mask)
{
_Publisher publisher;
_DataWriter datawriter = NULL;
gapi_dataWriter result = NULL;
_Topic topic = NULL;
gapi_dataWriterQos *writerQos;
gapi_context context;
gapi_topicQos* topicQos;
gapi_returnCode_t rc;
GAPI_CONTEXT_SET(context, _this, GAPI_METHOD_CREATE_DATAWRITER);
publisher = gapi_publisherClaim(_this, NULL);
if ( publisher ) {
topic = _TopicFromHandle(a_topic);
}
if ( topic ) {
if ( qos == GAPI_DATAWRITER_QOS_DEFAULT ) {
writerQos = &publisher->_defDataWriterQos;
} else if ( qos == GAPI_DATAWRITER_QOS_USE_TOPIC_QOS ) {
topicQos = gapi_topicQos__alloc();
writerQos = gapi_dataWriterQos__alloc();
gapi_dataWriterQosCopy(&publisher->_defDataWriterQos, writerQos);
_TopicGetQos(topic, topicQos);
gapi_mergeTopicQosWithDataWriterQos(topicQos,writerQos);
gapi_free(topicQos);
} else {
writerQos = (gapi_dataWriterQos *)qos;
}
rc = gapi_dataWriterQosIsConsistent(writerQos, &context);
if ( rc == GAPI_RETCODE_OK ) {
gapi_char *typeName;
gapi_char *topicName;
_DomainParticipant participant;
_TypeSupport typeSupport = NULL;
/* find topic with the participant for consistency */
typeName = _TopicGetTypeName(topic);
topicName = _TopicGetName(topic);
participant = _EntityParticipant(_Entity(publisher));
/* find type support for the data type to find data writer create function */
typeSupport = _DomainParticipantFindType(participant, typeName);
if(typeSupport)
{
/* if create function is NULL, take default from data writer */
datawriter = _DataWriterNew(topic,
typeSupport,
writerQos,
a_listener,
mask,
publisher);
if ( datawriter ) {
_ENTITY_REGISTER_OBJECT(_Entity(publisher),
(_Object)datawriter);
}
}else{
OS_REPORT_1(OS_WARNING,
"gapi_publisher_create_datawriter", 0,
"TypeSupport %s not found !",
typeName);
}
gapi_free(typeName);
gapi_free(topicName);
}
if (qos == GAPI_DATAWRITER_QOS_USE_TOPIC_QOS) {
gapi_free(writerQos);
}
}
_EntityRelease(publisher);
if ( datawriter ) {
gapi_object statusHandle;
statusHandle = _EntityHandle(_Entity(datawriter)->status);
result = (gapi_dataWriter)_EntityRelease(datawriter);
}
return result;
}
