Function.h

/*********************************************************************** Author: Zihan Chen (vczh) Licensed under https://github.com/vczh-libraries/License ***********************************************************************/

#ifndef VCZH_FUNCTION

#define VCZH_FUNCTION #include <memory.h>

#include "Basic.h"

#include "Pointer.h"

namespace

{

template

typename

class

Func

;

/*********************************************************************** vl::function_lambda::LambdaRetriveType<R(TArgs...)> ***********************************************************************/

namespace

function_lambda

{

template

typename

struct

LambdaRetriveType

{ };

template

typename

struct

FunctionObjectRetriveType

{

typedef

typename

LambdaRetriveType

decltype

operator

())>::Type

Type

;

typedef

typename

LambdaRetriveType

decltype

operator

())>::FunctionType

FunctionType

;

typedef

typename

LambdaRetriveType

decltype

operator

())>::ResultType

ResultType

;

typedef

typename

LambdaRetriveType

decltype

operator

())>::ParameterTypes

ParameterTypes

; };

template

typename

TObject

typename

...

TArgs

struct

LambdaRetriveType

(

__thiscall

TObject

::*)(

TArgs

...)

const

> {

typedef

Func

(

TArgs

...)>

Type

;

typedef

(

FunctionType

)(

TArgs

...);

typedef

ResultType

;

typedef

TypeTuple

TArgs

...>

ParameterTypes

; };

template

typename

TObject

typename

...

TArgs

struct

LambdaRetriveType

(

__thiscall

TObject

::*)(

TArgs

...)> {

typedef

Func

(

TArgs

...)>

Type

;

typedef

(

FunctionType

)(

TArgs

...);

typedef

ResultType

;

typedef

TypeTuple

TArgs

...>

ParameterTypes

; };

template

typename

...

TArgs

struct

FunctionObjectRetriveType

(*)(

TArgs

...)> {

typedef

Func

(

TArgs

...)>

Type

;

typedef

(

FunctionType

)(

TArgs

...);

typedef

ResultType

;

typedef

TypeTuple

TArgs

...>

ParameterTypes

; }; }

/*********************************************************************** vl::Func<R(TArgs...)> ***********************************************************************/

namespace

internal_invokers

{

template

typename

...

TArgs

class

Invoker

public

Object

{

public

virtual

Invoke

(

TArgs

&& ...

args

) =

; };

//------------------------------------------------------

template

typename

...

TArgs

class

StaticInvoker

public

Invoker

TArgs

...> {

protected

function

)(

TArgs

...

args

);

public

StaticInvoker

(

_function

)(

TArgs

...)) :function(

_function

) { }

Invoke

(

TArgs

&& ...

args

)

override

{

return

function

(

ForwardValue

TArgs

args

)...); } };

//------------------------------------------------------

template

typename

...

TArgs

class

MemberInvoker

public

Invoker

TArgs

...> {

protected

sender

;

(

::*

function

)(

TArgs

...

args

);

public

MemberInvoker

(

_sender

(

::*

_function

)(

TArgs

...

args

)) :sender(

_sender

) ,function(

_function

) { }

Invoke

(

TArgs

&& ...

args

)

override

{

return

(

sender

->*

function

)(

ForwardValue

TArgs

args

)...); } };

//------------------------------------------------------

template

typename

...

TArgs

class

ObjectInvoker

public

Invoker

TArgs

...> {

protected

function

;

public

ObjectInvoker

(

const

_function

) :function(

_function

) { }

ObjectInvoker

(

_function

) :function(

MoveValue

(

_function

)) { }

Invoke

(

TArgs

&& ...

args

)

override

{

return

function

(

ForwardValue

TArgs

args

)...); } };

//------------------------------------------------------

template

typename

...

TArgs

class

ObjectInvoker

void

TArgs

...> :

public

Invoker

void

TArgs

