#include <IInterface.h>
Inheritance diagram for mx::IInterface:
These interfaces contain nothing but pure virtual methods and are designed to minimize compilation dependencies between MxSDK
components. To that end they limit themselves to use in their signatures only trivial data types or those provided by the underlying SDK's system libraries (mxm
, mxcpc
, ...). Interfaces to GUI components may obviously also use Qt
datatypes.
The MxSDK
's I*
interfaces come in two flavors:
ISupports*Specification
Interfaces : denote that the component allows the client context to specify a specific set of parameters. Example: ISupportsHostSpecification
IRequires*
Interfaces : indicate that the component requires some external entity implementing a particular concept (interface) in order to function properly. Example: IRequiresExternalAuthenticator
ICanUse*
Interfaces : indicate that the component allows client contexts to toggle whether or not it should use (activate) a specific concept. To that end the component provides appropriate use*()
methods. Example: ICanUseAuthenticationDialog
with its method ICanUseAuthenticationDialog::useAuthenticationDialog()
.I*Receiver
Interfaces : for dataflow modelling - indicate that the component receives data of a specific kind for further processing. Such interfaces typically contain methods named receive*()
, where *
stands for the respective type of data, that client contexts may call to actively perform the transfer. These interfaces can therefore be seen as "passive" interfaces. Example: IStreamReceiver
with the method IStreamReceiver::receiveStreamBytes()
ISends*
Interfaces : for dataflow modelling - form the counterpart to the aforementioned I*Receiver
interfaces and indicate that the components actively send data of the respective type by calling the receive*()
methods. In order to do so, they obviously need to know where to transfer the data, so each ISends*
interface contains a respective set*Receiver()
method. Example: ISendsMxPEGTiles
with its method ISendsMxPEGTiles::setMxPEGTileReceiver()
IProcesses*
Interfaces : for dataflow modelling - are similar to I*Receiver
interfaces in that they also describe components that accept data of a specific kind for further processing, but differ in that the respective components are not "passive" in doing so, but perform the active role instead. As such they rather actively fetch their input data from an appropriate data source (guess what, implemented by I*Source
interfaces) by calling respective fetch*()
methods on it. These fetches are implemented in a matching process*()
method. Example: IProcessesStream
with its method IProcessesStream::processStreamBytes()
I*Source
Interfaces : for dataflow modelling - see IProcesses*
interfaces above. Example: IStreamSource
with its method IStreamSource::fetchStreamBytes()
. IHTTPGetStreamSource
. Click it to learn which fearture interfaces and other concept iterfaces it inherits (The dashed interface boxes indicate that the interfaces are inherited virtually).
As I*
interfaces are by general rule always inherited virtually, that is: using the virtual
keyword, concept interfaces are not required to be mutually disjoint.
[agu]
Alexander Gugau
[khe]
Kai Hergenroether