Exceptions

Overview

Robot Raconteur uses exceptions to handle errors. Robot Raconteur has a built-in set of exceptions defined by the library, and also allows custom exceptions to be defined in service definitions. See the Framework Exceptions Documentation for a full list of exceptions, and the documentation for each programming language for how they are used. All custom exceptions extend RobotRaconteurRemoteException.

Robot Raconteur can transparently pass exceptions from the service to the client (or client to service for callbacks). The following operations will transparently pass exceptions: * property get and set * function calls * objref get * pipe connect and close endpoints (for client) * callback calls (passing from client to service) * wire connect, close (for clients), peek, and poke * memory all operations

The example service definition experimental.exception_example contains a custom exception and an object with functions that will throw exceptions as an example. The service definition is shown below:

service experimental.exception_example

stdver 0.10

exception MyExampleCustomException

object ExceptionExample
    function void my_exception_function1()
    function void my_exception_function2()
end

The following example code demonstrates how to catch exceptions thrown by the example service:

# exception_example.py - Example of using exceptions in Python

from RobotRaconteur.Client import *

# Connect to the service
url = 'rr+tcp://localhost:53224/?service=exception_example'
c = RRN.ConnectService(url)

# Call the functions

# Catch an OperationFailedException built-in exception
try:
    c.my_exception_function1()
except RR.OperationFailedException as e:
    print("Caught OperationFailedException: " + str(e))

# Catch a custom exception
exp_type = RRN.GetExceptionType("experimental.exception_example.MyExampleCustomException", c)
try:
    c.my_exception_function2()
except exp_type as e:
    print("Caught MyExampleCustomException: " + str(e))

# Catch RobotRaconteurException to catch all Robot Raconteur exceptions
try:
    c.my_exception_function1()
except RR.RobotRaconteurException as e:
    print("Caught RobotRaconteurException: " + str(e))

% exceptions_example.m - Example of using exceptions in MATLAB

% Connect to the service
url = 'rr+tcp://localhost:53224/?service=exception_example';
c = RobotRaconteur.ConnectService(url);

% MATLAB does not filter exceptions by type, so any errors are caught by the catch block
try
    c.my_exception_function1();
catch e
    disp(e.message);
end

try
    c.my_exception_function2();
catch e
    disp(e.message);
end

// exception_example.cs - Example of handling exceptions in C#

using RobotRaconteur;
using System;
using System.Diagnostics;
using System.Linq;
using System.Collections.Generic;

using (var node_setup = new ClientNodeSetup(args))
{
    var c = (experimental.exception_example.ExceptionExample)RobotRaconteurNode.s.ConnectService(
        "rr+tcp://localhost:53224/?service=exception_example");

    // Catch an OperationFailedException built-in exception
    try
    {
        c.my_exception_function1();
    }
    catch (OperationFailedException e)
    {
        Console.WriteLine("Caught exception: " + e.Message);
    }

    // Catch a custom exception
    try
    {
        c.my_exception_function2();
    }
    catch (experimental.exception_example.MyExampleCustomException e)
    {
        Console.WriteLine("Caught exception: " + e.Message);
    }
}

// container_value_types.cpp - Example of using container value types (maps and lists)

#include <stdio.h>
#include <iostream>
#include <boost/range/algorithm.hpp>
#include <RobotRaconteur.h>
#include "robotraconteur_generated.h"

// Only use the RR alias in cpp files. Do not use it in header files.
namespace RR = RobotRaconteur;

int main(int argc, char* argv[])
{
    RR::ClientNodeSetup node_setup(ROBOTRACONTEUR_SERVICE_TYPES, argc, argv);

    experimental::exception_example::ExceptionExamplePtr c =
        RR::rr_cast<experimental::exception_example::ExceptionExample>(
            RR::RobotRaconteurNode::s()->ConnectService("rr+tcp://localhost:53224/?service=exception_example"));

    // Catch an OperationFailedException built-in exception
    try
    {
        c->my_exception_function1();
    }
    catch (const RR::OperationFailedException& e)
    {
        std::cout << "Caught OperationFailedException: " << e.what() << std::endl;
    }

    // Catch a custom exception
    try
    {
        c->my_exception_function2();
    }
    catch (const experimental::exception_example::MyExampleCustomException& e)
    {
        std::cout << "Caught MyExampleCustomException: " << e.what() << std::endl;
    }

    std::cout << "exception_example.cpp example complete" << std::endl;
    return 0;
}