Interface Inheritance
An interface can be based on one or many other interfaces. This way the interface inherits the methods defined in the parent interfaces. An implementation of such an interface can re-implement the methods of the parent interfaces. It is also possible to use existing implementations of the inherited interfaces when the component is registered.
Parent interfaces are defined with the MAXON_INTERFACE_BASES attribute. The default parent interface is maxon::ObjectInterface .
This example declares an interfaces that is directly based on maxon::ObjectInterface and an interface based on the previous interface:
// This example shows a base interface and a derived interface.// --------------------------------------------------------------------- // Simple class to store a number. // --------------------------------------------------------------------- class NumberInterface : MAXON_INTERFACE_BASES (maxon::ObjectInterface) { MAXON_INTERFACE (NumberInterface, MAXON_REFERENCE_NORMAL , "net.maxonexample.interfaces.number" );
// --------------------------------------------------------------------- // Returns the stored number. // --------------------------------------------------------------------- MAXON_METHOD maxon::Int GetNumber() const ; };
// --------------------------------------------------------------------- // Advanced class to store and handle a number. // --------------------------------------------------------------------- class AdvancedNumberInterface : MAXON_INTERFACE_BASES (NumberInterface) { MAXON_INTERFACE (AdvancedNumberInterface, MAXON_REFERENCE_NORMAL , "net.maxonexample.interfaces.advancednumber_example" );
// --------------------------------------------------------------------- // Adds the given value to the stored value. // --------------------------------------------------------------------- MAXON_METHOD void Add( maxon::Int n); }; #include "interface_inheritance1.hxx"
// published object "NumberClass" presents the component class for an implementation of NumberInterface MAXON_DECLARATION ( maxon::Class<NumberRef> , NumberClass, "net.maxonexample.class.number" );
// published object "AdvancedNumber" presents the reference object for an implementation of AdvancedNumberInterface MAXON_DECLARATION (AdvancedNumberRef, AdvancedNumber, "net.maxonexample.advancednumber" ); #include "interface_inheritance2.hxx"
Within the functions of an implementation it is possible to access the inherited functions using
super:
// implementation of AdvancedNumberInterface class AdvancedNumberImpl : public maxon::Component <AdvancedNumberImpl, AdvancedNumberInterface> { // add the component "NumberClass" as an implementation of the inherited interface "NumberInterface". MAXON_COMPONENT ( NORMAL , NumberClass); public : // overridden function of NumberInterface MAXON_METHOD void SetNumber( maxon::Int number) { // detect properties for fast access later _even = false ;
// check parity if (number % 2 == 0) _even = true ;
// call "SetNumber()" of the implementation defined with MAXON_COMPONENT() super.SetNumber(number); }
// implementation of AdvancedNumberInterface functions MAXON_METHOD maxon::Bool IsEven() const { return _even; } MAXON_METHOD void Add( maxon::Int n) { // obtain number value from super class maxon::Int number = super.GetNumber(); number += n;
// store number value by calling the implementation // of SetNumber() in this class self .SetNumber(number); } private : maxon::Bool _even; };
The result class can be used like this:
// This example shows the usage of a simple reference class. Both // functions of the base interface and a derived interface are used.// create object const AdvancedNumberRef number = AdvancedNumber();
// call overridden function number.SetNumber(100);
// use functions of derived interface if (number.IsEven()) DiagnosticOutput ( "Number is even" ); number.Add(1); if (!number.IsEven()) DiagnosticOutput ( "Number is not even" );
// use function of base interface DiagnosticOutput ( "Number: @" , number.GetNumber());
Additional components are typically implementations of the inherited interfaces and define the specific behaviour of the registered component. They can be added using the MAXON_COMPONENT() attribute or by implementing maxon::ComponentRoot::ConfigureClass().
