System

Detailed Description

Classes

class  PrivateOverloadRank0
 
class  PrivateOverloadRank1
 
class  PrivateOverloadRank2
 
class  PrivateOverloadRank3
 
class  PrivateOverloadRank4
 
class  PrivateOverloadRank5
 
struct  AlwaysFalse< T >
 
struct  And<... >
 
struct  And< true, REST... >
 
struct  And< false, REST... >
 
struct  And<>
 
class  Protected< SUPER >
 
class  ConstIf< T, MAKECONST >
 
class  ConstIf< T, true >
 
class  InheritConst< T, INHERIT_FROM >
 
class  InheritConst< T, const INHERIT_FROM >
 
class  Substitute< T, R >
 
class  Substitute< T &, R >
 
class  Substitute< T &&, R >
 
struct  ParameterPack< T >
 
struct  ParameterPack< T, REST... >
 
struct  GetSignature< FUNCTION >
 
struct  GetSignature< RET(ARGS...)>
 
struct  GetSignature< RET(*)(ARGS...)>
 
struct  GetSignature< RET(CALLABLE::*)(ARGS...)>
 
struct  GetSignature< RET(CALLABLE::*)(ARGS...) const >
 
class  CommonLValue< T, A, B >
 
class  CommonType< A, B >
 
struct  MemberDetectorHelper< U, U >
 
class  EnableIfFlag< T, FLAGS, A, B >
 
class  IsCompleteBase< T, Int, value >
 
class  IsComplete< T, COUNTER >
 
struct  GetReferencedType< T, DEF, typename >
 
struct  GetReferencedType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::ReferencedType >::type >
 
struct  GetConstReferencedType< T, DEF, typename >
 
struct  GetConstReferencedType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::ConstReferencedType >::type >
 
struct  GetDirectlyReferencedType< T, DEF, typename >
 
struct  GetDirectlyReferencedType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::DirectlyReferencedType >::type >
 
struct  GetErasedType< T, DEF, typename >
 
struct  GetErasedType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::ErasedType >::type >
 
struct  GetDirectlyReferencedTypeCheckConstAndPtr< REF >
 
struct  IsAllocType< T, DEF, typename >
 
struct  IsAllocType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::IsAllocType >::type >
 
struct  IsNonvirtualInterfaceType< T, DEF, typename >
 
struct  IsNonvirtualInterfaceType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::NonvirtualInterfaceMarker >::type >
 
struct  IsVirtualInterfaceType< T, DEF, typename >
 
struct  IsVirtualInterfaceType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::InterfaceMarker >::type >
 
struct  IsInterfaceType< T, DEF, typename >
 
struct  IsInterfaceType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::MTable >::type >
 
struct  GetValueType< T, DEF, typename >
 
struct  GetValueType< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::ValueType >::type >
 
struct  CheckHasBase< T, DEF, typename >
 
struct  CheckHasBase< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::HasBaseDetector >::type >
 
struct  GetNonConst< T, DEF, typename >
 
struct  GetNonConst< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::NonConst >::type >
 
struct  GetHandler< T, DEF, typename >
 
struct  GetHandler< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::Handler >::type >
 
class  IsReferenceClass< T >
 
class  IsObjectReferenceClass< T >
 
struct  IsPartiallyOrdered< T, DEF, typename >
 
struct  IsPartiallyOrdered< T, DEF, typename maxon::SFINAEHelper< void, typename std::decay< T >::type::PartiallyOrdered >::type >
 
struct  IsTriviallyEquatable< T >
 
struct  IsTriviallyHashable< T, typename >
 
struct  IsTriviallyHashable< T, decltype(T::TriviallyHashable())>
 
struct  IsZeroInitialized< T >
 
struct  IsZeroInitialized< Generic >
 
struct  HasBaseDetector< D, B >
 
struct  IsDerived< BASE >
 
struct  HasErasedBase< D, B >
 
struct  GenericCastMemberTrait< TO, FROM, SAFE, typename >
 
struct  GenericCastMemberTrait< const TO &, FROM, SAFE >
 
struct  GenericCastMemberTrait< const TO &, FROM &, SAFE >
 
struct  GenericCastMemberTrait< TO &, FROM &, SAFE >
 
struct  GenericCastMemberTrait< const TO *, FROM *, SAFE >
 
struct  GenericCastMemberTrait< TO *, FROM *, SAFE >
 
struct  GenericCastTrait< TO, FROM, SAFE, typename >
 
class  ByValueParam< T >
 
class  MultiplicativePromotion< T1, T2, Bool >
 
class  MultiplicativePromotion< T1, T2, false >
 
class  MultiplicativePromotion< GenericArithmetic, T, true >
 
class  MultiplicativePromotion< T, GenericArithmetic, true >
 
class  MultiplicativePromotion< GenericArithmetic, GenericArithmetic, true >
 
class  Dereference< T, ALSO_REFS >
 
class  BaseRef< T, HANDLER >
 
class  Dereference< BaseRef< T, HANDLER >, false >
 
class  Application
 
struct  FixedSizeArrayWrapperType< T, VALUES >
 
struct  PrivateFixedSizeArrayBuilder< D, INDICES >
 
struct  PrivateFixedSizeArrayBuilder< D, std::index_sequence< INDEX... > >
 
class  OutOfMemoryErrorInterface
 
class  FunctionNotImplementedErrorInterface
 
class  IllegalArgumentErrorInterface
 
class  NullptrErrorInterface
 
class  IllegalStateErrorInterface
 
class  UnexpectedErrorInterface
 
class  OperationCancelledErrorInterface
 
class  AggregatedErrorInterface
 
class  AggregatedError
 
class  ErrorIndirectRef
 
class  ErrorPtr
 
class  NoErrorPtr
 
class  UnsupportedArgumentErrorInterface
 
class  UnresolvedErrorInterface
 
class  UnknownErrorInterface
 
class  UnsupportedOperationErrorInterface
 
class  ShutdownErrorInterface
 
class  DisabledErrorInterface
 
class  ErrnoErrorInterface
 
class  PrivateDummyFree
 
struct  ClassInfoBase
 
struct  GenericCastMemberTrait< TO, FROM, SAFE, typename SFINAEHelper< void, typename TO::DirectlyReferencedType, typename FROM::DirectlyReferencedType >::type >
 
struct  LoggerLine
 
class  LoggerTypeInterface
 
class  FileLoggerTypeInterface
 
class  UserLoggerTypeInterface
 
class  LoggerInterface
 
class  InternedIdInitializer
 
class  ComponentDescriptor
 
class  IsComplete< Class< T >, COUNTER >
 
class  Class< R >
 
class  ClassInterface
 
class  ObjectInterface
 
class  ErrorInterface
 
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  Registry< T, R >
 
class  NonConstArray< TYPE >
 
class  StringPosition
 
class  StringEnd
 
class  StringCount
 
class  StringTemplate< INTERFACETYPE, REFTYPE, CHARTYPE >
 
class  SysCharArray
 
class  StringInterface
 
class  CStringInterface
 
class  String
 
class  CString
 
class  ToStringHelper2< T, INTERFACETYPE >
 
class  ToStringHelper2< T, false >
 
class  ToStringHelper2< T, true >
 
class  StringProxy
 
class  FormatStatement
 
class  Delegate< T >
 
class  System
 
class  SystemErrorInterface
 
class  NSSystemErrorInterface
 
class  UnicodeUtils
 
struct  TemplateInstantiation< TEMPLATE, ARGS >
 
struct  SubstituteType< T, MAP, typename >
 
struct  SubstituteType< T &, MAP, void >
 
struct  SubstituteType< T *, MAP, void >
 
struct  SubstituteType< const T, MAP, void >
 
struct  SubstituteType< T, MAP, typename SFINAEHelper< void, typename T::Instantiation >::type >
 
class  FormatTemplateHelper< ARGCNT, FORMATSTR >
 
class  FormatTemplateHelper< ARGCNT, const Char(&)[N]>
 
class  SourceLocation
 
class  RegularExpressionInterface
 
class  UnitTestErrorInterface
 
class  UnitTestInterface
 
class  UnitTestComponent< C, INTERFACES >
 

Macros

#define MAXON_CACHE_LINE_SIZE
 
#define MAXON_FALSE_SHARING_SIZE
 
#define MAXON_HAS_TRUE_TYPE(E)
 
#define OVERLOAD_MAX_RANK
 
#define MAXON_MEMBERFUNCTION_DETECTOR(Name)
 
#define MAXON_MEMBERTYPE_DETECTOR(Name, Member, Default)
 
#define PRIVATE_MAXON_DEFAULT_REFERENCE_CONSTRUCTORS(Cls, ...)
 
#define MAXON_DEFAULT_REFERENCE_CONSTRUCTORS(Cls, ...)
 
#define MAXON_UNIQUE_REFERENCE_CONSTRUCTORS(Cls, ...)
 
#define MAXON_DEPENDENCY_WEAK(headerOrEntity)
 
#define MAXON_DEPENDENCY_ON_MODULE(module)
 
#define PRIVATE_MAXON_DEPENDENCY_ON_MODULE_A(module, id)
 
#define PRIVATE_MAXON_DEPENDENCY_ON_MODULE_B(module, id)
 
#define PRIVATE_MAXON_DEPENDENCY_ON_MODULE_C(module, id)
 
#define MAXON_IMPLEMENTATION_MODULE(module)
 
#define PRIVATE_MAXON_iferr_(ErrType, BUILTINLIKELY, LINE, ...)
 
#define PRIVATE_MAXON_iferr(...)
 
#define PRIVATE_MAXON_ifnoerr(...)
 
#define iferr(...)
 
#define ifnoerr(...)
 
#define MAXON_ERROR_IMPLEMENT_AND_REGISTER(error, baseclass)
 
#define MAXON_ERROR_PREALLOCATE(errorName, init)
 
#define PRIVATE_MAXON_CHECKERROR0(type, condition, msg)
 
#define PRIVATE_MAXON_CHECKERROR1(type, condition, msg)
 
#define PRIVATE_MAXON_CHECKERROR_C(type, condition, msgPopulated, msg)
 
#define PRIVATE_MAXON_CHECKERROR_B(type, condition, msgPopulated, msg)
 
#define PRIVATE_MAXON_CHECKERROR_A(type, condition, msgPopulated, ...)
 
#define CheckArgument(condition, ...)
 
#define CheckArgumentDebugStop(condition, ...)
 
#define CheckState(condition, ...)
 
#define CheckStateDebugStop(condition, ...)
 
#define CheckAssert(condition, ...)
 
#define MAXON_FORWARD(header)
 
#define MAXON_CHECK_CLASS(Name)
 
#define MAXON_METHOD
 
#define MAXON_FUNCTION
 
#define MAXON_METHOD_RESERVE
 
#define MAXON_USING(...)
 
#define MAXON_USING_CONST(...)
 
#define PRIVATE_MAXON_REMOVE_REFERENCE
 
#define MAXON_REFERENCE_NONE(FREEIMPL)
 
#define PRIVATE_MAXON_REFERENCE_NONE_FLAGS
 
#define PRIVATE_MAXON_REFERENCE_NONE_COPY(Name)
 
#define MAXON_REFERENCE_STATIC(FREEIMPL)
 
#define PRIVATE_MAXON_REFERENCE_STATIC_FLAGS
 
#define PRIVATE_MAXON_REFERENCE_STATIC_COPY(Name)
 
#define MAXON_REFERENCE_POINTER(FREEIMPL)
 
#define PRIVATE_MAXON_REFERENCE_POINTER_FLAGS
 
#define PRIVATE_MAXON_REFERENCE_POINTER_COPY(Name)
 
#define MAXON_REFERENCE_CONST_POINTER(FREEIMPL)
 
#define PRIVATE_MAXON_REFERENCE_CONST_POINTER_FLAGS
 
#define PRIVATE_MAXON_REFERENCE_CONST_POINTER_COPY(Name)
 
#define MAXON_REFERENCE_NORMAL(FREEIMPL)
 
#define PRIVATE_MAXON_REFERENCE_NORMAL_FLAGS
 
#define PRIVATE_MAXON_REFERENCE_NORMAL_COPY(Name)
 
#define MAXON_REFERENCE_CONST(FREEIMPL)
 
#define PRIVATE_MAXON_REFERENCE_CONST_FLAGS
 
#define PRIVATE_MAXON_REFERENCE_CONST_COPY(Name)
 
#define MAXON_REFERENCE_COPY_ON_WRITE(FREEIMPL)
 
#define PRIVATE_MAXON_REFERENCE_COPY_ON_WRITE_FLAGS
 
#define PRIVATE_MAXON_REFERENCE_COPY_ON_WRITE_COPY(Name)
 
#define MAXON_REFERENCE_ALWAYS_COPY_ON_WRITE(FREEIMPL)
 
#define PRIVATE_MAXON_REFERENCE_ALWAYS_COPY_ON_WRITE_FLAGS
 
#define PRIVATE_MAXON_REFERENCE_ALWAYS_COPY_ON_WRITE_COPY(Name)
 
#define MAXON_ADD_TO_REFERENCE_CLASS(...)
 
#define MAXON_ADD_TO_COPY_ON_WRITE_REFERENCE_CLASS(...)
 
#define MAXON_ADD_TO_CONST_REFERENCE_CLASS(...)
 
#define MAXON_ADD_TO_INTERFACE_TEMPLATE_CLASS(...)
 
#define MAXON_INTERFACE_NONVIRTUAL(Name, REFKIND, ID, ...)
 
#define MAXON_INTERFACE_NONVIRTUAL_DERIVED(Name, REFKIND, ID, ...)
 
#define _MAXON_IMPLEMENTATION_BASICS(C)
 
#define MAXON_IMPLEMENTATION_BASICS(C, I)
 
#define MAXON_IMPLEMENTATION_NO_ALLOC(C, cast)
 
#define _MAXON_IMPLEMENTATION(C, cast)
 
#define MAXON_IMPLEMENTATION(C)
 
#define MAXON_IMPLEMENTATION_DERIVED(C, I)
 
#define COW_KIND_SFINAE
 
#define MAXON_IMPLEMENTATION_REGISTER(C, ...)
 
#define MAXON_IMPLEMENTATION_REGISTER_TEMPLATE(C, ...)
 
#define MAXON_INTERFACE_SIMPLE_VIRTUAL(Name, REFKIND)
 
#define PRIVATE_MAXON_INTERFACE_SIMPLE_VIRTUAL_VTABLE_ACCESS
 
#define MAXON_INTERFACE_SIMPLE_VIRTUAL_DERIVED(Name, REFKIND)
 
#define MAXON_IMPLEMENTATION_SIMPLE(C)
 
#define MAXON_IMPLEMENTATION_SIMPLE_DERIVABLE(C, BASE)
 
#define MAXON_IMPLEMENTATION_SIMPLE_FINAL(C, BASE)
 
#define MAXON_IMPLEMENTATION_SIMPLE_REGISTER(C)
 
#define MAXON_GENERIC(...)
 
#define MAXON_GENERIC_BASE(...)
 
#define PRIVATE_MAXON_GENERIC_REMOVE_VARIANCE(...)
 
#define PRIVATE_PRIVATE_MAXON_GENERIC_REMOVE_VARIANCE
 
#define PRIVATE_MAXON_GENERIC_A(...)
 
#define PRIVATE_MAXON_GENERIC_B(...)
 
#define PRIVATE_MAXON_GENERIC_C(...)
 
#define PRIVATE_MAXON_GENERIC_D(SWITCH, ...)
 
#define PRIVATE_MAXON_GENERIC_SWITCH_A(...)
 
#define PRIVATE_MAXON_GENERIC_SWITCH_B(...)
 
#define PRIVATE_MAXON_GENERIC_SWITCH_C(X, ...)
 
#define PRIVATE_MAXON_GENERIC_SWITCH_D(N)
 
#define PRIVATE_MAXON_GENERIC_SWITCH_E(N)
 
#define PRIVATE_MAXON_GENERIC_SWITCH_F(N)
 
#define PRIVATE_MAXON_GENERIC_SWITCH_0(...)
 
#define PRIVATE_MAXON_GENERIC_SWITCH_1(...)
 
#define PRIVATE_MAXON_GENERIC_SWITCH_TYPENAME(...)
 
#define PRIVATE_MAXON_GENERIC_TYPENAME_TEST_typename
 
#define PRIVATE_MAXON_GENERIC_USING_typename
 
#define MAXON_INTERNED_ID(IID, NAME)
 
#define MAXON_INTERNED_ID_LOCAL(IID, NAME)
 
#define MAXON_INITIALIZATION(...)
 
#define MAXON_DECLARATION(T, Name, id, ...)
 
#define PRIVATE_MAXON_DECLARATION_END
 
#define PRIVATE_MAXON_DECLARATION(T, Name, id, storage, ...)
 
#define PRIVATE_MAXON_DECLARATION_REGISTER_1(cnt, Name)
 
#define PRIVATE_MAXON_DECLARATION_REGISTER_2(cnt, REGISTRY, Name)
 
#define PRIVATE_MAXON_DECLARATION_REGISTER_A(N, CNT, ...)
 
#define PRIVATE_MAXON_DECLARATION_REGISTER_B(N, CNT, ...)
 
#define PRIVATE_MAXON_DECLARATION_REGISTER_C(N, CNT, ...)
 
#define MAXON_DECLARATION_REGISTER(...)
 
#define PRIVATE_MAXON_DECLARATION_REGISTER_DECLARATION(Name, prefix, id)
 
#define MAXON_DEPENDENCY(Name)
 
#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, UNIT, 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_STATIC_REGISTER_A(C, ID, ...)
 
#define PRIVATE_MAXON_STATIC_REGISTER_B(C, ID, ...)
 
#define PRIVATE_MAXON_STATIC_REGISTER_C(C, ID, ...)
 
#define PRIVATE_MAXON_INITIALIZED_TRANSLATION_UNIT(...)
 
#define PRIVATE_MAXON_INTERFACE_REGISTER_VIRTUAL(I, POSTFIX, TARGS, TEMPL, IID, ...)
 
#define PRIVATE_MAXON_INTERFACE_REGISTER_VIRTUAL_SINGLE_IMPL(I, POSTFIX, TARGS, TEMPL, IID, ...)
 
#define PRIVATE_MAXON_INTERFACE_REGISTER_VIRTUAL_SINGLE_BASE(I, TEMPL, IID, BASE)
 
#define PRIVATE_MAXON_INTERFACE_REGISTER_VIRTUAL_SINGLE_BASE_SINGLE_IMPL(I, TEMPL, IID, BASE)
 
#define PRIVATE_MAXON_INTERFACE_REGISTER_STATIC(I, TEMPL, IID)
 
#define MAXON_FUNCTIONNAME
 
#define MAXON_REGISTRY(T, Name, id)
 
#define CONSTSTRING(x)
 
#define CONSTCSTRING(x)
 
#define FormatString(...)
 
#define FormatCString(...)
 
#define MAXON_SWITCH_FALLTHROUGH
 
#define MAXON_DISALLOW_COPY_AND_ASSIGN(TypeName)
 
#define MAXON_OPERATOR_MOVE_ASSIGNMENT(TypeName)
 
#define MAXON_OPERATOR_COPY_ASSIGNMENT(TypeName)
 
#define MAXON_OPERATOR_INEQUALITY(TypeName)
 
#define MAXON_OPERATOR_COMPARISON(TypeName)
 
#define PRIVATE_MAXON_MOVE_MEMBERS(x, i, a)
 
#define MAXON_MOVE_MEMBERS(...)
 
#define PRIVATE_MAXON_COPY_MEMBERS(x, i, a)
 
#define MAXON_COPY_MEMBERS(...)
 
#define PRIVATE_MAXON_COPYFROM_MEMBERS(x, i, a)
 
#define MAXON_COPYFROM_MEMBERS(...)
 
#define MAXON_OPERATOR_COPYFROM(T, ...)
 
#define MAXON_HASHCODE(...)
 
#define PRIVATE_MAXON_EQUALITY_OPERATORS(x, i, a)
 
#define MAXON_OPERATOR_EQUALITY(T, ...)
 
#define PRIVATE_MAXON_SIZEOF(X, I, A)
 
#define PRIVATE_MAXON_IS_TRIVIALLY_HASHABLE(X, I, A)
 
#define MAXON_OPERATOR_HASH(T, ...)
 
#define MAXON_OPERATOR_EQUALITY_HASHCODE(T, ...)
 
#define PRIVATE_MAXON_STRUCT_MEMBER_TOSTRING(x, i, a)
 
#define PRIVATE_MAXON_STRUCT_MEMBER_TYPE(x, i, a)
 
#define PRIVATE_MAXON_STRUCT_MEMBER_COPY(x, i, a)
 
#define MAXON_OPERATOR_STRUCT(T, ...)
 
#define MAXON_STRUCT_TUPLE(T, ...)
 
#define MAXON_NONCONST_COUNTERPART(...)
 
#define PRIVATE_MAXON_MEMBER_ACCESSORS_PARAMS(x, i, a)
 
#define PRIVATE_MAXON_MEMBER_ACCESSORS_ARGS(x, i, a)
 
#define MAXON_MEMBER_ACCESSORS(T, M, ...)
 
#define MAXON_DECLARE_CONDITIONAL_COPY_CONSTRUCTOR(cls, cond)
 
#define MAXON_DECLARE_CONDITIONAL_MOVE_CONSTRUCTOR(cls, cond)
 
#define MAXON_DECLARE_CONDITIONAL_COPY_ASSIGNMENT(cls, cond)
 
#define MAXON_DECLARE_CONDITIONAL_MOVE_ASSIGNMENT(cls, cond)
 
#define MAXON_TARGET_RELEASE
 
#define STD_IS_REPLACEMENT(name, ...)
 
#define MAXON_WARN_UNUSED
 
#define MAXON_WARN_UNUSED_CLASS
 
#define MAXON_WARN_MUTE_UNUSED
 
#define MAXON_OFFSETOF_NON_STANDARD_LAYOUT
 
#define MAXON_ASSERT_STANDARD_LAYOUT(T)
 
#define MAXON_ASSERT_LEGAL_LAYOUT(T)
 
#define MAXON_SWITCH_CHECKALLENUMS_BEGIN
 
#define MAXON_SWITCH_CHECKALLENUMS_END
 
#define MAXON_ASSUME_ALIGNED(val, alignment)
 
#define MAXON_LIKELY(...)
 
#define MAXON_UNLIKELY(...)
 
#define MAXON_SAFE_PLACEMENT_NEW(PTR)
 
#define MAXON_FILE
 
#define FORMATTEMPLATECHECK0(formatString, ...)
 
#define FORMATTEMPLATECHECK1(formatString, ...)
 
#define FORMATTEMPLATECHECK_C(count, formatString, ...)
 
#define FORMATTEMPLATECHECK_B(count, formatString, ...)
 
#define FORMATTEMPLATECHECK_A(count, formatString, ...)
 
#define FORMATTEMPLATECHECK(formatString, ...)
 
#define OutputWithFlags(flags, formatString, ...)
 
#define DebugOutput(flags, formatString, ...)
 
#define DiagnosticOutput(formatString, ...)
 
#define DiagnosticVarOutput(...)
 
#define PRIVATE_MAXON_DiagnosticVarOutput(x, i, a)
 
#define WarningOutput(formatString, ...)
 
#define CriticalOutput(formatString, ...)
 
#define ApplicationOutput(formatString, ...)
 
#define OUTPUTCHECK0(A, B)
 
#define OUTPUTCHECK1(A, B)
 
#define OUTPUTCHECK_C(count, A, B)
 
#define OUTPUTCHECK_B(count, A, B)
 
#define OUTPUTCHECK_A(count, A, B)
 
#define OUTPUTCHECK(A, B, ...)
 
#define DebugStop(...)
 
#define CriticalStop(...)
 
#define DebugAssert(condition, ...)
 
#define CriticalAssert(condition, ...)
 
#define SizeAssert(type, s)
 
#define MAXON_SOURCE_LOCATION
 
#define MAXON_SOURCE_LOCATION_DECLARATION
 
#define MAXON_SOURCE_LOCATION_FORWARD
 
#define MAXON_SOURCE_LOCATION_NAME(x)
 
#define MAXON_FUNCTION_SIGNATURE
 
#define PRIVATE_MAXON_UNITTESTERROR0(type, condition, msg)
 
#define PRIVATE_MAXON_UNITTESTERROR1(type, condition, msg)
 
#define PRIVATE_MAXON_UNITTESTERROR_C(type, condition, msgPopulated, msg)
 
#define PRIVATE_MAXON_UNITTESTERROR_B(type, condition, msgPopulated, msg)
 
#define PRIVATE_MAXON_UNITTESTERROR_A(type, condition, msgPopulated, ...)
 
#define CheckUnitTestState(condition, ...)
 
#define CheckUnitTestResultOk(functioncall, ...)
 
#define CheckUnitTestResultError(functioncall, ...)
 

Typedefs

using OverloadRank0 = PrivateOverloadRank0 *
 
using OverloadRank1 = PrivateOverloadRank1 *
 
using OverloadRank2 = PrivateOverloadRank2 *
 
using OverloadRank3 = PrivateOverloadRank3 *
 
using OverloadRank4 = PrivateOverloadRank4 *
 
using OverloadRank5 = PrivateOverloadRank5 *
 
using OverloadRankMax = OverloadRank5
 
template<typename T , Int N>
using AddArrayT = T[N]
 
template<typename T >
using AddArrayOfUnknownBoundT = T[]
 
