Análisis de código fuente FastDDS: análisis de DataWriter

Tabla de contenido

Análisis del escritor de datos

Análisis de clase DataWriter

La clase DataWriter es una clase importante en la biblioteca Fast DDS y se utiliza para implementar la función de escritura de datos en el modelo de comunicación de publicación-suscripción DDS (Servicio de distribución de datos).

Propósito:
La clase DataWriter se utiliza para publicar datos en un tema específico (Tema). Es responsable de escribir datos en el tema y transmitirlos al lector de datos (DataReader) suscrito al tema. A través de DataWriter, los usuarios pueden publicar datos, registrar y cancelar el registro de instancias de datos, obtener información de estado y establecer la QoS (calidad de servicio) para la escritura de datos.

Variables miembro:

impl_: puntero a una instancia de la clase DataWriterImpl, que es la implementación real de DataWriter.

Funciones miembro:
La clase DataWriter proporciona múltiples funciones miembro. Las siguientes son algunas funciones importantes y sus funciones:

enable(): habilita el escritor de datos.
escribir (datos): escribe datos para el tema.
Register_instance (instancia): registra la instancia de datos.
unregister_instance (instancia): cancela el registro de la instancia de datos.
get_key_value (key_holder, handle): obtiene el valor clave de la instancia de datos.
set_qos(qos): establece la QoS para la escritura de datos.
get_qos(): obtiene la calidad del servicio de la escritura de datos actual.
set_listener(oyente): configura el oyente para la escritura de datos.
get_topic(): Obtiene el tema asociado.
get_publisher(): obtiene el editor que creó el escritor de datos.

Método de implementación aproximado:
El método de implementación de la clase DataWriter depende principalmente de la clase DataWriterImpl subyacente. La clase DataWriterImpl es la implementación real de DataWriter, que encapsula la lógica subyacente y las operaciones relacionadas con la escritura de datos. En la función miembro de DataWriter, la operación correspondiente se completa llamando a la función miembro correspondiente de DataWriterImpl. Por ejemplo, en la función de escritura (datos), se llama a la función de escritura (datos) de DataWriterImpl para realizar realmente la operación de escritura de datos.

Al mismo tiempo, la clase DataWriter también proporciona algunas otras funciones, como la función de tomar prestadas y devolver directamente muestras de datos en el grupo interno a través de las funciones lend_sample y descartar_loan, y obtener información de estado de la escritura de datos.

La siguiente es una descripción detallada del método.

Debido a que esta clase es esencialmente solo una clase contenedora, las funciones clave se implementan básicamente mediante la clase DataWriterImpl.

Análisis de clase DataWriterImpl

Diagrama de clase

La clase DataWriterImpl es una clase clave en la biblioteca Fast DDS y se utiliza para implementar la función de escritura de datos. Contiene operaciones y estados relacionados con la escritura de datos, así como la interacción con la capa de comunicación subyacente (RTPS). La siguiente es una introducción al rol y la implementación general de esta clase y sus funciones:

