cohtml

Utility macros for enabling bitwise flag operations on enum class types. These macros define the standard bitwise operators (|, &, ^, ~ and their assignment variants) so enum values can be combined and tested as flags. More…

Namespaces #

Classes #

Types #

Functions #

Detailed Description #

Utility macros for enabling bitwise flag operations on enum class types. These macros define the standard bitwise operators (|, &, ^, ~ and their assignment variants) so enum values can be combined and tested as flags.

When binding a std::variant property, changing the active alternative at runtime to a different complex type after the property has been bound to JavaScript is unsupported and results in undefined behavior. (e.g. model.data bound as MyUserType, then reassigned). The underlying JavaScript object is not recreated when the active type changes.

Contains almost all Coherent namespaces, classes and functions.

Types Documentation #

enum CompatibilityFlags #

Compatibility flags that can be used to enable legacy behaviors. Split into 2 groups, depending on what API the flag should be passed to:

• VCF - View compatibility flags, should be passed via the ViewSettings.
• LCF - Library compatibility flags, should be passed via the LibraryParams. All flags can be combined. View and Library compatibility flags are independent: flags intended for one are silently ignored by the other.

enum WorkType #

enum WorkExecutionMode #

The enumeration tells the Library how much work to execute in the invocation Please refer to the asynchronous work documentation for details.

enum GamepadHand #

Enumeration that represent binding of a gamepad to a specific hand. Used for motion tracking controllers which are used in pairs, one controller per hand.

enum HTMLTag #

enum RenderingTasksAvailableType #

enum LayoutAlgorithm #

enum InterceptRequestStatus #

enum InternalCaches #

enum CaptureMode #

When serializing rendering commands, part of the image data in a document is saved as well. With these capture modes, you can force the capturer to obfuscate the pixel data and with that no images will be leaked through the serialized capture.

enum RegisterModelStatus #

Status of a call to CreateModel() and RegisterModel()

enum UpdateModelStatus #

Status of a call to UpdateWholeModel(), UnregisterModel()

enum SynchronizeModelsStatus #

Status of a call to SynchronizeModels()

enum ValueType #

The primitive types coming from JS.

enum ElementType #

Represents the underlying data category of a property, array element, map value, or pair member exposed to the scripting system.

Primitive types (ET_Boolean through ET_Double) represent concrete C++ values. For all primitive types except ET_String, the SDK may cast pointers returned by *Info callbacks directly to the corresponding native type.

typedef TimePoint #

typedef double cohtml::TimePoint;

typedef TaskFamilyId #

typedef int cohtml::TaskFamilyId;

typedef OnWorkAvailableFunc #

typedef void(* cohtml::OnWorkAvailableFunc) (void *userData, WorkType type, TaskFamilyId family);

Called when a new task is available and should be executed later on.

typedef OnUserImageDroppedFunc #

typedef void(* cohtml::OnUserImageDroppedFunc) (void *userData, void *texturePtr);

typedef BoundEventHandle #

typedef void * cohtml::BoundEventHandle;

typedef OnRenderingTasksAvailableFunc #

typedef void(* cohtml::OnRenderingTasksAvailableFunc) (void *userData, unsigned viewId, unsigned frameId, RenderingTasksAvailableType type);

typedef OnMonotonicallyIncreasingTimeRequestFunc #

typedef double(* cohtml::OnMonotonicallyIncreasingTimeRequestFunc) (void *userdata, unsigned viewId);

typedef FrameCaptureCallback #

typedef void(* cohtml::FrameCaptureCallback) (void *userData, FrameCapture *capture);

Function signature of callback used in View::BeginCaptureDebugFrame and View::CaptureSingleDebugFrame.

Parameters:

• userData The user data passed to View::BeginCaptureDebugFrame and View::CaptureSingleDebugFrame calls
• capture Object containing pointer to the data and the size. Must call Release() when finished using it.

typedef Reader #

typedef void(* cohtml::Reader)(Binder *, void *, size_t);

typedef ArrayLengthGetter #

typedef size_t(* cohtml::ArrayLengthGetter) (void *);

