mavlink / MAVSDK / 20150727601

RemoteId::RemoteId(System& system) : PluginBase(), _impl{std::make_unique<RemoteIdImpl>(system)} {}

RemoteId::RemoteId(std::shared_ptr<System> system) :

    _impl{std::make_unique<RemoteIdImpl>(system)}

{}

RemoteId::~RemoteId() {}

RemoteId::Result RemoteId::set_basic_id(BasicId basic_id) const

    return _impl->set_basic_id(basic_id);

RemoteId::Result RemoteId::set_location(Location location) const

    return _impl->set_location(location);

RemoteId::Result RemoteId::set_system(SystemId system) const

    return _impl->set_system(system);

RemoteId::Result RemoteId::set_operator_id(OperatorId system) const

    return _impl->set_operator_id(system);

RemoteId::Result RemoteId::set_self_id(SelfId self_id) const

    return _impl->set_self_id(self_id);

RemoteId::ArmStatusHandle RemoteId::subscribe_arm_status(const ArmStatusCallback& callback)

    return _impl->subscribe_arm_status(callback);

void RemoteId::unsubscribe_arm_status(ArmStatusHandle handle)

    _impl->unsubscribe_arm_status(handle);

}

RemoteId::ArmStatus RemoteId::arm_status() const

    return _impl->arm_status();

