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");
// ---------------------------------------------------------------------
// Sets the stored number.
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// Returns the stored number.
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// Advanced class to store and handle a number.
// ---------------------------------------------------------------------
MAXON_INTERFACE(AdvancedNumberInterface, MAXON_REFERENCE_NORMAL, "net.maxonexample.interfaces.advancednumber_example");
// ---------------------------------------------------------------------
// Returns true if the number is even.
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// Adds the given value to the stored value.
// ---------------------------------------------------------------------
#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"
Definition: interface_inheritance.h:33
MAXON_METHOD void Add(maxon::Int n)
MAXON_METHOD maxon::Bool IsEven() const
MAXON_INTERFACE(AdvancedNumberInterface, MAXON_REFERENCE_NORMAL, "net.maxonexample.interfaces.advancednumber_example")
Definition: interface_inheritance.h:14
MAXON_METHOD void SetNumber(maxon::Int number)
MAXON_INTERFACE(NumberInterface, MAXON_REFERENCE_NORMAL, "net.maxonexample.interfaces.number")
MAXON_METHOD maxon::Int GetNumber() const
Definition: objectbase.h:709
const Py_UNICODE size_t n
Definition: unicodeobject.h:1184
Int64 Int
signed 32/64 bit int, size depends on the platform
Definition: apibase.h:188
bool Bool
boolean type, possible values are only false/true, 8 bit
Definition: apibase.h:181
Definition: interfacebase.h:1173
#define MAXON_DECLARATION(T, Name, id,...)
Definition: module.h:847
Definition: interfacebase.h:1001
Definition: objectbase.h:1062


Within the functions of an implementation it is possible to access the inherited functions using super:

// This example implements an interface which inherits from another interface.
// implementation of AdvancedNumberInterface
class AdvancedNumberImpl : public maxon::Component<AdvancedNumberImpl, AdvancedNumberInterface>
// add the component "NumberClass" as an implementation of the inherited interface "NumberInterface".
// 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()
// implementation of AdvancedNumberInterface functions
MAXON_METHOD maxon::Bool IsEven() const
return _even;
// 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
maxon::Bool _even;
@ Add
Definition: Python-ast.h:24
Definition: objectbase.h:2651
Samples the surface as the user moves over it the SculptObject and returns a new hit point and normal...
Definition: objectbase.h:2212

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
// use functions of derived interface
if (number.IsEven())
DiagnosticOutput("Number is even");
if (!number.IsEven())
DiagnosticOutput("Number is not even");
// use function of base interface
DiagnosticOutput("Number: @", number.GetNumber());
#define DiagnosticOutput(formatString,...)
Definition: debugdiagnostics.h:176


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().

Further Reading