template<typename TO , typename FROM , Bool SAFE>
using GenericCastReturnType = std::enable_if< GenericCastTrait< TO, typename maxon::details::MakeLValueConst< FROM >::type, SAFE >::value, typename GenericCastTrait< TO, typename maxon::details::MakeLValueConst< FROM >::type, SAFE >::ReturnType >
 
template<typename EXECUTION >
using ExecutionInterface = JobInterfaceTemplate< EXECUTION >
 
template<typename T , Bool HAS_ERROR>
using AddResult = typename maxon::details::AddResultHelper< T, HAS_ERROR >::type
 
template<typename TO , typename FROM >
using Out = std::is_constructible< TO, FROM >
 
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
 
using Utf16CharBuffer = BufferedBaseArray< Utf16Char, 512 >
 
using Utf32CharBuffer = BufferedBaseArray< Utf32Char, 256 >
 
using FROMSTR = void(*)(void *p, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
template<typename... BASES>
using NonEmptyBases = typename maxon::details::NonEmptyBasesHelper< typename std::conditional< STD_IS_REPLACEMENT(empty, BASES), EmptyClass, BASES >::type... >::type
 
using TOSTR = void(*)(String &result, const void *ptr, const FormatStatement *formatStatement)
 

Enumerations

enum class  SUBSYSTEM {
  UNDEFINED ,
  CONSOLE ,
  WINDOWS
}
 
enum class  APPLICATION_URLTYPE {
  STARTUP_DIR ,
  APPLICATION ,
  APP_EXECUTABLE ,
  CORELIBS_DIR ,
  RESOURCE_DIR ,
  TEMP_DIR ,
  PREFS_DIR ,
  GLOBALPREFS_DIR ,
  DESKTOP_DIR ,
  USER_HOME_DIR ,
  USER_DOCUMENTS_DIR ,
  SYSTEM_PROGRAMS_DIR ,
  CURRENT_WORKING_DIR ,
  CURRENT_MODULE_DIR ,
  CURRENT_MODULE_RESOURCE_DIR ,
  LIBRARY_DIR ,
  PREFS_DIR_STATIC ,
  TESTDATA_DIR
}
 
enum class  APPLICATIONMODE {
  DONTWAIT ,
  KEEPRUNNING ,
  SHUTDOWN
}
 
enum class  APPLICATIONFEATURE {
  NONE ,
  COMMANDLINE ,
  LIBRARY ,
  UI
}
 
enum class  STRINGCONVERSION {
  NONE ,
  ALLOW_MORE_CHARACTERS
}
 
enum class  STRINGCOMPARISON {
  MEMORY ,
  UNICODE_LETTERS ,
  UNICODE_NUMBERS ,
  CASEINSENSITIVE ,
  CASEINSENSITIVE_NUMBERS
}
 
enum class  NORMALIZATION {
  NFC ,
  NFD ,
  NKDC ,
  NFKD ,
  NFD_HFS
}
 
enum class  CHARACTERTYPE : UChar {
  UNKNOWN ,
  LU ,
  LL ,
  LT ,
  LM ,
  LO ,
  MN ,
  MC ,
  ME ,
  ND ,
  NL ,
  NO ,
  PC ,
  PD ,
  PS ,
  PE ,
  PI ,
  PF ,
  PO ,
  SM ,
  SC ,
  SK ,
  SO ,
  ZS ,
  ZL ,
  ZP ,
  CC ,
  CF ,
  CS ,
  CO ,
  CN
}
 
enum class  TARGETAUDIENCE {
  DEBUGGER ,
  DEVELOPERS ,
  USERS ,
  ALL
}
 
enum class  WRITEMETA {
  DEFAULT ,
  WARNING ,
  CRITICAL ,
  NONEWLINE ,
  UI_SYNC_DRAW
}
 
enum class  OUTPUT {
  NONE ,
  DIAGNOSTIC ,
  WARNING ,
  CRITICAL ,
  PRETTYPRINT ,
  NOLINEBREAK ,
  HEADER
}
 
enum class  REGPARSEMODE {
  MATCH ,
  CONTAINS ,
  STARTS ,
  ENDS
}
 

Functions

template<typename TO , typename FROM >
GenericCastReturnType< TO, FROM, false >::type GenericReinterpretCast (FROM &&value)
 
template<typename TO , typename FROM >
GenericCastReturnType< TO, FROM, true >::type GenericUpCast (FROM &&value)
 
template<typename T , Bool ALLOW_NONCONST = false>
DefaultValue ()
 
enum maxon::SUBSYSTEM MAXON_ENUM_LIST (SUBSYSTEM, "net.maxon.datatype.enum.subsystem")
 
enum maxon::APPLICATION_URLTYPE MAXON_ENUM_LIST (APPLICATION_URLTYPE, "net.maxon.datatype.enum.application_urltype")
 
enum maxon::APPLICATIONMODE MAXON_ENUM_LIST (APPLICATIONMODE, "net.maxon.datatype.enum.applicationmode")
 
enum maxon::APPLICATIONFEATURE MAXON_ENUM_FLAGS (APPLICATIONFEATURE)
 
 MAXON_DECLARATION (Class< Error >, ErrorObjectClass, "net.maxon.class.errorobject", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_DECLARATION (AggregatedError, AggregatedErrorObject, "net.maxon.object.aggregatederror", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
MAXON_ATTRIBUTE_FORCE_INLINE void operator% (ErrorPtr &rv, ThreadReferencedError &err)
 
template<typename R >
Cast (ErrorPtr &ref)
 
template<typename ERRORTYPE >
Bool IsErrorOfType (const Error &err)
 
 MAXON_REGISTRY (JobRef, ExecutionJobs, "net.maxon.registry.executionjobs")
 
template<typename C >
DefaultValueDetector< C *, &C::DefaultValue >::type ImplementationCreateDefaultValue (OverloadRank3)
 
template<typename C >
std::enable_if< MAXON_IS_COW_KIND(C::PrivateInterface::Hxx1::ReferenceClass::Handler::KIND), C * >::type ImplementationCreateDefaultValue (OverloadRank2)
 
template<typename C >
SFINAEHelper< C *, typename C::PrivateInterface::Hxx1::ReferenceClass::Handler >::type ImplementationCreateDefaultValue (OverloadRank1)
 
template<typename C >
C * ImplementationCreateDefaultValue (OverloadRank0)
 
template<typename C >
DefaultValueDetector< C *, &C::DefaultValue >::type ImplementationDestroyDefaultValue (const C *, OverloadRank3)
 
template<typename C >
std::enable_if< MAXON_IS_COW_KIND(C::PrivateInterface::Hxx1::ReferenceClass::Handler::KIND), C * >::type ImplementationDestroyDefaultValue (const C *o, OverloadRank2)
 
template<typename C >
void ImplementationDestroyDefaultValue (const C *, OverloadRank0)
 
 MAXON_DECLARATION (Class< LoggerTypeRef >, LoggerTypeBaseClass, "net.maxon.class.loggertypebase", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
 MAXON_REGISTRY (Class< LoggerTypeRef >, LoggerTypes, "net.maxon.core.registry.loggertypes")
 
 MAXON_REGISTRY (LoggerRef, Loggers, "net.maxon.core.registry.loggers")
 
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< RESULT > Cast (Result< SRC > &&src)
 
template<typename R , typename SRC , typename RESULT = typename maxon::details::CastHelper<R, SRC>::type>
Result< RESULT > AssertCast (Result< SRC > &&src)
 
 MAXON_REGISTRY (Class<>, Classes, "net.maxon.registry.classes")
 
 MAXON_REGISTRY (ClassTransformer, ClassTransformers, "net.maxon.registry.classtransformers")
 
 MAXON_DECLARATION (Class< ObjectRef >, ObjectBaseClass, "net.maxon.class.object", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"))
 
class ComponentRoot MAXON_IF_TARGET_DEBUG (:public EmptyVirtualClass,)
 
constexpr const CharGetFunctionName (const Char *funcName)
 
const StringDecodingRef & GetUtf8DefaultDecoder ()
 
const StringEncodingRef & GetUtf8DefaultEncoder ()
 
enum maxon::STRINGCONVERSION MAXON_ENUM_FLAGS (STRINGCONVERSION)
 
enum maxon::STRINGCOMPARISON MAXON_ENUM_LIST (STRINGCOMPARISON)
 
MAXON_ATTRIBUTE_FORCE_INLINE const Stringoperator""_s (const char *str, std::size_t cnt)
 
MAXON_ATTRIBUTE_FORCE_INLINE const Stringoperator""_s (const wchar_t *str, std::size_t cnt)
 
MAXON_ATTRIBUTE_FORCE_INLINE const CStringoperator""_cs (const char *str, std::size_t cnt)
 
Result< void > DescribeIO (const CStringInterface &s, const DataSerializeInterface &dsi)
 
Result< void > DescribeIO (const StringInterface &s, const DataSerializeInterface &dsi)
 
String operator+ (const String &a, const String &b)
 
String && operator+ (String &&a, const String &b)
 
String && operator+ (String &&a, String &&b)
 
String && operator+ (const String &a, String &&b)
 
CString operator+ (const CString &a, const CString &b)
 
CString && operator+ (CString &&a, const CString &b)
 
CString && operator+ (CString &&a, CString &&b)
 
CString && operator+ (const CString &a, CString &&b)
 
Stringoperator+= (String &s, const CString &b)
 
String operator+ (const String &a, const CString &b)
 
String && operator+ (String &&a, const CString &b)
 
String operator+ (const String &a, const Char *b)
 
String && operator+ (String &&a, const Char *b)
 
CString operator+ (const CString &a, const Char *b)
 
CString && operator+ (CString &&a, const Char *b)
 
String ToString (const String &str, const FormatStatement *formatStatement, Bool=false)
 
String ToString (const CString &str, const FormatStatement *formatStatement, Bool=false)
 
template<typename T >
decltype(std::declval< T >().ToString()) ToStringHelper (const T *object, const FormatStatement *formatStatement, Int *)
 
template<typename T >
String ToStringHelper (const T *object, const FormatStatement *formatStatement, const Int *checkDataType)
 
template<typename T >
std::enable_if<!STD_IS_REPLACEMENT(enum, T), String >::type ToString (const T &object, const FormatStatement *formatStatement, Bool checkDataType=true)
 
template<typename T >
std::enable_if<!STD_IS_REPLACEMENT(function, T), String >::type ToString (const T *object, const FormatStatement *formatStatement)
 
const StringToString (Bool val, const FormatStatement *formatStatement, Bool=false)
 
String ToString (Char val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (UChar val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Int16 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Int32 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Int64 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (UInt16 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (UInt32 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (UInt64 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Float64 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Float32 val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Utf16Char val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Utf32Char val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Char *val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (const Char *val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (const void *val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (void *val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (const Generic *val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ToString (Generic *val, const FormatStatement *formatStatement, Bool checkDataType=false)
 
String ExtractString (StringProxy *proxy)
 
const StringExtractString (const String &str)
 
const CharExtractString (const Char *str)
 
void ScanParameter (Float64 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (Float32 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (Int64 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (Int32 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (Int16 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (Char &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (UInt64 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (UInt32 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (UInt16 &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
void ScanParameter (UChar &result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
template<typename T >
void ScanParameter (T *&result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
template<typename T >
void FromStrHlp (T *result, const Block< const Utf32Char > &str, Int &processed, const String &formatStatement, Bool &error)
 
template<typename T >
FROMSTR GetFromStrHlp ()
 
Bool ScanStringTemplate (const String &str, const String &format, Int *parsedCharacters, Int argsCnt, void **args, FROMSTR *argFuncs)
 
CString ExtractCString (StringProxy *proxy)
 
template<Bool ISOKAY, typename T >
MAXON_ATTRIBUTE_FORCE_INLINEForwardString (T &&str)
 
template<typename STR , typename STR2 , typename... ARGS>
Bool ScanString (STR inputStr, STR2 formatStr, ARGS &... args)
 
template<typename STR , typename STR2 , typename... ARGS>
Bool ScanString (STR inputStr, Int &parsedInputCharacters, STR2 formatStr, ARGS &... args)
 
String _LoadResourceString (const Id &scope, const InternedId &keyValue)
 
template<typename STRID , typename... ARGUMENTS>
String LoadResourceString (const STRID &identifier, const ARGUMENTS &... args)
 
static Int StrLen (const SysChar *chr)
 
static Int StrLen (const Utf32Char *chr)
 
static Int StrLen (const Utf16Char *chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsSpace (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsTab (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsSpaceOrTab (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsLineEnd (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsNumeric (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsAlphabetic (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsAlphanumeric (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsHexadecimal (TYPE chr)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Int GetHexadecimalValue (TYPE chr)
 
template<typename ITERATABLETYPE , typename REFTYPE >
static MAXON_WARN_UNUSED REFTYPE JoinElements (ITERATABLETYPE &&iterable, const REFTYPE &delimiter, const FormatStatement *formatStr=nullptr)
 
template<typename STRINGTYPE >
void AppendStringWithSeparator (STRINGTYPE &base, const STRINGTYPE &add, const STRINGTYPE &delimiter)
 
template<typename STRINGTYPE >
STRINGTYPE AddStringWithSeparator (const STRINGTYPE &base, const STRINGTYPE &add, const STRINGTYPE &delimiter)
 
 MAXON_MEMBERFUNCTION_DETECTOR (GetReferenceCounter)
 
enum maxon::NORMALIZATION MAXON_ENUM_LIST (NORMALIZATION)
 
enum maxon::CHARACTERTYPE UChar MAXON_ENUM_LIST (CHARACTERTYPE)
 
template<typename TYPE >
MAXON_ATTRIBUTE_FORCE_INLINE Bool IsUnicodeLetter (TYPE chr)
 
enum maxon::TARGETAUDIENCE MAXON_ENUM_FLAGS (TARGETAUDIENCE, "net.maxon.datatype.enum.targetaudience", EARLY)
 
enum maxon::WRITEMETA MAXON_ENUM_FLAGS (WRITEMETA, "net.maxon.datatype.enum.writemeta", EARLY)
 
enum maxon::OUTPUT MAXON_ENUM_FLAGS (OUTPUT, "net.maxon.datatype.enum.output", EARLY)
 
void _ConsoleOutput (OUTPUT flags, const Char *str, Int line, const Char *file)
 
void _ConsoleOutput (OUTPUT flags, const String &str, Int line, const Char *file)
 
void _ConsoleOutput (OUTPUT flags, StringProxy *str, Int line, const Char *file)
 
void _ApplicationOutput (maxon::TARGETAUDIENCE t, maxon::WRITEMETA lvl, const maxon::String &str, Int line, const Char *file)
 
void _ApplicationOutput (maxon::TARGETAUDIENCE t, maxon::WRITEMETA lvl, const Char *str, Int line, const Char *file)
 
void _ApplicationOutput (maxon::TARGETAUDIENCE t, maxon::WRITEMETA lvl, const maxon::StringProxy *proxy, Int line, const Char *file)
 
template<typename T >
void ToStrHlp (String &result, const T *x, const FormatStatement *formatStatement)
 
template<typename T >
TOSTR GetToStrHlp ()
 
StringProxyFormat (const String &formatString, Int argsCnt, const void **args, const TOSTR *argFuncs)
 
StringProxyFormat (const Char *formatString, Int argsCnt, const void **args, const TOSTR *argFuncs)
 
template<Int ARGCNT, typename FORMATSTR , typename... ARGS>
StringProxyFormatTemplateX (FORMATSTR formatString, const ARGS &... args)
 
template<Int ARGCNT, typename FORMATSTR >
FORMATSTR FormatTemplateX (FORMATSTR formatString)
 
constexpr Int GetArgCnt (const Char *const formatStr)
 
constexpr bool StrStrConstExpr (const char *str, const char *search)
 
template<typename T >
static MAXON_ATTRIBUTE_FORCE_INLINE const CharPrivateGetClassName ()
 
enum maxon::REGPARSEMODE MAXON_ENUM_LIST (REGPARSEMODE)
 
 MAXON_REGISTRY (Class< UnitTestRef >, UnitTestClasses, "net.maxon.registry.unittestclasses")
 
 MAXON_REGISTRY (Class< UnitTestRef >, UnitTestWithC4DPluginClasses, "net.maxon.registry.unittestwithc4dpluginclasses")
 
 MAXON_REGISTRY (Class< UnitTestRef >, SpeedTestClasses, "net.maxon.registry.speedtestclasses")
 
 MAXON_REGISTRY (Class< UnitTestRef >, LongRunTestClasses, "net.maxon.registry.longruntestclasses")
 
 MAXON_DECLARATION (Class< UnitTestRef >, UnitTestBaseClass, "net.maxon.class.unittestbase", MAXON_IMPLEMENTATION_MODULE("net.maxon.misc"))
 
ErrorPtrPrivateGetRefMember ()
 
const ErrorPtrPrivateGetRefMember () const
 
String ToString (const FormatStatement *formatStatement=nullptr) const
 
String ToString (const FormatStatement *formatStatement=nullptr) const
 
String ToString (const FormatStatement *formatStatement=nullptr)
 
template<typename SCR >
Result< StringConvertString (const SCR &converter) const
 
static UniqueHash GetUniqueHashCode (const Byte *ptr, Int count)
 
static UniqueHash GetUniqueHashCode (const Block< const Byte > &bytes)
 
 UniqueHasher ()
 
void Combine (const Byte *ptr, Int count)
 
void Combine (const Block< const Byte > &bytes)
 
void Combine (const UniqueHash &value)
 
UniqueHash Finalize () const
 
 operator UniqueHash () const
 

Variables

struct maxon::AssetSortData MAXON_ENUM_LIST
 
Int alignment
 
maxon::CommandAssetInterface MAXON_ENUM_FLAGS
 
template<TranslationUnit & UNIT, UInt64 UNIT_HASH, Bool WEAK, typename NAME >
const maxon::EntityUse g_PrivateDependencyOnModule
 
static const Int STACKTRACE_SKIP
 
static const Int STRING_MAXIMUM_PRECISION
 
static const Int STRING_DYNAMIC_DIGITS
 
System::SPECIALBEHAVIOR g_systemBehavior
 
maxon::Bool g_isDebuggerPresent
 
maxon::Bool g_enableDebugBreak
 
static const Int REGPARSE_CONCAT
 
static const Int REGPARSE_ANYCHAR
 
static const Int REGPARSE_ANYDIGIT
 
static const Int REGPARSE_OPERATOR_OR
 
static const Int REGPARSE_OPERATOR_STAR
 
static const Int REGPARSE_OPERATOR_PARENTHESIS_LEFT
 
static const Int REGPARSE_OPERATOR_PARENTHESIS_RIGHT
 
static const T value [sizeof...(VALUES)]
 
static const InterfaceReference *const value [sizeof...(INTERFACES)]
 

Macro Definition Documentation

◆ MAXON_CACHE_LINE_SIZE

#define MAXON_CACHE_LINE_SIZE

Assume 64 byte cache line size.

◆ MAXON_FALSE_SHARING_SIZE

#define MAXON_FALSE_SHARING_SIZE

Assume 64 byte alignment to avoid false sharing for x86 and unknown architectures.

◆ MAXON_HAS_TRUE_TYPE

#define MAXON_HAS_TRUE_TYPE (   E)

◆ OVERLOAD_MAX_RANK

#define OVERLOAD_MAX_RANK

Use this as argument for the overload selection parameter of a set of overloaded functions, see OverloadRank0.

◆ MAXON_MEMBERFUNCTION_DETECTOR

#define MAXON_MEMBERFUNCTION_DETECTOR (   Name)

◆ MAXON_MEMBERTYPE_DETECTOR

#define MAXON_MEMBERTYPE_DETECTOR (   Name,
  Member,
  Default 
)

This macro defines a type trait class with the given Name having a single template type parameter. It checks if the type argument T (after removing a possible reference suffix) has a member type named Member. If so, Name<T> will contain a type alias member named type for T::Member, otherwise the type alias will point to Default. Also a static member constant value of type Bool is defined which is true if T::Member exists and it doesn't point to std::false_type. Example:

MAXON_MEMBERTYPE_DETECTOR(GetReferencedType, ReferencedType, std::false_type);
MAXON_MEMBERTYPE_DETECTOR(GetValueType, ValueType, void);
#define MAXON_MEMBERTYPE_DETECTOR(Name, Member, Default)
Definition: apibase.h:1022

With those two usages of the macro, GetReferencedType<T>::value will be true if T contains a member type ReferencedType (unless that is std::false_type), and GetValueType<T>::type will be the type T::ValueType if that exists, void otherwise.

You may override the default type by specifying a second template argument: GetValueType<T, X>::type will be X instead of the default void if T::ValueType doesn't exist.

◆ PRIVATE_MAXON_DEFAULT_REFERENCE_CONSTRUCTORS

#define PRIVATE_MAXON_DEFAULT_REFERENCE_CONSTRUCTORS (   Cls,
  ... 
)

◆ MAXON_DEFAULT_REFERENCE_CONSTRUCTORS

#define MAXON_DEFAULT_REFERENCE_CONSTRUCTORS (   Cls,
  ... 
)

◆ MAXON_UNIQUE_REFERENCE_CONSTRUCTORS

#define MAXON_UNIQUE_REFERENCE_CONSTRUCTORS (   Cls,
  ... 
)

◆ MAXON_DEPENDENCY_WEAK

#define MAXON_DEPENDENCY_WEAK (   headerOrEntity)

This macro can be used to reduce a dependency on a header file or entity to a weak dependency.

By default, all entities included from a header file are strong dependencies for the current translation unit (cpp file). This means that they have to be available in order for the current translation unit to work. With MAXON_DEPENDENCY_WEAK you can weaken this so that the current translation unit can be initialized even if the weakly referenced entities could not be resolved or initialized.

You have to check in your own code if the weakly referenced entities are actually available when you need them.

This example shows how to set up a weak dependency for an interface:

#include "maxon/llvm.h"
// This marks all entities included from "maxon/llvm.h" as weak dependencies.
MAXON_DEPENDENCY_WEAK("maxon/llvm.h");
// Alternatively, you can mark a specific entity as weak dependency.
MAXON_DEPENDENCY_WEAK(LlvmModuleInterface::_interface);
...
if (LlvmModuleInterface::_interface.IsInitialized()) // Before using LlvmModuleInterface, check if it is available.
{
... LlvmModuleInterface can be used, do something with it ...
}
#define MAXON_DEPENDENCY_WEAK(headerOrEntity)
Definition: entity.h:375

This example shows how to set up a weak dependency for a MAXON_DECLARATION:

MAXON_DEPENDENCY_WEAK(MediaStreamExifDataClass);
...
if (MediaStreamExifDataClass.IsInitialized())
{
...
}
Parameters
[in]headerOrEntityThis can be either the name of a header file whose declared entities shall be weak dependencies for the current translation unit (use the file name, prefixed by its namespace directories such as "maxon/llvm.h") or it can be a single entity such as LlvmModuleInterface::_interface or MediaStreamExifDataClass.

◆ MAXON_DEPENDENCY_ON_MODULE

#define MAXON_DEPENDENCY_ON_MODULE (   module)

MAXON_DEPENDENCY_ON_MODULE adds a dependency of the current module on the specified module. Use this if you want to make sure that the specified module has been initialized before this module is initialized. Normally a proper module initialization order is already ensured by the automatic dependencies, so you need this only in rare cases of dependencies that go beyond what automatic dependencies can detect.

// Adding dependency from current module to "net.maxon.nodes".
MAXON_DEPENDENCY_ON_MODULE("net.maxon.nodes");
#define MAXON_DEPENDENCY_ON_MODULE(module)
Definition: entity.h:408
Parameters
[in]moduleModule on which the current module shall depend (remember not to append ".module" as it is not part of the Id).
See also
manual_dep

◆ PRIVATE_MAXON_DEPENDENCY_ON_MODULE_A

#define PRIVATE_MAXON_DEPENDENCY_ON_MODULE_A (   module,
  id 
)

◆ PRIVATE_MAXON_DEPENDENCY_ON_MODULE_B

#define PRIVATE_MAXON_DEPENDENCY_ON_MODULE_B (   module,
  id 
)

◆ PRIVATE_MAXON_DEPENDENCY_ON_MODULE_C

#define PRIVATE_MAXON_DEPENDENCY_ON_MODULE_C (   module,
  id 
)

◆ MAXON_IMPLEMENTATION_MODULE

#define MAXON_IMPLEMENTATION_MODULE (   module)

This macro can be added to an interface or object declaration to tell in which module the corresponding definition is made. This is an optional information and helps to reduce the size of binaries:

  • Without that information, each cpp file which includes the declaration's header file registers an own dependency on the definition.
  • With MAXON_IMPLEMENTATION_MODULE, only a dependency on the module is registered, and that's shared for all declarations within a cpp file. Use this with care: Dependency tracking becomes less precise, and a failure of the initialization of the definition doesn't automatically deactivate dependent cpp files. So you should only make use of it for declarations whose definitions will never fail, and also only if the declarations are expected to be included in a lot of cpp files so that there's a significant reduction of binary sizes.

The usage of the macro for a non-virtual interface looks as follows:

class DataDictionaryInterface
{
MAXON_INTERFACE_NONVIRTUAL(DataDictionaryInterface, MAXON_REFERENCE_COPY_ON_WRITE, "net.maxon.interface.datadictionary", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"));
...
};
#define MAXON_REFERENCE_COPY_ON_WRITE(FREEIMPL)
Definition: interfacebase.h:1223
#define MAXON_IMPLEMENTATION_MODULE(module)
Definition: entity.h:466
#define MAXON_INTERFACE_NONVIRTUAL(Name, REFKIND, ID,...)
Definition: interfacebase.h:1350

The corresponding implementation (MAXON_IMPLEMENTATION) has to be in the module "net.maxon.kernel".

For a virtual interface the usage is similar:

class InputStreamInterface : MAXON_INTERFACE_BASES(BaseStreamInterface)
{
MAXON_INTERFACE(InputStreamInterface, MAXON_REFERENCE_NORMAL, "net.maxon.interface.inputstream", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"));
...
};
#define MAXON_REFERENCE_NORMAL(FREEIMPL)
Definition: interfacebase.h:1184
#define MAXON_INTERFACE(Name, REFKIND, ID,...)
Definition: objectbase.h:1121
#define MAXON_INTERFACE_BASES(...)
Definition: objectbase.h:1049

However, this doesn't restrict implementations of the interface – a virtual interface can have an arbitrary number of implementations, spread over several modules. It only tells that the bare interface is registered as part of the "net.maxon.kernel" module, namely via the FrameworkRegistration setting in projectdefinition.txt. If a virtual interface has static methods, their implementation (MAXON_STATIC_REGISTER) has to be in the specified module.

For a declaration, write

MAXON_DECLARATION(Class<UnitTestRef>, UnitTestBaseClass, "net.maxon.class.unittestbase", MAXON_IMPLEMENTATION_MODULE("net.maxon.misc"));
#define MAXON_DECLARATION(T, Name, id,...)
Definition: module.h:937

and place the corresponding definition (MAXON_DECLARATION_REGISTER) in the specified module. You can also apply the macro to a datatype declaration:

MAXON_DATATYPE(Id, "net.maxon.datatype.id", MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel"));
#define MAXON_DATATYPE(type, id,...)
Definition: datatype.h:296
Parameters
[in]moduleIdentifier of the module which defines the entity.

◆ PRIVATE_MAXON_iferr_

#define PRIVATE_MAXON_iferr_ (   ErrType,
  BUILTINLIKELY,
  LINE,
  ... 
)

◆ PRIVATE_MAXON_iferr

#define PRIVATE_MAXON_iferr (   ...)

◆ PRIVATE_MAXON_ifnoerr

#define PRIVATE_MAXON_ifnoerr (   ...)

◆ iferr

#define iferr (   ...)

The iferr macro can be used to simplify error handling. It is a special if which declares an error variable named err for the if/else scope. This variable is set to the error (if any) of the iferr-expression, and the if-branch is executed if there is an error. Expressions of several types are supported:

  • Result<T> expressions hold a result value and an error. You can use iferr just to check their error value, but you can also assign the result value to a variable and even declare the variable in the expression (it will be declared in the outer scope, not just in the if scope):
    Result<Int> Func();
    iferr (Func())
    return err;
    iferr (res = Func())
    return err;
    iferr (Int res = Func())
    return err;
    // res available here
    Py_UCS4 * res
    Definition: unicodeobject.h:1113
    maxon::Int Int
    Definition: ge_sys_math.h:60
    #define iferr(...)
    Definition: errorbase.h:388
  • Pointer-valued expressions set the err variable to an OutOfMemoryError if the expression evaluates to nullptr. Other than that, you can use iferr as in the previous case. E.g., you can write
    iferr (AutoMem<Char> data = NewMem(Char, size))
    return err;
    // data available here
    Py_ssize_t size
    Definition: bytesobject.h:86
    #define NewMem(T, cnt)
    Definition: defaultallocator.h:195
    maxon::Char Char
    Definition: ge_sys_math.h:52
  • If the expression returns a reference class, it behaves in a similar way as for a pointer-valued expression.
  • Finally, if the expression returns a ResultMem, the err variable is set to an OutOfMemoryError if the ResultMem is false. This only works for the simple case (with no additional result assignment):
    iferr (array.Resize(size))
    return err;

For nested iferr statements, you have to use iferr etc., otherwise you will get a conflict because two variables of the same name err are declared.

Parameters
[in]...Expression which shall be checked for an error condition.
See also
error_handling_iferr

◆ ifnoerr

#define ifnoerr (   ...)

The opposite of iferr.

◆ MAXON_ERROR_IMPLEMENT_AND_REGISTER

#define MAXON_ERROR_IMPLEMENT_AND_REGISTER (   error,
  baseclass 
)

This macro simplifies the implementation and registration of an error interface and its published error object. You can use this for error interfaces which don't introduce additional methods, and if the implementation shall not override any of the inherited implementations.

Example:

MAXON_ERROR_IMPLEMENT_AND_REGISTER(OutOfMemoryError, ErrorObjectClass);
#define MAXON_ERROR_IMPLEMENT_AND_REGISTER(error, baseclass)
Definition: errorbase.h:409
Parameters
[in]errorName of the error reference class such as OutOfMemoryError.
[in]baseclassAn expression returning the base object class (e.g., ErrorObjectClass). This should be an implementation of the base interfaces of the error interface.

◆ MAXON_ERROR_PREALLOCATE

#define MAXON_ERROR_PREALLOCATE (   errorName,
  init 
)

This macro preallocates an error for speed critical cases. The error is returned as a ThreadReferencedError which can be directly returned without any further function calls or overhead (which would happen internally when you'd return an Error object).

The following example preallocates g_myIllegalArgumentError which is assigned an IllegalArgumentError:

MAXON_ERROR_PREALLOCATE(g_myIllegalArgumentError, []() { return IllegalArgumentError(MAXON_SOURCE_LOCATION); });
#define MAXON_SOURCE_LOCATION
Definition: memoryallocationbase.h:67
#define MAXON_ERROR_PREALLOCATE(errorName, init)
Definition: errorbase.h:434
Parameters
[in]errorNameThe name of a globally visible ThreadReferencedError variable which is to be preallocated.
[in]initA lambda or function which returns a preallocated Error.

◆ PRIVATE_MAXON_CHECKERROR0

#define PRIVATE_MAXON_CHECKERROR0 (   type,
  condition,
  msg 
)

◆ PRIVATE_MAXON_CHECKERROR1

#define PRIVATE_MAXON_CHECKERROR1 (   type,
  condition,
  msg 
)

◆ PRIVATE_MAXON_CHECKERROR_C

#define PRIVATE_MAXON_CHECKERROR_C (   type,
  condition,
  msgPopulated,
  msg 
)

◆ PRIVATE_MAXON_CHECKERROR_B

#define PRIVATE_MAXON_CHECKERROR_B (   type,
  condition,
  msgPopulated,
  msg 
)

◆ PRIVATE_MAXON_CHECKERROR_A

#define PRIVATE_MAXON_CHECKERROR_A (   type,
  condition,
  msgPopulated,
  ... 
)

◆ CheckArgument

#define CheckArgument (   condition,
  ... 
)

This macro checks the specified condition, and if this evaluates to false, an IllegalArgumentError is returned from the current function. The condition will be part of the error message (taken over verbatim). The macro can only be used in a function which returns a Result<T>.

Optionally, you can specify a message which will be used instead of the verbatim condition. The message may use formatting like FormatString.

Examples:

// on error, the message is "Illegal argument: Condition (UInt) index < (UInt) _count not fulfilled."
CheckArgument((UInt) index < (UInt) _count);
// on error, the message is "Illegal argument: Framerate too low."
CheckArgument(frameRate >= 1.0, "Framerate too low.");
// on error, the message is "Illegal argument: Name my/file.txt contains forward slash."
CheckArgument(!name.FindLast('/', nullptr), "Name @ contains forward slash.", name);
const char const char * name
Definition: abstract.h:195
Py_ssize_t * index
Definition: abstract.h:374
maxon::UInt UInt
Definition: ge_sys_math.h:61
#define CheckArgument(condition,...)
Definition: errorbase.h:486
Parameters
[in]conditionThe condition to evaluate. If it evaluates to false, an IllegalArgumentError will be returned.
[in]...Optional message and parameters, will be formatted by FormatString.
See also
CheckState
CheckAssert
CheckArgumentDebugStop

◆ CheckArgumentDebugStop

#define CheckArgumentDebugStop (   condition,
  ... 
)

Like CheckArgument, but an additional DebugStop is executed on error.

◆ CheckState

#define CheckState (   condition,
  ... 
)

This macro checks the specified condition, and if this evaluates to false, an IllegalStateError is returned from the current function. The condition will be part of the error message (taken over verbatim). The macro can only be used in a function which returns a Result<T>.

Optionally, you can specify a message which will be used instead of the verbatim condition. The message may use formatting like FormatString.

For examples, see CheckArgument.

Parameters
[in]conditionThe condition to evaluate. If it evaluates to false, an IllegalStateError will be returned.
[in]...Optional message and parameters, will be formatted by FormatString.
See also
CheckArgument
CheckAssert
CheckStateDebugStop

◆ CheckStateDebugStop

#define CheckStateDebugStop (   condition,
  ... 
)

Like CheckState, but an additional DebugStop is executed on error.

◆ CheckAssert

#define CheckAssert (   condition,
  ... 
)

This macro checks the specified condition, and if this evaluates to false, an UnexpectedError is returned from the current function. The condition will be part of the error message (taken over verbatim). The macro can only be used in a function which returns a Result<T>.

Optionally, you can specify a message which will be used instead of the verbatim condition. The message may use formatting like FormatString.

For examples, see CheckArgument.

Parameters
[in]conditionThe condition to evaluate. If it evaluates to false, an UnexpectedError will be returned.
[in]...Optional message and parameters, will be formatted by FormatString.
See also
CheckArgument
CheckState

◆ MAXON_FORWARD

#define MAXON_FORWARD (   header)

This macro can be used to mark class/struct forward declarations and type aliases which make use of such declarations for the source processor. When a declaration is marked by MAXON_FORWARD the source processor generates slightly different code for interface methods/functions whose return type uses that declaration in order to avoid compilation errors about incomplete types.

You have to inform the source processor about the header file in which the definition of the forward declaration can be found. This is used for the auto-generated registration files which need the complete definition.

Example:

class DataDescriptionDefinition MAXON_FORWARD("maxon/datadescriptiondefinition.h");
using LanguageStringDataDescriptionDefinition = HashMap<Id, DataDescriptionDefinition> MAXON_FORWARD("maxon/datadescriptiondefinition.h");
#define MAXON_FORWARD(header)
Definition: interfacebase.h:985
The maxon namespace contains all declarations of the MAXON API.
Definition: autoweight.h:14
HashMap< Id, DataDescriptionDefinition > MAXON_FORWARD("maxon/datadescriptiondefinition.h") LanguageStringDataDescriptionDefinition
Definition: lazylanguagestringdatadescription.h:11
Parameters
[in]headerThe name of the header file (in quotes) where the type is defined.

◆ MAXON_CHECK_CLASS

#define MAXON_CHECK_CLASS (   Name)

This macro can be used within non-static member functions to statically assert that the given parameter Name matches the surrounding class.

Parameters
[in]NameUnqualified name of the class.

◆ MAXON_METHOD

#define MAXON_METHOD

Use this macro to mark a member function of an interface as an interface method. For simple virtual interfaces, only non-static member functions can be used as interface methods. Example:

MAXON_METHOD Int GetLength() const;
#define MAXON_METHOD
Definition: interfacebase.h:1012
See also
MAXON_INTERFACE_NONVIRTUAL
MAXON_INTERFACE_SIMPLE_VIRTUAL
MAXON_INTERFACE

◆ MAXON_FUNCTION

#define MAXON_FUNCTION

Use this macro to mark a member function of an interface as a function which shall be added to the reference classes. Unlike MAXON_METHOD, the function invocation will not be routed through the interface; you have to provide a normal C++ function definition. All kinds of interfaces allow both static and non-static functions.

MAXON_FUNCTION is very useful if you need a function pair of which one function is const and the other non-const, but besides constness they do the same so that a single method suffices:

MAXON_METHOD const MyElement& GetElement() const;
MAXON_FUNCTION MyElement& GetElement() { return MAXON_NONCONST_COUNTERPART(GetElement()); }
#define MAXON_FUNCTION
Definition: interfacebase.h:1033
#define MAXON_NONCONST_COUNTERPART(...)
Definition: classhelpers.h:655
See also
MAXON_INTERFACE_NONVIRTUAL
MAXON_INTERFACE_SIMPLE_VIRTUAL
MAXON_INTERFACE

◆ MAXON_METHOD_RESERVE

#define MAXON_METHOD_RESERVE

Use this macro to reserve a slot for a method in the method table of a simple virtual interface. You can later replace MAXON_METHOD_RESERVE by MAXON_METHOD without breaking binary compatibility of the interface.

Note
You can only reserve method slots for simple virtual interfaces. You can't use this for (non-simple) virtual interfaces or non-virtual interfaces.
Warning
When module A has been compiled with a version of the interface which has a reserved slot implements the interface and another module B has been compiled with a version with a true method, and module B calls that method on the implementation of A, a crash will happen because A doesn't provide an implementation of that method.

◆ MAXON_USING

#define MAXON_USING (   ...)

MAXON_USING can be used within an interface definition (as an equivalent to the regular C++ using) whenever a non-const method inherited from a base interface is hidden in the interface's reference class because the interface declares a method of the same name, and you want to make the inherited method visible again.

class AInterface : MAXON_INTERFACE_BASES(ObjectInterface)
{
MAXON_INTERFACE(AInterface, MAXON_REFERENCE_NORMAL, "some.interface.a");
public:
MAXON_METHOD void DoSomething(Int x);
};
class BInterface : MAXON_INTERFACE_BASES(AInterface)
{
MAXON_INTERFACE(BInterface, MAXON_REFERENCE_NORMAL, "some.interface.b");
public:
MAXON_USING(AInterface::DoSomething);
MAXON_METHOD void DoSomething(const String& x);
};
Definition: c4d_string.h:41
PyObject * x
Definition: bytesobject.h:38
#define MAXON_USING(...)
Definition: interfacebase.h:1078

For const methods you have to use MAXON_USING_CONST.

Parameters
[in]...The qualified name of an inherited non-const interface method.

◆ MAXON_USING_CONST

#define MAXON_USING_CONST (   ...)

MAXON_USING_CONST can be used within an interface definition (as an equivalent to the regular C++ using) whenever a const method inherited from a base interface is hidden in the interface's reference class because the interface declares a method of the same name, and you want to make the inherited method visible again.

For non-const methods you have to use MAXON_USING. See there for an example.

Parameters
[in]...The qualified name of an inherited const interface method.

◆ PRIVATE_MAXON_REMOVE_REFERENCE

#define PRIVATE_MAXON_REMOVE_REFERENCE

◆ MAXON_REFERENCE_NONE

#define MAXON_REFERENCE_NONE (   FREEIMPL)

Use this as argument to MAXON_INTERFACE_NONVIRTUAL to indicate that the interface should not have automatic reference counting, and that no reference class shall be created for the interface. This can be used for interfaces which shall be accessed through custom-coded wrapper classes which are then also responsible for the proper release of the objects. MAXON_REFERENCE_NONE cannot be used for virtual interfaces.

See also
MAXON_INTERFACE_NONVIRTUAL

◆ PRIVATE_MAXON_REFERENCE_NONE_FLAGS

#define PRIVATE_MAXON_REFERENCE_NONE_FLAGS

◆ PRIVATE_MAXON_REFERENCE_NONE_COPY

#define PRIVATE_MAXON_REFERENCE_NONE_COPY (   Name)

◆ MAXON_REFERENCE_STATIC

#define MAXON_REFERENCE_STATIC (   FREEIMPL)

Use this as argument to MAXON_INTERFACE_NONVIRTUAL to indicate that the interface has only static methods. MAXON_REFERENCE_STATIC can only be used for non-virtual interfaces.

See also
MAXON_INTERFACE_NONVIRTUAL

◆ PRIVATE_MAXON_REFERENCE_STATIC_FLAGS

#define PRIVATE_MAXON_REFERENCE_STATIC_FLAGS

◆ PRIVATE_MAXON_REFERENCE_STATIC_COPY

#define PRIVATE_MAXON_REFERENCE_STATIC_COPY (   Name)

◆ MAXON_REFERENCE_POINTER

#define MAXON_REFERENCE_POINTER (   FREEIMPL)

Use this as argument to MAXON_INTERFACE_NONVIRTUAL to indicate that the interface should not have automatic reference counting, but that a reference class shall be created for the interface. The reference class will behave like an ordinary pointer. For the interface design and its usage, one has to take care of the proper release of the objects. MAXON_REFERENCE_POINTER cannot be used for virtual interfaces.

See also
MAXON_INTERFACE_NONVIRTUAL

◆ PRIVATE_MAXON_REFERENCE_POINTER_FLAGS

#define PRIVATE_MAXON_REFERENCE_POINTER_FLAGS

◆ PRIVATE_MAXON_REFERENCE_POINTER_COPY

#define PRIVATE_MAXON_REFERENCE_POINTER_COPY (   Name)

◆ MAXON_REFERENCE_CONST_POINTER

#define MAXON_REFERENCE_CONST_POINTER (   FREEIMPL)

Use this as argument to MAXON_INTERFACE_NONVIRTUAL to indicate that the interface should not have automatic reference counting, but that a reference class shall be created for the interface. The reference class will behave like an ordinary pointer to a const object. For the interface design and its usage, one has to take care of the proper release of the objects. MAXON_REFERENCE_CONST_POINTER cannot be used for virtual interfaces.

See also
MAXON_INTERFACE_NONVIRTUAL

◆ PRIVATE_MAXON_REFERENCE_CONST_POINTER_FLAGS

#define PRIVATE_MAXON_REFERENCE_CONST_POINTER_FLAGS

◆ PRIVATE_MAXON_REFERENCE_CONST_POINTER_COPY

#define PRIVATE_MAXON_REFERENCE_CONST_POINTER_COPY (   Name)

◆ MAXON_REFERENCE_NORMAL

#define MAXON_REFERENCE_NORMAL (   FREEIMPL)

Use this as argument to MAXON_INTERFACE_NONVIRTUAL or MAXON_INTERFACE if the interface shall use automatic reference counting, and if non-const methods shall operate on the original object instead of making a copy. This is usually used for first-class objects which have an identity rather than just a value. The corresponding reference class is assumed to be the name of the interface with the Interface postfix replaced by Ref (e.g., InputStreamRef for the interface InputStreamInterface).

See also
MAXON_INTERFACE_NONVIRTUAL
MAXON_INTERFACE

◆ PRIVATE_MAXON_REFERENCE_NORMAL_FLAGS

#define PRIVATE_MAXON_REFERENCE_NORMAL_FLAGS

◆ PRIVATE_MAXON_REFERENCE_NORMAL_COPY

#define PRIVATE_MAXON_REFERENCE_NORMAL_COPY (   Name)

◆ MAXON_REFERENCE_CONST

#define MAXON_REFERENCE_CONST (   FREEIMPL)

Use this as argument to MAXON_INTERFACE_NONVIRTUAL or MAXON_INTERFACE if the interface shall use automatic reference counting, and if only const methods of the interface shall be carried over to the reference class. This is usually used for stateless objects which, once initialized, provide their relevant functionality through const methods (e.g., IoHandlerInterface). The corresponding reference class is assumed to be the name of the interface with the Interface postfix removed (e.g., IoHandler for the interface IoHandlerInterface).

See also
MAXON_INTERFACE_NONVIRTUAL
MAXON_INTERFACE

◆ PRIVATE_MAXON_REFERENCE_CONST_FLAGS

#define PRIVATE_MAXON_REFERENCE_CONST_FLAGS

◆ PRIVATE_MAXON_REFERENCE_CONST_COPY

#define PRIVATE_MAXON_REFERENCE_CONST_COPY (   Name)

◆ MAXON_REFERENCE_COPY_ON_WRITE

#define MAXON_REFERENCE_COPY_ON_WRITE (   FREEIMPL)

Use this as argument to MAXON_INTERFACE_NONVIRTUAL or MAXON_INTERFACE if the interface shall use automatic reference counting, and if the reference class shall have copy-on-write semantics. This means that when a non-const method is invoked through a reference and there are further references, a copy of the original object is made, and the non-const method is invoked on the copy. Thus, the further references aren't affected by potential modifications of the non-const method. This is usually used for value types (second-class objects) where only the value is important such as String. The corresponding reference class is assumed to be the name of the interface without the Interface postfix (e.g., String for the interface StringInterface).

See also
MAXON_INTERFACE_NONVIRTUAL
MAXON_INTERFACE

◆ PRIVATE_MAXON_REFERENCE_COPY_ON_WRITE_FLAGS

#define PRIVATE_MAXON_REFERENCE_COPY_ON_WRITE_FLAGS

◆ PRIVATE_MAXON_REFERENCE_COPY_ON_WRITE_COPY

#define PRIVATE_MAXON_REFERENCE_COPY_ON_WRITE_COPY (   Name)

◆ MAXON_REFERENCE_ALWAYS_COPY_ON_WRITE

#define MAXON_REFERENCE_ALWAYS_COPY_ON_WRITE (   FREEIMPL)

Use this as argument to MAXON_INTERFACE_NONVIRTUAL or MAXON_INTERFACE if the interface shall use automatic reference counting, and if the reference class shall have always-copy-on-write semantics. In contrast to MAXON_REFERENCE_COPY_ON_WRITE, this also makes a copy of the object if there is no other reference to the object, so that non-const methods, invoked through the reference class, will never modify an existing object. In other words: If the refcount == 1 then a call to a set function will always duplicate the object. The corresponding reference class is assumed to be the name of the interface without the Interface postfix (e.g., String for the interface StringInterface).

See also
MAXON_INTERFACE_NONVIRTUAL
MAXON_INTERFACE

◆ PRIVATE_MAXON_REFERENCE_ALWAYS_COPY_ON_WRITE_FLAGS

#define PRIVATE_MAXON_REFERENCE_ALWAYS_COPY_ON_WRITE_FLAGS

◆ PRIVATE_MAXON_REFERENCE_ALWAYS_COPY_ON_WRITE_COPY

#define PRIVATE_MAXON_REFERENCE_ALWAYS_COPY_ON_WRITE_COPY (   Name)

◆ MAXON_ADD_TO_REFERENCE_CLASS

#define MAXON_ADD_TO_REFERENCE_CLASS (   ...)

Use MAXON_ADD_TO_REFERENCE_CLASS if you want to add further code to the automatically generated non-const reference class of an interface. The source processor adds the arguments of the macro to the public part of the generated reference class. The added function will not be part of the generated const reference class or of the generated copy-on-write reference class. Example:

class DataFormatBaseReaderInterface : MAXON_INTERFACE_BASES(DataDictionaryObjectInterface)
{
MAXON_INTERFACE(DataFormatBaseReaderInterface, MAXON_REFERENCE_NORMAL, "net.maxon.interface.dataformatbasereader");
public:
MAXON_METHOD Result<void> CloseInput();
Result<void> ResetMaybeCloseInput()
{
Result<void> res = OK;
if (this->GetPointer())
{
if (System::GetReferenceCounter(this->GetPointer()) == 1)
res = this->GetPointer()->CloseInput();
this->ResetReference();
}
return res;
}
);
...
};
@ OK
User has selected a font.
#define MAXON_ADD_TO_REFERENCE_CLASS(...)
Definition: interfacebase.h:1281
Parameters
[in]...Code which shall be added to the generated reference class.
See also
MAXON_ADD_TO_CONST_REFERENCE_CLASS
MAXON_ADD_TO_COPY_ON_WRITE_REFERENCE_CLASS

◆ MAXON_ADD_TO_COPY_ON_WRITE_REFERENCE_CLASS

#define MAXON_ADD_TO_COPY_ON_WRITE_REFERENCE_CLASS (   ...)

Use MAXON_ADD_TO_COPY_ON_WRITE_REFERENCE_CLASS if you want to add further code to the automatically generated copy-on-write reference class of an interface. The source processor adds the arguments of the macro to the public part of the generated reference class. The added function will not be part of the generated const reference class or of the generated non-const reference class. For an example see MAXON_ADD_TO_REFERENCE_CLASS.

Parameters
[in]...Code which shall be added to the generated reference class.
See also
MAXON_ADD_TO_REFERENCE_CLASS
MAXON_ADD_TO_CONST_REFERENCE_CLASS

◆ MAXON_ADD_TO_CONST_REFERENCE_CLASS

#define MAXON_ADD_TO_CONST_REFERENCE_CLASS (   ...)

Use MAXON_ADD_TO_CONST_REFERENCE_CLASS if you want to add further code to the automatically generated const reference class of an interface. The source processor adds the arguments of the macro to the public part of the generated reference class. The added function will also be part of the generated non-const reference class and the generated copy-on-write reference class. For an example see MAXON_ADD_TO_REFERENCE_CLASS.

Parameters
[in]...Code which shall be added to the generated reference class.
See also
MAXON_ADD_TO_REFERENCE_CLASS
MAXON_ADD_TO_COPY_ON_WRITE_REFERENCE_CLASS

◆ MAXON_ADD_TO_INTERFACE_TEMPLATE_CLASS

#define MAXON_ADD_TO_INTERFACE_TEMPLATE_CLASS (   ...)

◆ MAXON_INTERFACE_NONVIRTUAL

#define MAXON_INTERFACE_NONVIRTUAL (   Name,
  REFKIND,
  ID,
  ... 
)

MAXON_INTERFACE_NONVIRTUAL marks a class declaration as a non-virtual interface declaration. Non-virtual interfaces are used to separate code into a published interface and its internal implementation. The implementation may reside in a different module as code which makes use of the interface, and the whole mechanism is compatible among different compilers.

nvinterfaces describes the declaration and implementation of non-virtual interfaces in detail. An example is the declaration of StringInterface:

class Application
{
MAXON_INTERFACE_NONVIRTUAL(Application, MAXON_REFERENCE_NONE, "net.maxon.interface.application");
public:
static MAXON_METHOD Result<Url> GetUrl(APPLICATION_URLTYPE urlType);
...
};
APPLICATION_URLTYPE
Possible values for GetUrl() function.
Definition: application.h:30
#define MAXON_REFERENCE_NONE(FREEIMPL)
Definition: interfacebase.h:1115

Non-virtual interfaces must not specify a base class unless you use MAXON_INTERFACE_NONVIRTUAL_DERIVED instead of MAXON_INTERFACE_NONVIRTUAL. Non-virtual interfaces have to be implemented by another class using MAXON_IMPLEMENTATION.

Parameters
[in]NameName of the interface (has to be the same as the surrounding class name).
[in]REFKINDOne of MAXON_REFERENCE_NONE, MAXON_REFERENCE_STATIC, MAXON_REFERENCE_POINTER, MAXON_REFERENCE_CONST_POINTER, MAXON_REFERENCE_NORMAL, MAXON_REFERENCE_CONST, MAXON_REFERENCE_COPY_ON_WRITE, MAXON_REFERENCE_ALWAYS_COPY_ON_WRITE.
[in]IDThe unique identifier of the interface.
[in]...Optional information about the interface, for now only MAXON_IMPLEMENTATION_MODULE can be used here.
See also
nvinterfaces
MAXON_METHOD
MAXON_FUNCTION
MAXON_INTERFACE_NONVIRTUAL_DERIVED
MAXON_INTERFACE
Note
It is recommended to use virtual interfaces (MAXON_INTERFACE) instead of non-virtual ones unless the interface consists only of static methods.
The macro itself leaves incomplete code which is completed by the source processor. So you have to place the macro in a header file, because the source processor only scans header files, and you have to include the generated hxx files in the header file. MAXON_INTERFACE_NONVIRTUAL must be placed somewhere before the #include of the first hxx file.

◆ MAXON_INTERFACE_NONVIRTUAL_DERIVED

#define MAXON_INTERFACE_NONVIRTUAL_DERIVED (   Name,
  REFKIND,
  ID,
  ... 
)

MAXON_INTERFACE_NONVIRTUAL_DERIVED marks a class declaration as a non-virtual interface declaration which is derived from another such declaration (i.e., either MAXON_INTERFACE_NONVIRTUAL or MAXON_INTERFACE_NONVIRTUAL_DERIVED). You have to use the base interface as base class in the class declaration. The derived interface inherits all methods from its base interface. You cannot use more than one direct base interface. Example:

class MacroPortInterface : public AttributedObjectInterface
{
MAXON_INTERFACE_NONVIRTUAL_DERIVED(MacroPortInterface, MAXON_REFERENCE_NORMAL, "net.maxon.interface.macroport");
...
};
#define MAXON_INTERFACE_NONVIRTUAL_DERIVED(Name, REFKIND, ID,...)
Definition: interfacebase.h:1396

Derived non-virtual interfaces have to be implemented by another class using MAXON_IMPLEMENTATION_DERIVED.

Parameters
[in]NameName of the interface (has to be the same as the surrounding class name).
[in]REFKINDOne of MAXON_REFERENCE_NONE, MAXON_REFERENCE_POINTER, MAXON_REFERENCE_CONST_POINTER, MAXON_REFERENCE_NORMAL, MAXON_REFERENCE_CONST, MAXON_REFERENCE_COPY_ON_WRITE, MAXON_REFERENCE_ALWAYS_COPY_ON_WRITE.
[in]IDThe unique identifier of the interface.
[in]...Optional information about the interface, for now only MAXON_IMPLEMENTATION_MODULE can be used here.
See also
nvinterfaces
MAXON_INTERFACE_NONVIRTUAL
Warning
As one can act (through an upcasted pointer to the base interface) on the implementation of the derived interface as if it was the implementation of the base interface, the implementation of the derived interface should derive from the implementation of the base interface (at least both have to be compatible).

◆ _MAXON_IMPLEMENTATION_BASICS

#define _MAXON_IMPLEMENTATION_BASICS (   C)

◆ MAXON_IMPLEMENTATION_BASICS

#define MAXON_IMPLEMENTATION_BASICS (   C,
 
)

◆ MAXON_IMPLEMENTATION_NO_ALLOC

#define MAXON_IMPLEMENTATION_NO_ALLOC (   C,
  cast 
)

◆ _MAXON_IMPLEMENTATION

#define _MAXON_IMPLEMENTATION (   C,
  cast 
)

◆ MAXON_IMPLEMENTATION

#define MAXON_IMPLEMENTATION (   C)

MAXON_IMPLEMENTATION has to be used within an implementation class for a non-virtual interface (declared with MAXON_INTERFACE_NONVIRTUAL). For more details, see nvinterfaces. An example is the implementation of StringInterface by a class XStringImpl:

class XStringImpl : private StringInterface
{
MAXON_IMPLEMENTATION(XStringImpl);
public:
XStringImpl() { }
XStringImpl(const XStringImpl& str) { Insert(0, &str); }
Int GetLength() const { return _txt.GetCount(); }
...
};
void * str
Definition: bytesobject.h:77
#define MAXON_IMPLEMENTATION(C)
Definition: interfacebase.h:1485
#define MAXON_IMPLEMENTATION_REGISTER(C,...)
Definition: interfacebase.h:1589

Don't forget to add MAXON_IMPLEMENTATION_REGISTER below the implementation class.

Parameters
[in]CName of the implementation class (has to be the same as the surrounding class name).
See also
nvinterfaces

◆ MAXON_IMPLEMENTATION_DERIVED

#define MAXON_IMPLEMENTATION_DERIVED (   C,
 
)

MAXON_IMPLEMENTATION_DERIVED has to be used within an implementation class for a derived non-virtual interface (declared with MAXON_INTERFACE_NONVIRTUAL_DERIVED). The implementation class should derive from the implementation class of the base interface. For more details, see nvinterfaces. An example is the implementation of MacroPortInterface by a class Port (AttributedObject implements the base interface AttributedObjectInterface):

class Port : public AttributedObject
{
MAXON_IMPLEMENTATION_DERIVED(Port, MacroPortInterface);
public:
...
};
#define MAXON_IMPLEMENTATION_DERIVED(C, I)
Definition: interfacebase.h:1512

Don't forget to add MAXON_IMPLEMENTATION_REGISTER below the implementation class.

Parameters
[in]CName of the implementation class (has to be the same as the surrounding class name).
[in]IName of the derived interface which C implements.
See also
nvinterfaces

◆ COW_KIND_SFINAE

#define COW_KIND_SFINAE

◆ MAXON_IMPLEMENTATION_REGISTER

#define MAXON_IMPLEMENTATION_REGISTER (   C,
  ... 
)

MAXON_IMPLEMENTATION_REGISTER completes the implementation of a non-virtual interface. It has to be used below the declaration of the implementation class (see MAXON_IMPLEMENTATION).

Parameters
[in]CName of the implementation class.
[in]...Additional flags for the NonvirtualInterfaceImplementation such as EntityBase::FLAGS::EXPLICIT.
See also
nvinterfaces

◆ MAXON_IMPLEMENTATION_REGISTER_TEMPLATE

#define MAXON_IMPLEMENTATION_REGISTER_TEMPLATE (   C,
  ... 
)

◆ MAXON_INTERFACE_SIMPLE_VIRTUAL

#define MAXON_INTERFACE_SIMPLE_VIRTUAL (   Name,
  REFKIND 
)

MAXON_INTERFACE_SIMPLE_VIRTUAL marks a class declaration as a simple virtual interface declaration. Unlike true virtual interfaces (MAXON_INTERFACE), simple virtual interfaces only support tree-like inheritance (no multiple inheritance), and they don't support adapters between different versions. They have less overhead for method invocations, so you should use simple virtual interfaces for performance-critical low-level purposes, where the interface is unlikely to change often.

svinterfaces describes the declaration and implementation of simple virtual interfaces in detail. As an example, consider:

class SimpleInterface
{
public:
MAXON_METHOD void DoSomething(Int index);
};
#define MAXON_INTERFACE_SIMPLE_VIRTUAL(Name, REFKIND)
Definition: interfacebase.h:1727

You can derive from simple virtual interfaces using MAXON_INTERFACE_SIMPLE_VIRTUAL_DERIVED.

Simple virtual interfaces can be implemented by several classes. An implementation class has to derive from the interface and to contain MAXON_IMPLEMENTATION_SIMPLE, and in its constructors it has to pass the static _clsMTable member declared by MAXON_IMPLEMENTATION_SIMPLE to the constructor of the base interface. Finally you have to use MAXON_IMPLEMENTATION_SIMPLE_REGISTER behind the class declaration to construct the vtable:

class SimpleImpl : private SimpleInterface
{
public:
SimpleImpl() : SimpleInterface(_clsMTable) { }
void DoSomething(Int index) { }
};
#define MAXON_IMPLEMENTATION_SIMPLE_REGISTER(C)
Definition: interfacebase.h:1916
#define MAXON_IMPLEMENTATION_SIMPLE(C)
Definition: interfacebase.h:1855

Simple virtual interfaces can be class templates (all other kinds of interfaces can't). In this case you have to prefix the registration as in

template <typename ARRAY> MAXON_IMPLEMENTATION_SIMPLE_REGISTER(ArrayImpl<ARRAY>);

Simple virtual interfaces can't have static methods, but they may have static functions (marked with MAXON_FUNCTION).

Parameters
[in]NameName of the interface (has to be the same as the surrounding class name).
[in]REFKINDOne of MAXON_REFERENCE_NONE, MAXON_REFERENCE_POINTER, MAXON_REFERENCE_CONST_POINTER, MAXON_REFERENCE_NORMAL, MAXON_REFERENCE_CONST, MAXON_REFERENCE_COPY_ON_WRITE, MAXON_REFERENCE_ALWAYS_COPY_ON_WRITE.
See also
svinterfaces
MAXON_METHOD
MAXON_METHOD_RESERVE
MAXON_FUNCTION
MAXON_INTERFACE_SIMPLE_VIRTUAL_DERIVED
MAXON_IMPLEMENTATION_SIMPLE
MAXON_IMPLEMENTATION_SIMPLE_REGISTER
MAXON_INTERFACE
Note
The macro itself leaves incomplete code which is completed by the source processor. So you have to place the macro in a header file, because the source processor only scans header files, and you have to include the generated hxx files in the header file. MAXON_INTERFACE_SIMPLE_VIRTUAL must be placed somewhere before the #include of the first hxx file.

◆ PRIVATE_MAXON_INTERFACE_SIMPLE_VIRTUAL_VTABLE_ACCESS

#define PRIVATE_MAXON_INTERFACE_SIMPLE_VIRTUAL_VTABLE_ACCESS

◆ MAXON_INTERFACE_SIMPLE_VIRTUAL_DERIVED

#define MAXON_INTERFACE_SIMPLE_VIRTUAL_DERIVED (   Name,
  REFKIND 
)

MAXON_INTERFACE_SIMPLE_VIRTUAL_DERIVED marks a class declaration as a simple virtual interface declaration which is derived from another such declaration (i.e., declared with MAXON_INTERFACE_SIMPLE_VIRTUAL or MAXON_INTERFACE_SIMPLE_VIRTUAL_DERIVED). You have to use the base interface as base class in the class declaration. The derived interface inherits all methods from its base interface. You cannot use more than one direct base interface. Example:

class DerivedSimpleInterface : private SimpleInterface
{
public:
MAXON_METHOD void DoSomethingElse();
};
#define MAXON_INTERFACE_SIMPLE_VIRTUAL_DERIVED(Name, REFKIND)
Definition: interfacebase.h:1804

The implementation of a derived simple virtual interface is the same as for a non-derived simple virtual interface.

Parameters
[in]NameName of the interface (has to be the same as the surrounding class name).
[in]REFKINDOne of MAXON_REFERENCE_NONE, MAXON_REFERENCE_POINTER, MAXON_REFERENCE_CONST_POINTER, MAXON_REFERENCE_NORMAL, MAXON_REFERENCE_CONST, MAXON_REFERENCE_COPY_ON_WRITE, MAXON_REFERENCE_ALWAYS_COPY_ON_WRITE.
See also
svinterfaces
MAXON_INTERFACE_SIMPLE_VIRTUAL

◆ MAXON_IMPLEMENTATION_SIMPLE

#define MAXON_IMPLEMENTATION_SIMPLE (   C)

MAXON_IMPLEMENTATION_SIMPLE has to be used in the implementation of a simple virtual interface. It defines the necessary members for such an implementation. For an example, see MAXON_INTERFACE_SIMPLE_VIRTUAL.

Don't forget to add MAXON_IMPLEMENTATION_SIMPLE_REGISTER below the implementation class.

Parameters
[in]CName of the implementation class (has to be the same as the surrounding class name).
See also
svinterfaces
MAXON_INTERFACE_SIMPLE_VIRTUAL

◆ MAXON_IMPLEMENTATION_SIMPLE_DERIVABLE

#define MAXON_IMPLEMENTATION_SIMPLE_DERIVABLE (   C,
  BASE 
)

MAXON_IMPLEMENTATION_SIMPLE_DERIVABLE has to be used in the implementation of a simple virtual interface. It defines the necessary members for such an implementation. For an example, see MAXON_INTERFACE_SIMPLE_VIRTUAL.

This wrapper macro enables the class to also be derived by other simple interface implementations.

Don't forget to add MAXON_IMPLEMENTATION_SIMPLE_REGISTER below the implementation class.

Parameters
[in]CName of the implementation class (has to be the same as the surrounding class name).
[in]BASEName of the class that is being derived from.
See also
svinterfaces
MAXON_INTERFACE_SIMPLE_VIRTUAL

◆ MAXON_IMPLEMENTATION_SIMPLE_FINAL

#define MAXON_IMPLEMENTATION_SIMPLE_FINAL (   C,
  BASE 
)

MAXON_IMPLEMENTATION_SIMPLE_FINAL can be used in the implementation of a simple virtual interface that will not be able to be derived from. It defines the necessary members and the default constructor for such an implementation. For an example, see MAXON_INTERFACE_SIMPLE_VIRTUAL.

Don't forget to add MAXON_IMPLEMENTATION_SIMPLE_REGISTER below the implementation class.

Parameters
[in]CName of the implementation class (has to be the same as the surrounding class name).
[in]BASEName of the base class.
See also
svinterfaces
MAXON_INTERFACE_SIMPLE_VIRTUAL

◆ MAXON_IMPLEMENTATION_SIMPLE_REGISTER

#define MAXON_IMPLEMENTATION_SIMPLE_REGISTER (   C)

MAXON_IMPLEMENTATION_SIMPLE_REGISTER completes the implementation of a simple virtual interface. It has to be used below the declaration of the implementation class (see MAXON_INTERFACE_SIMPLE_VIRTUAL).

Parameters
[in]CName of the implementation class.
See also
svinterfaces

◆ MAXON_GENERIC

#define MAXON_GENERIC (   ...)

◆ MAXON_GENERIC_BASE

#define MAXON_GENERIC_BASE (   ...)

◆ PRIVATE_MAXON_GENERIC_REMOVE_VARIANCE

#define PRIVATE_MAXON_GENERIC_REMOVE_VARIANCE (   ...)

◆ PRIVATE_PRIVATE_MAXON_GENERIC_REMOVE_VARIANCE

#define PRIVATE_PRIVATE_MAXON_GENERIC_REMOVE_VARIANCE

◆ PRIVATE_MAXON_GENERIC_A

#define PRIVATE_MAXON_GENERIC_A (   ...)

◆ PRIVATE_MAXON_GENERIC_B

#define PRIVATE_MAXON_GENERIC_B (   ...)

◆ PRIVATE_MAXON_GENERIC_C

#define PRIVATE_MAXON_GENERIC_C (   ...)

◆ PRIVATE_MAXON_GENERIC_D

#define PRIVATE_MAXON_GENERIC_D (   SWITCH,
  ... 
)

◆ PRIVATE_MAXON_GENERIC_SWITCH_A

#define PRIVATE_MAXON_GENERIC_SWITCH_A (   ...)

◆ PRIVATE_MAXON_GENERIC_SWITCH_B

#define PRIVATE_MAXON_GENERIC_SWITCH_B (   ...)

◆ PRIVATE_MAXON_GENERIC_SWITCH_C

#define PRIVATE_MAXON_GENERIC_SWITCH_C (   X,
  ... 
)

◆ PRIVATE_MAXON_GENERIC_SWITCH_D

#define PRIVATE_MAXON_GENERIC_SWITCH_D (   N)

◆ PRIVATE_MAXON_GENERIC_SWITCH_E

#define PRIVATE_MAXON_GENERIC_SWITCH_E (   N)

◆ PRIVATE_MAXON_GENERIC_SWITCH_F

#define PRIVATE_MAXON_GENERIC_SWITCH_F (   N)

◆ PRIVATE_MAXON_GENERIC_SWITCH_0

#define PRIVATE_MAXON_GENERIC_SWITCH_0 (   ...)

◆ PRIVATE_MAXON_GENERIC_SWITCH_1

#define PRIVATE_MAXON_GENERIC_SWITCH_1 (   ...)

◆ PRIVATE_MAXON_GENERIC_SWITCH_TYPENAME

#define PRIVATE_MAXON_GENERIC_SWITCH_TYPENAME (   ...)

◆ PRIVATE_MAXON_GENERIC_TYPENAME_TEST_typename

#define PRIVATE_MAXON_GENERIC_TYPENAME_TEST_typename

◆ PRIVATE_MAXON_GENERIC_USING_typename

#define PRIVATE_MAXON_GENERIC_USING_typename

◆ MAXON_INTERNED_ID

#define MAXON_INTERNED_ID (   IID,
  NAME 
)

MAXON_INTERNED_ID is used in a header file to define a global interned id as in

MAXON_INTERNED_ID("net.maxon.xyz", xyz);
#define MAXON_INTERNED_ID(IID, NAME)
Definition: module.h:64

xyz then refers to an InternedId with value "net.maxon.xyz". You can use this, e.g., for id-based maps where you need fast id comparisons: With interned ids, it suffices to just compare the Id pointers.

Parameters
[in]IIDC-string to use for the id.
[in]NAMEName of the global InternedId object to declare.
See also
MAXON_INTERNED_ID_LOCAL

◆ MAXON_INTERNED_ID_LOCAL

#define MAXON_INTERNED_ID_LOCAL (   IID,
  NAME 
)

MAXON_INTERNED_ID_LOCAL is used in a cpp file to define an InternedId as in

MAXON_INTERNED_ID_LOCAL("net.maxon.xyz", xyz);
#define MAXON_INTERNED_ID_LOCAL(IID, NAME)
Definition: module.h:81

xyz then refers to an InternedId with value "net.maxon.xyz". You can use this, e.g., for id-based maps where you need fast id comparisons: With interned ids, it suffices to just compare the Id pointers.

Parameters
[in]IIDC-string to use for the id.
[in]NAMEName of the InternedId object to declare.
See also
MAXON_INTERNED_ID
Note
The same NAME must not be used within more then one cpp file of a binary.

◆ MAXON_INITIALIZATION

#define MAXON_INITIALIZATION (   ...)

◆ MAXON_DECLARATION

#define MAXON_DECLARATION (   T,
  Name,
  id,
  ... 
)