DataWriterImpl(PublisherImpl*, TypeSupport, Topic*, const DataWriterQos&, DataWriterListener*): constructor de la clase, utilizado para crear un objeto DataWriterImpl e inicializar sus variables miembro.
~DataWriterImpl(): el destructor de la clase se utiliza para limpiar recursos y liberar memoria.
enable(): habilita el objeto DataWriterImpl, crea la entidad subyacente (RTPSWriter), etc.
lend_sample(void*, LoanInitializationKind): toma prestada una muestra del grupo interno para escribir datos.
descarte_loan (void*&): descarta muestras tomadas previamente.
escribir (vacío *): escribe datos en el tema.
write(void*, fastrtps::rtps::WriteParams&): con parámetros de escritura, escribe datos en el tema.
write (void*, const InstanceHandle_t&): escribe datos en la instancia especificada.
write_w_timestamp(void*, const InstanceHandle_t&, const fastrtps::Time_t&): con marca de tiempo, escribe datos en la instancia especificada.
Register_instance (void*): registra una nueva instancia y devuelve el identificador de la instancia.
Register_instance_w_timestamp(void*, const fastrtps::Time_t&): con marca de tiempo, registra una nueva instancia y devuelve el identificador de la instancia.
unregister_instance(void*, const InstanceHandle_t&, bool = false): cancela el registro de la instancia especificada.
unregister_instance_w_timestamp(void*, const InstanceHandle_t&, const fastrtps::Time_t&, bool = false): con marca de tiempo, cierra sesión en la instancia especificada.
guid(): obtiene el GUID de DataWriter.
get_instance_handle(): obtiene el identificador de instancia de DataWriter.
get_type(): obtiene el objeto de soporte del tipo de datos.
get_qos(): obtiene la configuración de QoS de DataWriter.
get_topic(): obtiene el tema asociado con DataWriter.
get_listener(): obtiene el oyente de DataWriter.
set_listener(DataWriterListener*): establece el oyente de DataWriter.
get_publication_matched_status(PublicationMatchedStatus&): obtiene el estado coincidente de la publicación.
get_offered_deadline_missed_status(OfferedDeadlineMissedStatus&): obtiene el estado de fecha límite no cumplida.
get_offered_incompatible_qos_status(OfferedIncompatibleQosStatus&): obtiene el estado de QoS incompatible.
set_qos(const DataWriterQos&): establece la configuración de QoS de DataWriter.
get_liveliness_lost_status (LivelinessLostStatus&): obtiene el estado de vivacidad perdida.
get_publisher(): obtiene el editor asociado.
afirmar_liveliness(): Afirmar vivacidad.
enable(): deshabilita el objeto DataWriterImpl y elimina todos los oyentes.
clear_history(size_t*): borra todos los datos del historial.
get_sending_locators(rtps::LocatorList&): obtiene la lista de localizadores a los que DataWriter puede enviar datos.
filter_is_being_removed(const char*): método llamado cuando se elimina el filtro.

Análisis de funciones clave

escribir

