objectbase.h File Reference

Classes

class  ComponentDescriptor
 
class  IsComplete< Class< T >, COUNTER >
 
class  Class< R >
 
struct  ClassGetNonConst< REF >
 
struct  ClassGetNonConst< ObjectRef >
 
class  ClassInterface
 
class  ObjectInterface
 
struct  ObjectInterface::ReferenceFunctions< ST >
 
struct  ObjectInterface::PrivateSuperMTable
 
struct  CastHelper< R, SRC, Bool >
 
struct  CastHelper< R, SRC, true >
 
class  ErrorInterface
 
struct  ErrorInterface::ReferenceFunctions< ST >
 
struct  ComponentIdentifierMetaData< T, DEF >
 
struct  ComponentIdentifierMetaData< const Char *, DEF >
 
struct  ComponentIdentifierMetaData< LiteralId, DEF >
 
struct  ComponentIdentifierMetaData< Id, DEF >
 
class  AdapterRoot
 
class  ComponentHelper< BASE, INTERFACES >
 
struct  PrivateSelfHelperBase
 
struct  PrivateSelfHelper< BASE, typename >
 
class  ComponentHelper< BASE >
 
class  ComponentHelper< BASE, I, REST... >
 
struct  InterfacesBlock< INTERFACES >
 
class  ComponentWithBase< C, BASE, INTERFACE, INTERFACES >
 
class  NullReturnType< T >
 

Namespaces

 maxon
 
 maxon::details
 
 maxon::Classes
 

Macros

#define MAXON_LARGE_VTABLE
 
#define MAXON_COMPONENT_HASHTABLE
 
#define MAXON_INTERFACE_BASES(...)
 
#define MAXON_INTERFACE_SINGLE_IMPLEMENTATION
 
#define MAXON_INTERFACE_INSTANTIATION(INSTANTIATION, ID, ...)
 
#define MAXON_INTERFACE(Name, REFKIND, ID)
 
#define MAXON_COMPONENT(KIND, ...)
 
#define PRIVATE_MAXON_COMPONENT_KIND
 
#define PRIVATE_MAXON_COMPONENT_KINDNORMAL
 
#define PRIVATE_MAXON_COMPONENT_KINDABSTRACT
 
#define PRIVATE_MAXON_COMPONENT_KINDSINGLETON
 
#define PRIVATE_MAXON_COMPONENT_KINDFINAL
 
#define PRIVATE_MAXON_COMPONENT_KINDFINAL_SINGLETON
 
#define PRIVATE_MAXON_COMPONENT_BASES_A(POPULATED, ...)
 
#define PRIVATE_MAXON_COMPONENT_BASES_B(POPULATED, ...)
 
#define PRIVATE_MAXON_COMPONENT_BASES_C(POPULATED, ...)
 
#define PRIVATE_MAXON_COMPONENT_BASES_0(...)
 
#define PRIVATE_MAXON_COMPONENT_BASES_HELPER(x, i, a)
 
#define PRIVATE_MAXON_COMPONENT_BASES_1(...)
 
#define PRIVATE_MAXON_COMPONENT_ID(...)
 
#define PRIVATE_MAXON_COMPONENT_REGISTRY(...)
 
#define PRIVATE_MAXON_COMPONENT_TYPE(DEF, ...)
 
#define PRIVATE_MAXON_COMPONENT_EXTRA_FLAGS
 
#define PRIVATE_MAXON_COMPONENT_REGISTER(C, TEMPLATE, TYPENAME, FLAGS, REGISTRY, ...)
 
#define MAXON_COMPONENT_SIMPLE(I)
 
#define PRIVATE_MAXON_CLASS_REGISTER(C, TEMPLATE, REGISTRY, TYPE, ...)
 
#define MAXON_COMPONENT_ONLY_REGISTER(C, ...)
 
#define MAXON_COMPONENT_ONLY_REGISTER_TEMPLATE(C, ...)
 
#define MAXON_COMPONENT_CLASS_REGISTER(C, ...)
 
#define MAXON_COMPONENT_CLASS_REGISTER_TEMPLATE(C, ...)
 
#define MAXON_COMPONENT_OBJECT_REGISTER(C, ...)
 
#define MAXON_COMPONENT_OBJECT_REGISTER_TEMPLATE(C, ...)
 
#define MAXON_STATIC_REGISTER(C, ...)
 
#define PRIVATE_MAXON_INITIALIZED_TRANSLATION_UNIT(...)
 
