| |||
Home > Class Reference > The CAInterface class > About the CAInterface class |
CAInterface
provides a basis for a software
model built around components and interfaces.
For CADI, an interface:
is an abstract class consisting entirely of pure virtual methods
derives from CAInterface
provides a number of methods for interacting with a component.
are identified by a string name of type if_name_t
and
an integer revision of type if_rev_t
. A higher
revision number indicates a newer revision of the same interface.
A component is a black-box entity that has a unique identity and provides concrete implementations of one or more interfaces:
Each of these interfaces can expose different facets of the component behavior.
These interfaces are the only way to interact with the component.
There is no way for a client to enumerate the set of interfaces that a component implements. The client must ask for specific interfaces by name.
(The implementation of a component interface might be provided by one or several interacting C++ objects. This is an implementation detail that is transparent to the client.)
If the component does not implement the requested
interface, it returns a NULL
pointer.
The CAInterface
class is the base class
for all interfaces. It defines a method, CAInterface::ObtainInterface()
,
that enables a client to obtain a reference to any of the interfaces
that the component implements.
The client specifies the ID and revision of the interface
that it is requesting. The component can return NULL
if
it does not implement that interface, or only implements a lower
revision.
Because each interface derives from CAInterface
,
a client can call ObtainInterface()
on any
one interface pointer to obtain a pointer to any other interface
implemented by the same component.
The following rules govern the use of components and interfaces:
Each component is distinct. No two components can
return the same pointer for a given interface. An ObtainInterface()
call
on one component must not return an interface on a different component.
Each interface consists of a name, a revision number,
and a C++ abstract class definition. The return value of ObtainInterface()
is
either NULL
or a pointer, castable to the class
type.
Where two interfaces have the same if_name_t
,
the newer revision of the interface must be compatible with the
old revision. (This includes the binary layout of any data-structures that
it uses and the semantics of any methods.)
During the lifetime of a component, any calls to ObtainInterface()
for
a given interface name and revision must always return the same
pointer value. It must not matter which of the component interfaces
is used to invoke ObtainInterface()
.
All components must implement an interface derived
from eslapi::CAInterface
.