MAXON_DECLARATION declares a published object with a unique identifier. You can use this macro in a header file, then the object can be used by including the header file. Also a dependency of the including source file on the definition of the object is set up, but only when the declarations is actually used within the source file (see Declaration::operator()). See published_objects for more details.

The object itself has to be defined in another source file. There are several kinds of published objects, each is defined in a different way:

  • General objects are defined by MAXON_DECLARATION_REGISTER.
    // header file
    MAXON_DECLARATION(Dimension, Length, "net.maxon.dimension.length");
    // source file defining the object
    {
    return g_baseDimensions[Int(BASE_DIMENSION::LENGTH)];
    }
    // source file using the component
    const Dimension& len = Dimensions::Length();
    PyObject PyObject const char const char char Py_ssize_t * len
    Definition: bytesobject.h:64
    #define MAXON_DECLARATION_REGISTER(...)
    Definition: module.h:1006
    MAXON_ATTRIBUTE_FORCE_INLINE Float32 Length(const Vector2d32 &input)
    Definition: apibasemath_extension.h:64
    LENGTH
    Definition: units.h:0
  • Classes can be defined as above, but typically they are defined by MAXON_COMPONENT_CLASS_REGISTER.
    // header file
    MAXON_DECLARATION(Class<InputStreamRef>, InputStreamBaseClass, "net.maxon.class.inputstreambase");
    // source file defining the class (it has to define the C++ class IoBaseInputStreamImpl)
    MAXON_COMPONENT_CLASS_REGISTER(IoBaseInputStreamImpl, InputStreamBaseClass);
    // source file using the class
    const Class<InputStreamRef>& cls = InputStreamBaseClass();
    PyObject * cls
    Definition: abstract.h:365
    #define MAXON_COMPONENT_CLASS_REGISTER(C,...)
    Definition: objectbase.h:2410
  • Component descriptors are defined by MAXON_COMPONENT_ONLY_REGISTER:
    // header file
    MAXON_DECLARATION(ComponentDescriptor, RPCComponent, "net.maxon.rpc.component.rpc");
    // source file defining the component
    MAXON_COMPONENT_ONLY_REGISTER(RPCComponentImpl, RPCComponent);
    // source file using the component
    const ComponentDescriptor& desc = RPCComponent();
    #define MAXON_COMPONENT_ONLY_REGISTER(C,...)
    Definition: objectbase.h:2359
    PyStructSequence_Desc * desc
    Definition: structseq.h:26