typedef ArrayElementGetter #

typedef void*(* cohtml::ArrayElementGetter) (void *, size_t);

typedef MapElementGetter #

typedef void*(* cohtml::MapElementGetter) (void *userData, const char *name);

typedef LengthGetter #

typedef size_t(* cohtml::LengthGetter) (void *userData);

typedef ElementGetter #

typedef void*(* cohtml::ElementGetter) (void *userData, size_t index);

typedef ArrayElementBinder #

typedef void(* cohtml::ArrayElementBinder) (Binder *, void *, size_t);

typedef TrueType #

typedef BoolConstant<true> cohtml::TrueType;

typedef FalseType #

typedef BoolConstant<false> cohtml::FalseType;

using RemoveConstRef_t #

template <typename T >
using cohtml::RemoveConstRef_t = typedef typename RemoveConstRef<T>::Type;

using DecayedType #

template <typename T >
using cohtml::DecayedType = typedef typename UnwrapPointerType< typename RemoveConstRef<T>::Type, PointerTrait<T>::Value >::Type;

typedef NativeReader #

typedef void*(* cohtml::NativeReader) (void *, size_t);

typedef VectorLengthFunc #

typedef size_t(* cohtml::VectorLengthFunc) (void *);

Functions Documentation #

function MakeHandler #

template <typename Functor >
IEventHandler * MakeHandler(
    Functor functor
)

Create event handler from generic C++ functor.

Parameters:

• functor generic C++ functor, i.e. pointer to static function or object with operator()

Return: IEventHandler that wraps the functor

function MakeHandler #

template <typename Method >
IEventHandler * MakeHandler(
    void * object,
    Method method
)

Create event handler from C++ method.

Parameters:

• object pointer to the instance with which the method will be invoked
• method the C++ method to be invoked

Return: IEventHandler that wraps the method

Warning: the object pointer is stored until cohtml::ViewListener::OnBindingsReleased is called. Therefore the pointer must remain valid until then.

function COHTML_DEFINE_ENUM_FLAG_OPERATORS #

COHTML_DEFINE_ENUM_FLAG_OPERATORS(
    CompatibilityFlags 
)

function AdaptRenderingAllocatorAndLoggerFromCohtml #

void AdaptRenderingAllocatorAndLoggerFromCohtml(
    IAllocator * allocator,
    Logging::ILogHandler * logger,
    renoir::IAllocator ** outRenderingAllocator,
    renoir::Logging::ILogHandler ** outRenderingLogger
)

Function to adapt Cohtml based IAllocator and ILogHandler to the Rendering library variants It will use the allocator instance to allocate the adapters. You can call this to use Cohtml instances when using an externally initialized rendering library.

function DestroyAdaptedRenderingAllocatorAndLogger #

void DestroyAdaptedRenderingAllocatorAndLogger(
    IAllocator * allocator,
    renoir::IAllocator * renderingAllocator,
    renoir::Logging::ILogHandler * renderingLogger
)

Deallocates the adapters created from AdaptRenderingAllocatorAndLoggerFromCohtml.

function IsTagSelfClosing #

inline bool IsTagSelfClosing(
    HTMLTag tag
)

function CanTagContainHTML #

inline bool CanTagContainHTML(
    HTMLTag tag
)

function CanSVGTagContainText #

inline bool CanSVGTagContainText(
    HTMLTag tag
)

function CanTagBeSVG #

inline bool CanTagBeSVG(
    HTMLTag tag
)

function CoherentCreateModelBindPointer #

template <typename T >
void COHERENT_STDCALL CoherentCreateModelBindPointer(
    Binder * binder,
    T * model
)

function CoherentArrayLength #

template <typename ArrayType ,
size_t Size>
size_t CoherentArrayLength(
    void * arrayPtr
)

function CoherentArrayElementReader #

template <typename ArrayType >
void CoherentArrayElementReader(
    Binder * binder,
    void * data,
    size_t position
)

function CoherentArrayElementBinder #

template <typename ArrayType >
void CoherentArrayElementBinder(
    Binder * binder,
    void * arr,
    size_t index
)