...> {

protected

function

;

public

ObjectInvoker

(

const

_function

) :function(

_function

) { }

ObjectInvoker

(

_function

) :function(

MoveValue

(

_function

)) { }

void

Invoke

(

TArgs

&& ...

args

)

override

{

function

(

ForwardValue

TArgs

args

)...); } }; }

/// <summary>A type for functors.</summary>

/// <typeparam name="R">The return type.</typeparam>

/// <typeparam name="TArgs">Types of parameters.</typeparam>

template

typename

...

TArgs

class

Func

(

TArgs

...)> :

public

Object

{

protected

Ptr

internal_invokers

Invoker

TArgs

...>>

invoker

;

template

typename

...

TArgs2

static

bool

IsEmptyFunc

(

const

Func

(

TArgs2

...)>&

function

) {

return

function

; }

template

typename

...

TArgs2

static

bool

IsEmptyFunc

(

Func

(

TArgs2

...)>&

function

) {

return

function

; }

template

typename

static

bool

IsEmptyFunc

(

&&) {

return

false

; }

public

typedef

FunctionType

(

TArgs

...);

typedef

ResultType

;

/// <summary>Create a null functor.</summary>

Func

() =

default

;

/// <summary>Copy a functor.</summary>

/// <param name="function">The functor to copy.</param>

Func

(

const

Func

(

TArgs

...)>&

function

) =

default

;

/// <summary>Move a functor.</summary>

/// <param name="function">The functor to move.</param>

Func

(

Func

(

TArgs

...)>&&

function

) =

default

;

/// <summary>Create a functor from a function pointer.</summary>

/// <param name="function">The function pointer.</param>

Func

(

function

)(

TArgs

...)) {

invoker

new

internal_invokers

StaticInvoker

TArgs

...>(

function

); }

/// <summary>Create a functor from a method.</summary>

/// <typeparam name="C">Type of the class that this method belongs to.</typeparam>

/// <param name="sender">The object that this method belongs to.</param>

/// <param name="function">The method pointer.</param>

template

typename

Func

(

sender

(

::*

function

)(

TArgs

...)) {

invoker

new

internal_invokers

MemberInvoker

TArgs

...>(

sender

function

); }

/// <summary>Create a functor from another compatible functor.</summary>

/// <typeparam name="C">Type of the functor to copy.</typeparam>

/// <param name="function">The functor to copy. It could be a lambda expression, or any types that has operator() members.</param>

template

typename

AcceptType

void

typename

ReturnConvertable

decltype

(

ValueOf

>()(

ValueOf

TArgs

>()...)),

>::

YesNoType

>::

Type

Func

(

function

) {

IsEmptyFunc

(

function

)) {

invoker

new

internal_invokers

ObjectInvoker

typename

RemoveCVR

>::

Type

TArgs

...>(

ForwardValue

&&>(

function

)); } }

/// <summary>Invoke the function.</summary>

/// <returns>Returns the function result. It crashes when the functor is null.</returns>

/// <param name="args">Arguments to invoke the function.</param>

operator

(

)

(

TArgs

...

args

)

const

{

return

invoker

Invoke

(

ForwardValue

TArgs

args

)...); }

Func

(

TArgs

...)>&

operator

(

const

Func

(

TArgs

...)>&

function

) {

invoker

function

invoker

;

return

this

; }

Func

(

TArgs

...)>&

operator

(

const

Func

(

TArgs

...)>&&

function

) {

invoker

MoveValue

(

function

invoker

);

return

this

; }

bool

operator

(

const

Func

(

TArgs

...)>&

function

)

const

{

return

invoker

function

invoker

; }

bool

operator

(

const

Func

(

TArgs

...)>&

function

)

const

{

return

invoker

function

invoker

; }

/// <summary>Test is the functor is non-null.</summary>

/// <returns>Returns true if the functor is non-null.</returns>

operator

bool

()

const

{

return

invoker

; } };

/*********************************************************************** LAMBDA ***********************************************************************/

namespace

function_lambda