ReturnCode_t DataWriterImpl::write(datos vacíos*)
{
    }
        escritor_->add_change(cambiar);
        cambiar->serializedPayload = *payload;
        CacheChange_t* cambio = historial_.get_last_added_change();
        }
            devolver ret;
        {
        if (ret != CódigoDeRetorno_t::RETCODE_OK)
        ReturnCode_t ret = create_new_change_with_params(ALIVE, data, wparams);
        WriteParams wparams;
        }
            return ReturnCode_t::RETCODE_ERROR;
        {
        if (!type_->serialize(data, payload.get()))
        }
        {
        if (!payload || !get_payload_pool()->get_payload(*payload))
        std::unique_ptr<SerializedPayload_t> carga útil(new SerializedPayload_t());
    {
    }
        escritor_->add_change(cambiar);
        cambio->serializedPayload = carga útil;
        CacheChange_t* cambio = historial_.get_last_added_change();
        }
            devolver ret;
        {
        if (ret != CódigoDeRetorno_t::RETCODE_OK)
        ReturnCode_t ret = create_new_change_with_params(ALIVE, data, wparams);
        WriteParams wparams;
        // 创建新的更改并添加到历史记录中
        }
            return ReturnCode_t::RETCODE_ERROR;
        {
        if (!type_->serialize(datos, &carga útil))
        // 序列化数据到负载中
        }
        {
        if (!get_payload_pool()->get_payload(carga útil))
        Carga útil SerializedPayload_t;
    {
    si (is_data_sharing_compatible_)
    }
    {
    si (datos == nullptr)
    }
    {
    if (escritor_ == nullptr)









    return ReturnCode_t::RETCODE_OK;
}

Los pasos principales de la función de escritura son los siguientes:

Primero, verifique si DataWriter está habilitado y devuelva RETCODE_NOT_ENABLED si no.
Luego, verifique si los datos están vacíos y devuelva RETCODE_BAD_PARAMETER si están vacíos.
A continuación, elija utilizar diferentes distribuidores de carga según la compatibilidad del intercambio de datos.
Si el intercambio de datos es compatible, use el grupo de carga para asignar un objeto SerializedPayload_t y luego serialice los datos en la carga útil.
Crea nuevos cambios y agrégalos al historial.
Configure la carga útil y agregue cambios al DataWriter.
Si el intercambio de datos es incompatible, se utiliza un asignador de carga interno para asignar un objeto SerializedPayload_t y luego serializar los datos en la carga útil.
Crea nuevos cambios y agrégalos al historial.
Configure la carga útil y agregue cambios al DataWriter.
Devolver RETCODE_OK indica que la operación de escritura fue exitosa.

escribir_w_marca de tiempo

ReturnCode_t DataWriterImpl::write_w_timestamp(void* data, const fastrtps::Time_t& marca de tiempo)
{
        CacheChange_t* cambio = historial_.get_last_added_change();
        // Establecer marca de tiempo y publicar cambios
        }
            devolver ret;
        {
        if (ret != CódigoDeRetorno_t::RETCODE_OK)
        ReturnCode_t ret = create_new_change_with_params(ALIVE, data, wparams);
        WriteParams wparams;
        // Crear nuevos cambios y agregarlos al historial
        }
            return ReturnCode_t::RETCODE_ERROR;
        {
        if (!type_->serialize(data, payload.get()))
        // Serializar datos en carga útil
        }
        {
        if (!payload || !get_payload_pool()->get_payload(*payload))
        std::unique_ptr<SerializedPayload_t> carga útil(new SerializedPayload_t());
    {
    más
    }
        escritor_->add_change(cambiar);
        cambiar->sourceTimestamp = marca de tiempo;
        cambio->serializedPayload = carga útil;
        CacheChange_t* cambio = historial_.get_last_added_change();
        }
            devolver ret;
        {
        if (ret != CódigoDeRetorno_t::RETCODE_OK)
        ReturnCode_t ret = create_new_change_with_params(ALIVE, data, wparams);
        WriteParams wparams;
        // Crear nuevos cambios y agregarlos al historial
        }
            return ReturnCode_t::RETCODE_ERROR;
        {
        if (!type_->serialize(datos, &carga útil))
        }
        {
        if (!get_payload_pool()->get_payload(carga útil))
        Carga útil SerializedPayload_t;
    {
    si (is_data_sharing_compatible_)
    }
    {
    si (datos == nullptr)
    }
        return ReturnCode_t::RETCODE_NOT_ENABLED;
    {
    if (escritor_ == nullptr)








        cambio->serializedPayload = *payload;
        cambio->sourceTimestamp = marca de tiempo;
        escritor_->add_change(cambiar);
    }
}

La implementación de la función write_w_timestamp es muy similar a la función de escritura. La diferencia es que acepta una marca de tiempo de parámetro adicional, que se utiliza para especificar la marca de tiempo de los datos.

Los pasos principales de la función write_w_timestamp son los siguientes:

Primero, verifique si DataWriter está habilitado y devuelva RETCODE_NOT_ENABLED si no.
Luego, verifique si los datos están vacíos y devuelva RETCODE_BAD_PARAMETER si están vacíos.
A continuación, elija utilizar diferentes distribuidores de carga según la compatibilidad del intercambio de datos.
Si el intercambio de datos es compatible, se asigna un objeto SerializedPayload_t utilizando el grupo de carga y los datos se serializan en la carga útil.
Crea nuevos cambios y agrégalos al historial.
Establezca la marca de tiempo y agregue los cambios al DataWriter.
Si el intercambio de datos es incompatible, se utiliza un asignador de carga interno para asignar un objeto SerializedPayload_t y serializar los datos en la carga útil.
Crea nuevos cambios y agrégalos al historial.
Establezca la marca de tiempo y agregue los cambios al DataWriter.
Devolver RETCODE_OK indica que la operación de escritura fue exitosa.

instancia_registro

ReturnCode_t DataWriterImpl::register_instance(clave vacía*)
{
}
    return ReturnCode_t::RETCODE_OK;
    History_.register_instance(cambio, clave);
    CacheChange_t* cambio = historial_.get_last_added_change();
    }
    {
    if (ret != CódigoDeRetorno_t::RETCODE_OK)
    ReturnCode_t ret = create_new_change_with_params(NOT_ALIVE_UNREGISTERED, clave, wparams);
    WriteParams wparams;
    }
    {
    if (history_.key_exists(clave))
    }
    {
    si (clave == nullptr)
    }
    {
    if (escritor_ == nullptr)

Los pasos principales de la función Register_instance son los siguientes:

Primero, verifique si DataWriter está habilitado y devuelva RETCODE_NOT_ENABLED si no.
Luego, verifique si el valor de la clave está vacío y devuelva RETCODE_BAD_PARAMETER si está vacío.
A continuación, verifique si la clave se ha registrado y devuelva RETCODE_PRECONDITION_NOT_MET si ya está registrada.
Crea nuevos cambios y agrégalos al historial. La función create_new_change_with_params se usa aquí para crear un nuevo cambio, el tipo de cambio es NOT_ALIVE_UNREGISTERED y los datos son el valor clave.
Registre la instancia en el historial. Asociar cambios con valores clave llamando a la función Register_instance permite que el historial rastree el estado de la instancia.
Devolver RETCODE_OK indica que la operación de la instancia de registro fue exitosa.

History_ es una variable miembro de la clase DataWriterImpl, que es un objeto utilizado para gestionar los registros de cambios históricos de DataWriter.

El propósito de History_ es almacenar todos los cambios enviados por DataWriter. Siempre que DataWriter quiere enviar nuevos datos, crea un nuevo cambio (objeto CacheChange_t) y lo agrega a History_. Los cambios en el historial se pueden ordenar por número de secuencia para que los datos se envíen y transmitan en el orden correcto.

Al gestionar registros históricos, DataWriter puede lograr algunas funciones importantes, como soporte de confiabilidad, acceso histórico, seguimiento y retransmisión de datos, etc. Los registros históricos también se pueden utilizar para atender las necesidades de los suscriptores, como lectura bajo demanda, consulta de datos históricos y filtrado de datos.

En DataWriterImpl, History_ es un objeto de tipo WriterHistory, que implementa la función de gestionar y mantener registros de cambios históricos. WriterHistory es una implementación proporcionada por la biblioteca Fast DDS para gestionar cambios históricos.

Al utilizar History_, DataWriter puede rastrear y administrar los datos enviados, garantizar la confiabilidad y coherencia de los datos y proporcionar acceso histórico flexible y capacidades de procesamiento de datos.

get_publication_matched_status

ReturnCode_t DataWriterImpl::get_publication_matched_status(PublicationMatchedStatus& estado)
{
    // 检查DataWriter是否已启用
    if (escritor_ == nullptr)
    {
        return ReturnCode_t::RETCODE_NOT_ENABLED;
    }
}
    return ReturnCode_t::RETCODE_OK;
    user_datawriter_->get_statuscondition().get_impl()->set_status(StatusMask::publication_matched(), false);
    }
        publicación_matched_status_.total_count_change = 0;
        publicación_matched_status_.current_count_change = 0;
        // cambio de cuenta actual y cambio de cuenta total
        estado = publicación_matched_status_;
        // 获取PublicationMatchedStatus并复制给status参数
        std::unique_lock<RecursiveTimedMutex> bloquear(escritor_->getMutex());

