static u_result create_builtin_readers (struct builtin_datareader_set *drset, u_participant p)
{
v_subscriberQos sQos = NULL;
v_readerQos rdQos = NULL;
v_gid gid;
c_value ps[1];
drset->subscriber = NULL;
drset->participant_dr = NULL;
drset->subscription_dr = NULL;
drset->publication_dr = NULL;
if ((sQos = u_subscriberQosNew (NULL)) == NULL)
goto fail;
sQos->presentation.access_scope = V_PRESENTATION_TOPIC;
if ((sQos->partition = os_strdup ("__BUILT-IN PARTITION__")) == NULL)
goto fail;
if ((rdQos = u_readerQosNew (NULL)) == NULL)
goto fail;
rdQos->durability.kind = V_DURABILITY_TRANSIENT;
rdQos->reliability.kind = V_RELIABILITY_RELIABLE;
rdQos->history.kind = V_HISTORY_KEEPLAST;
rdQos->history.depth = 1;
if ((drset->subscriber = u_subscriberNew (p, "DDSI2BuiltinSubscriber", sQos, TRUE)) == NULL)
goto fail;
gid = u_entityGid ((u_entity) drset->subscriber);
ps[0].kind = V_ULONG;
ps[0].is.ULong = gid.systemId;
in_printf (IN_LEVEL_INFO, "create_builtin_readers: systemId = %lx\n", (unsigned long) ps[0].is.ULong);
if ((drset->participant_dr = u_subscriberCreateDataReader (drset->subscriber, "DCPSParticipantReader", "select * from DCPSParticipant where key.systemId = %0", ps, rdQos, TRUE)) == NULL)
goto fail;
if ((drset->subscription_dr = u_subscriberCreateDataReader (drset->subscriber, "DCPSSubscriptionReader", "select * from DCPSSubscription where key.systemId = %0", ps, rdQos, TRUE)) == NULL)
goto fail;
if ((drset->publication_dr = u_subscriberCreateDataReader (drset->subscriber, "DCPSPublicationReader", "select * from DCPSPublication where key.systemId = %0", ps, rdQos, TRUE)) == NULL)
goto fail;
u_readerQosFree (rdQos);
u_subscriberQosFree (sQos);
return U_RESULT_OK;
fail:
destroy_builtin_readers (drset);
if (rdQos)
u_readerQosFree (rdQos);
if (sQos)
u_subscriberQosFree (sQos);
return U_RESULT_INTERNAL_ERROR;
}
gapi_returnCode_t
gapi_subscriber_set_qos (
gapi_subscriber _this,
const gapi_subscriberQos *qos)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
u_result uResult;
_Subscriber subscriber;
v_subscriberQos subscriberQos;
gapi_context context;
GAPI_CONTEXT_SET(context, _this, GAPI_METHOD_SET_QOS);
subscriber = gapi_subscriberClaim(_this, &result);
if ( subscriber && qos ) {
result = gapi_subscriberQosIsConsistent(qos, &context);
} else {
result = GAPI_RETCODE_BAD_PARAMETER;
}
if ((result == GAPI_RETCODE_OK ) && (_EntityEnabled(subscriber))) {
gapi_subscriberQos * existing_qos = gapi_subscriberQos__alloc();
result = gapi_subscriberQosCheckMutability(qos,
_SubscriberGetQos(subscriber,
existing_qos),
&context);
gapi_free(existing_qos);
}
if ( result == GAPI_RETCODE_OK ) {
subscriberQos = u_subscriberQosNew(NULL);
if (subscriberQos) {
if ( copySubscriberQosIn(qos, subscriberQos) ) {
uResult = u_entitySetQoS(_EntityUEntity(subscriber),
(v_qos)(subscriberQos) );
result = kernelResultToApiResult(uResult);
} else {
result = GAPI_RETCODE_OUT_OF_RESOURCES;
}
u_subscriberQosFree(subscriberQos);
} else {
result = GAPI_RETCODE_OUT_OF_RESOURCES;
}
}
_EntityRelease(subscriber);
return result;
}
void
SubscriberDelegate::qos(const dds::sub::qos::SubscriberQos& sqos)
{
org::opensplice::core::ScopedObjectLock scopedLock(*this);
u_subscriberQos uQos;
u_result uResult;
sqos.delegate().check();
uQos = sqos.delegate().u_qos();
if (!uQos) {
ISOCPP_THROW_EXCEPTION(ISOCPP_ERROR, "Could not convert subscriber qos.");
}
uResult = u_subscriberSetQos(u_subscriber(this->userHandle), uQos);
u_subscriberQosFree(uQos);
ISOCPP_U_RESULT_CHECK_AND_THROW(uResult, "Could not set subscriber qos.");
this->qos_ = sqos;
}
gapi_subscriberQos *
_SubscriberGetQos (
_Subscriber subscriber,
gapi_subscriberQos *qos)
{
v_subscriberQos subscriberQos;
u_subscriber uSubscriber;
assert(subscriber);
uSubscriber = U_SUBSCRIBER_GET(subscriber);
if ( u_entityQoS(u_entity(uSubscriber), (v_qos*)&subscriberQos) == U_RESULT_OK ) {
copySubscriberQosOut(subscriberQos, qos);
u_subscriberQosFree(subscriberQos);
}
return qos;
}
SubscriberDelegate::SubscriberDelegate(
const dds::domain::DomainParticipant& dp,
const dds::sub::qos::SubscriberQos& qos,
dds::sub::SubscriberListener* listener,
const dds::core::status::StatusMask& event_mask) :
dp_(dp),
qos_(qos)
{
ISOCPP_REPORT_STACK_DDS_BEGIN(dp);
u_subscriber uSub;
u_participant uPar;
u_subscriberQos uQos;
uPar = u_participant(this->dp_.delegate()->get_user_handle());
if (!uPar) {
ISOCPP_THROW_EXCEPTION(ISOCPP_ERROR, "Could not get subscriber participant.");
}
qos.delegate().check();
uQos = qos.delegate().u_qos();
if (!uQos) {
ISOCPP_THROW_EXCEPTION(ISOCPP_ERROR, "Could not convert subscriber QoS.");
}
std::string name = this->dp_.delegate()->create_child_name("subscriber");
uSub = u_subscriberNew(uPar, name.c_str(), uQos);
u_subscriberQosFree (uQos);
if (!uSub) {
ISOCPP_THROW_EXCEPTION(ISOCPP_ERROR, "Could not create subscriber.");
}
/* ObjectDelegate class will free the userlayer object in its destructor. */
this->userHandle = u_object(uSub);
this->listener_set((void*)listener, event_mask);
set_domain_id(dp.delegate()->get_domain_id());
}
_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;
}
