Fields

Syntax

A field is defined as Type name, where Type is the field's type and name is the field's name. For example:

string name;
ByteSeq image;
Fruit fruit;

Each field definition must be followed by a semicolon. You can define several fields on the same line if you wish, as in:

struct Point { int x; int y; }

The type of a field can be a basic type, a user-defined type, Object* (an untyped proxy), or Value(an untyped class instance).

Nullable and Non-Nullable Fields

Fields with proxy and class types are nullable. Optional fields (presented below) are also nullable. All other fields are non-nullable, meaning they must have a value when transmitted through Ice.

struct Example
{
    int count; // must be set
    Greeter* greeter; // proxy type, so it can be null
    Node node; // class type, so it can be null
}

Optional Fields

A field of a Slice class or exception may be declared as optional to indicate that a program can leave its value unset. Fields not declared as optional are known as required fields; a program must supply legal values for all required fields.

Each optional field must be assigned a unique, non-negative integer tag:

module M
{
    class C
    {
        string name;
        bool active;
        optional(2) string alternateName;
        optional(5) int overrideCode;
    }
}

It is legal for a base type's tag to be reused by a derived type:

exception BaseException
{
    optional(1) int systemCode;
}
 
exception DerivedException extends BaseException
{
    optional(1) string diagnostic; // OK
}

The scope of a tag is limited to its enclosing type and has no effect on base or derived types.

You can mark any field as optional, except if the field’s type is a class type or a constructed type that holds a class type. At the field level, optional and class are incompatible.

Optional fields and required fields can appear in any order in your class definition. You can also assign tags in any order. For example:

class UnusualButValidPerson
{
    optional(5) string nickname;
    string name;
    optional(0) Date dateOfBirth; // Date is a struct
    string currentAddress;
    optional(123) Fruit favoriteFruit; // Fruit is an enum
}

Default Values

You can specify a default value for a field that has one of the following types:

• An integral type (byte, short, int, long)

• A floating point type (float or double)

• string

• bool

• enum

For example:

struct Location
{
    string name;
    Point pt;
    bool display = true;
    string source = "GPS";
}

The legal syntax for literal values is the same as for Slice constants, and you may also use a constant as a default value. The language mapping guarantees that fields are initialized to their declared default values using a language-specific mechanism.

You can declare a default value for optional fields just as you can for required fields:

class C
{
    string name;
    bool active = true;
    optional(2) string alternateName;
    optional(5) int overrideCode = -1;
}

An optional field with a default value is considered to be set by default.

Language Mapping

A Slice field maps to a Swift property with the same name. The type of the property is the mapped Slice type. When the Slice field is non-optional, the property type is non-optional as well, except for class and proxy fields.

For example:

class Address { ... }

struct Person
{
    string name;
    Address address;
}

maps to:

public final class Person {
    public var name: String = ""       // non-optional String
    public var address: Address? = nil // optional Address
    ...
}

Optional Fields

An optional field maps to a Swift stored property with the same name. The mapped property’s type is optional. The tag value is not mapped to Swift.

For example:

class C
{
    optional(2) string alternateName;
    optional(5) int overrideCode;
    optional(1) Widget* favoriteWidgetProxy;
}

maps to:

open class C: Ice.Value {
    public var alternateName: String? = nil
    public var overrideCode: Int32? = nil
    public var favoriteWidgetProxy: WidgetPrx? = nil
    ...
}

Optional and non-optional proxies are mapped the same way, as illustrated above. As a result, you cannot distinguish between an optional proxy property that is not set and an optional proxy property set to nil.

Default Values

Slice default values map to default property values in Swift.

For example:

struct Location
{
    string name;
    Point point;
    bool display = true;
    string source = "GPS";
}

maps to:

public struct Location: Hashable, Sendable {
    public var name: String = ""
    public var point: Point = Point()
    public var display: Bool = true
    public var source: String = "GPS"
    ...
}

When you don’t define a default value in Slice, and you initialize a property without providing a value for this property, the generated code uses the following default: