delegates

Definition

Contains delegates definitions.

Classes
class	xtd::delegate< result_t(arguments_t...)>
	Represents a delegate, which is a data structure that refers to a static method or to a class instance && an instance method of that class. More...

Typedefs
template<class type_t >
using	xtd::comparison = xtd::delegate< int32(type_t x, type_t y)>
	Represents the method that compares two objects of the same type.
template<class output_t , class input_t >
using	xtd::converter = xtd::delegate< output_t(input_t input)>
	Represents a method that converts an object from one type to another type.
using	xtd::async_callback = xtd::delegate< void(async_result ar)>
	References a method to be called when a corresponding asynchronous operation completes.
template<class result_t , class ... arguments_t>
using	xtd::func = xtd::delegate< result_t(arguments_t... arguments)>
	Represents a delegate that has variables parameters and returns a value of the type specified by the result_t type.
using	xtd::threading::parameterized_thread_start = xtd::delegate< void(const xtd::any_object &obj)>
	Represents the method that executes on a xtd::threading::thread.
using	xtd::threading::thread_start = xtd::delegate< void()>
	Represents the method that executes on a xtd::threading::thread.
using	xtd::threading::wait_callback = xtd::delegate< void(const xtd::any_object &state)>
	Represents a callback method to be executed by a thread pool thread.
using	xtd::threading::wait_or_timer_callback = xtd::delegate< void(const xtd::any_object &state, bool timed_out)>
	Represents a method to be called when a xtd::threading::wait_handle is signaled or times out.
using	xtd::forms::message_loop_callback = xtd::delegate< bool()>
	Represents a method that will check whether the hosting environment is still sending messages.

Typedef Documentation

comparison

template<class type_t >

using xtd::comparison = typedef xtd::delegate<int32(type_t x, type_t y)>

#include <xtd.core/include/xtd/comparison.hpp>

Represents the method that compares two objects of the same type.

template<class type_t>
using comparison = xtd::delegate<int32(type_t x, type_t y)>;

Parameters

type_t	The type of the objects to compare.
x	The first object to compare.
y	The second object to compare.

Returns

A signed integer that indicates the relative values of x and y, as shown in the following table.

Value	Meaning
less than 0	x is less than y.
0	x equals y.
Greater than 0	x is greater than y.

Header

#include <xtd/comparison>

Library

xtd.core

converter

template<class output_t , class input_t >

using xtd::converter = typedef xtd::delegate<output_t(input_t input)>

#include <xtd.core/include/xtd/converter.hpp>

Represents a method that converts an object from one type to another type.

template<class output_t, class input_t>
using converter = xtd::delegate<output_t(input_t input)>;

Template Parameters

input_t	The type of object that is to be converted. This type parameter is contravariant. That is, you can use either the type you specified or any type that is less derived.
output_t	he type the input object is to be converted to. This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived.

Parameters

input

The object to convert.

Returns

The output_t that represents the converted input_t.

Header

#include <xtd/converter>

Namespace

xtd

Library

xtd.core

Remarks

This delegate is used by the xtd::array::convert_all method of the xtd::array class and the xtd::collections::generic::list::convert_all method of the xtd::collections::generic::list <type_t> class to convert each element of the collection from one type to another.

Examples

The following example defines a method named point_f_to_point that converts a xtd::drawing::point_f structure to a xtd::drawing::point structure. The example then creates a xtd::collections::generic::list <type_t> of xtd::drawing::point_f structures, creates a xtd::converter <point_f, point> delegate to represent the point_f_to_point method, and passes the delegate to the xtd::collections::generic::list::convert_all method. The xtd::collections::generic::list::convert_all method passes each element of the input list to the point_f_to_point method and puts the converted elements into a new list of Point structures. Both lists are displayed.

#include <xtd/xtd>
 
using namespace xtd;
using namespace xtd::collections::generic;
using namespace xtd::drawing;
 
class example {
public:
  static auto main() -> void {
    auto lpf = list<point_f> {};
    
    lpf.add(point_f {27.8f, 32.62f});
    lpf.add(point_f {99.3f, 147.273f});
    lpf.add(point_f {7.5f, 1412.2f});
    
    console::write_line();
    for (const auto& p : lpf)
      console::write_line(p);
    
    list<point> lp = lpf.convert_all(converter<point, const point_f&> {point_f_to_point});
    
    console::write_line();
    for (const auto& p : lp)
      console::write_line(p);
  }
 
  static point point_f_to_point(const point_f& pf) {
    return point {as<int>(pf.x), as<int>(pf.y)};
  }
};
 
startup_(example::main);
 
// This code produces the following output :
//
//
// {x=27.8, y=32.62}
// {x=99.3, y=147.273}
// {x=7.5, y=1412.2}
//
// {x=28, y=33}
// {x=99, y=147}
// {x=8, y=1412}

async_callback

using xtd::async_callback = typedef xtd::delegate<void(async_result ar)>

#include <xtd.core/include/xtd/delegate.hpp>

References a method to be called when a corresponding asynchronous operation completes.

