cohtml

Classes #

Types #

Functions #

Attributes #

Types Documentation #

enum ECohtmlPageLoadState #

typedef Reader #

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

typedef NativeReader #

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

typedef VectorLengthFunc #

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

using TRemoveAllExtents_T #

template <typename T >
using cohtml::TRemoveAllExtents_T = typedef typename std::remove_cv_t<typename TRemovePointer<typename TRemoveReference<T>::Type>::Type>;

using TRemoveCV_T #

template <typename T >
using cohtml::TRemoveCV_T = typedef typename std::remove_cv_t<T>;

typedef CoherentCustomBind #

typedef void(* cohtml::CoherentCustomBind) (cohtml::Binder *binder, const void *instance);

Functions Documentation #

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    FColor & value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    const FColor & value
)

function CoherentReadInternal #

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

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    FLinearColor & value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    const FLinearColor & value
)

function CoherentReadInternal #

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

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    FIntPoint & value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    const FIntPoint & value
)

function CoherentReadInternal #

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

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    FIntVector & value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    const FIntVector & value
)

function CoherentReadInternal #

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

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    FIntRect & value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    const FIntRect & value
)

function CoherentReadInternal #

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

function AnsiToTCharConverter #

inline void AnsiToTCharConverter(
    const char * Buffer,
    size_t Size,
    FString & Text
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    FString & value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    const FString & value
)

function CoherentReadInternal #

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

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    FText & value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    const FText & value
)

function CoherentReadInternal #

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

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    FName & value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    const FName & value
)

function CoherentReadInternal #

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

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    FVector2D & value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    const FVector2D & value
)

function CoherentReadInternal #

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

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    FVector & value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    const FVector & value
)

function CoherentReadInternal #

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

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    FVector4 & value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    const FVector4 & value
)

function CoherentReadInternal #

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

function CoherentTArrayElementReader #

template <typename T >
void CoherentTArrayElementReader(
    Binder * binder,
    void * data,
    size_t position
)

function CoherentTArrayNativeElementReader #

template <typename TArrayType >
void * CoherentTArrayNativeElementReader(
    void * data,
    size_t position
)

function CoherentTArrayLength #

template <typename TArrayType >
size_t CoherentTArrayLength(
    void * data
)

function CoherentTArrayElementReader #

template <typename TArrayType ,
typename T >
EnableIf<!cohtml::PointerTrait< T >::Value, void >::Type CoherentTArrayElementReader(
    Binder * binder,
    void * data,
    size_t position
)

function CoherentTArrayElementReader #

template <typename TArrayType ,
typename T >
EnableIf< cohtml::PointerTrait< T >::Value, void >::Type CoherentTArrayElementReader(
    Binder * binder,
    void * data,
    size_t position
)

function CoherentTArrayNativeElementReader #

template <typename TArrayType ,
typename T >
EnableIf<!cohtml::PointerTrait< T >::Value, void * >::Type CoherentTArrayNativeElementReader(
    void * data,
    size_t position
)

function CoherentTArrayNativeElementReader #

template <typename TArrayType ,
typename T >
EnableIf< cohtml::PointerTrait< T >::Value, void * >::Type CoherentTArrayNativeElementReader(
    void * data,
    size_t position
)

function CoherentTArrayElementBinder #

template <typename T >
void CoherentTArrayElementBinder(
    Binder * binder,
    void * arr,
    size_t index
)

function CoherentTArrayElementGetter #

template <typename T >
void * CoherentTArrayElementGetter(
    void * arr,
    size_t index
)

function CoherentBindInternal #

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

function CoherentBindInternal #

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

function CoherentBindInternal #

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

function CoherentBindInternal #

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

function CoherentBindInternal #

template <typename A >
void CoherentBindInternal(
    Binder * binder,
    TArray< int32, A > & value
)

function CoherentBindInternal #

template <typename A >
void CoherentBindInternal(
    Binder * binder,
    const TArray< int32, A > & value
)

function CoherentReadInternal #

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

function CoherentBindInternal #

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

function CoherentBindInternal #

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

function CoherentReadInternal #

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

function CoherentReadInternal #

