xtd 0.2.0
Loading...
Searching...
No Matches
Macros
keywords

Definition

Keywords are predefined, reserved identifiers that have special meanings to the compiler.

Macros

#define export_
 Define shared library export.
#define block_scope_
 The specified expression is cleared automatically when the scope is ended.
#define call_once_
 The xtd keyword call_once_ can be used to execute a routine exactly once. This can be used to initialise data in a thread-safe way.
#define core_export_
 Define shared library export.
#define delegate_
 The declaration of a delegate type is similar to a method signature. It has a return value and any number of parameters of any type.
#define enum_ut_(namespace_name, enum_t, underlying_t, ...)
 Provides the registration struct for enum with specified underlying type.
#define enum_(namespace_name, enum_t, ...)
 Provides the registration struct for enum.
#define enum_class_ut_(namespace_name, enum_class_t, underlying_t, ...)
 Provides the registration struct for enum class with specified underlying type.
#define enum_class_(namespace_name, enum_class_t, ...)
 Provides the registration struct for enum class.
#define enum_struct_ut_(namespace_name, enum_struct_t, underlying_t, ...)
 Provides the registration struct for enum with specified underlying type.
#define enum_struct_(namespace_name, enum_struct_t, ...)
 Provides the registration struct for enum struct.
#define flags_attribute_(namespace_name, enum_type)
 Provides the set attribute struct for enumerations helper.
#define foreach_(item, ...)
 The foreach_ keyword executes a statement or a block of statements for each element in an instance of the type that implements the xtd::collections::ienumerable or xtd::collections::generic::ienumerable <type_t> interfaces.
#define interface_
 This keyword is use to represent an interface.
#define lock_(object)
 The lock_ keyword marks a statement block as a critical section by obtaining the mutual-exclusion lock for a given object, executing a statement, and then releasing the lock. The following example includes a lock statement.
#define lock_guard_(object)
 The lock_guard_ keyword marks a statement block_guard as a critical section by obtaining the mutual-exclusion lock_guard for a given object, executing a statement, and then releasing the lock_guard. The following example includes a lock_guard statement.
#define nameof_(...)
 Used to obtain the simple (unqualified) string name of a variable, type, or member.
#define assembly_company_(company)
 Creates the assembly company information. Must be called once in your application.
#define assembly_configuration_(configuration)
 Creates the assembly configuration information. Must be called once in your application.
#define assembly_copyright_(copyright)
 Creates the assembly copoyright information. Must be called once in your application.
#define assembly_culture_(culture)
 Creates the assembly culture information. Must be called once in your application.
#define assembly_description_(description)
 Creates the assembly description information. Must be called once in your application.
#define assembly_file_version_(version)
 Creates the assembly file version information. Must be called once in your application.
#define assembly_guid_(guid)
 Creates the assembly guid information. Must be called once in your application.
#define assembly_identifier_(identifier)
 Creates the assembly identifier information. Must be called once in your application.
#define assembly_name_(name)
 Creates the assembly name information. Must be called once in your application.
#define assembly_product_(product)
 Creates the assembly product information. Must be called once in your application.
#define assembly_title_(title)
 Creates the assembly title information. Must be called once in your application.
#define assembly_trademark_(trademark)
 Creates the assembly trademark information. Must be called once in your application.
#define assembly_version_(version)
 Creates the assembly version information. Must be called once in your application.
#define scope_exit_
 Nowadays, every C++ developer is familiar with the Resource Acquisition Is Initialization (RAII) technique. It binds resource acquisition and release to initialization and destruction of a variable that holds the resource. There are times when writing a special class for such a variable is not worth the effort. This is when xtd scope_exit_ comes into play. scope_exit_ is always executed at the end of the scope.
#define scope_fail_
 Nowadays, every C++ developer is familiar with the Resource Acquisition Is Initialization (RAII) technique. It binds resource acquisition and release to initialization and destruction of a variable that holds the resource. There are times when writing a special class for such a variable is not worth the effort. This is when xtd scope_fail_ comes into play. scope_fail_ is executed only if an exception is in progress.
#define scope_success_
 Nowadays, every C++ developer is familiar with the Resource Acquisition Is Initialization (RAII) technique. It binds resource acquisition and release to initialization and destruction of a variable that holds the resource. There are times when writing a special class for such a variable is not worth the effort. This is when xtd scope_success_ comes into play. scope_success_ is executed only if no exception.
#define self_
 The self_ expression is a reference value expression whose value is the reference of the implicit object parameter (the object on which the non-static member function (up to C++23) implicit object member function (since C++23) is called).
#define sizeof_
 Used to obtain the size in bytes of the object representation of type or expression.
#define startup_(main_method)
 Defines the entry point to be called when the application loads. Generally this is set either to the main form in your application or to the main procedure that should run when the application starts.
#define static_
 This keyword is use to represent a static object. A static object can't be instantiated (constructors are deleted).
#define typeof_
 Used to obtain the type object of a specified type or object.
#define using_(...)
 The specified expression is cleared automatically when the scope is ended.
#define drawing_export_
 Define shared library export.
#define forms_export_
 Define shared library export.
#define tunit_export_
 Define shared library export.

Public Static Methods

static auto xtd::reflection::assembly_name_attribute::create (const string &name) -> assembly_name_attribute
 Creates the assembly name information. Must be called once in your application.

Macro Definition Documentation

◆ export_

#define export_

#include <export.hpp>

Define shared library export.

Warning
Internal use only

◆ block_scope_

#define block_scope_

#include <block_scope.hpp>

The specified expression is cleared automatically when the scope is ended.

Header
#include <xtd/block_scope>
Namespace
xtd
Library
xtd.core
Examples
// values is released automatically after the end closure }.
block_scope_(auto values = {1, 2, 3, 4, 5}) {
cout << string::join(", ", values) << endl;
}
block_scope_
#define block_scope_
The specified expression is cleared automatically when the scope is ended.
Definition block_scope.hpp:37
same as :
block_scope_(auto values = {1, 2, 3, 4, 5})
cout << string::join(", ", values) << endl;
same as :
{
auto values = {1, 2, 3, 4, 5};
cout << string::join(", ", values) << endl;
}
Remarks
same as using_
Examples
block_scope.cpp.

◆ call_once_

#define call_once_

#include <call_once.hpp>

The xtd keyword call_once_ can be used to execute a routine exactly once. This can be used to initialise data in a thread-safe way.

Namespace
xtd
Library
xtd.core
Remarks
See also xtd::call_once struct.
Examples
The following example shows how to use call_once_ keyword.
#include <xtd/xtd>
auto main() -> int {
console::write_line("(main) begin");
auto mre = manual_reset_event {};
auto thread_proc = [&] {
static auto cpt = 0;
call_once_ {
console::write_line(" (thread_proc) call once {} times", cpt + 1);
};
console::write_line(" (thread_proc) running {} times", ++cpt);
if (cpt == 3) mre.set();
};
thread_pool::register_wait_for_single_object(mre, thread_proc, {}, 100, false);
mre.wait_one();
thread::join_all();
console::write_line("(main) end");
}
// This code produces the following output :
//
// (main) begin
// (thread_proc) call once 1 times
// (thread_proc) running 1 times
// (thread_proc) running 2 times
// (thread_proc) running 3 times
// (main) end
call_once_
#define call_once_
The xtd keyword call_once_ can be used to execute a routine exactly once. This can be used to initial...
Definition call_once.hpp:50
Examples
call_once.cpp.

◆ core_export_

#define core_export_

#include <core_export.hpp>

Define shared library export.

Warning
Internal use only

◆ delegate_

#define delegate_

#include <delegate.hpp>

The declaration of a delegate type is similar to a method signature. It has a return value and any number of parameters of any type.

Namespace
xtd
Library
xtd.core
Examples
button.click += delegate_(const object& sender, const event_args& e) {
message_box::show("Button click!", "Message", message_box_buttons::ok);
};
delegate_
#define delegate_
The declaration of a delegate type is similar to a method signature. It has a return value and any nu...
Definition delegate.hpp:932
Examples
about_box.cpp, about_dialog.cpp, about_dialog_system.cpp, about_dialog_with_user_pages.cpp, application_add_message_filter.cpp, application_application_exit.cpp, application_context.cpp, application_enable_dark_mode.cpp, application_enable_light_mode.cpp, application_events.cpp, application_settings.cpp, application_settings_without_cmake_setting_commands.cpp, application_thread_exception.cpp, application_use_wait_cursor.cpp, assert_box.cpp, assert_dialog.cpp, background_worker.cpp, ball.cpp, bitmap_button.cpp, border_style.cpp, busy_box.cpp, busy_dialog.cpp, button.cpp, button2.cpp, button3.cpp, button4.cpp, button_appearance.cpp, button_renderer.cpp, change_color.cpp, change_parent.cpp, check_box.cpp, check_box_appearance.cpp, check_box_renderer.cpp, checked_list_box.cpp, clock.cpp, collapsible_panel.cpp, color_box.cpp, color_dialog.cpp, color_picker.cpp, colored_forms.cpp, colors.cpp, command_link_button.cpp, console_read_key.cpp, control.cpp, control_with_name_operator.cpp, countries.cpp, cursors.cpp, date_time_picker.cpp, debug_form.cpp, debug_message_box.cpp, debug_message_dialog.cpp, delegate_multicast.cpp, demo.cpp, dialog.cpp, domain_up_down.cpp, dot_matrix_display.cpp, emoticons.cpp, emplace.cpp, environment_cancel_signal.cpp, environment_program_exit.cpp, event.cpp, exception_box.cpp, exception_dialog.cpp, find_box.cpp, find_dialog.cpp, folder_browser_box.cpp, folder_browser_dialog.cpp, font_box.cpp, font_dialog.cpp, font_picker.cpp, form2.cpp, form_and_main.cpp, form_and_thread.cpp, form_background_image2.cpp, form_click.cpp, form_custom_event.cpp, form_decoration.cpp, form_paint.cpp, form_resize.cpp, form_show.cpp, form_show_hide.cpp, form_window_state.cpp, forms_timer.cpp, fourteen_segment_display.cpp, graph_control.cpp, h_scroll_bar.cpp, hello_world_message_box.cpp, hello_world_message_box2.cpp, hello_world_paint.cpp, hello_world_say.cpp, image_effects.cpp, image_list.cpp, images.cpp, images2.cpp, images3.cpp, input_box.cpp, input_dialog.cpp, input_dialog_multiline.cpp, input_dialog_password.cpp, key_events.cpp, lcd_label.cpp, lcd_label2.cpp, lcd_label3.cpp, lcd_label_appearance.cpp, lcd_label_with_dot_matrix.cpp, lcd_label_with_fourteen_segment.cpp, lcd_label_with_nine_segment.cpp, lcd_label_with_seven_segment.cpp, lcd_label_with_sixteen_segment.cpp, light_button.cpp, link_label.cpp, list_box.cpp, loading_indicator.cpp, message_box.cpp, message_box_appearance.cpp, message_dialog.cpp, message_dialog_show_sheet.cpp, month_calendar.cpp, mouse_events.cpp, move_form.cpp, nine_segment_display.cpp, numeric_text_box.cpp, numeric_up_down.cpp, open_file_box.cpp, open_file_dialog.cpp, painting.cpp, picture_box.cpp, popup_form.cpp, popup_panel.cpp, process_form.cpp, progress_bar.cpp, progress_box.cpp, progress_dialog.cpp, radio_button.cpp, radio_button_renderer.cpp, ranges_views.cpp, replace_box.cpp, replace_dialog.cpp, save_file_box.cpp, save_file_dialog.cpp, send_message_to_form.cpp, seven_segment_display.cpp, sixteen_segment_display.cpp, some_controls.cpp, some_system_controls.cpp, status_bar.cpp, status_bar_without_panels.cpp, switch_button.cpp, system_sound.cpp, text_box.cpp, text_box_password.cpp, text_box_password2.cpp, themes.cpp, toggle_button.cpp, tool_bar.cpp, trace_form.cpp, trace_message_box.cpp, trace_message_dialog.cpp, track_bar.cpp, track_bar2.cpp, tutorial_communicate.cpp, up_down_button.cpp, use_wait_cursor.cpp, user_dialog.cpp, user_dialog_show_sheet.cpp, v_scroll_bar.cpp, and wiggly.cpp.

◆ enum_ut_

