Interface Declaration

Table of Contents

About

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".

Declaration

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");
public:
// ---------------------------------------------------------------------
// Sets the number to store.
// ---------------------------------------------------------------------
MAXON_METHOD void SetNumber(maxon::Int number);
// ---------------------------------------------------------------------
// Returns the stored number.
// ---------------------------------------------------------------------
MAXON_METHOD maxon::Int GetNumber() const;
};
// 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"
SimpleClassInterface
[interfaces_basic_virtual_interface]
Definition: simpleclass.h:15
SimpleClassInterface::SetNumber
MAXON_METHOD void SetNumber(maxon::Int number)
SimpleClassInterface::MAXON_INTERFACE
MAXON_INTERFACE(SimpleClassInterface, MAXON_REFERENCE_NORMAL, "net.maxonexample.interfaces.simpleclass")
SimpleClassInterface::GetNumber
MAXON_METHOD maxon::Int GetNumber() const
maxon::Class
Definition: objectbase.h:696
maxon::Int
Int64 Int
signed 32/64 bit int, size depends on the platform
Definition: apibase.h:213
MAXON_REFERENCE_NORMAL
#define MAXON_REFERENCE_NORMAL(FREEIMPL)
Definition: interfacebase.h:1184
MAXON_DECLARATION
#define MAXON_DECLARATION(T, Name, id,...)
Definition: module.h:945
MAXON_METHOD
#define MAXON_METHOD
Definition: interfacebase.h:1012
MAXON_INTERFACE_BASES
#define MAXON_INTERFACE_BASES(...)
Definition: objectbase.h:1049

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.

Inheritance

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