function CoherentArrayElementGetterImpl #

template <typename T >
EnableIf< PointerTrait< T >::Value, void * >::Type CoherentArrayElementGetterImpl(
    T & object
)

function CoherentArrayElementGetterImpl #

template <typename T >
EnableIf<!PointerTrait< T >::Value &&!IsCString< T >::Value, void * >::Type CoherentArrayElementGetterImpl(
    T & object
)

function CoherentArrayElementGetterImpl #

template <typename T >
EnableIf<!PointerTrait< T >::Value &&IsCString< T >::Value, void * >::Type CoherentArrayElementGetterImpl(
    T & object
)

function CoherentArrayElementGetter #

template <typename ArrayType >
void * CoherentArrayElementGetter(
    void * arr,
    size_t index
)

function CoherentBindInternal #

template <typename ArrayType ,
size_t ArraySize>
inline EnableIf<!IsChar< ArrayType >::Value||IsSame< ArrayType, unsigned char >::Value >::Type CoherentBindInternal(
    Binder * binder,
    ArrayType(&) array[ArraySize]
)

function CoherentBindInternal #

template <typename ArrayType ,
size_t ArraySize>
inline EnableIf< IsChar< ArrayType >::Value &&!IsSame< ArrayType, unsigned char >::Value >::Type CoherentBindInternal(
    Binder * binder,
    ArrayType array[ArraySize]
)

function CoherentReadInternal #

template <typename ArrayType ,
size_t ArraySize>
inline EnableIf<!IsChar< ArrayType >::Value||IsSame< ArrayType, unsigned char >::Value >::Type CoherentReadInternal(
    Binder * binder,
    ArrayType(&) array[ArraySize]
)

function CoherentReadInternal #

template <typename ArrayType ,
size_t ArraySize>
inline EnableIf< IsChar< ArrayType >::Value &&!IsSame< ArrayType, unsigned char >::Value >::Type CoherentReadInternal(
    Binder * binder,
    ArrayType array[ArraySize]
)

function ValueTypeToString #

inline const char * ValueTypeToString(
    ValueType type
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    bool value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    signed short value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    unsigned short value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    signed int value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    unsigned int value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    signed long long value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    unsigned long long value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    signed long value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    unsigned long value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    char value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    signed char value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    unsigned char value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    float value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    double value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    const char * value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    const wchar_t * value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    const char16_t * value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    const char32_t * value
)

function CoherentReadInternal #

inline void CoherentReadInternal(
    Binder * binder,
    signed short & value
)

function CoherentReadInternal #

inline void CoherentReadInternal(
    Binder * binder,
    unsigned short & value
)

function CoherentReadInternal #

inline void CoherentReadInternal(
    Binder * binder,
    signed int & value
)

function CoherentReadInternal #

inline void CoherentReadInternal(
    Binder * binder,
    unsigned int & value
)

function CoherentReadInternal #

inline void CoherentReadInternal(
    Binder * binder,
    signed long long & value
)

function CoherentReadInternal #

inline void CoherentReadInternal(
    Binder * binder,
    unsigned long long & value
)

function CoherentReadInternal #

inline void CoherentReadInternal(
    Binder * binder,
    signed long & value
)

function CoherentReadInternal #

inline void CoherentReadInternal(
    Binder * binder,
    unsigned long & value
)

function CoherentReadInternal #

inline void CoherentReadInternal(
    Binder * binder,
    bool & value
)

function CoherentReadInternal #

inline void CoherentReadInternal(
    Binder * binder,
    char & value
)

function CoherentReadInternal #

inline void CoherentReadInternal(
    Binder * binder,
    signed char & value
)

function CoherentReadInternal #

inline void CoherentReadInternal(
    Binder * binder,
    unsigned char & value
)

function CoherentReadInternal #

inline void CoherentReadInternal(
    Binder * binder,
    float & value
)

function CoherentReadInternal #

inline void CoherentReadInternal(
    Binder * binder,
    double & value
)

function CoherentBindInternalPointerHelper #