Los pasos principales de la función get_publication_matched_status son los siguientes:

Primero, verifique si DataWriter está habilitado y devuelva RETCODE_NOT_ENABLED si no.
Utilice std::unique_lock para bloquear el mutex de DataWriter para garantizar la seguridad de los subprocesos.
Copie publication_matched_status_ en el parámetro de estado.
Restablece current_count_change y total_count_change en publication_matched_status_ a 0 para indicar que estos cambios se han procesado.
Establezca las condiciones de estado correspondientes llamando a user_datawriter_->get_statuscondition().get_impl()->set_status() y notifique al usuario los cambios en publication_matched_status_.
Devolver RETCODE_OK indica que PublicationMatchedStatus se obtuvo correctamente.

El PublicationMatchedStatus actual de un DataWriter representa el estado coincidente del suscriptor (DataReader) asociado con este DataWriter. PublicationMatchedStatus registra cambios en el número de suscriptores relacionados con DataWriter.

La estructura PublicationMatchedStatus contiene los siguientes campos:

total_count: Indica el número total de suscriptores asociados al DataWriter.
total_count_change: indica el cambio en el número total de suscriptores desde la última vez que se obtuvo PublicationMatchedStatus.
current_count: indica el número actual de suscriptores que coinciden con el DataWriter.
current_count_change: indica el cambio en el número de suscriptores actuales desde la última vez que se obtuvo PublicationMatchedStatus.

