Interface Declaration


The declaration of an interface is a virtual class that defines the methods, inheritance and reference mode of the interface. This interface is the base for any implementation and also the base for the automatically generated reference class.

An interface class must be named in the scheme of "ClassnameInterface". The automatically defined reference class will then be named "ClassnameRef".


The declaration of an interface is a C++ class declaration extended with multiple MAXON API attributes.

// This example shows the declaration of a simple interface.
// ---------------------------------------------------------------------
// Simple class that stores a maxon::Int number.
// ---------------------------------------------------------------------
class SimpleClassInterface : MAXON_INTERFACE_BASES(maxon::ObjectInterface)
MAXON_INTERFACE(SimpleClassInterface, MAXON_REFERENCE_NORMAL, "net.maxonexample.interfaces.simpleclass");
// ---------------------------------------------------------------------
// Sets the number to store.
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// Returns the stored number.
// ---------------------------------------------------------------------
// This interface is declared in a file named "simpleclass.h". The automatically
// generated files are therefore named "simpleclass1.hxx" and "simpleclass2.hxx"
// The .hxx header files define the reference class "SimpleClassRef".
#include "simpleclass1.hxx"
// declare the published objects "SomeSimpleClass" and "OtherSimpleClass"
// that give access to implementations of SimpleClassInterface
// the declaration must be placed between the two hxx files since "SimpleClassRef" is defined in the first hxx file
MAXON_DECLARATION(maxon::Class<SimpleClassRef>, SomeSimpleClass, "net.maxonexample.somesimpleclass");
MAXON_DECLARATION(SimpleClassRef, OtherSimpleClass, "net.maxonexample.othersimpleclass");
#include "simpleclass2.hxx"
Definition: simpleclass.h:15
MAXON_METHOD void SetNumber(maxon::Int number)
MAXON_INTERFACE(SimpleClassInterface, MAXON_REFERENCE_NORMAL, "net.maxonexample.interfaces.simpleclass")
MAXON_METHOD maxon::Int GetNumber() const
Definition: objectbase.h:709
Int64 Int
signed 32/64 bit int, size depends on the platform
Definition: apibase.h:188
Definition: interfacebase.h:1173
#define MAXON_DECLARATION(T, Name, id,...)
Definition: module.h:847
Definition: interfacebase.h:1001
Definition: objectbase.h:1062

In this example the following attributes are used:

  • MAXON_INTERFACE_BASES: Defines the base interfaces this interface inherits from. In this case the base interface is maxon::ObjectInterface, which is the base interface of all interfaces.
  • MAXON_INTERFACE: Marks a class declaration as a virtual interface declaration, defines the reference type (see below) and the interface ID.
  • MAXON_METHOD: Declares a member function as virtual. A component can implement this function. For other types of functions see Interface Methods.
  • MAXON_DECLARATION: Declares a public object that gives access to a specific implementation of this interface. See Published Objects.

The Source Processor will analyse the interface and will create additional classes (like the reference class) automatically. This generated code is stored in automatically generated header files. These header files must be included in the original header file that contains the interface declaration. These automatically generated header files are named after the original header file. If the original file is named myclass.h, the header files are named myclass1.hxx and myclass2.hxx.


An interface can be based on one or many other interfaces. For details see Interface Inheritance.

Reference Type

The reference type of an interface defines how instances of the reference class behave. For details see Reference Types.

Single Implementation

To attribute MAXON_INTERFACE_SINGLE_IMPLEMENTATION is used to declare that only one implementation of this interface is accepted. In any other case multiple implementations of a given interface can exist.

A typical use-case would be a static interface that only defines static methods.

Further Reading