#define PRIVATE_MAXON_INTERFACE_REGISTER_VIRTUAL(I, POSTFIX, TARGS, TEMPL, IID, NAME, ...)
 
#define PRIVATE_MAXON_INTERFACE_REGISTER_VIRTUAL_SINGLE_IMPL(I, POSTFIX, TARGS, TEMPL, IID, NAME, ...)
 
#define PRIVATE_MAXON_INTERFACE_REGISTER_VIRTUAL_SINGLE_BASE(I, TEMPL, IID, NAME, BASE)
 
#define PRIVATE_MAXON_INTERFACE_REGISTER_VIRTUAL_SINGLE_BASE_SINGLE_IMPL(I, TEMPL, IID, NAME, BASE)
 
#define PRIVATE_MAXON_INTERFACE_REGISTER_STATIC(I, TEMPL, IID)
 
#define MAXON_FUNCTIONNAME
 

Typedefs

template<typename TO , typename FROM >
using Out = std::is_constructible< TO, FROM >
 
using Object = ObjectInterface
 
using ClassTransformer = Delegate< Result< void >(ClassInterface *)>
 
template<typename C , typename... INTERFACES>
using Component = ComponentWithBase< C, ComponentRoot, INTERFACES... >
 
template<typename FROM , typename C , typename... INTERFACES>
using AdapterComponent = ComponentWithBase< C, AdapterRoot, FROM, INTERFACES... >
 
template<typename... INTERFACES>
using SelfPtr = typename ComponentHelper< ComponentRoot, INTERFACES... >::type::SelfPtr
 

Functions

template<typename R , typename SRC , typename RESULT = typename maxon::details::CastHelper<R, SRC>::AssertCastType>
RESULT AssertCast (SRC &&ref)
 
template<typename R , typename SRC , typename RESULT = typename maxon::details::CastHelper<R, SRC>::type>
RESULT Cast (SRC &&ref)
 
template<typename R , typename SRC , typename RESULT = typename maxon::details::CastHelper<R, SRC>::type>
Result< RESULTCast (Result< SRC > &&src)
 
template<typename R , typename SRC , typename RESULT = typename maxon::details::CastHelper<R, SRC>::type>
Result< RESULTAssertCast (Result< SRC > &&src)
 
 MAXON_REGISTRY (Class<>, Classes, "net.maxon.registry.classes")
 
template<typename R >
const Class< R > & Get (const Id &cls)
 
 MAXON_REGISTRY (ClassTransformer, ClassTransformers, "net.maxon.registry.classtransformers")
 
Result< void > AddComponentToClass (ClassInterface &cls, const ComponentDescriptor &comp)
 
template<typename C >
Result< void > AddComponentToClass (ClassInterface &cls, const Declaration< ComponentDescriptor, C > &comp)
 
Result< void > AddComponentToClass (ClassInterface &cls, const Class<> &comp)
 
template<typename T , typename C >
Result< void > AddComponentToClass (ClassInterface &cls, const Declaration< Class< T >, C > &comp)
 
class ComponentRoot MAXON_IF_TARGET_DEBUG (:public EmptyVirtualClass,)
 
constexpr const CharGetFunctionName (const Char *funcName)
 
const maxon::Charcstr (const maxon::Error &err)
 
const maxon::Charcstr (const maxon::ErrorPtr &err)
 
const maxon::Charcstr (const maxon::ThreadReferencedError &err)
 

Variables

 NORMAL
 
 SINGLETON
 
 ABSTRACT
 
static const Int STACKTRACE_SKIP
 

Macro Definition Documentation

◆ MAXON_LARGE_VTABLE

#define MAXON_LARGE_VTABLE

◆ MAXON_COMPONENT_HASHTABLE

#define MAXON_COMPONENT_HASHTABLE

Function Documentation

◆ cstr() [1/3]

const maxon::Char* cstr ( const maxon::Error &  err)

Debug helper, writing "cstr(err)" in the watch window will display the error as readable test.

◆ cstr() [2/3]

const maxon::Char* cstr ( const maxon::ErrorPtr err)

◆ cstr() [3/3]

const maxon::Char* cstr ( const maxon::ThreadReferencedError err)

Variable Documentation

◆ NORMAL

NORMAL

A normal object class.

◆ SINGLETON

SINGLETON

A singleton object class, i.e., a class with exactly one instance. The instance can be obtained with Create().

◆ ABSTRACT

ABSTRACT

< An abstract object class. Create() will return an UnsupportedOperationError.