Exceptions

A Slice exception is mapped to a C++ class with the same name. This mapping is similar to the mapping of classes.

Consider the following Slice exceptions:

module M
{
    exception GenericException
    {
        string reason;
    }

    exception BadTimeValException extends GenericException {}
}

The Slice compiler generates the following code for these exceptions:

class GenericException : public Ice::UserException
{
public:
    GenericException() noexcept = default;
    GenericException(std::string reason) noexcept;
    GenericException(const GenericException&) noexcept = default;

    void ice_throw() const override;

    std::string reason;
};

class BadTimeValException : public GenericException
{
public:
    using GenericException::GenericException;

    void ice_throw() const override;
};

There are a number of things to note about this generated code:

1. The generated class GenericException inherits from Ice::UserException. Ice::UserException is the ultimate ancestor of all mapped exceptions. It derives indirectly from std::exception.
2. The generated class contains a public data member for each Slice field.
3. The generated class has a constructor that takes one argument for each data member, as well as a default constructor.
4. The generated class as a noexcept copy-constructor, as required by C++ exception rules.
5. The generated class has a virtual function, ice_throws. It is implemented by throwing *this.
6. The generated class for BadTimeValException derives from the generated class GenericException.

Exception Printing

You can print any user exception instance by calling ice_print on this instance. ice_print is defined on Ice::Exception. Alternatively, you can print an exception instance with operator<<:

try
{
   ...
}
catch (const GreeterException& exception)
{
    cout << "Caught " << exception << endl;
}

operator<< just calls Ice::Exception::ice_print.

You can use the metadata directive "cpp:custom-print" to tell the Slice compiler that you want to use your own custom print implementation. For example:

["cpp:custom-print"]
exception GreeterException { ... }

The Slice compiler then generates an ice_print override declaration in the mapped C++ class, and you are responsible to implement this member function.

A Slice exception is mapped to a C# class with the same name. This mapping is similar to the mapping of classes.

Consider the following Slice exceptions:

module M
{
    exception GenericException
    {
        string reason;
    }

    exception BadTimeValException extends GenericException {}
}

The Slice compiler generates the following code for these exceptions:

public partial class GenericException : Ice.UserException
{
    public string reason = "";

    public GenericException(string reason) { ... }
    public GenericException() {}
}

public partial class BadTimeValException : GenericException
{
      public BadTimeValException(string reason)
          : base(reason)
      {
      }

      public BadTimeValException() {}
}

There are a number of things to note about this generated code:

1. The generated class GenericException inherits from Ice.UserException. Ice.UserException is the ultimate ancestor of all mapped exceptions. It derives indirectly from System.Exception.
2. The generated class contains a public field for each Slice field.
3. The generated class for BadTimeValException derives from the generated class GenericException.
4. The generated class provides a primary constructor and a parameterless constructor; they are identical to the generated constructors for classes. See C# Mapping for Classes.

A Slice exception is mapped to a Java class with the same name. This mapping is similar to the mapping of classes.

Consider the following Slice exceptions:

module M
{
    exception GenericException
    {
        string reason;
    }

    exception BadTimeValException extends GenericException {}
}

The Slice compiler generates the following code for these exceptions:

public class GenericException extends com.zeroc.Ice.UserException {
    public String reason;

    public GenericException() {
        this.reason = "";
    }

    public GenericException(String reason) {
        this.reason = reason;
    }

    // ...
}

public class BadTimeValException extends GenericException {
    public BadTimeValException() {
    }

    public BadTimeValException(String reason) {
        super(reason);
    }

    // ...
}

There are a number of things to note about this generated code:

1. The generated class GenericException inherits from UserException. UserException is the ultimate ancestor of all mapped exceptions. It’s a checked exception that derives from java.lang.Exception.
2. The generated class contains a public field for each Slice field.
3. The generated class for BadTimeValException derives from the generated class GenericException.
4. The generated class provides a canonical constructor and a parameterless constructor; they are identical to the generated constructors for classes. See Java Mapping for Classes.

Exception Specification

When an Slice operation has an exception specification, the corresponding client-side and server-side methods in Java have an exception specification. This is true for all mapped methods, except the proxy Async methods.

For example:

interface Greeter
{
    ["amd"]
    string greet(string name) throws BadNameException, GoneFishingException;
}

maps to:

// Client-side
public interface GreeterPrx extends com.zeroc.Ice.ObjectPrx {
    default String greet(String name)
        throws BadNameException, GoneFishingException {
        ...
    }

    default String greet(String name, java.util.Map<String, String> context)
        throws BadNameException, GoneFishingException {
        ...
    }

    // No exception specification
    default CompletableFuture<String> greetAsync(String name) {
        ...
    }

    default CompletableFuture<String> greetAsync(String name, java.util.Map<String, String> context) {
        ...
    }
}

// Server-side
public interface Greeter extends com.zeroc.Ice.Object {
    CompletionStage<String> greetAsync(String name, com.zeroc.Ice.Current current)
        throws BadNameException, GoneFishingException;
}

A Slice exception is mapped to a JavaScript class with the same name. This mapping is similar to the mapping of JavaScript Mapping for Classes.

Consider the following Slice exceptions:

module M
{
    exception GenericException
    {
        string reason;
    }

    exception BadTimeValException extends GenericException {}
}