The macro creates a global C++ object with the given Name. It has Declaration as base class, and the referenced object of the given Type is obtained by writing Name(). Name.GetId() returns the unique identifier.

Parameters
[in]TypeType of the object. This can be any type which is supported by Data, or ComponentDescriptor for published components.
[in]NameName of the object within the current namespace.
[in]idUnique identifier of the object.
[in]...Optional code to put into the declaration's helper class, e.g. MAXON_IMPLEMENTATION_MODULE.
See also
object_declaration

◆ PRIVATE_MAXON_DECLARATION_END

#define PRIVATE_MAXON_DECLARATION_END

◆ PRIVATE_MAXON_DECLARATION

#define PRIVATE_MAXON_DECLARATION (   T,
  Name,
  id,
  storage,
  ... 
)

◆ PRIVATE_MAXON_DECLARATION_REGISTER_1

#define PRIVATE_MAXON_DECLARATION_REGISTER_1 (   cnt,
  Name 
)

◆ PRIVATE_MAXON_DECLARATION_REGISTER_2

#define PRIVATE_MAXON_DECLARATION_REGISTER_2 (   cnt,
  REGISTRY,
  Name 
)

◆ PRIVATE_MAXON_DECLARATION_REGISTER_A

#define PRIVATE_MAXON_DECLARATION_REGISTER_A (   N,
  CNT,
  ... 
)

◆ PRIVATE_MAXON_DECLARATION_REGISTER_B

#define PRIVATE_MAXON_DECLARATION_REGISTER_B (   N,
  CNT,
  ... 
)

◆ PRIVATE_MAXON_DECLARATION_REGISTER_C

#define PRIVATE_MAXON_DECLARATION_REGISTER_C (   N,
  CNT,
  ... 
)

◆ MAXON_DECLARATION_REGISTER

#define MAXON_DECLARATION_REGISTER (   ...)

MAXON_DECLARATION_REGISTER defines a published object which has been declared in a header file by MAXON_DECLARATION. This macro has to be in a source file of a single module. The macro has to be followed by a code block which initializes the object. To be able to do so, the block receives a parameter named objectId which contains the public Id of the object (this is the same as Name.GetId()), and it has to return the initialized object or an error (the return type of the code block is a Result).

The identifier is given in the ... argument. There are two possibilities:

  • You can use the name of a MAXON_DECLARATION from a header file if you want to define its value:
    MAXON_DECLARATION_REGISTER(Dimensions::Length)
    If the MAXON_DECLARATION is within a registry namespace, the object will also be added to the corresponding registry.
  • You can specify the name of a registry and a unique identifier. In this case the object will be added to the registry:
    MAXON_DECLARATION_REGISTER(ExecutionJobs, "net.maxon.execution.unittests")

Example:

See MAXON_DECLARATION for a complete example showing also the header file part.

Parameters
[in]...Here you have to specify either one or two arguments:
  • If you use a single argument, this has to be the name of the MAXON_DECLARATION which shall be defined.
  • If you use two arguments, the first has to name a registry and the second the identifier to use for the registration. The object will then be added to the registry.
See also
object_definition

◆ PRIVATE_MAXON_DECLARATION_REGISTER_DECLARATION

#define PRIVATE_MAXON_DECLARATION_REGISTER_DECLARATION (   Name,
  prefix,
  id 
)

◆ MAXON_DEPENDENCY

#define MAXON_DEPENDENCY (   Name)

MAXON_DEPENDENCY is used in conjunction with MAXON_DEPENDENCY_REGISTER. It has to be in the same namespace as the corresponding MAXON_DEPENDENCY_REGISTER.

Parameters
[in]NameName of the dependency.
See also
MAXON_DEPENDENCY_REGISTER
manual_dep

◆ MAXON_INTERFACE_BASES

#define MAXON_INTERFACE_BASES (   ...)

This macro has to be used for the declaration of a virtual interface to specify the base interfaces. If no specific base interface shall be used, ObjectInterface has to be used.

