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 Python dataclass field with the same name. The type of the Python field is the mapped Slice type.

For example:

class Address { ... }

struct Person
{
    string name;
    Address address;
}

maps to:

@dataclass
class Person:
    name: str = ""
    address: Address | None = None

Optional Fields

An optional field maps to a Python field with the same name. The mapped field’s type is the mapped type or None, and the tag value is not mapped to Python.

For example:

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

maps to:

@dataclass(eq=False)
class C(Value):
    alternateName: str | None = None
    overrideCode: int | None = None
    favoriteWidgetProxy: WidgetPrx | None = None

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

Default Values

Slice default values map to default values in Python.

For example:

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

maps to:

@dataclass(order=True, unsafe_hash=True)
class Location:
    name: str = ""
    point: Point = field(default_factory=Point)
    display: bool = True
    source: str = "GPS"

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

See Also

• Classes

• Structures

• User Exceptions