Quella/unitreeApp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
Quella
2025-09-24 10:53:28 +08:00
commit f8e4df77fb
856 changed files with 140098 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

354
unitree_SDK/include/ddscxx/dds/pub/TAnyDataWriter.hpp Normal file
View File

@@ -0,0 +1,354 @@
#ifndef OMG_TDDS_PUB_ANY_DATA_WRITER_HPP_
#define OMG_TDDS_PUB_ANY_DATA_WRITER_HPP_
/* Copyright 2010, Object Management Group, Inc.
* Copyright 2010, PrismTech, Corp.
* Copyright 2010, Real-Time Innovations, Inc.
* All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <dds/core/TEntity.hpp>
#include <dds/pub/Publisher.hpp>
#include <dds/pub/qos/DataWriterQos.hpp>
#include <dds/topic/TopicDescription.hpp>
namespace dds
{
namespace pub
{
template <typename DELEGATE>
class TAnyDataWriter;
}
}
/**
* @brief
* Typeless base class for the typed DataWriter.
*
* DataWriters are created type specific (fi DataWriter<Foo::Bar> writer). However, there
* are many places in the API (and possibly application) where the type can not be known
* while still some DataWriter has to be passed around, stored or even typeless functionality
* called.<br>
* Main examples in the API that need typeless DataWriter are: Publisher, PublisherListener
* and DomainParticipantListener.
*
*/
template <typename DELEGATE>
class dds::pub::TAnyDataWriter : public dds::core::TEntity<DELEGATE>
{
public:
OMG_DDS_REF_TYPE_PROTECTED_DC(TAnyDataWriter, dds::core::TEntity, DELEGATE)
OMG_DDS_IMPLICIT_REF_BASE(TAnyDataWriter)
OMG_DDS_COMPLETE_RULE_OF_FIVE_VIRTUAL_DEFAULT(TAnyDataWriter)
//==========================================================================
//== Entity Navigation
/**
* Get the Publisher that owns this DataWriter.
*
* @return the Publisher
* @throws dds::core::Error
* An internal error has occurred.
* @throws dds::core::NullReferenceError
* The entity was not properly created and references to dds::core::null.
* @throws dds::core::AlreadyClosedError
* The entity has already been closed.
*/
const dds::pub::Publisher& publisher() const;
/**
* Get the TopicDescription associated with this DataWriter.
*
* @return the TopicDescription
* @throws dds::core::Error
* An internal error has occurred.
* @throws dds::core::NullReferenceError
* The entity was not properly created and references to dds::core::null.
* @throws dds::core::AlreadyClosedError
* The entity has already been closed.
*/
const dds::topic::TopicDescription& topic_description() const;
//==========================================================================
//== QoS Management
/**
* Gets the DataWriterQos setting for this instance.
*
* @return the qos
* @throws dds::core::Error
* An internal error has occurred.
* @throws dds::core::NullReferenceError
* The entity was not properly created and references to dds::core::null.
* @throws dds::core::AlreadyClosedError
* The entity has already been closed.
* @throws dds::core::OutOfResourcesError
* The Data Distribution Service ran out of resources to
* complete this operation.
*/
dds::pub::qos::DataWriterQos
qos() const;
/**
* This operation replaces the existing set of QosPolicy settings for a DataWriter.
*
* The parameter qos contains the object with the QosPolicy settings which is
* checked for self-consistency and mutability.
*
* When the application tries to change a
* QosPolicy setting for an enabled DataWriter, which can only be set before the
* DataWriter is enabled, the operation will fail and a
* ImmutablePolicyError is thrown. In other words, the application must
* provide the presently set QosPolicy settings in case of the immutable QosPolicy
* settings. Only the mutable QosPolicy settings can be changed.
*
* When the qos contains conflicting QosPolicy settings (not self-consistent),
* the operation will fail and an InconsistentPolicyError is thrown.
*
* @param qos the qos
* @throws dds::core::Error
* An internal error has occurred.
* @throws dds::core::NullReferenceError
* The entity was not properly created and references to dds::core::null.
* @throws dds::core::AlreadyClosedError
* The entity has already been closed.
* @throws dds::core::OutOfResourcesError
* The Data Distribution Service ran out of resources to
* complete this operation.
* @throws dds::core::ImmutablePolicyError
* The parameter qos contains an immutable QosPolicy setting with a
* different value than set during enabling of the DataWriter.
* @throws dds::core::InconsistentPolicyError
* The parameter qos contains conflicting QosPolicy settings,
*/
void qos(const dds::pub::qos::DataWriterQos& qos);
/** @copydoc dds::pub::TAnyDataWriter::qos(const dds::pub::qos::DataWriterQos& qos) */
TAnyDataWriter& operator << (const dds::pub::qos::DataWriterQos& qos);
/** @copydoc dds::pub::TAnyDataWriter::qos() */
const TAnyDataWriter& operator >> (dds::pub::qos::DataWriterQos& qos) const;
//==========================================================================
//== ACKs
/**
* This operation blocks the calling thread until either all data written
* by the DataWriter is acknowledged by the local infrastructure, or until
* the duration specified by the timeout parameter elapses,
* whichever happens first.
*
* Data is acknowledged by the local infrastructure when it does not need to be stored
* in its DataWriter’s local history. When a locally-connected subscription (including
* the networking service) has no more resources to store incoming samples it will start
* to reject these samples, resulting in their source DataWriters to store them
* temporarily in their own local history to be retransmitted at a later moment in time.<br>
* In such scenarios, the wait_for_acknowledgments operation will block until the
* DataWriter has retransmitted its entire history, which is therefore effectively
* empty, or until the timeout expires, whichever happens first. In the latter
* case, this operation will throw a TimeoutError.
*
* <i>
* Be aware that in case the operation returns normally, the data has only been
* acknowledged by the local infrastructure: it does not mean all remote subscriptions
* have already received the data. However, delivering the data to remote nodes is then
* the sole responsibility of the networking service: even when the publishing
* application would terminate, all data that has not yet been received may be
* considered ‘on-route’ and will therefore eventually arrive (unless the networking
* service itself will crash). In contrast, if a DataWriter would still have data in it’s
* local history buffer when it terminates, this data is considered ‘lost’.
* </i>
*
* This operation is intended to be used only if one or more of the contained
* DataWriters has its ReliabilityQosPolicyKind set to RELIABLE.
* Otherwise the operation will return immediately, since best-effort DataWriters will
* never store rejected samples in their local history:
* they will just drop them and continue business as usual.
*
* @param timeout the time out duration
* @throws dds::core::Error
* An internal error has occurred.
* @throws dds::core::NullReferenceError
* The entity was not properly created and references to dds::core::null.
* @throws dds::core::AlreadyClosedError
* The entity has already been closed.
* @throws dds::core::TimeoutError
* Not all data is acknowledged before timeout elapsed.
* @throws dds::core::OutOfResourcesError
* The Data Distribution Service ran out of resources to
* complete this operation.
*/
void wait_for_acknowledgments(const dds::core::Duration& timeout);
//==========================================================================
//== Status Management
/**
* This operation obtains the LivelinessLostStatus object of the DataWriter.
*
* The LivelinessLostStatus contains the information whether the liveliness (that the
* DataWriter has committed through its Liveliness QosPolicy) was respected.
* This means that the status represents whether the DataWriter failed to actively
* signal its liveliness within the offered liveliness period. If the liveliness is lost, the
* DataReader objects will consider the DataWriter as no longer “alive”.
*
* The LivelinessLostStatus can also be monitored using a
* DataWriterListener or by using the associated StatusCondition.
*
* @return the LivelinessLostStatus
* @throws dds::core::Error
* An internal error has occurred.
* @throws dds::core::NullReferenceError
* The entity was not properly created and references to dds::core::null.
* @throws dds::core::AlreadyClosedError
* The entity has already been closed.
* @throws dds::core::OutOfResourcesError
* The Data Distribution Service ran out of resources to
* complete this operation.
*/
const dds::core::status::LivelinessLostStatus liveliness_lost_status();
/**
* This operation obtains the OfferedDeadlineMissedStatus object of the DataWriter.
*
* The OfferedDeadlineMissedStatus contains the information whether the deadline (that the
* DataWriter has committed through its Deadline QosPolicy) was respected for
* each instance.
*
* The OfferedDeadlineMissedStatus can also be monitored using a
* DataWriterListener or by using the associated StatusCondition.
*
* @return the OfferedDeadlineMissedStatus
* @throws dds::core::Error
* An internal error has occurred.
* @throws dds::core::NullReferenceError
* The entity was not properly created and references to dds::core::null.
* @throws dds::core::AlreadyClosedError
* The entity has already been closed.
* @throws dds::core::OutOfResourcesError
* The Data Distribution Service ran out of resources to
* complete this operation.
*/
const dds::core::status::OfferedDeadlineMissedStatus offered_deadline_missed_status();
/**
* This operation obtains the OfferedIncompatibleQosStatus object of the DataWriter.
*
* The OfferedIncompatibleQosStatus contains the information whether a QosPolicy setting
* was incompatible with the requested QosPolicy setting.
*
* This means that the status represents whether a DataReader object has been
* discovered by the DataWriter with the same Topic and a requested
* DataReaderQos that was incompatible with the one offered by the DataWriter.
*
* The OfferedIncompatibleQosStatus can also be monitored using a
* DataWriterListener or by using the associated StatusCondition.
*
* @return the OfferedIncompatibleQosStatus
* @throws dds::core::Error
* An internal error has occurred.
* @throws dds::core::NullReferenceError
* The entity was not properly created and references to dds::core::null.
* @throws dds::core::AlreadyClosedError
* The entity has already been closed.
* @throws dds::core::OutOfResourcesError
* The Data Distribution Service ran out of resources to
* complete this operation.
*/
const dds::core::status::OfferedIncompatibleQosStatus offered_incompatible_qos_status();
/**
* This operation obtains the PublicationMatchedStatus object of the DataWriter.
*
* The PublicationMatchedStatus contains the information whether a new match has been
* discovered for the current publication, or whether an existing match has ceased to
* exist.
*
* This means that the status represents that either a DataReader object has been
* discovered by the DataWriter with the same Topic and a compatible Qos, or that a
* previously discovered DataReader has ceased to be matched to the current
* DataWriter. A DataReader may cease to match when it gets deleted, when it
* changes its Qos to a value that is incompatible with the current DataWriter or
* when either the DataWriter or the DataReader has chosen to put its matching
* counterpart on its ignore-list using the dds::sub::ignore or
* dds::pub::ignore operations.
*
* The operation may fail if the infrastructure does not hold the information necessary
* to fill in the PublicationMatchedStatus. This is the case when OpenSplice is
* configured not to maintain discovery information in the Networking Service. (See
* the description for the NetworkingService/Discovery/enabled property in
* the Deployment Manual for more information about this subject.) In this case the
* operation will throw UnsupportedError.
*
* The PublicationMatchedStatus can also be monitored using a
* DataWriterListener or by using the associated StatusCondition.
*
* @return the PublicationMatchedStatus
* @throws dds::core::Error
* An internal error has occurred.
* @throws dds::core::NullReferenceError
* The entity was not properly created and references to dds::core::null.
* @throws dds::core::UnsupportedError
* OpenSplice is configured not to maintain the information
* about “associated” subscriptions.
* @throws dds::core::AlreadyClosedError
* The entity has already been closed.
* @throws dds::core::OutOfResourcesError
* The Data Distribution Service ran out of resources to
* complete this operation.
*/
const dds::core::status::PublicationMatchedStatus publication_matched_status();
//==========================================================================
//== Liveliness Management
/**
* This operation asserts the liveliness for the DataWriter.
*
* This operation will manually assert the liveliness for the DataWriter. This way,
* the Data Distribution Service is informed that the corresponding DataWriter is
* still alive. This operation is used in combination with the Liveliness QosPolicy
* set to Liveliness::ManualByParticipant or Liveliness::ManualByTopic.
*
* Writing data via the write operation of a DataWriter will assert the liveliness on
* the DataWriter itself and its containing DomainParticipant. Therefore,
* assert_liveliness is only needed when not writing regularly.
*
* The liveliness should be asserted by the application, depending on the
* LivelinessQosPolicy. Asserting the liveliness for this DataWriter can also
* be achieved by asserting the liveliness to the DomainParticipant.
*
* @throws dds::core::Error
* An internal error has occurred.
* @throws dds::core::NullReferenceError
* The entity was not properly created and references to dds::core::null.
* @throws dds::core::AlreadyClosedError
* The entity has already been closed.
* @throws dds::core::OutOfResourcesError
* The Data Distribution Service ran out of resources to
* complete this operation.
* @throws dds::core::NotEnabledError
* The entity has not yet been enabled.
*/
void assert_liveliness();
};
#endif /* OMG_TDDS_PUB_ANY_DATA_WRITER_HPP_ */