template <typename T >
EnableIf< cohtml::TypeToElementType< T >::value==ElementType::ET_UserType, void >::Type CoherentBindInternalPointerHelper(
    Binder * binder,
    T * object
)

function CoherentBindInternalPointerHelper #

template <typename T >
EnableIf< cohtml::TypeToElementType< T >::value !=ElementType::ET_UserType, void >::Type CoherentBindInternalPointerHelper(
    Binder * binder,
    T * object
)

function CoherentBindInternalPointer #

template <typename T >
EnableIf< PointerTrait< T >::Value, void >::Type CoherentBindInternalPointer(
    Binder * binder,
    T & object
)

function CoherentBindInternalPointer #

template <typename T >
EnableIf<!PointerTrait< T >::Value &&!IsCString< T >::Value, void >::Type CoherentBindInternalPointer(
    Binder * binder,
    T & object
)

function CoherentBindInternalPointer #

template <typename T >
EnableIf<!PointerTrait< T * >::Value &&IsCString< T * >::Value, void >::Type CoherentBindInternalPointer(
    Binder * binder,
    T *& object
)

function CoherentReadInternalUserType #

template <typename T >
EnableIf< PointerTrait< T >::Value, void >::Type CoherentReadInternalUserType(
    Binder * binder,
    T & object
)

function CoherentReadInternalUserType #

template <typename T >
EnableIf<!PointerTrait< T >::Value &&IsCString< T >::Value, void >::Type CoherentReadInternalUserType(
    Binder * binder,
    T & object
)

function CoherentReadInternalUserType #

template <typename T >
EnableIf<!PointerTrait< T >::Value &&!IsCString< T >::Value, void >::Type CoherentReadInternalUserType(
    Binder * binder,
    T & object
)

function CoherentBindInternal #

template <typename T >
EnableIf< IsDefaultBindEnabled< T >::Value >::Type CoherentBindInternal(
    Binder * binder,
    T & object
)

function CoherentBindInternal #

template <typename T >
EnableIf< IsDefaultBindEnabled< T >::Value >::Type CoherentBindInternal(
    Binder * binder,
    const T & object
)

function CoherentReadInternal #

template <typename T >
EnableIf< IsDefaultBindEnabled< T >::Value >::Type CoherentReadInternal(
    Binder * binder,
    T & object
)

function CoherentBindKeyValueProperty #

template <typename T ,
typename A >
void CoherentBindKeyValueProperty(
    Binder * binder,
    T && key,
    A && value
)

function CoherentBindKeyValueProperty #

template <typename T ,
typename A >
void CoherentBindKeyValueProperty(
    Binder * binder,
    T && keyProperty,
    void * key,
    A && valueProperty,
    void * value
)

function ByRef #

template <typename T >
ByRefHolder< T > ByRef(
    T & ref
)

function CoherentBindInternal #

template <typename T >
void CoherentBindInternal(
    Binder * binder,
    ByRefHolder< T > & holder
)

function CoherentBindInternal #

template <typename T >
void CoherentBindInternal(
    Binder * binder,
    const ByRefHolder< T > & holder
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    renoir::Color & value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    const renoir::Color & value
)

function CoherentReadInternal #

inline void CoherentReadInternal(
    Binder * binder,
    renoir::Color & value
)

function CoherentBindInternal #

template <typename Key ,
typename Value ,
typename Comparator ,
typename Allocator >
void CoherentBindInternal(
    Binder * binder,
    std::map< Key, Value, Comparator, Allocator > & value
)

function CoherentBindInternal #

template <typename Key ,
typename Value ,
typename Comparator ,
typename Allocator >
void CoherentBindInternal(
    Binder * binder,
    const std::map< Key, Value, Comparator, Allocator > & value
)

function CoherentReadInternal #

template <typename Key ,
typename Value ,
typename Comparator ,
typename Allocator >
void CoherentReadInternal(
    Binder * binder,
    std::map< Key, Value, Comparator, Allocator > & value
)

function GetMapValueInvoke #