using async_callback = xtd::delegate<void(async_result ar)>;

Parameters

ar	The result of the asynchronous operation.

Header

#include <xtd/async_callback>

Namespace

xtd

Library

xtd.core

func

template<class result_t , class ... arguments_t>

using xtd::func = typedef xtd::delegate<result_t(arguments_t... arguments)>

#include <xtd.core/include/xtd/func.hpp>

Represents a delegate that has variables parameters and returns a value of the type specified by the result_t type.

using event_handler = xtd::delegate<void(xtd::object& sender, const xtd::event_args& e)>;

Template Parameters

result_t	The type of the return value of the method that this delegate encapsulates.
...arguments_t	The type of parameter list of the method that this delegate encapsulates.

Parameters

arguments

The parameter list of the method that this delegate encapsulates.

Returns

The return value of the method that this delegate encapsulates.

Header

#include <xtd/func>

Namespace

xtd

Library

xtd.core

parameterized_thread_start

using xtd::threading::parameterized_thread_start = typedef xtd::delegate<void(const xtd::any_object& obj)>

#include <xtd.core/include/xtd/threading/parameterized_thread_start.hpp>

Represents the method that executes on a xtd::threading::thread.

using parameterized_thread_start = xtd::delegate<void(const xtd::any_object& obj)>;

Parameters

obj	An object that contains data for the thread procedure. using parameterized_thread_start = action<const xtd::any_object&>

Header

#include <xtd/threading/parameterized_thread_start>

Namespace

xtd::threading

Library

xtd.core

thread_start

using xtd::threading::thread_start = typedef xtd::delegate<void()>

#include <xtd.core/include/xtd/threading/thread_start.hpp>

Represents the method that executes on a xtd::threading::thread.

using thread_start = xtd::delegate<void()>;

Header

#include <xtd/threading/thread_start>

Namespace

xtd::threading

Library

xtd.core

wait_callback

using xtd::threading::wait_callback = typedef xtd::delegate<void(const xtd::any_object& state)>

#include <xtd.core/include/xtd/threading/wait_callback.hpp>

Represents a callback method to be executed by a thread pool thread.

using wait_callback = xtd::delegate<void(const xtd::any_object& state)>;

Parameters

state

An object containing information to be used by the callback method.

Header

#include <xtd/threading/wait_callback>

Namespace

xtd::threading

Library

xtd.core

Remarks

xtd::threading::wait_callback represents a callback method that you want to execute on a xtd::threading::thread_pool thread. Create the delegate by passing your callback method to the xtd::threading::wait_callback constructor. Your method must have the signature shown here.

Queue the method for execution by passing the xtd::threading::wait_callback delegate to xtd::threading::thread_pool::queue_user_work_item. The callback method executes when a thread pool thread becomes available.

If you want to pass information to the callback method, create an object that contains the necessary information and pass it to the xtd::threading::thread_pool::queue_user_work_item(xtd::threading::wait_callback, xtd::object&) method as the second argument. Each time the callback method executes, the state parameter contains this object.

For examples that use the xtd::threading::wait_callback delegate, see the xtd::threading::thread_pool::queue_user_work_item method.

wait_or_timer_callback

using xtd::threading::wait_or_timer_callback = typedef xtd::delegate<void(const xtd::any_object& state, bool timed_out)>

#include <xtd.core/include/xtd/threading/wait_or_timer_callback.hpp>

Represents a method to be called when a xtd::threading::wait_handle is signaled or times out.

using wait_or_timer_callback = xtd::delegate<void(const xtd::any_object& state, bool timed_out)>;

Parameters

state	An object containing information to be used by the callback method each time it executes.
timed_out	true if the xtd::threading::wait_handle timed out; false if it was signaled.

Header

#include <xtd/threading/wait_or_timer_callback>

Namespace

xtd::threading

Library

xtd.core

Remarks

xtd::threading::wait_or_timer_callback represents a callback method that you want to execute when a registered wait handle times out or is signaled. Create the delegate by passing your callback method to the xtd::threading::wait_or_timer_callback constructor. Your method must have the signature shown here.

Create the registered wait handle by passing the xtd::threading::wait_or_timer_callback delegate and a xtd::threading::wait_handle to xtd::threading::thread_pool::register_wait_for_single_object. Your callback method executes each time the xtd::threading::wait_handle times out or is signaled.

If you want to pass information to your callback method, create an object that contains the necessary information and pass it to xtd::threading::thread_pool::register_wait_for_single_object when you create the registered wait handle. Each time your callback method executes, the state parameter contains this object.

message_loop_callback

using xtd::forms::message_loop_callback = typedef xtd::delegate<bool()>

#include <xtd.forms/include/xtd/forms/message_loop_callback.hpp>

Represents a method that will check whether the hosting environment is still sending messages.

using message_loop_callback = xtd::delegate<bool()>;

Returns

true if the hosting environment is still sending messages; otherwise, false.

Header

#include <xtd/forms/message_loop_callback>

Namespace

xtd::forms

Library

xtd.forms

Remarks

This delegate is used with the application::register_message_loop method.