Al monitorear los cambios en PublicationMatchedStatus, puede conocer los cambios en la situación de coincidencia entre DataWriter y los suscriptores. Por ejemplo, cuando un nuevo suscriptor coincide con un DataWriter, current_count y total_count se incrementan, y los cambios en el estado de coincidencia se pueden conocer verificando los campos current_count_change y total_count_change.

Algunas funciones se pueden lograr usando PublicationMatchedStatus, como:

Supervise el estado de la conexión del DataWriter y el suscriptor para determinar si la conexión de comunicación se estableció correctamente.
Ajuste la estrategia de publicación de datos según la cantidad de suscriptores que coincidan con DataWriter.
Activar operaciones específicas o funciones de devolución de llamada basadas en cambios en PublicationMatchedStatus

get_offered_deadline_missed_status

ReturnCode_t DataWriterImpl::get_offered_deadline_missed_status(OfferedDeadlineMissedStatus& estado)
{
}
    return ReturnCode_t::RETCODE_OK;
    user_datawriter_->get_statuscondition().get_impl()->set_status(StatusMask::offered_deadline_missed(), false);
    }
        ofrecido_deadline_missed_status_.total_count_change = 0;
        // 重置total_count和total_count_change
        estado = ofrecido_deadline_missed_status_;
        // 获取OfferedDeadlineMissedStatus并复制给status参数
        std::unique_lock<RecursiveTimedMutex> bloquear(escritor_->getMutex());
    }
    {
    if (escritor_ == nullptr)

Los pasos principales de la función get_offered_deadline_missed_status son los siguientes:

Primero, verifique si DataWriter está habilitado y devuelva RETCODE_NOT_ENABLED si no.
Utilice std::unique_lock para bloquear el mutex de DataWriter para garantizar la seguridad de los subprocesos.
Copie ofrecido_deadline_missed_status_ en el parámetro de estado.
Restablezca total_count_change en ofrecido_deadline_missed_status_ a 0 para indicar que los cambios se han procesado.
Establezca las condiciones de estado correspondientes llamando a user_datawriter_->get_statuscondition().get_impl()->set_status() para notificar al usuario de los cambios en OfferedDeadlineMissedStatus.
Devolver RETCODE_OK indica que OfferedDeadlineMissedStatus se obtuvo correctamente.

OfferedDeadlineMissedStatus indica que no se ha alcanzado la fecha límite del DataWriter. Este estado registra las estadísticas de la falla del DataWriter al enviar datos a tiempo de acuerdo con los requisitos de fecha límite definidos.

La estructura OfferedDeadlineMissedStatus contiene los siguientes campos:

total_count: Indica el número total de veces que se ha alcanzado o excedido la fecha límite desde que se inició DataWriter.
total_count_change: Indica el valor de cambio del número de veces que se ha alcanzado o excedido la fecha límite desde la última vez que se obtuvo OfferedDeadlineMissedStatus.

Al monitorear los cambios en OfferedDeadlineMissedStatus, puede comprender la situación en la que DataWriter no envía los datos según lo requerido antes de la fecha límite. Cuando DataWriter no envía datos a tiempo, los campos total_count y total_count_change aumentarán. Puede verificar los valores de estos campos para conocer la cantidad de veces y cambios en la fecha límite que no se ha cumplido.

Algunas funciones se pueden lograr usando OfferedDeadlineMissedStatus, como por ejemplo:

Supervise si DataWriter envía datos a tiempo según la fecha límite.
Tome las medidas adecuadas de tolerancia a fallos en función del incumplimiento del plazo, como reenviar datos o realizar operaciones compensatorias.
Activa operaciones específicas o funciones de devolución de llamada basadas en cambios en OfferedDeadlineMissedStatus.

get_offered_incompatible_qos_status

ReturnCode_t DataWriterImpl::get_offered_incompatible_qos_status(OfferedIncompatibleQosStatus& estado)
{
}
    return ReturnCode_t::RETCODE_OK;
    user_datawriter_->get_statuscondition().get_impl()->set_status(StatusMask::offered_incompatible_qos(), false);
    }
        ofrecido_incompatible_qos_status_.total_count_change = 0;
        // 重置total_count和total_count_change
        estado = ofrecido_incompatible_qos_status_;
        // 获取OfferedIncompatibleQosStatus并复制给status参数
        std::unique_lock<RecursiveTimedMutex> bloquear(escritor_->getMutex());
    }
    {
    if (escritor_ == nullptr)

Los pasos principales de la función get_offered_incompatible_qos_status son los siguientes:

Primero, verifique si DataWriter está habilitado y devuelva RETCODE_NOT_ENABLED si no.
Utilice std::unique_lock para bloquear el mutex de DataWriter para garantizar la seguridad de los subprocesos.
Copie ofrecido_incompatible_qos_status_ en el parámetro de estado.
Restablezca total_count_change en ofrecido_incompatible_qos_status_ a 0 para indicar que los cambios se han procesado.
Establezca las condiciones de estado correspondientes llamando a user_datawriter_->get_statuscondition().get_impl()->set_status() para notificar al usuario los cambios en OfferedIncompatibleQosStatus.
Devolver RETCODE_OK indica que OfferedIncompatibleQosStatus se obtuvo correctamente.

OfferedIncompatibleQosStatus indica que la QoS (Calidad de servicio) proporcionada por DataWriter es incompatible con la QoS del suscriptor (DataReader). Este estado registra estadísticas de incompatibilidad de QoS entre DataWriter y los suscriptores.

La estructura OfferedIncompatibleQosStatus contiene los siguientes campos:

total_count: Indica el número total de QoS incompatibles encontradas desde que se inició DataWriter.
total_count_change: Indica el valor de cambio del número de QoS incompatibles encontradas desde la última vez que se obtuvo OfferedIncompatibleQosStatus.

Al monitorear los cambios en OfferedIncompatibleQosStatus, puede comprender la incompatibilidad de QoS entre DataWriter y los suscriptores. Cuando el DataWriter y el suscriptor descubren una QoS incompatible, los campos total_count y total_count_change aumentarán. Puede conocer el número y los cambios de QoS incompatibles verificando los valores de estos campos.

Algunas funciones se pueden lograr usando OfferedIncompatibleQosStatus, como por ejemplo:

Supervise la compatibilidad de QoS entre DataWriter y los suscriptores.
Tome las medidas adecuadas en función de la situación de QoS incompatible, como intentar reconfigurar la QoS o negociar con los suscriptores.
Activa operaciones específicas o funciones de devolución de llamada basadas en cambios en OfferedIncompatibleQosStatus.

get_liveliness_lost_status

ReturnCode_t DataWriterImpl::get_liveliness_lost_status(LivelinessLostStatus& estado)
{
}
    return ReturnCode_t::RETCODE_OK;
    user_datawriter_->get_statuscondition().get_impl()->set_status(StatusMask::liveliness_lost(), false);
    }
        liveliness_lost_status_.total_count_change = 0;
        // 重置total_count和total_count_change
        estado = vivacidad_lost_status_;
        // 获取LivenessLostStatus并复制给status参数
        std::unique_lock<RecursiveTimedMutex> bloquear(escritor_->getMutex());
    }
    {
    if (escritor_ == nullptr)

Los pasos principales de la función get_liveliness_lost_status son los siguientes:

Primero, verifique si DataWriter está habilitado y devuelva RETCODE_NOT_ENABLED si no.
Utilice std::unique_lock para bloquear el mutex de DataWriter para garantizar la seguridad de los subprocesos.
Copie liveliness_lost_status_ en el parámetro de estado.
Restablece total_count_change en liveliness_lost_status_ a 0 para indicar que los cambios se han procesado.
Establezca las condiciones de estado correspondientes llamando a user_datawriter_->get_statuscondition().get_impl()->set_status() para notificar al usuario de los cambios en LivelinessLostStatus.
Devolver RETCODE_OK indica que LivelinessLostStatus se obtuvo correctamente.

En las comunicaciones de datos, la vivacidad se refiere al estado en el que una entidad (como DataWriter) continúa existiendo y estando activa. En el modelo de publicación-suscripción, un DataWriter demuestra su estado activo enviando mensajes de actividad o enviando periódicamente mensajes de latido. De esta manera, el suscriptor (DataReader) puede confirmar si el DataWriter todavía está activo para mantener el enlace de comunicación.

El propósito de la vivacidad es garantizar que las entidades en las comunicaciones de datos permanezcan activas para mantener la validez y coherencia del vínculo de comunicación. A través del mecanismo de vida, es posible detectar si un DataWriter ya no está activo, es decir, deja de enviar mensajes de vida o mensajes de latido, o si no puede cumplir con los requisitos de vida por algún motivo. Cuando DataWriter pierde actividad, el suscriptor puede manejarlo en consecuencia, como actualizar el estado del suscriptor, reasignar recursos o tomar otras medidas tolerantes a fallas.

get_sending_locators

ReturnCode_t DataWriterImpl::get_sending_locators(rtps::LocatorList& locators) const
{
}
    return ReturnCode_t::RETCODE_OK;
    localizadores = enviando_localizadores;
    //Copiar la lista de localizadores de envío a los localizadores de parámetros de salida
    rtps::LocatorList enviando_localizadores = escritor_->getRTPSParticipant()->getSendingLocators();
    }
    {
    if (escritor_ == nullptr)

Los pasos principales de la función get_sending_locators son los siguientes:

Primero, verifique si DataWriter está habilitado y devuelva RETCODE_NOT_ENABLED si no.
Llame a write_->getRTPSParticipant()->getSendingLocators() para obtener la lista de localizadores de envío que utiliza DataWriter.
Copia la lista de localizadores de envío a los localizadores de parámetros de salida.
Devolver RETCODE_OK indica que la adquisición de la lista de localizadores de envío se realizó correctamente.

Al llamar a la función get_sending_locators, puede obtener la lista de localizadores de envío que utiliza DataWriter. La lista de localizadores de envío contiene la información del localizador de red utilizada por DataWriter para enviar datos y se puede utilizar para comprender la configuración de comunicación actual y la información de conexión de DataWriter. Esto es útil para monitorear y depurar transferencias de datos y configuraciones de red.