template <typename Key ,
typename Value ,
typename Comparator ,
typename Allocator >
inline bool GetMapValueInvoke(
    Binder * binder,
    MapInfo * mapInfo,
    std::map< Key, Value, Comparator, Allocator > * pMap
)

function CoherentReadMapKey #

template <typename T >
void CoherentReadMapKey(
    Binder * binder,
    T & value
)

function GetMapValueInvoke #

template <typename T >
inline EnableIf<!IsMap< typename UnwrapPointerType< T, PointerTrait< T >::Value >::Type >::Value, bool >::Type GetMapValueInvoke(
    Binder * binder,
    void * object,
    MapInfo * mapInfo,
    const TypedProperty< T &> * prop
)

function GetMapValueInvoke #

template <typename T >
EnableIf< IsMap< typename UnwrapPointerType< T, PointerTrait< T >::Value >::Type >::Value, bool >::Type GetMapValueInvoke(
    Binder * binder,
    void * object,
    MapInfo * mapInfo,
    const TypedProperty< T &> * prop
)

function GetMapValueInvoke #

template <typename T >
inline bool GetMapValueInvoke(
    Binder * binder,
    MapInfo * mapInfo,
    T notMap
)

function CoherentMapNativeElementReader #

template <typename MapType ,
typename MapKeyType ,
typename MapValueType >
EnableIf<!cohtml::PointerTrait< MapValueType >::Value, void * >::Type CoherentMapNativeElementReader(
    void * data,
    char const * name
)

function CoherentMapNativeElementReader #

template <typename MapType ,
typename MapKeyType ,
typename MapValueType >
EnableIf< cohtml::PointerTrait< MapValueType >::Value, void * >::Type CoherentMapNativeElementReader(
    void * data,
    char const * name
)

function CoherentBindInternal #

template <typename T1 ,
typename T2 >
void CoherentBindInternal(
    Binder * binder,
    std::pair< T1, T2 > & value
)

function CoherentBindInternal #

template <typename T1 ,
typename T2 >
void CoherentBindInternal(
    Binder * binder,
    const std::pair< T1, T2 > & value
)

function CoherentReadInternal #

template <typename T1 ,
typename T2 >
void CoherentReadInternal(
    Binder * binder,
    std::pair< T1, T2 > & value
)

function GetPairValueInvoke #

template <typename T >
inline EnableIf<!IsPair< typename UnwrapPointerType< T, PointerTrait< T >::Value >::Type >::Value, bool >::Type GetPairValueInvoke(
    Binder * binder,
    void * object,
    PairInfo * pairInfo,
    const TypedProperty< T &> * prop
)

function GetPairValueInvoke #

template <typename T >
inline bool GetPairValueInvoke(
    Binder * binder,
    PairInfo * pairInfo,
    T value
)

function GetPairValueInvoke #

template <typename T1 ,
typename T2 >
inline bool GetPairValueInvoke(
    Binder * binder,
    PairInfo * pairInfo,
    std::pair< T1, T2 > * pPair
)

function GetPairValueInvoke #

template <typename T >
EnableIf< IsPair< typename UnwrapPointerType< T, PointerTrait< T >::Value >::Type >::Value, bool >::Type GetPairValueInvoke(
    Binder * binder,
    void * object,
    PairInfo * arrayInfo,
    const TypedProperty< T &> * prop
)

function ExtractRawArray #

template <typename ArrayType ,
size_t ArraySize>
inline EnableIf<(!IsChar< ArrayType >::Value||IsSame< ArrayType, unsigned char >::Value) &&(TypeToElementType< ArrayType >::value !=ElementType::ET_UserType), bool >::Type ExtractRawArray(
    Binder * binder,
    ArrayType(&) userData[ArraySize],
    ArrayInfo * arrayInfo
)

Helper function for converting a Property into an array when the property is a C-style array.

Parameters:

• binder - the binder to use
• userData - object that might be a C-style array or not
• arrayInfo - information about array type - callbacks, properties, methods

Return: true - if the conversion was successful

function ExtractRawArray #