The Slice compiler generates the following code for these exceptions:

class GenericException extends Ice.UserException {
    constructor(reason = "") {
        super();
        this.reason = reason;
    }
    ...
}

class BadTimeValException extends GenericException {}

class GenericException extends Ice.UserException {
    constructor(reason?: string);

    reason: string;
}

class BadTimeValException extends GenericException {}

There are a number of things to note about this generated code:

1. The generated class GenericException inherits from Ice.UserException. Ice.UserException is the ultimate ancestor of all mapped exceptions. It derives indirectly from JavaScript Error type.
2. The generated class contains a field for each Slice field.
3. The generated class for BadTimeValException derives from the generated class GenericException.
4. The generated class provides a constructor with a parameter for each field, just like mapped classes.

A Slice exception is mapped to a MATLAB class with the same name. This mapping is similar to the mapping of classes.

Consider the following Slice exceptions:

module M
{
    exception GenericException
    {
        string reason;
    }

    exception BadTimeValException extends GenericException {}
}

The Slice compiler generates the following code for these exceptions:

classdef GenericException < Ice.UserException
    properties
      reason (1, :) char
    end
    methods
       ...
    end
end

classdef BadTimeValException < M.GenericException
    methods
       ...
    end
end

There are a number of things to note about this generated code:

1. The generated class GenericException inherits from Ice.UserException. Ice.UserException is the ultimate ancestor of all mapped exceptions. It derives indirectly from MException.
2. The generated class contains a public property for each Slice field.
3. The generated class for BadTimeValException derives from the generated class GenericException.
4. The methods of the generated class are unimportant; in particular, since Ice for MATLAB is client-only, you don’t need to create user exceptions in MATLAB.

A Slice exception is mapped to a PHP class with the same name. This mapping is similar to the mapping of classes.

Consider the following Slice exceptions:

module M
{
    exception GenericException
    {
        string reason;
    }

    exception BadTimeValException extends GenericException {}
}

The Slice compiler generates the following code for these exceptions:

class GenericException extends \Ice\UserException
{
    public $reason;
    // ...
}

class BadTimeValException extends \M\GenericException
{
    // ..
}

There are a number of things to note about this generated code:

1. The generated class GenericException inherits from \Ice\UserException. \Ice\UserException is the ultimate ancestor of all mapped exceptions. It derives indirectly from \Exception.
2. The generated class contains a public variable for each Slice field.
3. The generated class for BadTimeValException derives from the generated class GenericException.
4. The methods of the generated class are unimportant; in particular, since Ice for PHP is client-only, you don’t need to create user exceptions in PHP.

A Slice exception is mapped to a Python class with the same name. This mapping is similar to the mapping of classes.

Consider the following Slice exceptions:

module M
{
    exception GenericException
    {
        string reason;
    }

    exception BadTimeValException extends GenericException {}
}

The Slice compiler generates the following code for these exceptions:

@dataclass
class GenericException(UserException):
    reason: str = ""

@dataclass
class BadTimeValException(GenericException):
    pass

There are a number of things to note about this generated code:

1. The generated classes are dataclasses, just like the mapping for classes.
2. The generate class GenericException inherits from UserException. Ice.UserException is the ultimate ancestor of all mapped exceptions. It derives indirectly from builtins.Exception.
3. The generated class contains a public field for each Slice field.
4. The generated class for BadTimeValException derives from the generated class GenericException.

A Slice exception is mapped to a Ruby class with the same name. This mapping is similar to the mapping of classes.

Consider the following Slice exceptions:

module M
{
    exception GenericException
    {
        string reason;
    }

    exception BadTimeValException extends GenericException {}
}

The Slice compiler generates the following code for these exceptions:

module ::M
    class GenericException < Ice::UserException
        attr_accessor :reason
        # ...
    end

    class BadTimeValException < ::M::GenericException
    # ...
    end
end

There are a number of things to note about this generated code:

1. The generated class GenericException inherits from Ice::UserException. Ice::UserException is the ultimate ancestor of all mapped exceptions. It derives indirectly from ::StandardError.
2. For each Slice field, the generated class contains an instance variable and accessors to read and write this variable.
3. The generated class for BadTimeValException derives from the generated class GenericException.
4. The methods of the generated class are unimportant; in particular, since Ice for Ruby is client-only, you don’t need to create user exceptions in Ruby.

A Slice exception is mapped to a Swift class with the same name. This mapping is similar to the mapping of classes.

Consider the following Slice exceptions:

module M
{
    exception GenericException
    {
        string reason;
    }

    exception BadTimeValException extends GenericException {}
}

The Slice compiler generates the following code for these exceptions:

open class GenericException: Ice.UserException, @unchecked Sendable {
    public var reason: String = ""

    public required init() {}

    public init(reason: String) {
        self.reason = reason
    }
    // ...
}

open class BadTimeValException: GenericException, @unchecked Sendable {
    // ...
}

There are a number of things to note about this generated code:

1. The generated class GenericException derives from Ice.UserException. The Ice.UserException class is the ultimate ancestor of all mapped exceptions. It conforms to the Error protocol.
2. The generated class contains a public property for each Slice field.
3. The generated class for BadTimeValException derives from the generated class GenericException.
4. The generated class a provides default initializer and a memberwise initializer; they are identical to the generated initializers for Slice classes.