c_char*
cmx_publisherNew(
const c_char* participant,
const c_char* name,
const c_char* qos)
{
u_participant par;
u_publisher pub;
c_char* result;
cmx_entityArg arg;
u_result ur;
v_publisherQos pqos;
cmx_entityKernelArg kernelArg;
result = NULL;
par = u_participant(cmx_entityUserEntity(participant));
if(par != NULL){
kernelArg = cmx_entityKernelArg(os_malloc(C_SIZEOF(cmx_entityKernelArg)));
u_entityAction(u_entity(par), cmx_entityKernelAction, (c_voidp)kernelArg);
if(qos != NULL){
pqos = v_publisherQos(cmx_qosKernelQosFromKind(qos, K_PUBLISHER, c_getBase(c_object(kernelArg->kernel))));
if(pqos == NULL){
pqos = v_publisherQosNew(kernelArg->kernel, NULL);
}
} else {
pqos = v_publisherQosNew(kernelArg->kernel, NULL);
}
pub = u_publisherNew(par, name, pqos, TRUE);
os_free(kernelArg);
c_free(pqos);
if(pub != NULL){
cmx_registerEntity(u_entity(pub));
arg = cmx_entityArg(os_malloc(C_SIZEOF(cmx_entityArg)));
arg->entity = u_entity(pub);
arg->create = FALSE;
arg->participant = NULL;
arg->result = NULL;
ur = u_entityAction(u_entity(pub), cmx_entityNewFromAction, (c_voidp)(arg));
if(ur == U_RESULT_OK){
result = arg->result;
os_free(arg);
}
}
}
return result;
}
PublisherDelegate::PublisherDelegate(const dds::domain::DomainParticipant& dp,
const dds::pub::qos::PublisherQos& qos,
dds::pub::PublisherListener* listener,
const dds::core::status::StatusMask& event_mask)
: dp_(dp),
qos_(qos),
default_dwqos_()
{
ISOCPP_REPORT_STACK_DDS_BEGIN(dp);
u_publisher uPub;
u_participant uPar;
u_publisherQos uQos;
uPar = u_participant(this->dp_.delegate()->get_user_handle());
if (!uPar) {
ISOCPP_THROW_EXCEPTION(ISOCPP_ERROR, "Could not get publisher participant.");
}
qos.delegate().check();
uQos = qos.delegate().u_qos();
if (!uQos) {
ISOCPP_THROW_EXCEPTION(ISOCPP_ERROR, "Could not convert publisher QoS.");
}
std::string name = this->dp_.delegate()->create_child_name("publisher");
uPub = u_publisherNew(uPar, name.c_str(), uQos, false);
u_publisherQosFree (uQos);
if (!uPub) {
ISOCPP_THROW_EXCEPTION(ISOCPP_ERROR, "Could not create publisher.");
}
/* ObjectDelegate class will free the userlayer object in its destructor. */
this->userHandle = u_object(uPub);
this->listener_set((void*)listener, event_mask);
set_domain_id(dp.delegate()->get_domain_id());
}
d_publisher
d_publisherNew(
d_admin admin)
{
d_publisher publisher;
d_durability durability;
d_configuration config;
v_publisherQos publisherQos;
v_writerQos writerQos;
publisher = NULL;
if(admin){
publisher = d_publisher(os_malloc(C_SIZEOF(d_publisher)));
d_objectInit(d_object(publisher), D_PUBLISHER, d_publisherDeinit);
publisher->enabled = TRUE;
publisher->admin = admin;
durability = d_adminGetDurability(admin);
config = d_durabilityGetConfiguration(durability);
publisherQos = d_publisherQosNew(config->partitionName);
publisher->publisher = u_publisherNew(
u_participant(d_durabilityGetService(durability)),
config->publisherName, publisherQos, TRUE);
d_publisherQosFree(publisherQos);
if(publisher->publisher){
publisher->statusWriter = NULL;
publisher->newGroupWriter = NULL;
publisher->groupsRequestWriter = NULL;
publisher->statusRequestWriter = NULL;
publisher->sampleRequestWriter = NULL;
publisher->sampleChainWriter = NULL;
publisher->nameSpacesWriter = NULL;
publisher->nameSpacesRequestWriter = NULL;
publisher->deleteDataWriter = NULL;
writerQos = d_writerQosNew(
V_DURABILITY_VOLATILE,
V_RELIABILITY_RELIABLE,
config->heartbeatLatencyBudget,
config->heartbeatTransportPriority);
publisher->statusNumber = 0;
publisher->statusWriter = u_writerNew (publisher->publisher,
"statusWriter",
d_adminGetStatusTopic(admin),
d_publisherStatusWriterCopy,
writerQos,
TRUE);
assert(publisher->statusWriter);
d_writerQosFree(writerQos);
writerQos = d_writerQosNew (V_DURABILITY_VOLATILE,
V_RELIABILITY_RELIABLE,
config->latencyBudget,
config->transportPriority);
u_entityAction(u_entity(publisher->statusWriter), d_publisherEnsureServicesAttached, durability);
publisher->newGroupNumber = 0;
publisher->newGroupWriter = u_writerNew (publisher->publisher,
"newGroupWriter",
d_adminGetNewGroupTopic(admin),
d_publisherNewGroupWriterCopy,
writerQos,
TRUE);
assert(publisher->newGroupWriter);
u_entityAction(u_entity(publisher->newGroupWriter), d_publisherEnsureServicesAttached, durability);
publisher->groupsRequestNumber = 0;
publisher->groupsRequestWriter = u_writerNew (publisher->publisher,
"groupsRequestWriter",
d_adminGetGroupsRequestTopic(admin),
d_publisherGroupsRequestWriterCopy,
writerQos,
TRUE);
assert(publisher->groupsRequestWriter);
u_entityAction(u_entity(publisher->groupsRequestWriter), d_publisherEnsureServicesAttached, durability);
publisher->statusRequestNumber = 0;
publisher->statusRequestWriter = u_writerNew (publisher->publisher,
"statusRequestWriter",
d_adminGetStatusRequestTopic(admin),
d_publisherStatusRequestWriterCopy,
writerQos,
TRUE);
assert(publisher->statusRequestWriter);
u_entityAction(u_entity(publisher->statusRequestWriter), d_publisherEnsureServicesAttached, durability);
publisher->sampleRequestNumber = 0;
publisher->sampleRequestWriter = u_writerNew (publisher->publisher,
"sampleRequestWriter",
d_adminGetSampleRequestTopic(admin),
d_publisherSampleRequestWriterCopy,
writerQos,
TRUE);
assert(publisher->sampleRequestWriter);
u_entityAction(u_entity(publisher->sampleRequestWriter), d_publisherEnsureServicesAttached, durability);
publisher->nameSpacesNumber = 0;
publisher->nameSpacesWriter = u_writerNew (publisher->publisher,
"nameSpacesWriter",
d_adminGetNameSpacesTopic(admin),
d_publisherNameSpacesWriterCopy,
writerQos,
TRUE);
assert(publisher->nameSpacesWriter);
u_entityAction(u_entity(publisher->nameSpacesWriter), d_publisherEnsureServicesAttached, durability);
publisher->nameSpacesRequestNumber = 0;
publisher->nameSpacesRequestWriter = u_writerNew (publisher->publisher,
"nameSpacesRequestWriter",
d_adminGetNameSpacesRequestTopic(admin),
d_publisherNameSpacesRequestWriterCopy,
writerQos,
TRUE);
assert(publisher->nameSpacesRequestWriter);
u_entityAction(u_entity(publisher->nameSpacesRequestWriter), d_publisherEnsureServicesAttached, durability);
publisher->deleteDataNumber = 0;
publisher->deleteDataWriter = u_writerNew (publisher->publisher,
"deleteDataWriter",
d_adminGetDeleteDataTopic(admin),
d_publisherDeleteDataWriterCopy,
writerQos,
TRUE);
assert(publisher->deleteDataWriter);
u_entityAction(u_entity(publisher->deleteDataWriter), d_publisherEnsureServicesAttached, durability);
d_writerQosFree(writerQos);
writerQos = d_writerQosNew (V_DURABILITY_VOLATILE,
V_RELIABILITY_RELIABLE,
config->alignerLatencyBudget,
config->alignerTransportPriority);
publisher->sampleChainNumber = 0;
publisher->sampleChainWriter = u_writerNew (publisher->publisher,
"sampleChainWriter",
d_adminGetSampleChainTopic(admin),
d_publisherSampleChainWriterCopy,
writerQos,
TRUE);
assert(publisher->sampleChainWriter);
u_entityAction(u_entity(publisher->sampleChainWriter), d_publisherEnsureServicesAttached, durability);
d_writerQosFree(writerQos);
} else {
d_publisherFree(publisher);
publisher = NULL;
}
}
return publisher;
}
_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;
}