class IoHandlerInterface : MAXON_INTERFACE_BASES(ObjectInterface)
{
MAXON_INTERFACE(IoHandlerInterface, MAXON_REFERENCE_CONST, "net.maxon.interface.iohandler");
...
};
class InputStreamInterface : MAXON_INTERFACE_BASES(BaseStreamInterface)
{
MAXON_INTERFACE(InputStreamInterface, MAXON_REFERENCE_NORMAL, "net.maxon.interface.inputstream");
...
};
#define MAXON_REFERENCE_CONST(FREEIMPL)
Definition: interfacebase.h:1206
See also
MAXON_INTERFACE

◆ MAXON_INTERFACE_SINGLE_IMPLEMENTATION

#define MAXON_INTERFACE_SINGLE_IMPLEMENTATION

MAXON_INTERFACE_SINGLE_IMPLEMENTATION indicates for a virtual interface that there will be exactly one implementation of the interface which allows for more efficient method calls. The method calls will be as efficient as for a non-virtual interface, so in general there is no need to use non-virtual interfaces at all.

class DimensionInterface : MAXON_INTERFACE_BASES(ObjectInterface)
{
MAXON_INTERFACE(DimensionInterface, MAXON_REFERENCE_CONST, "net.maxon.interface.dimension");
...
};
#define MAXON_INTERFACE_SINGLE_IMPLEMENTATION
Definition: objectbase.h:1069

At runtime it is an error if there is not exactly one registered component which implements the interface.

See also
MAXON_INTERFACE

◆ MAXON_INTERFACE_INSTANTIATION

#define MAXON_INTERFACE_INSTANTIATION (   INSTANTIATION,
  ID,
  ... 
)

◆ MAXON_INTERFACE

#define MAXON_INTERFACE (   Name,
  REFKIND,
  ID,
  ... 
)

MAXON_INTERFACE marks a class declaration as a virtual interface declaration. Virtual interfaces specify a set of methods (tagged by MAXON_METHOD), and they can have several base interfaces (specified by MAXON_INTERFACE_BASES).

Each interface can be implemented by several components (see MAXON_COMPONENT). A set of components make a class (see ClassInterface), and the interface's methods can then be invoked on an object of a class which has a suitable component.

vinterfaces describes the declaration and implementation of virtual interfaces in detail. An example is the declaration of InputStreamInterface:

class InputStreamInterface : MAXON_INTERFACE_BASES(BaseStreamInterface)
{
MAXON_INTERFACE(InputStreamInterface, MAXON_REFERENCE_NORMAL, "net.maxon.interface.inputstream");
public:
MAXON_METHOD Result<Int> ReadEOS(const Block<Byte>& data);
...
};

There are also non-virtual interfaces (see MAXON_INTERFACE_NONVIRTUAL). Those only allow a single implementation of the interface for the whole application, while virtual interfaces allow several implementations with the right one being selected by the class of the object on which a method is invoked. In general one should prefer virtual interfaces, if needed you can use MAXON_INTERFACE_SINGLE_IMPLEMENTATION to improve the performance of a method call.

Parameters
[in]NameName of the interface (has to be the same as the surrounding class name).
[in]REFKINDOne of MAXON_REFERENCE_NORMAL, MAXON_REFERENCE_CONST, MAXON_REFERENCE_COPY_ON_WRITE, MAXON_REFERENCE_ALWAYS_COPY_ON_WRITE.
[in]IDThe unique identifier of the interface.
[in]...Optional information about the interface, for now only MAXON_IMPLEMENTATION_MODULE can be used here.
See also
vinterfaces
MAXON_COMPONENT
MAXON_METHOD
MAXON_FUNCTION
MAXON_INTERFACE_SINGLE_IMPLEMENTATION
MAXON_INTERFACE_NONVIRTUAL
Note
The base class of a virtual interface in the sense of C++ will always be ObjectInterface. Thus, the interface hierarchy isn't reflected by the C++ class hierarchy. But it is taken into account by the Ptr, ConstPtr and reference classes of virtual interfaces.
The macro itself leaves incomplete code which is completed by the source processor. So you have to place the macro in a header file, because the source processor only scans header files, and you have to include the generated hxx files in the header file. MAXON_INTERFACE must be placed somewhere before the #include of the first hxx file.

◆ MAXON_COMPONENT

#define MAXON_COMPONENT (   KIND,
  ... 
)

MAXON_COMPONENT marks a C++ class declaration as a component implementation. Component implementations implement a set of virtual interfaces (see MAXON_INTERFACE), and a set of components in turn defines a class (see ClassInterface). vinterfaces describes the component implementation in detail.

The basic usage is illustrated by the following example:

class IoFileOutputStream : public Component<IoFileOutputStream, OutputStreamInterface>
{
MAXON_COMPONENT(NORMAL, OutputStreamBaseClass);
public:
MAXON_METHOD Result<void> Write(const Block<const Byte>& data)
{
...
}
...
};
MAXON_COMPONENT_CLASS_REGISTER(IoFileOutputStream, "net.maxon.class.iofileoutputstream");
@ NORMAL
Normal Tag morphing.
ComponentWithBase< C, ComponentRoot, INTERFACES... > Component
Definition: objectbase.h:2798
#define MAXON_COMPONENT(KIND,...)
Definition: objectbase.h:2212

The component implementation class has to be publicly derived from the Component class template. The argument to the first template parameter of Component has to repeat the class, the further arguments list the implemented interfaces.

Optionally you can specify arguments to MAXON_COMPONENT. The KIND argument has to be one of

  • NORMAL: The normal case. If you don't need to specify base components, you can simply omit this and just write MAXON_COMPONENT().
  • ABSTRACT: The class defined by MAXON_COMPONENT_CLASS_REGISTER will be an abstract class. Doesn't make sense in combination with MAXON_COMPONENT_ONLY_REGISTER or MAXON_COMPONENT_OBJECT_REGISTER.
  • SINGLETON: The class defined by MAXON_COMPONENT_CLASS_REGISTER or MAXON_COMPONENT_OBJECT_REGISTER will be a singleton class. Doesn't make sense in combination with MAXON_COMPONENT_ONLY_REGISTER.
  • FINAL: The component will be marked as final. This means that it is not allowed to add further components to an object class after this component. So you can be sure that no method which is implemented by the final component will be overridden by another component.
  • FINAL_SINGLETON: Combination of FINAL and SINGLETON. Doesn't make sense in combination with MAXON_COMPONENT_ONLY_REGISTER.

After the KIND argument you can list base components or base classes. This only makes sense if the component is registered with MAXON_COMPONENT_CLASS_REGISTER or MAXON_COMPONENT_OBJECT_REGISTER: Those macros also define an object class which will contain the component. If you specify base components or base classes, they will be added automatically to the object class before the component itself is added.

Don't forget to add MAXON_COMPONENT_ONLY_REGISTER, MAXON_COMPONENT_CLASS_REGISTER or MAXON_COMPONENT_OBJECT_REGISTER below the implementation class.

Parameters
[in]KINDEither leave empty, or use one of NORMAL, ABSTRACT, SINGLETON, FINAL, FINAL_SINGLETON.
[in]...Optionally you can specify base components or base classes for the object class which is defined by MAXON_COMPONENT_CLASS_REGISTER or MAXON_COMPONENT_OBJECT_REGISTER.
See also
vinterfaces
MAXON_INTERFACE

◆ PRIVATE_MAXON_COMPONENT_KIND

#define PRIVATE_MAXON_COMPONENT_KIND

◆ PRIVATE_MAXON_COMPONENT_KINDNORMAL

#define PRIVATE_MAXON_COMPONENT_KINDNORMAL

◆ PRIVATE_MAXON_COMPONENT_KINDABSTRACT

#define PRIVATE_MAXON_COMPONENT_KINDABSTRACT

◆ PRIVATE_MAXON_COMPONENT_KINDSINGLETON

#define PRIVATE_MAXON_COMPONENT_KINDSINGLETON

◆ PRIVATE_MAXON_COMPONENT_KINDFINAL

#define PRIVATE_MAXON_COMPONENT_KINDFINAL

◆ PRIVATE_MAXON_COMPONENT_KINDFINAL_SINGLETON

#define PRIVATE_MAXON_COMPONENT_KINDFINAL_SINGLETON

◆ PRIVATE_MAXON_COMPONENT_BASES_A

#define PRIVATE_MAXON_COMPONENT_BASES_A (   POPULATED,
  ... 
)

◆ PRIVATE_MAXON_COMPONENT_BASES_B

#define PRIVATE_MAXON_COMPONENT_BASES_B (   POPULATED,
  ... 
)

◆ PRIVATE_MAXON_COMPONENT_BASES_C

#define PRIVATE_MAXON_COMPONENT_BASES_C (   POPULATED,
  ... 
)

◆ PRIVATE_MAXON_COMPONENT_BASES_0

#define PRIVATE_MAXON_COMPONENT_BASES_0 (   ...)

◆ PRIVATE_MAXON_COMPONENT_BASES_HELPER

#define PRIVATE_MAXON_COMPONENT_BASES_HELPER (   x,
  i,
 
)

◆ PRIVATE_MAXON_COMPONENT_BASES_1

#define PRIVATE_MAXON_COMPONENT_BASES_1 (   ...)

◆ PRIVATE_MAXON_COMPONENT_ID

#define PRIVATE_MAXON_COMPONENT_ID (   ...)

◆ PRIVATE_MAXON_COMPONENT_REGISTRY

#define PRIVATE_MAXON_COMPONENT_REGISTRY (   ...)

◆ PRIVATE_MAXON_COMPONENT_TYPE

#define PRIVATE_MAXON_COMPONENT_TYPE (   DEF,
  ... 
)

◆ PRIVATE_MAXON_COMPONENT_EXTRA_FLAGS

#define PRIVATE_MAXON_COMPONENT_EXTRA_FLAGS

◆ PRIVATE_MAXON_COMPONENT_REGISTER

#define PRIVATE_MAXON_COMPONENT_REGISTER (   C,
  TEMPLATE,
  TYPENAME,
  FLAGS,
  UNIT,
  REGISTRY,
  ... 
)

◆ MAXON_COMPONENT_SIMPLE

#define MAXON_COMPONENT_SIMPLE (   I)

◆ PRIVATE_MAXON_CLASS_REGISTER

#define PRIVATE_MAXON_CLASS_REGISTER (   C,
  TEMPLATE,
  REGISTRY,
  TYPE,
  ... 
)

◆ MAXON_COMPONENT_ONLY_REGISTER

#define MAXON_COMPONENT_ONLY_REGISTER (   C,
  ... 
)

MAXON_COMPONENT_ONLY_REGISTER registers a component. Usually you also want to register an object class using the component, then you have to use the macros MAXON_COMPONENT_CLASS_REGISTER or MAXON_COMPONENT_OBJECT_REGISTER instead.

class WrappedStreamImpl : public Component<WrappedStreamImpl, WrappedStreamInterface>
{
...
};
MAXON_COMPONENT_ONLY_REGISTER(WrappedStreamImpl, WrappedStreamComponent);

For the identifier there are three possibilities:

  • To define the component which shall be addressed by a MAXON_DECLARATION from a header file, you use the name of that MAXON_DECLARATION:
    MAXON_COMPONENT_ONLY_REGISTER(WrappedStreamImpl, WrappedStreamComponent);
  • You can register the component using a unique identifier, this is typically only used for adapter components:
    MAXON_COMPONENT_ONLY_REGISTER(OutdatedTestAdapter21, "net.maxon.component.outdatedtestadapter21");
  • You can specify the name of a registry and a unique identifier. In this case the component will also be added to the registry:
    MAXON_COMPONENT_ONLY_REGISTER(SomeComponentImpl, MyComponents, "net.maxon.test.somecomponent");
Parameters
[in]CName of the implementation class.
[in]...Here you have to specify either one or two arguments (similar to MAXON_DECLARATION_REGISTER):
  • If you use a single argument, this has to be the unique identifier to use for the component, or the name of a MAXON_DECLARATION if the component shall be the matching definition.
  • If you use two arguments, the first has to name a registry and the second the identifier to use for the component. The component will also be added to the registry.

◆ MAXON_COMPONENT_ONLY_REGISTER_TEMPLATE

#define MAXON_COMPONENT_ONLY_REGISTER_TEMPLATE (   C,
  ... 
)

MAXON_COMPONENT_ONLY_REGISTER_TEMPLATE has to be used instead of MAXON_COMPONENT_ONLY_REGISTER if the component class is a template specialization.

See also
MAXON_COMPONENT_CLASS_REGISTER_TEMPLATE

◆ MAXON_COMPONENT_CLASS_REGISTER

#define MAXON_COMPONENT_CLASS_REGISTER (   C,
  ... 
)

MAXON_COMPONENT_CLASS_REGISTER registers a component and also creates an object class which uses the component. This is the usual way to register a component because in most cases you also want to have an object class.

The object class consists of the base components and base classes (if any) which you have specified in the MAXON_COMPONENT macro, and then the component itself. You can obtain the object class by the GetClass() function of the component implementation class. The object class will also be registered using the identifier given as argument to the macro.

The identifier is given in the ... argument. There are three possibilities:

  • You can register the object class using a unique identifier:
    MAXON_COMPONENT_CLASS_REGISTER(IoFileOutputStream, "net.maxon.class.iofileoutputstream");
  • You can use the name of a MAXON_DECLARATION from a header file if the object class shall be the matching definition for the declaration:
    MAXON_COMPONENT_CLASS_REGISTER(IoFileHandler, IoHandlerObjectFileClass);
    If the MAXON_DECLARATION is within a registry namespace, the object class will also be added to the corresponding registry.
  • You can specify the name of a registry and a unique identifier. In this case the object class will also be added to the registry:
    MAXON_COMPONENT_CLASS_REGISTER(NodesLoopTest, UnitTestClasses, "net.maxon.node.unittest.loop");

The component will be registered using the same identifier as the object class. A complete example for the first variant is

class IoFileOutputStream : public Component<IoFileOutputStream, OutputStreamInterface>
{
MAXON_COMPONENT(NORMAL, OutputStreamBaseClass);
public:
...
};
MAXON_COMPONENT_CLASS_REGISTER(IoFileOutputStream, "net.maxon.class.iofileoutputstream");
Parameters
[in]CName of the implementation class.
[in]...Here you have to specify either one or two arguments (similar to MAXON_DECLARATION_REGISTER):
  • If you use a single argument, this has to be the unique identifier to use for the registration, or the name of a MAXON_DECLARATION if the object class shall be the matching definition.
  • If you use two arguments, the first has to name a registry and the second the identifier to use for the registration. The object class will also be added to the registry.

◆ MAXON_COMPONENT_CLASS_REGISTER_TEMPLATE

#define MAXON_COMPONENT_CLASS_REGISTER_TEMPLATE (   C,
  ... 
)

MAXON_COMPONENT_CLASS_REGISTER_TEMPLATE has to be used instead of MAXON_COMPONENT_CLASS_REGISTER if the component class is a template specialization. Example:

template <typename INTERFACE, typename OUTPUT> class OutStreamConverter : public Component<OutStreamConverter<INTERFACE, OUTPUT>, INTERFACE>
{
MAXON_COMPONENT(NORMAL, DataDictionaryObjectClass);
...
};
// MAXON_MACROARG_TYPE has to be used because of the comma
MAXON_COMPONENT_CLASS_REGISTER_TEMPLATE(MAXON_MACROARG_TYPE(OutStreamConverter<OutputStreamInterface, OutputStreamRef>), "net.maxon.class.outputstreamconverterfromoutputstream");
#define MAXON_COMPONENT_CLASS_REGISTER_TEMPLATE(C,...)
Definition: objectbase.h:2426

◆ MAXON_COMPONENT_OBJECT_REGISTER

#define MAXON_COMPONENT_OBJECT_REGISTER (   C,
  ... 
)

MAXON_COMPONENT_OBJECT_REGISTER registers a component, creates an object class which uses the component and finally creates an instance of the object class. The instance is registered under the given identifier.

As for MAXON_COMPONENT_CLASS_REGISTER, the object class consists of the base components and base classes (if any) which you have specified in the MAXON_COMPONENT macro, and then the component itself. You can obtain the object class by the GetClass() function of the component implementation class. In addition to MAXON_COMPONENT_CLASS_REGISTER this macro also creates an instance of the object class (using Create() on the class). This instance will be registered using the identifier given as argument to the macro. So you use this macro e.g. for registries like IoHandlers with entries of type IoHandler, while you use MAXON_COMPONENT_CLASS_REGISTER for registries like UnitTestClasses with entries of type Class<UnitTestRef>.

The identifier is given in the ... argument. There are three possibilities:

  • You can use the name of a MAXON_DECLARATION from a header file if the instance shall be the matching definition for the declaration:
    MAXON_COMPONENT_OBJECT_REGISTER(FileFormatHandlerGenericFileImpl, FileFormatHandlers::GenericFile);
    If the MAXON_DECLARATION is within a registry namespace, the instance will also be added to the corresponding registry.
  • You can specify the name of a registry and a unique identifier. In this case the instance will also be added to the registry:
    MAXON_COMPONENT_OBJECT_REGISTER(IoStdinHandler, IoHandlers, "net.maxon.iohandler.stdin");
  • You can register the instance using a unique identifier, but this is rarely used for MAXON_COMPONENT_OBJECT_REGISTER:
    MAXON_COMPONENT_OBJECT_REGISTER(MyComponentClass, "com.foo.myobject");

The component and object class will be registered using the same identifier as the created object itself. A complete example is

class IoStdinHandler : public Component<IoStdinHandler, IoHandlerInterface>
{
MAXON_COMPONENT(NORMAL, IoHandlerObjectBaseClass);
...
};
MAXON_COMPONENT_OBJECT_REGISTER(IoStdinHandler, IoHandlers, "net.maxon.iohandler.stdin");
#define MAXON_COMPONENT_OBJECT_REGISTER(C,...)
Definition: objectbase.h:2473
Parameters
[in]CName of the implementation class.
[in]...Here you have to specify either one or two arguments (similar to MAXON_DECLARATION_REGISTER):
  • If you use a single argument, this has to be the name of the MAXON_DECLARATION for which the object shall be the matching definition, or a unique identifier to use for the registration.
  • If you use two arguments, the first has to name a registry and the second the identifier to use for the registration. The object will also be added to the registry.

◆ MAXON_COMPONENT_OBJECT_REGISTER_TEMPLATE

#define MAXON_COMPONENT_OBJECT_REGISTER_TEMPLATE (   C,
  ... 
)

MAXON_COMPONENT_OBJECT_REGISTER_TEMPLATE has to be used instead of MAXON_COMPONENT_OBJECT_REGISTER if the component class is a template specialization.

See also
MAXON_COMPONENT_CLASS_REGISTER_TEMPLATE

◆ MAXON_STATIC_REGISTER

#define MAXON_STATIC_REGISTER (   C,
  ... 
)

◆ PRIVATE_MAXON_STATIC_REGISTER_A

#define PRIVATE_MAXON_STATIC_REGISTER_A (   C,
  ID,
  ... 
)

◆ PRIVATE_MAXON_STATIC_REGISTER_B

#define PRIVATE_MAXON_STATIC_REGISTER_B (   C,
  ID,
  ... 
)

◆ PRIVATE_MAXON_STATIC_REGISTER_C

#define PRIVATE_MAXON_STATIC_REGISTER_C (   C,
  ID,
  ... 
)

◆ PRIVATE_MAXON_INITIALIZED_TRANSLATION_UNIT

#define PRIVATE_MAXON_INITIALIZED_TRANSLATION_UNIT (   ...)

◆ PRIVATE_MAXON_INTERFACE_REGISTER_VIRTUAL

#define PRIVATE_MAXON_INTERFACE_REGISTER_VIRTUAL (   I,
  POSTFIX,
  TARGS,
  TEMPL,
  IID,
  ... 
)

◆ PRIVATE_MAXON_INTERFACE_REGISTER_VIRTUAL_SINGLE_IMPL

#define PRIVATE_MAXON_INTERFACE_REGISTER_VIRTUAL_SINGLE_IMPL (   I,
  POSTFIX,
  TARGS,
  TEMPL,
  IID,
  ... 
)

◆ PRIVATE_MAXON_INTERFACE_REGISTER_VIRTUAL_SINGLE_BASE

#define PRIVATE_MAXON_INTERFACE_REGISTER_VIRTUAL_SINGLE_BASE (   I,
  TEMPL,
  IID,
  BASE 
)

◆ PRIVATE_MAXON_INTERFACE_REGISTER_VIRTUAL_SINGLE_BASE_SINGLE_IMPL

#define PRIVATE_MAXON_INTERFACE_REGISTER_VIRTUAL_SINGLE_BASE_SINGLE_IMPL (   I,
  TEMPL,
  IID,
  BASE 
)

◆ PRIVATE_MAXON_INTERFACE_REGISTER_STATIC

#define PRIVATE_MAXON_INTERFACE_REGISTER_STATIC (   I,
  TEMPL,
  IID 
)

◆ MAXON_FUNCTIONNAME

#define MAXON_FUNCTIONNAME

This macro returns the function name of the current member or global function.

◆ MAXON_REGISTRY

#define MAXON_REGISTRY (   T,
  Name,
  id 
)

Declares a registry for entries of the given type. Registries serve as a registry of entries, i.e., values of a common registry-specific type. E.g., all classes are registered at registry Classes, while all data types are registered at DataTypes. More information about registries is given in extensions.

The macro defines a namespace of the given Name within the current namespace. This allows to add MAXON_DECLARATIONs to the namespace for registry entries which shall be made public in header files, however it is not mandatory to publish registry entries in header files:

MAXON_REGISTRY(FileFormat, FileFormats, "net.maxon.registry.fileformats");
namespace FileFormats
{
MAXON_DECLARATION(FileFormat, MaxonDocumentBinary, "net.maxon.fileformat.maxondocumentbinary");
MAXON_DECLARATION(FileFormat, MaxonDocumentJson, "net.maxon.fileformat.maxondocumentjson");
MAXON_DECLARATION(FileFormat, MaxonDocumentXml, "net.maxon.fileformat.maxondocumentxml");
}
#define MAXON_REGISTRY(T, Name, id)
Definition: registrybase.h:381

The naming convention for registries is to use the plural of the kind of objects which will be registered at the registry (for example DataTypes, IoHandlers) or, if classes are registered at the registry, the kind of objects of those classes with a "Classes" suffix (for example DataCompressionClasses, UnitTestClasses).

The following example declares a registry IoHandlers at which entries of type IoHandler can be registered.

Parameters
[in]TType of the values which are stored at the registry. Has to be supported by Data.
[in]NameName of the registry within the current namespace.
[in]idUnique identifier of the registry.

◆ CONSTSTRING

#define CONSTSTRING (   x)

◆ CONSTCSTRING

#define CONSTCSTRING (   x)

◆ FormatString

#define FormatString (   ...)

Format a string with additional parameters. The Output Syntax is documented here. The processed String is returned, e.g. String str = FormatString("@ cubes are @", 5, "green"_s);

◆ FormatCString

#define FormatCString (   ...)

Format a string with additional parameters. The Output Syntax is documented here. The processed CString is returned, e.g. CString str = FormatString("@ cubes are @", 5, "green"_s);

◆ MAXON_SWITCH_FALLTHROUGH

#define MAXON_SWITCH_FALLTHROUGH

This statement needs to be used for any case in a switch the contains code, but does not call break. An example:

switch(condition)
{
case 0:
...do something...
case 1:
...do something...
break;
}
#define MAXON_SWITCH_FALLTHROUGH
Definition: classhelpers.h:337

◆ MAXON_DISALLOW_COPY_AND_ASSIGN

#define MAXON_DISALLOW_COPY_AND_ASSIGN (   TypeName)

This statement needs to be used at the beginning of any class that cannot be copied An example:

class MyClass
{
...
};
#define MAXON_DISALLOW_COPY_AND_ASSIGN(TypeName)
Definition: classhelpers.h:352

◆ MAXON_OPERATOR_MOVE_ASSIGNMENT

#define MAXON_OPERATOR_MOVE_ASSIGNMENT (   TypeName)

This statement automatically creates a move assignment operator from an existing move constructor. The access control (private, protected or public) of the operator is inherited from the context, so you have to put the macro in the public section if you want to make the assignment operator public. An example:

class MyClass
{
public:
MyClass(MyClass&& src);
...
};
PyObject * src
Definition: abstract.h:305
#define MAXON_OPERATOR_MOVE_ASSIGNMENT(TypeName)
Definition: classhelpers.h:381
Note
This macro can't be used for classes with virtual functions for the sake of safety. Because the created move assignment operator would invoke the constructor, the vtable pointer of the object would be changed if one accidentally used the assignment operator of a base class for an object of a derived class.
This macro must not be used for classes which support concurrent move assignment calls from multiple threads to the same object because the sequence of destructor and move constructor is not thread-safe.
See also
MAXON_OPERATOR_COPY_ASSIGNMENT

◆ MAXON_OPERATOR_COPY_ASSIGNMENT

#define MAXON_OPERATOR_COPY_ASSIGNMENT (   TypeName)

This statement automatically creates a copy assignment operator from an existing copy constructor. The access control (private, protected or public) of the operator is inherited from the context, so you have to put the macro in the public section if you want to make the assignment operator public. An example:

