Slice classes are mapped to Java classes with the same name. The generated class contains a public data member for each Slice data member (just as for structures and exceptions), and a member function for each operation. Consider the following class definition:
class TimeOfDay {
short hour; // 0 ‑ 23
short minute; // 0 ‑ 59
short second; // 0 ‑ 59
string format(); // Return time as hh:mm:ss
};
public interface _TimeOfDayOperations {
String format(Ice.Current current);
}
public interface _TimeOfDayOperationsNC {
String format();
}
public abstract class TimeOfDay extends Ice.ObjectImpl
implements _TimeOfDayOperations,
_TimeOfDayOperationsNC {
public short hour;
public short minute;
public short second;
public TimeOfDay();
public TimeOfDay(short hour, short minute, short second);
// ...
}
2.
The generated class TimeOfDay inherits (indirectly) from
Ice.Object. This means that all classes implicitly inherit from
Ice.Object, which is the ultimate ancestor of all classes. Note that
Ice.Object is
not the same as
Ice.ObjectPrx. In other words, you
cannot pass a class where a proxy is expected and vice versa.
The methods in the _<interface‑name>Operations interface have an additional trailing parameter of type
Ice.Current, whereas the methods in the
_<interface‑name>OperationsNC interface lack this additional trailing parameter. The methods without the
Current parameter simply forward to the methods with a
Current parameter, supplying a default
Current. For now, you can ignore this parameter and pretend it does not exist. (We look at it in more detail in
Section 28.6.)
If a class has only data members, but no operations, the compiler omits generating the
_<interface‑name>Operations and
_<interface‑name>OperationsNC interfaces.
Like interfaces, classes implicitly inherit from a common base class, Ice.Object. However, as shown in
Figure 10.1, classes inherit from
Ice.Object 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.Object contains a number of member functions:
package Ice;
public interface Object
{
int ice_hash();
boolean ice_isA(String s);
boolean ice_isA(String s, Current current);
void ice_ping();
void ice_ping(Current current);
String[] ice_ids();
String[] ice_ids(Current current);
String ice_id();
String ice_id(Current current);
void ice_preMarshal();
void ice_postUnmarshal();
DispatchStatus ice_dispatch(
Request request,
DispatchInterceptorAsyncCallback cb);
}
The member functions of Ice.Object behave as follows:
Note that the generated class does not override
hashCode and
equals. This means that classes are compared using shallow reference equality, not value equality (as is used for structures).
The class also provides a clone method (whose implementation is inherited from
Ice.ObjectImpl); the
clone method returns a shallow memberwise copy.
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 public data member.
If you wish to restrict access to a data member, you can modify its visibility using the
protected metadata directive. The presence of this directive causes the Slice compiler to generate the data member with protected visibility. As a result, the member can be accessed only by the class itself or by one of its subclasses. For example, the
TimeOfDay class shown below has the
protected metadata directive applied to each of its data members:
class TimeOfDay {
["protected"] short hour; // 0 ‑ 23
["protected"] short minute; // 0 ‑ 59
["protected"] short second; // 0 ‑ 59
string format(); // Return time as hh:mm:ss
};
public abstract class TimeOfDay extends Ice.ObjectImpl
implements _TimeOfDayOperations,
_TimeOfDayOperationsNC {
protected short hour;
protected short minute;
protected short second;
public TimeOfDay();
public TimeOfDay(short hour, short minute, short second);
// ...
}
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:
["protected"] class TimeOfDay {
short hour; // 0 ‑ 23
short minute; // 0 ‑ 59
short second; // 0 ‑ 59
string format(); // Return time as hh:mm:ss
};
Refer to Section 10.15.4 for additional information on data members.
Operations of classes are mapped to abstract member functions in the generated class. This means that, if a class contains operations (such as the
format operation of our
TimeOfDay class), you must provide an implementation of the operation in a class that is derived from the generated class. For example:
public class TimeOfDayI extends TimeOfDay {
public String format(Ice.Current current) {
DecimalFormat df
= (DecimalFormat)DecimalFormat.getInstance();
df.setMinimumIntegerDigits(2);
return new String(df.format(hour) + ":" +
df.format(minute) + ":" +
df.format(second));
}
}
Having created a class such as TimeOfDayI, we have an implementation and we can instantiate the
TimeOfDayI class, but we cannot receive it as the return value or as an out-parameter from an operation invocation. To see why, consider the following simple interface:
When a client invokes the get operation, the Ice run time must instantiate and return an instance of the
TimeOfDay class. However,
TimeOfDay is an abstract class that cannot be instantiated. Unless we tell it, the Ice run time cannot magically know that we have created a
TimeOfDayI class that implements the abstract
format operation of the
TimeOfDay abstract class. In other words, we must provide the Ice run time with a factory that knows that the
TimeOfDay abstract class has a
TimeOfDayI concrete implementation. The
Ice::Communicator interface provides us with the necessary operations:
module Ice {
local interface ObjectFactory {
Object create(string type);
void destroy();
};
local interface Communicator {
void addObjectFactory(ObjectFactory factory, string id);
ObjectFactory findObjectFactory(string id);
// ...
};
};
To supply the Ice run time with a factory for our TimeOfDayI class, we must implement the
ObjectFactory interface:
class ObjectFactory implements Ice.ObjectFactory {
public Ice.Object create(String type) {
if (type.equals("::M::TimeOfDay")) {
return new TimeOfDayI();
}
assert(false);
return null;
}
public void destroy() {
// Nothing to do
}
}
The object factory’s create method is called by the Ice run time when it needs to instantiate a
TimeOfDay class. The factory’s
destroy method is called by the Ice run time when its communicator is destroyed.
The create method is passed the type ID (see
Section 4.13) of the class to instantiate. For our
TimeOfDay class, the type ID is
"::M::TimeOfDay". Our implementation of
create checks the type ID: if it is
"::M::TimeOfDay", it instantiates and returns a
TimeOfDayI object. For other type IDs, it asserts because it does not know how to instantiate other types of objects.
Given a factory implementation, such as our ObjectFactory, we must inform the Ice run time of the existence of the factory:
Ice.Communicator ic = ...;
ic.addObjectFactory(new ObjectFactory(), "::M::TimeOfDay");
Now, whenever the Ice run time needs to instantiate a class with the type ID "::M::TimeOfDay", it calls the
create method of the registered
ObjectFactory instance.
The destroy operation of the object factory is invoked by the Ice run time when the communicator is destroyed. This gives you a chance to clean up any resources that may be used by your factory. Do not call
destroy on the factory while it is registered with the communicator—if you do, the Ice run time has no idea that this has happened and, depending on what your
destroy implementation is doing, may cause undefined behavior when the Ice run time tries to next use the factory.
The run time guarantees that destroy will be the last call made on the factory, that is,
create will not be called concurrently with
destroy, and
create will not be called once
destroy has been called. However, calls to
create can be made concurrently.
Note that you cannot register a factory for the same type ID twice: if you call addObjectFactory with a type ID for which a factory is registered, the Ice run time throws an
AlreadyRegisteredException.
Finally, keep in mind that if a class has only data members, but no operations, you need not create and register an object factory to transmit instances of such a class. Only if a class has operations do you have to define and register an object factory.
The generated class contains both a default constructor, and a constructor that accepts one argument for each member of the class. This allows you to create and initialize a class in a single statement, for example:
TimeOfDayI tod = new TimeOfDayI(14, 45, 00); // 14:45pm
class TimeOfDay {
short hour; // 0 ‑ 23
short minute; // 0 ‑ 59
short second; // 0 ‑ 59
};
class DateTime extends TimeOfDay {
short day; // 1 ‑ 31
short month; // 1 ‑ 12
short year; // 1753 onwards
};
public class TimeOfDay extends Ice.ObjectImpl {
public TimeOfDay() {}
public TimeOfDay(short hour, short minute, short second)
{
this.hour = hour;
this.minute = minute;
this.second = second;
}
// ...
}
public class DateTime extends TimeOfDay
{
public DateTime()
{
super();
}
public DateTime(short hour, short minute, short second,
short day, short month, short year)
{
super(hour, minute, second);
this.day = day;
this.month = month;
this.year = year;
}
// ...
}
In other words, if you want to instantiate and initialize a DateTime instance, you must either use the default constructor or provide data for all of the data members of the instance, including data members of any base classes.