#define enum_ut_ ( namespace_name,
enum_t,
underlying_t,
... )

#include <enum.hpp>

Provides the registration struct for enum with specified underlying type.

Header
#include <xtd/enum>
Library
xtd.core
Parameters
namespace_nameThe name of the the namespace. Empty if no namespace.
enum_typeThe name of the enum.
underlying_typeThe underying type.
...The enumeration list.
Remarks
This helper is created to facilitate to set the xtd::enum_register with the enumeration identifiers.
Warning
The helper has one limitiation :
  • The enumeration's cannot be in a class or struct. The enum must be in the global namespace or in a namespace hierarchy. If the enumeration is in a class or struct, add operators manually and use xtd::enum_register to register the enumeration identifiers.
Examples
The following code show how to use enum_ut_ helper.
#include <xtd/xtd>
enum_ut_(, enum_test, byte,
value_one,
value_two,
value_three,
value_four
);
auto main() -> int {
console::write_line("name = {}", enum_test::value_four);
console::write_line("value = {}", enum_object(enum_test::value_four).to_byte());
console::write_line("as<byte> = {}", as<byte>(enum_test::value_four));
console::write_line("values = {}", enum_object<>::get_values_as_int32<enum_test>());
console::write_line("names = {}", enum_object<>::get_names<enum_test>());
console::write_line("entries = {}", enum_object<>::get_entries_as_int32<enum_test>());
}
// This code produces the following output :
//
// name = value_four
// value = 3
// as<byte> = 3
// values = [0, 1, 2, 3]
// names = [value_one, value_two, value_three, value_four]
// entries = [(0, value_one), (1, value_two), (2, value_three), (3, value_four)]
enum_ut_
#define enum_ut_(namespace_name, enum_t, underlying_t,...)
Provides the registration struct for enum with specified underlying type.
Definition enum.hpp:31
Examples
enum_ut.cpp.

◆ enum_

#define enum_ ( namespace_name,
enum_t,
... )

#include <enum.hpp>

Provides the registration struct for enum.

Header
#include <xtd/enum>
Library
xtd.core
Parameters
namespace_nameThe name of the the namespace. Empty if no namespace.
enum_typeThe name of the enum.
...The enumeration list.
Remarks
This helper is created to facilitate to set the xtd::enum_register with the enumeration identifiers.
Warning
The helper has one limitiation :
  • The enumeration's cannot be in a class or struct. The enum must be in the global namespace or in a namespace hierarchy. If the enumeration is in a class or struct, add operators manually and use xtd::enum_register to register the enumeration identifiers.
Examples
The following code show how to use enum_ helper.
#include <xtd/xtd>
enum_(, enum_test,
value_one,
value_two,
value_three,
value_four
);
auto main() -> int {
console::write_line("name = {}", enum_test::value_four);
console::write_line("value = {}", enum_object(enum_test::value_four).to_int32());
console::write_line("as<int> = {}", as<int>(enum_test::value_four));
console::write_line("values = {}", enum_object<>::get_values_as_int32<enum_test>());
console::write_line("names = {}", enum_object<>::get_names<enum_test>());
console::write_line("entries = {}", enum_object<>::get_entries_as_int32<enum_test>());
}
// This code produces the following output :
//
// name = value_four
// value = 3
// as<int> = 3
// values = [0, 1, 2, 3]
// names = [value_one, value_two, value_three, value_four]
// entries = [(0, value_one), (1, value_two), (2, value_three), (3, value_four)]
enum_
#define enum_(namespace_name, enum_t,...)
Provides the registration struct for enum.
Definition enum.hpp:53
Examples
enum.cpp, and parse_enum.cpp.

◆ enum_class_ut_

#define enum_class_ut_ ( namespace_name,
enum_class_t,
underlying_t,
... )

#include <enum_class.hpp>

Provides the registration struct for enum class with specified underlying type.

Header
#include <xtd/enum>
Library
xtd.core
Parameters
namespace_nameThe name of the the namespace. Empty if no namespace.
enum_class_typeThe name of the enum class.
underlying_typeThe underying type.
...The enumeration list.
Remarks
This helper is created to facilitate to set the xtd::enum_register with the enumeration identifiers.
Warning
The helper has one limitiation :
  • The enumeration's cannot be in a class or struct. The enum must be in the global namespace or in a namespace hierarchy. If the enumeration is in a class or struct, add operators manually and use xtd::enum_register to register the enumeration identifiers.
Examples
The following code show how to use enum_class_ut_ helper.
#include <xtd/xtd>
enum_class_ut_(, enum_test, byte,
value_one,
value_two,
value_three,
value_four
);
auto main() -> int {
console::write_line("name = {}", enum_test::value_four);
console::write_line("value = {}", enum_object(enum_test::value_four).to_int32());
console::write_line("as<int> = {}", as<int>(enum_test::value_four));
console::write_line("values = {}", enum_object<>::get_values_as_int32<enum_test>());
console::write_line("names = {}", enum_object<>::get_names<enum_test>());
console::write_line("entries = {}", enum_object<>::get_entries_as_int32<enum_test>());
}
// This code produces the following output :
//
// name = value_four
// value = 3
// as<int> = 3
// values = [0, 1, 2, 3]
// names = [value_one, value_two, value_three, value_four]
// entries = [(0, value_one), (1, value_two), (2, value_three), (3, value_four)]
enum_class_ut_
#define enum_class_ut_(namespace_name, enum_class_t, underlying_t,...)
Provides the registration struct for enum class with specified underlying type.
Definition enum_class.hpp:30
Examples
enum_class_ut.cpp.

◆ enum_class_

#define enum_class_ ( namespace_name,
enum_class_t,
... )

#include <enum_class.hpp>

Provides the registration struct for enum class.

Header
#include <xtd/enum>
Library
xtd.core
Parameters
namespace_nameThe name of the the namespace. Empty if no namespace.
enum_class_typeThe name of the enum class.
...The enumeration list.
Remarks
This helper is created to facilitate to set the xtd::enum_register with the enumeration identifiers.
Warning
The helper has one limitiation :
  • The enumeration's cannot be in a class or struct. The enum must be in the global namespace or in a namespace hierarchy. If the enumeration is in a class or struct, add operators manually and use xtd::enum_register to register the enumeration identifiers.
Examples
The following code show how to use enum_ helper.
#include <xtd/xtd>
enum_class_(, enum_test,
value_one,
value_two,
value_three,
value_four
);
auto main() -> int {
console::write_line("name = {}", enum_test::value_four);
console::write_line("value = {}", enum_object(enum_test::value_four).to_int32());
console::write_line("as<int> = {}", as<int>(enum_test::value_four));
console::write_line("values = {}", enum_object<>::get_values_as_int32<enum_test>());
console::write_line("names = {}", enum_object<>::get_names<enum_test>());
console::write_line("entries = {}", enum_object<>::get_entries_as_int32<enum_test>());
}
// This code produces the following output :
//
// name = value_four
// value = 3
// as<int> = 3
// values = [0, 1, 2, 3]
// names = [value_one, value_two, value_three, value_four]
// entries = [(0, value_one), (1, value_two), (2, value_three), (3, value_four)]
enum_class_
#define enum_class_(namespace_name, enum_class_t,...)
Provides the registration struct for enum class.
Definition enum_class.hpp:52
Examples
enum_class.cpp, enum_class_flags.cpp, enum_class_flags_introspection.cpp, enum_class_parse.cpp, and parse_enum_class.cpp.

◆ enum_struct_ut_

#define enum_struct_ut_ ( namespace_name,
enum_struct_t,
underlying_t,
... )

#include <enum_struct.hpp>

Provides the registration struct for enum with specified underlying type.

Header
#include <xtd/enum>
Library
xtd.core
Parameters
namespace_nameThe name of the the namespace. Empty if no namespace.
enum_struct_typeThe name of the enum struct.
underlying_typeThe underying type.
...The enumeration list.
Remarks
This helper is created to facilitate to set the xtd::enum_register with the enumeration identifiers.
Warning
The helper has one limitiation :
  • The enumeration's cannot be in a class or struct. The enum must be in the global namespace or in a namespace hierarchy. If the enumeration is in a class or struct, add operators manually and use xtd::enum_register to register the enumeration identifiers.
Examples
The following code show how to use enum_struct_ut_ helper.
#include <xtd/xtd>
enum_struct_ut_(, enum_test, byte,
value_one,
value_two,
value_three,
value_four
);
auto main() -> int {
console::write_line("name = {}", enum_test::value_four);
console::write_line("value = {}", enum_object(enum_test::value_four).to_int32());
console::write_line("as<int> = {}", as<int>(enum_test::value_four));
console::write_line("values = {}", enum_object<>::get_values_as_int32<enum_test>());
console::write_line("names = {}", enum_object<>::get_names<enum_test>());
console::write_line("entries = {}", enum_object<>::get_entries_as_int32<enum_test>());
}
// This code produces the following output :
//
// name = value_four
// value = 3
// as<int> = 3
// values = [0, 1, 2, 3]
// names = [value_one, value_two, value_three, value_four]
// entries = [(0, value_one), (1, value_two), (2, value_three), (3, value_four)]
enum_struct_ut_
#define enum_struct_ut_(namespace_name, enum_struct_t, underlying_t,...)
Provides the registration struct for enum with specified underlying type.
Definition enum_struct.hpp:30
Examples
enum_struct_ut.cpp.

◆ enum_struct_

#define enum_struct_ ( namespace_name,
enum_struct_t,
... )

#include <enum_struct.hpp>

Provides the registration struct for enum struct.

Header
#include <xtd/enum>
Library
xtd.core
Parameters
namespace_nameThe name of the the namespace. Empty if no namespace.
enum_struct_typeThe name of the enum struct.
...The enumeration list.
Remarks
This helper is created to facilitate to set the xtd::enum_register with the enumeration identifiers.
Warning
The helper has one limitiation :
  • The enumeration's cannot be in a class or struct. The enum must be in the global namespace or in a namespace hierarchy. If the enumeration is in a class or struct, add operators manually and use xtd::enum_register to register the enumeration identifiers.
Examples
The following code show how to use enum_ helper.
#include <xtd/xtd>
enum_struct_(, enum_test,
value_one,
value_two,
value_three,
value_four
);
auto main() -> int {
console::write_line("name = {}", enum_test::value_four);
console::write_line("value = {}", enum_object(enum_test::value_four).to_int32());
console::write_line("as<int> = {}", as<int>(enum_test::value_four));
console::write_line("values = {}", enum_object<>::get_values_as_int32<enum_test>());
console::write_line("names = {}", enum_object<>::get_names<enum_test>());
console::write_line("entries = {}", enum_object<>::get_entries_as_int32<enum_test>());
}
// This code produces the following output :
//
// name = value_four
// value = 3
// as<int> = 3
// values = [0, 1, 2, 3]
// names = [value_one, value_two, value_three, value_four]
// entries = [(0, value_one), (1, value_two), (2, value_three), (3, value_four)]
enum_struct_
#define enum_struct_(namespace_name, enum_struct_t,...)
Provides the registration struct for enum struct.
Definition enum_struct.hpp:52
Examples
enum_struct.cpp, and parse_enum_struct.cpp.

◆ flags_attribute_

#define flags_attribute_ ( namespace_name,
enum_type )

#include <flags_attribute.hpp>

Provides the set attribute struct for enumerations helper.

Namespace
xtd
Library
xtd.core
Parameters
namespace_nameThe name of the the namespace. Empty if no namespace.
enum_typeThe name of the enum flags.
Remarks
This helper is created to facilitate to set the xtd::enum_set_attribute with the xtd::enum_attribute::flags atribute and the implementation of the following operators for enum flags:
Operator Name
^= Bitwise XOR assignment
&= Bitwise AND assignment
|= Bitwise OR assignment
+= Addition assignment
-= Subtraction assignment
Bitwise XOR
& Bitwise AND
| Bitwise OR
+ Addition
- Subtraction
~ Bitwise NOT
Warning
The helper as one limitiation :
  • The enum's flags cannot be in a class or struct. The enum must be in the global namespace or in a namespace hierarchy. If the enum flags is in a class or struct, add operators manually and use xtd::enum_set_attribute to register the xtd::enum_attribute::flags attribute.
