On this page:
Basic Python Mapping for Classes
A Slice class maps to a Python class with the same name. The generated class contains an attribute for each Slice data member (just as for structures and exceptions). Consider the following class definition:
The Python mapping generates the following code for this definition:
There are a number of things to note about the generated code:
- The generated class
Ice.Value. This means that all classes implicitly inherit from
Ice.Value, which is the ultimate ancestor of all classes. Note that
Ice.Valueis not the same as
Ice.ObjectPrx. In other words, you cannot pass a class where a proxy is expected and vice versa.
- The constructor defines an attribute for each Slice data member.
- The class defines the method
ice_idand static method
There is quite a bit to discuss here, so we will look at each item in turn.
Ice.Value in Python
Like interfaces, classes implicitly inherit from a common base class,
Ice.Value. However classes inherit from
Ice.Value instead of
Ice.ObjectPrx (which is at the base of the inheritance hierarchy for proxies). As a result, you cannot pass a class where a proxy is expected (and vice versa) because the base types for classes and proxies are not compatible.
Ice.Value contains a number of methods:
The member functions of
Ice.Value behave as follows:
This method returns the actual run-time type ID of the object. If you call
ice_idthrough a reference to a base instance, the returned type ID is the actual (possibly more derived) type ID of the instance.
This method is generated in each class and returns the static type ID of the class.
The Ice run time invokes this method prior to marshaling the object's state, providing the opportunity for a subclass to validate its declared data members.
The Ice run time invokes this method after unmarshaling an object's state. A subclass typically overrides this function when it needs to perform additional initialization using the values of its declared data members.
This functions returns the
SlicedDataobject if the value has been sliced during un-marshaling or
Note that neither
Ice.Value nor the generated class override
__eq__, so the default implementations apply.
Class Data Members in Python
By default, data members of classes are mapped exactly as for structures and exceptions: for each data member in the Slice definition, the generated class contains a corresponding attribute.
Optional data members use the same mapping as required data members, but an optional data member can also be set to the marker value
Ice.Unset to indicate that the member is unset. A well-behaved program must test an optional data member before using its value:
Ice.Unset marker value has different semantics than
None is a legal value for certain Slice types, the Ice run time requires a separate marker value so that it can determine whether an optional value is set. An optional value set to
None is considered to be set. If you need to distinguish between an unset value and a value set to
None, you can do so as follows:
Although Python provides no standard mechanism for restricting access to an object's attributes, by convention an attribute whose name begins with an underscore signals the author's intent that the attribute should only be accessed by the class itself or by one of its subclasses. You can employ this convention in your Slice classes using the
protected metadata directive. The presence of this directive causes the Slice compiler to prepend an underscore to the mapped name of the data member. For example, the
TimeOfDay class shown below has the
protected metadata directive applied to each of its data members:
The Slice compiler produces the following generated code for this definition:
For a class in which all of the data members are protected, the metadata directive can be applied to the class itself rather than to each member individually. For example, we can rewrite the
TimeOfDay class as follows:
Class Constructors in Python
Classes have a constructor that assigns to each data member a default value appropriate for its type:
|Data Member Type||Default Value|
||First enumerator in enumeration|
You can also declare different default values for data members of primitive and enumerated types.
For derived classes, the constructor has one parameter for each of the base class's data members, plus one parameter for each of the derived class's data members, in base-to-derived order.
You can invoke this constructor in one of two ways:
Provide values for all members, including optional members, in the order of declaration:
Ice.Unsetas the value of any optional member you want to be unset.
Used named arguments to specify values for certain members and in any order:
Class Operations in Python
Operations on classes are deprecated as of Ice 3.7. Skip this section unless you need to communicate with old applications that rely on this feature.
With the Python mapping, operations in classes are not mapped at all into the corresponding Python class. The generated Python class is the same whether the Slice class has operations or not.
The Slice to Python compiler also generates a separate
<class-name>Disp class, which can be used to implement an Ice object with these operations. For example:
results in the following generated code:
Disp class is the Python skeleton class for this Slice class. Skeleton classes are described in the Server-Side Python Mapping for Interfaces.
Value Factories in Python
While value factories were previously necessary when using classes with operations (a now deprecated feature), value factories may be used for any kind of class and are not deprecated.
Value factories allow you to create classes derived from the Python class generated by the Slice compiler, and tell the Ice run time to create instances of these classes when unmarshaling. For example, with the following simple interface:
The Ice run time will by default create and return a plain
If you wish, you can create your own custom derived class, and tell Ice to create and return these instances instead. For example:
You then create and register a value factory for your custom class with your Ice communicator: