net.jxta.platform
Class ModuleSpecID
java.lang.Object
|
+--net.jxta.id.ID
|
+--net.jxta.platform.ModuleSpecID
- All Implemented Interfaces:
- java.lang.Cloneable, java.io.Serializable
- public abstract class ModuleSpecID
- extends ID
A ModuleSpecID uniquely identifies a particular network behaviour
(wire protocol and choregraphy) that may be embodied by a Jxta Module.
There may be any number of implementations of a given SpecID. All
such implementations are assumed to be network compatible.
The Specification that corresponds to a given ModuleSpecID may be published
in a ModuleSpecAdvertisement. This advertisement is uniquely identified by
the ModuleSpecID that it describes.
The various implementations of a given SpecID may be published in
ModuleImplAdvertisements. These advertisements are identified by the
ModuleSpecID that they implement and a compatibility statement.
ModuleImplAdvertisements baring the same SpecID and compatibility statement
are theorethicaly interchangeable. However they may be subsequently discriminated
by a Description element.
A ModuleSpecID embeds a ModuleClassID which uniquely identifies a base Module
class. A base module class defines a local behaviour and one API per compatible
JXTA implementation.
A ModuleSpecID therefore uniquely identifies an abstract module, of which an
implementation compatible with the local JXTA implementation may be located and
instantiated.
In the standard PeerGroup implementation of the java reference implementation
the various services are specified as a list of ModuleSpecID, for each of which
the group locates and loads an implementation as part of the group's
initialization.
- Since:
- JXTA 1.0
- Version:
- $Revision: 1.3 $
- See Also:
PeerGroup,
Module,
ModuleClassID,
ModuleSpecAdvertisement,
ModuleImplAdvertisement,
ID,
Advertisement, Serialized Form
| Methods inherited from class java.lang.Object |
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait |
ModuleSpecID
public ModuleSpecID()
isOfSameBaseClass
public abstract boolean isOfSameBaseClass(ModuleClassID id)
- Returns true if this ModuleSpecID is of the same base class than the
given class.
Note: This method is NOT named "isOfClass" because a ModuleClassID
may have two portions; one that denotes a class proper,
and an optional second one that denotes a "Role". For convenience, we refer
the class stripped of its role portion as "the base class" although this is not
a totally accurate term.
A ModuleSpecID, is of a base class but is not related to any kind
of role. So using "isOfClass" could be misleading.
Base classes are represented by a class with the role ID set to zero, which
happens to be a valid class. This routine may be used for comparison with
such a class, of course.
- Parameters:
id - Module class id to compare with- Returns:
- boolean true if equals
- Since:
- JXTA 1.0
isOfSameBaseClass
public abstract boolean isOfSameBaseClass(ModuleSpecID id)
- Returns true if this ModuleSpecID is of the same base class than the
the given ModuleSpecID.
- Parameters:
id - Module spec id to compare with- Returns:
- boolean true if equals
- Since:
- JXTA 1.0
getBaseClass
public abstract ModuleClassID getBaseClass()
- Return a ModuleClassID of the same base class but with the role portion
set to zero. aka "the base class".
- Returns:
- ModuleClassID the base class.
- Since:
- JXTA 1.0