Examples
The following code show how to use flags_attribute_ helper.
#include <xtd/xtd>
enum class text_styles {
normal = 0b0,
bold = 0b1,
italic = 0b10,
underline = 0b100,
strikeout = 0b1000,
};
// Add text_style enum class flags operators and register flags attribute.
flags_attribute_(, text_styles);
// Only this operator is needed for text_styles enum class to be recognized by xtd::string::format().
template<> struct xtd::enum_register<text_styles> {
explicit operator auto() const noexcept {return xtd::enum_collection<text_styles> {{text_styles::normal, "normal"}, {text_styles::bold, "bold"}, {text_styles::italic, "italic"}, {text_styles::underline, "underline"}, {text_styles::strikeout, "strikeout"}};}
};
enum class cap {title, middle, end};
auto print_text_styles(const string& text, text_styles value, cap c) {
if (c == cap::title)
console::out
<< "┌───────────────────────────────────────────────┬────────────┬──────────────────────────────────┐" << environment::new_line
<< "│ text_styles │ format │ representation │" << environment::new_line
<< "├───────────────────────────────────────────────┼────────────┼──────────────────────────────────┤" << environment::new_line;
console::out << "│ " << text.pad_right(45) << " │ {} │ " << format("{}", value).pad_right(32) << " │" << environment::new_line;
console::out << "│ " << text.pad_right(45) << " │ {:b} │ " << format("{:b}", value).pad_right(32) << " │" << environment::new_line;
console::out << "│ " << text.pad_right(45) << " │ {:b4} │ " << format("{:b4}", value).pad_right(32) << " │" << environment::new_line;
console::out << "│ " << text.pad_right(45) << " │ {:B} │ " << format("{:B}", value).pad_right(32) << " │" << environment::new_line;
console::out << "│ " << text.pad_right(45) << " │ {:B4} │ " << format("{:B4}", value).pad_right(32) << " │" << environment::new_line;
console::out << "│ " << text.pad_right(45) << " │ {:d} │ " << format("{:d}", value).pad_right(32) << " │" << environment::new_line;
console::out << "│ " << text.pad_right(45) << " │ {:d1} │ " << format("{:d1}", value).pad_right(32) << " │" << environment::new_line;
console::out << "│ " << text.pad_right(45) << " │ {:D} │ " << format("{:D}", value).pad_right(32) << " │" << environment::new_line;
console::out << "│ " << text.pad_right(45) << " │ {:D1} │ " << format("{:D1}", value).pad_right(32) << " │" << environment::new_line;
console::out << "│ " << text.pad_right(45) << " │ {:g} │ " << format("{:g}", value).pad_right(32) << " │" << environment::new_line;
console::out << "│ " << text.pad_right(45) << " │ {:G} │ " << format("{:G}", value).pad_right(32) << " │" << environment::new_line;
console::out << "│ " << text.pad_right(45) << " │ {:o} │ " << format("{:o}", value).pad_right(32) << " │" << environment::new_line;
console::out << "│ " << text.pad_right(45) << " │ {:o2} │ " << format("{:o2}", value).pad_right(32) << " │" << environment::new_line;
console::out << "│ " << text.pad_right(45) << " │ {:O} │ " << format("{:O}", value).pad_right(32) << " │" << environment::new_line;
console::out << "│ " << text.pad_right(45) << " │ {:O2} │ " << format("{:O2}", value).pad_right(32) << " │" << environment::new_line;
console::out << "│ " << text.pad_right(45) << " │ {:x} │ " << format("{:x}", value).pad_right(32) << " │" << environment::new_line;
console::out << "│ " << text.pad_right(45) << " │ {:x2} │ " << format("{:x2}", value).pad_right(32) << " │" << environment::new_line;
console::out << "│ " << text.pad_right(45) << " │ {:X} │ " << format("{:X}", value).pad_right(32) << " │" << environment::new_line;
console::out << "│ " << text.pad_right(45) << " │ {:X2} │ " << format("{:X2}", value).pad_right(32) << " │" << environment::new_line;
if (c != cap::end)
console::out << "├───────────────────────────────────────────────┼────────────┼──────────────────────────────────┤" << environment::new_line;
else
console::out << "└───────────────────────────────────────────────┴────────────┴──────────────────────────────────┘" << environment::new_line;
}
auto main() -> int {
print_text_styles("text_styles::normal", text_styles::normal, cap::title);
print_text_styles("text_styles::bold|text_styles::italic", text_styles::bold|text_styles::italic, cap::middle);
print_text_styles("text_styles::strikeout", text_styles::strikeout, cap::end);
}
// This code produces the following output :
//
// ┌───────────────────────────────────────────────┬────────────┬──────────────────────────────────┐
// │ text_styles │ format │ representation │
// ├───────────────────────────────────────────────┼────────────┼──────────────────────────────────┤
// │ text_styles::normal │ {} │ normal │
// │ text_styles::normal │ {:b} │ 0 │
// │ text_styles::normal │ {:b4} │ 0000 │
// │ text_styles::normal │ {:B} │ 0 │
// │ text_styles::normal │ {:B4} │ 0000 │
// │ text_styles::normal │ {:d} │ 0 │
// │ text_styles::normal │ {:d1} │ 0 │
// │ text_styles::normal │ {:D} │ 0 │
// │ text_styles::normal │ {:D1} │ 0 │
// │ text_styles::normal │ {:g} │ normal │
// │ text_styles::normal │ {:G} │ normal │
// │ text_styles::normal │ {:o} │ 0 │
// │ text_styles::normal │ {:o2} │ 00 │
// │ text_styles::normal │ {:O} │ 0 │
// │ text_styles::normal │ {:O2} │ 00 │
// │ text_styles::normal │ {:x} │ 0 │
// │ text_styles::normal │ {:x2} │ 00 │
// │ text_styles::normal │ {:X} │ 0 │
// │ text_styles::normal │ {:X2} │ 00 │
// ├───────────────────────────────────────────────┼────────────┼──────────────────────────────────┤
// │ text_styles::bold|text_styles::italic │ {} │ bold, italic │
// │ text_styles::bold|text_styles::italic │ {:b} │ 11 │
// │ text_styles::bold|text_styles::italic │ {:b4} │ 0011 │
// │ text_styles::bold|text_styles::italic │ {:B} │ 11 │
// │ text_styles::bold|text_styles::italic │ {:B4} │ 0011 │
// │ text_styles::bold|text_styles::italic │ {:d} │ 3 │
// │ text_styles::bold|text_styles::italic │ {:d1} │ 3 │
// │ text_styles::bold|text_styles::italic │ {:D} │ 3 │
// │ text_styles::bold|text_styles::italic │ {:D1} │ 3 │
// │ text_styles::bold|text_styles::italic │ {:g} │ bold, italic │
// │ text_styles::bold|text_styles::italic │ {:G} │ bold, italic │
// │ text_styles::bold|text_styles::italic │ {:o} │ 3 │
// │ text_styles::bold|text_styles::italic │ {:o2} │ 03 │
// │ text_styles::bold|text_styles::italic │ {:O} │ 3 │
// │ text_styles::bold|text_styles::italic │ {:O2} │ 03 │
// │ text_styles::bold|text_styles::italic │ {:x} │ 3 │
// │ text_styles::bold|text_styles::italic │ {:x2} │ 03 │
// │ text_styles::bold|text_styles::italic │ {:X} │ 3 │
// │ text_styles::bold|text_styles::italic │ {:X2} │ 03 │
// ├───────────────────────────────────────────────┼────────────┼──────────────────────────────────┤
// │ text_styles::strikeout │ {} │ strikeout │
// │ text_styles::strikeout │ {:b} │ 1000 │
// │ text_styles::strikeout │ {:b4} │ 1000 │
// │ text_styles::strikeout │ {:B} │ 1000 │
// │ text_styles::strikeout │ {:B4} │ 1000 │
// │ text_styles::strikeout │ {:d} │ 8 │
// │ text_styles::strikeout │ {:d1} │ 8 │
// │ text_styles::strikeout │ {:D} │ 8 │
// │ text_styles::strikeout │ {:D1} │ 8 │
// │ text_styles::strikeout │ {:g} │ strikeout │
// │ text_styles::strikeout │ {:G} │ strikeout │
// │ text_styles::strikeout │ {:o} │ 10 │
// │ text_styles::strikeout │ {:o2} │ 10 │
// │ text_styles::strikeout │ {:O} │ 10 │
// │ text_styles::strikeout │ {:O2} │ 10 │
// │ text_styles::strikeout │ {:x} │ 8 │
// │ text_styles::strikeout │ {:x2} │ 08 │
// │ text_styles::strikeout │ {:X} │ 8 │
// │ text_styles::strikeout │ {:X2} │ 08 │
// └───────────────────────────────────────────────┴────────────┴──────────────────────────────────┘
xtd::basic_string::pad_right
auto pad_right(xtd::size total_width) const noexcept -> basic_string
Left-aligns the characters in this basic_string, padding with spaces on the right for a specified tot...
Definition basic_string.hpp:658
xtd::format
xtd::string format(const xtd::string &fmt, args_t &&... args)
Writes the text representation of the specified arguments list, to string using the specified format ...
Definition format.hpp:21
flags_attribute_
#define flags_attribute_(namespace_name, enum_type)
Provides the set attribute struct for enumerations helper.
Definition flags_attribute.hpp:34
xtd::enum_collection
std::vector< std::pair< enum_t, xtd::string > > enum_collection
Represents a pair of an enum_t value and a string of an enum of type enum_t.
Definition enum_collection.hpp:24
xtd::forms::status_bar_panel_style::text
@ text
The xtd::forms::status_bar_panel displays text in the standard font.
Definition status_bar_panel_style.hpp:25
xtd::forms::mouse_buttons::middle
@ middle
he middle mouse button was pressed.
Definition mouse_buttons.hpp:30
xtd::end
const_iterator end() const
Returns an iterator to the end.
Definition read_only_span.hpp:213
xtd::enum_register
Provides the registration struct for enumerations.
Definition enum_register.hpp:38
Examples
enum_class_flags.cpp, enum_class_flags_introspection.cpp, and format_enum_class_flags.cpp.

◆ foreach_

#define foreach_ ( item,
... )

#include <foreach.hpp>

The foreach_ keyword executes a statement or a block of statements for each element in an instance of the type that implements the xtd::collections::ienumerable or xtd::collections::generic::ienumerable <type_t> interfaces.

#define foreach_(item, enumerable)
Header
#include <xtd/foreach>
Namespace
xtd
Library
xtd.core
Examples
The following example shows how to use foreach_ keyword with an xtd::collections::generic::list <type_t> of xtd::string.
foreach_(const auto& item, list<string> {"one", "two", "three", "four"})
console::write_line(item);
foreach_
#define foreach_(item,...)
The foreach_ keyword executes a statement or a block of statements for each element in an instance of...
Definition foreach.hpp:27
Remarks
break and continue statements are supported.

◆ interface_

#define interface_

#include <interface.hpp>

This keyword is use to represent an interface.

Library
xtd.core
Examples
@include <xtd/interface>
class istringable interface_ {
public:
virtual xtd::string to_string() const = 0;
};
class foo : public istringable {
public:
Foo() = default;
std:::string to_string() const override {return "foo";}
};
interface_
#define interface_
This keyword is use to represent an interface.
Definition interface.hpp:58
xtd::string
xtd::basic_string< char > string
Represents text as a sequence of UTF-8 code units.
Definition __string_definitions.hpp:43
xtd
The xtd namespace contains all fundamental classes to access Hardware, Os, System,...
Definition abstract_object.hpp:8
Examples
interface.cpp.

◆ lock_

#define lock_ ( object)

#include <lock.hpp>

The lock_ keyword marks a statement block as a critical section by obtaining the mutual-exclusion lock for a given object, executing a statement, and then releasing the lock. The following example includes a lock statement.

class account : public object {
public:
void withdraw(decimal amount) {
lock_ (balance) {
if (amount > balance)
throw exception("Insufficient funds");
balance -= amount;
}
}
private:
decimal balance;
};
lock_
#define lock_(object)
The lock_ keyword marks a statement block as a critical section by obtaining the mutual-exclusion loc...
Definition lock.hpp:68
xtd::decimal
long double decimal
Represents a decimal-precision floating-point number.
Definition decimal.hpp:23

For more information, see Thread Synchronization.

