Esempio n. 1
0
Publisher* ParticipantImpl::createPublisher(PublisherAttributes& att,
		PublisherListener* listen)
{
	const char* const METHOD_NAME = "createPublisher";
	logInfo(PARTICIPANT,"CREATING PUBLISHER IN TOPIC: "<<att.topic.getTopicName(),C_B_YELLOW)
	//Look for the correct type registration

	TopicDataType* p_type = nullptr;

	if(!getRegisteredType(att.topic.getTopicDataType().c_str(),&p_type))
	{
		logError(PARTICIPANT,"Type : "<< att.topic.getTopicDataType() << " Not Registered");
		return nullptr;
	}
	if(att.topic.topicKind == WITH_KEY && !p_type->m_isGetKeyDefined)
	{
		logError(PARTICIPANT,"Keyed Topic needs getKey function");
		return nullptr;
	}
	if(m_att.rtps.builtin.use_STATIC_EndpointDiscoveryProtocol)
	{
		if(att.getUserDefinedID() <= 0)
		{
			logError(PARTICIPANT,"Static EDP requires user defined Id");
			return nullptr;
		}
	}
	if(!att.unicastLocatorList.isValid())
	{
		logError(PARTICIPANT,"Unicast Locator List for Publisher contains invalid Locator");
		return nullptr;
	}
	if(!att.multicastLocatorList.isValid())
	{
		logError(PARTICIPANT," Multicast Locator List for Publisher contains invalid Locator");
		return nullptr;
	}
	if(!att.qos.checkQos() || !att.topic.checkQos())
		return nullptr;

	//TODO CONSTRUIR LA IMPLEMENTACION DENTRO DEL OBJETO DEL USUARIO.
	PublisherImpl* pubimpl = new PublisherImpl(this,p_type,att,listen);
	Publisher* pub = new Publisher(pubimpl);
	pubimpl->mp_userPublisher = pub;
	pubimpl->mp_rtpsParticipant = this->mp_rtpsParticipant;

	WriterAttributes watt;
	watt.endpoint.durabilityKind = att.qos.m_durability.kind == VOLATILE_DURABILITY_QOS ? VOLATILE : TRANSIENT_LOCAL;
	watt.endpoint.endpointKind = WRITER;
	watt.endpoint.multicastLocatorList = att.multicastLocatorList;
	watt.endpoint.reliabilityKind = att.qos.m_reliability.kind == RELIABLE_RELIABILITY_QOS ? RELIABLE : BEST_EFFORT;
	watt.endpoint.topicKind = att.topic.topicKind;
	watt.endpoint.unicastLocatorList = att.unicastLocatorList;
	if(att.getEntityID()>0)
		watt.endpoint.setEntityID((uint8_t)att.getEntityID());
	if(att.getUserDefinedID()>0)
		watt.endpoint.setUserDefinedID((uint8_t)att.getUserDefinedID());
	watt.times = att.times;

	RTPSWriter* writer = RTPSDomain::createRTPSWriter(this->mp_rtpsParticipant,
			watt,
			(WriterHistory*)&pubimpl->m_history,
			(WriterListener*)&pubimpl->m_writerListener);
	if(writer == nullptr)
	{
		logError(PARTICIPANT,"Problem creating associated Writer");
		delete(pubimpl);
		return nullptr;
	}
	pubimpl->mp_writer = writer;
	//SAVE THE PUBLISHER PAIR
	t_p_PublisherPair pubpair;
	pubpair.first = pub;
	pubpair.second = pubimpl;
	m_publishers.push_back(pubpair);

	//REGISTER THE WRITER
	this->mp_rtpsParticipant->registerWriter(writer,att.topic,att.qos);

	return pub;
};
Esempio n. 2
0
Subscriber* ParticipantImpl::createSubscriber(SubscriberAttributes& att,
		SubscriberListener* listen)
{
	const char* const METHOD_NAME = "createSubscriber";
	logInfo(PARTICIPANT,"CREATING SUBSCRIBER IN TOPIC: "<<att.topic.getTopicName(),C_B_YELLOW)
	//Look for the correct type registration

	TopicDataType* p_type = nullptr;

	if(!getRegisteredType(att.topic.getTopicDataType().c_str(),&p_type))
	{
		logError(PARTICIPANT,"Type : "<< att.topic.getTopicDataType() << " Not Registered");
		return nullptr;
	}
	if(att.topic.topicKind == WITH_KEY && !p_type->m_isGetKeyDefined)
	{
		logError(PARTICIPANT,"Keyed Topic needs getKey function");
		return nullptr;
	}
	if(m_att.rtps.builtin.use_STATIC_EndpointDiscoveryProtocol)
	{
		if(att.getUserDefinedID() <= 0)
		{
			logError(PARTICIPANT,"Static EDP requires user defined Id");
			return nullptr;
		}
	}
	if(!att.unicastLocatorList.isValid())
	{
		logError(PARTICIPANT,"Unicast Locator List for Subscriber contains invalid Locator");
		return nullptr;
	}
	if(!att.multicastLocatorList.isValid())
	{
		logError(PARTICIPANT," Multicast Locator List for Subscriber contains invalid Locator");
		return nullptr;
	}
	if(!att.qos.checkQos() || !att.topic.checkQos())
		return nullptr;

	SubscriberImpl* subimpl = new SubscriberImpl(this,p_type,att,listen);
	Subscriber* sub = new Subscriber(subimpl);
	subimpl->mp_userSubscriber = sub;
	subimpl->mp_rtpsParticipant = this->mp_rtpsParticipant;

	ReaderAttributes ratt;
	ratt.endpoint.durabilityKind = att.qos.m_durability.kind == VOLATILE_DURABILITY_QOS ? VOLATILE : TRANSIENT_LOCAL;
	ratt.endpoint.endpointKind = READER;
	ratt.endpoint.multicastLocatorList = att.multicastLocatorList;
	ratt.endpoint.reliabilityKind = att.qos.m_reliability.kind == RELIABLE_RELIABILITY_QOS ? RELIABLE : BEST_EFFORT;
	ratt.endpoint.topicKind = att.topic.topicKind;
	ratt.endpoint.unicastLocatorList = att.unicastLocatorList;
	ratt.expectsInlineQos = att.expectsInlineQos;
	if(att.getEntityID()>0)
		ratt.endpoint.setEntityID((uint8_t)att.getEntityID());
	if(att.getUserDefinedID()>0)
		ratt.endpoint.setUserDefinedID((uint8_t)att.getUserDefinedID());
	ratt.times = att.times;

	RTPSReader* reader = RTPSDomain::createRTPSReader(this->mp_rtpsParticipant,
			ratt,
			(ReaderHistory*)&subimpl->m_history,
			(ReaderListener*)&subimpl->m_readerListener);
	if(reader == nullptr)
	{
		logError(PARTICIPANT,"Problem creating associated Reader");
		delete(subimpl);
		return nullptr;
	}
	subimpl->mp_reader = reader;
	//SAVE THE PUBLICHER PAIR
	t_p_SubscriberPair subpair;
	subpair.first = sub;
	subpair.second = subimpl;
	m_subscribers.push_back(subpair);

	//REGISTER THE READER
	this->mp_rtpsParticipant->registerReader(reader,att.topic,att.qos);

	return sub;
};
Esempio n. 3
0
  ELSE_LEXICAL_ANY(unsigned short);
  ELSE_LEXICAL_ANY(int);
  ELSE_LEXICAL_ANY(unsigned int);
  ELSE_LEXICAL_ANY(long);
  ELSE_LEXICAL_ANY(unsigned long);
  ELSE_LEXICAL_ANY(::int64_t);
  ELSE_LEXICAL_ANY(::uint64_t);
  ELSE_LEXICAL_ANY(long long);
  ELSE_LEXICAL_ANY(unsigned long long);
  ELSE_LEXICAL_ANY(float);
  ELSE_LEXICAL_ANY(double);

#undef ELSE_LEXICAL_ANY

  else {
    AbstractTypeHandler *handler = getRegisteredType(&v.type(), true);
    if (handler)
      return handler->asString(v, WString::Empty).jsStringLiteral();
    else {
      LOG_ERROR("unsupported type: '"<< v.type().name() << "'");
      return "''";
    }
  }
}

boost::any updateFromJS(const boost::any& v, std::string s)
{
  if (v.empty())
    return boost::any(s);
  else if (v.type() == typeid(WString))
    return boost::any(WString::fromUTF8(s));