template <typename Key ,
typename Value ,
typename Comparator ,
typename Allocator >
void CoherentReadInternal(
    Binder * binder,
    TMap< Key, TUniquePtr< Value >, Comparator, Allocator > & 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 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 GetMapValueInvoke #

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

function CoherentBindInternal #

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

Currently we require TPair’s “Key” and “Value” as “first” and “second”.

function CoherentBindInternal #

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

function CoherentReadInternal #

template <typename T1 ,
typename T2 >
void CoherentReadInternal(
    Binder * binder,
    TPair< 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 >
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 T1 ,
typename T2 >
inline bool GetPairValueInvoke(
    Binder * binder,
    PairInfo * pairInfo,
    TPair< T1, T2 > * pPair
)

function BindUType #

COHTMLPLUGIN_API void BindUType(
    cohtml::Binder * binder,
    const void * Object,
    const UStruct * Type
)

function ReadUType #

COHTMLPLUGIN_API void ReadUType(
    cohtml::Binder * binder,
    void * Object,
    const UStruct * Type
)

function BindUType #

COHTMLPLUGIN_API void BindUType(
    cohtml::Binder * binder,
    const void * Object,
    const UClass * Type
)

function ReadUType #

COHTMLPLUGIN_API void ReadUType(
    cohtml::Binder * binder,
    void * Object,
    const UClass * Type
)

function CoherentBindKeyValuePropertyUType #

template <typename KeyType ,
typename ValueType ,
typename UType >
void CoherentBindKeyValuePropertyUType(
    cohtml::Binder * Binder,
    KeyType && Key,
    ValueType && Value,
    UType && Type
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    const UDataTable & value
)

function CoherentBindInternal #

inline void CoherentBindInternal(
    Binder * binder,
    UDataTable & value
)

function RegisterUType #

COHTMLPLUGIN_API void RegisterUType(
    cohtml::Binder * Binder,
    void * Object,
    const UClass * Type
)

function RegisterUType #

COHTMLPLUGIN_API void RegisterUType(
    cohtml::Binder * Binder,
    void * Object,
    const UStruct * Type
)

function RegisterUEnumExposureByStr #

COHTMLPLUGIN_API void RegisterUEnumExposureByStr(
    const FString & UEnumName
)

function UnregisterUEnumExposureByStr #

COHTMLPLUGIN_API void UnregisterUEnumExposureByStr(
    const FString & UEnumName
)

function ClearRegisteredUEnumsByStrExposure #

COHTMLPLUGIN_API void ClearRegisteredUEnumsByStrExposure()

function DECLARE_DELEGATE_RetVal_TwoParams #

DECLARE_DELEGATE_RetVal_TwoParams(
    bool ,
    FShouldBindPropertyEvent ,
    const UStruct * ,
    const COH_PROP(Property) * 
)

function OnIgnoreProperty #

COHTMLPLUGIN_API FShouldBindPropertyEvent & OnIgnoreProperty()

function DECLARE_DELEGATE_RetVal_TwoParams #

DECLARE_DELEGATE_RetVal_TwoParams(
    bool ,
    FShouldBindFunctionEvent ,
    const UStruct * ,
    const UFunction * 
)

function OnIgnoreFunction #

COHTMLPLUGIN_API FShouldBindFunctionEvent & OnIgnoreFunction()

function CoherentCustomBindStub #

template <typename T >
void CoherentCustomBindStub(
    cohtml::Binder * binder,
    const void * instance
)

function RegisterCustomBindImpl #

COHTMLPLUGIN_API void RegisterCustomBindImpl(
    const UStruct * type,
    CoherentCustomBind stub
)

function RegisterCustomBindImpl #

COHTMLPLUGIN_API void RegisterCustomBindImpl(
    const UClass * type,
    CoherentCustomBind stub
)

function RegisterCustomBind #

template <typename T >
TEnableIf< TIsUStruct< T >::Value >::Type RegisterCustomBind()

function RegisterCustomBind #

template <typename T >
TEnableIf< TIsUClass< T >::Value >::Type RegisterCustomBind()

function CoherentBind #

template <typename UType >
TEnableIf< TIsUClass< UType >::Value >::Type CoherentBind(
    cohtml::Binder * Binder,
    const UType * Object
)

function CoherentBind #

template <typename UType >
TEnableIf< TIsUStruct< UType >::Value >::Type CoherentBind(
    cohtml::Binder * Binder,
    const UType * Object
)

function CoherentBind #

template <typename UType >
TEnableIf< TIsUClass< UType >::Value >::Type CoherentBind(
    cohtml::Binder * Binder,
    UType * Object
)

function CoherentBind #

template <typename UType >
TEnableIf< TIsUStruct< UType >::Value >::Type CoherentBind(
    cohtml::Binder * Binder,
    UType * Object
)

function CoherentBindInternal #

template <typename T >
TEnableIf< TIsUClass< T >::Value||TIsUStruct< T >::Value >::Type CoherentBindInternal(
    Binder * binder,
    T & object
)

function CoherentBindInternal #

template <typename T >
TEnableIf< TIsUClass< T >::Value||TIsUStruct< T >::Value >::Type CoherentBindInternal(
    Binder * binder,
    const T & object
)

function CoherentReadInternal #

template <typename UType >
TEnableIf< TIsUStruct< UType >::Value >::Type CoherentReadInternal(
    cohtml::Binder * Binder,
    UType & Object
)

function CoherentReadInternal #

template <typename UType >
TEnableIf< TIsUClass< UType >::Value >::Type CoherentReadInternal(
    cohtml::Binder * Binder,
    UType & Object
)

function CoherentReadInternal #

template <typename UType >
TEnableIf< TIsUStruct< UType >::Value >::Type CoherentReadInternal(
    cohtml::Binder * Binder,
    TUniquePtr< UType > & Object
)

function CoherentReadInternal #

template <typename UType >
TEnableIf< TIsUClass< UType >::Value >::Type CoherentReadInternal(
    cohtml::Binder * Binder,
    UType *& Object
)

Attributes Documentation #

variable UnboundedRequest #

static const int64 UnboundedRequest = -1;

variable MaxPartialReponseSize #

static const int64 MaxPartialReponseSize = 1 * 1024 * 1024;