Namespace
xtd
Library
xtd.core
Remarks
The lock_ keyword ensures that one thread does not enter a critical section of code while another thread is in the critical section. If another thread tries to enter a locked code, it will wait, block, until the object is released.
The section Threading discusses threading.
The lock_ keyword calls Enter at the start of the block and Exit at the end of the block. A xtd::threading::thread_interrupted_exception is thrown if xtd::threading::thread::interrupt interrupts a thread that is waiting to enter a lock statement.
In general, avoid locking on a public type, or instances beyond your code's control. The common constructs lock_ (*this), lock_ (typeof_<my_type>()), and lock_ ("myLock") violate this guideline:
  • lock_ (*this) is a problem if the instance can be accessed publicly.
  • lock_ (typeof_<my_type>()) is a problem if my_type is publicly accessible.
  • lock_ ("my_lock") is a problem because any other code in the process using the same string, will share the same lock.
Best practice is to define a private object to lock on, or a private static object variable to protect data common to all instances.
You can't use the await_ keyword in the body of a lock_ statement.
Examples
The following sample shows a simple use of threads without locking in C++.
#include <xtd/xtd>
using namespace xtd;
using namespace xtd::rhreading;
class thread_test {
public:
void run_me() {
console::write_line("run_me called");
}
static void main() {
thread_test b;
auto t = thread {thread_start {b, &thread_test::run_me));
t.start();
}
};
startup_(thread_test::main)
// Output: run_me called
xtd::console::write_line
static void write_line()
Writes the current line terminator to the standard output stream using the specified format informati...
startup_
#define startup_(main_method)
Defines the entry point to be called when the application loads. Generally this is set either to the ...
Definition startup.hpp:284
Examples
The following sample uses threads and lock_. As long as the lock statement is present, the statement block is a critical section and balance will never become a negative number.
Examples
lock.cpp, monitor_lock.cpp, monitor_pulse.cpp, and monitor_pulse_all.cpp.

◆ lock_guard_

#define lock_guard_ ( object)

#include <lock_guard.hpp>

The lock_guard_ keyword marks a statement block_guard as a critical section by obtaining the mutual-exclusion lock_guard for a given object, executing a statement, and then releasing the lock_guard. The following example includes a lock_guard statement.

class account : public object {
public:
void withdraw(decimal amount) {
lock_guard_ (balance) {
if (amount > balance)
throw exception("Insufficient funds");
balance -= amount;
}
}
private:
decimal balance;
};
lock_guard_
#define lock_guard_(object)
The lock_guard_ keyword marks a statement block_guard as a critical section by obtaining the mutual-e...
Definition lock_guard.hpp:65

For more information, see Thread Synchronization.

Namespace
xtd
Library
xtd.core
Remarks
The lock_guard_ keyword ensures that one thread does not enter a critical section of code while another thread is in the critical section. If another thread tries to enter a lock_guarded code, it will wait, block_guard, until the object is released.
The section Threading discusses threading.
The lock_guard_ keyword calls Enter at the start of the block_guard and Exit at the end of the block_guard. A xtd::threading::thread_interrupted_exception is thrown if xtd::threading::thread::interrupt interrupts a thread that is waiting to enter a lock_guard statement.
In general, avoid lock_guarding on a public type, or instances beyond your code's control. The common constructs lock_guard_ (*this), lock_guard_ (typeof_<my_type>()), and lock_guard_ ("myLock") violate this guideline:
  • lock_guard_ (*this) is a problem if the instance can be accessed publicly.
  • lock_guard_ (typeof_<my_type>()) is a problem if my_type is publicly accessible.
  • lock_guard_ ("my_lock_guard") is a problem because any other code in the process using the same string, will share the same lock_guard.
Best practice is to define a private object to lock_guard on, or a private static object variable to protect data common to all instances.
You can't use the await_ keyword in the body of a lock_guard_ statement.
Examples
The following sample shows a simple use of threads without lock_guarding in C++.
#include <xtd/xtd>
class thread_test {
public:
void run_me() {
console::write_line("run_me called");
}
static void main() {
thread_test b;
auto t = thread {thread_start {b, &thread_test::run_me));
t.start();
}
};
startup_(thread_test::main)
// Output: run_me called
Examples
The following sample uses threads and lock_guard_. As long as the lock_guard statement is present, the statement block_guard is a critical section and balance will never become a negative number.
#include <xtd/xtd>
namespace examples {
class account : public object {
public:
explicit account(int initial) : balance(initial) {}
void do_transactions() {
for (auto i = 0; i < 100; ++i)
withdraw(random.next(1, 100));
}
private:
int withdraw(int amount) {
// This condition never is true unless the lock statement is commented out.
if (balance < 0) throw system_exception {"Negative Balance"};
// Comment out the next line to see the effect of leaving out the lock keyword.
lock_guard_(balance) {
if (balance < amount) return 0;
console::write_line("Balance before Withdrawal : {0}", balance);
console::write_line("Amount to Withdraw : -{0}", amount);
balance = balance - amount;
console::write_line("Balance after Withdrawal : {0}", balance);
return amount;
}
return 0;
}
int balance = 0;
xtd::random random;
};
class program {
public:
static void main() {
auto account = examples::account {1000};
for (auto i = 0; i < 10; ++i)
thread_pool::queue_user_work_item({account, &account::do_transactions});
thread_pool::close();
}
};
}
startup_(examples::program::main);
// This code can produce the following output :
//
// Balance before Withdrawal : 1000
// Amount to Withdraw : -75
// Balance after Withdrawal : 925
// Balance before Withdrawal : 925
// Amount to Withdraw : -84
// Balance after Withdrawal : 841
// Balance before Withdrawal : 841
// Amount to Withdraw : -69
// Balance after Withdrawal : 772
// Balance before Withdrawal : 772
// Amount to Withdraw : -71
// Balance after Withdrawal : 701
// Balance before Withdrawal : 701
// Amount to Withdraw : -84
// Balance after Withdrawal : 617
// Balance before Withdrawal : 617
// Amount to Withdraw : -81
// Balance after Withdrawal : 536
// Balance before Withdrawal : 536
// Amount to Withdraw : -15
// Balance after Withdrawal : 521
// Balance before Withdrawal : 521
// Amount to Withdraw : -93
// Balance after Withdrawal : 428
// Balance before Withdrawal : 428
// Amount to Withdraw : -6
// Balance after Withdrawal : 422
// Balance before Withdrawal : 422
// Amount to Withdraw : -54
// Balance after Withdrawal : 368
// Balance before Withdrawal : 368
// Amount to Withdraw : -52
// Balance after Withdrawal : 316
// Balance before Withdrawal : 316
// Amount to Withdraw : -67
// Balance after Withdrawal : 249
// Balance before Withdrawal : 249
// Amount to Withdraw : -93
// Balance after Withdrawal : 156
// Balance before Withdrawal : 156
// Amount to Withdraw : -60
// Balance after Withdrawal : 96
// Balance before Withdrawal : 96
// Amount to Withdraw : -7
// Balance after Withdrawal : 89
// Balance before Withdrawal : 89
// Amount to Withdraw : -42
// Balance after Withdrawal : 47
// Balance before Withdrawal : 47
// Amount to Withdraw : -1
// Balance after Withdrawal : 46
// Balance before Withdrawal : 46
// Amount to Withdraw : -22
// Balance after Withdrawal : 24
// Balance before Withdrawal : 24
// Amount to Withdraw : -18
// Balance after Withdrawal : 6
// Balance before Withdrawal : 6
// Amount to Withdraw : -2
// Balance after Withdrawal : 4
// Balance before Withdrawal : 4
// Amount to Withdraw : -2
// Balance after Withdrawal : 2
// Balance before Withdrawal : 2
// Amount to Withdraw : -2
// Balance after Withdrawal : 0
xtd::console_key::i
@ i
The I key.
Definition console_key.hpp:104
Examples
lock_guard_keyword.cpp.

◆ nameof_

#define nameof_ ( ...)

#include <nameof.hpp>

Used to obtain the simple (unqualified) string name of a variable, type, or member.

Namespace
xtd
Library
xtd.core

When reporting errors in code, hooking up model-view-controller (MVC) links, firing property changed events, etc., you often want to capture the string name of a method. Using nameof helps keep your code valid when renaming definitions. Before, you had to use string literals to refer to definitions, which is brittle when renaming code elements because tools do not know to check these string literals.

A nameof expression has this form:

if (x == null) throw std::argument_error(nameof_(x));
write_line(nameof_(person.address().zip_code())); // prints "person.address().zip_code()"
nameof_
#define nameof_(...)
Used to obtain the simple (unqualified) string name of a variable, type, or member.
Definition nameof.hpp:34
Examples
Some C++ examples:
#include <xtd/xtd>
template<typename value_t>
void print_names(value_t value) {
auto the_answer_to_life_the_universe_and_everything = value;
console::write_line("{}", nameof_(print_names));
console::write_line("{}", nameof_(value_t));
console::write_line("{} is {}", nameof_(the_answer_to_life_the_universe_and_everything), the_answer_to_life_the_universe_and_everything);
console::write_line("{} = {}", nameof_((124 + 26) / 2), (124 + 26) / 2);
}
auto main() -> int {
print_names(42);
}
// This code produces the following output :
//
// print_names
// value_t
// the_answer_to_life_the_universe_and_everything is 42
// (124 + 26) / 2 = 75
Remarks
The argument to nameof must be a simple name, qualified name, member access, base access with a specified member, or this access with a specified member. The argument expression identifies a code definition, but it is never evaluated.
Because the argument needs to be an expression syntactically, there are many things disallowed that are not useful to list. The following are worth mentioning that produce errors: predefined types (for example, int or void), nullable types (Point?), array types (Customer[,]), pointer types (Buffer*), qualified alias (A::B), and unbound generic types (Dictionary<,>), preprocessing symbols (DEBUG), and labels (loop:).
If you need to get the fully-qualified name, you can use the typeof_ expression along with nameof. For example:
class c {
public:
void f(int i) {
log(xtd::string::format("{0}::{1}", typeof_<c>(), nameof_(f)), "method entry");
}
}
xtd::basic_string< char >::format
static auto format(const basic_string< char > &fmt, args_t &&... args) -> basic_string
typeof_
#define typeof_
Used to obtain the type object of a specified type or object.
Definition typeof.hpp:24
Examples
nameof.cpp.

◆ assembly_company_

#define assembly_company_ ( company)

#include <assembly_company_attribute.hpp>

Creates the assembly company information. Must be called once in your application.

Remarks
Use this keyword if you create create assembly informations manually.
Use CMake assembly macro if you want create assembly informations with CMake scripts.
Parameters
companyThe company information.
Header
#include <xtd/reflection/assembly_company_attribute>
Library
xtd.core
Examples
The following example shows how to use assembly information manually.
#include <xtd/xtd>
class form1 : public form {
public:
static auto main() {
application::run(form1 {});
}
form1() {
text("Form with manual assembly info");
controls().add_range({company, product, version, company_name, product_name, product_version});
client_size({350, 105});
company.auto_size(true);
company.text("Company name");
company.location({10, 10});
company.text_align(content_alignment::middle_left);
product.auto_size(true);
product.text("Product name");
product.location({10, 40});
product.text_align(content_alignment::middle_left);
version.auto_size(true);
version.text("Product version");
version.location({10, 70});
version.text_align(content_alignment::middle_left);
company_name.text(application::company_name());
company_name.read_only(true);
company_name.location({120, 10});
company_name.width(220);
product_name.text(application::product_name());
product_name.read_only(true);
product_name.location({120, 40});
product_name.width(220);
product_version.text(application::product_version());
product_version.read_only(true);
product_version.location({120, 70});
product_version.width(220);
}
private:
label company;
label product;
label version;
text_box company_name;
text_box product_name;
text_box product_version;
};
startup_(form1::main);
xtd::drawing::known_color::text_box
@ text_box
The system-defined color of the accent color (macos specific. On other platform is same as window).
Definition known_color.hpp:501
xtd::forms::style_sheets::label
xtd::forms::style_sheets::control label
The label data allows you to specify the box of a label control.
Definition label.hpp:25
#pragma region xtd generated code
// This code was generated by CMake script.
//
// Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
// Remarks : If this file was manually created, you need re-run cmake generator after creating
// or modifying any parameter bellow.
#include <xtd/reflection/assembly_info>
// Information about this assembly is defined by the following attributes.
// Change them to the values specific to your project.
assembly_title_("Forms with manual assembly information");
assembly_description_("This example shows how to use xtd assembly informations");
assembly_configuration_("Debug");
assembly_company_("Gammasoft");
assembly_product_("form_with_manual_assembly_info");
assembly_copyright_("Copyright © Gammasoft 2024");
assembly_trademark_("");
assembly_culture_("");
// The following GUID is for the ID of the typelib if this project is exposed to COM
// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
// In not specify or empty or "*" the cmake project version is used.
assembly_version_("1.0.0");
#pragma endregion
assembly_product_
#define assembly_product_(product)
Creates the assembly product information. Must be called once in your application.
Definition assembly_product_attribute.hpp:103
assembly_title_
#define assembly_title_(title)
Creates the assembly title information. Must be called once in your application.
Definition assembly_title_attribute.hpp:103
assembly_description_
#define assembly_description_(description)
Creates the assembly description information. Must be called once in your application.
Definition assembly_description_attribute.hpp:107
assembly_culture_
#define assembly_culture_(culture)
Creates the assembly culture information. Must be called once in your application.
Definition assembly_culture_attribute.hpp:103
assembly_version_
#define assembly_version_(version)
Creates the assembly version information. Must be called once in your application.
Definition assembly_version_attribute.hpp:108
assembly_trademark_
#define assembly_trademark_(trademark)
Creates the assembly trademark information. Must be called once in your application.
Definition assembly_trademark_attribute.hpp:101
assembly_company_
#define assembly_company_(company)
Creates the assembly company information. Must be called once in your application.
Definition assembly_company_attribute.hpp:103
assembly_configuration_
#define assembly_configuration_(configuration)
Creates the assembly configuration information. Must be called once in your application.
Definition assembly_configuration_attribute.hpp:103
assembly_copyright_
#define assembly_copyright_(copyright)
Creates the assembly copoyright information. Must be called once in your application.
Definition assembly_copyright_attribute.hpp:103

