_DataReaderView
_DataReaderViewNew (
const gapi_dataReaderViewQos * qos,
const _DataReader datareader)
{
_DataReaderView _this;
v_dataViewQos ViewQos;
u_dataView uReaderView;
_TypeSupport typeSupport;
_this = _DataReaderViewAlloc();
if ( _this != NULL ) {
_EntityInit(_Entity(_this),
_Entity(datareader));
typeSupport = _TopicDescriptionGetTypeSupport(datareader->topicDescription);
assert(typeSupport);
_this->datareader = datareader;
ViewQos = u_dataViewQosNew(NULL);
if ( ViewQos != NULL ) {
if ( !copyReaderViewQosIn(qos, ViewQos) ) {
u_dataViewQosFree(ViewQos);
_EntityDispose(_Entity(_this));
_this = NULL;
}
} else {
_EntityDispose(_Entity(_this));
_this = NULL;
}
}
if ( _this != NULL ) {
uReaderView = u_dataViewNew(u_dataReader(_EntityUEntity (datareader)),
"dataReaderView",
ViewQos);
if ( uReaderView ) {
U_DATAREADERVIEW_SET(_this, uReaderView);
} else {
_EntityDispose(_Entity(_this));
_this = NULL;
}
u_dataViewQosFree(ViewQos);
}
if ( _this != NULL ) {
if ( !initViewQuery(_this) ) {
u_dataViewFree(uReaderView);
_EntityDispose(_Entity(_this));
_this = NULL;
}
}
if ( _this != NULL ) {
_EntityStatus(_this) = _Entity(datareader)->status;
}
return _this;
}
gapi_returnCode_t
_PublisherFree (
_Publisher _this)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
_Status status;
u_publisher p;
assert(_this);
status = _EntityStatus(_this);
_StatusSetListener(status, NULL, 0);
_EntityClaim(status);
_StatusDeinit(status);
gapi_dataWriterQos_free(&_this->_defDataWriterQos);
p = U_PUBLISHER_GET(_this);
_EntityDispose (_Entity(_this));
if (u_publisherFree(p) != U_RESULT_OK) {
result = GAPI_RETCODE_ERROR;
}
return result;
}
gapi_returnCode_t
_SubscriberFree (
_Subscriber subscriber)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
_Status status;
u_subscriber s;
assert(subscriber);
status = _EntityStatus(subscriber);
_StatusSetListener(status, NULL, 0);
_EntityClaim(status);
_StatusDeinit(status);
gapi_dataReaderQos_free(&subscriber->_defDataReaderQos);
s = U_SUBSCRIBER_GET(subscriber);
_EntityDispose(_Entity(subscriber));
if (u_subscriberFree(s) != U_RESULT_OK) {
result = GAPI_RETCODE_ERROR;
}
return result;
}
void
_TopicDescriptionDispose (
_TopicDescription topicDescription)
{
gapi_free (topicDescription->topic_name);
gapi_free (topicDescription->type_name);
q_dispose(topicDescription->expr);
topicDescription->topic_name = NULL;
topicDescription->type_name = NULL;
topicDescription->expr = NULL;
_EntityDispose(_Entity(topicDescription));
}
void
_BuiltinSubscriberFree (
_Subscriber subscriber)
{
_Status status;
assert(subscriber != NULL);
status = _EntityStatus(subscriber);
_StatusSetListener(status, NULL, 0);
_EntityClaim(status);
_StatusDeinit(status);
u_subscriberFree(U_SUBSCRIBER_GET(subscriber));
_EntityDispose(_Entity(subscriber));
}
gapi_returnCode_t
_DataReaderViewFree (
_DataReaderView dataReaderView)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
u_dataView v;
assert(dataReaderView);
u_queryFree(dataReaderView->uQuery);
gapi_loanRegistry_free(dataReaderView->loanRegistry);
v = U_DATAREADERVIEW_GET(dataReaderView);
_EntityDispose (_Entity(dataReaderView));
u_dataViewFree(v);
return result;
}
gapi_returnCode_t
_DataReaderFree (
_DataReader _this)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
_Status status;
u_dataReader r;
assert(_this);
/* The following refCount checking and destruction mechanism is not
* bullet proof and may cause leakage.
* This is a temporary situation during GAPI redesign and should be
* resolved when the GAPI redesign is finished.
*/
r = U_DATAREADER_GET(_this);
_TopicDescriptionDecUse(_this->topicDescription);
status = _EntityStatus(_this);
_StatusSetListener(status, NULL, 0);
_EntityClaim(status);
_StatusDeinit(status);
gapi_loanRegistry_free(_this->loanRegistry);
/* Following the user layer reader object is deleted after the entity
* dispose because it will otherwise lead to a double free of the user
* layer reader.
* This is caused by the status condition which is attached to an exiting
* waitset and the fact that a status condition's user object is the user
* layer reader.
* This is a hack but besides of that the destruction of the user entity
* should be part of the entity dispose method.
* For now this works.
*/
_EntityDispose(_Entity(_this));
u_dataReaderFree(r);
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;
}
_DataWriter
_DataWriterNew (
const _Topic topic,
const _TypeSupport typesupport,
const gapi_dataWriterQos *qos,
const struct gapi_dataWriterListener *a_listener,
const gapi_statusMask mask,
const _Publisher publisher)
{
_DataWriter newDataWriter;
v_writerQos writerQos;
u_writer uWriter;
_TypeSupport typeSupport = (_TypeSupport)typesupport;
char dataWriterId[256];
gapi_string topicName;
newDataWriter = _DataWriterAlloc();
if ( newDataWriter != NULL ) {
_EntityInit(_Entity(newDataWriter),
_Entity(publisher));
newDataWriter->topic = topic;
if ( a_listener ) {
newDataWriter->listener = *a_listener;
}
writerQos = u_writerQosNew(NULL);
if ( (writerQos != NULL) ) {
if ( !copyWriterQosIn(qos, writerQos) ) {
u_writerQosFree (writerQos);
_EntityDispose(_Entity(newDataWriter));
newDataWriter = NULL;
}
} else {
_EntityDispose(_Entity(newDataWriter));
newDataWriter = NULL;
}
}
if ( newDataWriter != NULL ) {
u_writerCopy copy_action;
newDataWriter->copy_in = _TypeSupportCopyIn(typeSupport);
newDataWriter->copy_out = _TypeSupportCopyOut(typeSupport);
newDataWriter->copy_cache = _TypeSupportCopyCache(typeSupport);
copy_action = _TypeSupportGetWriterCopy(typeSupport);
if (!copy_action) {
copy_action = _DataWriterCopy;
}
topicName = _TopicDescriptionGetName (_TopicDescription(topic));
if (topicName) {
snprintf (dataWriterId,
sizeof (dataWriterId),
"%sWriter", topicName);
gapi_free (topicName);
} else {
snprintf (dataWriterId,
sizeof (dataWriterId),
"dataWriter");
}
uWriter = u_writerNew(_PublisherUpublisher(publisher),
dataWriterId,
_TopicUtopic(topic),
copy_action,
writerQos,
FALSE);
if ( uWriter != NULL ) {
U_WRITER_SET(newDataWriter, uWriter);
} else {
_EntityDispose(_Entity(newDataWriter));
newDataWriter = NULL;
}
u_writerQosFree(writerQos);
}
if ( newDataWriter != NULL ) {
_Status status;
status = _StatusNew(_Entity(newDataWriter),
STATUS_KIND_DATAWRITER,
(struct gapi_listener *)a_listener, mask);
_EntityStatus(newDataWriter) = status;
if (status) {
_TopicDescriptionIncUse(_TopicDescription(topic));
} else {
u_writerFree(uWriter);
_EntityDispose(_Entity(newDataWriter));
newDataWriter = NULL;
}
}
return newDataWriter;
}
_Publisher
_PublisherNew (
u_participant uParticipant,
const gapi_publisherQos *qos,
const struct gapi_publisherListener *a_listener,
const gapi_statusMask mask,
const _DomainParticipant participant)
{
v_publisherQos publisherQos;
_Publisher newPublisher;
assert(uParticipant);
assert(qos);
assert(participant);
newPublisher = _PublisherAlloc();
if ( newPublisher ) {
_EntityInit (_Entity(newPublisher),
_Entity(participant));
gapi_dataWriterQosCopy (&gapi_dataWriterQosDefault,
&newPublisher->_defDataWriterQos);
if ( a_listener ) {
newPublisher->_Listener = *a_listener;
}
}
if ( newPublisher ) {
publisherQos = u_publisherQosNew(NULL);
if ( publisherQos ) {
if ( !copyPublisherQosIn(qos, publisherQos)) {
_EntityDispose(_Entity(newPublisher));
newPublisher = NULL;
}
} else {
_EntityDispose(_Entity(newPublisher));
newPublisher = NULL;
}
}
if ( newPublisher ) {
u_publisher uPublisher;
uPublisher = u_publisherNew (uParticipant,
"publisher",
publisherQos,
FALSE);
u_publisherQosFree(publisherQos);
if ( uPublisher ) {
U_PUBLISHER_SET(newPublisher, uPublisher);
} else {
_EntityDispose(_Entity(newPublisher));
newPublisher = NULL;
}
}
if ( newPublisher ) {
_Status status;
status = _StatusNew(_Entity(newPublisher),
STATUS_KIND_PUBLISHER,
(struct gapi_listener *)a_listener, mask);
if (status) {
_EntityStatus(newPublisher) = status;
if ( qos->partition.name._length == 0 ) {
/*
* behaviour of the kernel in case of an empty sequence
* is that it is related to none of the partitions,
* while DCPS expects it to be conected to all partitions.
* Therefore this has to be done seperately.
*/
u_publisherPublish (U_PUBLISHER_GET(newPublisher), "");
}
} else {
u_publisherFree(U_PUBLISHER_GET(newPublisher));
_EntityDispose(_Entity(newPublisher));
newPublisher = NULL;
}
}
return newPublisher;
}
_Subscriber
_BuiltinSubscriberNew (
u_participant uParticipant,
_DomainParticipantFactory factory,
_DomainParticipant participant)
{
u_subscriber s;
_Status status;
_Subscriber newSubscriber = _SubscriberAlloc();
gapi_handle handle;
_TypeSupport typeSupport;
gapi_dataReaderQos rQos;
long i;
s = u_participantGetBuiltinSubscriber(uParticipant);
if (s) {
newSubscriber = _SubscriberAlloc();
if (newSubscriber != NULL) {
_EntityInit(_Entity(newSubscriber), _Entity(participant));
U_SUBSCRIBER_SET(newSubscriber, s);
status = _StatusNew(_Entity(newSubscriber),
STATUS_KIND_SUBSCRIBER,
NULL, 0);
if (status) {
for ( i = 0; i < MAX_BUILTIN_TOPIC; i++ ) {
_DataReader reader = NULL;
_Topic topic = NULL;
typeSupport = _DomainParticipantFindTypeSupport(participant,
_BuiltinTopicTypeName(i));
if (typeSupport) {
c_iter uTopicList;
u_topic uTopic;
uTopicList = u_participantFindTopic(uParticipant,
_BuiltinTopicName(i),
C_TIME_ZERO);
uTopic = c_iterTakeFirst(uTopicList);
if (uTopic) {
topic = _TopicFromKernelTopic(uTopic,
_BuiltinTopicName(i),
_BuiltinTopicTypeName(i),
typeSupport,
participant,
NULL);
while (uTopic) {
uTopic = c_iterTakeFirst(uTopicList);
/* multiple instances should not occure but
* just in case this loop frees all references.
*/
assert(uTopic == NULL);
u_entityFree(u_entity(uTopic));
}
} else {
OS_REPORT_2(OS_WARNING,"_BuiltinSubscriberNew",0,
"failed to resolve User layer Topic "
"'%s' for Participant 0x%x",
_BuiltinTopicName(i), participant);
}
} else {
OS_REPORT_2(OS_WARNING,"_BuiltinSubscriberNew",0,
"Builtin TypeSupport for type '%s' is not "
"yet registered for Participant 0x%x",
_BuiltinTopicTypeName(i), participant);
}
if (topic) {
initBuiltinDataReaderQos(&rQos);
reader = _DataReaderNew(_TopicDescription(topic),
typeSupport,
&rQos,
NULL, 0,
newSubscriber);
_EntityRelease(topic);
} else {
OS_REPORT_2(OS_WARNING,"_BuiltinSubscriberNew",0,
"failed to create Builtin Topic '%s' "
"for Participant 0x%x",
_BuiltinTopicName(i), participant);
}
if ( reader ) {
_ENTITY_REGISTER_OBJECT(_Entity(newSubscriber),
(_Object)reader);
handle = _EntityRelease(reader);
gapi_entity_enable(handle);
}
}
newSubscriber->builtin = TRUE;
_EntityStatus(newSubscriber) = status;
} else {
_EntityDispose(_Entity(newSubscriber));
newSubscriber = NULL;
}
}
}
return newSubscriber;
}
_DataReader
_DataReaderNew (
const _TopicDescription topicDescription,
const _TypeSupport typesupport,
const gapi_dataReaderQos *qos,
const struct gapi_dataReaderListener *a_listener,
const gapi_statusMask mask,
const _Subscriber subscriber)
{
_DataReader _this;
v_readerQos readerQos;
u_dataReader uReader;
gapi_string topicName;
char dataReaderId[256];
c_bool noError = TRUE;
readerQos = u_readerQosNew(NULL);
if ( readerQos != NULL ) {
if ( gapi_kernelReaderQosCopyIn(qos, readerQos) ) {
q_expr expr;
c_value *params;
topicName = _TopicDescriptionGetName (topicDescription);
if (topicName) {
snprintf (dataReaderId,
sizeof(dataReaderId),
"%sReader", topicName);
gapi_free (topicName);
} else {
snprintf (dataReaderId,
sizeof(dataReaderId),
"dataReader");
}
expr = _TopicDescriptionGetExpr(topicDescription);
if (_ObjectGetKind(_Object(topicDescription)) ==
OBJECT_KIND_CONTENTFILTEREDTOPIC) {
params = _ContentFilteredTopicParameters(
(_ContentFilteredTopic)topicDescription);
} else {
params = NULL;
}
uReader = u_dataReaderNew(_SubscriberUsubscriber(subscriber),
dataReaderId,
expr,
params,
readerQos,
FALSE);
q_dispose(expr);
os_free(params);
noError = (uReader != NULL);
if (noError) {
_this = _DataReaderAlloc();
if ( _this != NULL ) {
noError = _DataReaderInit(_this,
subscriber,
topicDescription,
typesupport,
a_listener,
mask,
uReader);
if (!noError) {
_EntityDispose(_Entity(_this));
}
}
if (!noError) {
u_dataReaderFree(uReader);
}
}
} else {
noError = FALSE;
}
u_readerQosFree(readerQos);
} else {
noError = FALSE;
}
if (!noError) {
_this = NULL;
}
return _this;
}
_Subscriber
_SubscriberNew (
u_participant uParticipant,
const gapi_subscriberQos *qos,
const struct gapi_subscriberListener *a_listener,
const gapi_statusMask mask,
const _DomainParticipant participant)
{
_Subscriber newSubscriber;
v_subscriberQos subscriberQos;
gapi_long len;
assert(uParticipant);
assert(qos);
assert(participant);
newSubscriber = _SubscriberAlloc();
if ( newSubscriber != NULL ) {
_EntityInit(_Entity(newSubscriber),
_Entity(participant));
gapi_dataReaderQosCopy (&gapi_dataReaderQosDefault,
&newSubscriber->_defDataReaderQos);
if ( a_listener ) {
newSubscriber->_Listener = *a_listener;
}
}
if (newSubscriber != NULL ) {
subscriberQos = u_subscriberQosNew(NULL);
if ( subscriberQos != NULL ) {
if ( !copySubscriberQosIn(qos, subscriberQos) ) {
_EntityDispose(_Entity(newSubscriber));
newSubscriber = NULL;
}
} else {
_EntityDispose(_Entity(newSubscriber));
newSubscriber = NULL;
}
}
if ( newSubscriber != NULL) {
u_subscriber uSubscriber;
uSubscriber = u_subscriberNew(uParticipant, "subscriber", subscriberQos, FALSE);
u_subscriberQosFree(subscriberQos);
if ( uSubscriber != NULL ) {
U_SUBSCRIBER_SET(newSubscriber, uSubscriber);
} else {
_EntityDispose(_Entity(newSubscriber));
newSubscriber = NULL;
}
}
if ( newSubscriber != NULL) {
_Status status;
status = _StatusNew(_Entity(newSubscriber),
STATUS_KIND_SUBSCRIBER,
(struct gapi_listener *)a_listener, mask);
if (status) {
_EntityStatus(newSubscriber) = status;
len = (gapi_long)qos->partition.name._length;
if ( qos->partition.name._length == 0UL ) {
/*
* behaviour of the kernel in case of an empty sequence
* is that it is related to none of the partitions,
* while DCPS expects it to be conected to all partitions.
* Therefore this has to be done seperately.
*/
u_subscriberSubscribe (U_SUBSCRIBER_GET(newSubscriber), "");
}
newSubscriber->builtin = FALSE;
} else {
u_subscriberFree(U_SUBSCRIBER_GET(newSubscriber));
_EntityDispose(_Entity(newSubscriber));
newSubscriber = NULL;
}
}
return newSubscriber;
}