{

/// <summary>Create a functor in [T:vl.Func`1] from another functor, with all type arguments autotimatically inferred. The "LAMBDA" macro is recommended for the same purpose for writing compact code.</summary>

/// <typeparam name="T">Type of the functor to copy.</typeparam>

/// <returns>A copied functor in [T:vl.Func`1].</returns>

/// <param name="functionObject">The functor to copy.</param>

template

typename

LambdaRetriveType

decltype

operator

())>::

Type

Lambda

(

functionObject

) {

return

functionObject

; }

/// <summary>Create a functor in [T:vl.Func`1] from a function pointer, with all type arguments autotimatically inferred. The "FUNCTION" macro is recommended for the same purpose for writing compact code.</summary>

/// <typeparam name="T">Type of the function pointer.</typeparam>

/// <returns>A copied functor in [T:vl.Func`1].</returns>

/// <param name="functionObject">The function pointer.</param>

template

typename

FunctionObjectRetriveType

>::

Type

ConvertToFunction

(

functionObject

) {

return

functionObject

; }

#define LAMBDA vl::function_lambda::Lambda

#define FUNCTION vl::function_lambda::ConvertToFunction

#define FUNCTION_TYPE(T) typename vl::function_lambda::FunctionObjectRetriveType<T>::Type

#define FUNCTION_RESULT_TYPE(T) typename vl::function_lambda::FunctionObjectRetriveType<T>::ResultType

}

/*********************************************************************** vl::function_binding::Binding<R(TArgs...)> ***********************************************************************/

namespace

function_binding

{

template

typename

struct

Binding

{ };

template

typename

struct

{

typedef

const

Type

;};

template

typename

struct

&>{

typedef

Type

;};

template

typename

struct

const

typedef

const

Type

;};

template

typename

struct

const

&>{

typedef

const

Type

;};

template

typename

...

TArgs

struct

Binding

(

TArgs

...)> {

typedef

FunctionType

(

TArgs

...);

typedef

CurriedType

(

TArgs

...);

typedef

FirstParameterType

;

class

Binder

public

Object

{

protected

Func

FunctionType

target

;

firstArgument

;

public

Binder

(

const

Func

FunctionType

_target

_firstArgument

) :target(

_target

) ,firstArgument(

ForwardValue

_firstArgument

)) { }

operator

(

)

(

TArgs

...

args

)

const

{

return

target

(

firstArgument

args

...); } };

class

Currier

public

Object

{

protected

Func

FunctionType

target

;

public

Currier

(

const

Func

FunctionType

_target

) :target(

_target

) { }

Func

CurriedType

operator

(

)

(

firstArgument

)

const

{

return

Binder

(

target

firstArgument

); } }; }; }

/// <summary>

/// Currize a function pointer.

/// Currizing means to create a new functor whose argument is the first argument of the original function.

/// Calling this functor will return another functor whose arguments are all remaining arguments of the original function.

/// Calling the returned function will call the original function.

/// </summary>

/// <typeparam name="T">Type of the function pointer.</typeparam>

/// <returns>The currized functor.</returns>

/// <param name="function">The function pointer to currize.</param>

template

typename

Func

typename

function_binding

Binding

>::

CurriedType

typename

function_binding

Binding

>::

FirstParameterType

Curry

(

function

) {

return

typename

function_binding

Binding

>::

Currier

(

function

); }

/// <summary>

/// Currize a functor in [T:vl.Func`1].

/// Currizing means to create a new functor whose argument is the first argument of the original function.

/// Calling this functor will return another functor whose arguments are all remaining arguments of the original function.

/// Calling the returned function will call the original function.

/// </summary>

/// <typeparam name="T">Type of the functor.</typeparam>

/// <returns>The currized functor.</returns>

/// <param name="function">The functor to currize.</param>

template

typename

Func

typename

function_binding

Binding

>::

CurriedType

typename

function_binding

Binding

>::

FirstParameterType

Curry

(

const

Func

function

) {

return

typename

function_binding

Binding

>::

Currier

(

function

); } }

#endif