◆ assembly_configuration_

#define assembly_configuration_ ( configuration)

#include <assembly_configuration_attribute.hpp>

Creates the assembly configuration information. Must be called once in your application.

Remarks
Use this keyword if you create create assembly informations manually.
Use CMake assembly macro if you want create assembly informations with CMake scripts.
Parameters
configurationThe configuration information.
Header
#include <xtd/reflection/assembly_configuration_attribute>
Library
xtd.core
Examples
The following example shows how to use assembly information manually.
#include <xtd/xtd>
class form1 : public form {
public:
static auto main() {
application::run(form1 {});
}
form1() {
text("Form with manual assembly info");
controls().add_range({company, product, version, company_name, product_name, product_version});
client_size({350, 105});
company.auto_size(true);
company.text("Company name");
company.location({10, 10});
company.text_align(content_alignment::middle_left);
product.auto_size(true);
product.text("Product name");
product.location({10, 40});
product.text_align(content_alignment::middle_left);
version.auto_size(true);
version.text("Product version");
version.location({10, 70});
version.text_align(content_alignment::middle_left);
company_name.text(application::company_name());
company_name.read_only(true);
company_name.location({120, 10});
company_name.width(220);
product_name.text(application::product_name());
product_name.read_only(true);
product_name.location({120, 40});
product_name.width(220);
product_version.text(application::product_version());
product_version.read_only(true);
product_version.location({120, 70});
product_version.width(220);
}
private:
label company;
label product;
label version;
text_box company_name;
text_box product_name;
text_box product_version;
};
startup_(form1::main);
#pragma region xtd generated code
// This code was generated by CMake script.
//
// Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
// Remarks : If this file was manually created, you need re-run cmake generator after creating
// or modifying any parameter bellow.
#include <xtd/reflection/assembly_info>
// Information about this assembly is defined by the following attributes.
// Change them to the values specific to your project.
assembly_title_("Forms with manual assembly information");
assembly_description_("This example shows how to use xtd assembly informations");
assembly_configuration_("Debug");
assembly_company_("Gammasoft");
assembly_product_("form_with_manual_assembly_info");
assembly_copyright_("Copyright © Gammasoft 2024");
assembly_trademark_("");
assembly_culture_("");
// The following GUID is for the ID of the typelib if this project is exposed to COM
// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
// In not specify or empty or "*" the cmake project version is used.
assembly_version_("1.0.0");
#pragma endregion

◆ assembly_copyright_

#define assembly_copyright_ ( copyright)

#include <assembly_copyright_attribute.hpp>

Creates the assembly copoyright information. Must be called once in your application.

Remarks
Use this keyword if you create create assembly informations manually.
Use CMake assembly macro if you want create assembly informations with CMake scripts.
Parameters
copyrightThe copyright information.
Header
#include <xtd/reflection/assembly_copyright_attribute>
Library
xtd.core
Examples
The following example shows how to use assembly information manually.
#include <xtd/xtd>
class form1 : public form {
public:
static auto main() {
application::run(form1 {});
}
form1() {
text("Form with manual assembly info");
controls().add_range({company, product, version, company_name, product_name, product_version});
client_size({350, 105});
company.auto_size(true);
company.text("Company name");
company.location({10, 10});
company.text_align(content_alignment::middle_left);
product.auto_size(true);
product.text("Product name");
product.location({10, 40});
product.text_align(content_alignment::middle_left);
version.auto_size(true);
version.text("Product version");
version.location({10, 70});
version.text_align(content_alignment::middle_left);
company_name.text(application::company_name());
company_name.read_only(true);
company_name.location({120, 10});
company_name.width(220);
product_name.text(application::product_name());
product_name.read_only(true);
product_name.location({120, 40});
product_name.width(220);
product_version.text(application::product_version());
product_version.read_only(true);
product_version.location({120, 70});
product_version.width(220);
}
private:
label company;
label product;
label version;
text_box company_name;
text_box product_name;
text_box product_version;
};
startup_(form1::main);
#pragma region xtd generated code
// This code was generated by CMake script.
//
// Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
// Remarks : If this file was manually created, you need re-run cmake generator after creating
// or modifying any parameter bellow.
#include <xtd/reflection/assembly_info>
// Information about this assembly is defined by the following attributes.
// Change them to the values specific to your project.
assembly_title_("Forms with manual assembly information");
assembly_description_("This example shows how to use xtd assembly informations");
assembly_configuration_("Debug");
assembly_company_("Gammasoft");
assembly_product_("form_with_manual_assembly_info");
assembly_copyright_("Copyright © Gammasoft 2024");
assembly_trademark_("");
assembly_culture_("");
// The following GUID is for the ID of the typelib if this project is exposed to COM
// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
// In not specify or empty or "*" the cmake project version is used.
assembly_version_("1.0.0");
#pragma endregion

◆ assembly_culture_

#define assembly_culture_ ( culture)

#include <assembly_culture_attribute.hpp>

Creates the assembly culture information. Must be called once in your application.

Remarks
Use this keyword if you create create assembly informations manually.
Use CMake assembly macro if you want create assembly informations with CMake scripts.
Parameters
cultureThe culture information.
Header
#include <xtd/reflection/assembly_culture_attribute>
Library
xtd.core
Examples
The following example shows how to use assembly information manually.
#include <xtd/xtd>
class form1 : public form {
public:
static auto main() {
application::run(form1 {});
}
form1() {
text("Form with manual assembly info");
controls().add_range({company, product, version, company_name, product_name, product_version});
client_size({350, 105});
company.auto_size(true);
company.text("Company name");
company.location({10, 10});
company.text_align(content_alignment::middle_left);
product.auto_size(true);
product.text("Product name");
product.location({10, 40});
product.text_align(content_alignment::middle_left);
version.auto_size(true);
version.text("Product version");
version.location({10, 70});
version.text_align(content_alignment::middle_left);
company_name.text(application::company_name());
company_name.read_only(true);
company_name.location({120, 10});
company_name.width(220);
product_name.text(application::product_name());
product_name.read_only(true);
product_name.location({120, 40});
product_name.width(220);
product_version.text(application::product_version());
product_version.read_only(true);
product_version.location({120, 70});
product_version.width(220);
}
private:
label company;
label product;
label version;
text_box company_name;
text_box product_name;
text_box product_version;
};
startup_(form1::main);
#pragma region xtd generated code
// This code was generated by CMake script.
//
// Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
// Remarks : If this file was manually created, you need re-run cmake generator after creating
// or modifying any parameter bellow.
#include <xtd/reflection/assembly_info>
// Information about this assembly is defined by the following attributes.
// Change them to the values specific to your project.
assembly_title_("Forms with manual assembly information");
assembly_description_("This example shows how to use xtd assembly informations");
assembly_configuration_("Debug");
assembly_company_("Gammasoft");
assembly_product_("form_with_manual_assembly_info");
assembly_copyright_("Copyright © Gammasoft 2024");
assembly_trademark_("");
assembly_culture_("");
// The following GUID is for the ID of the typelib if this project is exposed to COM
// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
// In not specify or empty or "*" the cmake project version is used.
assembly_version_("1.0.0");
#pragma endregion

◆ assembly_description_

#define assembly_description_ ( description)

#include <assembly_description_attribute.hpp>

Creates the assembly description information. Must be called once in your application.

Remarks
Use this keyword if you create create assembly informations manually.
Use CMake assembly macro if you want create assembly informations with CMake scripts.
Parameters
descriptionThe description information.
Header
#include <xtd/reflection/assembly_description_attribute>
Library
xtd.core
Examples
The following example shows how to use assembly information manually.
#include <xtd/xtd>
class form1 : public form {
public:
static auto main() {
application::run(form1 {});
}
form1() {
text("Form with manual assembly info");
controls().add_range({company, product, version, company_name, product_name, product_version});
client_size({350, 105});
company.auto_size(true);
company.text("Company name");
company.location({10, 10});
company.text_align(content_alignment::middle_left);
product.auto_size(true);
product.text("Product name");
product.location({10, 40});
product.text_align(content_alignment::middle_left);
version.auto_size(true);
version.text("Product version");
version.location({10, 70});
version.text_align(content_alignment::middle_left);
company_name.text(application::company_name());
company_name.read_only(true);
company_name.location({120, 10});
company_name.width(220);
product_name.text(application::product_name());
product_name.read_only(true);
product_name.location({120, 40});
product_name.width(220);
product_version.text(application::product_version());
product_version.read_only(true);
product_version.location({120, 70});
product_version.width(220);
}
private:
label company;
label product;
label version;
text_box company_name;
text_box product_name;
text_box product_version;
};
startup_(form1::main);
#pragma region xtd generated code
// This code was generated by CMake script.
//
// Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
// Remarks : If this file was manually created, you need re-run cmake generator after creating
// or modifying any parameter bellow.
#include <xtd/reflection/assembly_info>
// Information about this assembly is defined by the following attributes.
// Change them to the values specific to your project.
assembly_title_("Forms with manual assembly information");
assembly_description_("This example shows how to use xtd assembly informations");
assembly_configuration_("Debug");
assembly_company_("Gammasoft");
assembly_product_("form_with_manual_assembly_info");
assembly_copyright_("Copyright © Gammasoft 2024");
assembly_trademark_("");
assembly_culture_("");
// The following GUID is for the ID of the typelib if this project is exposed to COM
// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
// In not specify or empty or "*" the cmake project version is used.
assembly_version_("1.0.0");
#pragma endregion

◆ assembly_file_version_

#define assembly_file_version_ ( version)

#include <assembly_file_version_attribute.hpp>

Creates the assembly file version information. Must be called once in your application.