template <typename ArrayType ,
size_t ArraySize>
inline EnableIf<(!IsChar< ArrayType >::Value||IsSame< ArrayType, unsigned char >::Value) &&(TypeToElementType< ArrayType >::value==ElementType::ET_UserType), bool >::Type ExtractRawArray(
    Binder * binder,
    ArrayType(&) userData[ArraySize],
    ArrayInfo * arrayInfo
)

function ExtractRawArray #

template <typename ValueType >
inline bool ExtractRawArray(
    Binder * ,
    const ValueType & ,
    ArrayInfo * 
)

function CoherentTypeInfoCallCoherentBindInternal #

template <typename T >
EnableIf< IsCString< T >::Value, void >::Type CoherentTypeInfoCallCoherentBindInternal(
    Binder * binder
)

function CoherentTypeInfoCallCoherentBindInternal #

template <typename T >
EnableIf< IsCString< T >::Value, void >::Type CoherentTypeInfoCallCoherentBindInternal(
    Binder * binder,
    void * model
)

function CoherentTypeInfoCallCoherentBindInternal #

template <typename T >
EnableIf<!IsCString< T >::Value, void >::Type CoherentTypeInfoCallCoherentBindInternal(
    Binder * binder
)

function CoherentTypeInfoCallCoherentBindInternal #

template <typename T >
EnableIf<!IsCString< T >::Value, void >::Type CoherentTypeInfoCallCoherentBindInternal(
    Binder * binder,
    void * model
)

function GetObjectInfoInvoke #

template <typename Type >
EnableIf< PointerTrait< Type >::Value, bool >::Type GetObjectInfoInvoke(
    Binder * binder,
    void * object,
    ObjectInfo * objInfo,
    const TypedProperty< Type &> * prop
)

function GetObjectInfoInvoke #

template <typename Type >
EnableIf<!PointerTrait< Type >::Value, bool >::Type GetObjectInfoInvoke(
    Binder * binder,
    void * object,
    ObjectInfo * objInfo,
    const TypedProperty< Type &> * prop
)

function MakeProperty #

template <typename P >
FieldProperty< P > MakeProperty(
    const char * name,
    P p
)

function MakeProperty #

template <typename G ,
typename S >
ConcreteProperty< G, S > MakeProperty(
    const char * name,
    G g,
    S s
)

function MakePropertyReadOnly #

template <typename G >
ConcretePropertyReadOnly< G > MakePropertyReadOnly(
    const char * name,
    G g
)

function CoherentBindInternal #

template <typename Char ,
typename CharTraits ,
typename Allocator >
void CoherentBindInternal(
    Binder * binder,
    std::basic_string< Char, CharTraits, Allocator > & value
)

function CoherentBindInternal #

template <typename Char ,
typename CharTraits ,
typename Allocator >
void CoherentBindInternal(
    Binder * binder,
    const std::basic_string< Char, CharTraits, Allocator > & value
)

function CoherentReadInternal #

template <typename Char ,
typename CharTraits ,
typename Allocator >
void CoherentReadInternal(
    Binder * binder,
    std::basic_string< Char, CharTraits, Allocator > & value
)

function CoherentReadMapKey #

template <typename Char ,
typename CharTraits ,
typename Allocator >
void CoherentReadMapKey(
    Binder * binder,
    std::basic_string< Char, CharTraits, Allocator > & value
)

function DecayToMutablePtrUnchecked #

template <typename T >
DecayedType< T > * DecayToMutablePtrUnchecked(
    T & value
)

Removes const and reference qualifiers from T and converts the input to a mutable pointer.

• If T is a value type, returns &value
• If T is a pointer type, unwraps it and returns a mutable pointer valueThe value or pointer to decay

Mutable pointer to the decayed underlying type

Constness is discarded via blind cast and assumed to be safe by contract.

function CSTRING_TYPETRAIT #

CSTRING_TYPETRAIT(
    char 
)

function CSTRING_TYPETRAIT #

CSTRING_TYPETRAIT(
    signed char
)

function CSTRING_TYPETRAIT #

CSTRING_TYPETRAIT(
    unsigned char
)