class MyClass
{
public:
MyClass(const MyClass& src);
...
};
#define MAXON_OPERATOR_COPY_ASSIGNMENT(TypeName)
Definition: classhelpers.h:416
Note
This macro can't be used for classes with virtual functions for the sake of safety. Because the created copy assignment operator would invoke the constructor, the vtable pointer of the object would be changed if one accidentally used the assignment operator of a base class for an object of a derived class.
This macro must not be used for classes which support concurrent copy assignment calls from multiple threads to the same object because the sequence of destructor and copy constructor is not thread-safe.
See also
MAXON_OPERATOR_MOVE_ASSIGNMENT

◆ MAXON_OPERATOR_INEQUALITY

#define MAXON_OPERATOR_INEQUALITY (   TypeName)

This macro defines member operators >, <= and >= based on the member operator <. An example:

class MyClass
{
public:
Bool operator <(const MyClass& other) const { return ...; }
...
};
Bool operator<(const BaseTime &t1, const BaseTime &t2)
Definition: c4d_basetime.h:271
PyObject * other
Definition: dictobject.h:70
maxon::Bool Bool
Definition: ge_sys_math.h:51
#define MAXON_OPERATOR_INEQUALITY(TypeName)
Definition: classhelpers.h:441

◆ MAXON_OPERATOR_COMPARISON

#define MAXON_OPERATOR_COMPARISON (   TypeName)

This macro defines member operators !=, >, <= and >= based on the member operators == and <. An example:

class MyClass
{
public:
Bool operator ==(const MyClass& other) const { return ...; }
Bool operator <(const MyClass& other) const { return ...; }
...
};
Bool operator==(const BaseTime &t1, const BaseTime &t2)
Definition: c4d_basetime.h:264
#define MAXON_OPERATOR_COMPARISON(TypeName)
Definition: classhelpers.h:460

◆ PRIVATE_MAXON_MOVE_MEMBERS

#define PRIVATE_MAXON_MOVE_MEMBERS (   x,
  i,
 
)

◆ MAXON_MOVE_MEMBERS

#define MAXON_MOVE_MEMBERS (   ...)

MAXON_MOVE_MEMBERS simplifies the definition of a move constructor. Add all members which shall be moved from the source object to the new object to the argument list of MAXON_MOVE_MEMBERS as in

class Example
{
public:
Example(Example&& src) : MAXON_MOVE_MEMBERS(_a, _b) {}
private:
Int _a;
BaseArray<String> _b;
};
#define MAXON_MOVE_MEMBERS(...)
Definition: classhelpers.h:482

You have to use src as name of the constructor parameter.

◆ PRIVATE_MAXON_COPY_MEMBERS

#define PRIVATE_MAXON_COPY_MEMBERS (   x,
  i,
 
)

◆ MAXON_COPY_MEMBERS

#define MAXON_COPY_MEMBERS (   ...)

MAXON_COPY_MEMBERS simplifies the definition of a copy constructor. Add all members which shall be copied from the source object to the new object to the argument list of MAXON_COPY_MEMBERS as in

class Example
{
public:
Example(const Example& src) : MAXON_COPY_MEMBERS(_a, _b) {}
private:
Int _a;
String _b;
};
#define MAXON_COPY_MEMBERS(...)
Definition: classhelpers.h:501

You have to use src as name of the constructor parameter.

◆ PRIVATE_MAXON_COPYFROM_MEMBERS

#define PRIVATE_MAXON_COPYFROM_MEMBERS (   x,
  i,
 
)

◆ MAXON_COPYFROM_MEMBERS

#define MAXON_COPYFROM_MEMBERS (   ...)

◆ MAXON_OPERATOR_COPYFROM

#define MAXON_OPERATOR_COPYFROM (   T,
  ... 
)

◆ MAXON_HASHCODE

#define MAXON_HASHCODE (   ...)

MAXON_HASHCODE computes the hash code of the arguments based on DefaultCompare::GetCombinedHashCode.

◆ PRIVATE_MAXON_EQUALITY_OPERATORS

#define PRIVATE_MAXON_EQUALITY_OPERATORS (   x,
  i,
 
)

◆ MAXON_OPERATOR_EQUALITY

#define MAXON_OPERATOR_EQUALITY (   T,
  ... 
)

MAXON_OPERATOR_EQUALITY defines operator == and operator != for a class based on the equality operators for the class members. You have to list all members as in

{
public:
private:
Float64 _w;
};
Definition: c4d_quaternion.h:22
maxon::Float64 Float64
Definition: ge_sys_math.h:63
#define MAXON_OPERATOR_EQUALITY(T,...)
Definition: classhelpers.h:534

This will define the equality of two quaternions a, b by (a._w == b._w) && (a._v == b._v).

Parameters
[in]TThe enclosing class type for which the equality operators shall be defined.
[in]...List of class members. Equality operators must be available for the types of all members.
See also
MAXON_OPERATOR_HASH
MAXON_OPERATOR_EQUALITY_HASHCODE

◆ PRIVATE_MAXON_SIZEOF

#define PRIVATE_MAXON_SIZEOF (   X,
  I,
 
)

◆ PRIVATE_MAXON_IS_TRIVIALLY_HASHABLE

#define PRIVATE_MAXON_IS_TRIVIALLY_HASHABLE (   X,
  I,
 
)

◆ MAXON_OPERATOR_HASH

#define MAXON_OPERATOR_HASH (   T,
  ... 
)

MAXON_OPERATOR_HASH defines the GetHashCode/GetUniqueHashCode functions using DefaultCompare::GetHashCode/GetUniqueHashCode for the class members. You have to list all members as in

{
public:
private:
Float64 _w;
};
#define MAXON_OPERATOR_HASH(T,...)
Definition: classhelpers.h:559

This will define the hash code by DefaultCompare::GetCombinedHashCode(_w, _v).

Parameters
[in]TThe enclosing class type for which the hash code and hash value functions shall be defined.
[in]...List of class members. DefaultCompare::GetHashCode and DefaultCompare::GetUniqueHashCode must be available for the types of all members.
See also
MAXON_OPERATOR_EQUALITY
MAXON_OPERATOR_EQUALITY_HASHCODE

◆ MAXON_OPERATOR_EQUALITY_HASHCODE

#define MAXON_OPERATOR_EQUALITY_HASHCODE (   T,
  ... 
)

MAXON_OPERATOR_EQUALITY_HASHCODE defines operator == and operator != for a class based on the equality operators for the class members, and it defines the GetHashCode/GetUniqueHashCode functions using DefaultCompare::GetHashCode/GetUniqueHashCode for the class members. You have to list all members as in

{
public:
private:
Float64 _w;
};
#define MAXON_OPERATOR_EQUALITY_HASHCODE(T,...)
Definition: classhelpers.h:593

This will define the equality of two quaternions a, b by (a._w == b._w) && (a._v == b._v), and the hash code by DefaultCompare::GetCombinedHashCode(_w, _v).

Parameters
[in]TThe enclosing class type for which the equality operators and the hash code and hash value shall be defined.
[in]...List of class members. Equality operators must be available for the types of all members, likewise DefaultCompare::GetHashCode and DefaultCompare::GetUniqueHashCode.
See also
MAXON_OPERATOR_EQUALITY
MAXON_OPERATOR_HASH

◆ PRIVATE_MAXON_STRUCT_MEMBER_TOSTRING

#define PRIVATE_MAXON_STRUCT_MEMBER_TOSTRING (   x,
  i,
 
)

◆ PRIVATE_MAXON_STRUCT_MEMBER_TYPE

#define PRIVATE_MAXON_STRUCT_MEMBER_TYPE (   x,
  i,
 
)

◆ PRIVATE_MAXON_STRUCT_MEMBER_COPY

#define PRIVATE_MAXON_STRUCT_MEMBER_COPY (   x,
  i,
 
)

◆ MAXON_OPERATOR_STRUCT

#define MAXON_OPERATOR_STRUCT (   T,
  ... 
)

◆ MAXON_STRUCT_TUPLE

#define MAXON_STRUCT_TUPLE (   T,
  ... 
)

◆ MAXON_NONCONST_COUNTERPART

#define MAXON_NONCONST_COUNTERPART (   ...)

MAXON_NONCONST_COUNTERPART simplifies the implementation of a non-const counterpart of a const member function where the non-const function shall do exactly the same as the const function, but return a non-const value:

const V* FindValue(const K& key) const
{
...
}
V* FindValue(const K& key)
{
return MAXON_NONCONST_COUNTERPART(FindValue(key));
}
PyObject * key
Definition: abstract.h:289

If the implementation code is a simple one-liner, you may find it easier to just copy the code from the const function to the non-const function, but for more complex functions this code duplication should be avoided by just calling the const function in the non-const function (and adding the necessary casts). This is exactly what MAXON_NONCONST_COUNTERPART does.

The return type of the called const function has to be either a pointer or a reference to a const value, and the non-const function needs to have the corresponding non-const return type.

Parameters
[in]...The call to the const function, see example. You have to forward all function parameters.

◆ PRIVATE_MAXON_MEMBER_ACCESSORS_PARAMS

#define PRIVATE_MAXON_MEMBER_ACCESSORS_PARAMS (   x,
  i,
 
)

◆ PRIVATE_MAXON_MEMBER_ACCESSORS_ARGS

#define PRIVATE_MAXON_MEMBER_ACCESSORS_ARGS (   x,
  i,
 
)

◆ MAXON_MEMBER_ACCESSORS

#define MAXON_MEMBER_ACCESSORS (   T,
  M,
  ... 
)

MAXON_MEMBER_ACCESSORS simplifies the implementation of all four variants of member accessor functions which return the member by reference. You only have to implement the const l-value variant, and the macro adds the remaining three (non-const l-value, const r-value, non-const r-value). In general one should have all four variants like in this example:

class Test
{
public:
const Vector& GetValue() const & { return _value; }
Vector& GetValue() & { return _value; }
Vector GetValue() && { return std::move(_value); }
Vector GetValue() const && { return _value; }
private:
Vector _value;
};

This is to prevent code which returns references to temporaries, for example the following code compiles but crashes at run-time if Test didn't have ref-qualified accessor functions:

Test Func();
const Vector& Func2()
{
return Func().GetValue();
}

With ref-qualified accessor functions the code doesn't compile. To simplify the implementation the macro defines the latter three functions in terms of the const l-value accessor function:

class Test
{
public:
const Vector& GetValue() const & { return _value; }
private:
Vector _value;
};
#define MAXON_MEMBER_ACCESSORS(T, M,...)
Definition: classhelpers.h:706
Parameters
[in]TThe return type of the accessor functions (without any qualifier).
[in]MThe name of the accessor function.
[in]...List of parameter types of the accessor function (empty if the function has no parameters).

◆ MAXON_DECLARE_CONDITIONAL_COPY_CONSTRUCTOR

#define MAXON_DECLARE_CONDITIONAL_COPY_CONSTRUCTOR (   cls,
  cond 
)

This macro exists to improve the readability of defining a conditionally enabled copy constructor. The regular approach of using std::enable_if as a template argument should be used, because if templated versions exist, the compiler may default-generate an implicit the copy constructor and prefer that. The alternative approach is to conditionally define the type of the argument: If the given condition is matched, the substituted type is that of an actual copy/move constructor. Otherwise, DummyParamType is used, so the function is not a copy constructor. Analogous variants exist for move constructor and copy/move assignment operators.

Parameters
[in]TType of the enclosing class.
[in]condThe condition under which the copy constructor is enabled. Must be dependent on T.

◆ MAXON_DECLARE_CONDITIONAL_MOVE_CONSTRUCTOR

#define MAXON_DECLARE_CONDITIONAL_MOVE_CONSTRUCTOR (   cls,
  cond 
)

◆ MAXON_DECLARE_CONDITIONAL_COPY_ASSIGNMENT

#define MAXON_DECLARE_CONDITIONAL_COPY_ASSIGNMENT (   cls,
  cond 
)

◆ MAXON_DECLARE_CONDITIONAL_MOVE_ASSIGNMENT

#define MAXON_DECLARE_CONDITIONAL_MOVE_ASSIGNMENT (   cls,
  cond 
)

◆ MAXON_TARGET_RELEASE

#define MAXON_TARGET_RELEASE

◆ STD_IS_REPLACEMENT

#define STD_IS_REPLACEMENT (   name,
  ... 
)

◆ MAXON_WARN_UNUSED

#define MAXON_WARN_UNUSED

This macro is used to create a compile error under XCode and GCC if a function's return value is not examined. It should always be used in combination with the Result<> error handling, but is not limited to it. Write this macro at the beginning of your function declaration - before 'static' and the Result<T> return value. MAXON_WARN_UNUSED does not need to be written in declarations of virtual or non-virtual interfaces when the keyword MAXON_METHOD was used. Here an example:

template <typename T> static Result<void> Function(T val)
{
...
}
PyObject const char PyObject PyObject ** val
Definition: pycore_pyerrors.h:76

◆ MAXON_WARN_UNUSED_CLASS

#define MAXON_WARN_UNUSED_CLASS

◆ MAXON_WARN_MUTE_UNUSED

#define MAXON_WARN_MUTE_UNUSED

The MAXON_WARN_MUTE_UNUSED macro is deprecated. Please use iferr_ignore or iferr_cannot_fail and specify the reason why error handling isn't necessary.

◆ MAXON_OFFSETOF_NON_STANDARD_LAYOUT

#define MAXON_OFFSETOF_NON_STANDARD_LAYOUT

◆ MAXON_ASSERT_STANDARD_LAYOUT

#define MAXON_ASSERT_STANDARD_LAYOUT (   T)

◆ MAXON_ASSERT_LEGAL_LAYOUT

#define MAXON_ASSERT_LEGAL_LAYOUT (   T)

◆ MAXON_SWITCH_CHECKALLENUMS_BEGIN

#define MAXON_SWITCH_CHECKALLENUMS_BEGIN

This macro enables a error or warning if a switch statement wont implement an enumeration. usage:

enum class X { A, B };
switch (enumvar)
{
case A:
}
#define MAXON_SWITCH_CHECKALLENUMS_BEGIN
Definition: compilerdetection.h:384
#define MAXON_SWITCH_CHECKALLENUMS_END
Definition: compilerdetection.h:385
A
Quality A.
Definition: macros.h:1
@ A
Quality A.
@ B
Quality B.

The compiler will print "error C4062: enumerator 'maxon::X::B' in switch of enum 'maxon::X' is not handled"

◆ MAXON_SWITCH_CHECKALLENUMS_END

#define MAXON_SWITCH_CHECKALLENUMS_END

◆ MAXON_ASSUME_ALIGNED

#define MAXON_ASSUME_ALIGNED (   val,
  alignment 
)

◆ MAXON_LIKELY

#define MAXON_LIKELY (   ...)

◆ MAXON_UNLIKELY

#define MAXON_UNLIKELY (   ...)

◆ MAXON_SAFE_PLACEMENT_NEW

#define MAXON_SAFE_PLACEMENT_NEW (   PTR)

Clang 3.7 introduced a new optimization where a placement new wont check the given ptr for nullptr. for places where the pointer is already checked outside this is a great optimization. but places that allocate memory and pass this without a check to the placement new would crash the app. example:

#define MAXON_SAFE_PLACEMENT_NEW(PTR)
Definition: compilerdetection.h:469

http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1748 http://llvm.org/viewvc/llvm-project?view=revision&revision=229213

◆ MAXON_FILE

#define MAXON_FILE

◆ FORMATTEMPLATECHECK0

#define FORMATTEMPLATECHECK0 (   formatString,
  ... 
)

◆ FORMATTEMPLATECHECK1

#define FORMATTEMPLATECHECK1 (   formatString,
  ... 
)

◆ FORMATTEMPLATECHECK_C

#define FORMATTEMPLATECHECK_C (   count,
  formatString,
  ... 
)

◆ FORMATTEMPLATECHECK_B

#define FORMATTEMPLATECHECK_B (   count,
  formatString,
  ... 
)

◆ FORMATTEMPLATECHECK_A

#define FORMATTEMPLATECHECK_A (   count,
  formatString,
  ... 
)

◆ FORMATTEMPLATECHECK

#define FORMATTEMPLATECHECK (   formatString,
  ... 
)

◆ OutputWithFlags

#define OutputWithFlags (   flags,
  formatString,
  ... 
)

OutputWithFlags outputs text into the console. The output is visible in debug builds or in a release build when the debug console with diagnostic output is activated. The full Output Syntax can be used for the format string. Note that if you do not specify any additional parameters after the formatting string no formatting takes place - the raw string will stay unchanged. THREADSAFE.

◆ DebugOutput

#define DebugOutput (   flags,
  formatString,
  ... 
)

DebugOutput outputs text into the console. It only has any effect in debug builds and does not cost any time in release builds. It should be used for temporary output that must not be visible to a customer or external developer. The full Output Syntax can be used for the format string. Note that if you do not specify any additional parameters after the formatting string no formatting takes place - the raw string will stay unchanged. The flags are of type OUTPUT. THREADSAFE.

◆ DiagnosticOutput

#define DiagnosticOutput (   formatString,
  ... 
)

DiagnosticOutput outputs text into the console. The output is visible in debug builds or in a release build when the debug console with diagnostic output is activated. The full Output Syntax can be used for the format string. Note that if you do not specify any additional parameters after the formatting string no formatting takes place - the raw string will stay unchanged. THREADSAFE.

◆ DiagnosticVarOutput

#define DiagnosticVarOutput (   ...)

DiagnosticVarOutput outputs the values of variables into the console. It shows the variable names as well as their values. E.g. write {DiagnosticVarOutput(x, _y, v.z);} to get an output like {"x: 42, _y: 99, v.z: 0"}. The output is visible in debug builds or in a release build when the debug console with diagnostic output is activated. THREADSAFE.

◆ PRIVATE_MAXON_DiagnosticVarOutput

#define PRIVATE_MAXON_DiagnosticVarOutput (   x,
  i,
 
)

◆ WarningOutput

#define WarningOutput (   formatString,
  ... 
)

WarningOutput outputs text into the console. The output is visible in debug builds or in a release build when the debug console with warning output is activated. It should only be used to output unexpected, non-critical conditions. It automatically shows header information and adds a line break. The full Output Syntax can be used for the format string. Note that if you do not specify any additional parameters after the formatting string no formatting takes place - the raw string will stay unchanged. THREADSAFE.

◆ CriticalOutput

#define CriticalOutput (   formatString,
  ... 
)

CriticalOutput outputs text into the console. The output is visible in debug builds or in a release build when the debug console with critical output is activated. It should only be used to output unexpected, critical conditions that would most likely result in instability, e.g. an illegal array access or corrupt object structure. It can also be used for unexpected events, e.g. if a necessary module cannot be initialized. It automatically shows header information and adds a line break. It automatically stops the debugger if present. The full Output Syntax can be used for the format string. Note that if you do not specify any additional parameters after the formatting string no formatting takes place - the raw string will stay unchanged. THREADSAFE.

◆ ApplicationOutput

#define ApplicationOutput (   formatString,
  ... 
)

ApplicationOutput outputs text to the application console. The output is visible in the GUI version of the application. The full Output Syntax can be used for the format string. Note that if you do not specify any additional parameters after the formatting string no formatting takes place - the raw string will stay unchanged. THREADSAFE.

◆ OUTPUTCHECK0

#define OUTPUTCHECK0 (   A,
 
)

◆ OUTPUTCHECK1

#define OUTPUTCHECK1 (   A,
 
)

◆ OUTPUTCHECK_C

#define OUTPUTCHECK_C (   count,
  A,
 
)

◆ OUTPUTCHECK_B

#define OUTPUTCHECK_B (   count,
  A,
 
)

◆ OUTPUTCHECK_A

#define OUTPUTCHECK_A (   count,
  A,
 
)

◆ OUTPUTCHECK

#define OUTPUTCHECK (   A,
  B,
  ... 
)

◆ DebugStop

#define DebugStop (   ...)

DebugStop stops the execution of the application if it is a debug build and a debugger is present. In case of a debug build the file and line number are output (critical output category). A C string can be passed as argument that will be output as well. THREADSAFE.

◆ CriticalStop

#define CriticalStop (   ...)

CriticalStop stops the execution of the application if a debugger is present. The file and line number are output (critical output category). A C string can be passed as argument that will be output as well. THREADSAFE.

◆ DebugAssert

#define DebugAssert (   condition,
  ... 
)

DebugAssert is a conditional DebugStop. It does the same as DebugStop() if 'condition' is false. A C string can be passed as optional argument for output. THREADSAFE.

◆ CriticalAssert

#define CriticalAssert (   condition,
  ... 
)

CriticalAssert is a conditional CriticalStop. It does the same as CriticalStop() if 'condition' is false. A C string can be passed as optional argument for output. THREADSAFE.

◆ SizeAssert

#define SizeAssert (   type,
  s 
)

SizeAssert is a static assert verified at compile-time. It checks if the passed type is of size 's'. On failure an exception of negative STATICASSERT_CONDITION_FALSE is raised. THREADSAFE.

◆ MAXON_SOURCE_LOCATION

#define MAXON_SOURCE_LOCATION

MAXON_SOURCE_LOCATION creates a SourceLocation object for the current file location that can be passed to a memory allocation function (or something similar). This will later be used to track the origin of memory leaks. You could as well write SourceLocation(MAXON_FILE, LINE) in your code, but the purpose of this macro is to be able to easily modify the inner workings of the memory leak detector without having to modify all callers.

◆ MAXON_SOURCE_LOCATION_DECLARATION

#define MAXON_SOURCE_LOCATION_DECLARATION

MAXON_SOURCE_LOCATION_DECLARATION is a helper macro for function declarations that expect information about the origin of a memory allocation. Again the purpose of the macro is to be able to easily modify the inner workings of memory the leak detector without having to modify all callers.

◆ MAXON_SOURCE_LOCATION_FORWARD

#define MAXON_SOURCE_LOCATION_FORWARD

MAXON_SOURCE_LOCATION_FORWARD is used to forward information about the origin of a memory allocation to other functions with a MAXON_SOURCE_LOCATION_DECLARATION. The purpose of the macro is to be able to easily modify the inner workings of memory the leak detector without having to modify all callers.

◆ MAXON_SOURCE_LOCATION_NAME

#define MAXON_SOURCE_LOCATION_NAME (   x)

MAXON_SOURCE_LOCATION_NAME adds the allocated object name to the SourceLocation object.

◆ MAXON_FUNCTION_SIGNATURE

#define MAXON_FUNCTION_SIGNATURE

MAXON_FUNCTION_SIGNATURE return the name of the function the code is located in.

◆ PRIVATE_MAXON_UNITTESTERROR0

#define PRIVATE_MAXON_UNITTESTERROR0 (   type,
  condition,
  msg 
)

Internal helper to include original error's message in the UnitTestError.

◆ PRIVATE_MAXON_UNITTESTERROR1

#define PRIVATE_MAXON_UNITTESTERROR1 (   type,
  condition,
  msg 
)

◆ PRIVATE_MAXON_UNITTESTERROR_C

#define PRIVATE_MAXON_UNITTESTERROR_C (   type,
  condition,
  msgPopulated,
  msg 
)

◆ PRIVATE_MAXON_UNITTESTERROR_B

#define PRIVATE_MAXON_UNITTESTERROR_B (   type,
  condition,
  msgPopulated,
  msg 
)

◆ PRIVATE_MAXON_UNITTESTERROR_A

#define PRIVATE_MAXON_UNITTESTERROR_A (   type,
  condition,
  msgPopulated,
  ... 
)

◆ CheckUnitTestState

#define CheckUnitTestState (   condition,
  ... 
)

This macro checks the specified condition, and if this evaluates to false, a UnitTestError is returned from the current function. The condition will be part of the error message (taken over verbatim). The macro can only be used in a function which returns a Result<T>.

Optionally, you can specify a message which will be used instead of the verbatim condition. The message may use formatting like FormatString.

For examples, see CheckArgument.

Parameters
[in]conditionThe condition to evaluate. If it evaluates to false, an UnitTestError will be returned.
[in]...Optional message and parameters, will be formatted by FormatString.
See also
CheckArgument

◆ CheckUnitTestResultOk

#define CheckUnitTestResultOk (   functioncall,
  ... 
)

This macro checks if the result of the given function call returns no error. Any non error result is accepted, content of the Result will not be tested. If the function call returns an error of any type, the unit test fails, returning a UnitTestError. The function call string will be part of the error message (taken over verbatim). The macro can only be used in a function which returns a Result<T>.

See also
CheckUnitTestState

◆ CheckUnitTestResultError

#define CheckUnitTestResultError (   functioncall,
  ... 
)

Opposite of CheckUnitTestResultOk. Use in a unit test to validate that a given function call results in any kind of error. If no error is detected from the function call, the unit test fails, returning a UnitTestError.

See also
CheckUnitTestResultOk

Typedef Documentation

◆ OverloadRank0

Use OverloadRank0 .. OverloadRank5 as parameter types for a set of overloaded functions which have to be selected by means of SFINAE. OverloadRank0 has to be used for the least specific function (the fallback), higher ranks for the more specific functions in the correct order. E.g:

// this fallback will be chosen if T has neither a member type named Marker nor a member type named ExtraMarker:
template <typename T> void Func(const T& object, OverloadRank0);
// will be chosen if T has a member type named Marker, but no member type named ExtraMarker:
template <typename T> typename SFINAEHelper<void, typename T::Marker>::type Func(const T& object, OverloadRank1);
// will be chosen if T has a member type named ExtraMarker:
template <typename T> typename SFINAEHelper<void, typename T::ExtraMarker>::type Func(const T& object, OverloadRank2);
T type
The result type will always be T.
Definition: apibase.h:534
PrivateOverloadRank0 * OverloadRank0
Definition: apibase.h:664
PrivateOverloadRank2 * OverloadRank2
See OverloadRank0.
Definition: apibase.h:670
PrivateOverloadRank1 * OverloadRank1
See OverloadRank0.
Definition: apibase.h:667