Remarks
Use this keyword if you create create assembly informations manually.
Use CMake assembly macro if you want create assembly informations with CMake scripts.
Parameters
versionThe file version information.
Header
#include <xtd/reflection/assembly_file_version_attribute>
Library
xtd.core
Examples
The following example shows how to use assembly information manually.
#include <xtd/xtd>
class form1 : public form {
public:
static auto main() {
application::run(form1 {});
}
form1() {
text("Form with manual assembly info");
controls().add_range({company, product, version, company_name, product_name, product_version});
client_size({350, 105});
company.auto_size(true);
company.text("Company name");
company.location({10, 10});
company.text_align(content_alignment::middle_left);
product.auto_size(true);
product.text("Product name");
product.location({10, 40});
product.text_align(content_alignment::middle_left);
version.auto_size(true);
version.text("Product version");
version.location({10, 70});
version.text_align(content_alignment::middle_left);
company_name.text(application::company_name());
company_name.read_only(true);
company_name.location({120, 10});
company_name.width(220);
product_name.text(application::product_name());
product_name.read_only(true);
product_name.location({120, 40});
product_name.width(220);
product_version.text(application::product_version());
product_version.read_only(true);
product_version.location({120, 70});
product_version.width(220);
}
private:
label company;
label product;
label version;
text_box company_name;
text_box product_name;
text_box product_version;
};
startup_(form1::main);
#pragma region xtd generated code
// This code was generated by CMake script.
//
// Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
// Remarks : If this file was manually created, you need re-run cmake generator after creating
// or modifying any parameter bellow.
#include <xtd/reflection/assembly_info>
// Information about this assembly is defined by the following attributes.
// Change them to the values specific to your project.
assembly_title_("Forms with manual assembly information");
assembly_description_("This example shows how to use xtd assembly informations");
assembly_configuration_("Debug");
assembly_company_("Gammasoft");
assembly_product_("form_with_manual_assembly_info");
assembly_copyright_("Copyright © Gammasoft 2024");
assembly_trademark_("");
assembly_culture_("");
// The following GUID is for the ID of the typelib if this project is exposed to COM
// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
// In not specify or empty or "*" the cmake project version is used.
assembly_version_("1.0.0");
#pragma endregion

◆ assembly_guid_

#define assembly_guid_ ( guid)

#include <assembly_guid_attribute.hpp>

Creates the assembly guid information. Must be called once in your application.

Remarks
Use this keyword if you create create assembly informations manually.
Use CMake assembly macro if you want create assembly informations with CMake scripts.
Parameters
guidThe guid information.
Header
#include <xtd/reflection/assembly_guid_attribute>
Library
xtd.core
Examples
The following example shows how to use assembly information manually.
#include <xtd/xtd>
class form1 : public form {
public:
static auto main() {
application::run(form1 {});
}
form1() {
text("Form with manual assembly info");
controls().add_range({company, product, version, company_name, product_name, product_version});
client_size({350, 105});
company.auto_size(true);
company.text("Company name");
company.location({10, 10});
company.text_align(content_alignment::middle_left);
product.auto_size(true);
product.text("Product name");
product.location({10, 40});
product.text_align(content_alignment::middle_left);
version.auto_size(true);
version.text("Product version");
version.location({10, 70});
version.text_align(content_alignment::middle_left);
company_name.text(application::company_name());
company_name.read_only(true);
company_name.location({120, 10});
company_name.width(220);
product_name.text(application::product_name());
product_name.read_only(true);
product_name.location({120, 40});
product_name.width(220);
product_version.text(application::product_version());
product_version.read_only(true);
product_version.location({120, 70});
product_version.width(220);
}
private:
label company;
label product;
label version;
text_box company_name;
text_box product_name;
text_box product_version;
};
startup_(form1::main);
#pragma region xtd generated code
// This code was generated by CMake script.
//
// Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
// Remarks : If this file was manually created, you need re-run cmake generator after creating
// or modifying any parameter bellow.
#include <xtd/reflection/assembly_info>
// Information about this assembly is defined by the following attributes.
// Change them to the values specific to your project.
assembly_title_("Forms with manual assembly information");
assembly_description_("This example shows how to use xtd assembly informations");
assembly_configuration_("Debug");
assembly_company_("Gammasoft");
assembly_product_("form_with_manual_assembly_info");
assembly_copyright_("Copyright © Gammasoft 2024");
assembly_trademark_("");
assembly_culture_("");
// The following GUID is for the ID of the typelib if this project is exposed to COM
// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
// In not specify or empty or "*" the cmake project version is used.
assembly_version_("1.0.0");
#pragma endregion

◆ assembly_identifier_

#define assembly_identifier_ ( identifier)

#include <assembly_identifier_attribute.hpp>

Creates the assembly identifier information. Must be called once in your application.

Remarks
Use this keyword if you create create assembly informations manually.
Use CMake assembly macro if you want create assembly informations with CMake scripts.
Parameters
identifierThe identifier information.
Header
#include <xtd/reflection/assembly_identifier_attribute>
Library
xtd.core
Examples
The following example shows how to use assembly information manually.
#include <xtd/xtd>
class form1 : public form {
public:
static auto main() {
application::run(form1 {});
}
form1() {
text("Form with manual assembly info");
controls().add_range({company, product, version, company_name, product_name, product_version});
client_size({350, 105});
company.auto_size(true);
company.text("Company name");
company.location({10, 10});
company.text_align(content_alignment::middle_left);
product.auto_size(true);
product.text("Product name");
product.location({10, 40});
product.text_align(content_alignment::middle_left);
version.auto_size(true);
version.text("Product version");
version.location({10, 70});
version.text_align(content_alignment::middle_left);
company_name.text(application::company_name());
company_name.read_only(true);
company_name.location({120, 10});
company_name.width(220);
product_name.text(application::product_name());
product_name.read_only(true);
product_name.location({120, 40});
product_name.width(220);
product_version.text(application::product_version());
product_version.read_only(true);
product_version.location({120, 70});
product_version.width(220);
}
private:
label company;
label product;
label version;
text_box company_name;
text_box product_name;
text_box product_version;
};
startup_(form1::main);
#pragma region xtd generated code
// This code was generated by CMake script.
//
// Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
// Remarks : If this file was manually created, you need re-run cmake generator after creating
// or modifying any parameter bellow.
#include <xtd/reflection/assembly_info>
// Information about this assembly is defined by the following attributes.
// Change them to the values specific to your project.
assembly_title_("Forms with manual assembly information");
assembly_description_("This example shows how to use xtd assembly informations");
assembly_configuration_("Debug");
assembly_company_("Gammasoft");
assembly_product_("form_with_manual_assembly_info");
assembly_copyright_("Copyright © Gammasoft 2024");
assembly_trademark_("");
assembly_culture_("");
// The following GUID is for the ID of the typelib if this project is exposed to COM
// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
// In not specify or empty or "*" the cmake project version is used.
assembly_version_("1.0.0");
#pragma endregion

◆ assembly_name_

#define assembly_name_ ( name)

#include <assembly_name_attribute.hpp>

Creates the assembly name information. Must be called once in your application.

Remarks
Use this keyword if you create create assembly informations manually.
Use CMake assembly macro if you want create assembly informations with CMake scripts.
Parameters
nameThe name information.
Header
#include <xtd/reflection/assembly_name_attribute>
Library
xtd.core
Examples
The following example shows how to use assembly information manually.
#include <xtd/xtd>
class form1 : public form {
public:
static auto main() {
application::run(form1 {});
}
form1() {
text("Form with manual assembly info");
controls().add_range({company, product, version, company_name, product_name, product_version});
client_size({350, 105});
company.auto_size(true);
company.text("Company name");
company.location({10, 10});
company.text_align(content_alignment::middle_left);
product.auto_size(true);
product.text("Product name");
product.location({10, 40});
product.text_align(content_alignment::middle_left);
version.auto_size(true);
version.text("Product version");
version.location({10, 70});
version.text_align(content_alignment::middle_left);
company_name.text(application::company_name());
company_name.read_only(true);
company_name.location({120, 10});
company_name.width(220);
product_name.text(application::product_name());
product_name.read_only(true);
product_name.location({120, 40});
product_name.width(220);
product_version.text(application::product_version());
product_version.read_only(true);
product_version.location({120, 70});
product_version.width(220);
}
private:
label company;
label product;
label version;
text_box company_name;
text_box product_name;
text_box product_version;
};
startup_(form1::main);
#pragma region xtd generated code
// This code was generated by CMake script.
//
// Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
// Remarks : If this file was manually created, you need re-run cmake generator after creating
// or modifying any parameter bellow.
#include <xtd/reflection/assembly_info>
// Information about this assembly is defined by the following attributes.
// Change them to the values specific to your project.
assembly_title_("Forms with manual assembly information");
assembly_description_("This example shows how to use xtd assembly informations");
assembly_configuration_("Debug");
assembly_company_("Gammasoft");
assembly_product_("form_with_manual_assembly_info");
assembly_copyright_("Copyright © Gammasoft 2024");
assembly_trademark_("");
assembly_culture_("");
// The following GUID is for the ID of the typelib if this project is exposed to COM
// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
// In not specify or empty or "*" the cmake project version is used.
assembly_version_("1.0.0");
#pragma endregion

◆ assembly_product_

#define assembly_product_ ( product)

#include <assembly_product_attribute.hpp>

Creates the assembly product information. Must be called once in your application.

Remarks
Use this keyword if you create create assembly informations manually.
Use CMake assembly macro if you want create assembly informations with CMake scripts.
Parameters
productThe product information.
Header
#include <xtd/reflection/assembly_product_attribute>
Library
xtd.core
Examples
The following example shows how to use assembly information manually.
#include <xtd/xtd>
class form1 : public form {
public:
static auto main() {
application::run(form1 {});
}
form1() {
text("Form with manual assembly info");
controls().add_range({company, product, version, company_name, product_name, product_version});
client_size({350, 105});
company.auto_size(true);
company.text("Company name");
company.location({10, 10});
company.text_align(content_alignment::middle_left);
product.auto_size(true);
product.text("Product name");
product.location({10, 40});
product.text_align(content_alignment::middle_left);
version.auto_size(true);
version.text("Product version");
version.location({10, 70});
version.text_align(content_alignment::middle_left);
company_name.text(application::company_name());
company_name.read_only(true);
company_name.location({120, 10});
company_name.width(220);
product_name.text(application::product_name());
product_name.read_only(true);
product_name.location({120, 40});
product_name.width(220);
product_version.text(application::product_version());
product_version.read_only(true);
product_version.location({120, 70});
product_version.width(220);
}
private:
label company;
label product;
label version;
text_box company_name;
text_box product_name;
text_box product_version;
};
startup_(form1::main);
#pragma region xtd generated code
// This code was generated by CMake script.
//
// Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
// Remarks : If this file was manually created, you need re-run cmake generator after creating
// or modifying any parameter bellow.
#include <xtd/reflection/assembly_info>
// Information about this assembly is defined by the following attributes.
// Change them to the values specific to your project.
assembly_title_("Forms with manual assembly information");
assembly_description_("This example shows how to use xtd assembly informations");
assembly_configuration_("Debug");
assembly_company_("Gammasoft");
assembly_product_("form_with_manual_assembly_info");
assembly_copyright_("Copyright © Gammasoft 2024");
assembly_trademark_("");
assembly_culture_("");
// The following GUID is for the ID of the typelib if this project is exposed to COM
// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
// In not specify or empty or "*" the cmake project version is used.
assembly_version_("1.0.0");
#pragma endregion

◆ assembly_title_

#define assembly_title_ ( title)

#include <assembly_title_attribute.hpp>

Creates the assembly title information. Must be called once in your application.

Remarks
Use this keyword if you create create assembly informations manually.
Use CMake assembly macro if you want create assembly informations with CMake scripts.
Parameters
titleThe title information.
Header
#include <xtd/reflection/assembly_title_attribute>
Library
xtd.core
Examples
The following example shows how to use assembly information manually.
#include <xtd/xtd>
class form1 : public form {
public:
static auto main() {
application::run(form1 {});
}
form1() {
text("Form with manual assembly info");
controls().add_range({company, product, version, company_name, product_name, product_version});
client_size({350, 105});
company.auto_size(true);
company.text("Company name");
company.location({10, 10});
company.text_align(content_alignment::middle_left);
product.auto_size(true);
product.text("Product name");
product.location({10, 40});
product.text_align(content_alignment::middle_left);
version.auto_size(true);
version.text("Product version");
version.location({10, 70});
version.text_align(content_alignment::middle_left);
company_name.text(application::company_name());
company_name.read_only(true);
company_name.location({120, 10});
company_name.width(220);
product_name.text(application::product_name());
product_name.read_only(true);
product_name.location({120, 40});
product_name.width(220);
product_version.text(application::product_version());
product_version.read_only(true);
product_version.location({120, 70});
product_version.width(220);
}
private:
label company;
label product;
label version;
text_box company_name;
text_box product_name;
text_box product_version;
};
startup_(form1::main);
#pragma region xtd generated code
// This code was generated by CMake script.
//
// Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
// Remarks : If this file was manually created, you need re-run cmake generator after creating
// or modifying any parameter bellow.
#include <xtd/reflection/assembly_info>
// Information about this assembly is defined by the following attributes.
// Change them to the values specific to your project.
assembly_title_("Forms with manual assembly information");
assembly_description_("This example shows how to use xtd assembly informations");
assembly_configuration_("Debug");
assembly_company_("Gammasoft");
assembly_product_("form_with_manual_assembly_info");
assembly_copyright_("Copyright © Gammasoft 2024");
assembly_trademark_("");
assembly_culture_("");
// The following GUID is for the ID of the typelib if this project is exposed to COM
// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
// In not specify or empty or "*" the cmake project version is used.
assembly_version_("1.0.0");
#pragma endregion