function CSTRING_TYPETRAIT #

CSTRING_TYPETRAIT(
    wchar_t 
)

function CSTRING_TYPETRAIT #

CSTRING_TYPETRAIT(
    char16_t 
)

function CSTRING_TYPETRAIT #

CSTRING_TYPETRAIT(
    char32_t 
)

function CoherentBindInternal #

template <typename Key ,
typename Value ,
typename Hash ,
typename Pred ,
typename Allocator >
void CoherentBindInternal(
    Binder * binder,
    std::unordered_map< Key, Value, Hash, Pred, Allocator > & value
)

function CoherentBindInternal #

template <typename Key ,
typename Value ,
typename Hash ,
typename Pred ,
typename Allocator >
void CoherentBindInternal(
    Binder * binder,
    const std::unordered_map< Key, Value, Hash, Pred, Allocator > & value
)

function CoherentReadInternal #

template <typename Key ,
typename Value ,
typename Hash ,
typename Pred ,
typename Allocator >
void CoherentReadInternal(
    Binder * binder,
    std::unordered_map< Key, Value, Hash, Pred, Allocator > & value
)

function GetMapValueInvoke #

template <typename Key ,
typename Value ,
typename Hash ,
typename Pred ,
typename Allocator >
inline bool GetMapValueInvoke(
    Binder * binder,
    MapInfo * mapInfo,
    std::unordered_map< Key, Value, Hash, Pred, Allocator > * pMap
)

function CoherentBindInternal #

template <typename... Args>
void CoherentBindInternal(
    cohtml::Binder * binder,
    std::variant< Args... > & value
)

function CoherentBindInternal #

template <typename... Args>
void CoherentBindInternal(
    cohtml::Binder * binder,
    std::variant< Args... > * value
)

function CoherentBindInternal #

template <typename... Args>
void CoherentBindInternal(
    cohtml::Binder * binder,
    const std::variant< Args... > & value
)

function CoherentBindInternal #

template <typename... Args>
void CoherentBindInternal(
    cohtml::Binder * binder,
    const std::variant< Args... > * value
)

function CoherentReadInternal #

template <typename... Args>
void CoherentReadInternal(
    cohtml::Binder * binder,
    std::variant< Args... > & value
)

function CoherentReadInternal #

template <typename... Args>
void CoherentReadInternal(
    cohtml::Binder * binder,
    const std::variant< Args... > & value
)

function GetObjectInfoInvoke #

template <typename... Args>
bool GetObjectInfoInvoke(
    Binder * binder,
    ObjectInfo * objInfo,
    std::variant< Args... > & value
)

function GetArrayValueInvoke #

template <typename... Args>
bool GetArrayValueInvoke(
    Binder * binder,
    void * object,
    ArrayInfo * arrayinfo,
    const TypedProperty< std::variant< Args... > &> * prop
)

function GetArrayValueInvoke #

template <typename... Args>
bool GetArrayValueInvoke(
    Binder * binder,
    void * object,
    ArrayInfo * arrayinfo,
    const TypedProperty< std::variant< Args... > *&> * prop
)

function GetArrayValueInvoke #

template <typename... Args>
bool GetArrayValueInvoke(
    Binder * binder,
    void * object,
    ArrayInfo * arrayinfo,
    const TypedProperty< const std::variant< Args... > *&> * prop
)

function GetPairValueInvoke #

template <typename... Args>
bool GetPairValueInvoke(
    Binder * binder,
    void * object,
    PairInfo * pairInfo,
    const TypedProperty< std::variant< Args... > &> * prop
)

function GetPairValueInvoke #

template <typename... Args>
bool GetPairValueInvoke(
    Binder * binder,
    void * object,
    PairInfo * pairInfo,
    const TypedProperty< std::variant< Args... > *&> * prop
)

function GetPairValueInvoke #

template <typename... Args>
bool GetPairValueInvoke(
    Binder * binder,
    void * object,
    PairInfo * pairInfo,
    const TypedProperty< const std::variant< Args... > *&> * prop
)

function GetMapValueInvoke #