The set of overloaded functions has to be invoked with OVERLOAD_MAX_RANK as argument for the overload selection parameter:

PyObject * obj
Definition: complexobject.h:60
#define OVERLOAD_MAX_RANK
Use this as argument for the overload selection parameter of a set of overloaded functions,...
Definition: apibase.h:684

◆ OverloadRank1

See OverloadRank0.

◆ OverloadRank2

See OverloadRank0.

◆ OverloadRank3

See OverloadRank0.

◆ OverloadRank4

See OverloadRank0.

◆ OverloadRank5

See OverloadRank0.

◆ OverloadRankMax

◆ AddArrayT

using AddArrayT = T[N]

This type alias stands for the type {T[N]}.

Template Parameters
TA type.
NThe bound of the array.

◆ AddArrayOfUnknownBoundT

This type alias stands for the type {T[]}.

Template Parameters
TA type.

◆ GenericCastReturnType

using GenericCastReturnType = std::enable_if<GenericCastTrait<TO, typename maxon::details::MakeLValueConst<FROM>::type, SAFE>::value, typename GenericCastTrait<TO, typename maxon::details::MakeLValueConst<FROM>::type, SAFE>::ReturnType>

◆ ExecutionInterface

Class for code that needs to be executed once the whole system including modules is up and running. To register code write:

class ExecutionExample : public ExecutionInterface<ExecutionExample>
{
public:
Result<void> operator ()()
{
..do something..
return OK;
}
};
MAXON_DECLARATION_REGISTER(ExecutionJobs, "net.maxon.execution.example")
{
return NewObj(ExecutionExample);
}
return OK
Definition: apibase.h:2735
JobInterfaceTemplate< EXECUTION > ExecutionInterface
Definition: execution.h:33
#define NewObj(T,...)
Definition: newobj.h:108

◆ AddResult

using AddResult = typename maxon::details::AddResultHelper<T, HAS_ERROR>::type

◆ Out

using Out = std::is_constructible<TO, FROM>

◆ ClassTransformer

◆ Component

using Component = ComponentWithBase<C, ComponentRoot, INTERFACES...>

◆ AdapterComponent

using AdapterComponent = ComponentWithBase<C, AdapterRoot, FROM, INTERFACES...>

◆ SelfPtr

using SelfPtr = typename ComponentHelper<ComponentRoot, INTERFACES...>::type::SelfPtr

◆ Utf16CharBuffer

◆ Utf32CharBuffer

◆ FROMSTR

using FROMSTR = void (*)(void* p, const Block<const Utf32Char>& str, Int& processed, const String& formatStatement, Bool& error)

◆ NonEmptyBases

using NonEmptyBases = typename maxon::details::NonEmptyBasesHelper<typename std::conditional<STD_IS_REPLACEMENT(empty, BASES), EmptyClass, BASES>::type...>::type

NonEmptyBases is a type which has all of the classes given in BASES as (possibly indirect) base classes, except those which are empty. It can be used to avoid padding bytes which some compilers add for empty base classes. If all classes in BASES are empty, then NonEmptyBases is just a type alias for EmptyClass.

Template Parameters
BASESList of base classes.

◆ TOSTR

using TOSTR = void (*)(String& result, const void* ptr, const FormatStatement* formatStatement)

Enumeration Type Documentation

◆ SUBSYSTEM

enum SUBSYSTEM
strong

Available subsystems (Windows only)

Enumerator
UNDEFINED 

Undefined SUBSYSTEM.

CONSOLE 

(\/SUBSYSTEM:CONSOLE)

WINDOWS 

(\/SUBSYSTEM:WINDOWS)

◆ APPLICATION_URLTYPE

enum APPLICATION_URLTYPE
strong

Possible values for GetUrl() function.

Enumerator
STARTUP_DIR 

The directory where the executable/bundle is placed in. The executable name is not part of the Url.

APPLICATION 

The Url of the executable (Windows / Linux) or bundle (OS X / iOS).

APP_EXECUTABLE 

The Url of the inner executable. Under Windows / Linux this is identical to APPLICATION. Under OS X / iOS this is the Url inside the bundle.

CORELIBS_DIR 

The directory where the core modules are placed in.

RESOURCE_DIR 

The directory where the resource is placed in.

TEMP_DIR 

Temporary directory where data can be read or written. The temporary directory is placed in various locations depending on the operating system.

PREFS_DIR 

Preferences directory. The preferences directory is based on the startup Url of the application. If the parent directory location is changed, the preferences Url will change as well. The preferences directory is placed in various locations depending on the operating system.

GLOBALPREFS_DIR 

Global preferences directory. The global preferences Url is always in the same place for all applications on the same operating system.

DESKTOP_DIR 

Users desktop directory.

USER_HOME_DIR 

Users Home directory.

USER_DOCUMENTS_DIR 

Users documents directory.

SYSTEM_PROGRAMS_DIR 

System application directory. This is where apps are installed by default (e.g. "C:\Program Files")

CURRENT_WORKING_DIR 

Current working directory.

CURRENT_MODULE_DIR 

Directory of the module that invoked this call.

CURRENT_MODULE_RESOURCE_DIR 

Resource directory of the module that invoked this call.

LIBRARY_DIR 

Library directory.

PREFS_DIR_STATIC 

Same as PREFS_DIR but without being able to set the path in the config. Cineware AE plug-in generates a lite.cert file at this location. Used for placing and reading the Lite certification file.

TESTDATA_DIR 

Path to the test data file within g_testDataDir.

◆ APPLICATIONMODE

enum APPLICATIONMODE
strong
See also
Application::SetApplicationMode().
Enumerator
DONTWAIT 

Stops the execution as soon as all initializations are done, used for command line mode.

KEEPRUNNING 

Keeps the program running after all initializations.

SHUTDOWN 

Quits the application and leave the main loop. Only working when APPLICATIONMODE::KEEPRUNNING was set before.

◆ APPLICATIONFEATURE

enum APPLICATIONFEATURE
strong
Enumerator
NONE 

Default case.

COMMANDLINE 

Application runs as headless command line version.

LIBRARY 

Frameworks are used by plugins or another host (Cineware, Redshift, ...)

UI 

UI is enabled (if this is LIBRARY or COMMANDLINE)

◆ STRINGCONVERSION

enum STRINGCONVERSION
strong

Flags for the string to value conversion.

Enumerator
NONE 
ALLOW_MORE_CHARACTERS 

if the specified string is longer than the converted characters and you specify this flag no error will be returned

◆ STRINGCOMPARISON

enum STRINGCOMPARISON
strong

String Comparison Mode.

Enumerator
MEMORY 

default - fast comparison, memory block is directly compared. This does not result in a correct alphabetical order.

UNICODE_LETTERS 

strings are compared using correct unicode decomposition

UNICODE_NUMBERS 

strings are compared using correct unicode decomposition. Numbers in strings are identified, so "2" is smaller than "10"

CASEINSENSITIVE 

strings are compared case-insensitive using correct unicode decomposition

CASEINSENSITIVE_NUMBERS 

strings are compared case-insensitive using correct unicode decomposition. Numbers in strings are identified, so "2" is smaller than "10"

◆ NORMALIZATION

enum NORMALIZATION
strong
Enumerator
NFC 
NFD 
NKDC 
NFKD 
NFD_HFS 

◆ CHARACTERTYPE

enum CHARACTERTYPE : UChar
strong
Enumerator
UNKNOWN 
LU 
LL 
LT 
LM 
LO 
MN 
MC 
ME 
ND 
NL 
NO 
PC 
PD 
PS 
PE 
PI 
PF 
PO 
SM 
SC 
SK 
SO 
ZS 
ZL 
ZP 
CC 
CF 
CS 
CO 
CN 

◆ TARGETAUDIENCE

enum TARGETAUDIENCE
strong
Enumerator
DEBUGGER 
DEVELOPERS 
USERS 
ALL 

◆ WRITEMETA

enum WRITEMETA
strong
Enumerator
DEFAULT 
WARNING 
CRITICAL 
NONEWLINE 
UI_SYNC_DRAW 

◆ OUTPUT

enum OUTPUT
strong

Output flags for OutputWithFlags and DebugOutput.

Enumerator
NONE 

No flag set.

DIAGNOSTIC 

Diagnostic output, shows up if this group of output is activated. This is also the default.

WARNING 

Warning output, shows up if this group of output is activated.

CRITICAL 

Critical output, shows up if this group of output is activated.

PRETTYPRINT 

If set, it is tried to break and indent long output according to parentheses and commas.

NOLINEBREAK 

If set, no line break is added.

HEADER 

If set, header with line number and file name is added.

◆ REGPARSEMODE

enum REGPARSEMODE
strong

Regular expression parser find mode.

Enumerator
MATCH 

Searching for exact matches of the complete string.

CONTAINS 

Searching for any match within the string.

STARTS 

Searching for an match at the beginning of the text.

ENDS 

Searching for an match at the end of the text.

Function Documentation

◆ GenericReinterpretCast()

GenericCastReturnType<TO, FROM, false>::type maxon::GenericReinterpretCast ( FROM &&  value)

◆ GenericUpCast()

GenericCastReturnType<TO, FROM, true>::type maxon::GenericUpCast ( FROM &&  value)

◆ DefaultValue()

T maxon::DefaultValue ( )

Returns a default value of type T.

The default value is defined as follows:

  • If T is a const reference type const U&:
    • If U is a scalar type or Generic, the default value is a const reference to a zero-initialized memory.
    • If there is a specialization of maxon::DefaultValueFunctions for U, the default value is given by the return value of the DefaultValueRef function of that specialization.
    • Otherwise, if U has or inherits a static member function const U& U::DefaultValueRef() or const U& U::DefaultValue(), the default value is the return value of that function.
    • Otherwise, the default value is the return value of PrivateConstRefDefaultValue((U*) nullptr, OVERLOAD_MAX_RANK) (which is found using argument-dependent lookup). There is a function template PrivateConstRefDefaultValue<T>(T*, OverloadRank0) in the maxon namespace which returns a reference to a global default-initialized object of type const T.
  • Otherwise, if T is a non-const reference type U&:
    • If ALLOW_NONCONST is false, a compilation error occurs.
    • If ALLOW_NONCONST is true, a non-const reference to write-protected memory will be returned, so any write access to the returned reference will crash.
  • Otherwise T is not a reference type:
    • If T is a scalar type, the default value is T().
    • If there is a specialization of maxon::DefaultValueFunctions for T, the default value is given by the return value of the DefaultValue function of that specialization.
    • Otherwise, if T has or inherits a static member function T T::DefaultValue() or const T& T::DefaultValue(), the default value is the return value of that function.
    • Otherwise, the default value is T().
Template Parameters
TType of the default value. The cases T, T& and const T& are handled differently.
ALLOW_NONCONSTWith the default value of false, a compilation error occurs for non-const reference types. With true, a non-const reference to write-protected memory will be returned, so any write access to the returned reference will crash.
Note
It is necessary to use the fully-qualified name maxon::DefaultValue if the current scope already contains another DefaultValue declaration, which is the case for interfaces.
Returns
A default value of type T.

◆ MAXON_ENUM_LIST() [1/7]

enum maxon::SUBSYSTEM maxon::MAXON_ENUM_LIST ( SUBSYSTEM  ,
"net.maxon.datatype.enum.subsystem"   
)

◆ MAXON_ENUM_LIST() [2/7]

enum maxon::APPLICATION_URLTYPE maxon::MAXON_ENUM_LIST ( APPLICATION_URLTYPE  ,
"net.maxon.datatype.enum.application_urltype"   
)

◆ MAXON_ENUM_LIST() [3/7]

enum maxon::APPLICATIONMODE maxon::MAXON_ENUM_LIST ( APPLICATIONMODE  ,
"net.maxon.datatype.enum.applicationmode"   
)

◆ MAXON_ENUM_FLAGS() [1/5]

enum maxon::APPLICATIONFEATURE maxon::MAXON_ENUM_FLAGS ( APPLICATIONFEATURE  )

◆ MAXON_DECLARATION() [1/5]