◆ assembly_trademark_

#define assembly_trademark_ ( trademark)

#include <assembly_trademark_attribute.hpp>

Creates the assembly trademark information. Must be called once in your application.

Remarks
Use this keyword if you create create assembly informations manually.
Use CMake assembly macro if you want create assembly informations with CMake scripts.
Parameters
trademarkThe trademark information.
Header
#include <xtd/reflection/assembly_trademark_attribute>
Library
xtd.core
Examples
The following example shows how to use assembly information manually.
#include <xtd/xtd>
class form1 : public form {
public:
static auto main() {
application::run(form1 {});
}
form1() {
text("Form with manual assembly info");
controls().add_range({company, product, version, company_name, product_name, product_version});
client_size({350, 105});
company.auto_size(true);
company.text("Company name");
company.location({10, 10});
company.text_align(content_alignment::middle_left);
product.auto_size(true);
product.text("Product name");
product.location({10, 40});
product.text_align(content_alignment::middle_left);
version.auto_size(true);
version.text("Product version");
version.location({10, 70});
version.text_align(content_alignment::middle_left);
company_name.text(application::company_name());
company_name.read_only(true);
company_name.location({120, 10});
company_name.width(220);
product_name.text(application::product_name());
product_name.read_only(true);
product_name.location({120, 40});
product_name.width(220);
product_version.text(application::product_version());
product_version.read_only(true);
product_version.location({120, 70});
product_version.width(220);
}
private:
label company;
label product;
label version;
text_box company_name;
text_box product_name;
text_box product_version;
};
startup_(form1::main);
#pragma region xtd generated code
// This code was generated by CMake script.
//
// Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
// Remarks : If this file was manually created, you need re-run cmake generator after creating
// or modifying any parameter bellow.
#include <xtd/reflection/assembly_info>
// Information about this assembly is defined by the following attributes.
// Change them to the values specific to your project.
assembly_title_("Forms with manual assembly information");
assembly_description_("This example shows how to use xtd assembly informations");
assembly_configuration_("Debug");
assembly_company_("Gammasoft");
assembly_product_("form_with_manual_assembly_info");
assembly_copyright_("Copyright © Gammasoft 2024");
assembly_trademark_("");
assembly_culture_("");
// The following GUID is for the ID of the typelib if this project is exposed to COM
// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
// In not specify or empty or "*" the cmake project version is used.
assembly_version_("1.0.0");
#pragma endregion

◆ assembly_version_

#define assembly_version_ ( version)

#include <assembly_version_attribute.hpp>

Creates the assembly version information. Must be called once in your application.

Remarks
Use this keyword if you create create assembly informations manually.
Use CMake assembly macro if you want create assembly informations with CMake scripts.
Parameters
versionThe version information.
Header
#include <xtd/reflection/assembly_version_attribute>
Library
xtd.core
Examples
The following example shows how to use assembly information manually.
#include <xtd/xtd>
class form1 : public form {
public:
static auto main() {
application::run(form1 {});
}
form1() {
text("Form with manual assembly info");
controls().add_range({company, product, version, company_name, product_name, product_version});
client_size({350, 105});
company.auto_size(true);
company.text("Company name");
company.location({10, 10});
company.text_align(content_alignment::middle_left);
product.auto_size(true);
product.text("Product name");
product.location({10, 40});
product.text_align(content_alignment::middle_left);
version.auto_size(true);
version.text("Product version");
version.location({10, 70});
version.text_align(content_alignment::middle_left);
company_name.text(application::company_name());
company_name.read_only(true);
company_name.location({120, 10});
company_name.width(220);
product_name.text(application::product_name());
product_name.read_only(true);
product_name.location({120, 40});
product_name.width(220);
product_version.text(application::product_version());
product_version.read_only(true);
product_version.location({120, 70});
product_version.width(220);
}
private:
label company;
label product;
label version;
text_box company_name;
text_box product_name;
text_box product_version;
};
startup_(form1::main);
#pragma region xtd generated code
// This code was generated by CMake script.
//
// Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
// Remarks : If this file was manually created, you need re-run cmake generator after creating
// or modifying any parameter bellow.
#include <xtd/reflection/assembly_info>
// Information about this assembly is defined by the following attributes.
// Change them to the values specific to your project.
assembly_title_("Forms with manual assembly information");
assembly_description_("This example shows how to use xtd assembly informations");
assembly_configuration_("Debug");
assembly_company_("Gammasoft");
assembly_product_("form_with_manual_assembly_info");
assembly_copyright_("Copyright © Gammasoft 2024");
assembly_trademark_("");
assembly_culture_("");
// The following GUID is for the ID of the typelib if this project is exposed to COM
// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
// In not specify or empty or "*" the cmake project version is used.
assembly_version_("1.0.0");
#pragma endregion

◆ scope_exit_

#define scope_exit_

#include <scope_exit.hpp>

Nowadays, every C++ developer is familiar with the Resource Acquisition Is Initialization (RAII) technique. It binds resource acquisition and release to initialization and destruction of a variable that holds the resource. There are times when writing a special class for such a variable is not worth the effort. This is when xtd scope_exit_ comes into play. scope_exit_ is always executed at the end of the scope.

Namespace
xtd
Library
xtd.core
Remarks
xtd::scope_exit, xtd::scope_success_ and xtd::scope_fail are themselves RAII utilities.
They are designed to make scope-based cleanup and control flow more concise and expressive.
See also xtd::scope_exit struct.
#include <xtd/xtd>
auto main() -> int {
try {
scope_exit_ {
console::write_line("always (scope_exit)");
};
scope_success_ {
console::write_line("only on success (scope_success)");
};
scope_fail_ {
console::write_line("only on failure (scope_fail)");
};
console::write_line("begin");
// ...
console::write_line("do something...");
// Remove the comment from the following line to test failure
//throw invalid_operation_exception {};
// ...
console::write_line("end normally");
} catch (...) {
console::write_line("caught exception!");
}
}
// This code produces the following output if success :
//
// begin
// do something...
// end normally
// only on success (scope_success)
// always (scope_exit)
// This code produces the following output if throws exception :
//
// begin
// do something...
// only on failure (scope_fail)
// always (scope_exit)
// caught exception!
scope_exit_
#define scope_exit_
Nowadays, every C++ developer is familiar with the Resource Acquisition Is Initialization (RAII) tech...
Definition scope_exit.hpp:128
scope_success_
#define scope_success_
Nowadays, every C++ developer is familiar with the Resource Acquisition Is Initialization (RAII) tech...
Definition scope_success.hpp:128
scope_fail_
#define scope_fail_
Nowadays, every C++ developer is familiar with the Resource Acquisition Is Initialization (RAII) tech...
Definition scope_fail.hpp:128

◆ scope_fail_

#define scope_fail_

#include <scope_fail.hpp>

Nowadays, every C++ developer is familiar with the Resource Acquisition Is Initialization (RAII) technique. It binds resource acquisition and release to initialization and destruction of a variable that holds the resource. There are times when writing a special class for such a variable is not worth the effort. This is when xtd scope_fail_ comes into play. scope_fail_ is executed only if an exception is in progress.

Namespace
xtd
Library
xtd.core
Remarks
scope_exit_, scope_success_ and scope_fail_ are themselves RAII utilities.
They are designed to make scope-based cleanup and control flow more concise and expressive.
See also xtd::scope_fail struct.
#include <xtd/xtd>
auto main() -> int {
try {
scope_exit_ {
console::write_line("always (scope_exit)");
};
scope_success_ {
console::write_line("only on success (scope_success)");
};
scope_fail_ {
console::write_line("only on failure (scope_fail)");
};
console::write_line("begin");
// ...
console::write_line("do something...");
// Remove the comment from the following line to test failure
//throw invalid_operation_exception {};
// ...
console::write_line("end normally");
} catch (...) {
console::write_line("caught exception!");
}
}
// This code produces the following output if success :
//
// begin
// do something...
// end normally
// only on success (scope_success)
// always (scope_exit)
// This code produces the following output if throws exception :
//
// begin
// do something...
// only on failure (scope_fail)
// always (scope_exit)
// caught exception!

◆ scope_success_

#define scope_success_

#include <scope_success.hpp>

Nowadays, every C++ developer is familiar with the Resource Acquisition Is Initialization (RAII) technique. It binds resource acquisition and release to initialization and destruction of a variable that holds the resource. There are times when writing a special class for such a variable is not worth the effort. This is when xtd scope_success_ comes into play. scope_success_ is executed only if no exception.

Namespace
xtd
Library
xtd.core
Remarks
scope_exit_, scope_success_ and scope_fail_ are themselves RAII utilities.
They are designed to make scope-based cleanup and control flow more concise and expressive.
See also xtd::scope_success struct.
#include <xtd/xtd>
auto main() -> int {
try {
scope_exit_ {
console::write_line("always (scope_exit)");
};
scope_success_ {
console::write_line("only on success (scope_success)");
};
scope_fail_ {
console::write_line("only on failure (scope_fail)");
};
console::write_line("begin");
// ...
console::write_line("do something...");
// Remove the comment from the following line to test failure
//throw invalid_operation_exception {};
// ...
console::write_line("end normally");
} catch (...) {
console::write_line("caught exception!");
}
}
// This code produces the following output if success :
//
// begin
// do something...
// end normally
// only on success (scope_success)
// always (scope_exit)
// This code produces the following output if throws exception :
//
// begin
// do something...
// only on failure (scope_fail)
// always (scope_exit)
// caught exception!

◆ self_

#define self_

#include <self.hpp>

The self_ expression is a reference value expression whose value is the reference of the implicit object parameter (the object on which the non-static member function (up to C++23) implicit object member function (since C++23) is called).

Namespace
xtd
Library
xtd.core
Remarks
self_ is equivalent to *this.
Examples
The following example shows how to use the self_ keyword
#include <xtd/xtd>
struct coordinate : public istringable<coordinate> {
int x = 0;
int y = 0;
coordinate() noexcept = default;
coordinate(int x, int y) noexcept : x {x}, y {y} {}
coordinate& translate(int x, int y) noexcept {
self_.x += x;
self_.y += y;
return self_;
}
string to_string() const noexcept override {return string::format("{{x={}, y={}}}", x, y);}
};
auto main()->int {
auto c = coordinate {200, 100};
println("c => {}", c);
println("translate");
c.translate(50, 20);
println("c => {}", c);
}
// This code can produce the following output :
//
// c => {x=200, y=100}
// translate
// c => {x=250, y=120}
self_
#define self_
The self_ expression is a reference value expression whose value is the reference of the implicit obj...
Definition self.hpp:20
xtd::console_key::y
@ y
The Y key.
Definition console_key.hpp:136
xtd::console_key::c
@ c
The C key.
Definition console_key.hpp:92
xtd::console_key::x
@ x
The X key.
Definition console_key.hpp:134
xtd::println
void println(FILE *file)
Writes the current line terminator to the file output stream using the specified format information.
Definition println.hpp:14
xtd::to_string
string to_string() const noexcept override
Returns the string representation of this xtd::read_only_span <type_t> object.
Definition read_only_span.hpp:375
Examples
application_add_message_filter.cpp, application_idle.cpp, application_thread_exception.cpp, assert_dialog.cpp, busy_box.cpp, busy_dialog.cpp, color_box.cpp, color_dialog.cpp, enable_changed_event.cpp, forms_timer.cpp, list_box.cpp, panel.cpp, self.cpp, split_container.cpp, and texts.cpp.

◆ sizeof_

#define sizeof_

#include <sizeof.hpp>

Used to obtain the size in bytes of the object representation of type or expression.

Namespace
xtd
Library
xtd.core
Examples
// Get the size of a type :
xtd::size size1 = sizeof_<int>();
int i = 42;
// Get the size of an object :
xtd::size size2 = sizeof_(i);
sizeof_
#define sizeof_
Used to obtain the size in bytes of the object representation of type or expression.
Definition sizeof.hpp:23
xtd::size
size_t size
Represents a size of any object in bytes.
Definition size.hpp:23
Remarks
The sizeof_ operator cannot be overloaded.
Examples
sizeof.cpp.