template <typename... Args>
bool GetMapValueInvoke(
    Binder * binder,
    void * object,
    MapInfo * mapInfo,
    const TypedProperty< std::variant< Args... > &> * prop
)

function GetMapValueInvoke #

template <typename... Args>
bool GetMapValueInvoke(
    Binder * binder,
    void * object,
    MapInfo * mapInfo,
    const TypedProperty< std::variant< Args... > *&> * prop
)

function GetMapValueInvoke #

template <typename... Args>
bool GetMapValueInvoke(
    Binder * binder,
    void * object,
    MapInfo * mapInfo,
    const TypedProperty< const std::variant< Args... > *&> * prop
)

function CoherentVectorLength #

template <typename VectorType >
size_t CoherentVectorLength(
    void * vectorPtr
)

function CoherentVectorElementReader #

template <typename VectorType ,
typename T >
EnableIf<!cohtml::PointerTrait< T >::Value, void >::Type CoherentVectorElementReader(
    Binder * binder,
    void * vectorPtr,
    size_t position
)

function CoherentVectorElementReader #

template <typename VectorType ,
typename T >
EnableIf< cohtml::PointerTrait< T >::Value, void >::Type CoherentVectorElementReader(
    Binder * binder,
    void * vectorPtr,
    size_t position
)

function CoherentVectorNativeElementReader #

template <typename VectorType ,
typename T >
EnableIf<!cohtml::PointerTrait< T >::Value, void * >::Type CoherentVectorNativeElementReader(
    void * vectorPtr,
    size_t position
)

function CoherentVectorNativeElementReader #

template <typename VectorType ,
typename T >
EnableIf< cohtml::PointerTrait< T >::Value, void * >::Type CoherentVectorNativeElementReader(
    void * vectorPtr,
    size_t position
)

function CoherentVectorElementBinder #

template <typename VectorType >
void CoherentVectorElementBinder(
    Binder * binder,
    void * vectorPtr,
    size_t index
)

function CoherentBindInternal #

template <typename T ,
typename A >
void CoherentBindInternal(
    Binder * binder,
    std::vector< T, A > & value
)

function CoherentBindInternal #

template <typename T ,
typename A >
void CoherentBindInternal(
    Binder * binder,
    const std::vector< T, A > & value
)

function CoherentBindInternal #

template <typename A >
void CoherentBindInternal(
    Binder * binder,
    std::vector< float, A > & value
)

function CoherentBindInternal #

template <typename A >
void CoherentBindInternal(
    Binder * binder,
    const std::vector< float, A > & value
)

function CoherentBindInternal #

template <typename A >
void CoherentBindInternal(
    Binder * binder,
    std::vector< int, A > & value
)

function CoherentBindInternal #

template <typename A >
void CoherentBindInternal(
    Binder * binder,
    const std::vector< int, A > & value
)

function CoherentReadInternal #

template <typename T ,
typename A >
void CoherentReadInternal(
    Binder * binder,
    std::vector< T, A > & value
)

function GetArrayValueInvoke #

template <typename T >
inline EnableIf<!IsVector< typename UnwrapPointerType< T, PointerTrait< T >::Value >::Type >::Value, bool >::Type GetArrayValueInvoke(
    Binder * binder,
    void * object,
    ArrayInfo * arrayInfo,
    const TypedProperty< T &> * prop
)

function GetArrayValueInvoke #

template <typename T >
inline bool GetArrayValueInvoke(
    Binder * binder,
    ArrayInfo * arrayInfo,
    T value
)

function GetArrayValueInvoke #

template <typename T ,
typename A >
inline bool GetArrayValueInvoke(
    Binder * binder,
    ArrayInfo * arrayInfo,
    std::vector< T, A > * pVector
)

function GetArrayValueInvoke #

template <typename T >
EnableIf< IsVector< typename UnwrapPointerType< T, PointerTrait< T >::Value >::Type >::Value, bool >::Type GetArrayValueInvoke(
    Binder * binder,
    void * object,
    ArrayInfo * arrayInfo,
    const TypedProperty< T &> * prop
)