maxon::MAXON_DECLARATION ( Class< Error >  ,
ErrorObjectClass  ,
"net.maxon.class.errorobject"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

Base Error class to inherit from.

◆ MAXON_DECLARATION() [2/5]

maxon::MAXON_DECLARATION ( AggregatedError  ,
AggregatedErrorObject  ,
"net.maxon.object.aggregatederror"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ operator%()

MAXON_ATTRIBUTE_FORCE_INLINE void maxon::operator% ( ErrorPtr rv,
ThreadReferencedError err 
)

◆ Cast() [1/3]

R maxon::Cast ( ErrorPtr ref)

Casts an err object to an object reference of another error interface type. If the cast would be invalid because the err object isn't an instance of the other error interface, a null reference is returned.

Parameters
[in]refError object to cast.
Template Parameters
RReference class to cast to. This must be a reference class of a virtual interface.
Returns
Casted reference.

◆ IsErrorOfType()

Bool maxon::IsErrorOfType ( const Error &  err)

Checks if an error is of type ERRORTYPE. If multiple errors have been returned (AggregatedError) this method will return true if one of them is of type ERRORTYPE.

Template Parameters
ERRORTYPEThe type of error the caller is interested in.
Parameters
[in]errThe returned error to check.
Returns
True if one of the returned errors is of type ERRORTYPE, false otherwise.

◆ MAXON_REGISTRY() [1/9]

maxon::MAXON_REGISTRY ( JobRef  ,
ExecutionJobs  ,
"net.maxon.registry.executionjobs"   
)

◆ ImplementationCreateDefaultValue() [1/4]

DefaultValueDetector<C*, &C::DefaultValue>::type maxon::ImplementationCreateDefaultValue ( OverloadRank3  )

◆ ImplementationCreateDefaultValue() [2/4]

std::enable_if<MAXON_IS_COW_KIND(C::PrivateInterface::Hxx1::ReferenceClass::Handler::KIND), C*>::type maxon::ImplementationCreateDefaultValue ( OverloadRank2  )

◆ ImplementationCreateDefaultValue() [3/4]

SFINAEHelper<C*, typename C::PrivateInterface::Hxx1::ReferenceClass::Handler>::type maxon::ImplementationCreateDefaultValue ( OverloadRank1  )

◆ ImplementationCreateDefaultValue() [4/4]

C* maxon::ImplementationCreateDefaultValue ( OverloadRank0  )

◆ ImplementationDestroyDefaultValue() [1/3]

DefaultValueDetector<C*, &C::DefaultValue>::type maxon::ImplementationDestroyDefaultValue ( const C *  ,
OverloadRank3   
)

◆ ImplementationDestroyDefaultValue() [2/3]

std::enable_if<MAXON_IS_COW_KIND(C::PrivateInterface::Hxx1::ReferenceClass::Handler::KIND), C*>::type maxon::ImplementationDestroyDefaultValue ( const C *  o,
OverloadRank2   
)

◆ ImplementationDestroyDefaultValue() [3/3]

void maxon::ImplementationDestroyDefaultValue ( const C *  ,
OverloadRank0   
)

◆ MAXON_DECLARATION() [3/5]

maxon::MAXON_DECLARATION ( Class< LoggerTypeRef >  ,
LoggerTypeBaseClass  ,
"net.maxon.class.loggertypebase"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_REGISTRY() [2/9]

maxon::MAXON_REGISTRY ( Class< LoggerTypeRef >  ,
LoggerTypes  ,
"net.maxon.core.registry.loggertypes"   
)

◆ MAXON_REGISTRY() [3/9]

maxon::MAXON_REGISTRY ( LoggerRef  ,
Loggers  ,
"net.maxon.core.registry.loggers"   
)

◆ AssertCast() [1/2]

RESULT maxon::AssertCast ( SRC &&  ref)

Casts an object reference to an object reference of another interface type. In a debug configuration, it is checked if the referenced object is really an instance of the interface, while there is no check in a release configuration. No new reference is created, so the reference counter won't change.

Parameters
[in]refObject reference to cast.
Template Parameters
RReference class to cast to. This must be a reference class of a virtual interface.
Returns
Casted reference.

◆ Cast() [2/3]

RESULT maxon::Cast ( SRC &&  ref)

Casts an object reference to an object reference of another interface type. If the cast would be invalid because the referenced object isn't an instance of the interface, a null reference is returned. No new reference is created, so the reference counter won't change.

Parameters
[in]refObject reference to cast.
Template Parameters
RReference class to cast to. This must be a reference class of a virtual interface.
Returns
Casted reference.

◆ Cast() [3/3]

Result<RESULT> maxon::Cast ( Result< SRC > &&  src)

Casts a Result containing an object reference to a Result containing the same object reference, but having another reference class. If the cast would be invalid because the referenced object isn't an instance of the interface of the desired reference class, the reference within the returned Result will be set to nullptr.

Parameters
[in]srcResult to cast.
Template Parameters
RReference class to cast to. This must be a reference class of a virtual interface.
Returns
Casted Result.

◆ AssertCast() [2/2]

Result<RESULT> maxon::AssertCast ( Result< SRC > &&  src)

Casts a Result containing an object reference to a Result containing the same object reference, but having another reference class. In a debug configuration, it is checked if the referenced object is really an instance of the interface, while there is no check in a release configuration. No new reference is created, so the reference counter won't change.

Parameters
[in]srcResult to cast.
Template Parameters
RReference class to cast to. This must be a reference class of a virtual interface.
Returns
Casted Result.

◆ MAXON_REGISTRY() [4/9]

maxon::MAXON_REGISTRY ( Class<>  ,
Classes  ,
"net.maxon.registry.classes"   
)

Each class automatically registers itself at the Classes registry. With

Class<MyType> cls = Classes::Get<MyType>("com.foo.class.bar");

you can look for the class with identifier "com.foo.class.bar". MyType is the expected reference type of instances of the class.

◆ MAXON_REGISTRY() [5/9]

maxon::MAXON_REGISTRY ( ClassTransformer  ,
ClassTransformers  ,
"net.maxon.registry.classtransformers"   
)

◆ MAXON_DECLARATION() [4/5]

maxon::MAXON_DECLARATION ( Class< ObjectRef >  ,
ObjectBaseClass  ,
"net.maxon.class.object"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.kernel")   
)

◆ MAXON_IF_TARGET_DEBUG()

class ComponentRoot maxon::MAXON_IF_TARGET_DEBUG ( :public  EmptyVirtualClass)

ComponentRoot is the base class of all components (see MAXON_COMPONENT). Usually you don't have to take care of this because the Component template automatically sets ComponentRoot as base class. But if you use ComponentWithBase instead, you have to make sure that the base class you use for that template derives from ComponentRoot.

See also
MAXON_COMPONENT
ComponentWithBase

◆ GetFunctionName()

constexpr const Char* maxon::GetFunctionName ( const Char funcName)
constexpr

◆ GetUtf8DefaultDecoder()

const StringDecodingRef& maxon::GetUtf8DefaultDecoder ( )

Returns the default decoder for UTF-8 encodings. Note that you cannot check for equality to detect if an encoding is UTF-8 - as the reference is different in every module or instantiation. Use decoder.HasSameClass(GetUtf8DefaultDecoder()) instead.

Returns
The decoder.

◆ GetUtf8DefaultEncoder()

const StringEncodingRef& maxon::GetUtf8DefaultEncoder ( )

Returns the default encoder for UTF-8 encodings. Note that you cannot check for equality to detect if an encoding is UTF-8 - as the reference is different in every module or instantiation. Use encoder.HasSameClass(GetUtf8DefaultEncoder()) instead.

Returns
The encoder.

◆ MAXON_ENUM_FLAGS() [2/5]

enum maxon::STRINGCONVERSION maxon::MAXON_ENUM_FLAGS ( STRINGCONVERSION  )

◆ MAXON_ENUM_LIST() [4/7]

enum maxon::STRINGCOMPARISON maxon::MAXON_ENUM_LIST ( STRINGCOMPARISON  )

◆ operator""_s() [1/2]

MAXON_ATTRIBUTE_FORCE_INLINE const String& maxon::operator""_s ( const char *  str,
std::size_t  cnt 
)

Returns a String object of the characters passed in quotation marks. If the same characters are used in another place the String will still only be created once in memory. In the following example the second loop is far more efficient because the String is created only once whereas in the first loop the characters are converted to unicode and a new String object is created (and deleted) on each iteration.

for (...)
{
if (s.FindIndex(String("A is created each time.")) == 0) ...
}
for (...)
{
if (s.FindIndex("B is created only once."_s) == 42) ...
}
PyObject PyObject const char const char char ** s
Definition: bytesobject.h:60

As MSVC does not properly resolve "\u" sequences for char* you need to use the wchar_t version below for any characters >=0x80.

◆ operator""_s() [2/2]

MAXON_ATTRIBUTE_FORCE_INLINE const String& maxon::operator""_s ( const wchar_t *  str,
std::size_t  cnt 
)

Returns a String object of the characters passed in quotation marks. This version can be used for unicode characters, e.g. L"t\u00e8st"_s.

◆ operator""_cs()

MAXON_ATTRIBUTE_FORCE_INLINE const CString& maxon::operator""_cs ( const char *  str,
std::size_t  cnt 
)

Creates a (constant) C-string.

◆ DescribeIO() [1/2]

Result<void> maxon::DescribeIO ( const CStringInterface s,
const DataSerializeInterface dsi 
)

◆ DescribeIO() [2/2]

Result<void> maxon::DescribeIO ( const StringInterface s,
const DataSerializeInterface dsi 
)

◆ operator+() [1/14]

String maxon::operator+ ( const String a,
const String b 
)

Concatenates two strings, please don't use a = a + b since this is several times slower than a += b.

◆ operator+() [2/14]

String&& maxon::operator+ ( String &&  a,
const String b 
)

◆ operator+() [3/14]

String&& maxon::operator+ ( String &&  a,
String &&  b 
)

◆ operator+() [4/14]

String&& maxon::operator+ ( const String a,
String &&  b 
)

◆ operator+() [5/14]

CString maxon::operator+ ( const CString a,
const CString b 
)

Concatenates two strings, please don't use a = a + b since this is several times slower than a += b.

◆ operator+() [6/14]

CString&& maxon::operator+ ( CString &&  a,
const CString b 
)

◆ operator+() [7/14]

CString&& maxon::operator+ ( CString &&  a,
CString &&  b 
)

◆ operator+() [8/14]

CString&& maxon::operator+ ( const CString a,
CString &&  b 
)

◆ operator+=()

String& maxon::operator+= ( String s,
const CString b 
)

◆ operator+() [9/14]

String maxon::operator+ ( const String a,
const CString b 
)

◆ operator+() [10/14]

String&& maxon::operator+ ( String &&  a,
const CString b 
)

◆ operator+() [11/14]

String maxon::operator+ ( const String a,
const Char b 
)

◆ operator+() [12/14]

String&& maxon::operator+ ( String &&  a,
const Char b 
)

◆ operator+() [13/14]

CString maxon::operator+ ( const CString a,
const Char b 
)

◆ operator+() [14/14]

CString&& maxon::operator+ ( CString &&  a,
const Char b 
)

◆ ToString() [1/26]

String maxon::ToString ( const String str,
const FormatStatement formatStatement,
Bool  = false 
)

◆ ToString() [2/26]

String maxon::ToString ( const CString str,
const FormatStatement formatStatement,
Bool  = false 
)

◆ ToStringHelper() [1/2]

decltype(std::declval<T>().ToString()) maxon::ToStringHelper ( const T *  object,
const FormatStatement formatStatement,
Int  
)

◆ ToStringHelper() [2/2]

String maxon::ToStringHelper ( const T *  object,
const FormatStatement formatStatement,
const Int checkDataType 
)

◆ ToString() [3/26]

std::enable_if<!STD_IS_REPLACEMENT(enum, T), String>::type maxon::ToString ( const T &  object,
const FormatStatement formatStatement,
Bool  checkDataType = true 
)

◆ ToString() [4/26]

std::enable_if<!STD_IS_REPLACEMENT(function, T), String>::type maxon::ToString ( const T *  object,
const FormatStatement formatStatement 
)

◆ ToString() [5/26]

const String& maxon::ToString ( Bool  val,
const FormatStatement formatStatement,
Bool  = false 
)

◆ ToString() [6/26]

String maxon::ToString ( Char  val,
const FormatStatement formatStatement,
Bool  checkDataType = false 
)

Converts a variable into a readable string.

Parameters
[in]valThe value that will be converted.
[in]formatStatementNullptr or additional formatting instruction. See also Formatting Integer values.
[in]checkDataTypeMust be set to false, only for internal use.
Returns
The converted result.

◆ ToString() [7/26]

String maxon::ToString ( UChar  val,
const FormatStatement formatStatement,
Bool  checkDataType = false 
)

Converts a variable into a readable string.

Parameters
[in]valThe value that will be converted.
[in]formatStatementNullptr or additional formatting instruction. See also Formatting Integer values.
[in]checkDataTypeMust be set to false, only for internal use.
Returns
The converted result.

◆ ToString() [8/26]

String maxon::ToString ( Int16  val,
const FormatStatement formatStatement,
Bool  checkDataType = false 
)

Converts a variable into a readable string.

Parameters
[in]valThe value that will be converted.
[in]formatStatementNullptr or additional formatting instruction. See also Formatting Integer values.
[in]checkDataTypeMust be set to false, only for internal use.
Returns
The converted result.

◆ ToString() [9/26]

String maxon::ToString ( Int32  val,
const FormatStatement formatStatement,
Bool  checkDataType = false 
)

Converts a variable into a readable string.

Parameters
[in]valThe value that will be converted.
[in]formatStatementNullptr or additional formatting instruction. See also Formatting Integer values.
[in]checkDataTypeMust be set to false, only for internal use.
Returns
The converted result.

◆ ToString() [10/26]

String maxon::ToString ( Int64  val,
const FormatStatement formatStatement,
Bool  checkDataType = false 
)

Converts a variable into a readable string.

Parameters
[in]valThe value that will be converted.
[in]formatStatementNullptr or additional formatting instruction. See also Formatting Integer values.
[in]checkDataTypeMust be set to false, only for internal use.
Returns
The converted result.

◆ ToString() [11/26]

String maxon::ToString ( UInt16  val,
const FormatStatement formatStatement,
Bool  checkDataType = false 
)

Converts a variable into a readable string.

Parameters
[in]valThe value that will be converted.
[in]formatStatementNullptr or additional formatting instruction. See also Formatting Integer values.
[in]checkDataTypeMust be set to false, only for internal use.
Returns
The converted result.

◆ ToString() [12/26]

String maxon::ToString ( UInt32  val,
const FormatStatement formatStatement,
Bool  checkDataType = false 
)

Converts a variable into a readable string.

Parameters
[in]valThe value that will be converted.
[in]formatStatementNullptr or additional formatting instruction. See also Formatting Integer values.
[in]checkDataTypeMust be set to false, only for internal use.
Returns
The converted result.

◆ ToString() [13/26]

String maxon::ToString ( UInt64  val,
const FormatStatement formatStatement,
Bool  checkDataType = false 
)

Converts a variable into a readable string.

Parameters
[in]valThe value that will be converted.
[in]formatStatementNullptr or additional formatting instruction. See also Formatting Integer values.
[in]checkDataTypeMust be set to false, only for internal use.
Returns
The converted result.

◆ ToString() [14/26]

String maxon::ToString ( Float64  val,
const FormatStatement formatStatement,
Bool  checkDataType = false 
)

Converts a variable into a readable string.

Parameters
[in]valThe value that will be converted.
[in]formatStatementNullptr or additional formatting instruction. See also Formatting Floating point values.
[in]checkDataTypeMust be set to false, only for internal use.
Returns
The converted result.

◆ ToString() [15/26]

String maxon::ToString ( Float32  val,
const FormatStatement formatStatement,
Bool  checkDataType = false 
)

Converts a variable into a readable string.

Parameters
[in]valThe value that will be converted.
[in]formatStatementNullptr or additional formatting instruction. See also Formatting Floating point values.
[in]checkDataTypeMust be set to false, only for internal use.
Returns
The converted result.

◆ ToString() [16/26]

String maxon::ToString ( Utf16Char  val,
const FormatStatement formatStatement,
Bool  checkDataType = false 
)

Converts a variable into a readable string.

Parameters
[in]valThe value that will be converted.
[in]formatStatementNullptr or additional formatting instruction. See also Formatting Integer values.
[in]checkDataTypeMust be set to false, only for internal use.
Returns
The converted result.

◆ ToString() [17/26]

String maxon::ToString ( Utf32Char  val,
const FormatStatement formatStatement,
Bool  checkDataType = false 
)

Converts a variable into a readable string.

Parameters
[in]valThe value that will be converted.
[in]formatStatementNullptr or additional formatting instruction. See also Formatting Integer values.
[in]checkDataTypeMust be set to false, only for internal use.
Returns
The converted result.

◆ ToString() [18/26]

String maxon::ToString ( Char val,
const FormatStatement formatStatement,
Bool  checkDataType = false 
)

Converts a C-string into a readable string.

Parameters
[in]valThe value that will be converted.
[in]formatStatementNullptr or additional formatting instruction. No formatting instructions are currently supported.
[in]checkDataTypeMust be set to false, only for internal use.
Returns
The converted result.

◆ ToString() [19/26]

String maxon::ToString ( const Char val,
const FormatStatement formatStatement,
Bool  checkDataType = false 
)

Converts a C-string into a readable string.

Parameters
[in]valThe value that will be converted.
[in]formatStatementNullptr or additional formatting instruction. No formatting instructions are currently supported.
[in]checkDataTypeMust be set to false, only for internal use.
Returns
The converted result.

◆ ToString() [20/26]

String maxon::ToString ( const void *  val,
const FormatStatement formatStatement,
Bool  checkDataType = false 
)

Converts a pointer into a readable string.

Parameters
[in]valThe value that will be converted.
[in]formatStatementNullptr or additional formatting instruction. See also Formatting Pointer values.
[in]checkDataTypeMust be set to false, only for internal use.
Returns
The converted result.

◆ ToString() [21/26]

String maxon::ToString ( void *  val,
const FormatStatement formatStatement,
Bool  checkDataType = false 
)

Converts a pointer into a readable string.

Parameters
[in]valThe value that will be converted.
[in]formatStatementNullptr or additional formatting instruction. See also Formatting Pointer values.
[in]checkDataTypeMust be set to false, only for internal use.
Returns
The converted result.

◆ ToString() [22/26]

String maxon::ToString ( const Generic *  val,
const FormatStatement formatStatement,
Bool  checkDataType = false 
)

Converts a pointer into a readable string.

Parameters
[in]valThe value that will be converted.
[in]formatStatementNullptr or additional formatting instruction. See also Formatting Pointer values.
[in]checkDataTypeMust be set to false, only for internal use.
Returns
The converted result.

◆ ToString() [23/26]

String maxon::ToString ( Generic *  val,
const FormatStatement formatStatement,
Bool  checkDataType = false 
)

Converts a pointer into a readable string.

Parameters
[in]valThe value that will be converted.
[in]formatStatementNullptr or additional formatting instruction. See also Formatting Pointer values.
[in]checkDataTypeMust be set to false, only for internal use.
Returns
The converted result.

◆ ExtractString() [1/3]

String maxon::ExtractString ( StringProxy proxy)

◆ ExtractString() [2/3]

const String& maxon::ExtractString ( const String str)

◆ ExtractString() [3/3]

const Char* maxon::ExtractString ( const Char str)

◆ ScanParameter() [1/11]

void maxon::ScanParameter ( Float64 result,
const Block< const Utf32Char > &  str,
Int processed,
const String formatStatement,
Bool error 
)

◆ ScanParameter() [2/11]

void maxon::ScanParameter ( Float32 result,
const Block< const Utf32Char > &  str,
Int processed,
const String formatStatement,
Bool error 
)

◆ ScanParameter() [3/11]

void maxon::ScanParameter ( Int64 result,
const Block< const Utf32Char > &  str,
Int processed,
const String formatStatement,
Bool error 
)

◆ ScanParameter() [4/11]

void maxon::ScanParameter ( Int32 result,
const Block< const Utf32Char > &  str,
Int processed,
const String formatStatement,
Bool error 
)

◆ ScanParameter() [5/11]

void maxon::ScanParameter ( Int16 result,
const Block< const Utf32Char > &  str,
Int processed,
const String formatStatement,
Bool error 
)

◆ ScanParameter() [6/11]

void maxon::ScanParameter ( Char result,
const Block< const Utf32Char > &  str,
Int processed,
const String formatStatement,
Bool error 
)

◆ ScanParameter() [7/11]

void maxon::ScanParameter ( UInt64 result,
const Block< const Utf32Char > &  str,
Int processed,
const String formatStatement,
Bool error 
)

◆ ScanParameter() [8/11]

void maxon::ScanParameter ( UInt32 result,
const Block< const Utf32Char > &  str,
Int processed,
const String formatStatement,
Bool error 
)

◆ ScanParameter() [9/11]

void maxon::ScanParameter ( UInt16 result,
const Block< const Utf32Char > &  str,
Int processed,
const String formatStatement,
Bool error 
)

◆ ScanParameter() [10/11]

void maxon::ScanParameter ( UChar result,
const Block< const Utf32Char > &  str,
Int processed,
const String formatStatement,
Bool error 
)

◆ ScanParameter() [11/11]

void maxon::ScanParameter ( T *&  result,
const Block< const Utf32Char > &  str,
Int processed,
const String formatStatement,
Bool error 
)

◆ FromStrHlp()

void maxon::FromStrHlp ( T *  result,
const Block< const Utf32Char > &  str,
Int processed,
const String formatStatement,
Bool error 
)

◆ GetFromStrHlp()

FROMSTR maxon::GetFromStrHlp ( )

◆ ScanStringTemplate()

Bool maxon::ScanStringTemplate ( const String str,
const String format,
Int parsedCharacters,
Int  argsCnt,
void **  args,
FROMSTR argFuncs 
)

◆ ExtractCString()

CString maxon::ExtractCString ( StringProxy proxy)

◆ ForwardString()

MAXON_ATTRIBUTE_FORCE_INLINE T maxon::ForwardString ( T &&  str)

◆ ScanString() [1/2]

Bool maxon::ScanString ( STR  inputStr,
STR2  formatStr,
ARGS &...  args 
)

Scans a string 'inputStr' for parameters and stores them according to parameter format 'formatStr' into the locations given by the additional arguments. The basic syntax is the same as for DiagnosticOutput Output Syntax.
However only {x} and {c} are supported as formatting statements. It is not necessary to set {x} if you pass a pointer as parameter, only for regular Int/UInt's.
Here an example:

Float64 val1;
Int64 val2, val3;
void* val4;
Bool success = ScanString("@_7.345maef5.8=ab__", "@@_@m@{x}.@{c}=@", val1, val2, val3, val4);
maxon::Int64 Int64
Definition: ge_sys_math.h:58
Bool ScanString(STR inputStr, STR2 formatStr, ARGS &... args)
Definition: string.h:2214

The operation succeeds with 7.345 for val1, 0xaef5 for val2, 56 for val3 and 0xab for val4.

Parameters
[in]inputStrThe input string containing the data that will be extracted.
[in]formatStrThe string containing the parameter format.
[out]argsValues that will be extracted.
Returns
True if successful. Errors can happen if the parameter count does not match the format string, if the input string does not match the format string or the extracted data exceeds the limits of a datatype.

◆ ScanString() [2/2]

Bool maxon::ScanString ( STR  inputStr,
Int parsedInputCharacters,
STR2  formatStr,
ARGS &...  args 
)

Scans a string 'inputStr' for parameters and stores them according to parameter format 'formatStr' into the locations given by the additional arguments. The basic syntax is the same as for DiagnosticOutput Output Syntax.
However only {x} and {c} are supported as formatting statements. It is not necessary to set {x} if you pass a pointer as parameter, only for regular Int/UInt's.
Here an example:

Float64 val1;
Int64 val2, val3;
void* val4;
Int parsedCharacters;
Bool success = ScanString("@_7.345maef5.8=ab__", parsedCharacters, "@@_@m@{x}.@{c}=@", val1, val2, val3, val4);

The operation succeeds with 7.345 for val1, 0xaef5 for val2, 56 for val3 and 0xab for val4.

Parameters
[in]inputStrThe input string containing the data that will be extracted.
[out]parsedInputCharactersThe number of characters that were parsed to match formatStr.
[in]formatStrThe string containing the parameter format.
[out]argsValues that will be extracted.
Returns
True if successful. Errors can happen if the parameter count does not match the format string, if the input string does not match the format string or the extracted data exceeds the limits of a datatype.

◆ _LoadResourceString()

String maxon::_LoadResourceString ( const Id scope,
const InternedId keyValue 
)

◆ LoadResourceString()

String maxon::LoadResourceString ( const STRID &  identifier,
const ARGUMENTS &...  args 
)

Loads the string 'identifier' from the resource and format with the passed parameters.

◆ StrLen() [1/3]

static Int maxon::StrLen ( const SysChar chr)
static

Calculates the length of a null-terminated string of type SysChar.

◆ StrLen() [2/3]

static Int maxon::StrLen ( const Utf32Char chr)
static

Calculates the length of a null-terminated string of type Utf32Char.

◆ StrLen() [3/3]

static Int maxon::StrLen ( const Utf16Char chr)
static

Calculates the length of a null-terminated string of type Utf16Char.

◆ IsSpace()

MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::IsSpace ( TYPE  chr)

Checks if the passed character is a space.

◆ IsTab()

MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::IsTab ( TYPE  chr)

Checks if the passed character is a tab.

◆ IsSpaceOrTab()

MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::IsSpaceOrTab ( TYPE  chr)

Checks if the passed character is a space or tab.

◆ IsLineEnd()

MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::IsLineEnd ( TYPE  chr)

Checks if the passed character is a line end.

◆ IsNumeric()

MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::IsNumeric ( TYPE  chr)

Checks if the passed character is a digit.

◆ IsAlphabetic()

MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::IsAlphabetic ( TYPE  chr)

Checks if the passed character is a latin character ('A' to 'Z' and 'a' to 'z').

◆ IsAlphanumeric()

MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::IsAlphanumeric ( TYPE  chr)

Checks if the passed character is alphabetic or numeric.

◆ IsHexadecimal()

MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::IsHexadecimal ( TYPE  chr)

Checks if the passed character is alphabetic or numeric.

◆ GetHexadecimalValue()

MAXON_ATTRIBUTE_FORCE_INLINE Int maxon::GetHexadecimalValue ( TYPE  chr)

Calculates the value from a hexadecimal character. For a valid return value IsHexadecimal must fulfilled.

◆ JoinElements()

static MAXON_WARN_UNUSED REFTYPE maxon::JoinElements ( ITERATABLETYPE &&  iterable,
const REFTYPE &  delimiter,
const FormatStatement formatStr = nullptr 
)
static

Concatenates multiple elements to create a string. Here an example:

BaseArray<String> arr;
arr.Append("a"_s) iferr_return;
arr.Append("b"_s) iferr_return;
String res = JoinElements(arr, ", ");
static MAXON_WARN_UNUSED REFTYPE JoinElements(ITERATABLETYPE &&iterable, const REFTYPE &delimiter, const FormatStatement *formatStr=nullptr)
Definition: string.h:2390
#define iferr_return
Definition: resultbase.h:1524

The result will be "a, b"

Parameters
[in]iterableThe elements to concatenate, can be any iterable data type. The elements must have a valid implementation of ToString.
[in]delimiterThe delimiter that will be placed inbetween two elements. Must be a String or CString. It can be empty.
[in]formatStrThe string containing the parameter format.
Returns
The return string.

◆ AppendStringWithSeparator()

void maxon::AppendStringWithSeparator ( STRINGTYPE &  base,
const STRINGTYPE &  add,
const STRINGTYPE &  delimiter 
)

AppendStringWithSeparator description concats strings with a separator if the target string is already populated.

Parameters
[in,out]baseDestination string to append to.
[in]addString to add.
[in]delimiterString to add if 'base' and 'add' is populated.

◆ AddStringWithSeparator()

STRINGTYPE maxon::AddStringWithSeparator ( const STRINGTYPE &  base,
const STRINGTYPE &  add,
const STRINGTYPE &  delimiter 
)

AddStringWithSeparator description concats strings with a separator if the target string is already populated.

Parameters
[in]baseString to append to.
[in]addString to add.
[in]delimiterString to add if 'base' and 'add' is populated.
Returns
Concatenated String.

◆ MAXON_MEMBERFUNCTION_DETECTOR()

maxon::MAXON_MEMBERFUNCTION_DETECTOR ( GetReferenceCounter  )

◆ MAXON_ENUM_LIST() [5/7]

enum maxon::NORMALIZATION maxon::MAXON_ENUM_LIST ( NORMALIZATION  )

◆ MAXON_ENUM_LIST() [6/7]

enum maxon::CHARACTERTYPE UChar maxon::MAXON_ENUM_LIST ( CHARACTERTYPE  )

◆ IsUnicodeLetter()

MAXON_ATTRIBUTE_FORCE_INLINE Bool maxon::IsUnicodeLetter ( TYPE  chr)

Checks if the passed character is a unicode letter.

◆ MAXON_ENUM_FLAGS() [3/5]

enum maxon::TARGETAUDIENCE maxon::MAXON_ENUM_FLAGS ( TARGETAUDIENCE  ,
"net.maxon.datatype.enum.targetaudience"  ,
EARLY   
)

◆ MAXON_ENUM_FLAGS() [4/5]

enum maxon::WRITEMETA maxon::MAXON_ENUM_FLAGS ( WRITEMETA  ,
"net.maxon.datatype.enum.writemeta"  ,
EARLY   
)

◆ MAXON_ENUM_FLAGS() [5/5]

enum maxon::OUTPUT maxon::MAXON_ENUM_FLAGS ( OUTPUT  ,
"net.maxon.datatype.enum.output"  ,
EARLY   
)

◆ _ConsoleOutput() [1/3]

void maxon::_ConsoleOutput ( OUTPUT  flags,
const Char str,
Int  line,
const Char file 
)

◆ _ConsoleOutput() [2/3]

void maxon::_ConsoleOutput ( OUTPUT  flags,
const String str,
Int  line,
const Char file 
)

◆ _ConsoleOutput() [3/3]

void maxon::_ConsoleOutput ( OUTPUT  flags,
StringProxy str,
Int  line,
const Char file 
)

◆ _ApplicationOutput() [1/3]

void maxon::_ApplicationOutput ( maxon::TARGETAUDIENCE  t,
maxon::WRITEMETA  lvl,
const maxon::String str,
Int  line,
const Char file 
)

◆ _ApplicationOutput() [2/3]

void maxon::_ApplicationOutput ( maxon::TARGETAUDIENCE  t,
maxon::WRITEMETA  lvl,
const Char str,
Int  line,
const Char file 
)

◆ _ApplicationOutput() [3/3]

void maxon::_ApplicationOutput ( maxon::TARGETAUDIENCE  t,
maxon::WRITEMETA  lvl,
const maxon::StringProxy proxy,
Int  line,
const Char file 
)

◆ ToStrHlp()

void maxon::ToStrHlp ( String result,
const T *  x,
const FormatStatement formatStatement 
)

◆ GetToStrHlp()

TOSTR maxon::GetToStrHlp ( )

◆ Format() [1/2]

StringProxy* maxon::Format ( const String formatString,
Int  argsCnt,
const void **  args,
const TOSTR argFuncs 
)

◆ Format() [2/2]

StringProxy* maxon::Format ( const Char formatString,
Int  argsCnt,
const void **  args,
const TOSTR argFuncs 
)

◆ FormatTemplateX() [1/2]

StringProxy* maxon::FormatTemplateX ( FORMATSTR  formatString,
const ARGS &...  args 
)

◆ FormatTemplateX() [2/2]

FORMATSTR maxon::FormatTemplateX ( FORMATSTR  formatString)

◆ GetArgCnt()

constexpr Int maxon::GetArgCnt ( const Char *const  formatStr)
constexpr

cosntexpr which returns the number of '@' parameters in a Format string.

◆ StrStrConstExpr()

constexpr bool maxon::StrStrConstExpr ( const char *  str,
const char *  search 
)
constexpr

StrStrConstExpr implements the strstr() function as constexpr for compilers that do not support strstr as constexpr yet (e.g. clang 11.0.1)

Parameters
[in]strString to search in.
[in]searchString to search.
Returns
True if a match was found.

◆ PrivateGetClassName()

static MAXON_ATTRIBUTE_FORCE_INLINE const Char* maxon::PrivateGetClassName ( )
static

◆ MAXON_ENUM_LIST() [7/7]

enum maxon::REGPARSEMODE maxon::MAXON_ENUM_LIST ( REGPARSEMODE  )

◆ MAXON_REGISTRY() [6/9]

maxon::MAXON_REGISTRY ( Class< UnitTestRef >  ,
UnitTestClasses  ,
"net.maxon.registry.unittestclasses"   
)

◆ MAXON_REGISTRY() [7/9]

maxon::MAXON_REGISTRY ( Class< UnitTestRef >  ,
UnitTestWithC4DPluginClasses  ,
"net.maxon.registry.unittestwithc4dpluginclasses"   
)

◆ MAXON_REGISTRY() [8/9]

maxon::MAXON_REGISTRY ( Class< UnitTestRef >  ,
SpeedTestClasses  ,
"net.maxon.registry.speedtestclasses"   
)

◆ MAXON_REGISTRY() [9/9]

maxon::MAXON_REGISTRY ( Class< UnitTestRef >  ,
LongRunTestClasses  ,
"net.maxon.registry.longruntestclasses"   
)

◆ MAXON_DECLARATION() [5/5]

maxon::MAXON_DECLARATION ( Class< UnitTestRef >  ,
UnitTestBaseClass  ,
"net.maxon.class.unittestbase"  ,
MAXON_IMPLEMENTATION_MODULE("net.maxon.misc")   
)

◆ PrivateGetRefMember() [1/2]

ErrorPtr & PrivateGetRefMember ( )

◆ PrivateGetRefMember() [2/2]

const ErrorPtr & PrivateGetRefMember ( ) const

◆ ToString() [24/26]

String ToString ( const FormatStatement formatStatement = nullptr) const

Returns a readable string of the content.

Parameters
[in]formatStatementNullptr or additional formatting instruction. Currently no additional formatting instructions are supported.
Returns
The converted result.

◆ ToString() [25/26]

String ToString ( const FormatStatement formatStatement = nullptr) const

Returns a string representation of this collection as a list of all contained elements.

Parameters
[in]formatStatementNullptr or additional formatting instruction.
Returns
List of all elements as a String.

◆ ToString() [26/26]

String ToString ( const FormatStatement formatStatement = nullptr)

Iterates over this foreach iterator and returns a string with a list of all visited iteration values.

Parameters
[in]formatStatementNullptr or additional formatting instruction.
Returns
List of all iteration values as a String.
Warning
This is a non-const function which uses this iterator for the iteration. I.e., after function completion this iterator will point to the end.

◆ ConvertString()

Result<String> ConvertString ( const SCR &  converter) const

◆ GetUniqueHashCode() [1/2]

UniqueHash GetUniqueHashCode ( const Byte ptr,
Int  count 
)
static

Returns a 128-bit hash value of the given block of bytes.

Parameters
[in]ptrPointer to the first byte.
[in]countNumber of bytes.
Returns
A hash value for the block of bytes.

◆ GetUniqueHashCode() [2/2]

UniqueHash GetUniqueHashCode ( const Block< const Byte > &  bytes)
static

Returns a 128-bit hash value of the given block of bytes.

Parameters
[in]bytesByte block.
Returns
A hash value for the block of bytes.

◆ UniqueHasher()

◆ Combine() [1/3]

void Combine ( const Byte ptr,
Int  count 
)

Mixes the contents of the given byte block into the hasher state.

Parameters
[in]ptrPointer to the first byte.
[in]countNumber of bytes.

◆ Combine() [2/3]

void Combine ( const Block< const Byte > &  bytes)

Mixes the contents of the given byte block into the hasher state.

Parameters
[in]bytesA hash value.

◆ Combine() [3/3]

void Combine ( const UniqueHash value)

Mixes the given UniqueHash into the hasher state.

Parameters
[in]valueA hash value.

◆ Finalize()

UniqueHash Finalize ( ) const

Computes a UniqueHash from the current state of this hasher. The hasher can still be used to hash further bytes afterwards, and Finalize() can be called multiple times.

Returns
A hash value for the current state.

◆ operator UniqueHash()

operator UniqueHash ( ) const

Variable Documentation

◆ MAXON_ENUM_LIST

struct maxon::SDFFilterSettings MAXON_ENUM_LIST

◆ alignment

Int alignment

◆ MAXON_ENUM_FLAGS

struct maxon::FieldSampleData MAXON_ENUM_FLAGS

◆ g_PrivateDependencyOnModule

const maxon::EntityUse g_PrivateDependencyOnModule

◆ STACKTRACE_SKIP

const Int STACKTRACE_SKIP
static

◆ STRING_MAXIMUM_PRECISION

const Int STRING_MAXIMUM_PRECISION
static

Constant for FloatToString. If passed to FloatToString the returned string will have as many digits as it is necessary to store the exact value (that later can be converted back to the exactly same floating point value).

◆ STRING_DYNAMIC_DIGITS

const Int STRING_DYNAMIC_DIGITS
static

Constant for FloatToString. If passed to FloatToString the digits in front of the comma will be dynamically adjusted.

◆ g_systemBehavior

System::SPECIALBEHAVIOR g_systemBehavior
extern

Defines mostly legacy behaviour.

◆ g_isDebuggerPresent

maxon::Bool g_isDebuggerPresent
extern

determines, whether a debugging environment is present. Note that this value will be false if the debugger was attached to a process

◆ g_enableDebugBreak

maxon::Bool g_enableDebugBreak
extern

determines, whether debug breaks will be executed. Note that g_isDebuggerPresent needs to be true, too in order to have an effect.

◆ REGPARSE_CONCAT

const Int REGPARSE_CONCAT
static

◆ REGPARSE_ANYCHAR

const Int REGPARSE_ANYCHAR
static

◆ REGPARSE_ANYDIGIT

const Int REGPARSE_ANYDIGIT
static

◆ REGPARSE_OPERATOR_OR

const Int REGPARSE_OPERATOR_OR
static

◆ REGPARSE_OPERATOR_STAR

const Int REGPARSE_OPERATOR_STAR
static

◆ REGPARSE_OPERATOR_PARENTHESIS_LEFT

const Int REGPARSE_OPERATOR_PARENTHESIS_LEFT
static

◆ REGPARSE_OPERATOR_PARENTHESIS_RIGHT

const Int REGPARSE_OPERATOR_PARENTHESIS_RIGHT
static

◆ value [1/2]

const T value
static

◆ value [2/2]

const InterfaceReference *const value
static