std::ostream& operator<<(std::ostream& str, RemoteId::BasicId::IdType const& id_type)

    switch (id_type) {

        case RemoteId::BasicId::IdType::None:

            return str << "None";

        case RemoteId::BasicId::IdType::SerialNumber:

            return str << "Serial Number";

        case RemoteId::BasicId::IdType::CaaRegistrationId:

            return str << "Caa Registration Id";

        case RemoteId::BasicId::IdType::UtmAssignedUuid:

            return str << "Utm Assigned Uuid";

        case RemoteId::BasicId::IdType::SpecificSessionId:

            return str << "Specific Session Id";

        default:

            return str << "Unknown";

std::ostream& operator<<(std::ostream& str, RemoteId::BasicId::UasType const& uas_type)

    switch (uas_type) {

        case RemoteId::BasicId::UasType::None:

            return str << "None";

        case RemoteId::BasicId::UasType::Aeroplane:

            return str << "Aeroplane";

        case RemoteId::BasicId::UasType::HelicopterOrMultirotor:

            return str << "Helicopter Or Multirotor";

        case RemoteId::BasicId::UasType::Gyroplane:

            return str << "Gyroplane";

        case RemoteId::BasicId::UasType::HybridLift:

            return str << "Hybrid Lift";

        case RemoteId::BasicId::UasType::Ornithopter:

            return str << "Ornithopter";

        case RemoteId::BasicId::UasType::Glider:

            return str << "Glider";

        case RemoteId::BasicId::UasType::Kite:

            return str << "Kite";

        case RemoteId::BasicId::UasType::FreeBalloon:

            return str << "Free Balloon";

        case RemoteId::BasicId::UasType::CaptiveBalloon:

            return str << "Captive Balloon";

        case RemoteId::BasicId::UasType::Airship:

            return str << "Airship";

        case RemoteId::BasicId::UasType::FreeFallParachute:

            return str << "Free Fall Parachute";

        case RemoteId::BasicId::UasType::Rocket:

            return str << "Rocket";

        case RemoteId::BasicId::UasType::TetheredPoweredAircraft:

            return str << "Tethered Powered Aircraft";

        case RemoteId::BasicId::UasType::GroundObstacle:

            return str << "Ground Obstacle";

        case RemoteId::BasicId::UasType::Other:

            return str << "Other";

        default:

            return str << "Unknown";

bool operator==(const RemoteId::BasicId& lhs, const RemoteId::BasicId& rhs)

    return (rhs.id_type == lhs.id_type) && (rhs.ua_type == lhs.ua_type) &&

           (rhs.uas_id == lhs.uas_id);

std::ostream& operator<<(std::ostream& str, RemoteId::BasicId const& basic_id)

    str << std::setprecision(15);

    str << "basic_id:" << '\n' << "{\n";

    str << "    id_type: " << basic_id.id_type << '\n';

    str << "    ua_type: " << basic_id.ua_type << '\n';

    str << "    uas_id: " << basic_id.uas_id << '\n';

    str << '}';

    return str;

std::ostream& operator<<(std::ostream& str, RemoteId::Location::Status const& status)

    switch (status) {

        case RemoteId::Location::Status::Undeclared:

            return str << "Undeclared";

        case RemoteId::Location::Status::Ground:

            return str << "Ground";

        case RemoteId::Location::Status::Airborne:

            return str << "Airborne";

        case RemoteId::Location::Status::Emergency:

            return str << "Emergency";

        case RemoteId::Location::Status::RemoteIdSystemFailure:

            return str << "Remote Id System Failure";

        default:

            return str << "Unknown";

std::ostream& operator<<(std::ostream& str, RemoteId::Location::HeightRef const& height_ref)

    switch (height_ref) {

        case RemoteId::Location::HeightRef::OverTakeoff:

            return str << "Over Takeoff";

        case RemoteId::Location::HeightRef::OverGround:

            return str << "Over Ground";

        default:

            return str << "Unknown";

std::ostream& operator<<(std::ostream& str, RemoteId::Location::HorAcc const& hor_acc)

    switch (hor_acc) {

        case RemoteId::Location::HorAcc::Unknown:

            return str << "Unknown";

        case RemoteId::Location::HorAcc::Nm10:

            return str << "Nm 10";

        case RemoteId::Location::HorAcc::Nm4:

            return str << "Nm 4";

        case RemoteId::Location::HorAcc::Nm2:

            return str << "Nm 2";

        case RemoteId::Location::HorAcc::Nm1:

            return str << "Nm 1";

        case RemoteId::Location::HorAcc::Nm05:

            return str << "Nm 0 5";

        case RemoteId::Location::HorAcc::Nm03:

            return str << "Nm 0 3";

        case RemoteId::Location::HorAcc::Nm01:

            return str << "Nm 0 1";

        case RemoteId::Location::HorAcc::Nm005:

            return str << "Nm 0 05";

        case RemoteId::Location::HorAcc::Meter30:

            return str << "Meter 30";

        case RemoteId::Location::HorAcc::Meter10:

            return str << "Meter 10";

        case RemoteId::Location::HorAcc::Meter3:

            return str << "Meter 3";

        case RemoteId::Location::HorAcc::Meter1:

            return str << "Meter 1";

        default:

            return str << "Unknown";

std::ostream& operator<<(std::ostream& str, RemoteId::Location::VerAcc const& ver_acc)

    switch (ver_acc) {

        case RemoteId::Location::VerAcc::Unknown:

            return str << "Unknown";

        case RemoteId::Location::VerAcc::Meter150:

            return str << "Meter 150";

        case RemoteId::Location::VerAcc::Meter45:

            return str << "Meter 45";

        case RemoteId::Location::VerAcc::Meter25:

            return str << "Meter 25";

        case RemoteId::Location::VerAcc::Meter10:

            return str << "Meter 10";

        case RemoteId::Location::VerAcc::Meter3:

            return str << "Meter 3";

        case RemoteId::Location::VerAcc::Meter1:

            return str << "Meter 1";

        default:

            return str << "Unknown";

std::ostream& operator<<(std::ostream& str, RemoteId::Location::SpeedAcc const& speed_acc)

    switch (speed_acc) {

        case RemoteId::Location::SpeedAcc::Unknown:

            return str << "Unknown";

        case RemoteId::Location::SpeedAcc::MetersPerSecond10:

            return str << "Meters Per Second 10";

        case RemoteId::Location::SpeedAcc::MetersPerSecond3:

            return str << "Meters Per Second 3";

        case RemoteId::Location::SpeedAcc::MetersPerSecond1:

            return str << "Meters Per Second 1";

        case RemoteId::Location::SpeedAcc::MetersPerSecond03:

            return str << "Meters Per Second 0 3";

        default:

            return str << "Unknown";

std::ostream& operator<<(std::ostream& str, RemoteId::Location::TimeAcc const& time_acc)

    switch (time_acc) {

        case RemoteId::Location::TimeAcc::Unknown:

            return str << "Unknown";

        case RemoteId::Location::TimeAcc::Second01:

            return str << "Second 0 1";

        case RemoteId::Location::TimeAcc::Second02:

            return str << "Second 0 2";

        case RemoteId::Location::TimeAcc::Second03:

            return str << "Second 0 3";

        case RemoteId::Location::TimeAcc::Second04:

            return str << "Second 0 4";

        case RemoteId::Location::TimeAcc::Second05:

            return str << "Second 0 5";

        case RemoteId::Location::TimeAcc::Second06:

            return str << "Second 0 6";

        case RemoteId::Location::TimeAcc::Second07:

            return str << "Second 0 7";

        case RemoteId::Location::TimeAcc::Second08:

            return str << "Second 0 8";

        case RemoteId::Location::TimeAcc::Second09:

            return str << "Second 0 9";

        case RemoteId::Location::TimeAcc::Second10:

            return str << "Second 1 0";

        case RemoteId::Location::TimeAcc::Second11:

            return str << "Second 1 1";

        case RemoteId::Location::TimeAcc::Second12:

            return str << "Second 1 2";

        case RemoteId::Location::TimeAcc::Second13:

            return str << "Second 1 3";

        case RemoteId::Location::TimeAcc::Second14:

            return str << "Second 1 4";

        case RemoteId::Location::TimeAcc::Second15:

            return str << "Second 1 5";

        default:

            return str << "Unknown";

bool operator==(const RemoteId::Location& lhs, const RemoteId::Location& rhs)

    return (rhs.status == lhs.status) && (rhs.direction_deg == lhs.direction_deg) &&

           ((std::isnan(rhs.speed_horizontal_m_s) && std::isnan(lhs.speed_horizontal_m_s)) ||

            rhs.speed_horizontal_m_s == lhs.speed_horizontal_m_s) &&

           ((std::isnan(rhs.speed_vertical_m_s) && std::isnan(lhs.speed_vertical_m_s)) ||

            rhs.speed_vertical_m_s == lhs.speed_vertical_m_s) &&

           ((std::isnan(rhs.latitude_deg) && std::isnan(lhs.latitude_deg)) ||

            rhs.latitude_deg == lhs.latitude_deg) &&

           ((std::isnan(rhs.longitude_deg) && std::isnan(lhs.longitude_deg)) ||

            rhs.longitude_deg == lhs.longitude_deg) &&

           ((std::isnan(rhs.altitude_barometric_m) && std::isnan(lhs.altitude_barometric_m)) ||

            rhs.altitude_barometric_m == lhs.altitude_barometric_m) &&

           ((std::isnan(rhs.altitude_geodetic_m) && std::isnan(lhs.altitude_geodetic_m)) ||

            rhs.altitude_geodetic_m == lhs.altitude_geodetic_m) &&

           (rhs.height_reference == lhs.height_reference) &&

           ((std::isnan(rhs.height_m) && std::isnan(lhs.height_m)) ||

            rhs.height_m == lhs.height_m) &&

           (rhs.time_utc_us == lhs.time_utc_us) &&

           (rhs.horizontal_accuracy == lhs.horizontal_accuracy) &&

           (rhs.vertical_accuracy == lhs.vertical_accuracy) &&

           (rhs.barometer_accuracy == lhs.barometer_accuracy) &&

           (rhs.speed_accuracy == lhs.speed_accuracy) &&

           (rhs.timestamp_accuracy == lhs.timestamp_accuracy);

std::ostream& operator<<(std::ostream& str, RemoteId::Location const& location)

    str << std::setprecision(15);

    str << "location:" << '\n' << "{\n";

    str << "    status: " << location.status << '\n';

    str << "    direction_deg: " << location.direction_deg << '\n';

    str << "    speed_horizontal_m_s: " << location.speed_horizontal_m_s << '\n';

    str << "    speed_vertical_m_s: " << location.speed_vertical_m_s << '\n';

    str << "    latitude_deg: " << location.latitude_deg << '\n';

    str << "    longitude_deg: " << location.longitude_deg << '\n';

    str << "    altitude_barometric_m: " << location.altitude_barometric_m << '\n';

    str << "    altitude_geodetic_m: " << location.altitude_geodetic_m << '\n';

    str << "    height_reference: " << location.height_reference << '\n';

    str << "    height_m: " << location.height_m << '\n';

    str << "    time_utc_us: " << location.time_utc_us << '\n';

    str << "    horizontal_accuracy: " << location.horizontal_accuracy << '\n';

    str << "    vertical_accuracy: " << location.vertical_accuracy << '\n';

    str << "    barometer_accuracy: " << location.barometer_accuracy << '\n';

    str << "    speed_accuracy: " << location.speed_accuracy << '\n';

    str << "    timestamp_accuracy: " << location.timestamp_accuracy << '\n';

    str << '}';

    return str;

std::ostream& operator<<(

    switch (operator_location_type) {

        case RemoteId::SystemId::OperatorLocationType::Takeoff:

            return str << "Takeoff";

        case RemoteId::SystemId::OperatorLocationType::LiveGnss:

            return str << "Live Gnss";

        case RemoteId::SystemId::OperatorLocationType::Fixed:

            return str << "Fixed";

        default:

            return str << "Unknown";

operator<<(std::ostream& str, RemoteId::SystemId::ClassificationType const& classification_type)

    switch (classification_type) {

        case RemoteId::SystemId::ClassificationType::Undeclared:

            return str << "Undeclared";

        case RemoteId::SystemId::ClassificationType::Eu:

            return str << "Eu";

        default:

            return str << "Unknown";

std::ostream& operator<<(std::ostream& str, RemoteId::SystemId::CategoryEu const& category_eu)

    switch (category_eu) {

        case RemoteId::SystemId::CategoryEu::Undeclared:

            return str << "Undeclared";

        case RemoteId::SystemId::CategoryEu::Open:

            return str << "Open";

        case RemoteId::SystemId::CategoryEu::Specific:

            return str << "Specific";

        case RemoteId::SystemId::CategoryEu::Certified:

            return str << "Certified";

        default:

            return str << "Unknown";

std::ostream& operator<<(std::ostream& str, RemoteId::SystemId::ClassEu const& class_eu)

    switch (class_eu) {

        case RemoteId::SystemId::ClassEu::Undeclared:

            return str << "Undeclared";

        case RemoteId::SystemId::ClassEu::Class0:

            return str << "Class 0";

        case RemoteId::SystemId::ClassEu::Class1:

            return str << "Class 1";

        case RemoteId::SystemId::ClassEu::Class2:

            return str << "Class 2";

        case RemoteId::SystemId::ClassEu::Class3:

            return str << "Class 3";

        case RemoteId::SystemId::ClassEu::Class4:

            return str << "Class 4";

        case RemoteId::SystemId::ClassEu::Class5:

            return str << "Class 5";

        case RemoteId::SystemId::ClassEu::Class6:

            return str << "Class 6";

        default:

            return str << "Unknown";

bool operator==(const RemoteId::SystemId& lhs, const RemoteId::SystemId& rhs)

    return (rhs.operator_location_type == lhs.operator_location_type) &&

           (rhs.classification_type == lhs.classification_type) &&

           ((std::isnan(rhs.operator_latitude_deg) && std::isnan(lhs.operator_latitude_deg)) ||

            rhs.operator_latitude_deg == lhs.operator_latitude_deg) &&

           ((std::isnan(rhs.operator_longitude_deg) && std::isnan(lhs.operator_longitude_deg)) ||

            rhs.operator_longitude_deg == lhs.operator_longitude_deg) &&

           (rhs.area_count == lhs.area_count) && (rhs.area_radius_m == lhs.area_radius_m) &&

           ((std::isnan(rhs.area_ceiling_m) && std::isnan(lhs.area_ceiling_m)) ||

            rhs.area_ceiling_m == lhs.area_ceiling_m) &&

           ((std::isnan(rhs.area_floor_m) && std::isnan(lhs.area_floor_m)) ||

            rhs.area_floor_m == lhs.area_floor_m) &&

           (rhs.category_eu == lhs.category_eu) && (rhs.class_eu == lhs.class_eu) &&

           ((std::isnan(rhs.operator_altitude_geo_m) && std::isnan(lhs.operator_altitude_geo_m)) ||

            rhs.operator_altitude_geo_m == lhs.operator_altitude_geo_m) &&

           (rhs.time_utc_us == lhs.time_utc_us);

std::ostream& operator<<(std::ostream& str, RemoteId::SystemId const& system_id)

    str << std::setprecision(15);

    str << "system_id:" << '\n' << "{\n";

    str << "    operator_location_type: " << system_id.operator_location_type << '\n';

    str << "    classification_type: " << system_id.classification_type << '\n';

    str << "    operator_latitude_deg: " << system_id.operator_latitude_deg << '\n';

    str << "    operator_longitude_deg: " << system_id.operator_longitude_deg << '\n';

    str << "    area_count: " << system_id.area_count << '\n';

    str << "    area_radius_m: " << system_id.area_radius_m << '\n';

    str << "    area_ceiling_m: " << system_id.area_ceiling_m << '\n';

    str << "    area_floor_m: " << system_id.area_floor_m << '\n';

    str << "    category_eu: " << system_id.category_eu << '\n';

    str << "    class_eu: " << system_id.class_eu << '\n';

    str << "    operator_altitude_geo_m: " << system_id.operator_altitude_geo_m << '\n';

    str << "    time_utc_us: " << system_id.time_utc_us << '\n';

    str << '}';

    return str;

operator<<(std::ostream& str, RemoteId::OperatorId::OperatorIdType const& operator_id_type)

    switch (operator_id_type) {

        case RemoteId::OperatorId::OperatorIdType::Caa:

            return str << "Caa";

        default:

            return str << "Unknown";

bool operator==(const RemoteId::OperatorId& lhs, const RemoteId::OperatorId& rhs)

    return (rhs.operator_id_type == lhs.operator_id_type) && (rhs.operator_id == lhs.operator_id);

std::ostream& operator<<(std::ostream& str, RemoteId::OperatorId const& operator_id)

    str << std::setprecision(15);

    str << "operator_id:" << '\n' << "{\n";

    str << "    operator_id_type: " << operator_id.operator_id_type << '\n';

    str << "    operator_id: " << operator_id.operator_id << '\n';

    str << '}';

    return str;

std::ostream& operator<<(std::ostream& str, RemoteId::SelfId::DescType const& desc_type)

    switch (desc_type) {

        case RemoteId::SelfId::DescType::Text:

            return str << "Text";

        case RemoteId::SelfId::DescType::Emergency:

            return str << "Emergency";

        case RemoteId::SelfId::DescType::ExtendedStatus:

            return str << "Extended Status";

        default:

            return str << "Unknown";

bool operator==(const RemoteId::SelfId& lhs, const RemoteId::SelfId& rhs)

    return (rhs.description_type == lhs.description_type) && (rhs.description == lhs.description);

std::ostream& operator<<(std::ostream& str, RemoteId::SelfId const& self_id)

    str << std::setprecision(15);

    str << "self_id:" << '\n' << "{\n";

    str << "    description_type: " << self_id.description_type << '\n';

    str << "    description: " << self_id.description << '\n';

    str << '}';

    return str;

std::ostream& operator<<(std::ostream& str, RemoteId::ArmStatus::Status const& status)

    switch (status) {

        case RemoteId::ArmStatus::Status::GoodToArm:

            return str << "Good To Arm";

        case RemoteId::ArmStatus::Status::PreArmFailGeneric:

            return str << "Pre Arm Fail Generic";

        default:

            return str << "Unknown";

bool operator==(const RemoteId::ArmStatus& lhs, const RemoteId::ArmStatus& rhs)

    return (rhs.status == lhs.status) && (rhs.error == lhs.error);

std::ostream& operator<<(std::ostream& str, RemoteId::ArmStatus const& arm_status)

    str << std::setprecision(15);

    str << "arm_status:" << '\n' << "{\n";

    str << "    status: " << arm_status.status << '\n';

    str << "    error: " << arm_status.error << '\n';

    str << '}';

    return str;

std::ostream& operator<<(std::ostream& str, RemoteId::Result const& result)

    switch (result) {

        case RemoteId::Result::Unknown:

            return str << "Unknown";

        case RemoteId::Result::Success:

            return str << "Success";

        case RemoteId::Result::Error:

            return str << "Error";

        default:

            return str << "Unknown";