◆ startup_

#define startup_ ( main_method)

#include <startup.hpp>

Defines the entry point to be called when the application loads. Generally this is set either to the main form in your application or to the main procedure that should run when the application starts.

Namespace
xtd
Library
xtd.core
Parameters
main_methodThe main method.
Implementation
auto main() -> int {
return xtd::startup::safe_run(main_method);
}
xtd::startup::safe_run
static int safe_run(main_function_t main_function)
Safely call the specified application's main entry point.
Definition startup.hpp:50
Examples
This example show a main method without arguments and without return code
#include <xtd/xtd>
namespace main1_example {
class program {
public:
static void main() {
// Write arguments to the console output
for (auto arg : environment::get_command_line_args())
console::write_line(arg);
// return 42
environment::exit_code(42);
}
};
}
startup_(main1_example::program::main);
// Is the same as :
//
// auto main() -> int {
// return startup::safe_run(main1_example::program::main);
// }
// This code produces the following output if one two "three four" five are entered on command line:
//
// /!---OMITTED---!/main1
// one
// two
// three four
// five
This example show a main method with a return code and without arguments
#include <xtd/xtd>
namespace main2_example {
class program {
public:
static int main() {
// Write arguments to the console output
for (auto arg : environment::get_command_line_args())
console::write_line(arg);
return 42;
}
};
}
startup_(main2_example::program::main);
// Is the same as :
//
// auto main() -> int {
// return startup::safe_run(main2_example::program::main);
// }
// This code produces the following output if one two "three four" five are entered on command line:
//
// /!---OMITTED---!/main2
// one
// two
// three four
// five
This example show a main method with argument and without return code
#include <xtd/xtd>
namespace main3_example {
class program {
public:
static void main(const argument_collection& args) {
// Write arguments to the console output
for (auto arg : args)
console::write_line(arg);
// return 42
environment::exit_code(42);
}
};
}
startup_(main3_example::program::main);
// Is the same as :
//
// auto main() -> int {
// return startup::safe_run(main3_example::program::main);
// }
// This code produces the following output if one two "three four" five are entered on command line:
//
// one
// two
// three four
// five
This example show a main method with argument and return code
#include <xtd/xtd>
namespace main4_example {
class program {
public:
static int main(const argument_collection& args) {
// Write arguments to the console output
for (auto arg : args)
console::write_line(arg);
return 42;
}
};
}
startup_(main4_example::program::main);
// Is the same as :
//
// auto main() -> int {
// return startup::safe_run(main4_example::program::main);
// }
// This code produces the following output if one two "three four" five are entered on command line:
//
// one
// two
// three four
// five
Examples
application_and_assert.cpp, application_and_exception.cpp, application_enable_dark_mode.cpp, application_enable_light_mode.cpp, application_thread_exception.cpp, application_with_cmake_assembly_info.cpp, application_with_manual_assembly_info.cpp, auto_reset_event.cpp, background_worker.cpp, barrier.cpp, barrier_simple.cpp, binary_reader.cpp, binary_reader2.cpp, binary_reader3.cpp, bit_array.cpp, bit_converter_endianness.cpp, bit_converter_is_big_endian.cpp, bit_converter_is_little_endian.cpp, bit_converter_round_trips.cpp, border_style.cpp, calculator.cpp, change_parent.cpp, console_clear.cpp, console_firework.cpp, countdown_event.cpp, countries.cpp, date_time.cpp, date_time_add.cpp, date_time_add_days.cpp, date_time_add_hours.cpp, date_time_add_milliseconds.cpp, date_time_add_minutes.cpp, date_time_add_months.cpp, date_time_add_seconds.cpp, date_time_add_years.cpp, date_time_date.cpp, date_time_day_of_week.cpp, date_time_day_of_year.cpp, date_time_days_in_month.cpp, date_time_days_in_month2.cpp, date_time_max_value.cpp, date_time_min_value.cpp, date_time_now.cpp, date_time_now2.cpp, date_time_specify_kind.cpp, date_time_sprintf.cpp, date_time_subtract.cpp, date_time_ticks.cpp, date_time_ticks2.cpp, date_time_time_of_day.cpp, date_time_to_string_format.cpp, date_time_today.cpp, debug_message_box.cpp, default_trace_listener.cpp, drive_info.cpp, environment_cancel_signal.cpp, environment_exit.cpp, environment_exit_code.cpp, environment_program_exit.cpp, event_wait_handle.cpp, file_info.cpp, file_info_append_text.cpp, file_info_move_to.cpp, file_info_open.cpp, file_info_open_read.cpp, file_info_open_text.cpp, file_info_open_write.cpp, file_info_replace.cpp, form_and_main.cpp, form_background_image.cpp, form_show.cpp, generic_dictionary.cpp, generic_dictionary_constructor_with_idicationary.cpp, generic_hash_set.cpp, generic_hash_set2.cpp, generic_icollection.cpp, generic_ienumerable.cpp, generic_ienumerable2.cpp, generic_ienumerable3.cpp, generic_ilist.cpp, generic_linked_list.cpp, generic_linked_list_node.cpp, generic_list.cpp, generic_list2.cpp, generic_list3.cpp, generic_list4.cpp, generic_list_as_read_only.cpp, generic_list_binary_search.cpp, generic_list_convert_all.cpp, generic_list_exists.cpp, generic_list_for_each.cpp, generic_list_reverse.cpp, generic_ordered_dictionary.cpp, generic_queue.cpp, graph_control.cpp, horizontal_layout_panel.cpp, ienumerable.cpp, ienumerator.cpp, ilist.cpp, image_effects.cpp, interlocked.cpp, interlocked_decrement.cpp, ip_address.cpp, lcd_label3.cpp, lock.cpp, lock_guard.cpp, lock_guard_keyword.cpp, main.cpp, main1.cpp, main2.cpp, main3.cpp, main4.cpp, manual_reset_event.cpp, math.cpp, mixing_std_and_xtd_threads.cpp, monitor.cpp, monitor_lock.cpp, monitor_pulse.cpp, monitor_pulse_all.cpp, mutex.cpp, read_only_collection.cpp, semaphore.cpp, send_message_to_form.cpp, some_controls.cpp, some_system_controls.cpp, specialized_ordered_dictionary.cpp, stack_trace.cpp, system_sound.cpp, system_sounds.cpp, target_default_namespace.cpp, test_console.cpp, test_forms.cpp, themes.cpp, thread.cpp, thread_pool.cpp, time_span.cpp, timeout.cpp, timer.cpp, timers_timer.cpp, timers_timer_synchronizing_object.cpp, trace_message_box.cpp, track_bar2.cpp, tutorial_application_icon.cpp, tutorial_button.cpp, tutorial_communicate.cpp, tutorial_simple_application.cpp, uri.cpp, using_xtd_tunit_assert_without_tunit_app.cpp, version.cpp, version_os.cpp, vertical_layout_panel.cpp, and wait_handle.cpp.

◆ static_

#define static_

#include <static.hpp>

This keyword is use to represent a static object. A static object can't be instantiated (constructors are deleted).

Namespace
xtd
Library
xtd.core
Examples
class foo static_ {
public:
static xtd::string to_string() {return "foo";}
};
static_
#define static_
This keyword is use to represent a static object. A static object can't be instantiated (constructors...
Definition static.hpp:38
Examples
console_firework.cpp, environment_cancel_signal.cpp, environment_program_exit.cpp, and static.cpp.

◆ typeof_

#define typeof_

#include <typeof.hpp>

Used to obtain the type object of a specified type or object.

Returns
THe xtd::type_object that represent the type or the object.
Namespace
xtd
Library
xtd.core
Examples
// Get the type object of a type :
xtd::type_object type1 = typeof_<int>();
int i = 42;
// Get the type object of an object :
xtd::type_object type2 = typeof_(i);
xtd::type_object
Represents type declarations: class types, interface types, array types, value types,...
Definition type_object.hpp:37
Remarks
The typeof_ operator cannot be overloaded.
Examples
any.cpp, any_info.cpp, array_list2.cpp, boxed_info.cpp, file_info_move_to.cpp, iclonable.cpp, object_get_type.cpp, and typeof.cpp.

◆ using_

#define using_ ( ...)

#include <using.hpp>

The specified expression is cleared automatically when the scope is ended.

Header
#include <xtd/using>
Namespace
xtd
Library
xtd.core
Examples
// values is released automatically after the end closure }.
using_(auto values = {1, 2, 3, 4, 5}) {
cout << string::join(", ", values) << endl;
}
using_
#define using_(...)
The specified expression is cleared automatically when the scope is ended.
Definition using.hpp:36
same as :
using_(auto values = {1, 2, 3, 4, 5})
cout << string::join(", ", values) << endl;
same as :
{
auto values = {1, 2, 3, 4, 5};
cout << string::join(", ", values) << endl;
}
Remarks
same as block_scope_
Examples
binary_reader.cpp, binary_reader2.cpp, binary_reader3.cpp, file_info.cpp, file_info_append_text.cpp, file_info_open.cpp, file_info_open_read.cpp, file_info_open_text.cpp, file_info_open_write.cpp, jthread.cpp, lock_guard.cpp, process.cpp, and using.cpp.

◆ drawing_export_

#define drawing_export_

#include <drawing_export.hpp>

Define shared library export.

Warning
Internal use only

◆ forms_export_

#define forms_export_

#include <forms_export.hpp>

Define shared library export.

Warning
Internal use only

◆ tunit_export_

#define tunit_export_

#include <tunit_export.hpp>

Define shared library export.

Warning
Internal use only

Function Documentation

◆ create()

auto xtd::reflection::assembly_name_attribute::create ( const string & name) -> assembly_name_attribute
static

#include <assembly_name_attribute.hpp>

Creates the assembly name information. Must be called once in your application.

Remarks
Use this keyword if you create create assembly informations manually.
Use CMake assembly macro if you want create assembly informations with CMake scripts.
Parameters
nameThe name information.
Header
#include <xtd/reflection/assembly_name_attribute>
Library
xtd.core
Examples
The following example shows how to use assembly information manually.
#include <xtd/xtd>
class form1 : public form {
public:
static auto main() {
application::run(form1 {});
}
form1() {
text("Form with manual assembly info");
controls().add_range({company, product, version, company_name, product_name, product_version});
client_size({350, 105});
company.auto_size(true);
company.text("Company name");
company.location({10, 10});
company.text_align(content_alignment::middle_left);
product.auto_size(true);
product.text("Product name");
product.location({10, 40});
product.text_align(content_alignment::middle_left);
version.auto_size(true);
version.text("Product version");
version.location({10, 70});
version.text_align(content_alignment::middle_left);
company_name.text(application::company_name());
company_name.read_only(true);
company_name.location({120, 10});
company_name.width(220);
product_name.text(application::product_name());
product_name.read_only(true);
product_name.location({120, 40});
product_name.width(220);
product_version.text(application::product_version());
product_version.read_only(true);
product_version.location({120, 70});
product_version.width(220);
}
private:
label company;
label product;
label version;
text_box company_name;
text_box product_name;
text_box product_version;
};
startup_(form1::main);
xtd::version
Represents the version number of an assembly, operating system, or the xtd. This class cannot be inhe...
Definition version.hpp:115
xtd::text
Contains classes that represent ASCII and Unicode character encodings; abstract base classes for conv...
Definition basic_string_builder.hpp:17
#pragma region xtd generated code
// This code was generated by CMake script.
//
// Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
// Remarks : If this file was manually created, you need re-run cmake generator after creating
// or modifying any parameter bellow.
#include <xtd/reflection/assembly_info>
// Information about this assembly is defined by the following attributes.
// Change them to the values specific to your project.
assembly_title_("Forms with manual assembly information");
assembly_description_("This example shows how to use xtd assembly informations");
assembly_configuration_("Debug");
assembly_company_("Gammasoft");
assembly_product_("form_with_manual_assembly_info");
assembly_copyright_("Copyright © Gammasoft 2024");
assembly_trademark_("");
assembly_culture_("");
// The following GUID is for the ID of the typelib if this project is exposed to COM
// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
// In not specify or empty or "*" the cmake project version is used.
assembly_version_("1.0.0");
#pragma endregion
Generated on for xtd by Gammasoft. All rights reserved.