diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/CMakeLists.txt b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/CMakeLists.txt index 7906fe7ab838..427c1811078b 100644 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/CMakeLists.txt +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/CMakeLists.txt @@ -1,14 +1,5 @@ -cmake_minimum_required (VERSION 2.8.6) - -if(CMAKE_MAJOR_VERSION LESS 3) - project(CoSimIO CXX C) -else() - if(POLICY CMP0048) - # project command manages version - cmake_policy(SET CMP0048 NEW) - endif(POLICY CMP0048) - project(CoSimIO LANGUAGES CXX C VERSION 3.0.0) -endif() +cmake_minimum_required (VERSION 3.15.0) +project(CoSimIO LANGUAGES CXX C VERSION 3.0.0) # this has to be specified BEFORE including CTest! # suppressions file has to be included in the options, as using "MEMORYCHECK_SUPPRESSIONS_FILE" doesn't work on all systems @@ -36,7 +27,7 @@ endif() set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DCO_SIM_IO_DEBUG") -message("Building the CoSimIO with the following configuration:") +message("Building CoSimIO with the following configuration:") message(" CO_SIM_IO_BUILD_TYPE: " ${CO_SIM_IO_BUILD_TYPE}) message(" CO_SIM_IO_BUILD_MPI: " ${CO_SIM_IO_BUILD_MPI}) message(" CO_SIM_IO_BUILD_TESTING: " ${CO_SIM_IO_BUILD_TESTING}) @@ -85,7 +76,7 @@ if(MSVC) endif() elseif(${CMAKE_COMPILER_IS_GNUCXX}) - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c89") if (CO_SIM_IO_STRICT_COMPILER) @@ -101,7 +92,7 @@ elseif(${CMAKE_COMPILER_IS_GNUCXX}) # Note: This command makes sure that this option comes pretty late on the cmdline. link_libraries("$<$,$,7.0>,$,9.0>>:-lstdc++fs>") elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang") - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c89") if (CO_SIM_IO_STRICT_COMPILER) @@ -110,7 +101,7 @@ elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang") endif() elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel") - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c89") if (CO_SIM_IO_STRICT_COMPILER) @@ -119,7 +110,7 @@ elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel") endif() else() - set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -Wall -Wpedantic") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall -Wpedantic") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c89 -Wall -Wpedantic") endif() @@ -147,7 +138,7 @@ include(GenerateExportHeader) generate_export_header( co_sim_io EXPORT_MACRO_NAME CO_SIM_IO_API EXPORT_FILE_NAME ${CMAKE_CURRENT_SOURCE_DIR}/co_sim_io/includes/co_sim_io_api.hpp ) -install(TARGETS co_sim_io DESTINATION libs) +install(TARGETS co_sim_io DESTINATION bin) if (CO_SIM_IO_BUILD_MPI) # optionally enable communication via MPI @@ -166,7 +157,7 @@ if (CO_SIM_IO_BUILD_MPI) target_link_libraries(co_sim_io_mpi co_sim_io ${MPI_LIBRARIES}) - install(TARGETS co_sim_io_mpi DESTINATION libs) + install(TARGETS co_sim_io_mpi DESTINATION bin) endif() target_include_directories(co_sim_io PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/co_sim_io) diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/README.md b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/README.md index 2053b948b7b8..a01708c41835 100644 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/README.md +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/README.md @@ -31,6 +31,7 @@ The [changelog](https://github.com/KratosMultiphysics/CoSimIO/blob/master/CHANGE Besides the native C++ interface, the _CoSimIO_ also provides interfaces to other languages. Currently the following languages are supported: - C - Python +- Fortran These interfaces are implemented as consistent as possible with the C++ interface. @@ -46,6 +47,9 @@ The C interface is defined in [co_sim_io_c.h](https://github.com/KratosMultiphys ### **Python** The Python interface is defined in [_CoSimIO_ python module](https://github.com/KratosMultiphysics/CoSimIO/blob/master/co_sim_io/python/co_sim_io_python.cpp). The [pybind library](https://github.com/pybind/pybind11) is used for the Python exposure of the C++ interface. +### **Fortran** +The Fortran interface is defined in [co_sim_io.f90](https://github.com/KratosMultiphysics/CoSimIO/blob/master/co_sim_io/fortran/co_sim_io.f90). In addition to including this file it is required to compile _CoSimIO_ into a shared library and link against it. + ## Parallelism The _CoSimIO_ supports pure sequential and mpi-parallel executions. Shared memory parallelism is currently not planned but might be added at a later stage. diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/CMakeLists.txt b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/CMakeLists.txt new file mode 100644 index 000000000000..557ddfca60bf --- /dev/null +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/CMakeLists.txt @@ -0,0 +1,23 @@ +if(WIN32) + # To enable WINDOWS_EXPORT_ALL_SYMBOLS to automatically + # add export decorators for all classes, structs and functions + # see https://cmake.org/cmake/help/latest/prop_tgt/WINDOWS_EXPORT_ALL_SYMBOLS.html#prop_tgt:WINDOWS_EXPORT_ALL_SYMBOLS + cmake_minimum_required(VERSION 3.4) +endif(WIN32) + +message("Configuring CoSimIO for C") + +add_library (co_sim_io_c SHARED co_sim_io_c.cpp) +set_target_properties(co_sim_io_c PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON) + +target_link_libraries( co_sim_io_c co_sim_io ) + +install(TARGETS co_sim_io_c DESTINATION bin) + +if (CO_SIM_IO_BUILD_MPI) + add_library (co_sim_io_c_mpi SHARED co_sim_io_c_mpi.cpp) + + target_link_libraries(co_sim_io_c_mpi co_sim_io_c co_sim_io_mpi) + + install(TARGETS co_sim_io_c_mpi DESTINATION bin) +endif() diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/co_sim_io_c.cpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/co_sim_io_c.cpp new file mode 100644 index 000000000000..ae664a812934 --- /dev/null +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/co_sim_io_c.cpp @@ -0,0 +1,475 @@ +// ______ _____ _ ________ +// / ____/___ / ___/(_)___ ___ / _/ __ | +// / / / __ \\__ \/ / __ `__ \ / // / / / +// / /___/ /_/ /__/ / / / / / / // // /_/ / +// \____/\____/____/_/_/ /_/ /_/___/\____/ +// Kratos CoSimulationApplication +// +// License: BSD License, see license.txt +// +// Main authors: Philipp Bucher (https://github.com/philbucher) +// + +// Project includes +extern "C" { +#include "co_sim_io_c.h" +} +#include "co_sim_io.hpp" +#include "includes/connection.hpp" +#include "includes/data_container.hpp" +#include "includes/utilities.hpp" + +namespace { + // get C Info from C++ Info + CoSimIO_Info ConvertInfo(CoSimIO::Info I_Info) { + CoSimIO_Info info; + info.PtrCppInfo = new CoSimIO::Info(I_Info); + return info; + } + + // get C++ Info from C Info + CoSimIO::Info ConvertInfo(CoSimIO_Info I_Info) { + return CoSimIO::Info(*(static_cast(I_Info.PtrCppInfo))); + } +} + + +CoSimIO_Info CoSimIO_Hello() +{ + return ConvertInfo(CoSimIO::Hello()); +} + +CoSimIO_Info CoSimIO_Connect(const CoSimIO_Info I_Settings) +{ + return ConvertInfo(CoSimIO::Connect(ConvertInfo(I_Settings))); +} + +CoSimIO_Info CoSimIO_Disconnect(const CoSimIO_Info I_Info) +{ + return ConvertInfo(CoSimIO::Disconnect(ConvertInfo(I_Info))); +} + +CoSimIO_Info CoSimIO_ImportData( + const CoSimIO_Info I_Info, + int* O_Size, + double** O_Data) +{ + using namespace CoSimIO::Internals; + std::unique_ptr> p_container(new DataContainerRawMemory(O_Data, *O_Size)); + auto info = ConvertInfo(CoSimIO::ImportData(ConvertInfo(I_Info), *p_container)); + *O_Size = static_cast(p_container->size()); + return info; +} + +CoSimIO_Info CoSimIO_ExportData( + const CoSimIO_Info I_Info, + const int I_Size, + const double* I_Data) +{ + using namespace CoSimIO::Internals; + std::unique_ptr> p_container(new DataContainerRawMemoryReadOnly(I_Data, I_Size)); + return ConvertInfo(CoSimIO::ExportData(ConvertInfo(I_Info), *p_container)); +} + +CoSimIO_Info CoSimIO_ImportMesh( + const CoSimIO_Info I_Info, + CoSimIO_ModelPart O_ModelPart) +{ + CoSimIO::ModelPart& cpp_model_part = *(static_cast(O_ModelPart.PtrCppModelPart)); + + return ConvertInfo(CoSimIO::ImportMesh(ConvertInfo(I_Info), cpp_model_part)); +} + +CoSimIO_Info CoSimIO_ExportMesh( + const CoSimIO_Info I_Info, + const CoSimIO_ModelPart I_ModelPart) +{ + const CoSimIO::ModelPart& cpp_model_part = *(static_cast(I_ModelPart.PtrCppModelPart)); + + return ConvertInfo(CoSimIO::ExportMesh(ConvertInfo(I_Info), cpp_model_part)); +} + +void CoSimIO_PrintInfo(FILE *Stream, + const CoSimIO_Info I_Info) +{ + std::stringstream buffer; + buffer << *static_cast(I_Info.PtrCppInfo) << std::endl; + fprintf(Stream, "%s", buffer.str().c_str()); +} + +CoSimIO_Info CoSimIO_ImportInfo( + const CoSimIO_Info I_Info) +{ + return ConvertInfo(CoSimIO::ImportInfo(ConvertInfo(I_Info))); +} + +CoSimIO_Info CoSimIO_ExportInfo( + const CoSimIO_Info I_Info) +{ + return ConvertInfo(CoSimIO::ExportInfo(ConvertInfo(I_Info))); +} + +CoSimIO_Info CoSimIO_Register( + const CoSimIO_Info I_Info, + CoSimIO_Info (*I_FunctionPointer)(const CoSimIO_Info I_Info)) +{ + using FunctionPointerType = CoSimIO::Internals::Connection::FunctionPointerType; + + // auto return does not work here! + FunctionPointerType fct_callback = [I_FunctionPointer](const CoSimIO::Info& I_Info) + { + return ConvertInfo(I_FunctionPointer(ConvertInfo(I_Info))); + }; + + return ConvertInfo(CoSimIO::Register(ConvertInfo(I_Info), fct_callback)); +} + + +CoSimIO_Info CoSimIO_Run(const CoSimIO_Info I_Info) +{ + return ConvertInfo(CoSimIO::Run(ConvertInfo(I_Info))); +} + + +// Info functions +CoSimIO_Info CoSimIO_CreateInfo() +{ + CoSimIO_Info info; + info.PtrCppInfo = new CoSimIO::Info(); + return info; +} + +CoSimIO_Info CoSimIO_CopyInfo(const CoSimIO_Info I_Info) +{ + CoSimIO_Info info; + info.PtrCppInfo = new CoSimIO::Info(*static_cast(I_Info.PtrCppInfo)); // calling C++ copy constructor + return info; +} + +int CoSimIO_FreeInfo(CoSimIO_Info I_Info) +{ + delete static_cast(I_Info.PtrCppInfo); + + return 0; +} + +int CoSimIO_Info_Has(const CoSimIO_Info I_Info, const char* I_Key) +{ + return static_cast(I_Info.PtrCppInfo)->Has(I_Key); +} + +void CoSimIO_Info_Erase(const CoSimIO_Info I_Info, const char* I_Key) +{ + static_cast(I_Info.PtrCppInfo)->Erase(I_Key); +} + +void CoSimIO_Info_Clear(const CoSimIO_Info I_Info) +{ + static_cast(I_Info.PtrCppInfo)->Clear(); +} +int CoSimIO_Info_Size(const CoSimIO_Info I_Info) +{ + return static_cast(static_cast(I_Info.PtrCppInfo)->Size()); +} + + +int CoSimIO_Info_GetInt(const CoSimIO_Info I_Info, const char* I_Key) +{ + return static_cast(I_Info.PtrCppInfo)->Get(I_Key); +} + +double CoSimIO_Info_GetDouble(const CoSimIO_Info I_Info, const char* I_Key) +{ + return static_cast(I_Info.PtrCppInfo)->Get(I_Key); +} + +int CoSimIO_Info_GetBool(const CoSimIO_Info I_Info, const char* I_Key) +{ + return static_cast(I_Info.PtrCppInfo)->Get(I_Key); +} + +const char* CoSimIO_Info_GetString(const CoSimIO_Info I_Info, const char* I_Key) +{ + return static_cast(I_Info.PtrCppInfo)->Get(I_Key).c_str(); +} + +CoSimIO_Info CoSimIO_Info_GetInfo(const CoSimIO_Info I_Info, const char* I_Key) +{ + return ConvertInfo(static_cast(I_Info.PtrCppInfo)->Get(I_Key)); +} + + +void CoSimIO_Info_SetInt(CoSimIO_Info I_Info, const char* I_Key, const int I_Value) +{ + static_cast(I_Info.PtrCppInfo)->Set(I_Key, I_Value); +} + +void CoSimIO_Info_SetDouble(CoSimIO_Info I_Info, const char* I_Key, const double I_Value) +{ + static_cast(I_Info.PtrCppInfo)->Set(I_Key, I_Value); +} + +void CoSimIO_Info_SetBool(CoSimIO_Info I_Info, const char* I_Key, const int I_Value) +{ + static_cast(I_Info.PtrCppInfo)->Set(I_Key, I_Value); +} + +void CoSimIO_Info_SetString(CoSimIO_Info I_Info, const char* I_Key, const char* I_Value) +{ + static_cast(I_Info.PtrCppInfo)->Set(I_Key, I_Value); +} + +void CoSimIO_Info_SetInfo(CoSimIO_Info I_Info, const char* I_Key, CoSimIO_Info I_Value) +{ + static_cast(I_Info.PtrCppInfo)->Set(I_Key, ConvertInfo(I_Value)); +} + + +// ModelPart functions +CoSimIO_ModelPart CoSimIO_CreateModelPart(const char* I_Name) +{ + CoSimIO_ModelPart model_part; + model_part.PtrCppModelPart = new CoSimIO::ModelPart(I_Name); + return model_part; +} + + +const char* CoSimIO_ModelPart_Name(CoSimIO_ModelPart I_ModelPart) +{ + return static_cast(I_ModelPart.PtrCppModelPart)->Name().c_str(); +} + +int CoSimIO_ModelPart_NumberOfNodes(CoSimIO_ModelPart I_ModelPart) +{ + return static_cast(static_cast(I_ModelPart.PtrCppModelPart)->NumberOfNodes()); +} + +int CoSimIO_ModelPart_NumberOfLocalNodes(CoSimIO_ModelPart I_ModelPart) +{ + return static_cast(static_cast(I_ModelPart.PtrCppModelPart)->NumberOfLocalNodes()); +} + +int CoSimIO_ModelPart_NumberOfGhostNodes(CoSimIO_ModelPart I_ModelPart) +{ + return static_cast(static_cast(I_ModelPart.PtrCppModelPart)->NumberOfGhostNodes()); +} + +int CoSimIO_ModelPart_NumberOfElements(CoSimIO_ModelPart I_ModelPart) +{ + return static_cast(static_cast(I_ModelPart.PtrCppModelPart)->NumberOfElements()); +} + + +CoSimIO_Node CoSimIO_ModelPart_CreateNewNode( + CoSimIO_ModelPart I_ModelPart, + const int I_Id, + const double I_X, + const double I_Y, + const double I_Z) +{ + CoSimIO::Node& cpp_node = static_cast(I_ModelPart.PtrCppModelPart)->CreateNewNode(I_Id, I_X, I_Y, I_Z); + CoSimIO_Node node; + node.PtrCppNode = &cpp_node; + return node; +} + +void CoSimIO_ModelPart_CreateNewNodes( + CoSimIO_ModelPart I_ModelPart, + const int I_NumberOfNodes, + const int* I_Id, + const double* I_X, + const double* I_Y, + const double* I_Z) +{ + CoSimIO::Internals::DataContainerRawMemoryReadOnly ids(I_Id, I_NumberOfNodes); + CoSimIO::Internals::DataContainerRawMemoryReadOnly x(I_X, I_NumberOfNodes); + CoSimIO::Internals::DataContainerRawMemoryReadOnly y(I_Y, I_NumberOfNodes); + CoSimIO::Internals::DataContainerRawMemoryReadOnly z(I_Z, I_NumberOfNodes); + static_cast(I_ModelPart.PtrCppModelPart)->CreateNewNodes(ids, x, y, z); +} + +CoSimIO_Node CoSimIO_ModelPart_CreateNewGhostNode( + CoSimIO_ModelPart I_ModelPart, + const int I_Id, + const double I_X, + const double I_Y, + const double I_Z, + const int PartitionIndex) +{ + CoSimIO::Node& cpp_node = static_cast(I_ModelPart.PtrCppModelPart)->CreateNewGhostNode(I_Id, I_X, I_Y, I_Z, PartitionIndex); + CoSimIO_Node node; + node.PtrCppNode = &cpp_node; + return node; +} + +void CoSimIO_ModelPart_CreateNewGhostNodes( + CoSimIO_ModelPart I_ModelPart, + const int I_NumberOfNodes, + const int* I_Id, + const double* I_X, + const double* I_Y, + const double* I_Z, + const int* PartitionIndex) +{ + CoSimIO::Internals::DataContainerRawMemoryReadOnly ids(I_Id, I_NumberOfNodes); + CoSimIO::Internals::DataContainerRawMemoryReadOnly x(I_X, I_NumberOfNodes); + CoSimIO::Internals::DataContainerRawMemoryReadOnly y(I_Y, I_NumberOfNodes); + CoSimIO::Internals::DataContainerRawMemoryReadOnly z(I_Z, I_NumberOfNodes); + CoSimIO::Internals::DataContainerRawMemoryReadOnly p_idx(PartitionIndex, I_NumberOfNodes); + static_cast(I_ModelPart.PtrCppModelPart)->CreateNewGhostNodes(ids, x, y, z, p_idx); +} + +CoSimIO_Element CoSimIO_ModelPart_CreateNewElement( + CoSimIO_ModelPart I_ModelPart, + const int I_Id, + const CoSimIO_ElementType I_Type, + const int* I_Connectivities) +{ + const CoSimIO::ElementType cpp_element_type = static_cast(I_Type); + const std::size_t num_nodes = CoSimIO::Utilities::GetNumberOfNodesForElementType(cpp_element_type); + // convert the C-connectivities to C++ connectivities + CoSimIO::ConnectivitiesType connectivities(I_Connectivities, I_Connectivities+num_nodes); + + CoSimIO::Element& cpp_elem = static_cast(I_ModelPart.PtrCppModelPart)->CreateNewElement(I_Id, cpp_element_type, connectivities); + CoSimIO_Element elem; + elem.PtrCppElement = &cpp_elem; + return elem; +} + +void CoSimIO_ModelPart_CreateNewElements( + CoSimIO_ModelPart I_ModelPart, + const int I_NumberOfElements, + const int* I_Id, + const CoSimIO_ElementType* I_Type, + const int I_NumberOfConnectivities, + const int* I_Connectivities) +{ + CoSimIO::Internals::DataContainerRawMemoryReadOnly ids(I_Id, I_NumberOfElements); + std::vector types(I_NumberOfElements); + for (int i=0; i(I_Type[i]);} + CoSimIO::Internals::DataContainerRawMemoryReadOnly connectivities(I_Connectivities, I_NumberOfConnectivities); + static_cast(I_ModelPart.PtrCppModelPart)->CreateNewElements(ids, types, connectivities); +} + + +int CoSimIO_Node_Id(CoSimIO_Node I_Node) +{ + return static_cast(static_cast(I_Node.PtrCppNode)->Id()); +} + +double CoSimIO_Node_X(CoSimIO_Node I_Node) +{ + return static_cast(I_Node.PtrCppNode)->X(); +} + +double CoSimIO_Node_Y(CoSimIO_Node I_Node) +{ + return static_cast(I_Node.PtrCppNode)->Y(); +} + +double CoSimIO_Node_Z(CoSimIO_Node I_Node) +{ + return static_cast(I_Node.PtrCppNode)->Z(); +} + +double CoSimIO_Node_Coordinate(CoSimIO_Node I_Node, const int I_Index) +{ + // TODO add debug error if I_Index is out of bound (admissible values: 0,1,2) + return static_cast(I_Node.PtrCppNode)->Coordinates()[I_Index]; +} + + +CoSimIO_Node CoSimIO_ModelPart_GetNodeByIndex(CoSimIO_ModelPart I_ModelPart, const int I_Index) +{ + CoSimIO::Node& cpp_node = **(static_cast(I_ModelPart.PtrCppModelPart)->NodesBegin()+I_Index); + CoSimIO_Node node; + node.PtrCppNode = &cpp_node; + return node; +} +CoSimIO_Node CoSimIO_ModelPart_GetLocalNodeByIndex(CoSimIO_ModelPart I_ModelPart, const int I_Index) +{ + CoSimIO::Node& cpp_node = **(static_cast(I_ModelPart.PtrCppModelPart)->LocalNodesBegin()+I_Index); + CoSimIO_Node node; + node.PtrCppNode = &cpp_node; + return node; +} +CoSimIO_Node CoSimIO_ModelPart_GetGhostNodeByIndex(CoSimIO_ModelPart I_ModelPart, const int I_Index) +{ + CoSimIO::Node& cpp_node = **(static_cast(I_ModelPart.PtrCppModelPart)->GhostNodesBegin()+I_Index); + CoSimIO_Node node; + node.PtrCppNode = &cpp_node; + return node; +} + +CoSimIO_Node CoSimIO_ModelPart_GetNodeById(CoSimIO_ModelPart I_ModelPart, const int I_Id) +{ + CoSimIO::Node& cpp_node = static_cast(I_ModelPart.PtrCppModelPart)->GetNode(I_Id); + CoSimIO_Node node; + node.PtrCppNode = &cpp_node; + return node; +} + + +int CoSimIO_Element_Id(CoSimIO_Element I_Element) +{ + return static_cast(static_cast(I_Element.PtrCppElement)->Id()); +} + +CoSimIO_ElementType CoSimIO_Element_Type(CoSimIO_Element I_Element) +{ + return static_cast(static_cast(I_Element.PtrCppElement)->Type()); +} + +int CoSimIO_Element_NumberOfNodes(CoSimIO_Element I_Element) +{ + return static_cast(static_cast(I_Element.PtrCppElement)->NumberOfNodes()); +} + +CoSimIO_Node CoSimIO_Element_GetNodeByIndex(CoSimIO_Element I_Element, const int I_Index) +{ + CoSimIO::Node& cpp_node = **(static_cast(I_Element.PtrCppElement)->NodesBegin()+I_Index); + CoSimIO_Node node; + node.PtrCppNode = &cpp_node; + return node; +} + + + +CoSimIO_Element CoSimIO_ModelPart_GetElementByIndex(CoSimIO_ModelPart I_ModelPart, const int I_Index) +{ + CoSimIO::Element& cpp_elem = **(static_cast(I_ModelPart.PtrCppModelPart)->ElementsBegin()+I_Index); + CoSimIO_Element elem; + elem.PtrCppElement = &cpp_elem; + return elem; +} + +CoSimIO_Element CoSimIO_ModelPart_GetElementById(CoSimIO_ModelPart I_ModelPart, const int I_Id) +{ + CoSimIO::Element& cpp_elem = static_cast(I_ModelPart.PtrCppModelPart)->GetElement(I_Id); + CoSimIO_Element elem; + elem.PtrCppElement = &cpp_elem; + return elem; +} + +void CoSimIO_ModelPart_Clear(CoSimIO_ModelPart I_ModelPart) +{ + static_cast(I_ModelPart.PtrCppModelPart)->Clear(); +} + + +int CoSimIO_FreeModelPart(CoSimIO_ModelPart I_ModelPart) +{ + delete static_cast(I_ModelPart.PtrCppModelPart); + return 0; +} + + +void* CoSimIO_Malloc(size_t size){ + // Todo: Add a register of allocated memory: [pointer, size] + return malloc(size); +} + +void CoSimIO_Free (void* ptr){ + // Removing it from registered allocated memory + free(ptr); +} diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/co_sim_io_c.h b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/co_sim_io_c.h new file mode 100644 index 000000000000..c570d7468263 --- /dev/null +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/co_sim_io_c.h @@ -0,0 +1,89 @@ +/* ______ _____ _ ________ + / ____/___ / ___/(_)___ ___ / _/ __ | + / / / __ \\__ \/ / __ `__ \ / // / / / + / /___/ /_/ /__/ / / / / / / // // /_/ / + \____/\____/____/_/_/ /_/ /_/___/\____/ + Kratos CoSimulationApplication + + License: BSD License, see license.txt + + Main authors: Philipp Bucher (https://github.com/philbucher) +*/ + +#ifndef CO_SIM_IO_C_INCLUDED +#define CO_SIM_IO_C_INCLUDED + +/* C Interface for CoSimulation + see "co_sim_io.hpp" +*/ + +#include + +#include "co_sim_io_c_info.h" +#include "co_sim_io_c_model_part.h" + +#ifdef __cplusplus +extern "C" { /* Define extern C if C++ compiler is used */ +#endif + +enum CoSimIO_ConnectionStatus +{ + CoSimIO_NotConnected, + CoSimIO_Connected, + CoSimIO_Disconnected, + CoSimIO_ConnectionError, + CoSimIO_DisconnectionError +}; + +CO_SIM_IO_NODISCARD CoSimIO_Info CoSimIO_Hello( + void); + +CO_SIM_IO_NODISCARD CoSimIO_Info CoSimIO_Connect( + const CoSimIO_Info I_Settings); + +CO_SIM_IO_NODISCARD CoSimIO_Info CoSimIO_Disconnect( + const CoSimIO_Info I_Info); + +CO_SIM_IO_NODISCARD CoSimIO_Info CoSimIO_ImportData( + const CoSimIO_Info I_Info, + int* O_Size, + double** O_Data); + +CO_SIM_IO_NODISCARD CoSimIO_Info CoSimIO_ExportData( + const CoSimIO_Info I_Info, + const int I_Size, + const double* I_Data); + +CO_SIM_IO_NODISCARD CoSimIO_Info CoSimIO_ImportMesh( + const CoSimIO_Info I_Info, + CoSimIO_ModelPart O_ModelPart); + +CO_SIM_IO_NODISCARD CoSimIO_Info CoSimIO_ExportMesh( + const CoSimIO_Info I_Info, + const CoSimIO_ModelPart I_ModelPart); + + +void CoSimIO_PrintInfo(FILE *Stream, + const CoSimIO_Info I_Info); + +CO_SIM_IO_NODISCARD CoSimIO_Info CoSimIO_ImportInfo( + const CoSimIO_Info I_Info); + +CO_SIM_IO_NODISCARD CoSimIO_Info CoSimIO_ExportInfo( + const CoSimIO_Info I_Info); + +CO_SIM_IO_NODISCARD CoSimIO_Info CoSimIO_Register( + const CoSimIO_Info I_Info, + CoSimIO_Info (*I_FunctionPointer)(const CoSimIO_Info I_Info)); + +CO_SIM_IO_NODISCARD CoSimIO_Info CoSimIO_Run(const CoSimIO_Info I_Info); + +void* CoSimIO_Malloc(size_t size); + +void CoSimIO_Free (void* ptr); + +#ifdef __cplusplus +} +#endif + +#endif /* CO_SIM_IO_C_INCLUDED */ diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/co_sim_io_c_info.h b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/co_sim_io_c_info.h new file mode 100644 index 000000000000..98998bd2a4d0 --- /dev/null +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/co_sim_io_c_info.h @@ -0,0 +1,48 @@ +/* ______ _____ _ ________ + / ____/___ / ___/(_)___ ___ / _/ __ | + / / / __ \\__ \/ / __ `__ \ / // / / / + / /___/ /_/ /__/ / / / / / / // // /_/ / + \____/\____/____/_/_/ /_/ /_/___/\____/ + Kratos CoSimulationApplication + + License: BSD License, see license.txt + + Main authors: Philipp Bucher (https://github.com/philbucher) +*/ + +#ifndef CO_SIM_IO_C_INFO_INCLUDED +#define CO_SIM_IO_C_INFO_INCLUDED + + +#include "define_c.h" + +typedef struct CoSimIO_Info +{ + void* PtrCppInfo; +} CoSimIO_Info; + + +CO_SIM_IO_NODISCARD CoSimIO_Info CoSimIO_CreateInfo(void); + +CO_SIM_IO_NODISCARD CoSimIO_Info CoSimIO_CopyInfo(const CoSimIO_Info I_Info); + +int CoSimIO_FreeInfo(CoSimIO_Info I_Info); + +int CoSimIO_Info_Has(const CoSimIO_Info I_Info, const char* I_Key); +void CoSimIO_Info_Erase(const CoSimIO_Info I_Info, const char* I_Key); +void CoSimIO_Info_Clear(const CoSimIO_Info I_Info); +int CoSimIO_Info_Size(const CoSimIO_Info I_Info); + +int CoSimIO_Info_GetInt(const CoSimIO_Info I_Info, const char* I_Key); +double CoSimIO_Info_GetDouble(const CoSimIO_Info I_Info, const char* I_Key); +int CoSimIO_Info_GetBool(const CoSimIO_Info I_Info, const char* I_Key); +const char* CoSimIO_Info_GetString(const CoSimIO_Info I_Info, const char* I_Key); +CO_SIM_IO_NODISCARD CoSimIO_Info CoSimIO_Info_GetInfo(const CoSimIO_Info I_Info, const char* I_Key); + +void CoSimIO_Info_SetInt(CoSimIO_Info I_Info, const char* I_Key, const int I_Value); +void CoSimIO_Info_SetDouble(CoSimIO_Info I_Info, const char* I_Key, const double I_Value); +void CoSimIO_Info_SetBool(CoSimIO_Info I_Info, const char* I_Key, const int I_Value); +void CoSimIO_Info_SetString(CoSimIO_Info I_Info, const char* I_Key, const char* I_Value); +void CoSimIO_Info_SetInfo(CoSimIO_Info I_Info, const char* I_Key, CoSimIO_Info I_Value); + +#endif /* CO_SIM_IO_C_INFO_INCLUDED */ diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/co_sim_io_c_model_part.h b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/co_sim_io_c_model_part.h new file mode 100644 index 000000000000..d4b2d2f7c082 --- /dev/null +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/co_sim_io_c_model_part.h @@ -0,0 +1,142 @@ +/* ______ _____ _ ________ + / ____/___ / ___/(_)___ ___ / _/ __ | + / / / __ \\__ \/ / __ `__ \ / // / / / + / /___/ /_/ /__/ / / / / / / // // /_/ / + \____/\____/____/_/_/ /_/ /_/___/\____/ + Kratos CoSimulationApplication + + License: BSD License, see license.txt + + Main authors: Philipp Bucher (https://github.com/philbucher) +*/ + +#ifndef CO_SIM_IO_C_MODEL_PART_INCLUDED +#define CO_SIM_IO_C_MODEL_PART_INCLUDED + +#include "define_c.h" + +typedef struct CoSimIO_Node +{ + void* PtrCppNode; +} CoSimIO_Node; + +typedef struct CoSimIO_Element +{ + void* PtrCppElement; +} CoSimIO_Element; + +typedef struct CoSimIO_ModelPart +{ + void* PtrCppModelPart; +} CoSimIO_ModelPart; + +typedef enum +{ + CoSimIO_Hexahedra3D20, + CoSimIO_Hexahedra3D27, + CoSimIO_Hexahedra3D8, + CoSimIO_Prism3D15, + CoSimIO_Prism3D6, + CoSimIO_Pyramid3D13, + CoSimIO_Pyramid3D5, + CoSimIO_Quadrilateral2D4, + CoSimIO_Quadrilateral2D8, + CoSimIO_Quadrilateral2D9, + CoSimIO_Quadrilateral3D4, + CoSimIO_Quadrilateral3D8, + CoSimIO_Quadrilateral3D9, + CoSimIO_Tetrahedra3D10, + CoSimIO_Tetrahedra3D4, + CoSimIO_Triangle2D3, + CoSimIO_Triangle2D6, + CoSimIO_Triangle3D3, + CoSimIO_Triangle3D6, + CoSimIO_Line2D2, + CoSimIO_Line2D3, + CoSimIO_Line3D2, + CoSimIO_Line3D3, + CoSimIO_Point2D, + CoSimIO_Point3D +} CoSimIO_ElementType; + + +/* Node functions */ +int CoSimIO_Node_Id(CoSimIO_Node I_Node); +double CoSimIO_Node_X(CoSimIO_Node I_Node); +double CoSimIO_Node_Y(CoSimIO_Node I_Node); +double CoSimIO_Node_Z(CoSimIO_Node I_Node); +double CoSimIO_Node_Coordinate(CoSimIO_Node I_Node, const int I_Index); + + +/* Element functions */ +int CoSimIO_Element_Id(CoSimIO_Element I_Element); +CoSimIO_ElementType CoSimIO_Element_Type(CoSimIO_Element I_Element); +int CoSimIO_Element_NumberOfNodes(CoSimIO_Element I_Element); +CoSimIO_Node CoSimIO_Element_GetNodeByIndex(CoSimIO_Element I_Element, const int I_Index); + +/* ModelPart functions */ +CO_SIM_IO_NODISCARD CoSimIO_ModelPart CoSimIO_CreateModelPart(const char* I_Name); + +int CoSimIO_FreeModelPart(CoSimIO_ModelPart I_ModelPart); + +const char* CoSimIO_ModelPart_Name(CoSimIO_ModelPart I_ModelPart); +int CoSimIO_ModelPart_NumberOfNodes(CoSimIO_ModelPart I_ModelPart); +int CoSimIO_ModelPart_NumberOfLocalNodes(CoSimIO_ModelPart I_ModelPart); +int CoSimIO_ModelPart_NumberOfGhostNodes(CoSimIO_ModelPart I_ModelPart); +int CoSimIO_ModelPart_NumberOfElements(CoSimIO_ModelPart I_ModelPart); +CoSimIO_Node CoSimIO_ModelPart_GetNodeByIndex(CoSimIO_ModelPart I_ModelPart, const int I_Index); +CoSimIO_Node CoSimIO_ModelPart_GetLocalNodeByIndex(CoSimIO_ModelPart I_ModelPart, const int I_Index); +CoSimIO_Node CoSimIO_ModelPart_GetGhostNodeByIndex(CoSimIO_ModelPart I_ModelPart, const int I_Index); +CoSimIO_Node CoSimIO_ModelPart_GetNodeById(CoSimIO_ModelPart I_ModelPart, const int I_Id); +CoSimIO_Element CoSimIO_ModelPart_GetElementByIndex(CoSimIO_ModelPart I_ModelPart, const int I_Index); +CoSimIO_Element CoSimIO_ModelPart_GetElementById(CoSimIO_ModelPart I_ModelPart, const int I_Id); +void CoSimIO_ModelPart_Clear(CoSimIO_ModelPart I_ModelPart); + +CoSimIO_Node CoSimIO_ModelPart_CreateNewNode( + CoSimIO_ModelPart I_ModelPart, + const int I_Id, + const double I_X, + const double I_Y, + const double I_Z); + +void CoSimIO_ModelPart_CreateNewNodes( + CoSimIO_ModelPart I_ModelPart, + const int I_NumberOfNodes, + const int* I_Id, + const double* I_X, + const double* I_Y, + const double* I_Z); + +CoSimIO_Node CoSimIO_ModelPart_CreateNewGhostNode( + CoSimIO_ModelPart I_ModelPart, + const int I_Id, + const double I_X, + const double I_Y, + const double I_Z, + const int PartitionIndex); + +void CoSimIO_ModelPart_CreateNewGhostNodes( + CoSimIO_ModelPart I_ModelPart, + const int I_NumberOfNodes, + const int* I_Id, + const double* I_X, + const double* I_Y, + const double* I_Z, + const int* PartitionIndex); + +CoSimIO_Element CoSimIO_ModelPart_CreateNewElement( + CoSimIO_ModelPart I_ModelPart, + const int I_Id, + const CoSimIO_ElementType I_Type, + const int* I_Connectivities); + +void CoSimIO_ModelPart_CreateNewElements( + CoSimIO_ModelPart I_ModelPart, + const int I_NumberOfElements, + const int* I_Id, + const CoSimIO_ElementType* I_Type, + const int I_NumberOfConnectivities, + const int* I_Connectivities); + + +#endif /* CO_SIM_IO_C_MODEL_PART_INCLUDED */ diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/co_sim_io_c_mpi.cpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/co_sim_io_c_mpi.cpp new file mode 100644 index 000000000000..bbbee1b15ce8 --- /dev/null +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/co_sim_io_c_mpi.cpp @@ -0,0 +1,36 @@ +// ______ _____ _ ________ +// / ____/___ / ___/(_)___ ___ / _/ __ | +// / / / __ \\__ \/ / __ `__ \ / // / / / +// / /___/ /_/ /__/ / / / / / / // // /_/ / +// \____/\____/____/_/_/ /_/ /_/___/\____/ +// Kratos CoSimulationApplication +// +// License: BSD License, see license.txt +// +// Main authors: Philipp Bucher (https://github.com/philbucher) +// + +// Project includes +#include "co_sim_io_c_mpi.h" +#include "co_sim_io_mpi.hpp" + +namespace { + // get C Info from C++ Info + CoSimIO_Info ConvertInfo(CoSimIO::Info I_Info) { + CoSimIO_Info info; + info.PtrCppInfo = new CoSimIO::Info(I_Info); + return info; + } + + // get C++ Info from C Info + CoSimIO::Info ConvertInfo(CoSimIO_Info I_Info) { + return CoSimIO::Info(*(static_cast(I_Info.PtrCppInfo))); + } +} + +CO_SIM_IO_NODISCARD CoSimIO_Info CoSimIO_ConnectMPI( + const CoSimIO_Info I_Settings, + MPI_Comm ThisMPIComm) +{ + return ConvertInfo(CoSimIO::ConnectMPI(ConvertInfo(I_Settings), ThisMPIComm)); +} diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/co_sim_io_c_mpi.h b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/co_sim_io_c_mpi.h new file mode 100644 index 000000000000..71a2ce13a97b --- /dev/null +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/co_sim_io_c_mpi.h @@ -0,0 +1,35 @@ +/* ______ _____ _ ________ + / ____/___ / ___/(_)___ ___ / _/ __ | + / / / __ \\__ \/ / __ `__ \ / // / / / + / /___/ /_/ /__/ / / / / / / // // /_/ / + \____/\____/____/_/_/ /_/ /_/___/\____/ + Kratos CoSimulationApplication + + License: BSD License, see license.txt + + Main authors: Philipp Bucher (https://github.com/philbucher) +*/ + +#ifndef CO_SIM_IO_C_MPI_INCLUDED +#define CO_SIM_IO_C_MPI_INCLUDED + +/* C MPI-Interface for CoSimulation + see "co_sim_io_mpi.hpp" +*/ + +#include "mpi.h" +#include "co_sim_io_c.h" + +#ifdef __cplusplus +extern "C" { /* Define extern C if C++ compiler is used */ +#endif + +CO_SIM_IO_NODISCARD CoSimIO_Info CoSimIO_ConnectMPI( + const CoSimIO_Info I_Settings, + MPI_Comm ThisMPIComm); + +#ifdef __cplusplus +} +#endif + +#endif /* CO_SIM_IO_C_MPI_INCLUDED */ diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/define_c.h b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/define_c.h new file mode 100644 index 000000000000..8723b70ca97d --- /dev/null +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/c/define_c.h @@ -0,0 +1,26 @@ +/* ______ _____ _ ________ + / ____/___ / ___/(_)___ ___ / _/ __ | + / / / __ \\__ \/ / __ `__ \ / // / / / + / /___/ /_/ /__/ / / / / / / // // /_/ / + \____/\____/____/_/_/ /_/ /_/___/\____/ + Kratos CoSimulationApplication + + License: BSD License, see license.txt + + Main authors: Philipp Bucher (https://github.com/philbucher) +*/ + +#ifndef CO_SIM_IO_C_DEFINE_INCLUDED +#define CO_SIM_IO_C_DEFINE_INCLUDED + +/*nodiscard is part of C23: +https://en.cppreference.com/w/c/language/attributes/nodiscard +hence using custom solution +*/ +#if defined(__GNUC__) || defined(__clang__) || defined(__INTEL_COMPILER) +#define CO_SIM_IO_NODISCARD __attribute__((warn_unused_result)) +#else +#define CO_SIM_IO_NODISCARD +#endif + +#endif /* CO_SIM_IO_C_DEFINE_INCLUDED */ diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/fortran/CMakeLists.txt b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/fortran/CMakeLists.txt new file mode 100644 index 000000000000..2998f061662a --- /dev/null +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/fortran/CMakeLists.txt @@ -0,0 +1,9 @@ +message("Configuring CoSimIO for Fortran") + +enable_language(Fortran) + +add_library (co_sim_io_fortran SHARED co_sim_io.f90) + +target_link_libraries( co_sim_io_fortran co_sim_io_c ) + +install(TARGETS co_sim_io_fortran DESTINATION bin) diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/fortran/co_sim_io.f90 b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/fortran/co_sim_io.f90 new file mode 100644 index 000000000000..2b621dea94c3 --- /dev/null +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/fortran/co_sim_io.f90 @@ -0,0 +1,582 @@ +! ______ _____ _ ________ +! / ____/___ / ___/(_)___ ___ / _/ __ | +! / / / __ \\__ \/ / __ `__ \ / // / / / +! / /___/ /_/ /__/ / / / / / / // // /_/ / +! \____/\____/____/_/_/ /_/ /_/___/\____/ +! Kratos CoSimulationApplication +! +! License: BSD License, see license.txt +! +! Main authors: Philipp Bucher (https://github.com/philbucher), Ankit Nanda(https://github.com/Ankit-Nanda-altair) +! + + MODULE co_sim_io + USE, INTRINSIC :: ISO_C_BINDING + IMPLICIT NONE + + !START: co_sim_io_c_info.h structures + TYPE, BIND (C) :: CoSimIO_Info + TYPE(c_ptr) :: PtrCppInfo + END TYPE CoSimIO_Info + + !END: co_sim_io_c_info.h structures + + !START: co_sim_io_c_model_part.h structures + TYPE, BIND (C) :: CoSimIO_Node + TYPE(c_ptr) :: PtrCppNode + END TYPE CoSimIO_Node + + TYPE, BIND (C) :: CoSimIO_Element + TYPE(c_ptr) :: PtrCppElement + END TYPE CoSimIO_Element + + TYPE, BIND (C) :: CoSimIO_ModelPart + TYPE(c_ptr) :: PtrCppModelPart + END TYPE CoSimIO_ModelPart + + ENUM, BIND(C) + ENUMERATOR:: CoSimIO_ConnectionStatus = -1 + ENUMERATOR:: CoSimIO_NotConnected + ENUMERATOR:: CoSimIO_Connected + ENUMERATOR:: CoSimIO_Disconnected + ENUMERATOR:: CoSimIO_ConnectionError + ENUMERATOR:: CoSimIO_DisconnectionError + END ENUM + + ENUM, BIND(C) + ENUMERATOR:: CoSimIO_ElementType = -1 + ENUMERATOR:: CoSimIO_Hexahedra3D20 + ENUMERATOR:: CoSimIO_Hexahedra3D27 + ENUMERATOR:: CoSimIO_Hexahedra3D8 + ENUMERATOR:: CoSimIO_Prism3D15 + ENUMERATOR:: CoSimIO_Prism3D6 + ENUMERATOR:: CoSimIO_Pyramid3D13 + ENUMERATOR:: CoSimIO_Pyramid3D5 + ENUMERATOR:: CoSimIO_Quadrilateral2D4 + ENUMERATOR:: CoSimIO_Quadrilateral2D8 + ENUMERATOR:: CoSimIO_Quadrilateral2D9 + ENUMERATOR:: CoSimIO_Quadrilateral3D4 + ENUMERATOR:: CoSimIO_Quadrilateral3D8 + ENUMERATOR:: CoSimIO_Quadrilateral3D9 + ENUMERATOR:: CoSimIO_Tetrahedra3D10 + ENUMERATOR:: CoSimIO_Tetrahedra3D4 + ENUMERATOR:: CoSimIO_Triangle2D3 + ENUMERATOR:: CoSimIO_Triangle2D6 + ENUMERATOR:: CoSimIO_Triangle3D3 + ENUMERATOR:: CoSimIO_Triangle3D6 + ENUMERATOR:: CoSimIO_Line2D2 + ENUMERATOR:: CoSimIO_Line2D3 + ENUMERATOR:: CoSimIO_Line3D2 + ENUMERATOR:: CoSimIO_Line3D3 + ENUMERATOR:: CoSimIO_Point2D + ENUMERATOR:: CoSimIO_Point3D + END ENUM + !END: co_sim_io_c_model_part.h structures + + INTERFACE + + ! START: co_sim_io_c.h interface functions and subroutines + TYPE(CoSimIO_Info) FUNCTION CoSimIO_Hello() BIND(C, NAME="CoSimIO_Hello") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + END FUNCTION CoSimIO_Hello + + TYPE(CoSimIO_Info) FUNCTION CoSimIO_Connect (I_Settings) BIND(C, NAME="CoSimIO_Connect") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), VALUE :: I_Settings + END FUNCTION CoSimIO_Connect + + TYPE(CoSimIO_Info) FUNCTION CoSimIO_Disconnect (I_Info) BIND(C, NAME="CoSimIO_Disconnect") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), VALUE :: I_Info + END FUNCTION CoSimIO_Disconnect + + TYPE(CoSimIO_Info) FUNCTION CoSimIO_ImportData (I_Info, O_Size, O_Data) BIND(C, NAME="CoSimIO_ImportData") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), VALUE :: I_Info + INTEGER(KIND=c_int),pointer :: O_Size + REAL(KIND=c_double),pointer,DIMENSION(:) :: O_Data + END FUNCTION CoSimIO_ImportData + + + TYPE(CoSimIO_Info) FUNCTION CoSimIO_ImportData_fortran (I_Info, O_Size, O_Data) + & BIND(C, NAME="CoSimIO_ImportData_fortran") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), VALUE :: I_Info + INTEGER(KIND=c_int),VALUE :: O_Size + REAL(KIND=c_double),pointer,DIMENSION(:) :: O_Data + END FUNCTION CoSimIO_ImportData_fortran + + TYPE(CoSimIO_Info) FUNCTION CoSimIO_ExportData (I_Info, I_Size, I_Data) BIND(C, NAME="CoSimIO_ExportData") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), VALUE :: I_Info + INTEGER(KIND = c_int), VALUE :: I_Size + REAL(KIND=c_double),DIMENSION(*) :: I_Data + END FUNCTION CoSimIO_ExportData + + TYPE(CoSimIO_Info) FUNCTION CoSimIO_ImportMesh (I_Info, O_ModelPart) BIND(C, NAME="CoSimIO_ImportMesh") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_ModelPart, CoSimIO_Info + TYPE(CoSimIO_Info), VALUE :: I_Info + TYPE(CoSimIO_ModelPart), VALUE :: O_ModelPart + END FUNCTION CoSimIO_ImportMesh + + TYPE(CoSimIO_Info) FUNCTION CoSimIO_ExportMesh (I_Info, I_ModelPart) BIND(C, NAME="CoSimIO_ExportMesh") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_ModelPart, CoSimIO_Info + TYPE(CoSimIO_Info), VALUE :: I_Info + TYPE(CoSimIO_ModelPart), VALUE :: I_ModelPart + END FUNCTION CoSimIO_ExportMesh + + TYPE(CoSimIO_Info) FUNCTION CoSimIO_ImportInfo (I_Info) BIND(C, NAME="CoSimIO_ImportInfo") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), VALUE :: I_Info + END FUNCTION CoSimIO_ImportInfo + + TYPE(CoSimIO_Info) FUNCTION CoSimIO_ExportInfo (I_Info) BIND(C, NAME="CoSimIO_ExportInfo") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), VALUE :: I_Info + END FUNCTION CoSimIO_ExportInfo + + INTEGER(KIND=C_INT) FUNCTION CoSimIO_Register (I_Info, I_FunctionPointer) BIND(C, NAME="CoSimIO_Register") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), VALUE :: I_Info + TYPE(C_FUNPTR), VALUE :: I_FunctionPointer + END FUNCTION CoSimIO_Register + + TYPE(CoSimIO_Info) FUNCTION CoSimIO_Run (I_Info) BIND(C, NAME="CoSimIO_Run") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), VALUE :: I_Info + END FUNCTION CoSimIO_Run + + + TYPE(c_ptr) FUNCTION CoSimIO_Malloc (size) + USE, INTRINSIC :: ISO_C_BINDING + REAL(KIND=c_double), VALUE :: size + END FUNCTION CoSimIO_Malloc + + + SUBROUTINE CoSimIO_Free(ptr_h) BIND(C, NAME='CoSimIO_Free') + USE, INTRINSIC :: ISO_C_BINDING + !IMPORT CoSimIO_Info + TYPE(c_ptr),INTENT(IN), VALUE :: ptr_h + END SUBROUTINE CoSimIO_Free + ! END: co_sim_io_c.h interface + + !START: co_sim_io_c_info.h interface + TYPE(CoSimIO_Info) FUNCTION CoSimIO_CreateInfo() BIND(C, NAME="CoSimIO_CreateInfo") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + END FUNCTION CoSimIO_CreateInfo + + TYPE(CoSimIO_Info) FUNCTION CoSimIO_CopyInfo (I_Info) BIND(C, NAME="CoSimIO_CopyInfo") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), VALUE :: I_Info + END FUNCTION CoSimIO_CopyInfo + + INTEGER(KIND=c_int) FUNCTION CoSimIO_FreeInfo (I_Info) BIND(C, NAME="CoSimIO_FreeInfo") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), VALUE :: I_Info + END FUNCTION CoSimIO_FreeInfo + + + INTEGER(KIND=c_int) FUNCTION CoSimIO_Info_Has (I_Info, I_Key) BIND(C, NAME="CoSimIO_Info_Has") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), VALUE :: I_Info + CHARACTER(len=1, KIND=c_char), DIMENSION(*) :: I_Key + END FUNCTION CoSimIO_Info_Has + + + SUBROUTINE CoSimIO_Info_Erase(I_Info, I_Key) BIND(C, NAME='CoSimIO_Info_Erase') + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), INTENT(IN), VALUE :: I_Info + CHARACTER(len=1, KIND=c_char), DIMENSION(*) , INTENT(IN) :: I_Key + END SUBROUTINE CoSimIO_Info_Erase + + + SUBROUTINE CoSimIO_Info_Clear(I_Info) BIND(C, NAME='CoSimIO_Info_Clear') + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), INTENT(IN) , VALUE :: I_Info + END SUBROUTINE CoSimIO_Info_Clear + + INTEGER(KIND=c_int) FUNCTION CoSimIO_Info_Size (I_Info) BIND(C, NAME="CoSimIO_Info_Size") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), VALUE :: I_Info + END FUNCTION CoSimIO_Info_Size + + + INTEGER(KIND=c_int) FUNCTION CoSimIO_Info_GetInt (I_Info, I_Key) BIND(C, NAME="CoSimIO_Info_GetInt") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), VALUE :: I_Info + CHARACTER(len=1, KIND=c_char), DIMENSION(*) :: I_Key + END FUNCTION CoSimIO_Info_GetInt + + + REAL(KIND=c_double) FUNCTION CoSimIO_Info_GetDouble (I_Info, I_Key) BIND(C, NAME="CoSimIO_Info_GetDouble") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), VALUE :: I_Info + CHARACTER(len=1, KIND=c_char) , DIMENSION(*) :: I_Key + END FUNCTION CoSimIO_Info_GetDouble + + + INTEGER(KIND=c_int) FUNCTION CoSimIO_Info_GetBool (I_Info, I_Key) BIND(C, NAME="CoSimIO_Info_GetBool") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), VALUE :: I_Info + CHARACTER(len=1, KIND=c_char), DIMENSION(*) :: I_Key + END FUNCTION CoSimIO_Info_GetBool + + + type(c_ptr) FUNCTION CoSimIO_Info_GetString (I_Info, I_Key) BIND(C, NAME="CoSimIO_Info_GetString") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), VALUE :: I_Info + CHARACTER(LEN = 1, KIND=c_char), DIMENSION(*) :: I_Key + + END FUNCTION CoSimIO_Info_GetString + + + TYPE(CoSimIO_Info) FUNCTION CoSimIO_Info_GetInfo (I_Info, I_Key) BIND(C, NAME="CoSimIO_Info_GetInfo") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info),VALUE :: I_Info + CHARACTER(len=1, KIND=c_char) , DIMENSION(*) :: I_Key + END FUNCTION CoSimIO_Info_GetInfo + + + SUBROUTINE CoSimIO_Info_SetInt(I_Info, I_Key, I_Value) BIND(C, NAME='CoSimIO_Info_SetInt') + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), INTENT(IN), VALUE :: I_Info + CHARACTER(len=1, KIND=c_char), DIMENSION(*) , INTENT(IN) :: I_Key + INTEGER(KIND = c_int), INTENT(IN), VALUE :: I_Value + END SUBROUTINE CoSimIO_Info_SetInt + + + SUBROUTINE CoSimIO_Info_SetDouble(I_Info, I_Key, I_Value) BIND(C, NAME='CoSimIO_Info_SetDouble') + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), INTENT(IN), VALUE :: I_Info + CHARACTER(len=1, KIND=c_char), DIMENSION(*) , INTENT(IN) :: I_Key + REAL(KIND = c_double), INTENT(IN), VALUE :: I_Value + END SUBROUTINE CoSimIO_Info_SetDouble + + + SUBROUTINE CoSimIO_Info_SetBool(I_Info, I_Key, I_Value) BIND(C, NAME='CoSimIO_Info_SetBool') + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), INTENT(IN), VALUE :: I_Info + CHARACTER(len=1, KIND=c_char) , DIMENSION(*), INTENT(IN) :: I_Key + INTEGER(KIND = c_int), INTENT(IN), VALUE :: I_Value + END SUBROUTINE CoSimIO_Info_SetBool + + + SUBROUTINE CoSimIO_Info_SetString(I_Info, I_Key, I_Value) BIND(C, NAME='CoSimIO_Info_SetString') + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), INTENT(IN),VALUE :: I_Info + CHARACTER(KIND=c_char), INTENT(IN) :: I_Key(*) + CHARACTER( KIND=c_char), INTENT(IN) :: I_Value(20) + END SUBROUTINE CoSimIO_Info_SetString + + + SUBROUTINE CoSimIO_Info_SetInfo(I_Info, I_Key, I_Value) BIND(C, NAME='CoSimIO_Info_SetInfo') + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Info + TYPE(CoSimIO_Info), INTENT(IN), VALUE :: I_Info + CHARACTER(len=1, KIND=c_char), DIMENSION(*) , INTENT(IN) :: I_Key + TYPE(CoSimIO_Info), INTENT(IN), VALUE :: I_Value + END SUBROUTINE CoSimIO_Info_SetInfo + + ! END: co_sim_io_c_info.h interface + + ! START: co_sim_io_c_model_part.h interface + ! NODE FUNCTIONS + + INTEGER(KIND=c_int) FUNCTION CoSimIO_Node_Id (I_Node) BIND(C, NAME="CoSimIO_Node_Id") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Node + TYPE(CoSimIO_Node), VALUE :: I_Node + END FUNCTION CoSimIO_Node_Id + + REAL(KIND=c_double) FUNCTION CoSimIO_Node_X (I_Node) BIND(C, NAME="CoSimIO_Node_X") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Node + TYPE(CoSimIO_Node), VALUE :: I_Node + END FUNCTION CoSimIO_Node_X + + REAL(KIND=c_double) FUNCTION CoSimIO_Node_Y (I_Node) BIND(C, NAME="CoSimIO_Node_Y") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Node + TYPE(CoSimIO_Node), VALUE :: I_Node + END FUNCTION CoSimIO_Node_Y + + REAL(KIND=c_double) FUNCTION CoSimIO_Node_Z (I_Node) BIND(C, NAME="CoSimIO_Node_Z") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Node + TYPE(CoSimIO_Node), VALUE :: I_Node + END FUNCTION CoSimIO_Node_Z + + REAL(KIND=c_double) FUNCTION CoSimIO_Node_Coordinate (I_Node, I_Index) BIND(C, NAME="CoSimIO_Node_Coordinate") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Node + TYPE(CoSimIO_Node), VALUE :: I_Node + INTEGER , VALUE :: I_Index + END FUNCTION CoSimIO_Node_Coordinate + + !ELEMENT FUNCTIONS + + INTEGER(KIND=c_int) FUNCTION CoSimIO_Element_Id (I_Element) BIND(C, NAME="CoSimIO_Element_Id") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Element + TYPE(CoSimIO_Element), VALUE :: I_Element + END FUNCTION CoSimIO_Element_Id + + INTEGER(KIND(CoSimIO_ElementType)) FUNCTION CoSimIO_Element_Type (I_Element) BIND(C, NAME="CoSimIO_Element_Type") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Element , CoSimIO_ElementType + TYPE(CoSimIO_Element), VALUE :: I_Element + END FUNCTION CoSimIO_Element_Type + + INTEGER(KIND=c_int) FUNCTION CoSimIO_Element_NumberOfNodes (I_Element) BIND(C, NAME="CoSimIO_Element_NumberOfNodes") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Element + TYPE(CoSimIO_Element), VALUE :: I_Element + END FUNCTION CoSimIO_Element_NumberOfNodes + + TYPE(CoSimIO_Node) FUNCTION CoSimIO_Element_GetNodeByIndex (I_Element,I_Index) + & BIND(C, NAME="CoSimIO_Element_GetNodeByIndex") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Node, CoSimIO_Element + TYPE(CoSimIO_Element), VALUE :: I_Element + INTEGER , VALUE :: I_Index + END FUNCTION CoSimIO_Element_GetNodeByIndex + + !MODELPART FUNCTIONS + + + + TYPE(CoSimIO_ModelPart) FUNCTION CoSimIO_CreateModelPart (I_Name) BIND(C, NAME="CoSimIO_CreateModelPart") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_ModelPart + CHARACTER(KIND=c_char), INTENT(IN) :: I_Name(*) + END FUNCTION CoSimIO_CreateModelPart + + INTEGER(KIND=c_int) FUNCTION CoSimIO_FreeModelPart (I_ModelPart) BIND(C, NAME="CoSimIO_FreeModelPart") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_ModelPart + TYPE(CoSimIO_ModelPart), VALUE :: I_ModelPart + END FUNCTION CoSimIO_FreeModelPart + + type(c_ptr) FUNCTION CoSimIO_ModelPart_Name (I_ModelPart) BIND(C, NAME="CoSimIO_ModelPart_Name") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_ModelPart + TYPE(CoSimIO_ModelPart), VALUE :: I_ModelPart + END FUNCTION CoSimIO_ModelPart_Name + + INTEGER(KIND=c_int) FUNCTION CoSimIO_ModelPart_NumberOfNodes (I_ModelPart) + & BIND(C, NAME="CoSimIO_ModelPart_NumberOfNodes") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_ModelPart + TYPE(CoSimIO_ModelPart), VALUE :: I_ModelPart + END FUNCTION CoSimIO_ModelPart_NumberOfNodes + + INTEGER(KIND=c_int) FUNCTION CoSimIO_ModelPart_NumberOfLocalNodes (I_ModelPart) + & BIND(C, NAME="CoSimIO_ModelPart_NumberOfLocalNodes") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_ModelPart + TYPE(CoSimIO_ModelPart), VALUE :: I_ModelPart + END FUNCTION CoSimIO_ModelPart_NumberOfLocalNodes + + INTEGER(KIND=c_int) FUNCTION CoSimIO_ModelPart_NumberOfGhostNodes (I_ModelPart) + & BIND(C, NAME="CoSimIO_ModelPart_NumberOfGhostNodes") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_ModelPart + TYPE(CoSimIO_ModelPart), VALUE :: I_ModelPart + END FUNCTION CoSimIO_ModelPart_NumberOfGhostNodes + + INTEGER(KIND=c_int) FUNCTION CoSimIO_ModelPart_NumberOfElements (I_ModelPart) + & BIND(C, NAME="CoSimIO_ModelPart_NumberOfElements") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_ModelPart + TYPE(CoSimIO_ModelPart), VALUE :: I_ModelPart + END FUNCTION CoSimIO_ModelPart_NumberOfElements + + TYPE(CoSimIO_Node) FUNCTION CoSimIO_ModelPart_GetNodeByIndex (I_ModelPart,I_Index) + & BIND(C, NAME="CoSimIO_ModelPart_GetNodeByIndex") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Node, CoSimIO_ModelPart + TYPE(CoSimIO_ModelPart), VALUE :: I_ModelPart + INTEGER , VALUE :: I_Index + END FUNCTION CoSimIO_ModelPart_GetNodeByIndex + + TYPE(CoSimIO_Node) FUNCTION CoSimIO_ModelPart_GetLocalNodeByIndex (I_ModelPart,I_Index) + & BIND(C, NAME="CoSimIO_ModelPart_GetLocalNodeByIndex") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Node, CoSimIO_ModelPart + TYPE(CoSimIO_ModelPart), VALUE :: I_ModelPart + INTEGER , VALUE :: I_Index + END FUNCTION CoSimIO_ModelPart_GetLocalNodeByIndex + + TYPE(CoSimIO_Node) FUNCTION CoSimIO_ModelPart_GetGhostNodeByIndex (I_ModelPart,I_Index) + & BIND(C, NAME="CoSimIO_ModelPart_GetGhostNodeByIndex") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Node, CoSimIO_ModelPart + TYPE(CoSimIO_ModelPart), VALUE :: I_ModelPart + INTEGER , VALUE :: I_Index + END FUNCTION CoSimIO_ModelPart_GetGhostNodeByIndex + + TYPE(CoSimIO_Node) FUNCTION CoSimIO_ModelPart_GetNodeById (I_ModelPart,I_Index) + & BIND(C, NAME="CoSimIO_ModelPart_GetNodeById") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Node, CoSimIO_ModelPart + TYPE(CoSimIO_ModelPart), VALUE :: I_ModelPart + INTEGER , VALUE :: I_Index + END FUNCTION CoSimIO_ModelPart_GetNodeById + + TYPE(CoSimIO_Element) FUNCTION CoSimIO_ModelPart_GetElementByIndex (I_ModelPart,I_Index) + & BIND(C, NAME="CoSimIO_ModelPart_GetElementByIndex") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Element, CoSimIO_ModelPart + TYPE(CoSimIO_ModelPart), VALUE :: I_ModelPart + INTEGER , VALUE :: I_Index + END FUNCTION CoSimIO_ModelPart_GetElementByIndex + + TYPE(CoSimIO_Element) FUNCTION CoSimIO_ModelPart_GetElementById (I_ModelPart,I_Index) + & BIND(C, NAME="CoSimIO_ModelPart_GetElementById") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Element, CoSimIO_ModelPart + TYPE(CoSimIO_ModelPart), VALUE :: I_ModelPart + INTEGER , VALUE :: I_Index + END FUNCTION CoSimIO_ModelPart_GetElementById + + + SUBROUTINE CoSimIO_ModelPart_Clear(I_ModelPart) BIND(C, NAME='CoSimIO_ModelPart_Clear') + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_ModelPart + TYPE(CoSimIO_ModelPart), INTENT(IN) , VALUE :: I_ModelPart + END SUBROUTINE CoSimIO_ModelPart_Clear + + TYPE(CoSimIO_Node) FUNCTION CoSimIO_ModelPart_CreateNewNode (I_ModelPart,I_Id,I_X,I_Y,I_Z) + & BIND(C, NAME="CoSimIO_ModelPart_CreateNewNode") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Node, CoSimIO_ModelPart + TYPE(CoSimIO_ModelPart), VALUE :: I_ModelPart + INTEGER , VALUE :: I_Id + REAL(kind=c_double), VALUE :: I_X + REAL(kind=c_double), VALUE :: I_Y + REAL(kind=c_double), VALUE :: I_Z + END FUNCTION CoSimIO_ModelPart_CreateNewNode + + TYPE(CoSimIO_Node) FUNCTION CoSimIO_ModelPart_CreateNewGhostNode (I_ModelPart,I_Id,I_X,I_Y,I_Z,PartitionIndex) + & BIND(C, NAME="CoSimIO_ModelPart_CreateNewGhostNode") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Node, CoSimIO_ModelPart + TYPE(CoSimIO_ModelPart), VALUE :: I_ModelPart + INTEGER , VALUE :: I_Id + REAL(kind=c_double), VALUE :: I_X + REAL(kind=c_double), VALUE :: I_Y + REAL(kind=c_double), VALUE :: I_Z + INTEGER , VALUE :: PartitionIndex + END FUNCTION CoSimIO_ModelPart_CreateNewGhostNode + + TYPE(CoSimIO_Element) FUNCTION CoSimIO_ModelPart_CreateNewElement (I_ModelPart,I_Id, I_Type, I_Connectivities) + & BIND(C, NAME="CoSimIO_ModelPart_CreateNewElement") + USE, INTRINSIC :: ISO_C_BINDING + IMPORT CoSimIO_Element, CoSimIO_ModelPart, CoSimIO_ElementType + TYPE(CoSimIO_ModelPart), VALUE :: I_ModelPart + INTEGER , VALUE :: I_Id + INTEGER(KIND(CoSimIO_ElementType)), VALUE :: I_Type + INTEGER(KIND=c_int),DIMENSION(*) :: I_Connectivities + END FUNCTION CoSimIO_ModelPart_CreateNewElement + + + + + ! END : co_sim_io_c_model_part.h interface + + + + END INTERFACE + + CONTAINS + + FUNCTION CoSimIO_Info_GetString_Wrapper(I_Info, I_Key) RESULT(f_string) + + USE, INTRINSIC :: ISO_C_BINDING, ONLY: c_ptr,c_f_pointer,c_char,c_null_char + + TYPE(CoSimIO_Info), VALUE :: I_Info + CHARACTER(LEN = 1, KIND=c_char), DIMENSION(*) :: I_Key + TYPE(c_ptr) :: c_string_pointer + CHARACTER(len=:), ALLOCATABLE :: f_string + CHARACTER(kind=c_char), DIMENSION(:), POINTER :: char_pointer => null() + CHARACTER(len=255) :: temp_string + INTEGER :: i,length + + IF (ALLOCATED(f_string)) DEALLOCATE (f_string) + + c_string_pointer = CoSimIO_Info_GetString(I_Info, I_Key) + + CALL c_f_pointer(c_string_pointer,char_pointer,[255]) + + temp_string = " " + DO i=1,255 + IF (char_pointer(i)==c_null_char) THEN + length=i-1;EXIT + END IF + temp_string(i:i)=char_pointer(i) + END DO + + ALLOCATE(CHARACTER(len=length)::f_string) + f_string = TRIM(temp_string(1:length))//ACHAR(0) + END FUNCTION CoSimIO_Info_GetString_Wrapper + + + FUNCTION CoSimIO_ModelPart_Name_Wrapper(I_ModelPart) RESULT(f_string) + + USE, INTRINSIC :: ISO_C_BINDING, ONLY: c_ptr,c_f_pointer,c_char,c_null_char + + TYPE(CoSimIO_ModelPart), VALUE :: I_ModelPart + TYPE(c_ptr) :: c_string_pointer + CHARACTER(len=:), ALLOCATABLE :: f_string + CHARACTER(kind=c_char), DIMENSION(:), POINTER :: char_pointer => null() + CHARACTER(len=255) :: temp_string + INTEGER :: i,length + + IF (ALLOCATED(f_string)) DEALLOCATE (f_string) + + c_string_pointer = CoSimIO_ModelPart_Name (I_ModelPart) + + CALL c_f_pointer(c_string_pointer,char_pointer,[255]) + + temp_string = " " + DO i=1,255 + IF (char_pointer(i)==c_null_char) THEN + length=i-1;EXIT + END IF + temp_string(i:i)=char_pointer(i) + END DO + + ALLOCATE(CHARACTER(len=length)::f_string) + f_string = TRIM(temp_string(1:length))//ACHAR(0) + + END FUNCTION CoSimIO_ModelPart_Name_Wrapper + + END MODULE co_sim_io \ No newline at end of file diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/includes/communication/pipe_communication.hpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/includes/communication/pipe_communication.hpp index 291e686398cb..6a4dc26b616b 100644 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/includes/communication/pipe_communication.hpp +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/includes/communication/pipe_communication.hpp @@ -108,13 +108,17 @@ class BidirectionalPipe private: + #ifndef CO_SIM_IO_COMPILED_IN_WINDOWS int mPipeHandleWrite; int mPipeHandleRead; + #endif fs::path mPipeNameWrite; fs::path mPipeNameRead; + #ifndef CO_SIM_IO_COMPILED_IN_WINDOWS std::size_t mBufferSize; + #endif void SendSize(const std::uint64_t Size); diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/includes/filesystem_inc.hpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/includes/filesystem_inc.hpp index 3808bf44b8dd..2d7dfac346fe 100644 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/includes/filesystem_inc.hpp +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/includes/filesystem_inc.hpp @@ -13,7 +13,22 @@ #ifndef CO_SIM_IO_FILESYSTEM_INC_INCLUDED #define CO_SIM_IO_FILESYSTEM_INC_INCLUDED -#include -namespace fs = std::filesystem; +/* std::filesystem is part of C++17 +While we use C++11, the alternative implementation from +"https://github.com/gulrak/filesystem" is used +*/ + +#ifndef WIN32_LEAN_AND_MEAN + #define WIN32_LEAN_AND_MEAN +#endif +#ifndef NOMINMAX + #define NOMINMAX +#endif +#include "ghc/filesystem.hpp" +namespace fs = ghc::filesystem; + +// use this once moving to C++17 +// #include +// namespace fs = std::filesystem; #endif // CO_SIM_IO_FILESYSTEM_INC_INCLUDED diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/includes/model_part.hpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/includes/model_part.hpp index 4fb428f65343..557462c644df 100644 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/includes/model_part.hpp +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/includes/model_part.hpp @@ -13,7 +13,7 @@ #ifndef CO_SIM_IO_MODEL_PART_INCLUDED #define CO_SIM_IO_MODEL_PART_INCLUDED -/* This file contains the implementation of the CoSimIO::ModelPart +/* This file contains the implementation of th CoSimIO::ModelPart It serves as a data container when exchanging data Also it is used in order to be consistent with Kratos to reduce compatibility problems This is a simplified version of Kratos::ModelPart @@ -432,11 +432,11 @@ class CO_SIM_IO_API ModelPart std::unique_ptr mpLocalModelPart; std::unique_ptr mpGhostModelPart; - // this contains the map of ModelPart with Ghost Nodes + // this contains the the map of ModelPart with Ghost Nodes // for communication / synchronization the same is needed for the local nodes, i.e. // the ModelPart needs to know where its local nodes exist as ghost nodes // in Kratos this is computed with the ParallelFillCommunicator - // It can be added here in the future if required + // Here is can be added in the future if required PartitionModelPartsContainerType mPartitionModelParts; NodesContainerType::const_iterator FindNode(const IdType I_Id) const; diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/python/CMakeLists.txt b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/python/CMakeLists.txt new file mode 100644 index 000000000000..021465d647f0 --- /dev/null +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/python/CMakeLists.txt @@ -0,0 +1,37 @@ +message("Configuring CoSimIO for Python") + +# TODO make this configureable +add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../../external_libraries/pybind11 dummy) + +pybind11_add_module(PyCoSimIO co_sim_io_python.cpp) + +target_link_libraries( PyCoSimIO PRIVATE co_sim_io ) + +install(TARGETS PyCoSimIO DESTINATION bin) +file(WRITE "${CMAKE_INSTALL_PREFIX}/bin/CoSimIO/__init__.py" "from PyCoSimIO import *\nfrom PyCoSimIO import __version__\n") + +set(CoSimIOMPIInitFile "${CMAKE_INSTALL_PREFIX}/bin/CoSimIO/mpi/__init__.py") +set(mpi4pyInterfaceInitFile "${CMAKE_INSTALL_PREFIX}/bin/CoSimIO/mpi/mpi4pyInterface/__init__.py") + +# dummy init files that give proper errors in case something related to MPI was not compiled +# These files will be overwritten if the corresponding option is enabled, hence here we can write then unconditionally +file(WRITE ${CoSimIOMPIInitFile} "raise Exception('CoSimIO was compiled without MPI support! (use \"CO_SIM_IO_BUILD_MPI\" to enable it)')\n") +file(WRITE ${mpi4pyInterfaceInitFile} "raise Exception('The mpi4py interface was not compiled! (use \"CO_SIM_IO_BUILD_PYTHON_MPI4PY_INTERFACE\" to enable it)')\n") + +if (CO_SIM_IO_BUILD_MPI) + pybind11_add_module(PyCoSimIOMPI co_sim_io_python_mpi.cpp) + + target_link_libraries( PyCoSimIOMPI PRIVATE co_sim_io co_sim_io_mpi ) + + install(TARGETS PyCoSimIOMPI DESTINATION bin) + file(WRITE ${CoSimIOMPIInitFile} "from PyCoSimIOMPI import *\n") + + OPTION ( CO_SIM_IO_BUILD_PYTHON_MPI4PY_INTERFACE "Building the interface to mpi4py MPI communicators" OFF ) + if (CO_SIM_IO_BUILD_PYTHON_MPI4PY_INTERFACE) + message("Building the interface to mpi4py MPI communicators") + pybind11_add_module(PyCoSimIOMPI_mpi4pyInterface mpi4py_interface.cpp) + target_link_libraries( PyCoSimIOMPI_mpi4pyInterface PRIVATE ${MPI_LIBRARIES} ) + install(TARGETS PyCoSimIOMPI_mpi4pyInterface DESTINATION bin) + file(WRITE ${mpi4pyInterfaceInitFile} "from PyCoSimIOMPI_mpi4pyInterface import *\n") + endif() +endif() diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/python/co_sim_io_python.cpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/python/co_sim_io_python.cpp new file mode 100644 index 000000000000..fe0505c074ac --- /dev/null +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/python/co_sim_io_python.cpp @@ -0,0 +1,80 @@ +// ______ _____ _ ________ +// / ____/___ / ___/(_)___ ___ / _/ __ | +// / / / __ \\__ \/ / __ `__ \ / // / / / +// / /___/ /_/ /__/ / / / / / / // // /_/ / +// \____/\____/____/_/_/ /_/ /_/___/\____/ +// Kratos CoSimulationApplication +// +// License: BSD License, see license.txt +// +// Main authors: Philipp Bucher (https://github.com/philbucher) +// + +// Exposure of the CoSimIO to Python + +// System includes +#include +#include +#include +#include + +// External includes +#include "intrusive_ptr/intrusive_ptr.hpp" + +// pybind includes +#include +#include +#include + +// must be done before CoSimIO includes +PYBIND11_DECLARE_HOLDER_TYPE(T, CoSimIO::intrusive_ptr) + +// CoSimIO includes +#include "co_sim_io.hpp" +#include "info_to_python.hpp" +#include "model_part_to_python.hpp" +#include "vector_to_python.hpp" +#include "connection_status_to_python.hpp" +#include "version_to_python.hpp" + + +PYBIND11_MODULE(PyCoSimIO, m) +{ + namespace py = pybind11; + + m.def("Hello", & CoSimIO::Hello); + + m.def("Connect", &CoSimIO::Connect); + m.def("Disconnect", &CoSimIO::Disconnect); + + m.def("ImportMesh", &CoSimIO::ImportMesh); + m.def("ExportMesh", &CoSimIO::ExportMesh); + + m.def("ImportData", [](const CoSimIO::Info& I_Info, CoSimIO::VectorWrapper& rValues){ + return CoSimIO::ImportData( + I_Info, + rValues.Vector()); + }); + m.def("ExportData", [](const CoSimIO::Info& I_Info, const CoSimIO::VectorWrapper& rValues){ + return CoSimIO::ExportData( + I_Info, + rValues.Vector()); + }); + + m.def("ImportInfo", &CoSimIO::ImportInfo); + m.def("ExportInfo", &CoSimIO::ExportInfo); + + // functions for CoSim-orchestrated CoSimulation + m.def("Run", &CoSimIO::Run); + + m.def("Register", []( + const CoSimIO::Info& I_Info, + std::function FunctionPointer) + { return CoSimIO::Register(I_Info, FunctionPointer); } ); + + CoSimIO::AddCoSimIOInfoToPython(m); + CoSimIO::AddCoSimIOModelPartToPython(m); + CoSimIO::AddCoSimIOVectorToPython(m); + CoSimIO::AddCoSimIOConnectionStatusToPython(m); + CoSimIO::AddCoSimIOVersionToPython(m); +} diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/python/co_sim_io_python_mpi.cpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/python/co_sim_io_python_mpi.cpp new file mode 100644 index 000000000000..efec3f23d361 --- /dev/null +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/python/co_sim_io_python_mpi.cpp @@ -0,0 +1,36 @@ +// ______ _____ _ ________ +// / ____/___ / ___/(_)___ ___ / _/ __ | +// / / / __ \\__ \/ / __ `__ \ / // / / / +// / /___/ /_/ /__/ / / / / / / // // /_/ / +// \____/\____/____/_/_/ /_/ /_/___/\____/ +// Kratos CoSimulationApplication +// +// License: BSD License, see license.txt +// +// Main authors: Philipp Bucher (https://github.com/philbucher) +// + +// Exposure of the CoSimIO MPI interface to Python + +// System includes +// pybind includes +#include + +// CoSimIO includes +#include "co_sim_io_mpi.hpp" +#include "mpi_comm_holder.hpp" + +PYBIND11_MODULE(PyCoSimIOMPI, m) +{ + namespace py = pybind11; + + m.def("ConnectMPI", [](const CoSimIO::Info& I_Info) + { return CoSimIO::ConnectMPI(I_Info, MPI_COMM_WORLD); }); + + m.def("ConnectMPI", [](const CoSimIO::Info& I_Info, const CoSimIO::MPICommHolder& holder) + { + return CoSimIO::ConnectMPI(I_Info, holder.GetMPIComm()); + }); + + py::class_>(m,"MPICommHolder"); +} diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/python/model_part_to_python.hpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/python/model_part_to_python.hpp new file mode 100644 index 000000000000..1194c0e2a8b8 --- /dev/null +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/python/model_part_to_python.hpp @@ -0,0 +1,129 @@ +// ______ _____ _ ________ +// / ____/___ / ___/(_)___ ___ / _/ __ | +// / / / __ \\__ \/ / __ `__ \ / // / / / +// / /___/ /_/ /__/ / / / / / / // // /_/ / +// \____/\____/____/_/_/ /_/ /_/___/\____/ +// Kratos CoSimulationApplication +// +// License: BSD License, see license.txt +// +// Main authors: Philipp Bucher (https://github.com/philbucher) +// + +#ifndef CO_SIM_IO_MODEL_PART_TO_PYHON_INCLUDED +#define CO_SIM_IO_MODEL_PART_TO_PYHON_INCLUDED + +// Exposure of the CoSimIO to Python + +// System includes +#include +#include + +// pybind includes +#include +#include + +// CoSimIO include +#include "includes/model_part.hpp" + +namespace CoSimIO { + +void AddCoSimIOModelPartToPython(pybind11::module& m) +{ + namespace py = pybind11; + + py::class_(m,"Node") + .def(py::init()) + .def(py::init()) + .def("Id", &CoSimIO::Node::Id) + .def("X", &CoSimIO::Node::X) + .def("Y", &CoSimIO::Node::Y) + .def("Z", &CoSimIO::Node::Z) + .def("Coordinates", &CoSimIO::Node::Coordinates) + .def("__str__", [](const CoSimIO::Node& I_Node) + { std::stringstream ss; ss << I_Node; return ss.str(); } ) + ; + + py::class_(m,"Element") + .def(py::init()) + .def("Id", &CoSimIO::Element::Id) + .def("Type", &CoSimIO::Element::Type) + .def("NumberOfNodes", &CoSimIO::Element::NumberOfNodes) + .def_property_readonly("Nodes", [](CoSimIO::Element& I_Element) { + return py::make_iterator(I_Element.NodesBegin(), I_Element.NodesEnd()); + }, py::keep_alive<0, 1>()) /* Keep vector alive while iterator is used */ + .def("__str__", [](const CoSimIO::Element& I_Element) + { std::stringstream ss; ss << I_Element; return ss.str(); } ) + ; + + py::class_(m,"ModelPart") + .def(py::init()) + .def("Name", &CoSimIO::ModelPart::Name) + .def("NumberOfNodes", &CoSimIO::ModelPart::NumberOfNodes) + .def("NumberOfLocalNodes", &CoSimIO::ModelPart::NumberOfLocalNodes) + .def("NumberOfGhostNodes", &CoSimIO::ModelPart::NumberOfGhostNodes) + .def("NumberOfElements", &CoSimIO::ModelPart::NumberOfElements) + .def("CreateNewNode", &CoSimIO::ModelPart::CreateNewNode, py::return_value_policy::reference_internal) + .def("CreateNewNodes", &CoSimIO::ModelPart::CreateNewNodes, + std::vector>) + .def("CreateNewGhostNode", &CoSimIO::ModelPart::CreateNewGhostNode, py::return_value_policy::reference_internal) + .def("CreateNewGhostNodes", &CoSimIO::ModelPart::CreateNewGhostNodes, + std::vector, + std::vector>) + .def("CreateNewElement", &CoSimIO::ModelPart::CreateNewElement, py::return_value_policy::reference_internal) + .def("CreateNewElements", &CoSimIO::ModelPart::CreateNewElements, + std::vector, + std::vector>) + .def("GetNode", [](CoSimIO::ModelPart& I_ModelPart, const CoSimIO::IdType I_Id){ + return I_ModelPart.pGetNode(I_Id);}, py::return_value_policy::reference_internal) + .def("GetElement", [](CoSimIO::ModelPart& I_ModelPart, const CoSimIO::IdType I_Id){ + return I_ModelPart.pGetElement(I_Id);}, py::return_value_policy::reference_internal) + .def_property_readonly("Nodes", [](CoSimIO::ModelPart& I_ModelPart) { + return py::make_iterator(I_ModelPart.NodesBegin(), I_ModelPart.NodesEnd()); + }, py::keep_alive<0, 1>()) /* Keep vector alive while iterator is used */ + .def_property_readonly("LocalNodes", [](CoSimIO::ModelPart& I_ModelPart) { + return py::make_iterator(I_ModelPart.LocalNodesBegin(), I_ModelPart.LocalNodesEnd()); + }, py::keep_alive<0, 1>()) /* Keep vector alive while iterator is used */ + .def_property_readonly("GhostNodes", [](CoSimIO::ModelPart& I_ModelPart) { + return py::make_iterator(I_ModelPart.GhostNodesBegin(), I_ModelPart.GhostNodesEnd()); + }, py::keep_alive<0, 1>()) /* Keep vector alive while iterator is used */ + .def_property_readonly("Elements", [](CoSimIO::ModelPart& I_ModelPart) { + return py::make_iterator(I_ModelPart.ElementsBegin(), I_ModelPart.ElementsEnd()); + }, py::keep_alive<0, 1>()) /* Keep vector alive while iterator is used */ + .def("Clear", &CoSimIO::ModelPart::Clear) + .def("__str__", [](const CoSimIO::ModelPart& I_ModelPart) + { std::stringstream ss; ss << I_ModelPart; return ss.str(); } ) + ; + + py::enum_(m,"ElementType") + .value("Hexahedra3D20", CoSimIO::ElementType::Hexahedra3D20) + .value("Hexahedra3D27", CoSimIO::ElementType::Hexahedra3D27) + .value("Hexahedra3D8", CoSimIO::ElementType::Hexahedra3D8) + .value("Prism3D15", CoSimIO::ElementType::Prism3D15) + .value("Prism3D6", CoSimIO::ElementType::Prism3D6) + .value("Pyramid3D13", CoSimIO::ElementType::Pyramid3D13) + .value("Pyramid3D5", CoSimIO::ElementType::Pyramid3D5) + .value("Quadrilateral2D4", CoSimIO::ElementType::Quadrilateral2D4) + .value("Quadrilateral2D8", CoSimIO::ElementType::Quadrilateral2D8) + .value("Quadrilateral2D9", CoSimIO::ElementType::Quadrilateral2D9) + .value("Quadrilateral3D4", CoSimIO::ElementType::Quadrilateral3D4) + .value("Quadrilateral3D8", CoSimIO::ElementType::Quadrilateral3D8) + .value("Quadrilateral3D9", CoSimIO::ElementType::Quadrilateral3D9) + .value("Tetrahedra3D10", CoSimIO::ElementType::Tetrahedra3D10) + .value("Tetrahedra3D4", CoSimIO::ElementType::Tetrahedra3D4) + .value("Triangle2D3", CoSimIO::ElementType::Triangle2D3) + .value("Triangle2D6", CoSimIO::ElementType::Triangle2D6) + .value("Triangle3D3", CoSimIO::ElementType::Triangle3D3) + .value("Triangle3D6", CoSimIO::ElementType::Triangle3D6) + .value("Line2D2", CoSimIO::ElementType::Line2D2) + .value("Line2D3", CoSimIO::ElementType::Line2D3) + .value("Line3D2", CoSimIO::ElementType::Line3D2) + .value("Line3D3", CoSimIO::ElementType::Line3D3) + .value("Point2D", CoSimIO::ElementType::Point2D) + .value("Point3D", CoSimIO::ElementType::Point3D) + ; +} + +} // namespace CoSimIO + +#endif // CO_SIM_IO_MODEL_PART_TO_PYHON_INCLUDED diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/python/mpi4py_interface.cpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/python/mpi4py_interface.cpp new file mode 100644 index 000000000000..78de17d732bb --- /dev/null +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/python/mpi4py_interface.cpp @@ -0,0 +1,58 @@ +// ______ _____ _ ________ +// / ____/___ / ___/(_)___ ___ / _/ __ | +// / / / __ \\__ \/ / __ `__ \ / // / / / +// / /___/ /_/ /__/ / / / / / / // // /_/ / +// \____/\____/____/_/_/ /_/ /_/___/\____/ +// Kratos CoSimulationApplication +// +// License: BSD License, see license.txt +// +// Main authors: Philipp Bucher (https://github.com/philbucher) +// + +// System includes +#include + +// External includes +#include +#include + +// Project includes +#include "mpi_comm_holder.hpp" + + +namespace py = pybind11; + +class mpi4pyCommHolder : public CoSimIO::MPICommHolder +{ +public: + mpi4pyCommHolder(py::object PyComm) : CoSimIO::MPICommHolder(GetMPICommFromPybindObject(PyComm)) {} + +private: + MPI_Comm GetMPICommFromPybindObject(py::object PyComm) + { + PyObject *py_src = PyComm.ptr(); + + // import the mpi4py API + // must be done before any calls to mpi4py + // seems to be safe to call it multiple times + import_mpi4py(); + + // Check that we have been passed an mpi4py communicator + if (PyObject_TypeCheck(py_src, &PyMPIComm_Type)) { + // Convert to regular MPI communicator + return *(PyMPIComm_Get(py_src)); + } else { + throw std::runtime_error("A mpi4py Communictor object must be passed!"); + } + } +}; + +PYBIND11_MODULE(PyCoSimIOMPI_mpi4pyInterface, m) +{ + namespace py = pybind11; + + py::class_, CoSimIO::MPICommHolder>(m,"mpi4pyCommHolder") + .def(py::init()) + ; +} diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/python/mpi_comm_holder.hpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/python/mpi_comm_holder.hpp new file mode 100644 index 000000000000..71b0f9e1bcec --- /dev/null +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/python/mpi_comm_holder.hpp @@ -0,0 +1,35 @@ +// ______ _____ _ ________ +// / ____/___ / ___/(_)___ ___ / _/ __ | +// / / / __ \\__ \/ / __ `__ \ / // / / / +// / /___/ /_/ /__/ / / / / / / // // /_/ / +// \____/\____/____/_/_/ /_/ /_/___/\____/ +// Kratos CoSimulationApplication +// +// License: BSD License, see license.txt +// +// Main authors: Philipp Bucher (https://github.com/philbucher) +// + +#ifndef CO_SIM_IO_PYHON_MPI_COMM_HOLDER_INCLUDED +#define CO_SIM_IO_PYHON_MPI_COMM_HOLDER_INCLUDED + +// External includes +#include "mpi.h" + +namespace CoSimIO { + +class MPICommHolder +{ +public: + MPICommHolder(MPI_Comm Comm) : mComm(Comm) {} + virtual ~MPICommHolder() = default; + + MPI_Comm GetMPIComm() const {return mComm;} + +private: + MPI_Comm mComm; +}; + +} // namespace CoSimIO + +#endif // CO_SIM_IO_PYHON_MPI_COMM_HOLDER_INCLUDED diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/sources/communication/base_socket_communication.cpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/sources/communication/base_socket_communication.cpp index a5fb6806d4d4..8f71c4c1e85a 100644 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/sources/communication/base_socket_communication.cpp +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/sources/communication/base_socket_communication.cpp @@ -19,7 +19,7 @@ namespace CoSimIO { namespace Internals { template -BaseSocketCommunication::~BaseSocketCommunication() +BaseSocketCommunication::~BaseSocketCommunication() { CO_SIM_IO_TRY diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/sources/communication/pipe_communication.cpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/sources/communication/pipe_communication.cpp index 9ca4083834f4..50a7c8254fc8 100644 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/sources/communication/pipe_communication.cpp +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/sources/communication/pipe_communication.cpp @@ -114,7 +114,10 @@ PipeCommunication::BidirectionalPipe::BidirectionalPipe( const fs::path& rBasePipeName, const bool IsPrimary, const int BufferSize, - const int EchoLevel) : mBufferSize(BufferSize) + const int EchoLevel) + #ifndef CO_SIM_IO_COMPILED_IN_WINDOWS + : mBufferSize(BufferSize) + #endif { mPipeNameWrite = mPipeNameRead = rPipeDir / rBasePipeName; diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/sources/vtk_utilities.cpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/sources/vtk_utilities.cpp index 1beb0052f298..22fe097ec492 100644 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/sources/vtk_utilities.cpp +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/co_sim_io/sources/vtk_utilities.cpp @@ -88,7 +88,7 @@ void WriteVtk(const Info& I_Settings, const ModelPart& I_ModelPart) } // write cells connectivity - const auto const_id_map = id_map; // const reference to not accidentally modify the map + const auto const_id_map = id_map; // const reference to not accidentially modify the map output_file << "CELLS " << I_ModelPart.NumberOfElements() << " " << cell_list_size << "\n"; for (const auto& r_elem : I_ModelPart.Elements()) { const std::size_t num_nodes_cell = r_elem.NumberOfNodes(); diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/COPYING b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/COPYING index 4540e01fcc0f..da1a2db4d7bb 100644 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/COPYING +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/COPYING @@ -1,4 +1,4 @@ -Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com) +Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com) Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/README b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/README index 6ef60c29a8a7..cdc6c6667b05 100644 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/README +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/README @@ -1,4 +1,4 @@ -asio version 1.28.0 -Released Wednesday, 26 April 2023. +asio version 1.32.0 +Released Thursday, 15 August 2024. See doc/index.html for API documentation and a tutorial. diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/Makefile.am b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/Makefile.am deleted file mode 100644 index d7a9b9c60878..000000000000 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/Makefile.am +++ /dev/null @@ -1,678 +0,0 @@ -# find . -name "*.*pp" | sed -e 's/^\.\///' | sed -e 's/^.*$/ & \\/' | sort -nobase_include_HEADERS = \ - asio/any_completion_executor.hpp \ - asio/any_completion_handler.hpp \ - asio/any_io_executor.hpp \ - asio/append.hpp \ - asio/as_tuple.hpp \ - asio/associated_allocator.hpp \ - asio/associated_cancellation_slot.hpp \ - asio/associated_executor.hpp \ - asio/associated_immediate_executor.hpp \ - asio/associator.hpp \ - asio/async_result.hpp \ - asio/awaitable.hpp \ - asio/basic_datagram_socket.hpp \ - asio/basic_deadline_timer.hpp \ - asio/basic_file.hpp \ - asio/basic_io_object.hpp \ - asio/basic_random_access_file.hpp \ - asio/basic_raw_socket.hpp \ - asio/basic_readable_pipe.hpp \ - asio/basic_seq_packet_socket.hpp \ - asio/basic_serial_port.hpp \ - asio/basic_signal_set.hpp \ - asio/basic_socket_acceptor.hpp \ - asio/basic_socket.hpp \ - asio/basic_socket_iostream.hpp \ - asio/basic_socket_streambuf.hpp \ - asio/basic_streambuf_fwd.hpp \ - asio/basic_streambuf.hpp \ - asio/basic_stream_file.hpp \ - asio/basic_stream_socket.hpp \ - asio/basic_waitable_timer.hpp \ - asio/basic_writable_pipe.hpp \ - asio/bind_allocator.hpp \ - asio/bind_cancellation_slot.hpp \ - asio/bind_executor.hpp \ - asio/bind_immediate_executor.hpp \ - asio/buffered_read_stream_fwd.hpp \ - asio/buffered_read_stream.hpp \ - asio/buffered_stream_fwd.hpp \ - asio/buffered_stream.hpp \ - asio/buffered_write_stream_fwd.hpp \ - asio/buffered_write_stream.hpp \ - asio/buffer.hpp \ - asio/buffer_registration.hpp \ - asio/buffers_iterator.hpp \ - asio/cancellation_signal.hpp \ - asio/cancellation_state.hpp \ - asio/cancellation_type.hpp \ - asio/co_spawn.hpp \ - asio/completion_condition.hpp \ - asio/compose.hpp \ - asio/connect.hpp \ - asio/connect_pipe.hpp \ - asio/consign.hpp \ - asio/coroutine.hpp \ - asio/deadline_timer.hpp \ - asio/defer.hpp \ - asio/deferred.hpp \ - asio/detached.hpp \ - asio/detail/array_fwd.hpp \ - asio/detail/array.hpp \ - asio/detail/assert.hpp \ - asio/detail/atomic_count.hpp \ - asio/detail/base_from_cancellation_state.hpp \ - asio/detail/base_from_completion_cond.hpp \ - asio/detail/bind_handler.hpp \ - asio/detail/blocking_executor_op.hpp \ - asio/detail/buffered_stream_storage.hpp \ - asio/detail/buffer_resize_guard.hpp \ - asio/detail/buffer_sequence_adapter.hpp \ - asio/detail/bulk_executor_op.hpp \ - asio/detail/call_stack.hpp \ - asio/detail/chrono.hpp \ - asio/detail/chrono_time_traits.hpp \ - asio/detail/completion_handler.hpp \ - asio/detail/composed_work.hpp \ - asio/detail/concurrency_hint.hpp \ - asio/detail/conditionally_enabled_event.hpp \ - asio/detail/conditionally_enabled_mutex.hpp \ - asio/detail/config.hpp \ - asio/detail/consuming_buffers.hpp \ - asio/detail/cstddef.hpp \ - asio/detail/cstdint.hpp \ - asio/detail/date_time_fwd.hpp \ - asio/detail/deadline_timer_service.hpp \ - asio/detail/dependent_type.hpp \ - asio/detail/descriptor_ops.hpp \ - asio/detail/descriptor_read_op.hpp \ - asio/detail/descriptor_write_op.hpp \ - asio/detail/dev_poll_reactor.hpp \ - asio/detail/epoll_reactor.hpp \ - asio/detail/eventfd_select_interrupter.hpp \ - asio/detail/event.hpp \ - asio/detail/exception.hpp \ - asio/detail/executor_function.hpp \ - asio/detail/executor_op.hpp \ - asio/detail/fd_set_adapter.hpp \ - asio/detail/fenced_block.hpp \ - asio/detail/functional.hpp \ - asio/detail/future.hpp \ - asio/detail/gcc_arm_fenced_block.hpp \ - asio/detail/gcc_hppa_fenced_block.hpp \ - asio/detail/gcc_sync_fenced_block.hpp \ - asio/detail/gcc_x86_fenced_block.hpp \ - asio/detail/global.hpp \ - asio/detail/handler_alloc_helpers.hpp \ - asio/detail/handler_cont_helpers.hpp \ - asio/detail/handler_invoke_helpers.hpp \ - asio/detail/handler_tracking.hpp \ - asio/detail/handler_type_requirements.hpp \ - asio/detail/handler_work.hpp \ - asio/detail/hash_map.hpp \ - asio/detail/impl/buffer_sequence_adapter.ipp \ - asio/detail/impl/descriptor_ops.ipp \ - asio/detail/impl/dev_poll_reactor.hpp \ - asio/detail/impl/dev_poll_reactor.ipp \ - asio/detail/impl/epoll_reactor.hpp \ - asio/detail/impl/epoll_reactor.ipp \ - asio/detail/impl/eventfd_select_interrupter.ipp \ - asio/detail/impl/handler_tracking.ipp \ - asio/detail/impl/io_uring_descriptor_service.ipp \ - asio/detail/impl/io_uring_file_service.ipp \ - asio/detail/impl/io_uring_service.hpp \ - asio/detail/impl/io_uring_service.ipp \ - asio/detail/impl/io_uring_socket_service_base.ipp \ - asio/detail/impl/kqueue_reactor.hpp \ - asio/detail/impl/kqueue_reactor.ipp \ - asio/detail/impl/null_event.ipp \ - asio/detail/impl/pipe_select_interrupter.ipp \ - asio/detail/impl/posix_event.ipp \ - asio/detail/impl/posix_mutex.ipp \ - asio/detail/impl/posix_serial_port_service.ipp \ - asio/detail/impl/posix_thread.ipp \ - asio/detail/impl/posix_tss_ptr.ipp \ - asio/detail/impl/reactive_descriptor_service.ipp \ - asio/detail/impl/reactive_socket_service_base.ipp \ - asio/detail/impl/resolver_service_base.ipp \ - asio/detail/impl/scheduler.ipp \ - asio/detail/impl/select_reactor.hpp \ - asio/detail/impl/select_reactor.ipp \ - asio/detail/impl/service_registry.hpp \ - asio/detail/impl/service_registry.ipp \ - asio/detail/impl/signal_set_service.ipp \ - asio/detail/impl/socket_ops.ipp \ - asio/detail/impl/socket_select_interrupter.ipp \ - asio/detail/impl/strand_executor_service.hpp \ - asio/detail/impl/strand_executor_service.ipp \ - asio/detail/impl/strand_service.hpp \ - asio/detail/impl/strand_service.ipp \ - asio/detail/impl/thread_context.ipp \ - asio/detail/impl/throw_error.ipp \ - asio/detail/impl/timer_queue_ptime.ipp \ - asio/detail/impl/timer_queue_set.ipp \ - asio/detail/impl/win_event.ipp \ - asio/detail/impl/win_iocp_file_service.ipp \ - asio/detail/impl/win_iocp_handle_service.ipp \ - asio/detail/impl/win_iocp_io_context.hpp \ - asio/detail/impl/win_iocp_io_context.ipp \ - asio/detail/impl/win_iocp_serial_port_service.ipp \ - asio/detail/impl/win_iocp_socket_service_base.ipp \ - asio/detail/impl/win_mutex.ipp \ - asio/detail/impl/win_object_handle_service.ipp \ - asio/detail/impl/winrt_ssocket_service_base.ipp \ - asio/detail/impl/winrt_timer_scheduler.hpp \ - asio/detail/impl/winrt_timer_scheduler.ipp \ - asio/detail/impl/winsock_init.ipp \ - asio/detail/impl/win_static_mutex.ipp \ - asio/detail/impl/win_thread.ipp \ - asio/detail/impl/win_tss_ptr.ipp \ - asio/detail/initiate_defer.hpp \ - asio/detail/initiate_dispatch.hpp \ - asio/detail/initiate_post.hpp \ - asio/detail/io_control.hpp \ - asio/detail/io_object_impl.hpp \ - asio/detail/io_uring_descriptor_read_at_op.hpp \ - asio/detail/io_uring_descriptor_read_op.hpp \ - asio/detail/io_uring_descriptor_service.hpp \ - asio/detail/io_uring_descriptor_write_at_op.hpp \ - asio/detail/io_uring_descriptor_write_op.hpp \ - asio/detail/io_uring_file_service.hpp \ - asio/detail/io_uring_null_buffers_op.hpp \ - asio/detail/io_uring_operation.hpp \ - asio/detail/io_uring_service.hpp \ - asio/detail/io_uring_socket_accept_op.hpp \ - asio/detail/io_uring_socket_connect_op.hpp \ - asio/detail/io_uring_socket_recvfrom_op.hpp \ - asio/detail/io_uring_socket_recvmsg_op.hpp \ - asio/detail/io_uring_socket_recv_op.hpp \ - asio/detail/io_uring_socket_send_op.hpp \ - asio/detail/io_uring_socket_sendto_op.hpp \ - asio/detail/io_uring_socket_service_base.hpp \ - asio/detail/io_uring_socket_service.hpp \ - asio/detail/io_uring_wait_op.hpp \ - asio/detail/is_buffer_sequence.hpp \ - asio/detail/is_executor.hpp \ - asio/detail/keyword_tss_ptr.hpp \ - asio/detail/kqueue_reactor.hpp \ - asio/detail/limits.hpp \ - asio/detail/local_free_on_block_exit.hpp \ - asio/detail/macos_fenced_block.hpp \ - asio/detail/memory.hpp \ - asio/detail/mutex.hpp \ - asio/detail/non_const_lvalue.hpp \ - asio/detail/noncopyable.hpp \ - asio/detail/null_event.hpp \ - asio/detail/null_fenced_block.hpp \ - asio/detail/null_global.hpp \ - asio/detail/null_mutex.hpp \ - asio/detail/null_reactor.hpp \ - asio/detail/null_signal_blocker.hpp \ - asio/detail/null_socket_service.hpp \ - asio/detail/null_static_mutex.hpp \ - asio/detail/null_thread.hpp \ - asio/detail/null_tss_ptr.hpp \ - asio/detail/object_pool.hpp \ - asio/detail/old_win_sdk_compat.hpp \ - asio/detail/operation.hpp \ - asio/detail/op_queue.hpp \ - asio/detail/pipe_select_interrupter.hpp \ - asio/detail/pop_options.hpp \ - asio/detail/posix_event.hpp \ - asio/detail/posix_fd_set_adapter.hpp \ - asio/detail/posix_global.hpp \ - asio/detail/posix_mutex.hpp \ - asio/detail/posix_serial_port_service.hpp \ - asio/detail/posix_signal_blocker.hpp \ - asio/detail/posix_static_mutex.hpp \ - asio/detail/posix_thread.hpp \ - asio/detail/posix_tss_ptr.hpp \ - asio/detail/push_options.hpp \ - asio/detail/reactive_descriptor_service.hpp \ - asio/detail/reactive_null_buffers_op.hpp \ - asio/detail/reactive_socket_accept_op.hpp \ - asio/detail/reactive_socket_connect_op.hpp \ - asio/detail/reactive_socket_recvfrom_op.hpp \ - asio/detail/reactive_socket_recvmsg_op.hpp \ - asio/detail/reactive_socket_recv_op.hpp \ - asio/detail/reactive_socket_send_op.hpp \ - asio/detail/reactive_socket_sendto_op.hpp \ - asio/detail/reactive_socket_service_base.hpp \ - asio/detail/reactive_socket_service.hpp \ - asio/detail/reactive_wait_op.hpp \ - asio/detail/reactor.hpp \ - asio/detail/reactor_op.hpp \ - asio/detail/reactor_op_queue.hpp \ - asio/detail/recycling_allocator.hpp \ - asio/detail/regex_fwd.hpp \ - asio/detail/resolve_endpoint_op.hpp \ - asio/detail/resolve_op.hpp \ - asio/detail/resolve_query_op.hpp \ - asio/detail/resolver_service_base.hpp \ - asio/detail/resolver_service.hpp \ - asio/detail/scheduler.hpp \ - asio/detail/scheduler_operation.hpp \ - asio/detail/scheduler_task.hpp \ - asio/detail/scheduler_thread_info.hpp \ - asio/detail/scoped_lock.hpp \ - asio/detail/scoped_ptr.hpp \ - asio/detail/select_interrupter.hpp \ - asio/detail/select_reactor.hpp \ - asio/detail/service_registry.hpp \ - asio/detail/signal_blocker.hpp \ - asio/detail/signal_handler.hpp \ - asio/detail/signal_init.hpp \ - asio/detail/signal_op.hpp \ - asio/detail/signal_set_service.hpp \ - asio/detail/socket_holder.hpp \ - asio/detail/socket_ops.hpp \ - asio/detail/socket_option.hpp \ - asio/detail/socket_select_interrupter.hpp \ - asio/detail/socket_types.hpp \ - asio/detail/solaris_fenced_block.hpp \ - asio/detail/source_location.hpp \ - asio/detail/static_mutex.hpp \ - asio/detail/std_event.hpp \ - asio/detail/std_fenced_block.hpp \ - asio/detail/std_global.hpp \ - asio/detail/std_mutex.hpp \ - asio/detail/std_static_mutex.hpp \ - asio/detail/std_thread.hpp \ - asio/detail/strand_executor_service.hpp \ - asio/detail/strand_service.hpp \ - asio/detail/string_view.hpp \ - asio/detail/thread_context.hpp \ - asio/detail/thread_group.hpp \ - asio/detail/thread.hpp \ - asio/detail/thread_info_base.hpp \ - asio/detail/throw_error.hpp \ - asio/detail/throw_exception.hpp \ - asio/detail/timer_queue_base.hpp \ - asio/detail/timer_queue.hpp \ - asio/detail/timer_queue_ptime.hpp \ - asio/detail/timer_queue_set.hpp \ - asio/detail/timer_scheduler_fwd.hpp \ - asio/detail/timer_scheduler.hpp \ - asio/detail/tss_ptr.hpp \ - asio/detail/type_traits.hpp \ - asio/detail/utility.hpp \ - asio/detail/variadic_templates.hpp \ - asio/detail/wait_handler.hpp \ - asio/detail/wait_op.hpp \ - asio/detail/winapp_thread.hpp \ - asio/detail/wince_thread.hpp \ - asio/detail/win_event.hpp \ - asio/detail/win_fd_set_adapter.hpp \ - asio/detail/win_fenced_block.hpp \ - asio/detail/win_global.hpp \ - asio/detail/win_iocp_file_service.hpp \ - asio/detail/win_iocp_handle_read_op.hpp \ - asio/detail/win_iocp_handle_service.hpp \ - asio/detail/win_iocp_handle_write_op.hpp \ - asio/detail/win_iocp_io_context.hpp \ - asio/detail/win_iocp_null_buffers_op.hpp \ - asio/detail/win_iocp_operation.hpp \ - asio/detail/win_iocp_overlapped_op.hpp \ - asio/detail/win_iocp_overlapped_ptr.hpp \ - asio/detail/win_iocp_serial_port_service.hpp \ - asio/detail/win_iocp_socket_accept_op.hpp \ - asio/detail/win_iocp_socket_connect_op.hpp \ - asio/detail/win_iocp_socket_recvfrom_op.hpp \ - asio/detail/win_iocp_socket_recvmsg_op.hpp \ - asio/detail/win_iocp_socket_recv_op.hpp \ - asio/detail/win_iocp_socket_send_op.hpp \ - asio/detail/win_iocp_socket_service_base.hpp \ - asio/detail/win_iocp_socket_service.hpp \ - asio/detail/win_iocp_thread_info.hpp \ - asio/detail/win_iocp_wait_op.hpp \ - asio/detail/win_mutex.hpp \ - asio/detail/win_object_handle_service.hpp \ - asio/detail/winrt_async_manager.hpp \ - asio/detail/winrt_async_op.hpp \ - asio/detail/winrt_resolve_op.hpp \ - asio/detail/winrt_resolver_service.hpp \ - asio/detail/winrt_socket_connect_op.hpp \ - asio/detail/winrt_socket_recv_op.hpp \ - asio/detail/winrt_socket_send_op.hpp \ - asio/detail/winrt_ssocket_service_base.hpp \ - asio/detail/winrt_ssocket_service.hpp \ - asio/detail/winrt_timer_scheduler.hpp \ - asio/detail/winrt_utils.hpp \ - asio/detail/winsock_init.hpp \ - asio/detail/win_static_mutex.hpp \ - asio/detail/win_thread.hpp \ - asio/detail/win_tss_ptr.hpp \ - asio/detail/work_dispatcher.hpp \ - asio/detail/wrapped_handler.hpp \ - asio/dispatch.hpp \ - asio/error_code.hpp \ - asio/error.hpp \ - asio/execution.hpp \ - asio/execution_context.hpp \ - asio/execution/allocator.hpp \ - asio/execution/any_executor.hpp \ - asio/execution/bad_executor.hpp \ - asio/execution/blocking.hpp \ - asio/execution/blocking_adaptation.hpp \ - asio/execution/bulk_execute.hpp \ - asio/execution/bulk_guarantee.hpp \ - asio/execution/connect.hpp \ - asio/execution/context.hpp \ - asio/execution/context_as.hpp \ - asio/execution/detail/as_invocable.hpp \ - asio/execution/detail/as_operation.hpp \ - asio/execution/detail/as_receiver.hpp \ - asio/execution/detail/bulk_sender.hpp \ - asio/execution/detail/submit_receiver.hpp \ - asio/execution/detail/void_receiver.hpp \ - asio/execution/execute.hpp \ - asio/execution/executor.hpp \ - asio/execution/impl/bad_executor.ipp \ - asio/execution/impl/receiver_invocation_error.ipp \ - asio/execution/invocable_archetype.hpp \ - asio/execution/mapping.hpp \ - asio/execution/occupancy.hpp \ - asio/execution/operation_state.hpp \ - asio/execution/outstanding_work.hpp \ - asio/execution/prefer_only.hpp \ - asio/execution/receiver.hpp \ - asio/execution/receiver_invocation_error.hpp \ - asio/execution/relationship.hpp \ - asio/execution/schedule.hpp \ - asio/execution/scheduler.hpp \ - asio/execution/sender.hpp \ - asio/execution/set_done.hpp \ - asio/execution/set_error.hpp \ - asio/execution/set_value.hpp \ - asio/execution/start.hpp \ - asio/execution/submit.hpp \ - asio/executor.hpp \ - asio/executor_work_guard.hpp \ - asio/experimental/append.hpp \ - asio/experimental/as_single.hpp \ - asio/experimental/as_tuple.hpp \ - asio/experimental/awaitable_operators.hpp \ - asio/experimental/basic_channel.hpp \ - asio/experimental/basic_concurrent_channel.hpp \ - asio/experimental/cancellation_condition.hpp \ - asio/experimental/channel.hpp \ - asio/experimental/channel_error.hpp \ - asio/experimental/channel_traits.hpp \ - asio/experimental/co_composed.hpp \ - asio/experimental/co_spawn.hpp \ - asio/experimental/concurrent_channel.hpp \ - asio/experimental/coro.hpp \ - asio/experimental/coro_traits.hpp \ - asio/experimental/deferred.hpp \ - asio/experimental/detail/channel_handler.hpp \ - asio/experimental/detail/channel_message.hpp \ - asio/experimental/detail/channel_operation.hpp \ - asio/experimental/detail/channel_payload.hpp \ - asio/experimental/detail/channel_receive_op.hpp \ - asio/experimental/detail/channel_send_functions.hpp \ - asio/experimental/detail/channel_send_op.hpp \ - asio/experimental/detail/channel_service.hpp \ - asio/experimental/detail/coro_completion_handler.hpp \ - asio/experimental/detail/coro_promise_allocator.hpp \ - asio/experimental/detail/has_signature.hpp \ - asio/experimental/detail/impl/channel_service.hpp \ - asio/experimental/detail/partial_promise.hpp \ - asio/experimental/impl/as_single.hpp \ - asio/experimental/impl/channel_error.ipp \ - asio/experimental/impl/co_composed.hpp \ - asio/experimental/impl/coro.hpp \ - asio/experimental/impl/parallel_group.hpp \ - asio/experimental/impl/promise.hpp \ - asio/experimental/impl/use_coro.hpp \ - asio/experimental/impl/use_promise.hpp \ - asio/experimental/parallel_group.hpp \ - asio/experimental/prepend.hpp \ - asio/experimental/promise.hpp \ - asio/experimental/use_coro.hpp \ - asio/experimental/use_promise.hpp \ - asio/file_base.hpp \ - asio/generic/basic_endpoint.hpp \ - asio/generic/datagram_protocol.hpp \ - asio/generic/detail/endpoint.hpp \ - asio/generic/detail/impl/endpoint.ipp \ - asio/generic/raw_protocol.hpp \ - asio/generic/seq_packet_protocol.hpp \ - asio/generic/stream_protocol.hpp \ - asio/handler_alloc_hook.hpp \ - asio/handler_continuation_hook.hpp \ - asio/handler_invoke_hook.hpp \ - asio/high_resolution_timer.hpp \ - asio.hpp \ - asio/impl/any_completion_executor.ipp \ - asio/impl/any_io_executor.ipp \ - asio/impl/append.hpp \ - asio/impl/as_tuple.hpp \ - asio/impl/awaitable.hpp \ - asio/impl/buffered_read_stream.hpp \ - asio/impl/buffered_write_stream.hpp \ - asio/impl/cancellation_signal.ipp \ - asio/impl/co_spawn.hpp \ - asio/impl/connect.hpp \ - asio/impl/connect_pipe.hpp \ - asio/impl/connect_pipe.ipp \ - asio/impl/consign.hpp \ - asio/impl/deferred.hpp \ - asio/impl/detached.hpp \ - asio/impl/error_code.ipp \ - asio/impl/error.ipp \ - asio/impl/execution_context.hpp \ - asio/impl/execution_context.ipp \ - asio/impl/executor.hpp \ - asio/impl/executor.ipp \ - asio/impl/handler_alloc_hook.ipp \ - asio/impl/io_context.hpp \ - asio/impl/io_context.ipp \ - asio/impl/multiple_exceptions.ipp \ - asio/impl/prepend.hpp \ - asio/impl/read_at.hpp \ - asio/impl/read.hpp \ - asio/impl/read_until.hpp \ - asio/impl/redirect_error.hpp \ - asio/impl/serial_port_base.hpp \ - asio/impl/serial_port_base.ipp \ - asio/impl/spawn.hpp \ - asio/impl/src.hpp \ - asio/impl/system_context.hpp \ - asio/impl/system_context.ipp \ - asio/impl/system_executor.hpp \ - asio/impl/thread_pool.hpp \ - asio/impl/thread_pool.ipp \ - asio/impl/use_awaitable.hpp \ - asio/impl/use_future.hpp \ - asio/impl/write_at.hpp \ - asio/impl/write.hpp \ - asio/io_context.hpp \ - asio/io_context_strand.hpp \ - asio/io_service.hpp \ - asio/io_service_strand.hpp \ - asio/ip/address.hpp \ - asio/ip/address_v4.hpp \ - asio/ip/address_v4_iterator.hpp \ - asio/ip/address_v4_range.hpp \ - asio/ip/address_v6.hpp \ - asio/ip/address_v6_iterator.hpp \ - asio/ip/address_v6_range.hpp \ - asio/ip/bad_address_cast.hpp \ - asio/ip/basic_endpoint.hpp \ - asio/ip/basic_resolver_entry.hpp \ - asio/ip/basic_resolver.hpp \ - asio/ip/basic_resolver_iterator.hpp \ - asio/ip/basic_resolver_query.hpp \ - asio/ip/basic_resolver_results.hpp \ - asio/ip/detail/endpoint.hpp \ - asio/ip/detail/impl/endpoint.ipp \ - asio/ip/detail/socket_option.hpp \ - asio/ip/host_name.hpp \ - asio/ip/icmp.hpp \ - asio/ip/impl/address.hpp \ - asio/ip/impl/address.ipp \ - asio/ip/impl/address_v4.hpp \ - asio/ip/impl/address_v4.ipp \ - asio/ip/impl/address_v6.hpp \ - asio/ip/impl/address_v6.ipp \ - asio/ip/impl/basic_endpoint.hpp \ - asio/ip/impl/host_name.ipp \ - asio/ip/impl/network_v4.hpp \ - asio/ip/impl/network_v4.ipp \ - asio/ip/impl/network_v6.hpp \ - asio/ip/impl/network_v6.ipp \ - asio/ip/multicast.hpp \ - asio/ip/network_v4.hpp \ - asio/ip/network_v6.hpp \ - asio/ip/resolver_base.hpp \ - asio/ip/resolver_query_base.hpp \ - asio/ip/tcp.hpp \ - asio/ip/udp.hpp \ - asio/ip/unicast.hpp \ - asio/ip/v6_only.hpp \ - asio/is_applicable_property.hpp \ - asio/is_contiguous_iterator.hpp \ - asio/is_executor.hpp \ - asio/is_read_buffered.hpp \ - asio/is_write_buffered.hpp \ - asio/local/basic_endpoint.hpp \ - asio/local/connect_pair.hpp \ - asio/local/datagram_protocol.hpp \ - asio/local/detail/endpoint.hpp \ - asio/local/detail/impl/endpoint.ipp \ - asio/local/seq_packet_protocol.hpp \ - asio/local/stream_protocol.hpp \ - asio/multiple_exceptions.hpp \ - asio/packaged_task.hpp \ - asio/placeholders.hpp \ - asio/posix/basic_descriptor.hpp \ - asio/posix/basic_stream_descriptor.hpp \ - asio/posix/descriptor_base.hpp \ - asio/posix/descriptor.hpp \ - asio/posix/stream_descriptor.hpp \ - asio/post.hpp \ - asio/prefer.hpp \ - asio/prepend.hpp \ - asio/query.hpp \ - asio/random_access_file.hpp \ - asio/read_at.hpp \ - asio/read.hpp \ - asio/read_until.hpp \ - asio/readable_pipe.hpp \ - asio/recycling_allocator.hpp \ - asio/redirect_error.hpp \ - asio/registered_buffer.hpp \ - asio/require.hpp \ - asio/require_concept.hpp \ - asio/serial_port_base.hpp \ - asio/serial_port.hpp \ - asio/signal_set_base.hpp \ - asio/signal_set.hpp \ - asio/socket_base.hpp \ - asio/spawn.hpp \ - asio/ssl/context_base.hpp \ - asio/ssl/context.hpp \ - asio/ssl/detail/buffered_handshake_op.hpp \ - asio/ssl/detail/engine.hpp \ - asio/ssl/detail/handshake_op.hpp \ - asio/ssl/detail/impl/engine.ipp \ - asio/ssl/detail/impl/openssl_init.ipp \ - asio/ssl/detail/io.hpp \ - asio/ssl/detail/openssl_init.hpp \ - asio/ssl/detail/openssl_types.hpp \ - asio/ssl/detail/password_callback.hpp \ - asio/ssl/detail/read_op.hpp \ - asio/ssl/detail/shutdown_op.hpp \ - asio/ssl/detail/stream_core.hpp \ - asio/ssl/detail/verify_callback.hpp \ - asio/ssl/detail/write_op.hpp \ - asio/ssl/error.hpp \ - asio/ssl.hpp \ - asio/ssl/host_name_verification.hpp \ - asio/ssl/impl/context.hpp \ - asio/ssl/impl/context.ipp \ - asio/ssl/impl/error.ipp \ - asio/ssl/impl/host_name_verification.ipp \ - asio/ssl/impl/rfc2818_verification.ipp \ - asio/ssl/impl/src.hpp \ - asio/ssl/rfc2818_verification.hpp \ - asio/ssl/stream_base.hpp \ - asio/ssl/stream.hpp \ - asio/ssl/verify_context.hpp \ - asio/ssl/verify_mode.hpp \ - asio/static_thread_pool.hpp \ - asio/steady_timer.hpp \ - asio/strand.hpp \ - asio/streambuf.hpp \ - asio/stream_file.hpp \ - asio/system_context.hpp \ - asio/system_error.hpp \ - asio/system_executor.hpp \ - asio/system_timer.hpp \ - asio/this_coro.hpp \ - asio/thread.hpp \ - asio/thread_pool.hpp \ - asio/time_traits.hpp \ - asio/traits/bulk_execute_free.hpp \ - asio/traits/bulk_execute_member.hpp \ - asio/traits/connect_free.hpp \ - asio/traits/connect_member.hpp \ - asio/traits/equality_comparable.hpp \ - asio/traits/execute_free.hpp \ - asio/traits/execute_member.hpp \ - asio/traits/prefer_free.hpp \ - asio/traits/prefer_member.hpp \ - asio/traits/query_free.hpp \ - asio/traits/query_member.hpp \ - asio/traits/query_static_constexpr_member.hpp \ - asio/traits/require_concept_free.hpp \ - asio/traits/require_concept_member.hpp \ - asio/traits/require_free.hpp \ - asio/traits/require_member.hpp \ - asio/traits/schedule_free.hpp \ - asio/traits/schedule_member.hpp \ - asio/traits/set_done_free.hpp \ - asio/traits/set_done_member.hpp \ - asio/traits/set_error_free.hpp \ - asio/traits/set_error_member.hpp \ - asio/traits/set_value_free.hpp \ - asio/traits/set_value_member.hpp \ - asio/traits/start_free.hpp \ - asio/traits/start_member.hpp \ - asio/traits/static_query.hpp \ - asio/traits/static_require.hpp \ - asio/traits/static_require_concept.hpp \ - asio/traits/submit_free.hpp \ - asio/traits/submit_member.hpp \ - asio/ts/buffer.hpp \ - asio/ts/executor.hpp \ - asio/ts/internet.hpp \ - asio/ts/io_context.hpp \ - asio/ts/netfwd.hpp \ - asio/ts/net.hpp \ - asio/ts/socket.hpp \ - asio/ts/timer.hpp \ - asio/unyield.hpp \ - asio/use_awaitable.hpp \ - asio/use_future.hpp \ - asio/uses_executor.hpp \ - asio/version.hpp \ - asio/wait_traits.hpp \ - asio/windows/basic_object_handle.hpp \ - asio/windows/basic_overlapped_handle.hpp \ - asio/windows/basic_random_access_handle.hpp \ - asio/windows/basic_stream_handle.hpp \ - asio/windows/object_handle.hpp \ - asio/windows/overlapped_handle.hpp \ - asio/windows/overlapped_ptr.hpp \ - asio/windows/random_access_handle.hpp \ - asio/windows/stream_handle.hpp \ - asio/writable_pipe.hpp \ - asio/write_at.hpp \ - asio/write.hpp \ - asio/yield.hpp - -MAINTAINERCLEANFILES = \ - $(srcdir)/Makefile.in diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/Makefile.in b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/Makefile.in deleted file mode 100644 index 8ae22e5bd145..000000000000 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/Makefile.in +++ /dev/null @@ -1,1216 +0,0 @@ -# Makefile.in generated by automake 1.16.5 from Makefile.am. -# @configure_input@ - -# Copyright (C) 1994-2021 Free Software Foundation, Inc. - -# This Makefile.in is free software; the Free Software Foundation -# gives unlimited permission to copy and/or distribute it, -# with or without modifications, as long as this notice is preserved. - -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY, to the extent permitted by law; without -# even the implied warranty of MERCHANTABILITY or FITNESS FOR A -# PARTICULAR PURPOSE. - -@SET_MAKE@ - -VPATH = @srcdir@ -am__is_gnu_make = { \ - if test -z '$(MAKELEVEL)'; then \ - false; \ - elif test -n '$(MAKE_HOST)'; then \ - true; \ - elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ - true; \ - else \ - false; \ - fi; \ -} -am__make_running_with_option = \ - case $${target_option-} in \ - ?) ;; \ - *) echo "am__make_running_with_option: internal error: invalid" \ - "target option '$${target_option-}' specified" >&2; \ - exit 1;; \ - esac; \ - has_opt=no; \ - sane_makeflags=$$MAKEFLAGS; \ - if $(am__is_gnu_make); then \ - sane_makeflags=$$MFLAGS; \ - else \ - case $$MAKEFLAGS in \ - *\\[\ \ ]*) \ - bs=\\; \ - sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ - | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ - esac; \ - fi; \ - skip_next=no; \ - strip_trailopt () \ - { \ - flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ - }; \ - for flg in $$sane_makeflags; do \ - test $$skip_next = yes && { skip_next=no; continue; }; \ - case $$flg in \ - *=*|--*) continue;; \ - -*I) strip_trailopt 'I'; skip_next=yes;; \ - -*I?*) strip_trailopt 'I';; \ - -*O) strip_trailopt 'O'; skip_next=yes;; \ - -*O?*) strip_trailopt 'O';; \ - -*l) strip_trailopt 'l'; skip_next=yes;; \ - -*l?*) strip_trailopt 'l';; \ - -[dEDm]) skip_next=yes;; \ - -[JT]) skip_next=yes;; \ - esac; \ - case $$flg in \ - *$$target_option*) has_opt=yes; break;; \ - esac; \ - done; \ - test $$has_opt = yes -am__make_dryrun = (target_option=n; $(am__make_running_with_option)) -am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) -pkgdatadir = $(datadir)/@PACKAGE@ -pkgincludedir = $(includedir)/@PACKAGE@ -pkglibdir = $(libdir)/@PACKAGE@ -pkglibexecdir = $(libexecdir)/@PACKAGE@ -am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd -install_sh_DATA = $(install_sh) -c -m 644 -install_sh_PROGRAM = $(install_sh) -c -install_sh_SCRIPT = $(install_sh) -c -INSTALL_HEADER = $(INSTALL_DATA) -transform = $(program_transform_name) -NORMAL_INSTALL = : -PRE_INSTALL = : -POST_INSTALL = : -NORMAL_UNINSTALL = : -PRE_UNINSTALL = : -POST_UNINSTALL = : -build_triplet = @build@ -host_triplet = @host@ -subdir = include -ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 -am__aclocal_m4_deps = $(top_srcdir)/configure.ac -am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ - $(ACLOCAL_M4) -DIST_COMMON = $(srcdir)/Makefile.am $(nobase_include_HEADERS) \ - $(am__DIST_COMMON) -mkinstalldirs = $(install_sh) -d -CONFIG_CLEAN_FILES = -CONFIG_CLEAN_VPATH_FILES = -AM_V_P = $(am__v_P_@AM_V@) -am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) -am__v_P_0 = false -am__v_P_1 = : -AM_V_GEN = $(am__v_GEN_@AM_V@) -am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) -am__v_GEN_0 = @echo " GEN " $@; -am__v_GEN_1 = -AM_V_at = $(am__v_at_@AM_V@) -am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) -am__v_at_0 = @ -am__v_at_1 = -SOURCES = -DIST_SOURCES = -am__can_run_installinfo = \ - case $$AM_UPDATE_INFO_DIR in \ - n|no|NO) false;; \ - *) (install-info --version) >/dev/null 2>&1;; \ - esac -am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; -am__vpath_adj = case $$p in \ - $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ - *) f=$$p;; \ - esac; -am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; -am__install_max = 40 -am__nobase_strip_setup = \ - srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` -am__nobase_strip = \ - for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" -am__nobase_list = $(am__nobase_strip_setup); \ - for p in $$list; do echo "$$p $$p"; done | \ - sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ - $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ - if (++n[$$2] == $(am__install_max)) \ - { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ - END { for (dir in files) print dir, files[dir] }' -am__base_list = \ - sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ - sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' -am__uninstall_files_from_dir = { \ - test -z "$$files" \ - || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ - || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ - $(am__cd) "$$dir" && rm -f $$files; }; \ - } -am__installdirs = "$(DESTDIR)$(includedir)" -HEADERS = $(nobase_include_HEADERS) -am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) -# Read a list of newline-separated strings from the standard input, -# and print each of them once, without duplicates. Input order is -# *not* preserved. -am__uniquify_input = $(AWK) '\ - BEGIN { nonempty = 0; } \ - { items[$$0] = 1; nonempty = 1; } \ - END { if (nonempty) { for (i in items) print i; }; } \ -' -# Make sure the list of sources is unique. This is necessary because, -# e.g., the same source file might be shared among _SOURCES variables -# for different programs/libraries. -am__define_uniq_tagged_files = \ - list='$(am__tagged_files)'; \ - unique=`for i in $$list; do \ - if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ - done | $(am__uniquify_input)` -am__DIST_COMMON = $(srcdir)/Makefile.in -DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) -ACLOCAL = @ACLOCAL@ -AMTAR = @AMTAR@ -AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ -AUTOCONF = @AUTOCONF@ -AUTOHEADER = @AUTOHEADER@ -AUTOMAKE = @AUTOMAKE@ -AWK = @AWK@ -CC = @CC@ -CCDEPMODE = @CCDEPMODE@ -CFLAGS = @CFLAGS@ -CPPFLAGS = @CPPFLAGS@ -CSCOPE = @CSCOPE@ -CTAGS = @CTAGS@ -CXX = @CXX@ -CXXDEPMODE = @CXXDEPMODE@ -CXXFLAGS = @CXXFLAGS@ -CYGPATH_W = @CYGPATH_W@ -DEFS = @DEFS@ -DEPDIR = @DEPDIR@ -ECHO_C = @ECHO_C@ -ECHO_N = @ECHO_N@ -ECHO_T = @ECHO_T@ -ETAGS = @ETAGS@ -EXEEXT = @EXEEXT@ -INSTALL = @INSTALL@ -INSTALL_DATA = @INSTALL_DATA@ -INSTALL_PROGRAM = @INSTALL_PROGRAM@ -INSTALL_SCRIPT = @INSTALL_SCRIPT@ -INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ -LDFLAGS = @LDFLAGS@ -LIBOBJS = @LIBOBJS@ -LIBS = @LIBS@ -LTLIBOBJS = @LTLIBOBJS@ -MAINT = @MAINT@ -MAKEINFO = @MAKEINFO@ -MKDIR_P = @MKDIR_P@ -OBJEXT = @OBJEXT@ -PACKAGE = @PACKAGE@ -PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ -PACKAGE_NAME = @PACKAGE_NAME@ -PACKAGE_STRING = @PACKAGE_STRING@ -PACKAGE_TARNAME = @PACKAGE_TARNAME@ -PACKAGE_URL = @PACKAGE_URL@ -PACKAGE_VERSION = @PACKAGE_VERSION@ -PATH_SEPARATOR = @PATH_SEPARATOR@ -RANLIB = @RANLIB@ -SET_MAKE = @SET_MAKE@ -SHELL = @SHELL@ -STRIP = @STRIP@ -VERSION = @VERSION@ -abs_builddir = @abs_builddir@ -abs_srcdir = @abs_srcdir@ -abs_top_builddir = @abs_top_builddir@ -abs_top_srcdir = @abs_top_srcdir@ -ac_ct_CC = @ac_ct_CC@ -ac_ct_CXX = @ac_ct_CXX@ -am__include = @am__include@ -am__leading_dot = @am__leading_dot@ -am__quote = @am__quote@ -am__tar = @am__tar@ -am__untar = @am__untar@ -bindir = @bindir@ -build = @build@ -build_alias = @build_alias@ -build_cpu = @build_cpu@ -build_os = @build_os@ -build_vendor = @build_vendor@ -builddir = @builddir@ -datadir = @datadir@ -datarootdir = @datarootdir@ -docdir = @docdir@ -dvidir = @dvidir@ -exec_prefix = @exec_prefix@ -host = @host@ -host_alias = @host_alias@ -host_cpu = @host_cpu@ -host_os = @host_os@ -host_vendor = @host_vendor@ -htmldir = @htmldir@ -includedir = @includedir@ -infodir = @infodir@ -install_sh = @install_sh@ -libdir = @libdir@ -libexecdir = @libexecdir@ -localedir = @localedir@ -localstatedir = @localstatedir@ -mandir = @mandir@ -mkdir_p = @mkdir_p@ -oldincludedir = @oldincludedir@ -pdfdir = @pdfdir@ -pkgconfigdir = @pkgconfigdir@ -prefix = @prefix@ -program_transform_name = @program_transform_name@ -psdir = @psdir@ -runstatedir = @runstatedir@ -sbindir = @sbindir@ -sharedstatedir = @sharedstatedir@ -srcdir = @srcdir@ -sysconfdir = @sysconfdir@ -target_alias = @target_alias@ -top_build_prefix = @top_build_prefix@ -top_builddir = @top_builddir@ -top_srcdir = @top_srcdir@ - -# find . -name "*.*pp" | sed -e 's/^\.\///' | sed -e 's/^.*$/ & \\/' | sort -nobase_include_HEADERS = \ - asio/any_completion_executor.hpp \ - asio/any_completion_handler.hpp \ - asio/any_io_executor.hpp \ - asio/append.hpp \ - asio/as_tuple.hpp \ - asio/associated_allocator.hpp \ - asio/associated_cancellation_slot.hpp \ - asio/associated_executor.hpp \ - asio/associated_immediate_executor.hpp \ - asio/associator.hpp \ - asio/async_result.hpp \ - asio/awaitable.hpp \ - asio/basic_datagram_socket.hpp \ - asio/basic_deadline_timer.hpp \ - asio/basic_file.hpp \ - asio/basic_io_object.hpp \ - asio/basic_random_access_file.hpp \ - asio/basic_raw_socket.hpp \ - asio/basic_readable_pipe.hpp \ - asio/basic_seq_packet_socket.hpp \ - asio/basic_serial_port.hpp \ - asio/basic_signal_set.hpp \ - asio/basic_socket_acceptor.hpp \ - asio/basic_socket.hpp \ - asio/basic_socket_iostream.hpp \ - asio/basic_socket_streambuf.hpp \ - asio/basic_streambuf_fwd.hpp \ - asio/basic_streambuf.hpp \ - asio/basic_stream_file.hpp \ - asio/basic_stream_socket.hpp \ - asio/basic_waitable_timer.hpp \ - asio/basic_writable_pipe.hpp \ - asio/bind_allocator.hpp \ - asio/bind_cancellation_slot.hpp \ - asio/bind_executor.hpp \ - asio/bind_immediate_executor.hpp \ - asio/buffered_read_stream_fwd.hpp \ - asio/buffered_read_stream.hpp \ - asio/buffered_stream_fwd.hpp \ - asio/buffered_stream.hpp \ - asio/buffered_write_stream_fwd.hpp \ - asio/buffered_write_stream.hpp \ - asio/buffer.hpp \ - asio/buffer_registration.hpp \ - asio/buffers_iterator.hpp \ - asio/cancellation_signal.hpp \ - asio/cancellation_state.hpp \ - asio/cancellation_type.hpp \ - asio/co_spawn.hpp \ - asio/completion_condition.hpp \ - asio/compose.hpp \ - asio/connect.hpp \ - asio/connect_pipe.hpp \ - asio/consign.hpp \ - asio/coroutine.hpp \ - asio/deadline_timer.hpp \ - asio/defer.hpp \ - asio/deferred.hpp \ - asio/detached.hpp \ - asio/detail/array_fwd.hpp \ - asio/detail/array.hpp \ - asio/detail/assert.hpp \ - asio/detail/atomic_count.hpp \ - asio/detail/base_from_cancellation_state.hpp \ - asio/detail/base_from_completion_cond.hpp \ - asio/detail/bind_handler.hpp \ - asio/detail/blocking_executor_op.hpp \ - asio/detail/buffered_stream_storage.hpp \ - asio/detail/buffer_resize_guard.hpp \ - asio/detail/buffer_sequence_adapter.hpp \ - asio/detail/bulk_executor_op.hpp \ - asio/detail/call_stack.hpp \ - asio/detail/chrono.hpp \ - asio/detail/chrono_time_traits.hpp \ - asio/detail/completion_handler.hpp \ - asio/detail/composed_work.hpp \ - asio/detail/concurrency_hint.hpp \ - asio/detail/conditionally_enabled_event.hpp \ - asio/detail/conditionally_enabled_mutex.hpp \ - asio/detail/config.hpp \ - asio/detail/consuming_buffers.hpp \ - asio/detail/cstddef.hpp \ - asio/detail/cstdint.hpp \ - asio/detail/date_time_fwd.hpp \ - asio/detail/deadline_timer_service.hpp \ - asio/detail/dependent_type.hpp \ - asio/detail/descriptor_ops.hpp \ - asio/detail/descriptor_read_op.hpp \ - asio/detail/descriptor_write_op.hpp \ - asio/detail/dev_poll_reactor.hpp \ - asio/detail/epoll_reactor.hpp \ - asio/detail/eventfd_select_interrupter.hpp \ - asio/detail/event.hpp \ - asio/detail/exception.hpp \ - asio/detail/executor_function.hpp \ - asio/detail/executor_op.hpp \ - asio/detail/fd_set_adapter.hpp \ - asio/detail/fenced_block.hpp \ - asio/detail/functional.hpp \ - asio/detail/future.hpp \ - asio/detail/gcc_arm_fenced_block.hpp \ - asio/detail/gcc_hppa_fenced_block.hpp \ - asio/detail/gcc_sync_fenced_block.hpp \ - asio/detail/gcc_x86_fenced_block.hpp \ - asio/detail/global.hpp \ - asio/detail/handler_alloc_helpers.hpp \ - asio/detail/handler_cont_helpers.hpp \ - asio/detail/handler_invoke_helpers.hpp \ - asio/detail/handler_tracking.hpp \ - asio/detail/handler_type_requirements.hpp \ - asio/detail/handler_work.hpp \ - asio/detail/hash_map.hpp \ - asio/detail/impl/buffer_sequence_adapter.ipp \ - asio/detail/impl/descriptor_ops.ipp \ - asio/detail/impl/dev_poll_reactor.hpp \ - asio/detail/impl/dev_poll_reactor.ipp \ - asio/detail/impl/epoll_reactor.hpp \ - asio/detail/impl/epoll_reactor.ipp \ - asio/detail/impl/eventfd_select_interrupter.ipp \ - asio/detail/impl/handler_tracking.ipp \ - asio/detail/impl/io_uring_descriptor_service.ipp \ - asio/detail/impl/io_uring_file_service.ipp \ - asio/detail/impl/io_uring_service.hpp \ - asio/detail/impl/io_uring_service.ipp \ - asio/detail/impl/io_uring_socket_service_base.ipp \ - asio/detail/impl/kqueue_reactor.hpp \ - asio/detail/impl/kqueue_reactor.ipp \ - asio/detail/impl/null_event.ipp \ - asio/detail/impl/pipe_select_interrupter.ipp \ - asio/detail/impl/posix_event.ipp \ - asio/detail/impl/posix_mutex.ipp \ - asio/detail/impl/posix_serial_port_service.ipp \ - asio/detail/impl/posix_thread.ipp \ - asio/detail/impl/posix_tss_ptr.ipp \ - asio/detail/impl/reactive_descriptor_service.ipp \ - asio/detail/impl/reactive_socket_service_base.ipp \ - asio/detail/impl/resolver_service_base.ipp \ - asio/detail/impl/scheduler.ipp \ - asio/detail/impl/select_reactor.hpp \ - asio/detail/impl/select_reactor.ipp \ - asio/detail/impl/service_registry.hpp \ - asio/detail/impl/service_registry.ipp \ - asio/detail/impl/signal_set_service.ipp \ - asio/detail/impl/socket_ops.ipp \ - asio/detail/impl/socket_select_interrupter.ipp \ - asio/detail/impl/strand_executor_service.hpp \ - asio/detail/impl/strand_executor_service.ipp \ - asio/detail/impl/strand_service.hpp \ - asio/detail/impl/strand_service.ipp \ - asio/detail/impl/thread_context.ipp \ - asio/detail/impl/throw_error.ipp \ - asio/detail/impl/timer_queue_ptime.ipp \ - asio/detail/impl/timer_queue_set.ipp \ - asio/detail/impl/win_event.ipp \ - asio/detail/impl/win_iocp_file_service.ipp \ - asio/detail/impl/win_iocp_handle_service.ipp \ - asio/detail/impl/win_iocp_io_context.hpp \ - asio/detail/impl/win_iocp_io_context.ipp \ - asio/detail/impl/win_iocp_serial_port_service.ipp \ - asio/detail/impl/win_iocp_socket_service_base.ipp \ - asio/detail/impl/win_mutex.ipp \ - asio/detail/impl/win_object_handle_service.ipp \ - asio/detail/impl/winrt_ssocket_service_base.ipp \ - asio/detail/impl/winrt_timer_scheduler.hpp \ - asio/detail/impl/winrt_timer_scheduler.ipp \ - asio/detail/impl/winsock_init.ipp \ - asio/detail/impl/win_static_mutex.ipp \ - asio/detail/impl/win_thread.ipp \ - asio/detail/impl/win_tss_ptr.ipp \ - asio/detail/initiate_defer.hpp \ - asio/detail/initiate_dispatch.hpp \ - asio/detail/initiate_post.hpp \ - asio/detail/io_control.hpp \ - asio/detail/io_object_impl.hpp \ - asio/detail/io_uring_descriptor_read_at_op.hpp \ - asio/detail/io_uring_descriptor_read_op.hpp \ - asio/detail/io_uring_descriptor_service.hpp \ - asio/detail/io_uring_descriptor_write_at_op.hpp \ - asio/detail/io_uring_descriptor_write_op.hpp \ - asio/detail/io_uring_file_service.hpp \ - asio/detail/io_uring_null_buffers_op.hpp \ - asio/detail/io_uring_operation.hpp \ - asio/detail/io_uring_service.hpp \ - asio/detail/io_uring_socket_accept_op.hpp \ - asio/detail/io_uring_socket_connect_op.hpp \ - asio/detail/io_uring_socket_recvfrom_op.hpp \ - asio/detail/io_uring_socket_recvmsg_op.hpp \ - asio/detail/io_uring_socket_recv_op.hpp \ - asio/detail/io_uring_socket_send_op.hpp \ - asio/detail/io_uring_socket_sendto_op.hpp \ - asio/detail/io_uring_socket_service_base.hpp \ - asio/detail/io_uring_socket_service.hpp \ - asio/detail/io_uring_wait_op.hpp \ - asio/detail/is_buffer_sequence.hpp \ - asio/detail/is_executor.hpp \ - asio/detail/keyword_tss_ptr.hpp \ - asio/detail/kqueue_reactor.hpp \ - asio/detail/limits.hpp \ - asio/detail/local_free_on_block_exit.hpp \ - asio/detail/macos_fenced_block.hpp \ - asio/detail/memory.hpp \ - asio/detail/mutex.hpp \ - asio/detail/non_const_lvalue.hpp \ - asio/detail/noncopyable.hpp \ - asio/detail/null_event.hpp \ - asio/detail/null_fenced_block.hpp \ - asio/detail/null_global.hpp \ - asio/detail/null_mutex.hpp \ - asio/detail/null_reactor.hpp \ - asio/detail/null_signal_blocker.hpp \ - asio/detail/null_socket_service.hpp \ - asio/detail/null_static_mutex.hpp \ - asio/detail/null_thread.hpp \ - asio/detail/null_tss_ptr.hpp \ - asio/detail/object_pool.hpp \ - asio/detail/old_win_sdk_compat.hpp \ - asio/detail/operation.hpp \ - asio/detail/op_queue.hpp \ - asio/detail/pipe_select_interrupter.hpp \ - asio/detail/pop_options.hpp \ - asio/detail/posix_event.hpp \ - asio/detail/posix_fd_set_adapter.hpp \ - asio/detail/posix_global.hpp \ - asio/detail/posix_mutex.hpp \ - asio/detail/posix_serial_port_service.hpp \ - asio/detail/posix_signal_blocker.hpp \ - asio/detail/posix_static_mutex.hpp \ - asio/detail/posix_thread.hpp \ - asio/detail/posix_tss_ptr.hpp \ - asio/detail/push_options.hpp \ - asio/detail/reactive_descriptor_service.hpp \ - asio/detail/reactive_null_buffers_op.hpp \ - asio/detail/reactive_socket_accept_op.hpp \ - asio/detail/reactive_socket_connect_op.hpp \ - asio/detail/reactive_socket_recvfrom_op.hpp \ - asio/detail/reactive_socket_recvmsg_op.hpp \ - asio/detail/reactive_socket_recv_op.hpp \ - asio/detail/reactive_socket_send_op.hpp \ - asio/detail/reactive_socket_sendto_op.hpp \ - asio/detail/reactive_socket_service_base.hpp \ - asio/detail/reactive_socket_service.hpp \ - asio/detail/reactive_wait_op.hpp \ - asio/detail/reactor.hpp \ - asio/detail/reactor_op.hpp \ - asio/detail/reactor_op_queue.hpp \ - asio/detail/recycling_allocator.hpp \ - asio/detail/regex_fwd.hpp \ - asio/detail/resolve_endpoint_op.hpp \ - asio/detail/resolve_op.hpp \ - asio/detail/resolve_query_op.hpp \ - asio/detail/resolver_service_base.hpp \ - asio/detail/resolver_service.hpp \ - asio/detail/scheduler.hpp \ - asio/detail/scheduler_operation.hpp \ - asio/detail/scheduler_task.hpp \ - asio/detail/scheduler_thread_info.hpp \ - asio/detail/scoped_lock.hpp \ - asio/detail/scoped_ptr.hpp \ - asio/detail/select_interrupter.hpp \ - asio/detail/select_reactor.hpp \ - asio/detail/service_registry.hpp \ - asio/detail/signal_blocker.hpp \ - asio/detail/signal_handler.hpp \ - asio/detail/signal_init.hpp \ - asio/detail/signal_op.hpp \ - asio/detail/signal_set_service.hpp \ - asio/detail/socket_holder.hpp \ - asio/detail/socket_ops.hpp \ - asio/detail/socket_option.hpp \ - asio/detail/socket_select_interrupter.hpp \ - asio/detail/socket_types.hpp \ - asio/detail/solaris_fenced_block.hpp \ - asio/detail/source_location.hpp \ - asio/detail/static_mutex.hpp \ - asio/detail/std_event.hpp \ - asio/detail/std_fenced_block.hpp \ - asio/detail/std_global.hpp \ - asio/detail/std_mutex.hpp \ - asio/detail/std_static_mutex.hpp \ - asio/detail/std_thread.hpp \ - asio/detail/strand_executor_service.hpp \ - asio/detail/strand_service.hpp \ - asio/detail/string_view.hpp \ - asio/detail/thread_context.hpp \ - asio/detail/thread_group.hpp \ - asio/detail/thread.hpp \ - asio/detail/thread_info_base.hpp \ - asio/detail/throw_error.hpp \ - asio/detail/throw_exception.hpp \ - asio/detail/timer_queue_base.hpp \ - asio/detail/timer_queue.hpp \ - asio/detail/timer_queue_ptime.hpp \ - asio/detail/timer_queue_set.hpp \ - asio/detail/timer_scheduler_fwd.hpp \ - asio/detail/timer_scheduler.hpp \ - asio/detail/tss_ptr.hpp \ - asio/detail/type_traits.hpp \ - asio/detail/utility.hpp \ - asio/detail/variadic_templates.hpp \ - asio/detail/wait_handler.hpp \ - asio/detail/wait_op.hpp \ - asio/detail/winapp_thread.hpp \ - asio/detail/wince_thread.hpp \ - asio/detail/win_event.hpp \ - asio/detail/win_fd_set_adapter.hpp \ - asio/detail/win_fenced_block.hpp \ - asio/detail/win_global.hpp \ - asio/detail/win_iocp_file_service.hpp \ - asio/detail/win_iocp_handle_read_op.hpp \ - asio/detail/win_iocp_handle_service.hpp \ - asio/detail/win_iocp_handle_write_op.hpp \ - asio/detail/win_iocp_io_context.hpp \ - asio/detail/win_iocp_null_buffers_op.hpp \ - asio/detail/win_iocp_operation.hpp \ - asio/detail/win_iocp_overlapped_op.hpp \ - asio/detail/win_iocp_overlapped_ptr.hpp \ - asio/detail/win_iocp_serial_port_service.hpp \ - asio/detail/win_iocp_socket_accept_op.hpp \ - asio/detail/win_iocp_socket_connect_op.hpp \ - asio/detail/win_iocp_socket_recvfrom_op.hpp \ - asio/detail/win_iocp_socket_recvmsg_op.hpp \ - asio/detail/win_iocp_socket_recv_op.hpp \ - asio/detail/win_iocp_socket_send_op.hpp \ - asio/detail/win_iocp_socket_service_base.hpp \ - asio/detail/win_iocp_socket_service.hpp \ - asio/detail/win_iocp_thread_info.hpp \ - asio/detail/win_iocp_wait_op.hpp \ - asio/detail/win_mutex.hpp \ - asio/detail/win_object_handle_service.hpp \ - asio/detail/winrt_async_manager.hpp \ - asio/detail/winrt_async_op.hpp \ - asio/detail/winrt_resolve_op.hpp \ - asio/detail/winrt_resolver_service.hpp \ - asio/detail/winrt_socket_connect_op.hpp \ - asio/detail/winrt_socket_recv_op.hpp \ - asio/detail/winrt_socket_send_op.hpp \ - asio/detail/winrt_ssocket_service_base.hpp \ - asio/detail/winrt_ssocket_service.hpp \ - asio/detail/winrt_timer_scheduler.hpp \ - asio/detail/winrt_utils.hpp \ - asio/detail/winsock_init.hpp \ - asio/detail/win_static_mutex.hpp \ - asio/detail/win_thread.hpp \ - asio/detail/win_tss_ptr.hpp \ - asio/detail/work_dispatcher.hpp \ - asio/detail/wrapped_handler.hpp \ - asio/dispatch.hpp \ - asio/error_code.hpp \ - asio/error.hpp \ - asio/execution.hpp \ - asio/execution_context.hpp \ - asio/execution/allocator.hpp \ - asio/execution/any_executor.hpp \ - asio/execution/bad_executor.hpp \ - asio/execution/blocking.hpp \ - asio/execution/blocking_adaptation.hpp \ - asio/execution/bulk_execute.hpp \ - asio/execution/bulk_guarantee.hpp \ - asio/execution/connect.hpp \ - asio/execution/context.hpp \ - asio/execution/context_as.hpp \ - asio/execution/detail/as_invocable.hpp \ - asio/execution/detail/as_operation.hpp \ - asio/execution/detail/as_receiver.hpp \ - asio/execution/detail/bulk_sender.hpp \ - asio/execution/detail/submit_receiver.hpp \ - asio/execution/detail/void_receiver.hpp \ - asio/execution/execute.hpp \ - asio/execution/executor.hpp \ - asio/execution/impl/bad_executor.ipp \ - asio/execution/impl/receiver_invocation_error.ipp \ - asio/execution/invocable_archetype.hpp \ - asio/execution/mapping.hpp \ - asio/execution/occupancy.hpp \ - asio/execution/operation_state.hpp \ - asio/execution/outstanding_work.hpp \ - asio/execution/prefer_only.hpp \ - asio/execution/receiver.hpp \ - asio/execution/receiver_invocation_error.hpp \ - asio/execution/relationship.hpp \ - asio/execution/schedule.hpp \ - asio/execution/scheduler.hpp \ - asio/execution/sender.hpp \ - asio/execution/set_done.hpp \ - asio/execution/set_error.hpp \ - asio/execution/set_value.hpp \ - asio/execution/start.hpp \ - asio/execution/submit.hpp \ - asio/executor.hpp \ - asio/executor_work_guard.hpp \ - asio/experimental/append.hpp \ - asio/experimental/as_single.hpp \ - asio/experimental/as_tuple.hpp \ - asio/experimental/awaitable_operators.hpp \ - asio/experimental/basic_channel.hpp \ - asio/experimental/basic_concurrent_channel.hpp \ - asio/experimental/cancellation_condition.hpp \ - asio/experimental/channel.hpp \ - asio/experimental/channel_error.hpp \ - asio/experimental/channel_traits.hpp \ - asio/experimental/co_composed.hpp \ - asio/experimental/co_spawn.hpp \ - asio/experimental/concurrent_channel.hpp \ - asio/experimental/coro.hpp \ - asio/experimental/coro_traits.hpp \ - asio/experimental/deferred.hpp \ - asio/experimental/detail/channel_handler.hpp \ - asio/experimental/detail/channel_message.hpp \ - asio/experimental/detail/channel_operation.hpp \ - asio/experimental/detail/channel_payload.hpp \ - asio/experimental/detail/channel_receive_op.hpp \ - asio/experimental/detail/channel_send_functions.hpp \ - asio/experimental/detail/channel_send_op.hpp \ - asio/experimental/detail/channel_service.hpp \ - asio/experimental/detail/coro_completion_handler.hpp \ - asio/experimental/detail/coro_promise_allocator.hpp \ - asio/experimental/detail/has_signature.hpp \ - asio/experimental/detail/impl/channel_service.hpp \ - asio/experimental/detail/partial_promise.hpp \ - asio/experimental/impl/as_single.hpp \ - asio/experimental/impl/channel_error.ipp \ - asio/experimental/impl/co_composed.hpp \ - asio/experimental/impl/coro.hpp \ - asio/experimental/impl/parallel_group.hpp \ - asio/experimental/impl/promise.hpp \ - asio/experimental/impl/use_coro.hpp \ - asio/experimental/impl/use_promise.hpp \ - asio/experimental/parallel_group.hpp \ - asio/experimental/prepend.hpp \ - asio/experimental/promise.hpp \ - asio/experimental/use_coro.hpp \ - asio/experimental/use_promise.hpp \ - asio/file_base.hpp \ - asio/generic/basic_endpoint.hpp \ - asio/generic/datagram_protocol.hpp \ - asio/generic/detail/endpoint.hpp \ - asio/generic/detail/impl/endpoint.ipp \ - asio/generic/raw_protocol.hpp \ - asio/generic/seq_packet_protocol.hpp \ - asio/generic/stream_protocol.hpp \ - asio/handler_alloc_hook.hpp \ - asio/handler_continuation_hook.hpp \ - asio/handler_invoke_hook.hpp \ - asio/high_resolution_timer.hpp \ - asio.hpp \ - asio/impl/any_completion_executor.ipp \ - asio/impl/any_io_executor.ipp \ - asio/impl/append.hpp \ - asio/impl/as_tuple.hpp \ - asio/impl/awaitable.hpp \ - asio/impl/buffered_read_stream.hpp \ - asio/impl/buffered_write_stream.hpp \ - asio/impl/cancellation_signal.ipp \ - asio/impl/co_spawn.hpp \ - asio/impl/connect.hpp \ - asio/impl/connect_pipe.hpp \ - asio/impl/connect_pipe.ipp \ - asio/impl/consign.hpp \ - asio/impl/deferred.hpp \ - asio/impl/detached.hpp \ - asio/impl/error_code.ipp \ - asio/impl/error.ipp \ - asio/impl/execution_context.hpp \ - asio/impl/execution_context.ipp \ - asio/impl/executor.hpp \ - asio/impl/executor.ipp \ - asio/impl/handler_alloc_hook.ipp \ - asio/impl/io_context.hpp \ - asio/impl/io_context.ipp \ - asio/impl/multiple_exceptions.ipp \ - asio/impl/prepend.hpp \ - asio/impl/read_at.hpp \ - asio/impl/read.hpp \ - asio/impl/read_until.hpp \ - asio/impl/redirect_error.hpp \ - asio/impl/serial_port_base.hpp \ - asio/impl/serial_port_base.ipp \ - asio/impl/spawn.hpp \ - asio/impl/src.hpp \ - asio/impl/system_context.hpp \ - asio/impl/system_context.ipp \ - asio/impl/system_executor.hpp \ - asio/impl/thread_pool.hpp \ - asio/impl/thread_pool.ipp \ - asio/impl/use_awaitable.hpp \ - asio/impl/use_future.hpp \ - asio/impl/write_at.hpp \ - asio/impl/write.hpp \ - asio/io_context.hpp \ - asio/io_context_strand.hpp \ - asio/io_service.hpp \ - asio/io_service_strand.hpp \ - asio/ip/address.hpp \ - asio/ip/address_v4.hpp \ - asio/ip/address_v4_iterator.hpp \ - asio/ip/address_v4_range.hpp \ - asio/ip/address_v6.hpp \ - asio/ip/address_v6_iterator.hpp \ - asio/ip/address_v6_range.hpp \ - asio/ip/bad_address_cast.hpp \ - asio/ip/basic_endpoint.hpp \ - asio/ip/basic_resolver_entry.hpp \ - asio/ip/basic_resolver.hpp \ - asio/ip/basic_resolver_iterator.hpp \ - asio/ip/basic_resolver_query.hpp \ - asio/ip/basic_resolver_results.hpp \ - asio/ip/detail/endpoint.hpp \ - asio/ip/detail/impl/endpoint.ipp \ - asio/ip/detail/socket_option.hpp \ - asio/ip/host_name.hpp \ - asio/ip/icmp.hpp \ - asio/ip/impl/address.hpp \ - asio/ip/impl/address.ipp \ - asio/ip/impl/address_v4.hpp \ - asio/ip/impl/address_v4.ipp \ - asio/ip/impl/address_v6.hpp \ - asio/ip/impl/address_v6.ipp \ - asio/ip/impl/basic_endpoint.hpp \ - asio/ip/impl/host_name.ipp \ - asio/ip/impl/network_v4.hpp \ - asio/ip/impl/network_v4.ipp \ - asio/ip/impl/network_v6.hpp \ - asio/ip/impl/network_v6.ipp \ - asio/ip/multicast.hpp \ - asio/ip/network_v4.hpp \ - asio/ip/network_v6.hpp \ - asio/ip/resolver_base.hpp \ - asio/ip/resolver_query_base.hpp \ - asio/ip/tcp.hpp \ - asio/ip/udp.hpp \ - asio/ip/unicast.hpp \ - asio/ip/v6_only.hpp \ - asio/is_applicable_property.hpp \ - asio/is_contiguous_iterator.hpp \ - asio/is_executor.hpp \ - asio/is_read_buffered.hpp \ - asio/is_write_buffered.hpp \ - asio/local/basic_endpoint.hpp \ - asio/local/connect_pair.hpp \ - asio/local/datagram_protocol.hpp \ - asio/local/detail/endpoint.hpp \ - asio/local/detail/impl/endpoint.ipp \ - asio/local/seq_packet_protocol.hpp \ - asio/local/stream_protocol.hpp \ - asio/multiple_exceptions.hpp \ - asio/packaged_task.hpp \ - asio/placeholders.hpp \ - asio/posix/basic_descriptor.hpp \ - asio/posix/basic_stream_descriptor.hpp \ - asio/posix/descriptor_base.hpp \ - asio/posix/descriptor.hpp \ - asio/posix/stream_descriptor.hpp \ - asio/post.hpp \ - asio/prefer.hpp \ - asio/prepend.hpp \ - asio/query.hpp \ - asio/random_access_file.hpp \ - asio/read_at.hpp \ - asio/read.hpp \ - asio/read_until.hpp \ - asio/readable_pipe.hpp \ - asio/recycling_allocator.hpp \ - asio/redirect_error.hpp \ - asio/registered_buffer.hpp \ - asio/require.hpp \ - asio/require_concept.hpp \ - asio/serial_port_base.hpp \ - asio/serial_port.hpp \ - asio/signal_set_base.hpp \ - asio/signal_set.hpp \ - asio/socket_base.hpp \ - asio/spawn.hpp \ - asio/ssl/context_base.hpp \ - asio/ssl/context.hpp \ - asio/ssl/detail/buffered_handshake_op.hpp \ - asio/ssl/detail/engine.hpp \ - asio/ssl/detail/handshake_op.hpp \ - asio/ssl/detail/impl/engine.ipp \ - asio/ssl/detail/impl/openssl_init.ipp \ - asio/ssl/detail/io.hpp \ - asio/ssl/detail/openssl_init.hpp \ - asio/ssl/detail/openssl_types.hpp \ - asio/ssl/detail/password_callback.hpp \ - asio/ssl/detail/read_op.hpp \ - asio/ssl/detail/shutdown_op.hpp \ - asio/ssl/detail/stream_core.hpp \ - asio/ssl/detail/verify_callback.hpp \ - asio/ssl/detail/write_op.hpp \ - asio/ssl/error.hpp \ - asio/ssl.hpp \ - asio/ssl/host_name_verification.hpp \ - asio/ssl/impl/context.hpp \ - asio/ssl/impl/context.ipp \ - asio/ssl/impl/error.ipp \ - asio/ssl/impl/host_name_verification.ipp \ - asio/ssl/impl/rfc2818_verification.ipp \ - asio/ssl/impl/src.hpp \ - asio/ssl/rfc2818_verification.hpp \ - asio/ssl/stream_base.hpp \ - asio/ssl/stream.hpp \ - asio/ssl/verify_context.hpp \ - asio/ssl/verify_mode.hpp \ - asio/static_thread_pool.hpp \ - asio/steady_timer.hpp \ - asio/strand.hpp \ - asio/streambuf.hpp \ - asio/stream_file.hpp \ - asio/system_context.hpp \ - asio/system_error.hpp \ - asio/system_executor.hpp \ - asio/system_timer.hpp \ - asio/this_coro.hpp \ - asio/thread.hpp \ - asio/thread_pool.hpp \ - asio/time_traits.hpp \ - asio/traits/bulk_execute_free.hpp \ - asio/traits/bulk_execute_member.hpp \ - asio/traits/connect_free.hpp \ - asio/traits/connect_member.hpp \ - asio/traits/equality_comparable.hpp \ - asio/traits/execute_free.hpp \ - asio/traits/execute_member.hpp \ - asio/traits/prefer_free.hpp \ - asio/traits/prefer_member.hpp \ - asio/traits/query_free.hpp \ - asio/traits/query_member.hpp \ - asio/traits/query_static_constexpr_member.hpp \ - asio/traits/require_concept_free.hpp \ - asio/traits/require_concept_member.hpp \ - asio/traits/require_free.hpp \ - asio/traits/require_member.hpp \ - asio/traits/schedule_free.hpp \ - asio/traits/schedule_member.hpp \ - asio/traits/set_done_free.hpp \ - asio/traits/set_done_member.hpp \ - asio/traits/set_error_free.hpp \ - asio/traits/set_error_member.hpp \ - asio/traits/set_value_free.hpp \ - asio/traits/set_value_member.hpp \ - asio/traits/start_free.hpp \ - asio/traits/start_member.hpp \ - asio/traits/static_query.hpp \ - asio/traits/static_require.hpp \ - asio/traits/static_require_concept.hpp \ - asio/traits/submit_free.hpp \ - asio/traits/submit_member.hpp \ - asio/ts/buffer.hpp \ - asio/ts/executor.hpp \ - asio/ts/internet.hpp \ - asio/ts/io_context.hpp \ - asio/ts/netfwd.hpp \ - asio/ts/net.hpp \ - asio/ts/socket.hpp \ - asio/ts/timer.hpp \ - asio/unyield.hpp \ - asio/use_awaitable.hpp \ - asio/use_future.hpp \ - asio/uses_executor.hpp \ - asio/version.hpp \ - asio/wait_traits.hpp \ - asio/windows/basic_object_handle.hpp \ - asio/windows/basic_overlapped_handle.hpp \ - asio/windows/basic_random_access_handle.hpp \ - asio/windows/basic_stream_handle.hpp \ - asio/windows/object_handle.hpp \ - asio/windows/overlapped_handle.hpp \ - asio/windows/overlapped_ptr.hpp \ - asio/windows/random_access_handle.hpp \ - asio/windows/stream_handle.hpp \ - asio/writable_pipe.hpp \ - asio/write_at.hpp \ - asio/write.hpp \ - asio/yield.hpp - -MAINTAINERCLEANFILES = \ - $(srcdir)/Makefile.in - -all: all-am - -.SUFFIXES: -$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps) - @for dep in $?; do \ - case '$(am__configure_deps)' in \ - *$$dep*) \ - ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ - && { if test -f $@; then exit 0; else break; fi; }; \ - exit 1;; \ - esac; \ - done; \ - echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign include/Makefile'; \ - $(am__cd) $(top_srcdir) && \ - $(AUTOMAKE) --foreign include/Makefile -Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status - @case '$?' in \ - *config.status*) \ - cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ - *) \ - echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \ - cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ - esac; - -$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) - cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh - -$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) - cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh -$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps) - cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh -$(am__aclocal_m4_deps): -install-nobase_includeHEADERS: $(nobase_include_HEADERS) - @$(NORMAL_INSTALL) - @list='$(nobase_include_HEADERS)'; test -n "$(includedir)" || list=; \ - if test -n "$$list"; then \ - echo " $(MKDIR_P) '$(DESTDIR)$(includedir)'"; \ - $(MKDIR_P) "$(DESTDIR)$(includedir)" || exit 1; \ - fi; \ - $(am__nobase_list) | while read dir files; do \ - xfiles=; for file in $$files; do \ - if test -f "$$file"; then xfiles="$$xfiles $$file"; \ - else xfiles="$$xfiles $(srcdir)/$$file"; fi; done; \ - test -z "$$xfiles" || { \ - test "x$$dir" = x. || { \ - echo " $(MKDIR_P) '$(DESTDIR)$(includedir)/$$dir'"; \ - $(MKDIR_P) "$(DESTDIR)$(includedir)/$$dir"; }; \ - echo " $(INSTALL_HEADER) $$xfiles '$(DESTDIR)$(includedir)/$$dir'"; \ - $(INSTALL_HEADER) $$xfiles "$(DESTDIR)$(includedir)/$$dir" || exit $$?; }; \ - done - -uninstall-nobase_includeHEADERS: - @$(NORMAL_UNINSTALL) - @list='$(nobase_include_HEADERS)'; test -n "$(includedir)" || list=; \ - $(am__nobase_strip_setup); files=`$(am__nobase_strip)`; \ - dir='$(DESTDIR)$(includedir)'; $(am__uninstall_files_from_dir) - -ID: $(am__tagged_files) - $(am__define_uniq_tagged_files); mkid -fID $$unique -tags: tags-am -TAGS: tags - -tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) - set x; \ - here=`pwd`; \ - $(am__define_uniq_tagged_files); \ - shift; \ - if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ - test -n "$$unique" || unique=$$empty_fix; \ - if test $$# -gt 0; then \ - $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ - "$$@" $$unique; \ - else \ - $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ - $$unique; \ - fi; \ - fi -ctags: ctags-am - -CTAGS: ctags -ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) - $(am__define_uniq_tagged_files); \ - test -z "$(CTAGS_ARGS)$$unique" \ - || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ - $$unique - -GTAGS: - here=`$(am__cd) $(top_builddir) && pwd` \ - && $(am__cd) $(top_srcdir) \ - && gtags -i $(GTAGS_ARGS) "$$here" -cscopelist: cscopelist-am - -cscopelist-am: $(am__tagged_files) - list='$(am__tagged_files)'; \ - case "$(srcdir)" in \ - [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ - *) sdir=$(subdir)/$(srcdir) ;; \ - esac; \ - for i in $$list; do \ - if test -f "$$i"; then \ - echo "$(subdir)/$$i"; \ - else \ - echo "$$sdir/$$i"; \ - fi; \ - done >> $(top_builddir)/cscope.files - -distclean-tags: - -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags -distdir: $(BUILT_SOURCES) - $(MAKE) $(AM_MAKEFLAGS) distdir-am - -distdir-am: $(DISTFILES) - @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ - topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ - list='$(DISTFILES)'; \ - dist_files=`for file in $$list; do echo $$file; done | \ - sed -e "s|^$$srcdirstrip/||;t" \ - -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ - case $$dist_files in \ - */*) $(MKDIR_P) `echo "$$dist_files" | \ - sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ - sort -u` ;; \ - esac; \ - for file in $$dist_files; do \ - if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ - if test -d $$d/$$file; then \ - dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ - if test -d "$(distdir)/$$file"; then \ - find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ - fi; \ - if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ - cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ - find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ - fi; \ - cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ - else \ - test -f "$(distdir)/$$file" \ - || cp -p $$d/$$file "$(distdir)/$$file" \ - || exit 1; \ - fi; \ - done -check-am: all-am -check: check-am -all-am: Makefile $(HEADERS) -installdirs: - for dir in "$(DESTDIR)$(includedir)"; do \ - test -z "$$dir" || $(MKDIR_P) "$$dir"; \ - done -install: install-am -install-exec: install-exec-am -install-data: install-data-am -uninstall: uninstall-am - -install-am: all-am - @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am - -installcheck: installcheck-am -install-strip: - if test -z '$(STRIP)'; then \ - $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ - install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ - install; \ - else \ - $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ - install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ - "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ - fi -mostlyclean-generic: - -clean-generic: - -distclean-generic: - -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) - -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) - -maintainer-clean-generic: - @echo "This command is intended for maintainers to use" - @echo "it deletes files that may require special tools to rebuild." - -test -z "$(MAINTAINERCLEANFILES)" || rm -f $(MAINTAINERCLEANFILES) -clean: clean-am - -clean-am: clean-generic mostlyclean-am - -distclean: distclean-am - -rm -f Makefile -distclean-am: clean-am distclean-generic distclean-tags - -dvi: dvi-am - -dvi-am: - -html: html-am - -html-am: - -info: info-am - -info-am: - -install-data-am: install-nobase_includeHEADERS - -install-dvi: install-dvi-am - -install-dvi-am: - -install-exec-am: - -install-html: install-html-am - -install-html-am: - -install-info: install-info-am - -install-info-am: - -install-man: - -install-pdf: install-pdf-am - -install-pdf-am: - -install-ps: install-ps-am - -install-ps-am: - -installcheck-am: - -maintainer-clean: maintainer-clean-am - -rm -f Makefile -maintainer-clean-am: distclean-am maintainer-clean-generic - -mostlyclean: mostlyclean-am - -mostlyclean-am: mostlyclean-generic - -pdf: pdf-am - -pdf-am: - -ps: ps-am - -ps-am: - -uninstall-am: uninstall-nobase_includeHEADERS - -.MAKE: install-am install-strip - -.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \ - cscopelist-am ctags ctags-am distclean distclean-generic \ - distclean-tags distdir dvi dvi-am html html-am info info-am \ - install install-am install-data install-data-am install-dvi \ - install-dvi-am install-exec install-exec-am install-html \ - install-html-am install-info install-info-am install-man \ - install-nobase_includeHEADERS install-pdf install-pdf-am \ - install-ps install-ps-am install-strip installcheck \ - installcheck-am installdirs maintainer-clean \ - maintainer-clean-generic mostlyclean mostlyclean-generic pdf \ - pdf-am ps ps-am tags tags-am uninstall uninstall-am \ - uninstall-nobase_includeHEADERS - -.PRECIOUS: Makefile - - -# Tell versions [3.59,3.63) of GNU make to not export all variables. -# Otherwise a system limit (for SysV at least) may be exceeded. -.NOEXPORT: diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio.hpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio.hpp index a973ab178c41..11e594a4f62f 100644 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio.hpp +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio.hpp @@ -2,7 +2,7 @@ // asio.hpp // ~~~~~~~~ // -// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) @@ -59,12 +59,17 @@ #include "asio/buffered_write_stream_fwd.hpp" #include "asio/buffered_write_stream.hpp" #include "asio/buffers_iterator.hpp" +#include "asio/cancel_after.hpp" +#include "asio/cancel_at.hpp" #include "asio/cancellation_signal.hpp" #include "asio/cancellation_state.hpp" #include "asio/cancellation_type.hpp" +#include "asio/co_composed.hpp" #include "asio/co_spawn.hpp" #include "asio/completion_condition.hpp" #include "asio/compose.hpp" +#include "asio/composed.hpp" +#include "asio/config.hpp" #include "asio/connect.hpp" #include "asio/connect_pipe.hpp" #include "asio/consign.hpp" @@ -72,8 +77,10 @@ #include "asio/deadline_timer.hpp" #include "asio/defer.hpp" #include "asio/deferred.hpp" +#include "asio/default_completion_token.hpp" #include "asio/detached.hpp" #include "asio/dispatch.hpp" +#include "asio/disposition.hpp" #include "asio/error.hpp" #include "asio/error_code.hpp" #include "asio/execution.hpp" @@ -81,30 +88,15 @@ #include "asio/execution/any_executor.hpp" #include "asio/execution/blocking.hpp" #include "asio/execution/blocking_adaptation.hpp" -#include "asio/execution/bulk_execute.hpp" -#include "asio/execution/bulk_guarantee.hpp" -#include "asio/execution/connect.hpp" #include "asio/execution/context.hpp" #include "asio/execution/context_as.hpp" -#include "asio/execution/execute.hpp" #include "asio/execution/executor.hpp" #include "asio/execution/invocable_archetype.hpp" #include "asio/execution/mapping.hpp" #include "asio/execution/occupancy.hpp" -#include "asio/execution/operation_state.hpp" #include "asio/execution/outstanding_work.hpp" #include "asio/execution/prefer_only.hpp" -#include "asio/execution/receiver.hpp" -#include "asio/execution/receiver_invocation_error.hpp" #include "asio/execution/relationship.hpp" -#include "asio/execution/schedule.hpp" -#include "asio/execution/scheduler.hpp" -#include "asio/execution/sender.hpp" -#include "asio/execution/set_done.hpp" -#include "asio/execution/set_error.hpp" -#include "asio/execution/set_value.hpp" -#include "asio/execution/start.hpp" -#include "asio/execution_context.hpp" #include "asio/executor.hpp" #include "asio/executor_work_guard.hpp" #include "asio/file_base.hpp" @@ -113,14 +105,11 @@ #include "asio/generic/raw_protocol.hpp" #include "asio/generic/seq_packet_protocol.hpp" #include "asio/generic/stream_protocol.hpp" -#include "asio/handler_alloc_hook.hpp" #include "asio/handler_continuation_hook.hpp" -#include "asio/handler_invoke_hook.hpp" #include "asio/high_resolution_timer.hpp" +#include "asio/immediate.hpp" #include "asio/io_context.hpp" #include "asio/io_context_strand.hpp" -#include "asio/io_service.hpp" -#include "asio/io_service_strand.hpp" #include "asio/ip/address.hpp" #include "asio/ip/address_v4.hpp" #include "asio/ip/address_v4_iterator.hpp" diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/any_completion_executor.hpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/any_completion_executor.hpp index 420927cc1d0b..650ff7bafddc 100644 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/any_completion_executor.hpp +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/any_completion_executor.hpp @@ -2,7 +2,7 @@ // any_completion_executor.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) @@ -75,20 +75,18 @@ class any_completion_executor : #endif // !defined(GENERATING_DOCUMENTATION) /// Default constructor. - ASIO_DECL any_completion_executor() ASIO_NOEXCEPT; + ASIO_DECL any_completion_executor() noexcept; /// Construct in an empty state. Equivalent effects to default constructor. - ASIO_DECL any_completion_executor(nullptr_t) ASIO_NOEXCEPT; + ASIO_DECL any_completion_executor(nullptr_t) noexcept; /// Copy constructor. ASIO_DECL any_completion_executor( - const any_completion_executor& e) ASIO_NOEXCEPT; + const any_completion_executor& e) noexcept; -#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) /// Move constructor. ASIO_DECL any_completion_executor( - any_completion_executor&& e) ASIO_NOEXCEPT; -#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) + any_completion_executor&& e) noexcept; /// Construct to point to the same target as another any_executor. #if defined(GENERATING_DOCUMENTATION) @@ -98,7 +96,7 @@ class any_completion_executor : #else // defined(GENERATING_DOCUMENTATION) template any_completion_executor(OtherAnyExecutor e, - typename constraint< + constraint_t< conditional< !is_same::value && is_base_of, false_type >::type::value - >::type = 0) - : base_type(ASIO_MOVE_CAST(OtherAnyExecutor)(e)) + > = 0) + : base_type(static_cast(e)) { } #endif // defined(GENERATING_DOCUMENTATION) @@ -122,7 +120,7 @@ class any_completion_executor : #else // defined(GENERATING_DOCUMENTATION) template any_completion_executor(std::nothrow_t, OtherAnyExecutor e, - typename constraint< + constraint_t< conditional< !is_same::value && is_base_of, false_type >::type::value - >::type = 0) ASIO_NOEXCEPT - : base_type(std::nothrow, ASIO_MOVE_CAST(OtherAnyExecutor)(e)) + > = 0) noexcept + : base_type(std::nothrow, static_cast(e)) { } #endif // defined(GENERATING_DOCUMENTATION) /// Construct to point to the same target as another any_executor. ASIO_DECL any_completion_executor(std::nothrow_t, - const any_completion_executor& e) ASIO_NOEXCEPT; + const any_completion_executor& e) noexcept; -#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) /// Construct to point to the same target as another any_executor. ASIO_DECL any_completion_executor(std::nothrow_t, - any_completion_executor&& e) ASIO_NOEXCEPT; -#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) + any_completion_executor&& e) noexcept; /// Construct a polymorphic wrapper for the specified executor. #if defined(GENERATING_DOCUMENTATION) @@ -155,7 +151,7 @@ class any_completion_executor : #else // defined(GENERATING_DOCUMENTATION) template any_completion_executor(Executor e, - typename constraint< + constraint_t< conditional< !is_same::value && !is_base_of, false_type >::type::value - >::type = 0) - : base_type(ASIO_MOVE_CAST(Executor)(e)) + > = 0) + : base_type(static_cast(e)) { } #endif // defined(GENERATING_DOCUMENTATION) @@ -177,7 +173,7 @@ class any_completion_executor : #else // defined(GENERATING_DOCUMENTATION) template any_completion_executor(std::nothrow_t, Executor e, - typename constraint< + constraint_t< conditional< !is_same::value && !is_base_of, false_type >::type::value - >::type = 0) ASIO_NOEXCEPT - : base_type(std::nothrow, ASIO_MOVE_CAST(Executor)(e)) + > = 0) noexcept + : base_type(std::nothrow, static_cast(e)) { } #endif // defined(GENERATING_DOCUMENTATION) /// Assignment operator. ASIO_DECL any_completion_executor& operator=( - const any_completion_executor& e) ASIO_NOEXCEPT; + const any_completion_executor& e) noexcept; -#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) /// Move assignment operator. ASIO_DECL any_completion_executor& operator=( - any_completion_executor&& e) ASIO_NOEXCEPT; -#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) + any_completion_executor&& e) noexcept; /// Assignment operator that sets the polymorphic wrapper to the empty state. ASIO_DECL any_completion_executor& operator=(nullptr_t); @@ -209,7 +203,7 @@ class any_completion_executor : ASIO_DECL ~any_completion_executor(); /// Swap targets with another polymorphic wrapper. - ASIO_DECL void swap(any_completion_executor& other) ASIO_NOEXCEPT; + ASIO_DECL void swap(any_completion_executor& other) noexcept; /// Obtain a polymorphic wrapper with the specified property. /** @@ -222,9 +216,9 @@ class any_completion_executor : */ template any_completion_executor require(const Property& p, - typename constraint< + constraint_t< traits::require_member::is_valid - >::type = 0) const + > = 0) const { return static_cast(*this).require(p); } @@ -240,9 +234,9 @@ class any_completion_executor : */ template any_completion_executor prefer(const Property& p, - typename constraint< + constraint_t< traits::prefer_member::is_valid - >::type = 0) const + > = 0) const { return static_cast(*this).prefer(p); } diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/any_completion_handler.hpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/any_completion_handler.hpp index cd114537ff13..45b3e75fec78 100644 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/any_completion_handler.hpp +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/any_completion_handler.hpp @@ -2,7 +2,7 @@ // any_completion_handler.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) @@ -12,20 +12,16 @@ #define ASIO_ANY_COMPLETION_HANDLER_HPP #include "asio/detail/config.hpp" - -#if (defined(ASIO_HAS_STD_TUPLE) \ - && defined(ASIO_HAS_MOVE) \ - && defined(ASIO_HAS_VARIADIC_TEMPLATES)) \ - || defined(GENERATING_DOCUMENTATION) - #include #include #include #include #include "asio/any_completion_executor.hpp" +#include "asio/any_io_executor.hpp" #include "asio/associated_allocator.hpp" #include "asio/associated_cancellation_slot.hpp" #include "asio/associated_executor.hpp" +#include "asio/associated_immediate_executor.hpp" #include "asio/cancellation_state.hpp" #include "asio/recycling_allocator.hpp" @@ -39,11 +35,11 @@ class any_completion_handler_impl_base public: template explicit any_completion_handler_impl_base(S&& slot) - : cancel_state_(ASIO_MOVE_CAST(S)(slot), enable_total_cancellation()) + : cancel_state_(static_cast(slot), enable_total_cancellation()) { } - cancellation_slot get_cancellation_slot() const ASIO_NOEXCEPT + cancellation_slot get_cancellation_slot() const noexcept { return cancel_state_.slot(); } @@ -59,8 +55,8 @@ class any_completion_handler_impl : public: template any_completion_handler_impl(S&& slot, H&& h) - : any_completion_handler_impl_base(ASIO_MOVE_CAST(S)(slot)), - handler_(ASIO_MOVE_CAST(H)(h)) + : any_completion_handler_impl_base(static_cast(slot)), + handler_(static_cast(h)) { } @@ -103,7 +99,7 @@ class any_completion_handler_impl : any_completion_handler_impl* ptr = new (uninit_ptr.get()) any_completion_handler_impl( - ASIO_MOVE_CAST(S)(slot), ASIO_MOVE_CAST(H)(h)); + static_cast(slot), static_cast(h)); uninit_ptr.release(); return ptr; @@ -119,12 +115,19 @@ class any_completion_handler_impl : } any_completion_executor executor( - const any_completion_executor& candidate) const ASIO_NOEXCEPT + const any_completion_executor& candidate) const noexcept { return any_completion_executor(std::nothrow, (get_associated_executor)(handler_, candidate)); } + any_completion_executor immediate_executor( + const any_io_executor& candidate) const noexcept + { + return any_completion_executor(std::nothrow, + (get_associated_immediate_executor)(handler_, candidate)); + } + void* allocate(std::size_t size, std::size_t align) const { typename std::allocator_traits< @@ -180,11 +183,11 @@ class any_completion_handler_impl : asio::recycling_allocator())}; std::unique_ptr ptr(this, d); - Handler handler(ASIO_MOVE_CAST(Handler)(handler_)); + Handler handler(static_cast(handler_)); ptr.reset(); - ASIO_MOVE_CAST(Handler)(handler)( - ASIO_MOVE_CAST(Args)(args)...); + static_cast(handler)( + static_cast(args)...); } private: @@ -207,14 +210,14 @@ class any_completion_handler_call_fn void call(any_completion_handler_impl_base* impl, Args... args) const { - call_fn_(impl, ASIO_MOVE_CAST(Args)(args)...); + call_fn_(impl, static_cast(args)...); } template static void impl(any_completion_handler_impl_base* impl, Args... args) { static_cast*>(impl)->call( - ASIO_MOVE_CAST(Args)(args)...); + static_cast(args)...); } private: @@ -305,6 +308,36 @@ class any_completion_handler_executor_fn type executor_fn_; }; +class any_completion_handler_immediate_executor_fn +{ +public: + using type = any_completion_executor(*)( + any_completion_handler_impl_base*, const any_io_executor&); + + constexpr any_completion_handler_immediate_executor_fn(type fn) + : immediate_executor_fn_(fn) + { + } + + any_completion_executor immediate_executor( + any_completion_handler_impl_base* impl, + const any_io_executor& candidate) const + { + return immediate_executor_fn_(impl, candidate); + } + + template + static any_completion_executor impl(any_completion_handler_impl_base* impl, + const any_io_executor& candidate) + { + return static_cast*>( + impl)->immediate_executor(candidate); + } + +private: + type immediate_executor_fn_; +}; + class any_completion_handler_allocate_fn { public: @@ -367,6 +400,7 @@ template class any_completion_handler_fn_table : private any_completion_handler_destroy_fn, private any_completion_handler_executor_fn, + private any_completion_handler_immediate_executor_fn, private any_completion_handler_allocate_fn, private any_completion_handler_deallocate_fn, private any_completion_handler_call_fns @@ -376,11 +410,13 @@ class any_completion_handler_fn_table constexpr any_completion_handler_fn_table( any_completion_handler_destroy_fn::type destroy_fn, any_completion_handler_executor_fn::type executor_fn, + any_completion_handler_immediate_executor_fn::type immediate_executor_fn, any_completion_handler_allocate_fn::type allocate_fn, any_completion_handler_deallocate_fn::type deallocate_fn, CallFns... call_fns) : any_completion_handler_destroy_fn(destroy_fn), any_completion_handler_executor_fn(executor_fn), + any_completion_handler_immediate_executor_fn(immediate_executor_fn), any_completion_handler_allocate_fn(allocate_fn), any_completion_handler_deallocate_fn(deallocate_fn), any_completion_handler_call_fns(call_fns...) @@ -389,6 +425,7 @@ class any_completion_handler_fn_table using any_completion_handler_destroy_fn::destroy; using any_completion_handler_executor_fn::executor; + using any_completion_handler_immediate_executor_fn::immediate_executor; using any_completion_handler_allocate_fn::allocate; using any_completion_handler_deallocate_fn::deallocate; using any_completion_handler_call_fns::call; @@ -401,6 +438,7 @@ struct any_completion_handler_fn_table_instance value = any_completion_handler_fn_table( &any_completion_handler_destroy_fn::impl, &any_completion_handler_executor_fn::impl, + &any_completion_handler_immediate_executor_fn::impl, &any_completion_handler_allocate_fn::impl, &any_completion_handler_deallocate_fn::impl, &any_completion_handler_call_fn::template impl...); @@ -431,7 +469,7 @@ class any_completion_handler_allocator detail::any_completion_handler_impl_base* impl_; constexpr any_completion_handler_allocator(int, - const any_completion_handler& h) ASIO_NOEXCEPT + const any_completion_handler& h) noexcept : fn_table_(h.fn_table_), impl_(h.impl_) { @@ -453,7 +491,7 @@ class any_completion_handler_allocator template constexpr any_completion_handler_allocator( const any_completion_handler_allocator& a) - ASIO_NOEXCEPT + noexcept : fn_table_(a.fn_table_), impl_(a.impl_) { @@ -461,14 +499,14 @@ class any_completion_handler_allocator /// Equality operator. constexpr bool operator==( - const any_completion_handler_allocator& other) const ASIO_NOEXCEPT + const any_completion_handler_allocator& other) const noexcept { return fn_table_ == other.fn_table_ && impl_ == other.impl_; } /// Inequality operator. constexpr bool operator!=( - const any_completion_handler_allocator& other) const ASIO_NOEXCEPT + const any_completion_handler_allocator& other) const noexcept { return fn_table_ != other.fn_table_ || impl_ != other.impl_; } @@ -476,9 +514,15 @@ class any_completion_handler_allocator /// Allocate space for @c n objects of the allocator's value type. T* allocate(std::size_t n) const { - return static_cast( - fn_table_->allocate( - impl_, sizeof(T) * n, alignof(T))); + if (fn_table_) + { + return static_cast( + fn_table_->allocate( + impl_, sizeof(T) * n, alignof(T))); + } + std::bad_alloc ex; + asio::detail::throw_exception(ex); + return nullptr; } /// Deallocate space for @c n objects of the allocator's value type. @@ -505,7 +549,7 @@ class any_completion_handler_allocator detail::any_completion_handler_impl_base* impl_; constexpr any_completion_handler_allocator(int, - const any_completion_handler& h) ASIO_NOEXCEPT + const any_completion_handler& h) noexcept : fn_table_(h.fn_table_), impl_(h.impl_) { @@ -527,7 +571,7 @@ class any_completion_handler_allocator template constexpr any_completion_handler_allocator( const any_completion_handler_allocator& a) - ASIO_NOEXCEPT + noexcept : fn_table_(a.fn_table_), impl_(a.impl_) { @@ -535,14 +579,14 @@ class any_completion_handler_allocator /// Equality operator. constexpr bool operator==( - const any_completion_handler_allocator& other) const ASIO_NOEXCEPT + const any_completion_handler_allocator& other) const noexcept { return fn_table_ == other.fn_table_ && impl_ == other.impl_; } /// Inequality operator. constexpr bool operator!=( - const any_completion_handler_allocator& other) const ASIO_NOEXCEPT + const any_completion_handler_allocator& other) const noexcept { return fn_table_ != other.fn_table_ || impl_ != other.impl_; } @@ -576,6 +620,9 @@ class any_completion_handler template friend struct associated_executor; + template + friend struct associated_immediate_executor; + const detail::any_completion_handler_fn_table* fn_table_; detail::any_completion_handler_impl_base* impl_; #endif // !defined(GENERATING_DOCUMENTATION) @@ -604,16 +651,16 @@ class any_completion_handler } /// Construct an @c any_completion_handler to contain the specified target. - template ::type> + template > any_completion_handler(H&& h, - typename constraint< - !is_same::type, any_completion_handler>::value - >::type = 0) + constraint_t< + !is_same, any_completion_handler>::value + > = 0) : fn_table_( &detail::any_completion_handler_fn_table_instance< Handler, Signatures...>::value), impl_(detail::any_completion_handler_impl::create( - (get_associated_cancellation_slot)(h), ASIO_MOVE_CAST(H)(h))) + (get_associated_cancellation_slot)(h), static_cast(h))) { } @@ -621,7 +668,7 @@ class any_completion_handler /** * After the operation, the moved-from object @c other has no target. */ - any_completion_handler(any_completion_handler&& other) ASIO_NOEXCEPT + any_completion_handler(any_completion_handler&& other) noexcept : fn_table_(other.fn_table_), impl_(other.impl_) { @@ -634,15 +681,15 @@ class any_completion_handler * After the operation, the moved-from object @c other has no target. */ any_completion_handler& operator=( - any_completion_handler&& other) ASIO_NOEXCEPT + any_completion_handler&& other) noexcept { any_completion_handler( - ASIO_MOVE_CAST(any_completion_handler)(other)).swap(*this); + static_cast(other)).swap(*this); return *this; } /// Assignment operator that sets the polymorphic wrapper to the empty state. - any_completion_handler& operator=(nullptr_t) ASIO_NOEXCEPT + any_completion_handler& operator=(nullptr_t) noexcept { any_completion_handler().swap(*this); return *this; @@ -656,34 +703,34 @@ class any_completion_handler } /// Test if the polymorphic wrapper is empty. - constexpr explicit operator bool() const ASIO_NOEXCEPT + constexpr explicit operator bool() const noexcept { return impl_ != nullptr; } /// Test if the polymorphic wrapper is non-empty. - constexpr bool operator!() const ASIO_NOEXCEPT + constexpr bool operator!() const noexcept { return impl_ == nullptr; } /// Swap the content of an @c any_completion_handler with another. - void swap(any_completion_handler& other) ASIO_NOEXCEPT + void swap(any_completion_handler& other) noexcept { std::swap(fn_table_, other.fn_table_); std::swap(impl_, other.impl_); } /// Get the associated allocator. - allocator_type get_allocator() const ASIO_NOEXCEPT + allocator_type get_allocator() const noexcept { return allocator_type(0, *this); } /// Get the associated cancellation slot. - cancellation_slot_type get_cancellation_slot() const ASIO_NOEXCEPT + cancellation_slot_type get_cancellation_slot() const noexcept { - return impl_->get_cancellation_slot(); + return impl_ ? impl_->get_cancellation_slot() : cancellation_slot_type(); } /// Function call operator. @@ -697,12 +744,12 @@ class any_completion_handler */ template auto operator()(Args&&... args) - -> decltype(fn_table_->call(impl_, ASIO_MOVE_CAST(Args)(args)...)) + -> decltype(fn_table_->call(impl_, static_cast(args)...)) { if (detail::any_completion_handler_impl_base* impl = impl_) { impl_ = nullptr; - return fn_table_->call(impl, ASIO_MOVE_CAST(Args)(args)...); + return fn_table_->call(impl, static_cast(args)...); } std::bad_function_call ex; asio::detail::throw_exception(ex); @@ -710,28 +757,28 @@ class any_completion_handler /// Equality operator. friend constexpr bool operator==( - const any_completion_handler& a, nullptr_t) ASIO_NOEXCEPT + const any_completion_handler& a, nullptr_t) noexcept { return a.impl_ == nullptr; } /// Equality operator. friend constexpr bool operator==( - nullptr_t, const any_completion_handler& b) ASIO_NOEXCEPT + nullptr_t, const any_completion_handler& b) noexcept { return nullptr == b.impl_; } /// Inequality operator. friend constexpr bool operator!=( - const any_completion_handler& a, nullptr_t) ASIO_NOEXCEPT + const any_completion_handler& a, nullptr_t) noexcept { return a.impl_ != nullptr; } /// Inequality operator. friend constexpr bool operator!=( - nullptr_t, const any_completion_handler& b) ASIO_NOEXCEPT + nullptr_t, const any_completion_handler& b) noexcept { return nullptr != b.impl_; } @@ -743,10 +790,28 @@ struct associated_executor, Candidate> using type = any_completion_executor; static type get(const any_completion_handler& handler, - const Candidate& candidate = Candidate()) ASIO_NOEXCEPT + const Candidate& candidate = Candidate()) noexcept { - return handler.fn_table_->executor(handler.impl_, - any_completion_executor(std::nothrow, candidate)); + any_completion_executor any_candidate(std::nothrow, candidate); + return handler.fn_table_ + ? handler.fn_table_->executor(handler.impl_, any_candidate) + : any_candidate; + } +}; + +template +struct associated_immediate_executor< + any_completion_handler, Candidate> +{ + using type = any_completion_executor; + + static type get(const any_completion_handler& handler, + const Candidate& candidate = Candidate()) noexcept + { + any_io_executor any_candidate(std::nothrow, candidate); + return handler.fn_table_ + ? handler.fn_table_->immediate_executor(handler.impl_, any_candidate) + : any_candidate; } }; @@ -754,9 +819,4 @@ struct associated_executor, Candidate> #include "asio/detail/pop_options.hpp" -#endif // (defined(ASIO_HAS_STD_TUPLE) - // && defined(ASIO_HAS_MOVE) - // && defined(ASIO_HAS_VARIADIC_TEMPLATES)) - // || defined(GENERATING_DOCUMENTATION) - #endif // ASIO_ANY_COMPLETION_HANDLER_HPP diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/any_io_executor.hpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/any_io_executor.hpp index 7a77c90d1208..d35acf44ae34 100644 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/any_io_executor.hpp +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/any_io_executor.hpp @@ -2,7 +2,7 @@ // any_io_executor.hpp // ~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) @@ -87,18 +87,16 @@ class any_io_executor : #endif // !defined(GENERATING_DOCUMENTATION) /// Default constructor. - ASIO_DECL any_io_executor() ASIO_NOEXCEPT; + ASIO_DECL any_io_executor() noexcept; /// Construct in an empty state. Equivalent effects to default constructor. - ASIO_DECL any_io_executor(nullptr_t) ASIO_NOEXCEPT; + ASIO_DECL any_io_executor(nullptr_t) noexcept; /// Copy constructor. - ASIO_DECL any_io_executor(const any_io_executor& e) ASIO_NOEXCEPT; + ASIO_DECL any_io_executor(const any_io_executor& e) noexcept; -#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) /// Move constructor. - ASIO_DECL any_io_executor(any_io_executor&& e) ASIO_NOEXCEPT; -#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) + ASIO_DECL any_io_executor(any_io_executor&& e) noexcept; /// Construct to point to the same target as another any_executor. #if defined(GENERATING_DOCUMENTATION) @@ -107,8 +105,8 @@ class any_io_executor : #else // defined(GENERATING_DOCUMENTATION) template any_io_executor(OtherAnyExecutor e, - typename constraint< - conditional< + constraint_t< + conditional_t< !is_same::value && is_base_of::value, @@ -116,9 +114,9 @@ class any_io_executor : 0, supportable_properties_type>::template is_valid_target, false_type - >::type::value - >::type = 0) - : base_type(ASIO_MOVE_CAST(OtherAnyExecutor)(e)) + >::value + > = 0) + : base_type(static_cast(e)) { } #endif // defined(GENERATING_DOCUMENTATION) @@ -131,8 +129,8 @@ class any_io_executor : #else // defined(GENERATING_DOCUMENTATION) template any_io_executor(std::nothrow_t, OtherAnyExecutor e, - typename constraint< - conditional< + constraint_t< + conditional_t< !is_same::value && is_base_of::value, @@ -140,22 +138,19 @@ class any_io_executor : 0, supportable_properties_type>::template is_valid_target, false_type - >::type::value - >::type = 0) ASIO_NOEXCEPT - : base_type(std::nothrow, ASIO_MOVE_CAST(OtherAnyExecutor)(e)) + >::value + > = 0) noexcept + : base_type(std::nothrow, static_cast(e)) { } #endif // defined(GENERATING_DOCUMENTATION) /// Construct to point to the same target as another any_executor. ASIO_DECL any_io_executor(std::nothrow_t, - const any_io_executor& e) ASIO_NOEXCEPT; + const any_io_executor& e) noexcept; -#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) /// Construct to point to the same target as another any_executor. - ASIO_DECL any_io_executor(std::nothrow_t, - any_io_executor&& e) ASIO_NOEXCEPT; -#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) + ASIO_DECL any_io_executor(std::nothrow_t, any_io_executor&& e) noexcept; /// Construct a polymorphic wrapper for the specified executor. #if defined(GENERATING_DOCUMENTATION) @@ -164,17 +159,17 @@ class any_io_executor : #else // defined(GENERATING_DOCUMENTATION) template any_io_executor(Executor e, - typename constraint< - conditional< + constraint_t< + conditional_t< !is_same::value && !is_base_of::value, execution::detail::is_valid_target_executor< Executor, supportable_properties_type>, false_type - >::type::value - >::type = 0) - : base_type(ASIO_MOVE_CAST(Executor)(e)) + >::value + > = 0) + : base_type(static_cast(e)) { } #endif // defined(GENERATING_DOCUMENTATION) @@ -186,30 +181,27 @@ class any_io_executor : #else // defined(GENERATING_DOCUMENTATION) template any_io_executor(std::nothrow_t, Executor e, - typename constraint< - conditional< + constraint_t< + conditional_t< !is_same::value && !is_base_of::value, execution::detail::is_valid_target_executor< Executor, supportable_properties_type>, false_type - >::type::value - >::type = 0) ASIO_NOEXCEPT - : base_type(std::nothrow, ASIO_MOVE_CAST(Executor)(e)) + >::value + > = 0) noexcept + : base_type(std::nothrow, static_cast(e)) { } #endif // defined(GENERATING_DOCUMENTATION) /// Assignment operator. ASIO_DECL any_io_executor& operator=( - const any_io_executor& e) ASIO_NOEXCEPT; + const any_io_executor& e) noexcept; -#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) /// Move assignment operator. - ASIO_DECL any_io_executor& operator=( - any_io_executor&& e) ASIO_NOEXCEPT; -#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) + ASIO_DECL any_io_executor& operator=(any_io_executor&& e) noexcept; /// Assignment operator that sets the polymorphic wrapper to the empty state. ASIO_DECL any_io_executor& operator=(nullptr_t); @@ -218,7 +210,7 @@ class any_io_executor : ASIO_DECL ~any_io_executor(); /// Swap targets with another polymorphic wrapper. - ASIO_DECL void swap(any_io_executor& other) ASIO_NOEXCEPT; + ASIO_DECL void swap(any_io_executor& other) noexcept; /// Obtain a polymorphic wrapper with the specified property. /** @@ -231,9 +223,9 @@ class any_io_executor : */ template any_io_executor require(const Property& p, - typename constraint< + constraint_t< traits::require_member::is_valid - >::type = 0) const + > = 0) const { return static_cast(*this).require(p); } @@ -249,9 +241,9 @@ class any_io_executor : */ template any_io_executor prefer(const Property& p, - typename constraint< + constraint_t< traits::prefer_member::is_valid - >::type = 0) const + > = 0) const { return static_cast(*this).prefer(p); } diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/append.hpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/append.hpp index 9ac4a95044e0..046089242801 100644 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/append.hpp +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/append.hpp @@ -2,7 +2,7 @@ // append.hpp // ~~~~~~~~~~ // -// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) @@ -16,11 +16,6 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include "asio/detail/config.hpp" - -#if (defined(ASIO_HAS_STD_TUPLE) \ - && defined(ASIO_HAS_VARIADIC_TEMPLATES)) \ - || defined(GENERATING_DOCUMENTATION) - #include #include "asio/detail/type_traits.hpp" @@ -37,11 +32,9 @@ class append_t public: /// Constructor. template - ASIO_CONSTEXPR explicit append_t( - ASIO_MOVE_ARG(T) completion_token, - ASIO_MOVE_ARG(V)... values) - : token_(ASIO_MOVE_CAST(T)(completion_token)), - values_(ASIO_MOVE_CAST(V)(values)...) + constexpr explicit append_t(T&& completion_token, V&&... values) + : token_(static_cast(completion_token)), + values_(static_cast(values)...) { } @@ -54,15 +47,13 @@ class append_t /// arguments should be passed additional values after the results of the /// operation. template -ASIO_NODISCARD inline ASIO_CONSTEXPR append_t< - typename decay::type, typename decay::type...> -append(ASIO_MOVE_ARG(CompletionToken) completion_token, - ASIO_MOVE_ARG(Values)... values) +ASIO_NODISCARD inline constexpr +append_t, decay_t...> +append(CompletionToken&& completion_token, Values&&... values) { - return append_t< - typename decay::type, typename decay::type...>( - ASIO_MOVE_CAST(CompletionToken)(completion_token), - ASIO_MOVE_CAST(Values)(values)...); + return append_t, decay_t...>( + static_cast(completion_token), + static_cast(values)...); } } // namespace asio @@ -71,8 +62,4 @@ append(ASIO_MOVE_ARG(CompletionToken) completion_token, #include "asio/impl/append.hpp" -#endif // (defined(ASIO_HAS_STD_TUPLE) - // && defined(ASIO_HAS_VARIADIC_TEMPLATES)) - // || defined(GENERATING_DOCUMENTATION) - #endif // ASIO_APPEND_HPP diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/as_tuple.hpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/as_tuple.hpp index 96ac47c82e47..ab1894efcec4 100644 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/as_tuple.hpp +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/as_tuple.hpp @@ -2,7 +2,7 @@ // as_tuple.hpp // ~~~~~~~~~~~~ // -// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) @@ -16,11 +16,6 @@ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include "asio/detail/config.hpp" - -#if (defined(ASIO_HAS_STD_TUPLE) \ - && defined(ASIO_HAS_VARIADIC_TEMPLATES)) \ - || defined(GENERATING_DOCUMENTATION) - #include "asio/detail/type_traits.hpp" #include "asio/detail/push_options.hpp" @@ -50,18 +45,18 @@ class as_tuple_t * token is itself defaulted as an argument to allow it to capture a source * location. */ - ASIO_CONSTEXPR as_tuple_t( + constexpr as_tuple_t( default_constructor_tag = default_constructor_tag(), CompletionToken token = CompletionToken()) - : token_(ASIO_MOVE_CAST(CompletionToken)(token)) + : token_(static_cast(token)) { } /// Constructor. template - ASIO_CONSTEXPR explicit as_tuple_t( - ASIO_MOVE_ARG(T) completion_token) - : token_(ASIO_MOVE_CAST(T)(completion_token)) + constexpr explicit as_tuple_t( + T&& completion_token) + : token_(static_cast(completion_token)) { } @@ -76,13 +71,13 @@ class as_tuple_t /// Construct the adapted executor from the inner executor type. template executor_with_default(const InnerExecutor1& ex, - typename constraint< - conditional< + constraint_t< + conditional_t< !is_same::value, is_convertible, false_type - >::type::value - >::type = 0) ASIO_NOEXCEPT + >::value + > = 0) noexcept : InnerExecutor(ex) { } @@ -90,41 +85,63 @@ class as_tuple_t /// Type alias to adapt an I/O object to use @c as_tuple_t as its /// default completion token type. -#if defined(ASIO_HAS_ALIAS_TEMPLATES) \ - || defined(GENERATING_DOCUMENTATION) template using as_default_on_t = typename T::template rebind_executor< - executor_with_default >::other; -#endif // defined(ASIO_HAS_ALIAS_TEMPLATES) - // || defined(GENERATING_DOCUMENTATION) + executor_with_default>::other; /// Function helper to adapt an I/O object to use @c as_tuple_t as its /// default completion token type. template - static typename decay::type::template rebind_executor< - executor_with_default::type::executor_type> + static typename decay_t::template rebind_executor< + executor_with_default::executor_type> >::other - as_default_on(ASIO_MOVE_ARG(T) object) + as_default_on(T&& object) { - return typename decay::type::template rebind_executor< - executor_with_default::type::executor_type> - >::other(ASIO_MOVE_CAST(T)(object)); + return typename decay_t::template rebind_executor< + executor_with_default::executor_type> + >::other(static_cast(object)); } //private: CompletionToken token_; }; -/// Adapt a @ref completion_token to specify that the completion handler -/// arguments should be combined into a single tuple argument. -template -ASIO_NODISCARD inline -ASIO_CONSTEXPR as_tuple_t::type> -as_tuple(ASIO_MOVE_ARG(CompletionToken) completion_token) +/// A function object type that adapts a @ref completion_token to specify that +/// the completion handler arguments should be combined into a single tuple +/// argument. +/** + * May also be used directly as a completion token, in which case it adapts the + * asynchronous operation's default completion token (or asio::deferred + * if no default is available). + */ +struct partial_as_tuple { - return as_tuple_t::type>( - ASIO_MOVE_CAST(CompletionToken)(completion_token)); -} + /// Default constructor. + constexpr partial_as_tuple() + { + } + + /// Adapt a @ref completion_token to specify that the completion handler + /// arguments should be combined into a single tuple argument. + template + ASIO_NODISCARD inline + constexpr as_tuple_t> + operator()(CompletionToken&& completion_token) const + { + return as_tuple_t>( + static_cast(completion_token)); + } +}; + +/// A function object that adapts a @ref completion_token to specify that the +/// completion handler arguments should be combined into a single tuple +/// argument. +/** + * May also be used directly as a completion token, in which case it adapts the + * asynchronous operation's default completion token (or asio::deferred + * if no default is available). + */ +ASIO_INLINE_VARIABLE constexpr partial_as_tuple as_tuple; } // namespace asio @@ -132,8 +149,4 @@ as_tuple(ASIO_MOVE_ARG(CompletionToken) completion_token) #include "asio/impl/as_tuple.hpp" -#endif // (defined(ASIO_HAS_STD_TUPLE) - // && defined(ASIO_HAS_VARIADIC_TEMPLATES)) - // || defined(GENERATING_DOCUMENTATION) - #endif // ASIO_AS_TUPLE_HPP diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/associated_allocator.hpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/associated_allocator.hpp index 8e864673cd2d..f21ea250efb3 100644 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/associated_allocator.hpp +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/associated_allocator.hpp @@ -2,7 +2,7 @@ // associated_allocator.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) @@ -36,9 +36,7 @@ struct has_allocator_type : false_type }; template -struct has_allocator_type::type> - : true_type +struct has_allocator_type> : true_type { }; @@ -49,33 +47,30 @@ struct associated_allocator_impl typedef A type; - static type get(const T&) ASIO_NOEXCEPT + static type get(const T&) noexcept { return type(); } - static const type& get(const T&, const A& a) ASIO_NOEXCEPT + static const type& get(const T&, const A& a) noexcept { return a; } }; template -struct associated_allocator_impl::type> +struct associated_allocator_impl> { typedef typename T::allocator_type type; - static ASIO_AUTO_RETURN_TYPE_PREFIX(type) get( - const T& t) ASIO_NOEXCEPT - ASIO_AUTO_RETURN_TYPE_SUFFIX((t.get_allocator())) + static auto get(const T& t) noexcept + -> decltype(t.get_allocator()) { return t.get_allocator(); } - static ASIO_AUTO_RETURN_TYPE_PREFIX(type) get( - const T& t, const A&) ASIO_NOEXCEPT - ASIO_AUTO_RETURN_TYPE_SUFFIX((t.get_allocator())) + static auto get(const T& t, const A&) noexcept + -> decltype(t.get_allocator()) { return t.get_allocator(); } @@ -83,12 +78,12 @@ struct associated_allocator_impl struct associated_allocator_impl::value - >::type, - typename void_type< + >, + void_t< typename associator::type - >::type> : associator + >> : associator { }; @@ -115,7 +110,7 @@ struct associated_allocator_impl > +template > struct associated_allocator #if !defined(GENERATING_DOCUMENTATION) : detail::associated_allocator_impl @@ -128,11 +123,11 @@ struct associated_allocator /// If @c T has a nested type @c allocator_type, returns /// t.get_allocator(). Otherwise returns @c type(). - static decltype(auto) get(const T& t) ASIO_NOEXCEPT; + static decltype(auto) get(const T& t) noexcept; /// If @c T has a nested type @c allocator_type, returns /// t.get_allocator(). Otherwise returns @c a. - static decltype(auto) get(const T& t, const Allocator& a) ASIO_NOEXCEPT; + static decltype(auto) get(const T& t, const Allocator& a) noexcept; #endif // defined(GENERATING_DOCUMENTATION) }; @@ -142,7 +137,7 @@ struct associated_allocator */ template ASIO_NODISCARD inline typename associated_allocator::type -get_associated_allocator(const T& t) ASIO_NOEXCEPT +get_associated_allocator(const T& t) noexcept { return associated_allocator::get(t); } @@ -152,23 +147,17 @@ get_associated_allocator(const T& t) ASIO_NOEXCEPT * @returns associated_allocator::get(t, a) */ template -ASIO_NODISCARD inline ASIO_AUTO_RETURN_TYPE_PREFIX2( - typename associated_allocator::type) -get_associated_allocator(const T& t, const Allocator& a) ASIO_NOEXCEPT - ASIO_AUTO_RETURN_TYPE_SUFFIX(( - associated_allocator::get(t, a))) +ASIO_NODISCARD inline auto get_associated_allocator( + const T& t, const Allocator& a) noexcept + -> decltype(associated_allocator::get(t, a)) { return associated_allocator::get(t, a); } -#if defined(ASIO_HAS_ALIAS_TEMPLATES) - -template > +template > using associated_allocator_t = typename associated_allocator::type; -#endif // defined(ASIO_HAS_ALIAS_TEMPLATES) - namespace detail { template @@ -178,22 +167,19 @@ struct associated_allocator_forwarding_base template struct associated_allocator_forwarding_base::asio_associated_allocator_is_unspecialised, void >::value - >::type> + >> { typedef void asio_associated_allocator_is_unspecialised; }; } // namespace detail -#if defined(ASIO_HAS_STD_REFERENCE_WRAPPER) \ - || defined(GENERATING_DOCUMENTATION) - /// Specialisation of associated_allocator for @c std::reference_wrapper. template struct associated_allocator, Allocator> @@ -207,25 +193,20 @@ struct associated_allocator, Allocator> /// Forwards the request to get the allocator to the associator specialisation /// for the unwrapped type @c T. - static type get(reference_wrapper t) ASIO_NOEXCEPT + static type get(reference_wrapper t) noexcept { return associated_allocator::get(t.get()); } /// Forwards the request to get the allocator to the associator specialisation /// for the unwrapped type @c T. - static ASIO_AUTO_RETURN_TYPE_PREFIX(type) get( - reference_wrapper t, const Allocator& a) ASIO_NOEXCEPT - ASIO_AUTO_RETURN_TYPE_SUFFIX(( - associated_allocator::get(t.get(), a))) + static auto get(reference_wrapper t, const Allocator& a) noexcept + -> decltype(associated_allocator::get(t.get(), a)) { return associated_allocator::get(t.get(), a); } }; -#endif // defined(ASIO_HAS_STD_REFERENCE_WRAPPER) - // || defined(GENERATING_DOCUMENTATION) - } // namespace asio #include "asio/detail/pop_options.hpp" diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/associated_cancellation_slot.hpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/associated_cancellation_slot.hpp index 65d82b646ba4..518bd881eaff 100644 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/associated_cancellation_slot.hpp +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/associated_cancellation_slot.hpp @@ -2,7 +2,7 @@ // associated_cancellation_slot.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) @@ -36,9 +36,8 @@ struct has_cancellation_slot_type : false_type }; template -struct has_cancellation_slot_type::type> - : true_type +struct has_cancellation_slot_type> + : true_type { }; @@ -49,12 +48,12 @@ struct associated_cancellation_slot_impl typedef S type; - static type get(const T&) ASIO_NOEXCEPT + static type get(const T&) noexcept { return type(); } - static const type& get(const T&, const S& s) ASIO_NOEXCEPT + static const type& get(const T&, const S& s) noexcept { return s; } @@ -62,20 +61,18 @@ struct associated_cancellation_slot_impl template struct associated_cancellation_slot_impl::type> + void_t> { typedef typename T::cancellation_slot_type type; - static ASIO_AUTO_RETURN_TYPE_PREFIX(type) get( - const T& t) ASIO_NOEXCEPT - ASIO_AUTO_RETURN_TYPE_SUFFIX((t.get_cancellation_slot())) + static auto get(const T& t) noexcept + -> decltype(t.get_cancellation_slot()) { return t.get_cancellation_slot(); } - static ASIO_AUTO_RETURN_TYPE_PREFIX(type) get( - const T& t, const S&) ASIO_NOEXCEPT - ASIO_AUTO_RETURN_TYPE_SUFFIX((t.get_cancellation_slot())) + static auto get(const T& t, const S&) noexcept + -> decltype(t.get_cancellation_slot()) { return t.get_cancellation_slot(); } @@ -83,12 +80,12 @@ struct associated_cancellation_slot_impl struct associated_cancellation_slot_impl::value - >::type, - typename void_type< + >, + void_t< typename associator::type - >::type> : associator + >> : associator { }; @@ -129,12 +126,12 @@ struct associated_cancellation_slot /// If @c T has a nested type @c cancellation_slot_type, returns /// t.get_cancellation_slot(). Otherwise returns @c type(). - static decltype(auto) get(const T& t) ASIO_NOEXCEPT; + static decltype(auto) get(const T& t) noexcept; /// If @c T has a nested type @c cancellation_slot_type, returns /// t.get_cancellation_slot(). Otherwise returns @c s. static decltype(auto) get(const T& t, - const CancellationSlot& s) ASIO_NOEXCEPT; + const CancellationSlot& s) noexcept; #endif // defined(GENERATING_DOCUMENTATION) }; @@ -144,7 +141,7 @@ struct associated_cancellation_slot */ template ASIO_NODISCARD inline typename associated_cancellation_slot::type -get_associated_cancellation_slot(const T& t) ASIO_NOEXCEPT +get_associated_cancellation_slot(const T& t) noexcept { return associated_cancellation_slot::get(t); } @@ -155,24 +152,17 @@ get_associated_cancellation_slot(const T& t) ASIO_NOEXCEPT * CancellationSlot>::get(t, st) */ template -ASIO_NODISCARD inline ASIO_AUTO_RETURN_TYPE_PREFIX2( - typename associated_cancellation_slot::type) -get_associated_cancellation_slot(const T& t, - const CancellationSlot& st) ASIO_NOEXCEPT - ASIO_AUTO_RETURN_TYPE_SUFFIX(( - associated_cancellation_slot::get(t, st))) +ASIO_NODISCARD inline auto get_associated_cancellation_slot( + const T& t, const CancellationSlot& st) noexcept + -> decltype(associated_cancellation_slot::get(t, st)) { return associated_cancellation_slot::get(t, st); } -#if defined(ASIO_HAS_ALIAS_TEMPLATES) - template using associated_cancellation_slot_t = typename associated_cancellation_slot::type; -#endif // defined(ASIO_HAS_ALIAS_TEMPLATES) - namespace detail { template @@ -182,22 +172,19 @@ struct associated_cancellation_slot_forwarding_base template struct associated_cancellation_slot_forwarding_base::asio_associated_cancellation_slot_is_unspecialised, void >::value - >::type> + >> { typedef void asio_associated_cancellation_slot_is_unspecialised; }; } // namespace detail -#if defined(ASIO_HAS_STD_REFERENCE_WRAPPER) \ - || defined(GENERATING_DOCUMENTATION) - /// Specialisation of associated_cancellation_slot for @c /// std::reference_wrapper. template @@ -212,25 +199,21 @@ struct associated_cancellation_slot, CancellationSlot> /// Forwards the request to get the cancellation slot to the associator /// specialisation for the unwrapped type @c T. - static type get(reference_wrapper t) ASIO_NOEXCEPT + static type get(reference_wrapper t) noexcept { return associated_cancellation_slot::get(t.get()); } /// Forwards the request to get the cancellation slot to the associator /// specialisation for the unwrapped type @c T. - static ASIO_AUTO_RETURN_TYPE_PREFIX(type) get(reference_wrapper t, - const CancellationSlot& s) ASIO_NOEXCEPT - ASIO_AUTO_RETURN_TYPE_SUFFIX(( - associated_cancellation_slot::get(t.get(), s))) + static auto get(reference_wrapper t, const CancellationSlot& s) noexcept + -> decltype( + associated_cancellation_slot::get(t.get(), s)) { return associated_cancellation_slot::get(t.get(), s); } }; -#endif // defined(ASIO_HAS_STD_REFERENCE_WRAPPER) - // || defined(GENERATING_DOCUMENTATION) - } // namespace asio #include "asio/detail/pop_options.hpp" diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/associated_executor.hpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/associated_executor.hpp index 92279891d655..4ca7ba149e90 100644 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/associated_executor.hpp +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/associated_executor.hpp @@ -2,7 +2,7 @@ // associated_executor.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) @@ -38,8 +38,7 @@ struct has_executor_type : false_type }; template -struct has_executor_type::type> +struct has_executor_type> : true_type { }; @@ -51,33 +50,30 @@ struct associated_executor_impl typedef E type; - static type get(const T&) ASIO_NOEXCEPT + static type get(const T&) noexcept { return type(); } - static const type& get(const T&, const E& e) ASIO_NOEXCEPT + static const type& get(const T&, const E& e) noexcept { return e; } }; template -struct associated_executor_impl::type> +struct associated_executor_impl> { typedef typename T::executor_type type; - static ASIO_AUTO_RETURN_TYPE_PREFIX(type) get( - const T& t) ASIO_NOEXCEPT - ASIO_AUTO_RETURN_TYPE_SUFFIX((t.get_executor())) + static auto get(const T& t) noexcept + -> decltype(t.get_executor()) { return t.get_executor(); } - static ASIO_AUTO_RETURN_TYPE_PREFIX(type) get( - const T& t, const E&) ASIO_NOEXCEPT - ASIO_AUTO_RETURN_TYPE_SUFFIX((t.get_executor())) + static auto get(const T& t, const E&) noexcept + -> decltype(t.get_executor()) { return t.get_executor(); } @@ -85,12 +81,12 @@ struct associated_executor_impl struct associated_executor_impl::value - >::type, - typename void_type< + >, + void_t< typename associator::type - >::type> : associator + >> : associator { }; @@ -130,11 +126,11 @@ struct associated_executor /// If @c T has a nested type @c executor_type, returns /// t.get_executor(). Otherwise returns @c type(). - static decltype(auto) get(const T& t) ASIO_NOEXCEPT; + static decltype(auto) get(const T& t) noexcept; /// If @c T has a nested type @c executor_type, returns /// t.get_executor(). Otherwise returns @c ex. - static decltype(auto) get(const T& t, const Executor& ex) ASIO_NOEXCEPT; + static decltype(auto) get(const T& t, const Executor& ex) noexcept; #endif // defined(GENERATING_DOCUMENTATION) }; @@ -144,7 +140,7 @@ struct associated_executor */ template ASIO_NODISCARD inline typename associated_executor::type -get_associated_executor(const T& t) ASIO_NOEXCEPT +get_associated_executor(const T& t) noexcept { return associated_executor::get(t); } @@ -154,14 +150,12 @@ get_associated_executor(const T& t) ASIO_NOEXCEPT * @returns associated_executor::get(t, ex) */ template -ASIO_NODISCARD inline ASIO_AUTO_RETURN_TYPE_PREFIX2( - typename associated_executor::type) -get_associated_executor(const T& t, const Executor& ex, - typename constraint< +ASIO_NODISCARD inline auto get_associated_executor( + const T& t, const Executor& ex, + constraint_t< is_executor::value || execution::is_executor::value - >::type = 0) ASIO_NOEXCEPT - ASIO_AUTO_RETURN_TYPE_SUFFIX(( - associated_executor::get(t, ex))) + > = 0) noexcept + -> decltype(associated_executor::get(t, ex)) { return associated_executor::get(t, ex); } @@ -175,20 +169,16 @@ template ASIO_NODISCARD inline typename associated_executor::type get_associated_executor(const T& t, ExecutionContext& ctx, - typename constraint::value>::type = 0) ASIO_NOEXCEPT + constraint_t::value> = 0) noexcept { return associated_executor::get(t, ctx.get_executor()); } -#if defined(ASIO_HAS_ALIAS_TEMPLATES) - template using associated_executor_t = typename associated_executor::type; -#endif // defined(ASIO_HAS_ALIAS_TEMPLATES) - namespace detail { template @@ -198,22 +188,19 @@ struct associated_executor_forwarding_base template struct associated_executor_forwarding_base::asio_associated_executor_is_unspecialised, void >::value - >::type> + >> { typedef void asio_associated_executor_is_unspecialised; }; } // namespace detail -#if defined(ASIO_HAS_STD_REFERENCE_WRAPPER) \ - || defined(GENERATING_DOCUMENTATION) - /// Specialisation of associated_executor for @c std::reference_wrapper. template struct associated_executor, Executor> @@ -227,25 +214,20 @@ struct associated_executor, Executor> /// Forwards the request to get the executor to the associator specialisation /// for the unwrapped type @c T. - static type get(reference_wrapper t) ASIO_NOEXCEPT + static type get(reference_wrapper t) noexcept { return associated_executor::get(t.get()); } /// Forwards the request to get the executor to the associator specialisation /// for the unwrapped type @c T. - static ASIO_AUTO_RETURN_TYPE_PREFIX(type) get( - reference_wrapper t, const Executor& ex) ASIO_NOEXCEPT - ASIO_AUTO_RETURN_TYPE_SUFFIX(( - associated_executor::get(t.get(), ex))) + static auto get(reference_wrapper t, const Executor& ex) noexcept + -> decltype(associated_executor::get(t.get(), ex)) { return associated_executor::get(t.get(), ex); } }; -#endif // defined(ASIO_HAS_STD_REFERENCE_WRAPPER) - // || defined(GENERATING_DOCUMENTATION) - } // namespace asio #include "asio/detail/pop_options.hpp" diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/associated_immediate_executor.hpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/associated_immediate_executor.hpp index 54bced17a57c..f189f1ca2f9a 100644 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/associated_immediate_executor.hpp +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/associated_immediate_executor.hpp @@ -2,7 +2,7 @@ // associated_immediate_executor.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) @@ -41,7 +41,7 @@ struct has_immediate_executor_type : false_type template struct has_immediate_executor_type::type> + void_t> : true_type { }; @@ -49,9 +49,10 @@ struct has_immediate_executor_type struct default_immediate_executor { - typedef typename require_result::type type; + typedef decay_t> type; - static type get(const E& e) ASIO_NOEXCEPT + static auto get(const E& e) noexcept + -> decltype(asio::require(e, execution::blocking.never)) { return asio::require(e, execution::blocking.never); } @@ -59,59 +60,57 @@ struct default_immediate_executor template struct default_immediate_executor::value - >::type, - typename enable_if< + >, + enable_if_t< is_executor::value - >::type> + >> { class type : public E { public: template explicit type(const Executor1& e, - typename constraint< - conditional< + constraint_t< + conditional_t< !is_same::value, is_convertible, false_type - >::type::value - >::type = 0) ASIO_NOEXCEPT + >::value + > = 0) noexcept : E(e) { } - type(const type& other) ASIO_NOEXCEPT + type(const type& other) noexcept : E(static_cast(other)) { } -#if defined(ASIO_HAS_MOVE) - type(type&& other) ASIO_NOEXCEPT - : E(ASIO_MOVE_CAST(E)(other)) + type(type&& other) noexcept + : E(static_cast(other)) { } -#endif // defined(ASIO_HAS_MOVE) template - void dispatch(ASIO_MOVE_ARG(Function) f, const Allocator& a) const + void dispatch(Function&& f, const Allocator& a) const { - this->post(ASIO_MOVE_CAST(Function)(f), a); + this->post(static_cast(f), a); } - friend bool operator==(const type& a, const type& b) ASIO_NOEXCEPT + friend bool operator==(const type& a, const type& b) noexcept { return static_cast(a) == static_cast(b); } - friend bool operator!=(const type& a, const type& b) ASIO_NOEXCEPT + friend bool operator!=(const type& a, const type& b) noexcept { return static_cast(a) != static_cast(b); } }; - static type get(const E& e) ASIO_NOEXCEPT + static type get(const E& e) noexcept { return type(e); } @@ -124,9 +123,8 @@ struct associated_immediate_executor_impl typedef typename default_immediate_executor::type type; - static ASIO_AUTO_RETURN_TYPE_PREFIX(type) get( - const T&, const E& e) ASIO_NOEXCEPT - ASIO_AUTO_RETURN_TYPE_SUFFIX((default_immediate_executor::get(e))) + static auto get(const T&, const E& e) noexcept + -> decltype(default_immediate_executor::get(e)) { return default_immediate_executor::get(e); } @@ -134,13 +132,12 @@ struct associated_immediate_executor_impl template struct associated_immediate_executor_impl::type> + void_t> { typedef typename T::immediate_executor_type type; - static ASIO_AUTO_RETURN_TYPE_PREFIX(type) get( - const T& t, const E&) ASIO_NOEXCEPT - ASIO_AUTO_RETURN_TYPE_SUFFIX((t.get_immediate_executor())) + static auto get(const T& t, const E&) noexcept + -> decltype(t.get_immediate_executor()) { return t.get_immediate_executor(); } @@ -148,12 +145,12 @@ struct associated_immediate_executor_impl struct associated_immediate_executor_impl::value - >::type, - typename void_type< + >, + void_t< typename associator::type - >::type> : associator + >> : associator { }; @@ -194,7 +191,7 @@ struct associated_immediate_executor /// If @c T has a nested type @c immediate_executor_type, returns /// t.get_immediate_executor(). Otherwise returns /// asio::require(ex, asio::execution::blocking.never). - static decltype(auto) get(const T& t, const Executor& ex) ASIO_NOEXCEPT; + static decltype(auto) get(const T& t, const Executor& ex) noexcept; #endif // defined(GENERATING_DOCUMENTATION) }; @@ -203,14 +200,12 @@ struct associated_immediate_executor * @returns associated_immediate_executor::get(t, ex) */ template -ASIO_NODISCARD inline ASIO_AUTO_RETURN_TYPE_PREFIX2( - typename associated_immediate_executor::type) -get_associated_immediate_executor(const T& t, const Executor& ex, - typename constraint< +ASIO_NODISCARD inline auto get_associated_immediate_executor( + const T& t, const Executor& ex, + constraint_t< is_executor::value || execution::is_executor::value - >::type = 0) ASIO_NOEXCEPT - ASIO_AUTO_RETURN_TYPE_SUFFIX(( - associated_immediate_executor::get(t, ex))) + > = 0) noexcept + -> decltype(associated_immediate_executor::get(t, ex)) { return associated_immediate_executor::get(t, ex); } @@ -224,21 +219,18 @@ template ASIO_NODISCARD inline typename associated_immediate_executor::type get_associated_immediate_executor(const T& t, ExecutionContext& ctx, - typename constraint::value>::type = 0) ASIO_NOEXCEPT + constraint_t< + is_convertible::value + > = 0) noexcept { return associated_immediate_executor::get(t, ctx.get_executor()); } -#if defined(ASIO_HAS_ALIAS_TEMPLATES) - template using associated_immediate_executor_t = typename associated_immediate_executor::type; -#endif // defined(ASIO_HAS_ALIAS_TEMPLATES) - namespace detail { template @@ -248,22 +240,19 @@ struct associated_immediate_executor_forwarding_base template struct associated_immediate_executor_forwarding_base::asio_associated_immediate_executor_is_unspecialised, void >::value - >::type> + >> { typedef void asio_associated_immediate_executor_is_unspecialised; }; } // namespace detail -#if defined(ASIO_HAS_STD_REFERENCE_WRAPPER) \ - || defined(GENERATING_DOCUMENTATION) - /// Specialisation of associated_immediate_executor for /// @c std::reference_wrapper. template @@ -278,18 +267,13 @@ struct associated_immediate_executor, Executor> /// Forwards the request to get the executor to the associator specialisation /// for the unwrapped type @c T. - static ASIO_AUTO_RETURN_TYPE_PREFIX(type) get( - reference_wrapper t, const Executor& ex) ASIO_NOEXCEPT - ASIO_AUTO_RETURN_TYPE_SUFFIX(( - associated_immediate_executor::get(t.get(), ex))) + static auto get(reference_wrapper t, const Executor& ex) noexcept + -> decltype(associated_immediate_executor::get(t.get(), ex)) { return associated_immediate_executor::get(t.get(), ex); } }; -#endif // defined(ASIO_HAS_STD_REFERENCE_WRAPPER) - // || defined(GENERATING_DOCUMENTATION) - } // namespace asio #include "asio/detail/pop_options.hpp" diff --git a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/associator.hpp b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/associator.hpp index e954c44289d6..fbc97694a6f5 100644 --- a/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/associator.hpp +++ b/applications/CoSimulationApplication/custom_external_libraries/CoSimIO/external_libraries/asio/include/asio/associator.hpp @@ -2,7 +2,7 @@ // associator.hpp // ~~~~~~~~~~~~~~ // -// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2024 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) @@ -23,7 +23,7 @@ namespace asio { /// Used to generically specialise associators for a type. template