diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9be7e27058..f9e3dd0c8b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -247,6 +247,10 @@ option( KICAD_GAL_PROFILE
"Enable profiling info for GAL"
OFF )
+option( KICAD_IPC_API
+ "Enable experimental IPC API"
+ OFF )
+
# Global setting: exports are explicit
set( CMAKE_CXX_VISIBILITY_PRESET "hidden" )
set( CMAKE_VISIBILITY_INLINES_HIDDEN ON )
@@ -278,6 +282,10 @@ if( KICAD_WAYLAND )
add_compile_definitions( KICAD_WAYLAND )
endif()
+if( KICAD_IPC_API )
+ add_definitions( -DKICAD_IPC_API )
+endif()
+
# Ensure DEBUG is defined for all platforms in Debug builds
add_compile_definitions( $<$<CONFIG:Debug>:DEBUG> )
@@ -842,6 +850,26 @@ if( OCC_VERSION_STRING VERSION_LESS 7.5.0 )
endif()
include_directories( SYSTEM ${OCC_INCLUDE_DIR} )
+option( KICAD_USE_CMAKE_FINDPROTOBUF "Use FindProtobuf provided by CMake" OFF )
+mark_as_advanced( KICAD_USE_CMAKE_FINDPROTOBUF )
+
+if( KICAD_USE_CMAKE_FINDPROTOBUF )
+ include( FindProtobuf )
+ find_package( Protobuf REQUIRED )
+else()
+ find_package( Protobuf REQUIRED CONFIG )
+ set( Protobuf_LIBRARY "protobuf::libprotobuf" )
+endif()
+
+if( NOT Protobuf_PROTOC_EXECUTABLE )
+ set( Protobuf_PROTOC_EXECUTABLE "protobuf::protoc" )
+endif()
+
+if( NOT Protobuf_INCLUDE_DIR )
+ get_target_property( Protobuf_INCLUDE_DIR protobuf::libprotobuf INTERFACE_INCLUDE_DIRECTORIES )
+endif()
+
+
# Assist with header file searching optimization:
# INC_BEFORE and INC_AFTER are two lists which go at the front and back of the
# header file search lists, respectively.
@@ -1051,6 +1079,10 @@ if( KICAD_USE_SENTRY )
add_compile_definitions( KICAD_USE_SENTRY )
endif()
+if( KICAD_IPC_API )
+ find_package( nng REQUIRED )
+endif()
+
#================================================
# Add the doxygen target
#================================================
@@ -1121,6 +1153,8 @@ if( KICAD_BUILD_I18N )
add_subdirectory( translation )
endif()
+add_subdirectory( api )
+
if( APPLE )
set( KICAD_OSX_CODESIGN ON
CACHE BOOL "Sign KiCad.app on macOS" FORCE )
diff --git a/api/CMakeLists.txt b/api/CMakeLists.txt
new file mode 100644
index 0000000000..2138c8de34
--- /dev/null
+++ b/api/CMakeLists.txt
@@ -0,0 +1,118 @@
+# This program source code file is part of KiCad, a free EDA CAD application.
+#
+# Copyright (C) 2023 KiCad Developers, see AUTHORS.TXT for contributors.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or (at your
+# option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program. If not, see <http://www.gnu.org/licenses/>.
+
+# Search paths for protoc when generating code
+set( Protobuf_IMPORT_DIRS ${Protobuf_INCLUDE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/proto )
+
+set( KIAPI_PROTO_SRCS
+ common/envelope.proto
+
+ common/types/base_types.proto
+
+ common/commands/base_commands.proto
+ common/commands/editor_commands.proto
+
+ board/board_types.proto
+ )
+
+# Generated C++ code must be in the build dir; it is dependent on the version of protoc installed
+set( KIAPI_CPP_BASEPATH ${CMAKE_CURRENT_BINARY_DIR}/cpp/api )
+
+foreach( PROTO_SRC ${KIAPI_PROTO_SRCS} )
+ string( REGEX REPLACE "\.proto$" ".pb.cc" CPP_SRC ${PROTO_SRC} )
+ string( REGEX REPLACE "\.proto$" ".pb.h" CPP_HEADER ${PROTO_SRC} )
+ set( KIAPI_CPP_SRCS ${KIAPI_CPP_SRCS} ${KIAPI_CPP_BASEPATH}/${CPP_SRC} )
+ set( KIAPI_CPP_HEADERS ${KIAPI_CPP_HEADERS} ${KIAPI_CPP_BASEPATH}/${CPP_HEADER} )
+ set( KIAPI_PROTO_SRC_FULLPATHS ${KIAPI_PROTO_SRC_FULLPATHS} ${CMAKE_CURRENT_SOURCE_DIR}/proto/${PROTO_SRC} )
+endforeach ()
+
+add_custom_command( COMMAND ${CMAKE_COMMAND} -E make_directory ${KIAPI_CPP_BASEPATH}
+ COMMAND ${Protobuf_PROTOC_EXECUTABLE}
+ --cpp_out=dllexport_decl=KIAPI_IMPORTEXPORT:${KIAPI_CPP_BASEPATH}
+ --proto_path=${CMAKE_CURRENT_SOURCE_DIR}/proto
+ ${KIAPI_PROTO_SRCS}
+ COMMENT "Generating API protobuf source files from proto definitions..."
+ WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+ DEPENDS ${KIAPI_PROTO_SRC_FULLPATHS}
+ OUTPUT ${KIAPI_CPP_SRCS} ${KIAPI_CPP_HEADERS}
+ )
+
+# kiapi must be a shared DLL because the protobuf messages can only be initialized once
+add_library( kiapi SHARED
+ ${CMAKE_CURRENT_SOURCE_DIR}/../include/import_export.h
+ ${KIAPI_CPP_SRCS}
+ ${KIAPI_CPP_HEADERS}
+ )
+
+target_compile_definitions( kiapi PRIVATE KIAPI_IMPORTEXPORT=APIEXPORT )
+target_compile_definitions( kiapi INTERFACE KIAPI_IMPORTEXPORT=APIIMPORT )
+
+# https://groups.google.com/g/protobuf/c/PDR1bqRazts
+if(MSVC)
+ target_compile_options( kiapi PRIVATE /FI${CMAKE_CURRENT_SOURCE_DIR}/../include/import_export.h )
+else()
+ add_definitions( -include ${CMAKE_CURRENT_SOURCE_DIR}/../include/import_export.h )
+endif()
+
+if( APPLE )
+ # puts library into the main kicad.app bundle in build tree
+ set_target_properties( kiapi PROPERTIES
+ LIBRARY_OUTPUT_DIRECTORY "${OSX_BUNDLE_BUILD_LIB_DIR}"
+ INSTALL_NAME_DIR "${OSX_BUNDLE_BUILD_LIB_DIR}"
+ )
+endif()
+
+install( TARGETS
+ kiapi
+ RUNTIME DESTINATION ${KICAD_LIB}
+ LIBRARY DESTINATION ${KICAD_LIB}
+ COMPONENT binary
+ )
+
+if( KICAD_WIN32_INSTALL_PDBS )
+ # Get the PDBs to copy over for MSVC
+ install(FILES $<TARGET_PDB_FILE:kiapi> DESTINATION ${KICAD_BIN})
+endif()
+
+# Because CMake doesn't guess this from the .cc extension generated by protoc
+set_target_properties( kiapi PROPERTIES LINKER_LANGUAGE CXX )
+
+target_include_directories( kiapi SYSTEM PUBLIC ${Protobuf_INCLUDE_DIRS} )
+
+target_link_libraries( kiapi protobuf::libprotobuf )
+
+target_include_directories( kiapi INTERFACE
+ ${CMAKE_CURRENT_BINARY_DIR}/cpp # Leaving off the /api/ to make #include statments less ambiguous
+ )
+
+# Because when building internally, the generated files do not include the "api" base path
+target_include_directories( kiapi PUBLIC ${KIAPI_CPP_BASEPATH} )
+
+option( KICAD_BUILD_ENUM_EXPORTER
+ "Build the enum exporter used as part of generating the IPC APIs"
+ OFF )
+
+if( KICAD_BUILD_ENUM_EXPORTER )
+ add_subdirectory( enums )
+
+ add_custom_target( enum_definitions
+ COMMAND $<TARGET_FILE:enum_exporter> ${CMAKE_CURRENT_BINARY_DIR}/enums.json
+ WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+ COMMENT "Generating API definitions from KiCad enums..."
+ DEPENDS enum_exporter
+ )
+endif()
diff --git a/api/enums/CMakeLists.txt b/api/enums/CMakeLists.txt
new file mode 100644
index 0000000000..3c5efd20e4
--- /dev/null
+++ b/api/enums/CMakeLists.txt
@@ -0,0 +1,43 @@
+# This program source code file is part of KiCad, a free EDA CAD application.
+#
+# Copyright (C) 2023 KiCad Developers, see AUTHORS.TXT for contributors.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or (at your
+# option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program. If not, see <http://www.gnu.org/licenses/>.
+
+include_directories( BEFORE ${INC_BEFORE} )
+include_directories(
+ ${INC_AFTER}
+ )
+
+add_executable( enum_exporter WIN32
+ enum_exporter.cpp
+ )
+
+target_link_libraries( enum_exporter
+ common
+ )
+
+target_include_directories( enum_exporter PRIVATE
+ $<TARGET_PROPERTY:magic_enum,INTERFACE_INCLUDE_DIRECTORIES>
+ )
+
+if( MSVC )
+ # The cli needs subsystem:console or else we can't link wmain/main
+ set_target_properties(enum_exporter PROPERTIES COMPILE_DEFINITIONS_DEBUG "_CONSOLE")
+ set_target_properties(enum_exporter PROPERTIES COMPILE_DEFINITIONS_RELWITHDEBINFO "_CONSOLE")
+ set_target_properties(enum_exporter PROPERTIES LINK_FLAGS_DEBUG "/SUBSYSTEM:CONSOLE")
+ set_target_properties(enum_exporter PROPERTIES LINK_FLAGS_RELWITHDEBINFO "/SUBSYSTEM:CONSOLE")
+ set_target_properties(enum_exporter PROPERTIES LINK_FLAGS_RELEASE "/SUBSYSTEM:CONSOLE")
+ set_target_properties(enum_exporter PROPERTIES LINK_FLAGS_MINSIZEREL "/SUBSYSTEM:CONSOLE")
+endif()
diff --git a/api/enums/enum_exporter.cpp b/api/enums/enum_exporter.cpp
new file mode 100644
index 0000000000..c9accd65bb
--- /dev/null
+++ b/api/enums/enum_exporter.cpp
@@ -0,0 +1,91 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2023 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <filesystem>
+#include <iostream>
+#include <string>
+
+#include <argparse/argparse.hpp>
+#include <fmt.h>
+#include <nlohmann/json.hpp>
+
+#define MAGIC_ENUM_RANGE_MAX 1024
+#include <magic_enum.hpp>
+
+#include <layer_ids.h>
+#include <eda_shape.h>
+#include <core/typeinfo.h>
+
+
+template<typename T>
+nlohmann::json FormatEnum()
+{
+ nlohmann::json js;
+
+ js["type"] = magic_enum::enum_type_name<T>();
+ js["values"] = nlohmann::json::array();
+
+ for( const std::pair<T, std::string_view>& entry : magic_enum::enum_entries<T>() )
+ {
+ js["values"].emplace_back( nlohmann::json( {
+ { "key", entry.second },
+ { "value", static_cast<int>( entry.first ) }
+ } ) );
+ }
+
+ return js;
+}
+
+
+int main( int argc, char* argv[] )
+{
+ argparse::ArgumentParser args( "enum_exporter" );
+
+ args.add_argument( "output_dir" ).default_value( std::string() );
+
+ try
+ {
+ args.parse_args( argc, argv );
+ }
+ catch( const std::runtime_error& err )
+ {
+ std::cerr << err.what() << std::endl;
+ std::cerr << args;
+ std::exit( 1 );
+ }
+
+ std::filesystem::path path( args.get<std::string>( "output_dir" ) );
+ std::ofstream outfile;
+
+ if( !path.empty() )
+ {
+ path = std::filesystem::absolute( path );
+ outfile.open( path );
+ }
+
+ std::ostream& out = outfile.is_open() ? outfile : std::cout;
+
+ nlohmann::json js = nlohmann::json::array();
+
+ js += FormatEnum<PCB_LAYER_ID>();
+ js += FormatEnum<SHAPE_T>();
+ js += FormatEnum<KICAD_T>();
+
+ out << js.dump( 4 ) << std::endl;
+}
diff --git a/api/proto/board/board_types.proto b/api/proto/board/board_types.proto
new file mode 100644
index 0000000000..d02ef2da4e
--- /dev/null
+++ b/api/proto/board/board_types.proto
@@ -0,0 +1,110 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+syntax = "proto3";
+
+package kiapi.board.types;
+
+import "common/types/base_types.proto";
+
+/// Represents a track segment on a board
+message Track
+{
+ kiapi.common.types.KIID id = 1;
+ kiapi.common.types.Point2D start = 2;
+ kiapi.common.types.Point2D end = 3;
+ kiapi.common.types.Distance width = 4;
+ kiapi.common.types.LockedState locked = 5;
+ kiapi.common.types.BoardLayer layer = 6;
+ kiapi.common.types.Net net = 7;
+}
+
+/// Represents an arc track (not a PCB_SHAPE in arc shape)
+/// Arc tracks in KiCad store start, midpoint, and end.
+/// All other values (center point, angles, etc) are inferred.
+message Arc
+{
+ kiapi.common.types.KIID id = 1;
+ kiapi.common.types.Point2D start = 2;
+ kiapi.common.types.Point2D mid = 3; /// Arc midpoint
+ kiapi.common.types.Point2D end = 4;
+ kiapi.common.types.Distance width = 5;
+ kiapi.common.types.LockedState locked = 6;
+ kiapi.common.types.BoardLayer layer = 7;
+ kiapi.common.types.Net net = 8;
+}
+
+enum PadStackType
+{
+ PST_UNKNOWN = 0;
+ PST_THROUGH = 1; /// Through all layers; same shape on all layers
+ PST_BLIND_BURIED = 2; /// From a start layer to end layer (inclusive); same shape on all included layers
+}
+
+enum UnconnectedLayerRemoval
+{
+ ULR_UNKNOWN = 0;
+
+ /// Keep annular rings on all layers
+ ULR_KEEP = 1;
+
+ /// Remove annular rings on unconnected layers, including start and end layers.
+ ULR_REMOVE = 2;
+
+ /// Remove annular rings on unconnected layers, but preserve start and end layers even if unconnected.
+ ULR_REMOVE_EXCEPT_START_AND_END = 3;
+}
+
+/// A pad stack definition for a multilayer pad or via.
+message PadStack
+{
+ /// What type of pad stack this represents.
+ PadStackType type = 1;
+
+ /// Lowest (closest to F_Cu) layer this stack exists on. Ignored if type == PST_THROUGH.
+ kiapi.common.types.BoardLayer start_layer = 2;
+
+ /// Highest (closest to B_Cu) layer this stack exists on. Ignored if type == PST_THROUGH.
+ kiapi.common.types.BoardLayer end_layer = 3;
+
+ /// How to treat annular rings on unconnected layers.
+ UnconnectedLayerRemoval unconnected_layer_removal = 4;
+}
+
+/// Represents a via
+message Via
+{
+ /// The unique identifier of the via
+ kiapi.common.types.KIID id = 1;
+
+ /// The location of the via's center point
+ kiapi.common.types.Point2D position = 2;
+
+ /// The diameter of the via's circular copper pad
+ kiapi.common.types.Distance pad_diameter = 4;
+
+ /// The diameter of the via's drilled hole
+ kiapi.common.types.Distance drill_diameter = 5;
+
+ /// The pad stack definition for this via. The via's VIATYPE (blind/buried/normal) is inferred from this.
+ PadStack pad_stack = 6;
+
+ kiapi.common.types.LockedState locked = 7;
+ kiapi.common.types.Net net = 8;
+}
diff --git a/api/proto/common/commands/base_commands.proto b/api/proto/common/commands/base_commands.proto
new file mode 100644
index 0000000000..d2c69e1b4c
--- /dev/null
+++ b/api/proto/common/commands/base_commands.proto
@@ -0,0 +1,33 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+syntax = "proto3";
+
+package kiapi.common.commands;
+
+import "common/types/base_types.proto";
+
+message GetVersion
+{
+}
+
+message GetVersionResponse
+{
+ kiapi.common.types.KiCadVersion version = 1;
+}
diff --git a/api/proto/common/commands/editor_commands.proto b/api/proto/common/commands/editor_commands.proto
new file mode 100644
index 0000000000..6299faaa8f
--- /dev/null
+++ b/api/proto/common/commands/editor_commands.proto
@@ -0,0 +1,251 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * Commands and responses related to manipulating editor windows
+ */
+
+syntax = "proto3";
+
+package kiapi.common.commands;
+
+import "google/protobuf/any.proto";
+import "common/types/base_types.proto";
+
+/// Refreshes the given frame, if that frame is open
+message RefreshEditor
+{
+ kiapi.common.types.FrameType frame = 1;
+}
+
+/// Retrieves a list of open documents of the given type
+message GetOpenDocuments
+{
+ /// Which type of documents to query
+ kiapi.common.types.DocumentType type = 1;
+}
+
+message GetOpenDocumentsResponse
+{
+ repeated kiapi.common.types.DocumentSpecifier documents = 1;
+}
+
+/*
+ * Runs a TOOL_ACTION using the TOOL_MANAGER of a given frame.
+ * WARNING: The TOOL_ACTIONs are specifically *not* an API.
+ * Command names may change as code is refactored, and commands may disappear.
+ * This API method is provided for low-level prototyping purposes only.
+ */
+message RunAction
+{
+ string action = 1; // Action name, like "eeschema.InteractiveSelection.ClearSelection"
+}
+
+enum RunActionStatus
+{
+ RAS_UNKNOWN = 0;
+ RAS_OK = 1; // The action was submitted successfully.
+ RAS_INVALID = 2; // The action was unknown for the targeted frame.
+ RAS_FRAME_NOT_OPEN = 3; // The targeted frame was not open when the call was submitted.
+}
+
+/*
+ * NOTE: At the moment, RAS_FRAME_NOT_OPEN won't be returned as the handler is inside the frame.
+ */
+message RunActionResponse
+{
+ RunActionStatus status = 1;
+}
+
+
+/*
+ * Begins a staged set of changes. Any modifications made to a document through the API after this
+ * call will be saved to a pending commit, and will not appear in KiCad until a matching call to
+ * END_COMMIT.
+ */
+message BeginCommit
+{
+}
+
+
+message BeginCommitResponse
+{
+}
+
+
+enum CommitResult
+{
+ CR_UNKNOWN = 0;
+ CR_OK = 1; // Commit was pushed successfully
+ CR_NO_COMMIT = 2; // There was no commit started
+}
+
+
+message EndCommit
+{
+ // Optional message describing this changeset
+ string message = 1;
+}
+
+
+message EndCommitResponse
+{
+ CommitResult result = 1;
+}
+
+/// Creates new items on a given document
+message CreateItems
+{
+ /// Specifies which document to create on, which fields are included, etc.
+ kiapi.common.types.ItemHeader header = 1;
+
+ /// List of items to create
+ repeated google.protobuf.Any items = 2;
+
+ /// Items may be created on a top-level document (sheet, board, etc) or inside a container
+ /// (symbol, footprint). If this field is not empty, it holds the ID of a symbol or footprint
+ /// that the items should be added to. This ID must be an existing symbol (for schematic
+ /// documents) or footprint (for board documents). If the given container does not exist or is
+ /// not the correct item type, the CreateItems call will fail.
+ kiapi.common.types.KIID container = 3;
+}
+
+enum ItemCreationStatus
+{
+ ICS_UNKNOWN = 0;
+ ICS_OK = 1; /// The item was created
+ ICS_INVALID_TYPE = 2; /// The item's type is not valid for the given document
+ ICS_EXISTING = 3; /// The item had a specified KIID and that KIID was already in use
+}
+
+message ItemCreationResult
+{
+ ItemCreationStatus status = 1;
+
+ /// The created version of the item, including an updated KIID as applicable
+ google.protobuf.Any item = 2;
+}
+
+message CreateItemsResponse
+{
+ /// Specifies which document was modified, which fields are included in created_items, etc.
+ kiapi.common.types.ItemHeader header = 1;
+
+ /// Status of the overall request; may return IRS_OK even if no items were created
+ kiapi.common.types.ItemRequestStatus status = 2;
+
+ /// Status of each item to be created
+ repeated ItemCreationResult created_items = 3;
+}
+
+message GetItems
+{
+ /// Specifies which document to query, which fields to return, etc.
+ kiapi.common.types.ItemHeader header = 1;
+
+ /// List of one or more types of items to retreive
+ repeated kiapi.common.types.ItemType types = 2;
+}
+
+message GetItemsResponse
+{
+ /// Specifies which document was modified, which fields are included in items, etc.
+ kiapi.common.types.ItemHeader header = 1;
+
+ /// Status of the overall request; may return IRS_OK even if no items were retrieved
+ kiapi.common.types.ItemRequestStatus status = 2;
+
+ repeated google.protobuf.Any items = 3;
+}
+
+/// Updates items in a given document
+message UpdateItems
+{
+ /// Specifies which document to modify, which fields are included, etc.
+ kiapi.common.types.ItemHeader header = 1;
+
+ /// List of items to modify
+ repeated google.protobuf.Any items = 2;
+}
+
+enum ItemUpdateStatus
+{
+ IUS_UNKNOWN = 0;
+ IUS_OK = 1; /// The item was updated
+ IUS_INVALID_TYPE = 2; /// The item's type is not valid for the given document
+ IUS_NONEXISTENT = 3; /// The item did not exist in the given document
+ IUS_IMMUTABLE = 4; /// The item is not allowed to be modified by the API
+}
+
+message ItemUpdateResult
+{
+ ItemUpdateStatus status = 1;
+
+ /// The update version of the item
+ google.protobuf.Any item = 2;
+}
+
+message UpdateItemsResponse
+{
+ /// Specifies which document was modified, which fields are included in updated_items, etc.
+ kiapi.common.types.ItemHeader header = 1;
+
+ /// Status of the overall request; may return IRS_OK even if no items were modified
+ kiapi.common.types.ItemRequestStatus status = 2;
+
+ /// Status of each item to be created
+ repeated ItemUpdateResult updated_items = 3;
+}
+
+/// Deletes items in a given document
+message DeleteItems
+{
+ /// Specifies which document to modify
+ kiapi.common.types.ItemHeader header = 1;
+
+ /// List of item KIIDs to delete
+ repeated kiapi.common.types.KIID item_ids = 2;
+}
+
+enum ItemDeletionStatus
+{
+ IDS_UNKNOWN = 0;
+ IDS_OK = 1;
+ IDS_NONEXISTENT = 2; /// The item did not exist in the given document
+ IDS_IMMUTABLE = 3; /// The item is not allowed to be modified by the API
+}
+
+message ItemDeletionResult
+{
+ kiapi.common.types.KIID id = 1;
+
+ ItemDeletionStatus status = 2;
+}
+
+message DeleteItemsResponse
+{
+ /// Specifies which document was modified, etc.
+ kiapi.common.types.ItemHeader header = 1;
+
+ /// Status of the overall request; may return IRS_OK even if no items were deleted
+ kiapi.common.types.ItemRequestStatus status = 2;
+
+ /// Status of each item requested to be deleted
+ repeated ItemDeletionResult deleted_items = 3;
+}
diff --git a/api/proto/common/envelope.proto b/api/proto/common/envelope.proto
new file mode 100644
index 0000000000..8ae918d423
--- /dev/null
+++ b/api/proto/common/envelope.proto
@@ -0,0 +1,90 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+syntax = "proto3";
+
+package kiapi.common;
+
+import "google/protobuf/any.proto";
+
+enum ApiStatusCode
+{
+ AS_UNKNOWN = 0;
+ AS_OK = 1; // Request succeeded
+ AS_TIMEOUT = 2; // Request timed out
+ AS_BAD_REQUEST = 3; // The request had invalid parameters or otherwise was illegal
+ AS_NOT_READY = 4; // KiCad was not (yet) in a state where it could handle API requests
+ AS_UNHANDLED = 5; // The request was not handled by KiCad
+ AS_TOKEN_MISMATCH = 6; // The kicad_token in the request didn't match this KiCad's token
+}
+
+/*
+ * For future expansion: any header fields that should be sent with a request
+ */
+message ApiRequestHeader
+{
+ // An opaque string identifying a running instance of KiCad. If this is set to a non-empty
+ // string in an API request, KiCad will reject the request if the value doesn't match its own
+ // token. This can be used to let API clients make sure they are still talking to the same
+ // instance of KiCad if they are long-running.
+ string kicad_token = 1;
+
+ // A string identifying an API client. Should be set by the client to a value that is unique
+ // to a specific instance of a client, for example the package name of the client plus its
+ // process ID or a random string, e.g. "com.github.me.my_awesome_plugin-73951". The main purpose
+ // of this name is to identify the client in debug logs.
+ string client_name = 2;
+}
+
+/*
+ * The top-level envelope container for an API request (message from a client to the KiCad API server)
+ */
+message ApiRequest
+{
+ ApiRequestHeader header = 1;
+
+ google.protobuf.Any message = 2;
+}
+
+/*
+ * For future expansion: any header fields that should be sent with a response
+ */
+message ApiResponseHeader
+{
+ /// An opaque string identifying a running instance of KiCad.
+ string kicad_token = 1;
+}
+
+message ApiResponse
+{
+ ApiResponseHeader header = 1;
+
+ ApiResponseStatus status = 2;
+
+ google.protobuf.Any message = 3;
+}
+
+message ApiResponseStatus
+{
+ /// A code describing the category of error (or AS_OK if no error)
+ ApiStatusCode status = 1;
+
+ /// A human-readable description of the error, if any
+ string error_message = 2;
+}
diff --git a/api/proto/common/types/base_types.proto b/api/proto/common/types/base_types.proto
new file mode 100644
index 0000000000..b9fa3fc9cd
--- /dev/null
+++ b/api/proto/common/types/base_types.proto
@@ -0,0 +1,217 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2024 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * base_types.proto
+ * Includes types used in many parts of the API
+ */
+
+syntax = "proto3";
+
+package kiapi.common.types;
+
+import "google/protobuf/field_mask.proto";
+
+enum CommandStatus
+{
+ CS_UNKNOWN = 0;
+ CS_OK = 1; // Command succeeded
+ CS_FAILED = 2; // Command failed
+}
+
+message CommandStatusResponse
+{
+ CommandStatus status = 1;
+}
+
+/**
+ * Describes a particular version of KiCad
+ */
+message KiCadVersion
+{
+ uint32 major = 1;
+ uint32 minor = 2;
+ uint32 patch = 3;
+
+ // Full identifier string, potentially containing git hashes, packager-added info, etc.
+ string full_version = 4;
+}
+
+/**
+ * Some commands are specific to a KiCad window (frame). This list contains all addressable frames.
+ */
+enum FrameType
+{
+ FT_UNKNOWN = 0;
+ FT_PROJECT_MANAGER = 1;
+ FT_SCHEMATIC_EDITOR = 2;
+ FT_PCB_EDITOR = 3;
+ FT_SPICE_SIMULATOR = 4;
+ FT_SYMBOL_EDITOR = 5;
+ FT_FOOTPRINT_EDITOR = 6;
+ FT_DRAWING_SHEET_EDITOR = 7;
+}
+
+/**
+ * Describes a KIID, or UUID of an object in a KiCad editor model.
+ */
+message KIID
+{
+ // The KIID's value in standard UUID format, stored as a string for easy portability
+ string value = 1;
+}
+
+/**
+ * Identifier for the type of document being targeted by a request
+ */
+enum DocumentType
+{
+ DOCTYPE_UNKNOWN = 0;
+ DOCTYPE_SCHEMATIC = 1;
+ DOCTYPE_SYMBOL = 2;
+ DOCTYPE_PCB = 3;
+ DOCTYPE_FOOTPRINT = 4;
+ DOCTYPE_DRAWING_SHEET = 5;
+}
+
+/**
+ * Describes a KiCad LIB_ID; a unique identifier for a loaded symbol or footprint
+ */
+message LibraryIdentifier
+{
+ /// The library portion of the LIB_ID
+ string library_nickname = 1;
+
+ /// The symbol or footprint name
+ string entry_name = 2;
+}
+
+/**
+ * Describes a unique sheet in a schematic
+ */
+message SheetPath
+{
+ /// The canonical path to the sheet. The first KIID will be the root sheet, etc.
+ repeated KIID path = 1;
+
+ /// The path converted to a human readable form such as "/", "/child", or "/child/grandchild"
+ string path_human_readable = 2;
+}
+
+/**
+ * Describes a document that will be the target of a request
+ */
+message DocumentSpecifier
+{
+ DocumentType type = 1;
+
+ oneof identifier
+ {
+ /// If type == DT_SYMBOL or DT_FOOTPRINT, identifies a certain library entry
+ LibraryIdentifier lib_id = 2;
+
+ /// If type == DT_SCHEMATIC, identifies a sheet with a given path
+ SheetPath sheet_path = 3;
+
+ /// If type == DT_PCB, identifies a PCB with a given filename, e.g. "board.kicad_pcb"
+ string board_filename = 4;
+ }
+}
+
+/**
+ * Describes the type of a KiCad item (wrapper for KICAD_T)
+ */
+message ItemType
+{
+ /// Must be a valid value in the KICAD_T C++ enum (see typeinfo.h)
+ int32 type = 1;
+}
+
+/**
+ * This header is included in requests and responses about item(s) in a document
+ */
+message ItemHeader
+{
+ /// Which document is this request targeting?
+ DocumentSpecifier document = 1;
+
+ /// Which fields on the item(s) are included with this request or response
+ google.protobuf.FieldMask field_mask = 2;
+}
+
+/**
+ * Status of a request that included an ItemHeader
+ */
+enum ItemRequestStatus
+{
+ IRS_UNKNOWN = 0;
+ IRS_OK = 1;
+ IRS_DOCUMENT_NOT_FOUND = 2; /// The given document is not open in KiCad
+ IRS_FIELD_MASK_INVALID = 3; /// The given field_mask contains invalid specifiers
+}
+
+/// Describes a point in 2D space. All coordinates are in nanometers.
+message Point2D
+{
+ int64 x_nm = 1;
+ int64 y_nm = 2;
+}
+
+/// Describes a point in 3D space. All coordinates are in nanometers.
+message Point3D
+{
+ int64 x_nm = 1;
+ int64 y_nm = 2;
+ int64 z_nm = 3;
+}
+
+/// Describes a quantity of distance (size, length, etc). All coordinates are in nanometers.
+message Distance
+{
+ int64 value_nm = 1;
+}
+
+/// Describes whether or not an item is locked for editing or movement
+enum LockedState
+{
+ LS_UNKNOWN = 0;
+ LS_UNLOCKED = 1;
+ LS_LOCKED = 2;
+}
+
+message BoardLayer
+{
+ int32 layer_id = 1; /// From PCB_LAYER_T
+}
+
+/// Describes a copper item's net
+message Net
+{
+ /// A unique code representing this net
+ int32 code = 1;
+
+ /// Human-readable net name
+ string name = 2;
+}
+
+/// Describes a net class (a grouping of nets)
+message NetClass
+{
+ string name = 1;
+}
diff --git a/cmake/Findnng.cmake b/cmake/Findnng.cmake
new file mode 100644
index 0000000000..9b4e05b440
--- /dev/null
+++ b/cmake/Findnng.cmake
@@ -0,0 +1,26 @@
+find_package(PkgConfig)
+
+if(PKG_CONFIG_FOUND)
+ pkg_check_modules(_NNG nng)
+endif (PKG_CONFIG_FOUND)
+
+FIND_PATH(NNG_INCLUDE_DIR
+ NAMES
+ nng/nng.h
+ PATH_SUFFIXES
+ include
+ )
+
+FIND_LIBRARY(NNG_LIBRARY
+ NAMES
+ nng
+ PATH_SUFFIXES
+ "lib"
+ "local/lib"
+ )
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(nng
+ REQUIRED_VARS NNG_INCLUDE_DIR NNG_LIBRARY)
+
+MARK_AS_ADVANCED(NNG_INCLUDE_DIR NNG_LIBRARY)
diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt
index 07b35d676c..a67cb76a65 100644
--- a/common/CMakeLists.txt
+++ b/common/CMakeLists.txt
@@ -186,6 +186,7 @@ set_target_properties(kicommon PROPERTIES CXX_VISIBILITY_PRESET hidden)
target_link_libraries( kicommon
core
+ kiapi
kimath
kiplatform
nlohmann_json
@@ -254,6 +255,7 @@ target_include_directories( kicommon
.
${CMAKE_BINARY_DIR}
$<TARGET_PROPERTY:pegtl,INTERFACE_INCLUDE_DIRECTORIES>
+ $<TARGET_PROPERTY:kiapi,INTERFACE_INCLUDE_DIRECTORIES>
)
add_dependencies( kicommon pegtl version_header )
@@ -335,6 +337,8 @@ set( COMMON_DLG_SRCS
dialogs/panel_mouse_settings_base.cpp
dialogs/panel_packages_and_updates.cpp
dialogs/panel_packages_and_updates_base.cpp
+ dialogs/panel_python_settings.cpp
+ dialogs/panel_python_settings_base.cpp
dialogs/panel_setup_netclasses.cpp
dialogs/panel_setup_netclasses_base.cpp
dialogs/panel_setup_severities.cpp
@@ -608,6 +612,15 @@ set( COMMON_SRCS
)
+if( KICAD_IPC_API )
+ set( COMMON_SRCS
+ ${COMMON_SRCS}
+ api/api_server.cpp
+ api/api_handler.cpp
+ api/api_handler_common.cpp
+ )
+endif()
+
add_library( common STATIC
${COMMON_SRCS}
)
@@ -647,6 +660,12 @@ if( KICAD_USE_SENTRY )
sentry )
endif()
+if( KICAD_IPC_API )
+ target_link_libraries( common
+ kinng
+ )
+endif()
+
target_include_directories( common
PUBLIC
.
@@ -656,19 +675,17 @@ target_include_directories( common
# text markup support
add_dependencies( common pegtl )
+
target_include_directories( common PUBLIC
$<TARGET_PROPERTY:pegtl,INTERFACE_INCLUDE_DIRECTORIES>
+ $<TARGET_PROPERTY:magic_enum,INTERFACE_INCLUDE_DIRECTORIES>
+ $<TARGET_PROPERTY:expected,INTERFACE_INCLUDE_DIRECTORIES>
)
target_include_directories( common SYSTEM PUBLIC
$<TARGET_PROPERTY:nanodbc,INTERFACE_INCLUDE_DIRECTORIES>
)
-target_include_directories( common PUBLIC
- $<TARGET_PROPERTY:magic_enum,INTERFACE_INCLUDE_DIRECTORIES>
- )
-
-
set( PCB_COMMON_SRCS
fp_lib_table.cpp
hash_eda.cpp
diff --git a/common/advanced_config.cpp b/common/advanced_config.cpp
index 1228b00169..7bab16d597 100644
--- a/common/advanced_config.cpp
+++ b/common/advanced_config.cpp
@@ -110,6 +110,7 @@ static const wxChar OcePluginAngularDeflection[] = wxT( "OcePluginAngularDeflect
static const wxChar TriangulateSimplificationLevel[] = wxT( "TriangulateSimplificationLevel" );
static const wxChar TriangulateMinimumArea[] = wxT( "TriangulateMinimumArea" );
static const wxChar EnableCacheFriendlyFracture[] = wxT( "EnableCacheFriendlyFracture" );
+static const wxChar EnableAPILogging[] = wxT( "EnableAPILogging" );
} // namespace KEYS
@@ -244,6 +245,7 @@ ADVANCED_CFG::ADVANCED_CFG()
m_3DRT_BevelExtentFactor = 1.0 / 16.0;
m_UseClipper2 = true;
+ m_EnableAPILogging = false;
m_Use3DConnexionDriver = true;
@@ -444,6 +446,9 @@ void ADVANCED_CFG::loadSettings( wxConfigBase& aCfg )
configParams.push_back( new PARAM_CFG_BOOL( true, AC_KEYS::EnableGenerators,
&m_EnableGenerators, m_EnableGenerators ) );
+ configParams.push_back( new PARAM_CFG_BOOL( true, AC_KEYS::EnableAPILogging,
+ &m_EnableAPILogging, m_EnableAPILogging ) );
+
configParams.push_back( new PARAM_CFG_BOOL( true, AC_KEYS::EnableGit,
&m_EnableGit, m_EnableGit ) );
diff --git a/common/api/api_handler.cpp b/common/api/api_handler.cpp
new file mode 100644
index 0000000000..f1f1620a95
--- /dev/null
+++ b/common/api/api_handler.cpp
@@ -0,0 +1,74 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2023 Jon Evans <jon@craftyjon.com>
+ * Copyright (C) 2023 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <api/api_handler.h>
+
+using kiapi::common::ApiRequest, kiapi::common::ApiResponse, kiapi::common::ApiResponseStatus;
+
+
+API_RESULT API_HANDLER::Handle( ApiRequest& aMsg )
+{
+ ApiResponseStatus status;
+
+ if( !aMsg.has_message() )
+ {
+ status.set_status( ApiStatusCode::AS_BAD_REQUEST );
+ status.set_error_message( "request has no inner message" );
+ return tl::unexpected( status );
+ }
+
+ std::string typeName;
+
+ if( !google::protobuf::Any::ParseAnyTypeUrl( aMsg.message().type_url(), &typeName ) )
+ {
+ status.set_status( ApiStatusCode::AS_BAD_REQUEST );
+ status.set_error_message( "could not parse inner message type" );
+ return tl::unexpected( status );
+ }
+
+ auto it = m_handlers.find( typeName );
+
+ if( it != m_handlers.end() )
+ {
+ REQUEST_HANDLER& handler = it->second;
+ return handler( aMsg );
+ }
+
+ status.set_status( ApiStatusCode::AS_UNHANDLED );
+ // This response is used internally; no need for an error message
+ return tl::unexpected( status );
+}
+
+
+std::optional<KICAD_T> API_HANDLER::TypeNameFromAny( const google::protobuf::Any& aMessage )
+{
+ static const std::map<std::string, KICAD_T> s_types = {
+ { "type.googleapis.com/kiapi.board.types.Track", PCB_TRACE_T },
+ { "type.googleapis.com/kiapi.board.types.Arc", PCB_ARC_T },
+ { "type.googleapis.com/kiapi.board.types.Via", PCB_VIA_T },
+ };
+
+ auto it = s_types.find( aMessage.type_url() );
+
+ if( it != s_types.end() )
+ return it->second;
+
+ return std::nullopt;
+}
diff --git a/common/api/api_handler_common.cpp b/common/api/api_handler_common.cpp
new file mode 100644
index 0000000000..8ff39c6f58
--- /dev/null
+++ b/common/api/api_handler_common.cpp
@@ -0,0 +1,52 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2023 Jon Evans <jon@craftyjon.com>
+ * Copyright (C) 2023 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <tuple>
+
+#include <api/api_handler_common.h>
+#include <build_version.h>
+#include <pgm_base.h>
+#include <wx/string.h>
+
+using namespace kiapi::common::commands;
+using namespace kiapi::common::types;
+using google::protobuf::Empty;
+
+
+API_HANDLER_COMMON::API_HANDLER_COMMON() :
+ API_HANDLER()
+{
+ registerHandler<GetVersion, GetVersionResponse>( &API_HANDLER_COMMON::handleGetVersion );
+}
+
+
+HANDLER_RESULT<GetVersionResponse> API_HANDLER_COMMON::handleGetVersion( GetVersion& aMsg )
+{
+ GetVersionResponse reply;
+
+ reply.mutable_version()->set_full_version( GetBuildVersion().ToStdString() );
+
+ std::tuple<int, int, int> version = GetMajorMinorPatchTuple();
+ reply.mutable_version()->set_major( std::get<0>( version ) );
+ reply.mutable_version()->set_minor( std::get<1>( version ) );
+ reply.mutable_version()->set_patch( std::get<2>( version ) );
+
+ return reply;
+}
diff --git a/common/api/api_server.cpp b/common/api/api_server.cpp
new file mode 100644
index 0000000000..5cf8505e36
--- /dev/null
+++ b/common/api/api_server.cpp
@@ -0,0 +1,193 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2023 Jon Evans <jon@craftyjon.com>
+ * Copyright (C) 2023 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <wx/app.h>
+#include <wx/datetime.h>
+#include <wx/event.h>
+
+#include <advanced_config.h>
+#include <api/api_server.h>
+#include <api/api_handler_common.h>
+#include <kiid.h>
+#include <kinng.h>
+#include <paths.h>
+#include <pgm_base.h>
+#include <string_utils.h>
+
+#include <api/common/envelope.pb.h>
+
+using kiapi::common::ApiRequest, kiapi::common::ApiResponse, kiapi::common::ApiStatusCode;
+
+
+wxString KICAD_API_SERVER::s_logFileName = "api.log";
+
+
+wxDEFINE_EVENT( API_REQUEST_EVENT, wxCommandEvent );
+
+
+KICAD_API_SERVER::KICAD_API_SERVER() :
+ wxEvtHandler(),
+ m_token( KIID().AsStdString() ),
+ m_readyToReply( false )
+{
+ m_server = std::make_unique<KINNG_REQUEST_SERVER>();
+ m_server->SetCallback( [&]( std::string* aRequest ) { onApiRequest( aRequest ); } );
+
+ m_commonHandler = std::make_unique<API_HANDLER_COMMON>();
+ RegisterHandler( m_commonHandler.get() );
+
+ m_logFilePath.AssignDir( PATHS::GetLogsPath() );
+ m_logFilePath.SetName( s_logFileName );
+
+ if( ADVANCED_CFG::GetCfg().m_EnableAPILogging )
+ PATHS::EnsurePathExists( PATHS::GetLogsPath() );
+
+ log( "--- KiCad API server started ---\n" );
+
+ Bind( API_REQUEST_EVENT, &KICAD_API_SERVER::handleApiEvent, this );
+}
+
+
+KICAD_API_SERVER::~KICAD_API_SERVER()
+{
+}
+
+
+void KICAD_API_SERVER::RegisterHandler( API_HANDLER* aHandler )
+{
+ wxCHECK( aHandler, /* void */ );
+ m_handlers.insert( aHandler );
+}
+
+
+void KICAD_API_SERVER::DeregisterHandler( API_HANDLER* aHandler )
+{
+ m_handlers.erase( aHandler );
+}
+
+
+void KICAD_API_SERVER::onApiRequest( std::string* aRequest )
+{
+ if( !m_readyToReply )
+ {
+ ApiResponse notHandled;
+ notHandled.mutable_status()->set_status( ApiStatusCode::AS_NOT_READY );
+ notHandled.mutable_status()->set_error_message( "KiCad is not ready to reply" );
+ m_server->Reply( notHandled.SerializeAsString() );
+ log( "Got incoming request but was not yet ready to reply." );
+ return;
+ }
+
+ wxCommandEvent* evt = new wxCommandEvent( API_REQUEST_EVENT );
+
+ // We don't actually need write access to this string, but client data is non-const
+ evt->SetClientData( static_cast<void*>( aRequest ) );
+
+ // Takes ownership and frees the wxCommandEvent
+ QueueEvent( evt );
+}
+
+
+void KICAD_API_SERVER::handleApiEvent( wxCommandEvent& aEvent )
+{
+ std::string& requestString = *static_cast<std::string*>( aEvent.GetClientData() );
+ ApiRequest request;
+
+ if( !request.ParseFromString( requestString ) )
+ {
+ ApiResponse error;
+ error.mutable_header()->set_kicad_token( m_token );
+ error.mutable_status()->set_status( ApiStatusCode::AS_BAD_REQUEST );
+ error.mutable_status()->set_error_message( "request could not be parsed" );
+ m_server->Reply( error.SerializeAsString() );
+ log( "Response (ERROR): " + error.Utf8DebugString() );
+ }
+
+ log( "Request: " + request.Utf8DebugString() );
+
+ if( !request.header().kicad_token().empty() &&
+ request.header().kicad_token().compare( m_token ) != 0 )
+ {
+ ApiResponse error;
+ error.mutable_header()->set_kicad_token( m_token );
+ error.mutable_status()->set_status( ApiStatusCode::AS_TOKEN_MISMATCH );
+ error.mutable_status()->set_error_message(
+ "the provided kicad_token did not match this KiCad instance's token" );
+ m_server->Reply( error.SerializeAsString() );
+ log( "Response (ERROR): " + error.Utf8DebugString() );
+ }
+
+ API_RESULT result;
+
+ for( API_HANDLER* handler : m_handlers )
+ {
+ result = handler->Handle( request );
+
+ if( result.has_value() )
+ break;
+ else if( result.error().status() != ApiStatusCode::AS_UNHANDLED )
+ break;
+ }
+
+ // Note: at the point we call Reply(), we no longer own requestString.
+
+ if( result.has_value() )
+ {
+ result->mutable_header()->set_kicad_token( m_token );
+ m_server->Reply( result->SerializeAsString() );
+ log( "Response: " + result->Utf8DebugString() );
+ }
+ else
+ {
+ ApiResponse error;
+ error.mutable_status()->CopyFrom( result.error() );
+ error.mutable_header()->set_kicad_token( m_token );
+
+ if( result.error().status() == ApiStatusCode::AS_UNHANDLED )
+ {
+ std::string type = "<unparseable Any>";
+ google::protobuf::Any::ParseAnyTypeUrl( request.message().type_url(), &type );
+ std::string msg = fmt::format( "no handler available for request of type {}", type );
+ error.mutable_status()->set_error_message( msg );
+ }
+
+ m_server->Reply( error.SerializeAsString() );
+ log( "Response (ERROR): " + error.Utf8DebugString() );
+ }
+}
+
+
+void KICAD_API_SERVER::log( const std::string& aOutput )
+{
+ if( !ADVANCED_CFG::GetCfg().m_EnableAPILogging )
+ return;
+
+ FILE* fp = wxFopen( m_logFilePath.GetFullPath(), wxT( "a" ) );
+
+ if( !fp )
+ return;
+
+ wxString out;
+ wxDateTime now = wxDateTime::Now();
+
+ fprintf( fp, "%s", TO_UTF8( out.Format( wxS( "%s: %s" ),
+ now.FormatISOCombined(), aOutput ) ) );
+ fclose( fp );
+}
diff --git a/common/dialogs/panel_python_settings.cpp b/common/dialogs/panel_python_settings.cpp
new file mode 100644
index 0000000000..c6e29c4183
--- /dev/null
+++ b/common/dialogs/panel_python_settings.cpp
@@ -0,0 +1,109 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2023 Jon Evans <jon@craftyjon.com>
+ * Copyright (C) 2023 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <dialogs/panel_python_settings.h>
+#include <widgets/ui_common.h>
+#include <pgm_base.h>
+#include <python_manager.h>
+#include <settings/common_settings.h>
+#include <settings/settings_manager.h>
+
+
+PANEL_PYTHON_SETTINGS::PANEL_PYTHON_SETTINGS( wxWindow* aParent ) :
+ PANEL_PYTHON_SETTINGS_BASE( aParent )
+{
+ wxFont helpFont = KIUI::GetInfoFont( this ).Italic();
+ m_stPythonStatus->SetFont( helpFont );
+}
+
+
+void PANEL_PYTHON_SETTINGS::ResetPanel()
+{
+}
+
+
+bool PANEL_PYTHON_SETTINGS::TransferDataToWindow()
+{
+ SETTINGS_MANAGER& mgr = Pgm().GetSettingsManager();
+ COMMON_SETTINGS* settings = mgr.GetCommonSettings();
+
+ m_pickerPythonInterpreter->SetFileName( settings->m_Python.interpreter_path );
+ validateInterpreter();
+
+ return true;
+}
+
+
+bool PANEL_PYTHON_SETTINGS::TransferDataFromWindow()
+{
+ SETTINGS_MANAGER& mgr = Pgm().GetSettingsManager();
+ COMMON_SETTINGS* settings = mgr.GetCommonSettings();
+
+ if( m_interpreterValid )
+ settings->m_Python.interpreter_path = m_pickerPythonInterpreter->GetTextCtrlValue();
+
+ return true;
+}
+
+
+void PANEL_PYTHON_SETTINGS::OnPythonInterpreterChanged( wxFileDirPickerEvent& event )
+{
+ validateInterpreter();
+}
+
+
+void PANEL_PYTHON_SETTINGS::OnBtnDetectAutomaticallyClicked( wxCommandEvent& aEvent )
+{
+}
+
+
+void PANEL_PYTHON_SETTINGS::validateInterpreter()
+{
+ m_interpreterValid = false;
+
+ wxFileName pythonExe( m_pickerPythonInterpreter->GetTextCtrlValue() );
+
+ if( !pythonExe.FileExists() )
+ {
+ m_stPythonStatus->SetLabel( _( "No valid Python interpreter chosen; external Python "
+ "plugins will not be available" ) );
+ return;
+ }
+
+ PYTHON_MANAGER manager( pythonExe.GetFullPath() );
+
+ manager.Execute( wxS( "--version" ),
+ [&]( int aRetCode, const wxString& aStdOut )
+ {
+ wxString msg;
+
+ if( aRetCode == 0 && aStdOut.Contains( wxS( "Python 3" ) ) )
+ {
+ msg = wxString::Format( _( "Found %s" ), aStdOut );
+ m_interpreterValid = true;
+ }
+ else
+ {
+ msg = _( "Not a valid Python 3 interpreter" );
+ }
+
+ m_stPythonStatus->SetLabel( msg );
+ } );
+}
diff --git a/common/dialogs/panel_python_settings_base.cpp b/common/dialogs/panel_python_settings_base.cpp
new file mode 100644
index 0000000000..0027bfde2e
--- /dev/null
+++ b/common/dialogs/panel_python_settings_base.cpp
@@ -0,0 +1,70 @@
+///////////////////////////////////////////////////////////////////////////
+// C++ code generated with wxFormBuilder (version 3.10.1-0-g8feb16b3)
+// http://www.wxformbuilder.org/
+//
+// PLEASE DO *NOT* EDIT THIS FILE!
+///////////////////////////////////////////////////////////////////////////
+
+#include "panel_python_settings_base.h"
+
+///////////////////////////////////////////////////////////////////////////
+
+PANEL_PYTHON_SETTINGS_BASE::PANEL_PYTHON_SETTINGS_BASE( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style, const wxString& name ) : RESETTABLE_PANEL( parent, id, pos, size, style, name )
+{
+ wxBoxSizer* bPanelSizer;
+ bPanelSizer = new wxBoxSizer( wxHORIZONTAL );
+
+ wxBoxSizer* bSizer8;
+ bSizer8 = new wxBoxSizer( wxVERTICAL );
+
+ wxStaticBoxSizer* sbSizer1;
+ sbSizer1 = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Python Interpreter") ), wxVERTICAL );
+
+ wxBoxSizer* bSizer4;
+ bSizer4 = new wxBoxSizer( wxHORIZONTAL );
+
+ m_staticText2 = new wxStaticText( sbSizer1->GetStaticBox(), wxID_ANY, _("Path to Python interpreter:"), wxDefaultPosition, wxDefaultSize, 0 );
+ m_staticText2->Wrap( -1 );
+ bSizer4->Add( m_staticText2, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
+
+ m_pickerPythonInterpreter = new wxFilePickerCtrl( sbSizer1->GetStaticBox(), wxID_ANY, wxEmptyString, _("Select the path to a Python interpreter"), _("*.*"), wxDefaultPosition, wxDefaultSize, wxFLP_DEFAULT_STYLE|wxFLP_USE_TEXTCTRL );
+ bSizer4->Add( m_pickerPythonInterpreter, 1, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
+
+ m_btnDetectAutomatically = new wxButton( sbSizer1->GetStaticBox(), wxID_ANY, _("Detect Automatically"), wxDefaultPosition, wxDefaultSize, 0 );
+ bSizer4->Add( m_btnDetectAutomatically, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
+
+
+ sbSizer1->Add( bSizer4, 0, wxEXPAND, 5 );
+
+ m_stPythonStatus = new wxStaticText( sbSizer1->GetStaticBox(), wxID_ANY, _("No Python interpreter chosen; external Python plugins will not be available"), wxDefaultPosition, wxDefaultSize, 0 );
+ m_stPythonStatus->Wrap( -1 );
+ m_stPythonStatus->SetToolTip( _("Python interpreter status") );
+
+ sbSizer1->Add( m_stPythonStatus, 0, wxALL, 5 );
+
+
+ bSizer8->Add( sbSizer1, 0, wxALL|wxEXPAND, 5 );
+
+
+ bSizer8->Add( 0, 0, 1, wxEXPAND, 5 );
+
+
+ bPanelSizer->Add( bSizer8, 1, wxEXPAND, 5 );
+
+
+ this->SetSizer( bPanelSizer );
+ this->Layout();
+ bPanelSizer->Fit( this );
+
+ // Connect Events
+ m_pickerPythonInterpreter->Connect( wxEVT_COMMAND_FILEPICKER_CHANGED, wxFileDirPickerEventHandler( PANEL_PYTHON_SETTINGS_BASE::OnPythonInterpreterChanged ), NULL, this );
+ m_btnDetectAutomatically->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( PANEL_PYTHON_SETTINGS_BASE::OnBtnDetectAutomaticallyClicked ), NULL, this );
+}
+
+PANEL_PYTHON_SETTINGS_BASE::~PANEL_PYTHON_SETTINGS_BASE()
+{
+ // Disconnect Events
+ m_pickerPythonInterpreter->Disconnect( wxEVT_COMMAND_FILEPICKER_CHANGED, wxFileDirPickerEventHandler( PANEL_PYTHON_SETTINGS_BASE::OnPythonInterpreterChanged ), NULL, this );
+ m_btnDetectAutomatically->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( PANEL_PYTHON_SETTINGS_BASE::OnBtnDetectAutomaticallyClicked ), NULL, this );
+
+}
diff --git a/common/dialogs/panel_python_settings_base.fbp b/common/dialogs/panel_python_settings_base.fbp
new file mode 100644
index 0000000000..c55caeea53
--- /dev/null
+++ b/common/dialogs/panel_python_settings_base.fbp
@@ -0,0 +1,371 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<wxFormBuilder_Project>
+ <FileVersion major="1" minor="16" />
+ <object class="Project" expanded="1">
+ <property name="class_decoration"></property>
+ <property name="code_generation">C++</property>
+ <property name="disconnect_events">1</property>
+ <property name="disconnect_mode">source_name</property>
+ <property name="disconnect_php_events">0</property>
+ <property name="disconnect_python_events">0</property>
+ <property name="embedded_files_path">res</property>
+ <property name="encoding">UTF-8</property>
+ <property name="event_generation">connect</property>
+ <property name="file">panel_python_settings_base</property>
+ <property name="first_id">1000</property>
+ <property name="help_provider">none</property>
+ <property name="image_path_wrapper_function_name"></property>
+ <property name="indent_with_spaces"></property>
+ <property name="internationalize">1</property>
+ <property name="name">PanelPythonSettings</property>
+ <property name="namespace"></property>
+ <property name="path">.</property>
+ <property name="precompiled_header"></property>
+ <property name="relative_path">1</property>
+ <property name="skip_lua_events">1</property>
+ <property name="skip_php_events">1</property>
+ <property name="skip_python_events">1</property>
+ <property name="ui_table">UI</property>
+ <property name="use_array_enum">0</property>
+ <property name="use_enum">1</property>
+ <property name="use_microsoft_bom">0</property>
+ <object class="Panel" expanded="1">
+ <property name="aui_managed">0</property>
+ <property name="aui_manager_style">wxAUI_MGR_DEFAULT</property>
+ <property name="bg"></property>
+ <property name="context_help"></property>
+ <property name="context_menu">1</property>
+ <property name="enabled">1</property>
+ <property name="event_handler">impl_virtual</property>
+ <property name="fg"></property>
+ <property name="font"></property>
+ <property name="hidden">0</property>
+ <property name="id">wxID_ANY</property>
+ <property name="maximum_size"></property>
+ <property name="minimum_size"></property>
+ <property name="name">PANEL_PYTHON_SETTINGS_BASE</property>
+ <property name="pos"></property>
+ <property name="size">-1,-1</property>
+ <property name="subclass">RESETTABLE_PANEL; widgets/resettable_panel.h; Not forward_declare</property>
+ <property name="tooltip"></property>
+ <property name="two_step_creation">0</property>
+ <property name="window_extra_style"></property>
+ <property name="window_name"></property>
+ <property name="window_style">wxTAB_TRAVERSAL</property>
+ <object class="wxBoxSizer" expanded="1">
+ <property name="minimum_size"></property>
+ <property name="name">bPanelSizer</property>
+ <property name="orient">wxHORIZONTAL</property>
+ <property name="permission">none</property>
+ <object class="sizeritem" expanded="1">
+ <property name="border">5</property>
+ <property name="flag">wxEXPAND</property>
+ <property name="proportion">1</property>
+ <object class="wxBoxSizer" expanded="1">
+ <property name="minimum_size"></property>
+ <property name="name">bSizer8</property>
+ <property name="orient">wxVERTICAL</property>
+ <property name="permission">none</property>
+ <object class="sizeritem" expanded="1">
+ <property name="border">5</property>
+ <property name="flag">wxALL|wxEXPAND</property>
+ <property name="proportion">0</property>
+ <object class="wxStaticBoxSizer" expanded="1">
+ <property name="id">wxID_ANY</property>
+ <property name="label">Python Interpreter</property>
+ <property name="minimum_size"></property>
+ <property name="name">sbSizer1</property>
+ <property name="orient">wxVERTICAL</property>
+ <property name="parent">1</property>
+ <property name="permission">none</property>
+ <object class="sizeritem" expanded="1">
+ <property name="border">5</property>
+ <property name="flag">wxEXPAND</property>
+ <property name="proportion">0</property>
+ <object class="wxBoxSizer" expanded="1">
+ <property name="minimum_size"></property>
+ <property name="name">bSizer4</property>
+ <property name="orient">wxHORIZONTAL</property>
+ <property name="permission">none</property>
+ <object class="sizeritem" expanded="1">
+ <property name="border">5</property>
+ <property name="flag">wxALIGN_CENTER_VERTICAL|wxALL</property>
+ <property name="proportion">0</property>
+ <object class="wxStaticText" expanded="1">
+ <property name="BottomDockable">1</property>
+ <property name="LeftDockable">1</property>
+ <property name="RightDockable">1</property>
+ <property name="TopDockable">1</property>
+ <property name="aui_layer"></property>
+ <property name="aui_name"></property>
+ <property name="aui_position"></property>
+ <property name="aui_row"></property>
+ <property name="best_size"></property>
+ <property name="bg"></property>
+ <property name="caption"></property>
+ <property name="caption_visible">1</property>
+ <property name="center_pane">0</property>
+ <property name="close_button">1</property>
+ <property name="context_help"></property>
+ <property name="context_menu">1</property>
+ <property name="default_pane">0</property>
+ <property name="dock">Dock</property>
+ <property name="dock_fixed">0</property>
+ <property name="docking">Left</property>
+ <property name="enabled">1</property>
+ <property name="fg"></property>
+ <property name="floatable">1</property>
+ <property name="font"></property>
+ <property name="gripper">0</property>
+ <property name="hidden">0</property>
+ <property name="id">wxID_ANY</property>
+ <property name="label">Path to Python interpreter:</property>
+ <property name="markup">0</property>
+ <property name="max_size"></property>
+ <property name="maximize_button">0</property>
+ <property name="maximum_size"></property>
+ <property name="min_size"></property>
+ <property name="minimize_button">0</property>
+ <property name="minimum_size"></property>
+ <property name="moveable">1</property>
+ <property name="name">m_staticText2</property>
+ <property name="pane_border">1</property>
+ <property name="pane_position"></property>
+ <property name="pane_size"></property>
+ <property name="permission">protected</property>
+ <property name="pin_button">1</property>
+ <property name="pos"></property>
+ <property name="resize">Resizable</property>
+ <property name="show">1</property>
+ <property name="size"></property>
+ <property name="style"></property>
+ <property name="subclass">; ; forward_declare</property>
+ <property name="toolbar_pane">0</property>
+ <property name="tooltip"></property>
+ <property name="window_extra_style"></property>
+ <property name="window_name"></property>
+ <property name="window_style"></property>
+ <property name="wrap">-1</property>
+ </object>
+ </object>
+ <object class="sizeritem" expanded="1">
+ <property name="border">5</property>
+ <property name="flag">wxALIGN_CENTER_VERTICAL|wxALL</property>
+ <property name="proportion">1</property>
+ <object class="wxFilePickerCtrl" expanded="1">
+ <property name="BottomDockable">1</property>
+ <property name="LeftDockable">1</property>
+ <property name="RightDockable">1</property>
+ <property name="TopDockable">1</property>
+ <property name="aui_layer"></property>
+ <property name="aui_name"></property>
+ <property name="aui_position"></property>
+ <property name="aui_row"></property>
+ <property name="best_size"></property>
+ <property name="bg"></property>
+ <property name="caption"></property>
+ <property name="caption_visible">1</property>
+ <property name="center_pane">0</property>
+ <property name="close_button">1</property>
+ <property name="context_help"></property>
+ <property name="context_menu">1</property>
+ <property name="default_pane">0</property>
+ <property name="dock">Dock</property>
+ <property name="dock_fixed">0</property>
+ <property name="docking">Left</property>
+ <property name="enabled">1</property>
+ <property name="fg"></property>
+ <property name="floatable">1</property>
+ <property name="font"></property>
+ <property name="gripper">0</property>
+ <property name="hidden">0</property>
+ <property name="id">wxID_ANY</property>
+ <property name="max_size"></property>
+ <property name="maximize_button">0</property>
+ <property name="maximum_size"></property>
+ <property name="message">Select the path to a Python interpreter</property>
+ <property name="min_size"></property>
+ <property name="minimize_button">0</property>
+ <property name="minimum_size"></property>
+ <property name="moveable">1</property>
+ <property name="name">m_pickerPythonInterpreter</property>
+ <property name="pane_border">1</property>
+ <property name="pane_position"></property>
+ <property name="pane_size"></property>
+ <property name="permission">protected</property>
+ <property name="pin_button">1</property>
+ <property name="pos"></property>
+ <property name="resize">Resizable</property>
+ <property name="show">1</property>
+ <property name="size"></property>
+ <property name="style">wxFLP_DEFAULT_STYLE|wxFLP_USE_TEXTCTRL</property>
+ <property name="subclass">; ; forward_declare</property>
+ <property name="toolbar_pane">0</property>
+ <property name="tooltip"></property>
+ <property name="validator_data_type"></property>
+ <property name="validator_style">wxFILTER_NONE</property>
+ <property name="validator_type">wxDefaultValidator</property>
+ <property name="validator_variable"></property>
+ <property name="value"></property>
+ <property name="wildcard">*.*</property>
+ <property name="window_extra_style"></property>
+ <property name="window_name"></property>
+ <property name="window_style"></property>
+ <event name="OnFileChanged">OnPythonInterpreterChanged</event>
+ </object>
+ </object>
+ <object class="sizeritem" expanded="1">
+ <property name="border">5</property>
+ <property name="flag">wxALIGN_CENTER_VERTICAL|wxALL</property>
+ <property name="proportion">0</property>
+ <object class="wxButton" expanded="1">
+ <property name="BottomDockable">1</property>
+ <property name="LeftDockable">1</property>
+ <property name="RightDockable">1</property>
+ <property name="TopDockable">1</property>
+ <property name="aui_layer"></property>
+ <property name="aui_name"></property>
+ <property name="aui_position"></property>
+ <property name="aui_row"></property>
+ <property name="auth_needed">0</property>
+ <property name="best_size"></property>
+ <property name="bg"></property>
+ <property name="bitmap"></property>
+ <property name="caption"></property>
+ <property name="caption_visible">1</property>
+ <property name="center_pane">0</property>
+ <property name="close_button">1</property>
+ <property name="context_help"></property>
+ <property name="context_menu">1</property>
+ <property name="current"></property>
+ <property name="default">0</property>
+ <property name="default_pane">0</property>
+ <property name="disabled"></property>
+ <property name="dock">Dock</property>
+ <property name="dock_fixed">0</property>
+ <property name="docking">Left</property>
+ <property name="enabled">1</property>
+ <property name="fg"></property>
+ <property name="floatable">1</property>
+ <property name="focus"></property>
+ <property name="font"></property>
+ <property name="gripper">0</property>
+ <property name="hidden">0</property>
+ <property name="id">wxID_ANY</property>
+ <property name="label">Detect Automatically</property>
+ <property name="margins"></property>
+ <property name="markup">0</property>
+ <property name="max_size"></property>
+ <property name="maximize_button">0</property>
+ <property name="maximum_size"></property>
+ <property name="min_size"></property>
+ <property name="minimize_button">0</property>
+ <property name="minimum_size"></property>
+ <property name="moveable">1</property>
+ <property name="name">m_btnDetectAutomatically</property>
+ <property name="pane_border">1</property>
+ <property name="pane_position"></property>
+ <property name="pane_size"></property>
+ <property name="permission">protected</property>
+ <property name="pin_button">1</property>
+ <property name="pos"></property>
+ <property name="position"></property>
+ <property name="pressed"></property>
+ <property name="resize">Resizable</property>
+ <property name="show">1</property>
+ <property name="size"></property>
+ <property name="style"></property>
+ <property name="subclass">; ; forward_declare</property>
+ <property name="toolbar_pane">0</property>
+ <property name="tooltip"></property>
+ <property name="validator_data_type"></property>
+ <property name="validator_style">wxFILTER_NONE</property>
+ <property name="validator_type">wxDefaultValidator</property>
+ <property name="validator_variable"></property>
+ <property name="window_extra_style"></property>
+ <property name="window_name"></property>
+ <property name="window_style"></property>
+ <event name="OnButtonClick">OnBtnDetectAutomaticallyClicked</event>
+ </object>
+ </object>
+ </object>
+ </object>
+ <object class="sizeritem" expanded="1">
+ <property name="border">5</property>
+ <property name="flag">wxALL</property>
+ <property name="proportion">0</property>
+ <object class="wxStaticText" expanded="1">
+ <property name="BottomDockable">1</property>
+ <property name="LeftDockable">1</property>
+ <property name="RightDockable">1</property>
+ <property name="TopDockable">1</property>
+ <property name="aui_layer"></property>
+ <property name="aui_name"></property>
+ <property name="aui_position"></property>
+ <property name="aui_row"></property>
+ <property name="best_size"></property>
+ <property name="bg"></property>
+ <property name="caption"></property>
+ <property name="caption_visible">1</property>
+ <property name="center_pane">0</property>
+ <property name="close_button">1</property>
+ <property name="context_help"></property>
+ <property name="context_menu">1</property>
+ <property name="default_pane">0</property>
+ <property name="dock">Dock</property>
+ <property name="dock_fixed">0</property>
+ <property name="docking">Left</property>
+ <property name="enabled">1</property>
+ <property name="fg"></property>
+ <property name="floatable">1</property>
+ <property name="font"></property>
+ <property name="gripper">0</property>
+ <property name="hidden">0</property>
+ <property name="id">wxID_ANY</property>
+ <property name="label">No Python interpreter chosen; external Python plugins will not be available</property>
+ <property name="markup">0</property>
+ <property name="max_size"></property>
+ <property name="maximize_button">0</property>
+ <property name="maximum_size"></property>
+ <property name="min_size"></property>
+ <property name="minimize_button">0</property>
+ <property name="minimum_size"></property>
+ <property name="moveable">1</property>
+ <property name="name">m_stPythonStatus</property>
+ <property name="pane_border">1</property>
+ <property name="pane_position"></property>
+ <property name="pane_size"></property>
+ <property name="permission">public</property>
+ <property name="pin_button">1</property>
+ <property name="pos"></property>
+ <property name="resize">Resizable</property>
+ <property name="show">1</property>
+ <property name="size"></property>
+ <property name="style"></property>
+ <property name="subclass">; ; forward_declare</property>
+ <property name="toolbar_pane">0</property>
+ <property name="tooltip">Python interpreter status</property>
+ <property name="window_extra_style"></property>
+ <property name="window_name"></property>
+ <property name="window_style"></property>
+ <property name="wrap">-1</property>
+ </object>
+ </object>
+ </object>
+ </object>
+ <object class="sizeritem" expanded="1">
+ <property name="border">5</property>
+ <property name="flag">wxEXPAND</property>
+ <property name="proportion">1</property>
+ <object class="spacer" expanded="1">
+ <property name="height">0</property>
+ <property name="permission">protected</property>
+ <property name="width">0</property>
+ </object>
+ </object>
+ </object>
+ </object>
+ </object>
+ </object>
+ </object>
+</wxFormBuilder_Project>
diff --git a/common/dialogs/panel_python_settings_base.h b/common/dialogs/panel_python_settings_base.h
new file mode 100644
index 0000000000..05f13508d5
--- /dev/null
+++ b/common/dialogs/panel_python_settings_base.h
@@ -0,0 +1,56 @@
+///////////////////////////////////////////////////////////////////////////
+// C++ code generated with wxFormBuilder (version 3.10.1-0-g8feb16b3)
+// http://www.wxformbuilder.org/
+//
+// PLEASE DO *NOT* EDIT THIS FILE!
+///////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include <wx/artprov.h>
+#include <wx/xrc/xmlres.h>
+#include <wx/intl.h>
+#include "widgets/resettable_panel.h"
+#include <wx/string.h>
+#include <wx/stattext.h>
+#include <wx/gdicmn.h>
+#include <wx/font.h>
+#include <wx/colour.h>
+#include <wx/settings.h>
+#include <wx/filepicker.h>
+#include <wx/button.h>
+#include <wx/bitmap.h>
+#include <wx/image.h>
+#include <wx/icon.h>
+#include <wx/sizer.h>
+#include <wx/statbox.h>
+#include <wx/panel.h>
+
+///////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+/// Class PANEL_PYTHON_SETTINGS_BASE
+///////////////////////////////////////////////////////////////////////////////
+class PANEL_PYTHON_SETTINGS_BASE : public RESETTABLE_PANEL
+{
+ private:
+
+ protected:
+ wxStaticText* m_staticText2;
+ wxFilePickerCtrl* m_pickerPythonInterpreter;
+ wxButton* m_btnDetectAutomatically;
+
+ // Virtual event handlers, override them in your derived class
+ virtual void OnPythonInterpreterChanged( wxFileDirPickerEvent& event ) { event.Skip(); }
+ virtual void OnBtnDetectAutomaticallyClicked( wxCommandEvent& event ) { event.Skip(); }
+
+
+ public:
+ wxStaticText* m_stPythonStatus;
+
+ PANEL_PYTHON_SETTINGS_BASE( wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize( -1,-1 ), long style = wxTAB_TRAVERSAL, const wxString& name = wxEmptyString );
+
+ ~PANEL_PYTHON_SETTINGS_BASE();
+
+};
+
diff --git a/common/eda_base_frame.cpp b/common/eda_base_frame.cpp
index 868a5234df..4333c77f48 100644
--- a/common/eda_base_frame.cpp
+++ b/common/eda_base_frame.cpp
@@ -32,6 +32,7 @@
#include <dialogs/panel_common_settings.h>
#include <dialogs/panel_mouse_settings.h>
#include <dialogs/panel_data_collection.h>
+#include <dialogs/panel_python_settings.h>
#include <eda_dde.h>
#include <file_history.h>
#include <id.h>
@@ -1235,6 +1236,10 @@ void EDA_BASE_FRAME::ShowPreferences( wxString aStartPage, wxString aStartParent
{
}
+#ifdef KICAD_IPC_API
+ book->AddPage( new PANEL_PYTHON_SETTINGS( book ), _( "Python Scripting" ) );
+#endif
+
// Update all of the action hotkeys. The process of loading the actions through
// the KiFACE will only get us the default hotkeys
ReadHotKeyConfigIntoActions( wxEmptyString, hotkeysPanel->ActionsList() );
diff --git a/common/kiid.cpp b/common/kiid.cpp
index 4c7e8eb18c..ae10e316e9 100644
--- a/common/kiid.cpp
+++ b/common/kiid.cpp
@@ -260,6 +260,12 @@ wxString KIID::AsString() const
}
+std::string KIID::AsStdString() const
+{
+ return boost::uuids::to_string( m_uuid );
+}
+
+
wxString KIID::AsLegacyTimestampString() const
{
return wxString::Format( "%8.8lX", (unsigned long) AsLegacyTimestamp() );
diff --git a/common/paths.cpp b/common/paths.cpp
index 48b698f7b9..992f1c3fb7 100644
--- a/common/paths.cpp
+++ b/common/paths.cpp
@@ -399,6 +399,17 @@ wxString PATHS::GetInstanceCheckerPath()
}
+wxString PATHS::GetLogsPath()
+{
+ wxFileName tmp;
+ getUserDocumentPath( tmp );
+
+ tmp.AppendDir( wxT( "logs" ) );
+
+ return tmp.GetPath();
+}
+
+
bool PATHS::EnsurePathExists( const wxString& aPath )
{
wxFileName path( aPath );
diff --git a/common/pgm_base.cpp b/common/pgm_base.cpp
index 6771980c67..317c60f8d0 100644
--- a/common/pgm_base.cpp
+++ b/common/pgm_base.cpp
@@ -74,6 +74,10 @@
#include <build_version.h>
#endif
+#ifdef KICAD_IPC_API
+#include <api/api_server.h>
+#endif
+
/**
* Current list of languages supported by KiCad.
*
diff --git a/common/settings/common_settings.cpp b/common/settings/common_settings.cpp
index c10d0578e4..7ff028d306 100644
--- a/common/settings/common_settings.cpp
+++ b/common/settings/common_settings.cpp
@@ -53,7 +53,8 @@ COMMON_SETTINGS::COMMON_SETTINGS() :
m_System(),
m_DoNotShowAgain(),
m_NetclassPanel(),
- m_PackageManager()
+ m_PackageManager(),
+ m_Python()
{
/*
* Automatic dark mode detection works fine on Mac.
@@ -397,7 +398,8 @@ COMMON_SETTINGS::COMMON_SETTINGS() :
m_params.emplace_back( new PARAM<bool>( "git.useDefaultAuthor",
&m_Git.useDefaultAuthor, true ) );
-
+ m_params.emplace_back( new PARAM<wxString>( "python.interpreter_path",
+ &m_Python.interpreter_path, wxS( "" ) ) );
registerMigration( 0, 1, std::bind( &COMMON_SETTINGS::migrateSchema0to1, this ) );
registerMigration( 1, 2, std::bind( &COMMON_SETTINGS::migrateSchema1to2, this ) );
diff --git a/common/single_top.cpp b/common/single_top.cpp
index 4c85457d98..186b454207 100644
--- a/common/single_top.cpp
+++ b/common/single_top.cpp
@@ -58,6 +58,10 @@
#include <sentry.h>
#endif
+#ifdef KICAD_IPC_API
+#include <api/api_server.h>
+#endif
+
// Only a single KIWAY is supported in this single_top top level component,
// which is dedicated to loading only a single DSO.
KIWAY Kiway( KFCTL_STANDALONE );
@@ -78,6 +82,10 @@ static struct PGM_SINGLE_TOP : public PGM_BASE
Kiway.OnKiwayEnd();
+#ifdef KICAD_IPC_API
+ m_api_server.reset();
+#endif
+
if( m_settings_manager && m_settings_manager->IsOK() )
{
SaveCommonSettings();
@@ -350,6 +358,11 @@ bool PGM_SINGLE_TOP::OnPgmInit()
GetSettingsManager().RegisterSettings( new KICAD_SETTINGS );
+#ifdef KICAD_IPC_API
+ // Create the API server thread once the app event loop exists
+ m_api_server = std::make_unique<KICAD_API_SERVER>();
+#endif
+
// Use KIWAY to create a top window, which registers its existence also.
// "TOP_FRAME" is a macro that is passed on compiler command line from CMake,
// and is one of the types in FRAME_T.
@@ -424,5 +437,9 @@ bool PGM_SINGLE_TOP::OnPgmInit()
frame->OpenProjectFiles( fileArgs );
}
+#ifdef KICAD_IPC_API
+ m_api_server->SetReadyToReply();
+#endif
+
return true;
}
diff --git a/common/tool/tool_manager.cpp b/common/tool/tool_manager.cpp
index 97af5480a8..725184b054 100644
--- a/common/tool/tool_manager.cpp
+++ b/common/tool/tool_manager.cpp
@@ -302,7 +302,7 @@ bool TOOL_MANAGER::doRunAction( const std::string& aActionName, bool aNow, const
doRunAction( *action, aNow, aParam, aCommit );
- return false;
+ return true;
}
diff --git a/eeschema/sch_marker.cpp b/eeschema/sch_marker.cpp
index 47f21c1a2f..e5cbe4925e 100644
--- a/eeschema/sch_marker.cpp
+++ b/eeschema/sch_marker.cpp
@@ -88,7 +88,7 @@ void SCH_MARKER::SwapData( SCH_ITEM* aItem )
}
-wxString SCH_MARKER::Serialize() const
+wxString SCH_MARKER::SerializeToString() const
{
std::shared_ptr<ERC_ITEM> erc = std::static_pointer_cast<ERC_ITEM>( m_rcItem );
wxString sheetSpecificPath, mainItemPath, auxItemPath;
@@ -109,7 +109,7 @@ wxString SCH_MARKER::Serialize() const
}
-SCH_MARKER* SCH_MARKER::Deserialize( SCHEMATIC* schematic, const wxString& data )
+SCH_MARKER* SCH_MARKER::DeserializeFromString( SCHEMATIC* schematic, const wxString& data )
{
wxArrayString props = wxSplit( data, '|' );
VECTOR2I markerPos( (int) strtol( props[1].c_str(), nullptr, 10 ),
diff --git a/eeschema/sch_marker.h b/eeschema/sch_marker.h
index db1f42f3c2..be6856d0d3 100644
--- a/eeschema/sch_marker.h
+++ b/eeschema/sch_marker.h
@@ -53,8 +53,8 @@ public:
void SwapData( SCH_ITEM* aItem ) override;
- wxString Serialize() const;
- static SCH_MARKER* Deserialize( SCHEMATIC* schematic, const wxString& data );
+ wxString SerializeToString() const;
+ static SCH_MARKER* DeserializeFromString( SCHEMATIC* schematic, const wxString& data );
void ViewGetLayers( int aLayers[], int& aCount ) const override;
diff --git a/eeschema/schematic.cpp b/eeschema/schematic.cpp
index e7e4e1ced0..238518373e 100644
--- a/eeschema/schematic.cpp
+++ b/eeschema/schematic.cpp
@@ -312,7 +312,7 @@ std::vector<SCH_MARKER*> SCHEMATIC::ResolveERCExclusions()
for( auto it = settings.m_ErcExclusions.begin(); it != settings.m_ErcExclusions.end(); )
{
- SCH_MARKER* testMarker = SCH_MARKER::Deserialize( this, *it );
+ SCH_MARKER* testMarker = SCH_MARKER::DeserializeFromString( this, *it );
if( testMarker->IsLegacyMarker() )
{
@@ -322,7 +322,7 @@ std::vector<SCH_MARKER*> SCHEMATIC::ResolveERCExclusions()
&& settingsKey != wxT( "hier_label_mismatch" )
&& settingsKey != wxT( "different_unit_net" ) )
{
- migratedExclusions.insert( testMarker->Serialize() );
+ migratedExclusions.insert( testMarker->SerializeToString() );
}
it = settings.m_ErcExclusions.erase( it );
@@ -344,7 +344,7 @@ std::vector<SCH_MARKER*> SCHEMATIC::ResolveERCExclusions()
for( SCH_ITEM* item : sheet.LastScreen()->Items().OfType( SCH_MARKER_T ) )
{
SCH_MARKER* marker = static_cast<SCH_MARKER*>( item );
- wxString serialized = marker->Serialize();
+ wxString serialized = marker->SerializeToString();
std::set<wxString>::iterator it = settings.m_ErcExclusions.find( serialized );
if( it != settings.m_ErcExclusions.end() )
@@ -359,7 +359,7 @@ std::vector<SCH_MARKER*> SCHEMATIC::ResolveERCExclusions()
for( const wxString& serialized : settings.m_ErcExclusions )
{
- SCH_MARKER* marker = SCH_MARKER::Deserialize( this, serialized );
+ SCH_MARKER* marker = SCH_MARKER::DeserializeFromString( this, serialized );
if( marker )
{
@@ -811,7 +811,7 @@ void SCHEMATIC::RecordERCExclusions()
if( marker->IsExcluded() )
{
- wxString serialized = marker->Serialize();
+ wxString serialized = marker->SerializeToString();
ercSettings.m_ErcExclusions.insert( serialized );
ercSettings.m_ErcExclusionComments[ serialized ] = marker->GetComment();
}
diff --git a/include/advanced_config.h b/include/advanced_config.h
index f20f2df7c6..bb7d05a4e4 100644
--- a/include/advanced_config.h
+++ b/include/advanced_config.h
@@ -576,8 +576,11 @@ public:
*/
bool m_EnableCacheFriendlyFracture;
- ///@}
-
+ /**
+ * Log IPC API requests and responses
+ */
+ bool m_EnableAPILogging;
+///@}
private:
ADVANCED_CFG();
diff --git a/include/api/api_handler.h b/include/api/api_handler.h
new file mode 100644
index 0000000000..1dc76ad79a
--- /dev/null
+++ b/include/api/api_handler.h
@@ -0,0 +1,137 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2023 Jon Evans <jon@craftyjon.com>
+ * Copyright (C) 2023 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef KICAD_API_HANDLER_H
+#define KICAD_API_HANDLER_H
+
+#include <functional>
+#include <optional>
+
+#include <fmt/format.h>
+#include <tl/expected.hpp>
+
+#include <wx/debug.h>
+#include <wx/string.h>
+
+#include <google/protobuf/message.h>
+
+#include <import_export.h>
+#include <api/common/envelope.pb.h>
+#include <core/typeinfo.h>
+
+using kiapi::common::ApiRequest, kiapi::common::ApiResponse;
+using kiapi::common::ApiResponseStatus, kiapi::common::ApiStatusCode;
+
+typedef tl::expected<ApiResponse, ApiResponseStatus> API_RESULT;
+
+template <typename T>
+using HANDLER_RESULT = tl::expected<T, ApiResponseStatus>;
+
+class API_HANDLER
+{
+public:
+ API_HANDLER() {}
+
+ /**
+ * Attempt to handle the given API request, if a handler exists in this class for the message.
+ * @param aMsg is a request to attempt to handle
+ * @return a response to send to the client, or an appropriate error
+ */
+ API_RESULT Handle( ApiRequest& aMsg );
+
+ static std::optional<KICAD_T> TypeNameFromAny( const google::protobuf::Any& aMessage );
+
+protected:
+
+ /**
+ * A handler for outer messages (envelopes) that will unpack to inner messages and call a
+ * specific handler function. @see registerHandler.
+ */
+ typedef std::function<HANDLER_RESULT<ApiResponse>( ApiRequest& )> REQUEST_HANDLER;
+
+ /**
+ * Registers an API command handler for the given message types.
+ *
+ * When an API request matching the given type comes in, the handler will be called and its
+ * response will be packed into an envelope for sending back to the API client.
+ *
+ * If the given message does not unpack into the request type, an envelope is returned with
+ * status AS_BAD_REQUEST, which probably indicates corruption in the message.
+ *
+ * @tparam RequestType is a protobuf message type containing a command
+ * @tparam ResponseType is a protobuf message type containing a command response
+ * @tparam HandlerType is the implied type of the API_HANDLER subclass
+ * @param aHandler is the handler function for the given request and response types
+ */
+ template <class RequestType, class ResponseType, class HandlerType>
+ void registerHandler( HANDLER_RESULT<ResponseType>( HandlerType::* aHandler )( RequestType& ) )
+ {
+ std::string typeName = RequestType().GetTypeName();
+
+ wxASSERT_MSG( !m_handlers.count( typeName ),
+ wxString::Format( "Duplicate API handler for type %s", typeName ) );
+
+ m_handlers[typeName] =
+ [=]( ApiRequest& aRequest ) -> API_RESULT
+ {
+ RequestType command;
+ ApiResponse envelope;
+
+ if( !tryUnpack( aRequest, envelope, command ) )
+ return envelope;
+
+ HANDLER_RESULT<ResponseType> response =
+ std::invoke( aHandler, static_cast<HandlerType*>( this ), command );
+
+ if( response.has_value() )
+ {
+ envelope.mutable_status()->set_status( ApiStatusCode::AS_OK );
+ envelope.mutable_message()->PackFrom( *response );
+ return envelope;
+ }
+ else
+ {
+ return tl::unexpected( response.error() );
+ }
+ };
+ }
+
+ /// Maps type name (without the URL prefix) to a handler method
+ std::map<std::string, REQUEST_HANDLER> m_handlers;
+
+private:
+
+ template<typename MessageType>
+ bool tryUnpack( ApiRequest& aRequest, ApiResponse& aReply, MessageType& aDest )
+ {
+ if( !aRequest.message().UnpackTo( &aDest ) )
+ {
+ std::string msg = fmt::format( "could not unpack message of type {} from request",
+ aDest.GetTypeName() );
+ aReply.mutable_status()->set_status( ApiStatusCode::AS_BAD_REQUEST );
+ aReply.mutable_status()->set_error_message( msg );
+ return false;
+ }
+
+ return true;
+ }
+};
+
+#endif //KICAD_API_HANDLER_H
diff --git a/include/api/api_handler_common.h b/include/api/api_handler_common.h
new file mode 100644
index 0000000000..c950d4c535
--- /dev/null
+++ b/include/api/api_handler_common.h
@@ -0,0 +1,42 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2023 Jon Evans <jon@craftyjon.com>
+ * Copyright (C) 2023 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef KICAD_API_HANDLER_COMMON_H
+#define KICAD_API_HANDLER_COMMON_H
+
+#include <api/api_handler.h>
+#include <api/common/commands/base_commands.pb.h>
+#include <api/common/commands/editor_commands.pb.h>
+
+#include <google/protobuf/empty.pb.h>
+
+using namespace kiapi;
+using namespace kiapi::common;
+
+class API_HANDLER_COMMON : public API_HANDLER
+{
+public:
+ API_HANDLER_COMMON();
+
+private:
+ HANDLER_RESULT<commands::GetVersionResponse> handleGetVersion( commands::GetVersion& aMsg );
+};
+
+#endif //KICAD_API_HANDLER_COMMON_H
diff --git a/include/api/api_server.h b/include/api/api_server.h
new file mode 100644
index 0000000000..0d5e7f9b3a
--- /dev/null
+++ b/include/api/api_server.h
@@ -0,0 +1,97 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2023 Jon Evans <jon@craftyjon.com>
+ * Copyright (C) 2023 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef KICAD_API_SERVER_H
+#define KICAD_API_SERVER_H
+
+#include <memory>
+#include <set>
+#include <string>
+
+#include <wx/event.h>
+#include <wx/filename.h>
+
+class API_HANDLER;
+class API_HANDLER_COMMON;
+class KINNG_REQUEST_SERVER;
+class wxEvtHandler;
+
+
+wxDECLARE_EVENT( API_REQUEST_EVENT, wxCommandEvent );
+
+
+class KICAD_API_SERVER : public wxEvtHandler
+{
+public:
+ KICAD_API_SERVER();
+
+ ~KICAD_API_SERVER();
+
+ /**
+ * Adds a new request handler to the server. Each handler maintains its own list of API
+ * messages that it knows how to handle, and the server will pass every incoming message to all
+ * handlers in succession until one of them handles it.
+ *
+ * The caller is responsible for the lifetime of the handler and must call DeregisterHandler
+ * before the pointer is freed.
+ *
+ * @param aHandler is a pointer (non-owned) to API_HANDLER
+ */
+ void RegisterHandler( API_HANDLER* aHandler );
+
+ void DeregisterHandler( API_HANDLER* aHandler );
+
+ void SetReadyToReply( bool aReady = true ) { m_readyToReply = aReady; }
+
+private:
+
+ /**
+ * Callback that executes on the server thread and generates an event that will be handled by
+ * the wxWidgets event loop to process an incoming request. Temporarily takes ownership of the
+ * request pointer so that it can be passed through the event system.
+ *
+ * @param aRequest is a pointer to a string containing bytes that came in over the wire
+ */
+ void onApiRequest( std::string* aRequest );
+
+ /**
+ * Event handler that receives the event on the main thread sent by onApiRequest
+ * @param aEvent will contain a pointer to an incoming API request string in the client data
+ */
+ void handleApiEvent( wxCommandEvent& aEvent );
+
+ void log( const std::string& aOutput );
+
+ std::unique_ptr<KINNG_REQUEST_SERVER> m_server;
+
+ std::set<API_HANDLER*> m_handlers;
+
+ std::string m_token;
+
+ bool m_readyToReply;
+
+ std::unique_ptr<API_HANDLER_COMMON> m_commonHandler;
+
+ static wxString s_logFileName;
+
+ wxFileName m_logFilePath;
+};
+
+#endif //KICAD_API_SERVER_H
diff --git a/include/dialogs/panel_python_settings.h b/include/dialogs/panel_python_settings.h
new file mode 100644
index 0000000000..3750b3bb7d
--- /dev/null
+++ b/include/dialogs/panel_python_settings.h
@@ -0,0 +1,49 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2023 Jon Evans <jon@craftyjon.com>
+ * Copyright (C) 2023 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef KICAD_PANEL_PYTHON_SETTINGS_H
+#define KICAD_PANEL_PYTHON_SETTINGS_H
+
+#include <dialogs/panel_python_settings_base.h>
+
+class PAGED_DIALOG;
+
+
+class PANEL_PYTHON_SETTINGS : public PANEL_PYTHON_SETTINGS_BASE
+{
+public:
+ PANEL_PYTHON_SETTINGS( wxWindow* aParent );
+
+ void ResetPanel() override;
+
+protected:
+ bool TransferDataFromWindow() override;
+ bool TransferDataToWindow() override;
+
+ void OnPythonInterpreterChanged( wxFileDirPickerEvent& event ) override;
+ void OnBtnDetectAutomaticallyClicked( wxCommandEvent& aEvent ) override;
+
+private:
+ void validateInterpreter();
+
+ bool m_interpreterValid;
+};
+
+#endif //KICAD_PANEL_PYTHON_SETTINGS_H
diff --git a/include/eda_item.h b/include/eda_item.h
index 26ba280c83..89ff04b830 100644
--- a/include/eda_item.h
+++ b/include/eda_item.h
@@ -52,6 +52,8 @@ class UNITS_PROVIDER;
class EDA_DRAW_FRAME;
class MSG_PANEL_ITEM;
+namespace google { namespace protobuf { class Any; } }
+
/**
* Used to inspect and possibly collect the (search) results of iterating over a list or
@@ -436,6 +438,10 @@ public:
virtual void ViewGetLayers( int aLayers[], int& aCount ) const override;
+ virtual void Serialize( google::protobuf::Any &aContainer ) const {}
+
+ virtual bool Deserialize( const google::protobuf::Any &aContainer ) { return false; }
+
#if defined(DEBUG)
/**
diff --git a/include/kiid.h b/include/kiid.h
index 896d0e2031..b5bfe2c0fc 100644
--- a/include/kiid.h
+++ b/include/kiid.h
@@ -64,6 +64,7 @@ public:
wxString AsString() const;
wxString AsLegacyTimestampString() const;
+ std::string AsStdString() const;
/**
* Returns true if a string has the correct formatting to be a KIID.
diff --git a/include/layer_ids.h b/include/layer_ids.h
index b72c0c503f..1d5ec5cbea 100644
--- a/include/layer_ids.h
+++ b/include/layer_ids.h
@@ -61,8 +61,7 @@ enum PCB_LAYER_ID: int
UNDEFINED_LAYER = -1,
UNSELECTED_LAYER = -2,
- PCBNEW_LAYER_ID_START = 0,
- F_Cu = PCBNEW_LAYER_ID_START,
+ F_Cu = 0,
In1_Cu,
In2_Cu,
In3_Cu,
@@ -138,6 +137,8 @@ enum PCB_LAYER_ID: int
PCB_LAYER_ID_COUNT
};
+constexpr PCB_LAYER_ID PCBNEW_LAYER_ID_START = F_Cu;
+
#define MAX_CU_LAYERS (B_Cu - F_Cu + 1)
/**
diff --git a/include/paths.h b/include/paths.h
index 05d12707b1..e4571a52bb 100644
--- a/include/paths.h
+++ b/include/paths.h
@@ -153,6 +153,11 @@ public:
*/
static wxString GetInstanceCheckerPath();
+ /**
+ * Gets a path to use for user-visible log files
+ */
+ static wxString GetLogsPath();
+
/**
* Attempts to create a given path if it does not exist
*/
diff --git a/include/pgm_base.h b/include/pgm_base.h
index 22acf09112..63b449eaa9 100644
--- a/include/pgm_base.h
+++ b/include/pgm_base.h
@@ -52,6 +52,10 @@ class COMMON_SETTINGS;
class SETTINGS_MANAGER;
class SCRIPTING;
+#ifdef KICAD_IPC_API
+class KICAD_API_SERVER;
+#endif
+
/**
* A small class to handle the list of existing translations.
*
@@ -142,6 +146,10 @@ public:
virtual NOTIFICATIONS_MANAGER& GetNotificationsManager() const { return *m_notifications_manager; }
+#ifdef KICAD_IPC_API
+ KICAD_API_SERVER& GetApiServer() { return *m_api_server; }
+#endif
+
virtual void SetTextEditor( const wxString& aFileName );
/**
@@ -403,6 +411,9 @@ protected:
/// Checks if there is another copy of Kicad running at the same time
std::unique_ptr<wxSingleInstanceChecker> m_pgm_checker;
+#ifdef KICAD_IPC_API
+ std::unique_ptr<KICAD_API_SERVER> m_api_server;
+#endif
wxString m_kicad_env; /// The KICAD system environment variable.
diff --git a/include/properties/property.h b/include/properties/property.h
index deedd02850..68ac01b88c 100644
--- a/include/properties/property.h
+++ b/include/properties/property.h
@@ -37,6 +37,10 @@
#include <wx/validate.h> // required for propgrid
#include <wx/propgrid/property.h>
+#ifdef DEBUG
+#include <wx/wxcrt.h>
+#endif
+
#include <functional>
#include <unordered_map>
#include <memory>
diff --git a/include/settings/common_settings.h b/include/settings/common_settings.h
index 1372c70348..e6105ba886 100644
--- a/include/settings/common_settings.h
+++ b/include/settings/common_settings.h
@@ -166,6 +166,11 @@ public:
wxString authorEmail;
};
+ struct PYTHON
+ {
+ wxString interpreter_path;
+ };
+
COMMON_SETTINGS();
virtual ~COMMON_SETTINGS() {}
@@ -217,6 +222,8 @@ public:
PACKAGE_MANAGER m_PackageManager;
GIT m_Git;
+
+ PYTHON m_Python;
};
#endif
diff --git a/kicad/CMakeLists.txt b/kicad/CMakeLists.txt
index 7480c7dae4..e34422c9a2 100644
--- a/kicad/CMakeLists.txt
+++ b/kicad/CMakeLists.txt
@@ -108,6 +108,11 @@ if( MSVC )
set_target_properties(kicad-cli PROPERTIES LINK_FLAGS_RELWITHDEBINFO "/SUBSYSTEM:CONSOLE")
set_target_properties(kicad-cli PROPERTIES LINK_FLAGS_RELEASE "/SUBSYSTEM:CONSOLE")
set_target_properties(kicad-cli PROPERTIES LINK_FLAGS_MINSIZEREL "/SUBSYSTEM:CONSOLE")
+
+ # Allow running from build dir
+ add_custom_command( TARGET kicad POST_BUILD
+ COMMAND ${CMAKE_COMMAND} -E copy_if_different "$<TARGET_FILE:kiapi>" "$<TARGET_FILE_DIR:kicad>"
+ )
endif()
if( UNIX )
diff --git a/kicad/kicad.cpp b/kicad/kicad.cpp
index 8ada0831fa..3d99f13634 100644
--- a/kicad/kicad.cpp
+++ b/kicad/kicad.cpp
@@ -57,6 +57,10 @@
#include <kiplatform/app.h>
#include <kiplatform/environment.h>
+#ifdef KICAD_IPC_API
+#include <api/api_server.h>
+#endif
+
// a dummy to quiet linking with EDA_BASE_FRAME::config();
#include <kiface_base.h>
@@ -237,6 +241,10 @@ bool PGM_KICAD::OnPgmInit()
KICAD_SETTINGS* settings = static_cast<KICAD_SETTINGS*>( PgmSettings() );
+#ifdef KICAD_IPC_API
+ m_api_server = std::make_unique<KICAD_API_SERVER>();
+#endif
+
wxString projToLoad;
HideSplash();
@@ -348,6 +356,10 @@ bool PGM_KICAD::OnPgmInit()
frame->Show( true );
frame->Raise();
+#ifdef KICAD_IPC_API
+ m_api_server->SetReadyToReply();
+#endif
+
return true;
}
@@ -362,6 +374,10 @@ void PGM_KICAD::OnPgmExit()
{
Kiway.OnKiwayEnd();
+#ifdef KICAD_IPC_API
+ m_api_server.reset();
+#endif
+
if( m_settings_manager && m_settings_manager->IsOK() )
{
SaveCommonSettings();
diff --git a/libs/CMakeLists.txt b/libs/CMakeLists.txt
index e4d39d3a40..eb96b456a4 100644
--- a/libs/CMakeLists.txt
+++ b/libs/CMakeLists.txt
@@ -26,3 +26,7 @@ add_subdirectory( core )
add_subdirectory( kimath )
add_subdirectory( kiplatform )
add_subdirectory( sexpr )
+
+if( KICAD_IPC_API )
+ add_subdirectory( kinng )
+endif()
diff --git a/libs/kinng/CMakeLists.txt b/libs/kinng/CMakeLists.txt
new file mode 100644
index 0000000000..d798164f8a
--- /dev/null
+++ b/libs/kinng/CMakeLists.txt
@@ -0,0 +1,38 @@
+# This program source code file is part of KiCad, a free EDA CAD application.
+#
+# Copyright (C) 2023 KiCad Developers, see AUTHORS.TXT for contributors.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or (at your
+# option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program. If not, see <http://www.gnu.org/licenses/>.
+
+set( KINNG_SRCS
+ src/kinng.cpp
+ )
+
+add_library( kinng STATIC
+ ${KINNG_SRCS}
+ )
+
+target_link_libraries( kinng
+ ${NNG_LIBRARY}
+ )
+
+target_include_directories( kinng PUBLIC
+ ${PROJECT_BINARY_DIR}
+ ${CMAKE_CURRENT_SOURCE_DIR}/include
+ )
+
+target_include_directories( kinng PRIVATE
+ ${PROJECT_SOURCE_DIR}/include
+ ${NNG_INCLUDE_DIR}
+ )
\ No newline at end of file
diff --git a/libs/kinng/include/kinng.h b/libs/kinng/include/kinng.h
new file mode 100644
index 0000000000..d67cfd462e
--- /dev/null
+++ b/libs/kinng/include/kinng.h
@@ -0,0 +1,64 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2023 Jon Evans <jon@craftyjon.com>
+ * Copyright (C) 2023 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef KICAD_KINNG_H
+#define KICAD_KINNG_H
+
+#include <atomic>
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+#include <thread>
+
+
+class KINNG_REQUEST_SERVER
+{
+public:
+ KINNG_REQUEST_SERVER();
+
+ ~KINNG_REQUEST_SERVER();
+
+ bool Start();
+
+ void Stop();
+
+ void SetCallback( std::function<void(std::string*)> aFunc ) { m_callback = aFunc; }
+
+ void Reply( const std::string& aReply );
+
+private:
+ void listenThread();
+
+ std::thread m_thread;
+
+ std::atomic<bool> m_shutdown;
+
+ std::string m_socketUrl;
+
+ std::function<void(std::string*)> m_callback;
+
+ std::string m_pendingReply;
+
+ std::condition_variable m_replyReady;
+
+ std::mutex m_mutex;
+};
+
+#endif //KICAD_KINNG_H
diff --git a/libs/kinng/src/kinng.cpp b/libs/kinng/src/kinng.cpp
new file mode 100644
index 0000000000..8c86e540ec
--- /dev/null
+++ b/libs/kinng/src/kinng.cpp
@@ -0,0 +1,129 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2023 Jon Evans <jon@craftyjon.com>
+ * Copyright (C) 2023 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <kinng.h>
+#include <nng/nng.h>
+#include <nng/protocol/reqrep0/rep.h>
+#include <nng/protocol/reqrep0/req.h>
+
+
+KINNG_REQUEST_SERVER::KINNG_REQUEST_SERVER() :
+ m_callback()
+{
+#ifdef WIN32
+ m_socketUrl = "ipc://\\.\\pipe\\kicad";
+#else
+ m_socketUrl = "ipc:///tmp/kicad.sock";
+#endif
+
+ Start();
+}
+
+
+KINNG_REQUEST_SERVER::~KINNG_REQUEST_SERVER()
+{
+ Stop();
+}
+
+
+bool KINNG_REQUEST_SERVER::Start()
+{
+ m_shutdown.store( false );
+ m_thread = std::thread( [&]() { listenThread(); } );
+ return true;
+}
+
+
+void KINNG_REQUEST_SERVER::Stop()
+{
+ if( !m_thread.joinable() )
+ return;
+
+ {
+ std::lock_guard<std::mutex> lock( m_mutex );
+ m_replyReady.notify_all();
+ }
+
+ m_shutdown.store( true );
+ m_thread.join();
+}
+
+
+void KINNG_REQUEST_SERVER::Reply( const std::string& aReply )
+{
+ std::lock_guard<std::mutex> lock( m_mutex );
+ m_pendingReply = aReply;
+ m_replyReady.notify_all();
+}
+
+
+void KINNG_REQUEST_SERVER::listenThread()
+{
+ nng_socket socket;
+ nng_listener listener;
+ int retCode = 0;
+
+ retCode = nng_rep0_open( &socket );
+
+ if( retCode != 0 )
+ return;
+
+ retCode = nng_listener_create( &listener, socket, m_socketUrl.c_str() );
+
+ if( retCode != 0 )
+ return;
+
+ nng_socket_set_ms( socket, NNG_OPT_RECVTIMEO, 500 );
+
+ nng_listener_start( listener, 0 );
+
+ while( !m_shutdown.load() )
+ {
+ char* buf = nullptr;
+ size_t sz;
+ uint64_t val;
+
+ retCode = nng_recv( socket, &buf, &sz, NNG_FLAG_ALLOC );
+
+ if( retCode == NNG_ETIMEDOUT )
+ continue;
+
+ if( retCode != 0 )
+ {
+ nng_free( buf, sz );
+ break;
+ }
+
+ std::string message( buf, sz );
+
+ if( m_callback )
+ m_callback( &message );
+
+ std::unique_lock<std::mutex> lock( m_mutex );
+ m_replyReady.wait( lock, [&]() { return !m_pendingReply.empty(); } );
+
+ retCode = nng_send( socket, const_cast<std::string::value_type*>( m_pendingReply.c_str() ),
+ m_pendingReply.length(), 0 );
+
+ m_pendingReply.clear();
+ }
+
+ nng_close( socket );
+}
diff --git a/pcbnew/CMakeLists.txt b/pcbnew/CMakeLists.txt
index 2364dcda71..dde42117a7 100644
--- a/pcbnew/CMakeLists.txt
+++ b/pcbnew/CMakeLists.txt
@@ -425,6 +425,12 @@ set( PCBNEW_SCRIPTING_PYTHON_HELPERS
python/scripting/pcb_scripting_tool.cpp
)
+if( KICAD_IPC_API )
+ set( PCBNEW_SRCS ${PCBNEW_SRCS}
+ api/api_handler_pcb.cpp
+ )
+endif()
+
if( COMPILER_SUPPORTS_WARNINGS )
# Only compile our source files with the warnings, since the SWIG generated
@@ -719,7 +725,6 @@ set( PCBNEW_KIFACE_LIBRARIES
${PCBNEW_EXTRA_LIBS} # -lrt must follow Boost
)
-
target_link_libraries( pcbnew_kiface
PRIVATE
${PCBNEW_KIFACE_LIBRARIES}
@@ -742,6 +747,9 @@ if( WIN32 )
add_custom_command( TARGET pcbnew POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy_if_different "$<TARGET_FILE:kicad_3dsg>" "$<TARGET_FILE_DIR:pcbnew>"
)
+ add_custom_command( TARGET pcbnew POST_BUILD
+ COMMAND ${CMAKE_COMMAND} -E copy_if_different "$<TARGET_FILE:kiapi>" "$<TARGET_FILE_DIR:pcbnew>"
+ )
endif()
# these 2 binaries are a matched set, keep them together:
diff --git a/pcbnew/api/api_handler_pcb.cpp b/pcbnew/api/api_handler_pcb.cpp
new file mode 100644
index 0000000000..69e7aa1940
--- /dev/null
+++ b/pcbnew/api/api_handler_pcb.cpp
@@ -0,0 +1,493 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2023 Jon Evans <jon@craftyjon.com>
+ * Copyright (C) 2023 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <magic_enum.hpp>
+
+#include <api/api_handler_pcb.h>
+#include <board_commit.h>
+#include <pcb_edit_frame.h>
+#include <pcb_track.h>
+#include <tool/tool_manager.h>
+
+#include <api/common/types/base_types.pb.h>
+
+using namespace kiapi::common::commands;
+using kiapi::common::types::CommandStatus;
+using kiapi::common::types::DocumentType;
+using kiapi::common::types::ItemRequestStatus;
+
+static const wxString s_defaultCommitMessage = wxS( "Modification from API" );
+
+
+API_HANDLER_PCB::API_HANDLER_PCB( PCB_EDIT_FRAME* aFrame ) :
+ API_HANDLER(),
+ m_frame( aFrame )
+{
+ registerHandler<RunAction, RunActionResponse>( &API_HANDLER_PCB::handleRunAction );
+ registerHandler<GetOpenDocuments, GetOpenDocumentsResponse>(
+ &API_HANDLER_PCB::handleGetOpenDocuments );
+
+ registerHandler<BeginCommit, BeginCommitResponse>( &API_HANDLER_PCB::handleBeginCommit );
+ registerHandler<EndCommit, EndCommitResponse>( &API_HANDLER_PCB::handleEndCommit );
+
+ registerHandler<CreateItems, CreateItemsResponse>( &API_HANDLER_PCB::handleCreateItems );
+ registerHandler<GetItems, GetItemsResponse>( &API_HANDLER_PCB::handleGetItems );
+ registerHandler<UpdateItems, UpdateItemsResponse>( &API_HANDLER_PCB::handleUpdateItems );
+ registerHandler<DeleteItems, DeleteItemsResponse>( &API_HANDLER_PCB::handleDeleteItems );
+
+}
+
+
+HANDLER_RESULT<RunActionResponse> API_HANDLER_PCB::handleRunAction( RunAction& aRequest )
+{
+ RunActionResponse response;
+
+ if( m_frame->GetToolManager()->RunAction( aRequest.action(), true ) )
+ response.set_status( RunActionStatus::RAS_OK );
+ else
+ response.set_status( RunActionStatus::RAS_INVALID );
+
+ return response;
+}
+
+
+HANDLER_RESULT<GetOpenDocumentsResponse> API_HANDLER_PCB::handleGetOpenDocuments(
+ GetOpenDocuments& aMsg )
+{
+ if( aMsg.type() != DocumentType::DOCTYPE_PCB )
+ {
+ ApiResponseStatus e;
+ // No message needed for AS_UNHANDLED; this is an internal flag for the API server
+ e.set_status( ApiStatusCode::AS_UNHANDLED );
+ return tl::unexpected( e );
+ }
+
+ GetOpenDocumentsResponse response;
+ common::types::DocumentSpecifier doc;
+
+ wxFileName fn( m_frame->GetCurrentFileName() );
+
+ doc.set_type( DocumentType::DOCTYPE_PCB );
+ doc.set_board_filename( fn.GetFullName() );
+
+ response.mutable_documents()->Add( std::move( doc ) );
+ return response;
+}
+
+
+HANDLER_RESULT<BeginCommitResponse> API_HANDLER_PCB::handleBeginCommit( BeginCommit& aMsg )
+{
+ BeginCommitResponse response;
+
+ if( m_commit )
+ {
+ // TODO: right now there is no way for m_transactionInProgress to be true here, but
+ // we should still check it as a safety measure and return a specific error
+ //if( !m_transactionInProgress )
+
+ m_commit->Revert();
+ }
+
+ m_commit.reset( new BOARD_COMMIT( m_frame ) );
+
+ // TODO: return an opaque ID for this new commit to make this more robust
+ m_transactionInProgress = true;
+
+ return response;
+}
+
+
+HANDLER_RESULT<EndCommitResponse> API_HANDLER_PCB::handleEndCommit( EndCommit& aMsg )
+{
+ EndCommitResponse response;
+
+ // TODO: return more specific error if m_transactionInProgress is false
+ if( !m_transactionInProgress )
+ {
+ // Make sure we don't get stuck with a commit we can never push
+ m_commit.reset();
+ response.set_result( CommitResult::CR_NO_COMMIT );
+ return response;
+ }
+
+ if( !m_commit )
+ {
+ response.set_result( CommitResult::CR_NO_COMMIT );
+ return response;
+ }
+
+ pushCurrentCommit( aMsg.message() );
+ m_transactionInProgress = false;
+
+ response.set_result( CommitResult::CR_OK );
+ return response;
+}
+
+
+BOARD_COMMIT* API_HANDLER_PCB::getCurrentCommit()
+{
+ if( !m_commit )
+ m_commit.reset( new BOARD_COMMIT( m_frame ) );
+
+ return m_commit.get();
+}
+
+
+void API_HANDLER_PCB::pushCurrentCommit( const std::string& aMessage )
+{
+ wxCHECK( m_commit, /* void */ );
+
+ wxString msg( aMessage.c_str(), wxConvUTF8 );
+
+ if( msg.IsEmpty() )
+ msg = s_defaultCommitMessage;
+
+ m_commit->Push( msg );
+ m_commit.reset();
+
+ m_frame->Refresh();
+}
+
+
+bool API_HANDLER_PCB::validateItemHeaderDocument( const common::types::ItemHeader& aHeader )
+{
+ // TODO: this should return a more complex error type.
+ // We should provide detailed feedback when a header fails validation, and distinguish between
+ // "skip this handler" and "this is the right handler, but the request is invalid"
+ if( !aHeader.has_document() || aHeader.document().type() != DocumentType::DOCTYPE_PCB )
+ return false;
+
+ wxFileName fn( m_frame->GetCurrentFileName() );
+
+ return aHeader.document().board_filename().compare( fn.GetFullName() ) == 0;
+}
+
+
+std::unique_ptr<BOARD_ITEM> API_HANDLER_PCB::createItemForType( KICAD_T aType,
+ BOARD_ITEM_CONTAINER* aContainer )
+{
+ switch( aType )
+ {
+ case PCB_TRACE_T: return std::make_unique<PCB_TRACK>( aContainer );
+ case PCB_ARC_T: return std::make_unique<PCB_ARC>( aContainer );
+ case PCB_VIA_T: return std::make_unique<PCB_VIA>( aContainer );
+ default: return nullptr;
+ }
+}
+
+
+HANDLER_RESULT<CreateItemsResponse> API_HANDLER_PCB::handleCreateItems( CreateItems& aMsg )
+{
+ ApiResponseStatus e;
+
+ if( !validateItemHeaderDocument( aMsg.header() ) )
+ {
+ // No message needed for AS_UNHANDLED; this is an internal flag for the API server
+ e.set_status( ApiStatusCode::AS_UNHANDLED );
+ return tl::unexpected( e );
+ }
+
+ BOARD* board = m_frame->GetBoard();
+ BOARD_ITEM_SET boardItems = board->GetItemSet();
+
+ std::map<KIID, BOARD_ITEM*> itemUuidMap;
+
+ std::for_each( boardItems.begin(), boardItems.end(),
+ [&]( BOARD_ITEM* aItem )
+ {
+ itemUuidMap[aItem->m_Uuid] = aItem;
+ } );
+
+ BOARD_COMMIT* commit = getCurrentCommit();
+
+ CreateItemsResponse response;
+
+ for( const google::protobuf::Any& anyItem : aMsg.items() )
+ {
+ ItemCreationResult itemResult;
+ std::optional<KICAD_T> type = TypeNameFromAny( anyItem );
+
+ if( !type )
+ {
+ itemResult.set_status( ItemCreationStatus::ICS_INVALID_TYPE );
+ response.mutable_created_items()->Add( std::move( itemResult ) );
+ continue;
+ }
+
+ std::unique_ptr<BOARD_ITEM> item = createItemForType( *type, board );
+
+ if( !item )
+ {
+ itemResult.set_status( ItemCreationStatus::ICS_INVALID_TYPE );
+ e.set_error_message( fmt::format( "item type {} not supported for board",
+ magic_enum::enum_name( *type ) ) );
+ response.mutable_created_items()->Add( std::move( itemResult ) );
+ continue;
+ }
+
+ if( !item->Deserialize( anyItem ) )
+ {
+ e.set_status( ApiStatusCode::AS_BAD_REQUEST );
+ e.set_error_message( fmt::format( "could not unpack {} from request",
+ item->GetClass().ToStdString() ) );
+ return tl::unexpected( e );
+ }
+
+ if( itemUuidMap.count( item->m_Uuid ) )
+ {
+ itemResult.set_status( ItemCreationStatus::ICS_EXISTING );
+ response.mutable_created_items()->Add( std::move( itemResult ) );
+ continue;
+ }
+
+ itemResult.set_status( ItemCreationStatus::ICS_OK );
+ item->Serialize( *itemResult.mutable_item() );
+ commit->Add( item.release() );
+
+ response.mutable_created_items()->Add( std::move( itemResult ) );
+ }
+
+ pushCurrentCommit( "Added items via API" );
+ response.set_status( ItemRequestStatus::IRS_OK );
+ return response;
+}
+
+
+HANDLER_RESULT<GetItemsResponse> API_HANDLER_PCB::handleGetItems( GetItems& aMsg )
+{
+ if( !validateItemHeaderDocument( aMsg.header() ) )
+ {
+ ApiResponseStatus e;
+ // No message needed for AS_UNHANDLED; this is an internal flag for the API server
+ e.set_status( ApiStatusCode::AS_UNHANDLED );
+ return tl::unexpected( e );
+ }
+
+ GetItemsResponse response;
+
+ BOARD* board = m_frame->GetBoard();
+ std::vector<BOARD_ITEM*> items;
+ std::set<KICAD_T> typesRequested, typesInserted;
+ bool handledAnything = false;
+
+ for( const common::types::ItemType& typeMessage : aMsg.types() )
+ {
+ KICAD_T type;
+
+ if( std::optional<KICAD_T> opt_type = magic_enum::enum_cast<KICAD_T>( typeMessage.type() ) )
+ type = *opt_type;
+ else
+ continue;
+
+ typesRequested.emplace( type );
+
+ if( typesInserted.count( type ) )
+ continue;
+
+ switch( type )
+ {
+ case PCB_TRACE_T:
+ case PCB_ARC_T:
+ case PCB_VIA_T:
+ handledAnything = true;
+ std::copy( board->Tracks().begin(), board->Tracks().end(),
+ std::back_inserter( items ) );
+ typesInserted.insert( { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T } );
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ if( !handledAnything )
+ {
+ ApiResponseStatus e;
+ e.set_status( ApiStatusCode::AS_BAD_REQUEST );
+ e.set_error_message( "none of the requested types are valid for a Board object" );
+ return tl::unexpected( e );
+ }
+
+ for( const BOARD_ITEM* item : items )
+ {
+ if( !typesRequested.count( item->Type() ) )
+ continue;
+
+ google::protobuf::Any itemBuf;
+ item->Serialize( itemBuf );
+ response.mutable_items()->Add( std::move( itemBuf ) );
+ }
+
+ response.set_status( ItemRequestStatus::IRS_OK );
+ return response;
+}
+
+
+HANDLER_RESULT<UpdateItemsResponse> API_HANDLER_PCB::handleUpdateItems( UpdateItems& aMsg )
+{
+ ApiResponseStatus e;
+
+ if( !validateItemHeaderDocument( aMsg.header() ) )
+ {
+ // No message needed for AS_UNHANDLED; this is an internal flag for the API server
+ e.set_status( ApiStatusCode::AS_UNHANDLED );
+ return tl::unexpected( e );
+ }
+
+ BOARD* board = m_frame->GetBoard();
+ BOARD_ITEM_SET boardItems = board->GetItemSet();
+
+ std::map<KIID, BOARD_ITEM*> itemUuidMap;
+
+ std::for_each( boardItems.begin(), boardItems.end(),
+ [&]( BOARD_ITEM* aItem )
+ {
+ itemUuidMap[aItem->m_Uuid] = aItem;
+ } );
+
+ BOARD_COMMIT* commit = getCurrentCommit();
+
+ UpdateItemsResponse response;
+
+ for( const google::protobuf::Any& anyItem : aMsg.items() )
+ {
+ ItemUpdateResult itemResult;
+ std::optional<KICAD_T> type = TypeNameFromAny( anyItem );
+
+ if( !type )
+ {
+ itemResult.set_status( ItemUpdateStatus::IUS_INVALID_TYPE );
+ response.mutable_updated_items()->Add( std::move( itemResult ) );
+ continue;
+ }
+
+ std::unique_ptr<BOARD_ITEM> temporaryItem = createItemForType( *type, board );
+
+ if( !temporaryItem )
+ {
+ itemResult.set_status( ItemUpdateStatus::IUS_INVALID_TYPE );
+ response.mutable_updated_items()->Add( std::move( itemResult ) );
+ continue;
+ }
+
+ if( !temporaryItem->Deserialize( anyItem ) )
+ {
+ e.set_status( ApiStatusCode::AS_BAD_REQUEST );
+ e.set_error_message( fmt::format( "could not unpack {} from request",
+ magic_enum::enum_name( *type ) ) );
+ return tl::unexpected( e );
+ }
+
+ if( !itemUuidMap.count( temporaryItem->m_Uuid ) )
+ {
+ itemResult.set_status( ItemUpdateStatus::IUS_NONEXISTENT );
+ response.mutable_updated_items()->Add( std::move( itemResult ) );
+ continue;
+ }
+
+ BOARD_ITEM* boardItem = itemUuidMap[temporaryItem->m_Uuid];
+
+ boardItem->SwapItemData( temporaryItem.get() );
+
+ itemResult.set_status( ItemUpdateStatus::IUS_OK );
+ boardItem->Serialize( *itemResult.mutable_item() );
+ commit->Modify( boardItem );
+
+ itemResult.set_status( ItemUpdateStatus::IUS_OK );
+ response.mutable_updated_items()->Add( std::move( itemResult ) );
+ }
+
+ response.set_status( ItemRequestStatus::IRS_OK );
+ pushCurrentCommit( "Updated items via API" );
+ return response;
+}
+
+
+HANDLER_RESULT<DeleteItemsResponse> API_HANDLER_PCB::handleDeleteItems( DeleteItems& aMsg )
+{
+ if( !validateItemHeaderDocument( aMsg.header() ) )
+ {
+ ApiResponseStatus e;
+ // No message needed for AS_UNHANDLED; this is an internal flag for the API server
+ e.set_status( ApiStatusCode::AS_UNHANDLED );
+ return tl::unexpected( e );
+ }
+
+ std::map<KIID, ItemDeletionStatus> itemsToDelete;
+
+ for( const common::types::KIID& kiidBuf : aMsg.item_ids() )
+ {
+ if( !kiidBuf.value().empty() )
+ {
+ KIID kiid( kiidBuf.value() );
+ itemsToDelete[kiid] = ItemDeletionStatus::IDS_NONEXISTENT;
+ }
+ }
+
+ if( itemsToDelete.empty() )
+ {
+ ApiResponseStatus e;
+ e.set_status( ApiStatusCode::AS_BAD_REQUEST );
+ e.set_error_message( "no valid items to delete were given" );
+ return tl::unexpected( e );
+ }
+
+ BOARD* board = m_frame->GetBoard();
+
+ // This is somewhat inefficient on paper, but the total number of items on a board is
+ // not computationally-speaking very high even on what we'd consider a large design.
+ // If this ends up not being the case, we should consider doing something like refactoring
+ // BOARD to contain all items in a contiguous memory arena and constructing views over it
+ // when we want to filter to just tracks, etc.
+ BOARD_ITEM_SET items = board->GetItemSet();
+ std::vector<BOARD_ITEM*> validatedItems;
+
+ for( BOARD_ITEM* item : items )
+ {
+ if( itemsToDelete.count( item->m_Uuid ) )
+ {
+ validatedItems.push_back( item );
+ itemsToDelete[item->m_Uuid] = ItemDeletionStatus::IDS_OK;
+ }
+
+ // Note: we don't currently support locking items from API modification, but here is where
+ // to add it in the future (and return IDS_IMMUTABLE)
+ }
+
+ BOARD_COMMIT* commit = getCurrentCommit();
+
+ for( BOARD_ITEM* item : validatedItems )
+ commit->Remove( item );
+
+ if( !m_transactionInProgress )
+ pushCurrentCommit( "Deleted items via API" );
+
+ DeleteItemsResponse response;
+
+ for( const auto& [id, status] : itemsToDelete )
+ {
+ ItemDeletionResult result;
+ result.mutable_id()->set_value( id.AsStdString() );
+ result.set_status( status );
+ }
+
+ response.set_status( ItemRequestStatus::IRS_OK );
+ return response;
+}
diff --git a/pcbnew/api/api_handler_pcb.h b/pcbnew/api/api_handler_pcb.h
new file mode 100644
index 0000000000..13b6e32719
--- /dev/null
+++ b/pcbnew/api/api_handler_pcb.h
@@ -0,0 +1,86 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2023 Jon Evans <jon@craftyjon.com>
+ * Copyright (C) 2023 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef KICAD_API_HANDLER_PCB_H
+#define KICAD_API_HANDLER_PCB_H
+
+#include <google/protobuf/empty.pb.h>
+
+#include <api/api_handler.h>
+
+#include <api/common/commands/editor_commands.pb.h>
+
+#include <properties/property_mgr.h>
+
+using namespace kiapi;
+using namespace kiapi::common;
+
+using google::protobuf::Empty;
+
+
+class BOARD_COMMIT;
+class BOARD_ITEM;
+class BOARD_ITEM_CONTAINER;
+class EDA_ITEM;
+class PCB_EDIT_FRAME;
+class PCB_TRACK;
+class PROPERTY_BASE;
+
+
+class API_HANDLER_PCB : public API_HANDLER
+{
+public:
+ API_HANDLER_PCB( PCB_EDIT_FRAME* aFrame );
+
+private:
+ typedef std::map<std::string, PROPERTY_BASE*> PROTO_PROPERTY_MAP;
+
+ static std::unique_ptr<BOARD_ITEM> createItemForType( KICAD_T aType,
+ BOARD_ITEM_CONTAINER* aContainer );
+
+ HANDLER_RESULT<commands::RunActionResponse> handleRunAction( commands::RunAction& aMsg );
+
+ HANDLER_RESULT<commands::GetOpenDocumentsResponse> handleGetOpenDocuments(
+ commands::GetOpenDocuments& aMsg );
+
+ HANDLER_RESULT<commands::BeginCommitResponse> handleBeginCommit( commands::BeginCommit& aMsg );
+ HANDLER_RESULT<commands::EndCommitResponse> handleEndCommit( commands::EndCommit& aMsg );
+
+ HANDLER_RESULT<commands::CreateItemsResponse> handleCreateItems( commands::CreateItems& aMsg );
+ HANDLER_RESULT<commands::GetItemsResponse> handleGetItems( commands::GetItems& aMsg );
+ HANDLER_RESULT<commands::UpdateItemsResponse> handleUpdateItems( commands::UpdateItems& aMsg );
+ HANDLER_RESULT<commands::DeleteItemsResponse> handleDeleteItems( commands::DeleteItems& aMsg );
+
+private:
+
+ bool validateItemHeaderDocument( const common::types::ItemHeader& aHeader );
+
+ BOARD_COMMIT* getCurrentCommit();
+
+ void pushCurrentCommit( const std::string& aMessage );
+
+ PCB_EDIT_FRAME* m_frame;
+
+ std::unique_ptr<BOARD_COMMIT> m_commit;
+
+ bool m_transactionInProgress;
+};
+
+#endif //KICAD_API_HANDLER_PCB_H
diff --git a/pcbnew/board.cpp b/pcbnew/board.cpp
index 7d378dc9d8..c35c2505cf 100644
--- a/pcbnew/board.cpp
+++ b/pcbnew/board.cpp
@@ -337,7 +337,7 @@ void BOARD::RecordDRCExclusions()
{
if( marker->IsExcluded() )
{
- wxString serialized = marker->Serialize();
+ wxString serialized = marker->SerializeToString();
m_designSettings->m_DrcExclusions.insert( serialized );
m_designSettings->m_DrcExclusionComments[ serialized ] = marker->GetComment();
}
@@ -355,7 +355,7 @@ std::vector<PCB_MARKER*> BOARD::ResolveDRCExclusions( bool aCreateMarkers )
for( PCB_MARKER* marker : GetBoard()->Markers() )
{
- wxString serialized = marker->Serialize();
+ wxString serialized = marker->SerializeToString();
std::set<wxString>::iterator it = exclusions.find( serialized );
if( it != exclusions.end() )
@@ -376,7 +376,7 @@ std::vector<PCB_MARKER*> BOARD::ResolveDRCExclusions( bool aCreateMarkers )
{
for( const wxString& serialized : exclusions )
{
- PCB_MARKER* marker = PCB_MARKER::Deserialize( serialized );
+ PCB_MARKER* marker = PCB_MARKER::DeserializeFromString( serialized );
if( !marker )
continue;
diff --git a/pcbnew/dialogs/dialog_drc.cpp b/pcbnew/dialogs/dialog_drc.cpp
index babb8a4099..9302047b4c 100644
--- a/pcbnew/dialogs/dialog_drc.cpp
+++ b/pcbnew/dialogs/dialog_drc.cpp
@@ -710,7 +710,7 @@ void DIALOG_DRC::OnDRCItemRClick( wxDataViewEvent& aEvent )
marker->SetExcluded( true, dlg.GetValue() );
- wxString serialized = marker->Serialize();
+ wxString serialized = marker->SerializeToString();
m_frame->GetDesignSettings().m_DrcExclusions.insert( serialized );
m_frame->GetDesignSettings().m_DrcExclusionComments[ serialized ] = dlg.GetValue();
@@ -726,7 +726,7 @@ void DIALOG_DRC::OnDRCItemRClick( wxDataViewEvent& aEvent )
{
marker->SetExcluded( false );
- wxString serialized = marker->Serialize();
+ wxString serialized = marker->SerializeToString();
m_frame->GetDesignSettings().m_DrcExclusions.erase( serialized );
m_frame->GetDesignSettings().m_DrcExclusionComments.erase( serialized );
@@ -758,7 +758,7 @@ void DIALOG_DRC::OnDRCItemRClick( wxDataViewEvent& aEvent )
marker->SetExcluded( true, dlg.GetValue() );
- wxString serialized = marker->Serialize();
+ wxString serialized = marker->SerializeToString();
m_frame->GetDesignSettings().m_DrcExclusions.insert( serialized );
m_frame->GetDesignSettings().m_DrcExclusionComments[ serialized ] = dlg.GetValue();
@@ -792,7 +792,7 @@ void DIALOG_DRC::OnDRCItemRClick( wxDataViewEvent& aEvent )
{
marker->SetExcluded( false );
- wxString serialized = marker->Serialize();
+ wxString serialized = marker->SerializeToString();
m_frame->GetDesignSettings().m_DrcExclusions.erase( serialized );
m_frame->GetDesignSettings().m_DrcExclusionComments.erase( serialized );
}
@@ -812,7 +812,7 @@ void DIALOG_DRC::OnDRCItemRClick( wxDataViewEvent& aEvent )
{
marker->SetExcluded( true );
- wxString serialized = marker->Serialize();
+ wxString serialized = marker->SerializeToString();
m_frame->GetDesignSettings().m_DrcExclusions.insert( serialized );
}
}
@@ -1082,7 +1082,7 @@ void DIALOG_DRC::ExcludeMarker()
if( marker && marker->GetSeverity() != RPT_SEVERITY_EXCLUSION )
{
marker->SetExcluded( true );
- m_frame->GetDesignSettings().m_DrcExclusions.insert( marker->Serialize() );
+ m_frame->GetDesignSettings().m_DrcExclusions.insert( marker->SerializeToString() );
m_frame->GetCanvas()->GetView()->Update( marker );
// Update view
diff --git a/pcbnew/pcb_edit_frame.cpp b/pcbnew/pcb_edit_frame.cpp
index 204b4cc367..276d7c3ffb 100644
--- a/pcbnew/pcb_edit_frame.cpp
+++ b/pcbnew/pcb_edit_frame.cpp
@@ -109,6 +109,11 @@
#include <footprint_viewer_frame.h>
#include <footprint_chooser_frame.h>
+#ifdef KICAD_IPC_API
+#include <api/api_server.h>
+#include <api/api_handler_pcb.h>
+#endif
+
#include <action_plugin.h>
#include <pcbnew_scripting_helpers.h>
#include "../scripting/python_scripting.h"
@@ -426,6 +431,11 @@ PCB_EDIT_FRAME::PCB_EDIT_FRAME( KIWAY* aKiway, wxWindow* aParent ) :
// Sync action plugins in case they changed since the last time the frame opened
GetToolManager()->RunAction( PCB_ACTIONS::pluginsReload );
+#ifdef KICAD_IPC_API
+ m_apiHandler = std::make_unique<API_HANDLER_PCB>( this );
+ Pgm().GetApiServer().RegisterHandler( m_apiHandler.get() );
+#endif
+
GetCanvas()->SwitchBackend( m_canvasType );
ActivateGalCanvas();
@@ -517,6 +527,16 @@ PCB_EDIT_FRAME::~PCB_EDIT_FRAME()
delete m_eventCounterTimer;
}
+#ifdef KICAD_IPC_API
+ Pgm().GetApiServer().DeregisterHandler( m_apiHandler.get() );
+#endif
+
+ // Close modeless dialogs
+ wxWindow* open_dlg = wxWindow::FindWindowByName( DIALOG_DRC_WINDOW_NAME );
+
+ if( open_dlg )
+ open_dlg->Close( true );
+
// Shutdown all running tools
if( m_toolManager )
m_toolManager->ShutdownAllTools();
diff --git a/pcbnew/pcb_edit_frame.h b/pcbnew/pcb_edit_frame.h
index e24aa49f73..2ae779e81e 100644
--- a/pcbnew/pcb_edit_frame.h
+++ b/pcbnew/pcb_edit_frame.h
@@ -58,6 +58,11 @@ class ACTION_MENU;
class TOOL_ACTION;
class STRING_UTF8_MAP;
+#ifdef KICAD_IPC_API
+class KICAD_API_SERVER;
+class API_HANDLER_PCB;
+#endif
+
enum LAST_PATH_TYPE : unsigned int;
namespace PCB { struct IFACE; } // KIFACE is in pcbnew.cpp
@@ -856,6 +861,10 @@ private:
wxTimer m_redrawNetnamesTimer;
wxTimer* m_eventCounterTimer;
+
+#ifdef KICAD_IPC_API
+ std::unique_ptr<API_HANDLER_PCB> m_apiHandler;
+#endif
};
#endif // __PCB_EDIT_FRAME_H__
diff --git a/pcbnew/pcb_marker.cpp b/pcbnew/pcb_marker.cpp
index 3de53aadf9..52e450aed0 100644
--- a/pcbnew/pcb_marker.cpp
+++ b/pcbnew/pcb_marker.cpp
@@ -93,7 +93,7 @@ PCB_MARKER::~PCB_MARKER()
}
-wxString PCB_MARKER::Serialize() const
+wxString PCB_MARKER::SerializeToString() const
{
if( m_rcItem->GetErrorCode() == DRCE_COPPER_SLIVER )
{
@@ -137,7 +137,7 @@ wxString PCB_MARKER::Serialize() const
}
-PCB_MARKER* PCB_MARKER::Deserialize( const wxString& data )
+PCB_MARKER* PCB_MARKER::DeserializeFromString( const wxString& data )
{
auto getMarkerLayer =
[]( const wxString& layerName ) -> int
@@ -367,4 +367,4 @@ static struct PCB_MARKER_DESC
_HKI( "Locked" ),
[]( INSPECTABLE* aItem ) { return false; } );
}
-} _PCB_MARKER_DESC;
\ No newline at end of file
+} _PCB_MARKER_DESC;
diff --git a/pcbnew/pcb_marker.h b/pcbnew/pcb_marker.h
index 5e1011c9eb..d31869b2da 100644
--- a/pcbnew/pcb_marker.h
+++ b/pcbnew/pcb_marker.h
@@ -52,9 +52,9 @@ public:
const KIID GetUUID() const override { return m_Uuid; }
- wxString Serialize() const;
+ wxString SerializeToString() const;
- static PCB_MARKER* Deserialize( const wxString& data );
+ static PCB_MARKER* DeserializeFromString( const wxString& data );
void Move( const VECTOR2I& aMoveVector ) override
{
diff --git a/pcbnew/pcb_track.cpp b/pcbnew/pcb_track.cpp
index e9b74e34f0..c10a74d65b 100644
--- a/pcbnew/pcb_track.cpp
+++ b/pcbnew/pcb_track.cpp
@@ -23,6 +23,7 @@
* or you may write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
+#include <magic_enum.hpp>
#include <pcb_base_frame.h>
#include <core/mirror.h>
@@ -44,6 +45,9 @@
#include <pcb_painter.h>
#include <trigo.h>
+#include <google/protobuf/any.pb.h>
+#include <api/board/board_types.pb.h>
+
using KIGFX::PCB_PAINTER;
using KIGFX::PCB_RENDER_SETTINGS;
@@ -287,6 +291,196 @@ double PCB_VIA::Similarity( const BOARD_ITEM& aOther ) const
}
+void PCB_TRACK::Serialize( google::protobuf::Any &aContainer ) const
+{
+ kiapi::board::types::Track track;
+
+ track.mutable_id()->set_value( m_Uuid.AsStdString() );
+ track.mutable_start()->set_x_nm( GetPosition().x );
+ track.mutable_start()->set_y_nm( GetPosition().y );
+ track.mutable_end()->set_x_nm( GetEnd().x );
+ track.mutable_end()->set_y_nm( GetEnd().y );
+ track.mutable_width()->set_value_nm( GetWidth() );
+ track.mutable_layer()->set_layer_id( GetLayer() );
+ track.set_locked( IsLocked() ? kiapi::common::types::LockedState::LS_LOCKED
+ : kiapi::common::types::LockedState::LS_UNLOCKED );
+ track.mutable_net()->set_code( GetNetCode() );
+ track.mutable_net()->set_name( GetNetname() );
+
+ aContainer.PackFrom( track );
+}
+
+
+bool PCB_TRACK::Deserialize( const google::protobuf::Any &aContainer )
+{
+ kiapi::board::types::Track track;
+
+ if( !aContainer.UnpackTo( &track ) )
+ return false;
+
+ const_cast<KIID&>( m_Uuid ) = KIID( track.id().value() );
+ SetStart( VECTOR2I( track.start().x_nm(), track.start().y_nm() ) );
+ SetEnd( VECTOR2I( track.end().x_nm(), track.end().y_nm() ) );
+ SetWidth( track.width().value_nm() );
+ SetLayer( magic_enum::enum_cast<PCB_LAYER_ID>( track.layer().layer_id() ).value_or( F_Cu ) );
+ SetNetCode( track.net().code() );
+ SetLocked( track.locked() == kiapi::common::types::LockedState::LS_LOCKED );
+
+ return true;
+}
+
+
+void PCB_ARC::Serialize( google::protobuf::Any &aContainer ) const
+{
+ kiapi::board::types::Arc arc;
+
+ arc.mutable_id()->set_value( m_Uuid.AsStdString() );
+ arc.mutable_start()->set_x_nm( GetPosition().x );
+ arc.mutable_start()->set_y_nm( GetPosition().y );
+ arc.mutable_mid()->set_x_nm( GetMid().x );
+ arc.mutable_mid()->set_y_nm( GetMid().y );
+ arc.mutable_end()->set_x_nm( GetEnd().x );
+ arc.mutable_end()->set_y_nm( GetEnd().y );
+ arc.mutable_width()->set_value_nm( GetWidth() );
+ arc.mutable_layer()->set_layer_id( GetLayer() );
+ arc.set_locked( IsLocked() ? kiapi::common::types::LockedState::LS_LOCKED
+ : kiapi::common::types::LockedState::LS_UNLOCKED );
+ arc.mutable_net()->set_code( GetNetCode() );
+ arc.mutable_net()->set_name( GetNetname() );
+
+ aContainer.PackFrom( arc );
+}
+
+
+bool PCB_ARC::Deserialize( const google::protobuf::Any &aContainer )
+{
+ kiapi::board::types::Arc arc;
+
+ if( !aContainer.UnpackTo( &arc ) )
+ return false;
+
+ const_cast<KIID&>( m_Uuid ) = KIID( arc.id().value() );
+ SetStart( VECTOR2I( arc.start().x_nm(), arc.start().y_nm() ) );
+ SetMid( VECTOR2I( arc.mid().x_nm(), arc.mid().y_nm() ) );
+ SetEnd( VECTOR2I( arc.end().x_nm(), arc.end().y_nm() ) );
+ SetWidth( arc.width().value_nm() );
+ SetLayer( magic_enum::enum_cast<PCB_LAYER_ID>( arc.layer().layer_id() ).value_or( F_Cu ) );
+ SetNetCode( arc.net().code() );
+ SetLocked( arc.locked() == kiapi::common::types::LockedState::LS_LOCKED );
+
+ return true;
+}
+
+
+void PCB_VIA::Serialize( google::protobuf::Any &aContainer ) const
+{
+ kiapi::board::types::Via via;
+
+ via.mutable_id()->set_value( m_Uuid.AsStdString() );
+ via.mutable_position()->set_x_nm( GetPosition().x );
+ via.mutable_position()->set_y_nm( GetPosition().y );
+ via.mutable_pad_diameter()->set_value_nm( GetWidth() );
+ via.mutable_drill_diameter()->set_value_nm( GetDrillValue() );
+
+ kiapi::board::types::PadStack* padstack = via.mutable_pad_stack();
+ padstack->set_type( GetViaType() == VIATYPE::BLIND_BURIED
+ ? kiapi::board::types::PadStackType::PST_BLIND_BURIED
+ : kiapi::board::types::PadStackType::PST_THROUGH );
+ padstack->mutable_start_layer()->set_layer_id( m_layer );
+ padstack->mutable_end_layer()->set_layer_id( m_bottomLayer );
+
+ kiapi::board::types::UnconnectedLayerRemoval ulr;
+
+ if( m_removeUnconnectedLayer )
+ {
+ if( m_keepStartEndLayer )
+ ulr = kiapi::board::types::UnconnectedLayerRemoval::ULR_REMOVE_EXCEPT_START_AND_END;
+ else
+ ulr = kiapi::board::types::UnconnectedLayerRemoval::ULR_REMOVE;
+ }
+ else
+ {
+ ulr = kiapi::board::types::UnconnectedLayerRemoval::ULR_KEEP;
+ }
+
+ // TODO: Microvia status is ignored here. Do we still need it?
+
+ padstack->set_unconnected_layer_removal( ulr );
+
+ via.set_locked( IsLocked() ? kiapi::common::types::LockedState::LS_LOCKED
+ : kiapi::common::types::LockedState::LS_UNLOCKED );
+ via.mutable_net()->set_code( GetNetCode() );
+ via.mutable_net()->set_name( GetNetname() );
+
+ aContainer.PackFrom( via );
+}
+
+
+bool PCB_VIA::Deserialize( const google::protobuf::Any &aContainer )
+{
+ kiapi::board::types::Via via;
+
+ if( !aContainer.UnpackTo( &via ) )
+ return false;
+
+ const_cast<KIID&>( m_Uuid ) = KIID( via.id().value() );
+ SetStart( VECTOR2I( via.position().x_nm(), via.position().y_nm() ) );
+ SetEnd( GetStart() );
+ SetWidth( via.pad_diameter().value_nm() );
+ SetDrill( via.drill_diameter().value_nm() );
+
+ const kiapi::board::types::PadStack& padstack = via.pad_stack();
+
+ switch( padstack.type() )
+ {
+ case kiapi::board::types::PadStackType::PST_BLIND_BURIED:
+ SetViaType( VIATYPE::BLIND_BURIED );
+ break;
+
+ default:
+ SetViaType( VIATYPE::THROUGH );
+ break;
+ }
+
+ if( GetViaType() != VIATYPE::THROUGH )
+ {
+ m_layer = magic_enum::enum_cast<PCB_LAYER_ID>( padstack.start_layer().layer_id() )
+ .value_or( F_Cu );
+ m_bottomLayer = magic_enum::enum_cast<PCB_LAYER_ID>( padstack.end_layer().layer_id() )
+ .value_or( B_Cu );
+ }
+ else
+ {
+ m_layer = F_Cu;
+ m_bottomLayer = B_Cu;
+ }
+
+ switch( padstack.unconnected_layer_removal() )
+ {
+ case kiapi::board::types::UnconnectedLayerRemoval::ULR_REMOVE:
+ m_removeUnconnectedLayer = true;
+ m_keepStartEndLayer = false;
+ break;
+
+ case kiapi::board::types::UnconnectedLayerRemoval::ULR_REMOVE_EXCEPT_START_AND_END:
+ m_removeUnconnectedLayer = true;
+ m_keepStartEndLayer = true;
+ break;
+
+ default:
+ case kiapi::board::types::UnconnectedLayerRemoval::ULR_KEEP:
+ m_removeUnconnectedLayer = false;
+ m_keepStartEndLayer = false;
+ break;
+ }
+
+ SetNetCode( via.net().code() );
+ SetLocked( via.locked() == kiapi::common::types::LockedState::LS_LOCKED );
+
+ return true;
+}
+
+
bool PCB_TRACK::ApproxCollinear( const PCB_TRACK& aTrack )
{
SEG a( m_Start, m_End );
diff --git a/pcbnew/pcb_track.h b/pcbnew/pcb_track.h
index ed58753491..bfda00cb07 100644
--- a/pcbnew/pcb_track.h
+++ b/pcbnew/pcb_track.h
@@ -260,6 +260,9 @@ public:
bool operator()( const PCB_TRACK* aFirst, const PCB_TRACK* aSecond ) const;
};
+ void Serialize( google::protobuf::Any &aContainer ) const override;
+ bool Deserialize( const google::protobuf::Any &aContainer ) override;
+
#if defined (DEBUG)
virtual void Show( int nestLevel, std::ostream& os ) const override { ShowDummy( os ); }
#endif
@@ -361,6 +364,9 @@ public:
bool operator==( const BOARD_ITEM& aOther ) const override;
+ void Serialize( google::protobuf::Any &aContainer ) const override;
+ bool Deserialize( const google::protobuf::Any &aContainer ) override;
+
protected:
virtual void swapData( BOARD_ITEM* aImage ) override;
@@ -595,6 +601,9 @@ public:
bool operator==( const BOARD_ITEM& aOther ) const override;
+ void Serialize( google::protobuf::Any &aContainer ) const override;
+ bool Deserialize( const google::protobuf::Any &aContainer ) override;
+
protected:
void swapData( BOARD_ITEM* aImage ) override;
diff --git a/qa/tests/libs/CMakeLists.txt b/qa/tests/libs/CMakeLists.txt
index 9836c2585b..9a60c61c87 100644
--- a/qa/tests/libs/CMakeLists.txt
+++ b/qa/tests/libs/CMakeLists.txt
@@ -23,3 +23,7 @@
add_subdirectory( sexpr )
add_subdirectory( kimath )
+
+if( KICAD_IPC_API )
+ add_subdirectory( kinng )
+endif()
diff --git a/qa/tests/libs/kinng/CMakeLists.txt b/qa/tests/libs/kinng/CMakeLists.txt
new file mode 100644
index 0000000000..fe1ad33330
--- /dev/null
+++ b/qa/tests/libs/kinng/CMakeLists.txt
@@ -0,0 +1,41 @@
+# This program source code file is part of KiCad, a free EDA CAD application.
+#
+# Copyright (C) 2023 KiCad Developers, see AUTHORS.TXT for contributors.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or (at your
+# option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program. If not, see <http://www.gnu.org/licenses/>.
+
+set( QA_KINNG_SRCS
+ kinng_test_module.cpp
+ test_kinng.cpp
+ )
+
+add_executable( qa_kinng
+ ${QA_KINNG_SRCS}
+ )
+
+target_link_libraries( qa_kinng
+ qa_utils
+ kinng
+ kiapi
+ ${NNG_LIBRARY}
+ ${wxWidgets_LIBRARIES}
+ )
+
+target_include_directories( qa_kinng PRIVATE
+ ${CMAKE_SOURCE_DIR}/include
+ ${CMAKE_SOURCE_DIR}/qa/mocks/include
+ ${CMAKE_CURRENT_SOURCE_DIR}
+ )
+
+kicad_add_boost_test( qa_kinng qa_kinng )
diff --git a/qa/tests/libs/kinng/kinng_test_module.cpp b/qa/tests/libs/kinng/kinng_test_module.cpp
new file mode 100644
index 0000000000..96bee685b0
--- /dev/null
+++ b/qa/tests/libs/kinng/kinng_test_module.cpp
@@ -0,0 +1,22 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2023 Jon Evans <jon@craftyjon.com>
+ * Copyright (C) 2023 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define BOOST_TEST_MODULE KiNNG
+#include <boost/test/unit_test.hpp>
\ No newline at end of file
diff --git a/qa/tests/libs/kinng/test_kinng.cpp b/qa/tests/libs/kinng/test_kinng.cpp
new file mode 100644
index 0000000000..74b1d2ad2e
--- /dev/null
+++ b/qa/tests/libs/kinng/test_kinng.cpp
@@ -0,0 +1,34 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2023 Jon Evans <jon@craftyjon.com>
+ * Copyright (C) 2023 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <qa_utils/wx_utils/unit_test_utils.h>
+#include <kinng.h>
+
+#include <import_export.h>
+#include <api/common/envelope.pb.h>
+
+BOOST_AUTO_TEST_SUITE( KiNNG )
+
+BOOST_AUTO_TEST_CASE( CreateIPCResponder )
+{
+ KINNG_REQUEST_SERVER server;
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/qa/tests/pcbnew/drc/test_custom_rule_severities.cpp b/qa/tests/pcbnew/drc/test_custom_rule_severities.cpp
index 42edc44036..4336f5876c 100644
--- a/qa/tests/pcbnew/drc/test_custom_rule_severities.cpp
+++ b/qa/tests/pcbnew/drc/test_custom_rule_severities.cpp
@@ -67,7 +67,7 @@ BOOST_FIXTURE_TEST_CASE( DRCCustomRuleSeverityTest, DRC_REGRESSION_TEST_FIXTURE
{
PCB_MARKER temp( aItem, aPos );
- if( bds.m_DrcExclusions.find( temp.Serialize() ) == bds.m_DrcExclusions.end() )
+ if( bds.m_DrcExclusions.find( temp.SerializeToString() ) == bds.m_DrcExclusions.end() )
violations.push_back( *aItem );
} );
diff --git a/qa/tests/pcbnew/drc/test_drc_copper_graphics.cpp b/qa/tests/pcbnew/drc/test_drc_copper_graphics.cpp
index 8da5fd15e0..d0464bac08 100644
--- a/qa/tests/pcbnew/drc/test_drc_copper_graphics.cpp
+++ b/qa/tests/pcbnew/drc/test_drc_copper_graphics.cpp
@@ -65,7 +65,7 @@ BOOST_FIXTURE_TEST_CASE( DRCCopperGraphicsTest, DRC_COPPER_GRAPHICS_TEST_FIXTURE
{
PCB_MARKER temp( aItem, aPos );
- if( bds.m_DrcExclusions.find( temp.Serialize() ) == bds.m_DrcExclusions.end() )
+ if( bds.m_DrcExclusions.find( temp.SerializeToString() ) == bds.m_DrcExclusions.end() )
violations.push_back( *aItem );
} );
diff --git a/qa/tests/pcbnew/drc/test_drc_regressions.cpp b/qa/tests/pcbnew/drc/test_drc_regressions.cpp
index ac3d8a7acf..041923c569 100644
--- a/qa/tests/pcbnew/drc/test_drc_regressions.cpp
+++ b/qa/tests/pcbnew/drc/test_drc_regressions.cpp
@@ -161,7 +161,7 @@ BOOST_FIXTURE_TEST_CASE( DRCFalseNegativeRegressions, DRC_REGRESSION_TEST_FIXTUR
{
PCB_MARKER temp( aItem, aPos );
- if( bds.m_DrcExclusions.find( temp.Serialize() ) == bds.m_DrcExclusions.end() )
+ if( bds.m_DrcExclusions.find( temp.SerializeToString() ) == bds.m_DrcExclusions.end() )
violations.push_back( *aItem );
} );
diff --git a/qa/tests/pcbnew/drc/test_solder_mask_bridging.cpp b/qa/tests/pcbnew/drc/test_solder_mask_bridging.cpp
index f6bf1794ad..c12d8b7315 100644
--- a/qa/tests/pcbnew/drc/test_solder_mask_bridging.cpp
+++ b/qa/tests/pcbnew/drc/test_solder_mask_bridging.cpp
@@ -62,7 +62,7 @@ BOOST_FIXTURE_TEST_CASE( DRCSolderMaskBridgingTest, DRC_SOLDER_MASK_BRIDGING_TES
{
PCB_MARKER temp( aItem, aPos );
- if( bds.m_DrcExclusions.find( temp.Serialize() ) == bds.m_DrcExclusions.end() )
+ if( bds.m_DrcExclusions.find( temp.SerializeToString() ) == bds.m_DrcExclusions.end() )
violations.push_back( *aItem );
} );
diff --git a/scripting/CMakeLists.txt b/scripting/CMakeLists.txt
index 5ec2face6b..719208225a 100644
--- a/scripting/CMakeLists.txt
+++ b/scripting/CMakeLists.txt
@@ -1,5 +1,6 @@
set( KIPYTHON_SRCS
kipython_settings.cpp
+ python_manager.cpp
)
add_library( scripting STATIC
diff --git a/scripting/python_manager.cpp b/scripting/python_manager.cpp
new file mode 100644
index 0000000000..d0b318a6b1
--- /dev/null
+++ b/scripting/python_manager.cpp
@@ -0,0 +1,73 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2023 Jon Evans <jon@craftyjon.com>
+ * Copyright (C) 2023 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <wx/process.h>
+
+#include <utility>
+
+#include "python_manager.h"
+
+class PYTHON_PROCESS : public wxProcess
+{
+public:
+ PYTHON_PROCESS( std::function<void(int, const wxString&)> aCallback ) :
+ wxProcess(),
+ m_callback( std::move( aCallback ) )
+ {}
+
+ void OnTerminate( int aPid, int aStatus ) override
+ {
+ if( m_callback )
+ {
+ wxString output;
+ wxInputStream* processOut = GetInputStream();
+ size_t bytesRead = 0;
+
+ while( processOut->CanRead() && bytesRead < MAX_OUTPUT_LEN )
+ {
+ char buffer[4096];
+ buffer[ processOut->Read( buffer, sizeof( buffer ) - 1 ).LastRead() ] = '\0';
+ output.append( buffer, sizeof( buffer ) );
+ bytesRead += processOut->LastRead();
+ }
+
+ m_callback( aStatus, output );
+ }
+ }
+
+ static constexpr size_t MAX_OUTPUT_LEN = 1024L * 1024L;
+
+private:
+ std::function<void(int, const wxString&)> m_callback;
+};
+
+
+void PYTHON_MANAGER::Execute( const wxString& aArgs,
+ const std::function<void( int, const wxString& )>& aCallback )
+{
+ PYTHON_PROCESS* process = new PYTHON_PROCESS( aCallback );
+ process->Redirect();
+
+ wxString cmd = wxString::Format( wxS( "%s %s" ), m_interpreterPath, aArgs );
+ long pid = wxExecute( cmd, wxEXEC_ASYNC, process );
+
+ if( pid == 0 )
+ aCallback( -1, wxEmptyString );
+}
diff --git a/scripting/python_manager.h b/scripting/python_manager.h
new file mode 100644
index 0000000000..d8a4fb5d47
--- /dev/null
+++ b/scripting/python_manager.h
@@ -0,0 +1,48 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2023 Jon Evans <jon@craftyjon.com>
+ * Copyright (C) 2023 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef KICAD_PYTHON_MANAGER_H
+#define KICAD_PYTHON_MANAGER_H
+
+#include <functional>
+#include <optional>
+
+#include <wx/wx.h>
+
+
+class PYTHON_MANAGER
+{
+public:
+ PYTHON_MANAGER( const wxString& aInterpreterPath ) :
+ m_interpreterPath( aInterpreterPath )
+ {}
+
+ void Execute( const wxString& aArgs,
+ const std::function<void(int, const wxString&)>& aCallback );
+
+ wxString GetInterpreterPath() const { return m_interpreterPath; }
+ void SetInterpreterPath( const wxString& aPath ) { m_interpreterPath = aPath; }
+
+private:
+ wxString m_interpreterPath;
+};
+
+
+#endif //KICAD_PYTHON_MANAGER_H
diff --git a/thirdparty/CMakeLists.txt b/thirdparty/CMakeLists.txt
index 289fabdf97..138f3c9dc8 100644
--- a/thirdparty/CMakeLists.txt
+++ b/thirdparty/CMakeLists.txt
@@ -39,6 +39,7 @@ add_subdirectory( clipper2 )
add_subdirectory( compoundfilereader )
add_subdirectory( delaunator )
add_subdirectory( dxflib_qcad )
+add_subdirectory( expected )
set( FMT_INSTALL OFF )
add_subdirectory( fmt )
add_subdirectory( gzip-hpp )
diff --git a/thirdparty/expected/CMakeLists.txt b/thirdparty/expected/CMakeLists.txt
new file mode 100644
index 0000000000..9251ef71fd
--- /dev/null
+++ b/thirdparty/expected/CMakeLists.txt
@@ -0,0 +1,7 @@
+add_library( expected INTERFACE )
+
+target_include_directories( expected INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include )
+
+target_sources( expected INTERFACE
+ ${CMAKE_CURRENT_SOURCE_DIR}/include/tl/expected.hpp
+ )
diff --git a/thirdparty/expected/COPYING b/thirdparty/expected/COPYING
new file mode 100644
index 0000000000..0e259d42c9
--- /dev/null
+++ b/thirdparty/expected/COPYING
@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+ CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+ LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+ ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+ INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+ REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+ PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+ THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+ HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+ i. the right to reproduce, adapt, distribute, perform, display,
+ communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+ likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+ subject to the limitations in paragraph 4(a), below;
+ v. rights protecting the extraction, dissemination, use and reuse of data
+ in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+ European Parliament and of the Council of 11 March 1996 on the legal
+ protection of databases, and under any national implementation
+ thereof, including any amended or successor version of such
+ directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+ world based on applicable law or treaty, and any national
+ implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+ surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+ warranties of any kind concerning the Work, express, implied,
+ statutory or otherwise, including without limitation warranties of
+ title, merchantability, fitness for a particular purpose, non
+ infringement, or the absence of latent or other defects, accuracy, or
+ the present or absence of errors, whether or not discoverable, all to
+ the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+ that may apply to the Work or any use thereof, including without
+ limitation any person's Copyright and Related Rights in the Work.
+ Further, Affirmer disclaims responsibility for obtaining any necessary
+ consents, permissions or other rights required for any use of the
+ Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+ party to this document and has no duty or obligation with respect to
+ this CC0 or use of the Work.
diff --git a/thirdparty/expected/README.txt b/thirdparty/expected/README.txt
new file mode 100644
index 0000000000..cf3ce8186f
--- /dev/null
+++ b/thirdparty/expected/README.txt
@@ -0,0 +1,4 @@
+This directory contains the expected library from https://github.com/TartanLlama/expected
+
+It is licensed under CC0-1.0, with the license text in the COPYING file in this directory.
+
diff --git a/thirdparty/expected/include/tl/expected.hpp b/thirdparty/expected/include/tl/expected.hpp
new file mode 100644
index 0000000000..afee404d43
--- /dev/null
+++ b/thirdparty/expected/include/tl/expected.hpp
@@ -0,0 +1,2444 @@
+///
+// expected - An implementation of std::expected with extensions
+// Written in 2017 by Sy Brand (tartanllama@gmail.com, @TartanLlama)
+//
+// Documentation available at http://tl.tartanllama.xyz/
+//
+// To the extent possible under law, the author(s) have dedicated all
+// copyright and related and neighboring rights to this software to the
+// public domain worldwide. This software is distributed without any warranty.
+//
+// You should have received a copy of the CC0 Public Domain Dedication
+// along with this software. If not, see
+// <http://creativecommons.org/publicdomain/zero/1.0/>.
+///
+
+#ifndef TL_EXPECTED_HPP
+#define TL_EXPECTED_HPP
+
+#define TL_EXPECTED_VERSION_MAJOR 1
+#define TL_EXPECTED_VERSION_MINOR 1
+#define TL_EXPECTED_VERSION_PATCH 0
+
+#include <exception>
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+#if defined(__EXCEPTIONS) || defined(_CPPUNWIND)
+#define TL_EXPECTED_EXCEPTIONS_ENABLED
+#endif
+
+#if (defined(_MSC_VER) && _MSC_VER == 1900)
+#define TL_EXPECTED_MSVC2015
+#define TL_EXPECTED_MSVC2015_CONSTEXPR
+#else
+#define TL_EXPECTED_MSVC2015_CONSTEXPR constexpr
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && \
+ !defined(__clang__))
+#define TL_EXPECTED_GCC49
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 4 && \
+ !defined(__clang__))
+#define TL_EXPECTED_GCC54
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 5 && \
+ !defined(__clang__))
+#define TL_EXPECTED_GCC55
+#endif
+
+#if !defined(TL_ASSERT)
+//can't have assert in constexpr in C++11 and GCC 4.9 has a compiler bug
+#if (__cplusplus > 201103L) && !defined(TL_EXPECTED_GCC49)
+#include <cassert>
+#define TL_ASSERT(x) assert(x)
+#else
+#define TL_ASSERT(x)
+#endif
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && \
+ !defined(__clang__))
+// GCC < 5 doesn't support overloading on const&& for member functions
+
+#define TL_EXPECTED_NO_CONSTRR
+// GCC < 5 doesn't support some standard C++11 type traits
+#define TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \
+ std::has_trivial_copy_constructor<T>
+#define TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \
+ std::has_trivial_copy_assign<T>
+
+// This one will be different for GCC 5.7 if it's ever supported
+#define TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T) \
+ std::is_trivially_destructible<T>
+
+// GCC 5 < v < 8 has a bug in is_trivially_copy_constructible which breaks
+// std::vector for non-copyable types
+#elif (defined(__GNUC__) && __GNUC__ < 8 && !defined(__clang__))
+#ifndef TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
+#define TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
+namespace tl {
+namespace detail {
+template <class T>
+struct is_trivially_copy_constructible
+ : std::is_trivially_copy_constructible<T> {};
+#ifdef _GLIBCXX_VECTOR
+template <class T, class A>
+struct is_trivially_copy_constructible<std::vector<T, A>> : std::false_type {};
+#endif
+} // namespace detail
+} // namespace tl
+#endif
+
+#define TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \
+ tl::detail::is_trivially_copy_constructible<T>
+#define TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \
+ std::is_trivially_copy_assignable<T>
+#define TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T) \
+ std::is_trivially_destructible<T>
+#else
+#define TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) \
+ std::is_trivially_copy_constructible<T>
+#define TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T) \
+ std::is_trivially_copy_assignable<T>
+#define TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T) \
+ std::is_trivially_destructible<T>
+#endif
+
+#if __cplusplus > 201103L
+#define TL_EXPECTED_CXX14
+#endif
+
+#ifdef TL_EXPECTED_GCC49
+#define TL_EXPECTED_GCC49_CONSTEXPR
+#else
+#define TL_EXPECTED_GCC49_CONSTEXPR constexpr
+#endif
+
+#if (__cplusplus == 201103L || defined(TL_EXPECTED_MSVC2015) || \
+ defined(TL_EXPECTED_GCC49))
+#define TL_EXPECTED_11_CONSTEXPR
+#else
+#define TL_EXPECTED_11_CONSTEXPR constexpr
+#endif
+
+namespace tl {
+template <class T, class E> class expected;
+
+#ifndef TL_MONOSTATE_INPLACE_MUTEX
+#define TL_MONOSTATE_INPLACE_MUTEX
+class monostate {};
+
+struct in_place_t {
+ explicit in_place_t() = default;
+};
+static constexpr in_place_t in_place{};
+#endif
+
+template <class E> class unexpected {
+public:
+ static_assert(!std::is_same<E, void>::value, "E must not be void");
+
+ unexpected() = delete;
+ constexpr explicit unexpected(const E &e) : m_val(e) {}
+
+ constexpr explicit unexpected(E &&e) : m_val(std::move(e)) {}
+
+ template <class... Args, typename std::enable_if<std::is_constructible<
+ E, Args &&...>::value>::type * = nullptr>
+ constexpr explicit unexpected(Args &&...args)
+ : m_val(std::forward<Args>(args)...) {}
+ template <
+ class U, class... Args,
+ typename std::enable_if<std::is_constructible<
+ E, std::initializer_list<U> &, Args &&...>::value>::type * = nullptr>
+ constexpr explicit unexpected(std::initializer_list<U> l, Args &&...args)
+ : m_val(l, std::forward<Args>(args)...) {}
+
+ constexpr const E &value() const & { return m_val; }
+ TL_EXPECTED_11_CONSTEXPR E &value() & { return m_val; }
+ TL_EXPECTED_11_CONSTEXPR E &&value() && { return std::move(m_val); }
+ constexpr const E &&value() const && { return std::move(m_val); }
+
+private:
+ E m_val;
+};
+
+#ifdef __cpp_deduction_guides
+template <class E> unexpected(E) -> unexpected<E>;
+#endif
+
+template <class E>
+constexpr bool operator==(const unexpected<E> &lhs, const unexpected<E> &rhs) {
+ return lhs.value() == rhs.value();
+}
+template <class E>
+constexpr bool operator!=(const unexpected<E> &lhs, const unexpected<E> &rhs) {
+ return lhs.value() != rhs.value();
+}
+template <class E>
+constexpr bool operator<(const unexpected<E> &lhs, const unexpected<E> &rhs) {
+ return lhs.value() < rhs.value();
+}
+template <class E>
+constexpr bool operator<=(const unexpected<E> &lhs, const unexpected<E> &rhs) {
+ return lhs.value() <= rhs.value();
+}
+template <class E>
+constexpr bool operator>(const unexpected<E> &lhs, const unexpected<E> &rhs) {
+ return lhs.value() > rhs.value();
+}
+template <class E>
+constexpr bool operator>=(const unexpected<E> &lhs, const unexpected<E> &rhs) {
+ return lhs.value() >= rhs.value();
+}
+
+template <class E>
+unexpected<typename std::decay<E>::type> make_unexpected(E &&e) {
+ return unexpected<typename std::decay<E>::type>(std::forward<E>(e));
+}
+
+struct unexpect_t {
+ unexpect_t() = default;
+};
+static constexpr unexpect_t unexpect{};
+
+namespace detail {
+template <typename E>
+[[noreturn]] TL_EXPECTED_11_CONSTEXPR void throw_exception(E &&e) {
+#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
+ throw std::forward<E>(e);
+#else
+ (void)e;
+#ifdef _MSC_VER
+ __assume(0);
+#else
+ __builtin_unreachable();
+#endif
+#endif
+}
+
+#ifndef TL_TRAITS_MUTEX
+#define TL_TRAITS_MUTEX
+// C++14-style aliases for brevity
+template <class T> using remove_const_t = typename std::remove_const<T>::type;
+template <class T>
+using remove_reference_t = typename std::remove_reference<T>::type;
+template <class T> using decay_t = typename std::decay<T>::type;
+template <bool E, class T = void>
+using enable_if_t = typename std::enable_if<E, T>::type;
+template <bool B, class T, class F>
+using conditional_t = typename std::conditional<B, T, F>::type;
+
+// std::conjunction from C++17
+template <class...> struct conjunction : std::true_type {};
+template <class B> struct conjunction<B> : B {};
+template <class B, class... Bs>
+struct conjunction<B, Bs...>
+ : std::conditional<bool(B::value), conjunction<Bs...>, B>::type {};
+
+#if defined(_LIBCPP_VERSION) && __cplusplus == 201103L
+#define TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND
+#endif
+
+// In C++11 mode, there's an issue in libc++'s std::mem_fn
+// which results in a hard-error when using it in a noexcept expression
+// in some cases. This is a check to workaround the common failing case.
+#ifdef TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND
+template <class T>
+struct is_pointer_to_non_const_member_func : std::false_type {};
+template <class T, class Ret, class... Args>
+struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...)>
+ : std::true_type {};
+template <class T, class Ret, class... Args>
+struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) &>
+ : std::true_type {};
+template <class T, class Ret, class... Args>
+struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) &&>
+ : std::true_type {};
+template <class T, class Ret, class... Args>
+struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile>
+ : std::true_type {};
+template <class T, class Ret, class... Args>
+struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile &>
+ : std::true_type {};
+template <class T, class Ret, class... Args>
+struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile &&>
+ : std::true_type {};
+
+template <class T> struct is_const_or_const_ref : std::false_type {};
+template <class T> struct is_const_or_const_ref<T const &> : std::true_type {};
+template <class T> struct is_const_or_const_ref<T const> : std::true_type {};
+#endif
+
+// std::invoke from C++17
+// https://stackoverflow.com/questions/38288042/c11-14-invoke-workaround
+template <
+ typename Fn, typename... Args,
+#ifdef TL_TRAITS_LIBCXX_MEM_FN_WORKAROUND
+ typename = enable_if_t<!(is_pointer_to_non_const_member_func<Fn>::value &&
+ is_const_or_const_ref<Args...>::value)>,
+#endif
+ typename = enable_if_t<std::is_member_pointer<decay_t<Fn>>::value>, int = 0>
+constexpr auto invoke(Fn &&f, Args &&...args) noexcept(
+ noexcept(std::mem_fn(f)(std::forward<Args>(args)...)))
+ -> decltype(std::mem_fn(f)(std::forward<Args>(args)...)) {
+ return std::mem_fn(f)(std::forward<Args>(args)...);
+}
+
+template <typename Fn, typename... Args,
+ typename = enable_if_t<!std::is_member_pointer<decay_t<Fn>>::value>>
+constexpr auto invoke(Fn &&f, Args &&...args) noexcept(
+ noexcept(std::forward<Fn>(f)(std::forward<Args>(args)...)))
+ -> decltype(std::forward<Fn>(f)(std::forward<Args>(args)...)) {
+ return std::forward<Fn>(f)(std::forward<Args>(args)...);
+}
+
+// std::invoke_result from C++17
+template <class F, class, class... Us> struct invoke_result_impl;
+
+template <class F, class... Us>
+struct invoke_result_impl<
+ F,
+ decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...), void()),
+ Us...> {
+ using type =
+ decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...));
+};
+
+template <class F, class... Us>
+using invoke_result = invoke_result_impl<F, void, Us...>;
+
+template <class F, class... Us>
+using invoke_result_t = typename invoke_result<F, Us...>::type;
+
+#if defined(_MSC_VER) && _MSC_VER <= 1900
+// TODO make a version which works with MSVC 2015
+template <class T, class U = T> struct is_swappable : std::true_type {};
+
+template <class T, class U = T> struct is_nothrow_swappable : std::true_type {};
+#else
+// https://stackoverflow.com/questions/26744589/what-is-a-proper-way-to-implement-is-swappable-to-test-for-the-swappable-concept
+namespace swap_adl_tests {
+// if swap ADL finds this then it would call std::swap otherwise (same
+// signature)
+struct tag {};
+
+template <class T> tag swap(T &, T &);
+template <class T, std::size_t N> tag swap(T (&a)[N], T (&b)[N]);
+
+// helper functions to test if an unqualified swap is possible, and if it
+// becomes std::swap
+template <class, class> std::false_type can_swap(...) noexcept(false);
+template <class T, class U,
+ class = decltype(swap(std::declval<T &>(), std::declval<U &>()))>
+std::true_type can_swap(int) noexcept(noexcept(swap(std::declval<T &>(),
+ std::declval<U &>())));
+
+template <class, class> std::false_type uses_std(...);
+template <class T, class U>
+std::is_same<decltype(swap(std::declval<T &>(), std::declval<U &>())), tag>
+uses_std(int);
+
+template <class T>
+struct is_std_swap_noexcept
+ : std::integral_constant<bool,
+ std::is_nothrow_move_constructible<T>::value &&
+ std::is_nothrow_move_assignable<T>::value> {};
+
+template <class T, std::size_t N>
+struct is_std_swap_noexcept<T[N]> : is_std_swap_noexcept<T> {};
+
+template <class T, class U>
+struct is_adl_swap_noexcept
+ : std::integral_constant<bool, noexcept(can_swap<T, U>(0))> {};
+} // namespace swap_adl_tests
+
+template <class T, class U = T>
+struct is_swappable
+ : std::integral_constant<
+ bool,
+ decltype(detail::swap_adl_tests::can_swap<T, U>(0))::value &&
+ (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value ||
+ (std::is_move_assignable<T>::value &&
+ std::is_move_constructible<T>::value))> {};
+
+template <class T, std::size_t N>
+struct is_swappable<T[N], T[N]>
+ : std::integral_constant<
+ bool,
+ decltype(detail::swap_adl_tests::can_swap<T[N], T[N]>(0))::value &&
+ (!decltype(detail::swap_adl_tests::uses_std<T[N], T[N]>(
+ 0))::value ||
+ is_swappable<T, T>::value)> {};
+
+template <class T, class U = T>
+struct is_nothrow_swappable
+ : std::integral_constant<
+ bool,
+ is_swappable<T, U>::value &&
+ ((decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value &&
+ detail::swap_adl_tests::is_std_swap_noexcept<T>::value) ||
+ (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value &&
+ detail::swap_adl_tests::is_adl_swap_noexcept<T, U>::value))> {};
+#endif
+#endif
+
+// Trait for checking if a type is a tl::expected
+template <class T> struct is_expected_impl : std::false_type {};
+template <class T, class E>
+struct is_expected_impl<expected<T, E>> : std::true_type {};
+template <class T> using is_expected = is_expected_impl<decay_t<T>>;
+
+template <class T, class E, class U>
+using expected_enable_forward_value = detail::enable_if_t<
+ std::is_constructible<T, U &&>::value &&
+ !std::is_same<detail::decay_t<U>, in_place_t>::value &&
+ !std::is_same<expected<T, E>, detail::decay_t<U>>::value &&
+ !std::is_same<unexpected<E>, detail::decay_t<U>>::value>;
+
+template <class T, class E, class U, class G, class UR, class GR>
+using expected_enable_from_other = detail::enable_if_t<
+ std::is_constructible<T, UR>::value &&
+ std::is_constructible<E, GR>::value &&
+ !std::is_constructible<T, expected<U, G> &>::value &&
+ !std::is_constructible<T, expected<U, G> &&>::value &&
+ !std::is_constructible<T, const expected<U, G> &>::value &&
+ !std::is_constructible<T, const expected<U, G> &&>::value &&
+ !std::is_convertible<expected<U, G> &, T>::value &&
+ !std::is_convertible<expected<U, G> &&, T>::value &&
+ !std::is_convertible<const expected<U, G> &, T>::value &&
+ !std::is_convertible<const expected<U, G> &&, T>::value>;
+
+template <class T, class U>
+using is_void_or = conditional_t<std::is_void<T>::value, std::true_type, U>;
+
+template <class T>
+using is_copy_constructible_or_void =
+ is_void_or<T, std::is_copy_constructible<T>>;
+
+template <class T>
+using is_move_constructible_or_void =
+ is_void_or<T, std::is_move_constructible<T>>;
+
+template <class T>
+using is_copy_assignable_or_void = is_void_or<T, std::is_copy_assignable<T>>;
+
+template <class T>
+using is_move_assignable_or_void = is_void_or<T, std::is_move_assignable<T>>;
+
+} // namespace detail
+
+namespace detail {
+struct no_init_t {};
+static constexpr no_init_t no_init{};
+
+// Implements the storage of the values, and ensures that the destructor is
+// trivial if it can be.
+//
+// This specialization is for where neither `T` or `E` is trivially
+// destructible, so the destructors must be called on destruction of the
+// `expected`
+template <class T, class E, bool = std::is_trivially_destructible<T>::value,
+ bool = std::is_trivially_destructible<E>::value>
+struct expected_storage_base {
+ constexpr expected_storage_base() : m_val(T{}), m_has_val(true) {}
+ constexpr expected_storage_base(no_init_t) : m_no_init(), m_has_val(false) {}
+
+ template <class... Args,
+ detail::enable_if_t<std::is_constructible<T, Args &&...>::value> * =
+ nullptr>
+ constexpr expected_storage_base(in_place_t, Args &&...args)
+ : m_val(std::forward<Args>(args)...), m_has_val(true) {}
+
+ template <class U, class... Args,
+ detail::enable_if_t<std::is_constructible<
+ T, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
+ constexpr expected_storage_base(in_place_t, std::initializer_list<U> il,
+ Args &&...args)
+ : m_val(il, std::forward<Args>(args)...), m_has_val(true) {}
+ template <class... Args,
+ detail::enable_if_t<std::is_constructible<E, Args &&...>::value> * =
+ nullptr>
+ constexpr explicit expected_storage_base(unexpect_t, Args &&...args)
+ : m_unexpect(std::forward<Args>(args)...), m_has_val(false) {}
+
+ template <class U, class... Args,
+ detail::enable_if_t<std::is_constructible<
+ E, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
+ constexpr explicit expected_storage_base(unexpect_t,
+ std::initializer_list<U> il,
+ Args &&...args)
+ : m_unexpect(il, std::forward<Args>(args)...), m_has_val(false) {}
+
+ ~expected_storage_base() {
+ if (m_has_val) {
+ m_val.~T();
+ } else {
+ m_unexpect.~unexpected<E>();
+ }
+ }
+ union {
+ T m_val;
+ unexpected<E> m_unexpect;
+ char m_no_init;
+ };
+ bool m_has_val;
+};
+
+// This specialization is for when both `T` and `E` are trivially-destructible,
+// so the destructor of the `expected` can be trivial.
+template <class T, class E> struct expected_storage_base<T, E, true, true> {
+ constexpr expected_storage_base() : m_val(T{}), m_has_val(true) {}
+ constexpr expected_storage_base(no_init_t) : m_no_init(), m_has_val(false) {}
+
+ template <class... Args,
+ detail::enable_if_t<std::is_constructible<T, Args &&...>::value> * =
+ nullptr>
+ constexpr expected_storage_base(in_place_t, Args &&...args)
+ : m_val(std::forward<Args>(args)...), m_has_val(true) {}
+
+ template <class U, class... Args,
+ detail::enable_if_t<std::is_constructible<
+ T, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
+ constexpr expected_storage_base(in_place_t, std::initializer_list<U> il,
+ Args &&...args)
+ : m_val(il, std::forward<Args>(args)...), m_has_val(true) {}
+ template <class... Args,
+ detail::enable_if_t<std::is_constructible<E, Args &&...>::value> * =
+ nullptr>
+ constexpr explicit expected_storage_base(unexpect_t, Args &&...args)
+ : m_unexpect(std::forward<Args>(args)...), m_has_val(false) {}
+
+ template <class U, class... Args,
+ detail::enable_if_t<std::is_constructible<
+ E, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
+ constexpr explicit expected_storage_base(unexpect_t,
+ std::initializer_list<U> il,
+ Args &&...args)
+ : m_unexpect(il, std::forward<Args>(args)...), m_has_val(false) {}
+
+ ~expected_storage_base() = default;
+ union {
+ T m_val;
+ unexpected<E> m_unexpect;
+ char m_no_init;
+ };
+ bool m_has_val;
+};
+
+// T is trivial, E is not.
+template <class T, class E> struct expected_storage_base<T, E, true, false> {
+ constexpr expected_storage_base() : m_val(T{}), m_has_val(true) {}
+ TL_EXPECTED_MSVC2015_CONSTEXPR expected_storage_base(no_init_t)
+ : m_no_init(), m_has_val(false) {}
+
+ template <class... Args,
+ detail::enable_if_t<std::is_constructible<T, Args &&...>::value> * =
+ nullptr>
+ constexpr expected_storage_base(in_place_t, Args &&...args)
+ : m_val(std::forward<Args>(args)...), m_has_val(true) {}
+
+ template <class U, class... Args,
+ detail::enable_if_t<std::is_constructible<
+ T, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
+ constexpr expected_storage_base(in_place_t, std::initializer_list<U> il,
+ Args &&...args)
+ : m_val(il, std::forward<Args>(args)...), m_has_val(true) {}
+ template <class... Args,
+ detail::enable_if_t<std::is_constructible<E, Args &&...>::value> * =
+ nullptr>
+ constexpr explicit expected_storage_base(unexpect_t, Args &&...args)
+ : m_unexpect(std::forward<Args>(args)...), m_has_val(false) {}
+
+ template <class U, class... Args,
+ detail::enable_if_t<std::is_constructible<
+ E, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
+ constexpr explicit expected_storage_base(unexpect_t,
+ std::initializer_list<U> il,
+ Args &&...args)
+ : m_unexpect(il, std::forward<Args>(args)...), m_has_val(false) {}
+
+ ~expected_storage_base() {
+ if (!m_has_val) {
+ m_unexpect.~unexpected<E>();
+ }
+ }
+
+ union {
+ T m_val;
+ unexpected<E> m_unexpect;
+ char m_no_init;
+ };
+ bool m_has_val;
+};
+
+// E is trivial, T is not.
+template <class T, class E> struct expected_storage_base<T, E, false, true> {
+ constexpr expected_storage_base() : m_val(T{}), m_has_val(true) {}
+ constexpr expected_storage_base(no_init_t) : m_no_init(), m_has_val(false) {}
+
+ template <class... Args,
+ detail::enable_if_t<std::is_constructible<T, Args &&...>::value> * =
+ nullptr>
+ constexpr expected_storage_base(in_place_t, Args &&...args)
+ : m_val(std::forward<Args>(args)...), m_has_val(true) {}
+
+ template <class U, class... Args,
+ detail::enable_if_t<std::is_constructible<
+ T, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
+ constexpr expected_storage_base(in_place_t, std::initializer_list<U> il,
+ Args &&...args)
+ : m_val(il, std::forward<Args>(args)...), m_has_val(true) {}
+ template <class... Args,
+ detail::enable_if_t<std::is_constructible<E, Args &&...>::value> * =
+ nullptr>
+ constexpr explicit expected_storage_base(unexpect_t, Args &&...args)
+ : m_unexpect(std::forward<Args>(args)...), m_has_val(false) {}
+
+ template <class U, class... Args,
+ detail::enable_if_t<std::is_constructible<
+ E, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
+ constexpr explicit expected_storage_base(unexpect_t,
+ std::initializer_list<U> il,
+ Args &&...args)
+ : m_unexpect(il, std::forward<Args>(args)...), m_has_val(false) {}
+
+ ~expected_storage_base() {
+ if (m_has_val) {
+ m_val.~T();
+ }
+ }
+ union {
+ T m_val;
+ unexpected<E> m_unexpect;
+ char m_no_init;
+ };
+ bool m_has_val;
+};
+
+// `T` is `void`, `E` is trivially-destructible
+template <class E> struct expected_storage_base<void, E, false, true> {
+ #if __GNUC__ <= 5
+ //no constexpr for GCC 4/5 bug
+ #else
+ TL_EXPECTED_MSVC2015_CONSTEXPR
+ #endif
+ expected_storage_base() : m_has_val(true) {}
+
+ constexpr expected_storage_base(no_init_t) : m_val(), m_has_val(false) {}
+
+ constexpr expected_storage_base(in_place_t) : m_has_val(true) {}
+
+ template <class... Args,
+ detail::enable_if_t<std::is_constructible<E, Args &&...>::value> * =
+ nullptr>
+ constexpr explicit expected_storage_base(unexpect_t, Args &&...args)
+ : m_unexpect(std::forward<Args>(args)...), m_has_val(false) {}
+
+ template <class U, class... Args,
+ detail::enable_if_t<std::is_constructible<
+ E, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
+ constexpr explicit expected_storage_base(unexpect_t,
+ std::initializer_list<U> il,
+ Args &&...args)
+ : m_unexpect(il, std::forward<Args>(args)...), m_has_val(false) {}
+
+ ~expected_storage_base() = default;
+ struct dummy {};
+ union {
+ unexpected<E> m_unexpect;
+ dummy m_val;
+ };
+ bool m_has_val;
+};
+
+// `T` is `void`, `E` is not trivially-destructible
+template <class E> struct expected_storage_base<void, E, false, false> {
+ constexpr expected_storage_base() : m_dummy(), m_has_val(true) {}
+ constexpr expected_storage_base(no_init_t) : m_dummy(), m_has_val(false) {}
+
+ constexpr expected_storage_base(in_place_t) : m_dummy(), m_has_val(true) {}
+
+ template <class... Args,
+ detail::enable_if_t<std::is_constructible<E, Args &&...>::value> * =
+ nullptr>
+ constexpr explicit expected_storage_base(unexpect_t, Args &&...args)
+ : m_unexpect(std::forward<Args>(args)...), m_has_val(false) {}
+
+ template <class U, class... Args,
+ detail::enable_if_t<std::is_constructible<
+ E, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
+ constexpr explicit expected_storage_base(unexpect_t,
+ std::initializer_list<U> il,
+ Args &&...args)
+ : m_unexpect(il, std::forward<Args>(args)...), m_has_val(false) {}
+
+ ~expected_storage_base() {
+ if (!m_has_val) {
+ m_unexpect.~unexpected<E>();
+ }
+ }
+
+ union {
+ unexpected<E> m_unexpect;
+ char m_dummy;
+ };
+ bool m_has_val;
+};
+
+// This base class provides some handy member functions which can be used in
+// further derived classes
+template <class T, class E>
+struct expected_operations_base : expected_storage_base<T, E> {
+ using expected_storage_base<T, E>::expected_storage_base;
+
+ template <class... Args> void construct(Args &&...args) noexcept {
+ new (std::addressof(this->m_val)) T(std::forward<Args>(args)...);
+ this->m_has_val = true;
+ }
+
+ template <class Rhs> void construct_with(Rhs &&rhs) noexcept {
+ new (std::addressof(this->m_val)) T(std::forward<Rhs>(rhs).get());
+ this->m_has_val = true;
+ }
+
+ template <class... Args> void construct_error(Args &&...args) noexcept {
+ new (std::addressof(this->m_unexpect))
+ unexpected<E>(std::forward<Args>(args)...);
+ this->m_has_val = false;
+ }
+
+#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
+
+ // These assign overloads ensure that the most efficient assignment
+ // implementation is used while maintaining the strong exception guarantee.
+ // The problematic case is where rhs has a value, but *this does not.
+ //
+ // This overload handles the case where we can just copy-construct `T`
+ // directly into place without throwing.
+ template <class U = T,
+ detail::enable_if_t<std::is_nothrow_copy_constructible<U>::value>
+ * = nullptr>
+ void assign(const expected_operations_base &rhs) noexcept {
+ if (!this->m_has_val && rhs.m_has_val) {
+ geterr().~unexpected<E>();
+ construct(rhs.get());
+ } else {
+ assign_common(rhs);
+ }
+ }
+
+ // This overload handles the case where we can attempt to create a copy of
+ // `T`, then no-throw move it into place if the copy was successful.
+ template <class U = T,
+ detail::enable_if_t<!std::is_nothrow_copy_constructible<U>::value &&
+ std::is_nothrow_move_constructible<U>::value>
+ * = nullptr>
+ void assign(const expected_operations_base &rhs) noexcept {
+ if (!this->m_has_val && rhs.m_has_val) {
+ T tmp = rhs.get();
+ geterr().~unexpected<E>();
+ construct(std::move(tmp));
+ } else {
+ assign_common(rhs);
+ }
+ }
+
+ // This overload is the worst-case, where we have to move-construct the
+ // unexpected value into temporary storage, then try to copy the T into place.
+ // If the construction succeeds, then everything is fine, but if it throws,
+ // then we move the old unexpected value back into place before rethrowing the
+ // exception.
+ template <class U = T,
+ detail::enable_if_t<!std::is_nothrow_copy_constructible<U>::value &&
+ !std::is_nothrow_move_constructible<U>::value>
+ * = nullptr>
+ void assign(const expected_operations_base &rhs) {
+ if (!this->m_has_val && rhs.m_has_val) {
+ auto tmp = std::move(geterr());
+ geterr().~unexpected<E>();
+
+#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
+ try {
+ construct(rhs.get());
+ } catch (...) {
+ geterr() = std::move(tmp);
+ throw;
+ }
+#else
+ construct(rhs.get());
+#endif
+ } else {
+ assign_common(rhs);
+ }
+ }
+
+ // These overloads do the same as above, but for rvalues
+ template <class U = T,
+ detail::enable_if_t<std::is_nothrow_move_constructible<U>::value>
+ * = nullptr>
+ void assign(expected_operations_base &&rhs) noexcept {
+ if (!this->m_has_val && rhs.m_has_val) {
+ geterr().~unexpected<E>();
+ construct(std::move(rhs).get());
+ } else {
+ assign_common(std::move(rhs));
+ }
+ }
+
+ template <class U = T,
+ detail::enable_if_t<!std::is_nothrow_move_constructible<U>::value>
+ * = nullptr>
+ void assign(expected_operations_base &&rhs) {
+ if (!this->m_has_val && rhs.m_has_val) {
+ auto tmp = std::move(geterr());
+ geterr().~unexpected<E>();
+#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
+ try {
+ construct(std::move(rhs).get());
+ } catch (...) {
+ geterr() = std::move(tmp);
+ throw;
+ }
+#else
+ construct(std::move(rhs).get());
+#endif
+ } else {
+ assign_common(std::move(rhs));
+ }
+ }
+
+#else
+
+ // If exceptions are disabled then we can just copy-construct
+ void assign(const expected_operations_base &rhs) noexcept {
+ if (!this->m_has_val && rhs.m_has_val) {
+ geterr().~unexpected<E>();
+ construct(rhs.get());
+ } else {
+ assign_common(rhs);
+ }
+ }
+
+ void assign(expected_operations_base &&rhs) noexcept {
+ if (!this->m_has_val && rhs.m_has_val) {
+ geterr().~unexpected<E>();
+ construct(std::move(rhs).get());
+ } else {
+ assign_common(std::move(rhs));
+ }
+ }
+
+#endif
+
+ // The common part of move/copy assigning
+ template <class Rhs> void assign_common(Rhs &&rhs) {
+ if (this->m_has_val) {
+ if (rhs.m_has_val) {
+ get() = std::forward<Rhs>(rhs).get();
+ } else {
+ destroy_val();
+ construct_error(std::forward<Rhs>(rhs).geterr());
+ }
+ } else {
+ if (!rhs.m_has_val) {
+ geterr() = std::forward<Rhs>(rhs).geterr();
+ }
+ }
+ }
+
+ bool has_value() const { return this->m_has_val; }
+
+ TL_EXPECTED_11_CONSTEXPR T &get() & { return this->m_val; }
+ constexpr const T &get() const & { return this->m_val; }
+ TL_EXPECTED_11_CONSTEXPR T &&get() && { return std::move(this->m_val); }
+#ifndef TL_EXPECTED_NO_CONSTRR
+ constexpr const T &&get() const && { return std::move(this->m_val); }
+#endif
+
+ TL_EXPECTED_11_CONSTEXPR unexpected<E> &geterr() & {
+ return this->m_unexpect;
+ }
+ constexpr const unexpected<E> &geterr() const & { return this->m_unexpect; }
+ TL_EXPECTED_11_CONSTEXPR unexpected<E> &&geterr() && {
+ return std::move(this->m_unexpect);
+ }
+#ifndef TL_EXPECTED_NO_CONSTRR
+ constexpr const unexpected<E> &&geterr() const && {
+ return std::move(this->m_unexpect);
+ }
+#endif
+
+ TL_EXPECTED_11_CONSTEXPR void destroy_val() { get().~T(); }
+};
+
+// This base class provides some handy member functions which can be used in
+// further derived classes
+template <class E>
+struct expected_operations_base<void, E> : expected_storage_base<void, E> {
+ using expected_storage_base<void, E>::expected_storage_base;
+
+ template <class... Args> void construct() noexcept { this->m_has_val = true; }
+
+ // This function doesn't use its argument, but needs it so that code in
+ // levels above this can work independently of whether T is void
+ template <class Rhs> void construct_with(Rhs &&) noexcept {
+ this->m_has_val = true;
+ }
+
+ template <class... Args> void construct_error(Args &&...args) noexcept {
+ new (std::addressof(this->m_unexpect))
+ unexpected<E>(std::forward<Args>(args)...);
+ this->m_has_val = false;
+ }
+
+ template <class Rhs> void assign(Rhs &&rhs) noexcept {
+ if (!this->m_has_val) {
+ if (rhs.m_has_val) {
+ geterr().~unexpected<E>();
+ construct();
+ } else {
+ geterr() = std::forward<Rhs>(rhs).geterr();
+ }
+ } else {
+ if (!rhs.m_has_val) {
+ construct_error(std::forward<Rhs>(rhs).geterr());
+ }
+ }
+ }
+
+ bool has_value() const { return this->m_has_val; }
+
+ TL_EXPECTED_11_CONSTEXPR unexpected<E> &geterr() & {
+ return this->m_unexpect;
+ }
+ constexpr const unexpected<E> &geterr() const & { return this->m_unexpect; }
+ TL_EXPECTED_11_CONSTEXPR unexpected<E> &&geterr() && {
+ return std::move(this->m_unexpect);
+ }
+#ifndef TL_EXPECTED_NO_CONSTRR
+ constexpr const unexpected<E> &&geterr() const && {
+ return std::move(this->m_unexpect);
+ }
+#endif
+
+ TL_EXPECTED_11_CONSTEXPR void destroy_val() {
+ // no-op
+ }
+};
+
+// This class manages conditionally having a trivial copy constructor
+// This specialization is for when T and E are trivially copy constructible
+template <class T, class E,
+ bool = is_void_or<T, TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)>::
+ value &&TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(E)::value>
+struct expected_copy_base : expected_operations_base<T, E> {
+ using expected_operations_base<T, E>::expected_operations_base;
+};
+
+// This specialization is for when T or E are not trivially copy constructible
+template <class T, class E>
+struct expected_copy_base<T, E, false> : expected_operations_base<T, E> {
+ using expected_operations_base<T, E>::expected_operations_base;
+
+ expected_copy_base() = default;
+ expected_copy_base(const expected_copy_base &rhs)
+ : expected_operations_base<T, E>(no_init) {
+ if (rhs.has_value()) {
+ this->construct_with(rhs);
+ } else {
+ this->construct_error(rhs.geterr());
+ }
+ }
+
+ expected_copy_base(expected_copy_base &&rhs) = default;
+ expected_copy_base &operator=(const expected_copy_base &rhs) = default;
+ expected_copy_base &operator=(expected_copy_base &&rhs) = default;
+};
+
+// This class manages conditionally having a trivial move constructor
+// Unfortunately there's no way to achieve this in GCC < 5 AFAIK, since it
+// doesn't implement an analogue to std::is_trivially_move_constructible. We
+// have to make do with a non-trivial move constructor even if T is trivially
+// move constructible
+#ifndef TL_EXPECTED_GCC49
+template <class T, class E,
+ bool = is_void_or<T, std::is_trivially_move_constructible<T>>::value
+ &&std::is_trivially_move_constructible<E>::value>
+struct expected_move_base : expected_copy_base<T, E> {
+ using expected_copy_base<T, E>::expected_copy_base;
+};
+#else
+template <class T, class E, bool = false> struct expected_move_base;
+#endif
+template <class T, class E>
+struct expected_move_base<T, E, false> : expected_copy_base<T, E> {
+ using expected_copy_base<T, E>::expected_copy_base;
+
+ expected_move_base() = default;
+ expected_move_base(const expected_move_base &rhs) = default;
+
+ expected_move_base(expected_move_base &&rhs) noexcept(
+ std::is_nothrow_move_constructible<T>::value)
+ : expected_copy_base<T, E>(no_init) {
+ if (rhs.has_value()) {
+ this->construct_with(std::move(rhs));
+ } else {
+ this->construct_error(std::move(rhs.geterr()));
+ }
+ }
+ expected_move_base &operator=(const expected_move_base &rhs) = default;
+ expected_move_base &operator=(expected_move_base &&rhs) = default;
+};
+
+// This class manages conditionally having a trivial copy assignment operator
+template <class T, class E,
+ bool = is_void_or<
+ T, conjunction<TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(T),
+ TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T),
+ TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(T)>>::value
+ &&TL_EXPECTED_IS_TRIVIALLY_COPY_ASSIGNABLE(E)::value
+ &&TL_EXPECTED_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(E)::value
+ &&TL_EXPECTED_IS_TRIVIALLY_DESTRUCTIBLE(E)::value>
+struct expected_copy_assign_base : expected_move_base<T, E> {
+ using expected_move_base<T, E>::expected_move_base;
+};
+
+template <class T, class E>
+struct expected_copy_assign_base<T, E, false> : expected_move_base<T, E> {
+ using expected_move_base<T, E>::expected_move_base;
+
+ expected_copy_assign_base() = default;
+ expected_copy_assign_base(const expected_copy_assign_base &rhs) = default;
+
+ expected_copy_assign_base(expected_copy_assign_base &&rhs) = default;
+ expected_copy_assign_base &operator=(const expected_copy_assign_base &rhs) {
+ this->assign(rhs);
+ return *this;
+ }
+ expected_copy_assign_base &
+ operator=(expected_copy_assign_base &&rhs) = default;
+};
+
+// This class manages conditionally having a trivial move assignment operator
+// Unfortunately there's no way to achieve this in GCC < 5 AFAIK, since it
+// doesn't implement an analogue to std::is_trivially_move_assignable. We have
+// to make do with a non-trivial move assignment operator even if T is trivially
+// move assignable
+#ifndef TL_EXPECTED_GCC49
+template <class T, class E,
+ bool =
+ is_void_or<T, conjunction<std::is_trivially_destructible<T>,
+ std::is_trivially_move_constructible<T>,
+ std::is_trivially_move_assignable<T>>>::
+ value &&std::is_trivially_destructible<E>::value
+ &&std::is_trivially_move_constructible<E>::value
+ &&std::is_trivially_move_assignable<E>::value>
+struct expected_move_assign_base : expected_copy_assign_base<T, E> {
+ using expected_copy_assign_base<T, E>::expected_copy_assign_base;
+};
+#else
+template <class T, class E, bool = false> struct expected_move_assign_base;
+#endif
+
+template <class T, class E>
+struct expected_move_assign_base<T, E, false>
+ : expected_copy_assign_base<T, E> {
+ using expected_copy_assign_base<T, E>::expected_copy_assign_base;
+
+ expected_move_assign_base() = default;
+ expected_move_assign_base(const expected_move_assign_base &rhs) = default;
+
+ expected_move_assign_base(expected_move_assign_base &&rhs) = default;
+
+ expected_move_assign_base &
+ operator=(const expected_move_assign_base &rhs) = default;
+
+ expected_move_assign_base &
+ operator=(expected_move_assign_base &&rhs) noexcept(
+ std::is_nothrow_move_constructible<T>::value
+ &&std::is_nothrow_move_assignable<T>::value) {
+ this->assign(std::move(rhs));
+ return *this;
+ }
+};
+
+// expected_delete_ctor_base will conditionally delete copy and move
+// constructors depending on whether T is copy/move constructible
+template <class T, class E,
+ bool EnableCopy = (is_copy_constructible_or_void<T>::value &&
+ std::is_copy_constructible<E>::value),
+ bool EnableMove = (is_move_constructible_or_void<T>::value &&
+ std::is_move_constructible<E>::value)>
+struct expected_delete_ctor_base {
+ expected_delete_ctor_base() = default;
+ expected_delete_ctor_base(const expected_delete_ctor_base &) = default;
+ expected_delete_ctor_base(expected_delete_ctor_base &&) noexcept = default;
+ expected_delete_ctor_base &
+ operator=(const expected_delete_ctor_base &) = default;
+ expected_delete_ctor_base &
+ operator=(expected_delete_ctor_base &&) noexcept = default;
+};
+
+template <class T, class E>
+struct expected_delete_ctor_base<T, E, true, false> {
+ expected_delete_ctor_base() = default;
+ expected_delete_ctor_base(const expected_delete_ctor_base &) = default;
+ expected_delete_ctor_base(expected_delete_ctor_base &&) noexcept = delete;
+ expected_delete_ctor_base &
+ operator=(const expected_delete_ctor_base &) = default;
+ expected_delete_ctor_base &
+ operator=(expected_delete_ctor_base &&) noexcept = default;
+};
+
+template <class T, class E>
+struct expected_delete_ctor_base<T, E, false, true> {
+ expected_delete_ctor_base() = default;
+ expected_delete_ctor_base(const expected_delete_ctor_base &) = delete;
+ expected_delete_ctor_base(expected_delete_ctor_base &&) noexcept = default;
+ expected_delete_ctor_base &
+ operator=(const expected_delete_ctor_base &) = default;
+ expected_delete_ctor_base &
+ operator=(expected_delete_ctor_base &&) noexcept = default;
+};
+
+template <class T, class E>
+struct expected_delete_ctor_base<T, E, false, false> {
+ expected_delete_ctor_base() = default;
+ expected_delete_ctor_base(const expected_delete_ctor_base &) = delete;
+ expected_delete_ctor_base(expected_delete_ctor_base &&) noexcept = delete;
+ expected_delete_ctor_base &
+ operator=(const expected_delete_ctor_base &) = default;
+ expected_delete_ctor_base &
+ operator=(expected_delete_ctor_base &&) noexcept = default;
+};
+
+// expected_delete_assign_base will conditionally delete copy and move
+// constructors depending on whether T and E are copy/move constructible +
+// assignable
+template <class T, class E,
+ bool EnableCopy = (is_copy_constructible_or_void<T>::value &&
+ std::is_copy_constructible<E>::value &&
+ is_copy_assignable_or_void<T>::value &&
+ std::is_copy_assignable<E>::value),
+ bool EnableMove = (is_move_constructible_or_void<T>::value &&
+ std::is_move_constructible<E>::value &&
+ is_move_assignable_or_void<T>::value &&
+ std::is_move_assignable<E>::value)>
+struct expected_delete_assign_base {
+ expected_delete_assign_base() = default;
+ expected_delete_assign_base(const expected_delete_assign_base &) = default;
+ expected_delete_assign_base(expected_delete_assign_base &&) noexcept =
+ default;
+ expected_delete_assign_base &
+ operator=(const expected_delete_assign_base &) = default;
+ expected_delete_assign_base &
+ operator=(expected_delete_assign_base &&) noexcept = default;
+};
+
+template <class T, class E>
+struct expected_delete_assign_base<T, E, true, false> {
+ expected_delete_assign_base() = default;
+ expected_delete_assign_base(const expected_delete_assign_base &) = default;
+ expected_delete_assign_base(expected_delete_assign_base &&) noexcept =
+ default;
+ expected_delete_assign_base &
+ operator=(const expected_delete_assign_base &) = default;
+ expected_delete_assign_base &
+ operator=(expected_delete_assign_base &&) noexcept = delete;
+};
+
+template <class T, class E>
+struct expected_delete_assign_base<T, E, false, true> {
+ expected_delete_assign_base() = default;
+ expected_delete_assign_base(const expected_delete_assign_base &) = default;
+ expected_delete_assign_base(expected_delete_assign_base &&) noexcept =
+ default;
+ expected_delete_assign_base &
+ operator=(const expected_delete_assign_base &) = delete;
+ expected_delete_assign_base &
+ operator=(expected_delete_assign_base &&) noexcept = default;
+};
+
+template <class T, class E>
+struct expected_delete_assign_base<T, E, false, false> {
+ expected_delete_assign_base() = default;
+ expected_delete_assign_base(const expected_delete_assign_base &) = default;
+ expected_delete_assign_base(expected_delete_assign_base &&) noexcept =
+ default;
+ expected_delete_assign_base &
+ operator=(const expected_delete_assign_base &) = delete;
+ expected_delete_assign_base &
+ operator=(expected_delete_assign_base &&) noexcept = delete;
+};
+
+// This is needed to be able to construct the expected_default_ctor_base which
+// follows, while still conditionally deleting the default constructor.
+struct default_constructor_tag {
+ explicit constexpr default_constructor_tag() = default;
+};
+
+// expected_default_ctor_base will ensure that expected has a deleted default
+// consturctor if T is not default constructible.
+// This specialization is for when T is default constructible
+template <class T, class E,
+ bool Enable =
+ std::is_default_constructible<T>::value || std::is_void<T>::value>
+struct expected_default_ctor_base {
+ constexpr expected_default_ctor_base() noexcept = default;
+ constexpr expected_default_ctor_base(
+ expected_default_ctor_base const &) noexcept = default;
+ constexpr expected_default_ctor_base(expected_default_ctor_base &&) noexcept =
+ default;
+ expected_default_ctor_base &
+ operator=(expected_default_ctor_base const &) noexcept = default;
+ expected_default_ctor_base &
+ operator=(expected_default_ctor_base &&) noexcept = default;
+
+ constexpr explicit expected_default_ctor_base(default_constructor_tag) {}
+};
+
+// This specialization is for when T is not default constructible
+template <class T, class E> struct expected_default_ctor_base<T, E, false> {
+ constexpr expected_default_ctor_base() noexcept = delete;
+ constexpr expected_default_ctor_base(
+ expected_default_ctor_base const &) noexcept = default;
+ constexpr expected_default_ctor_base(expected_default_ctor_base &&) noexcept =
+ default;
+ expected_default_ctor_base &
+ operator=(expected_default_ctor_base const &) noexcept = default;
+ expected_default_ctor_base &
+ operator=(expected_default_ctor_base &&) noexcept = default;
+
+ constexpr explicit expected_default_ctor_base(default_constructor_tag) {}
+};
+} // namespace detail
+
+template <class E> class bad_expected_access : public std::exception {
+public:
+ explicit bad_expected_access(E e) : m_val(std::move(e)) {}
+
+ virtual const char *what() const noexcept override {
+ return "Bad expected access";
+ }
+
+ const E &error() const & { return m_val; }
+ E &error() & { return m_val; }
+ const E &&error() const && { return std::move(m_val); }
+ E &&error() && { return std::move(m_val); }
+
+private:
+ E m_val;
+};
+
+/// An `expected<T, E>` object is an object that contains the storage for
+/// another object and manages the lifetime of this contained object `T`.
+/// Alternatively it could contain the storage for another unexpected object
+/// `E`. The contained object may not be initialized after the expected object
+/// has been initialized, and may not be destroyed before the expected object
+/// has been destroyed. The initialization state of the contained object is
+/// tracked by the expected object.
+template <class T, class E>
+class expected : private detail::expected_move_assign_base<T, E>,
+ private detail::expected_delete_ctor_base<T, E>,
+ private detail::expected_delete_assign_base<T, E>,
+ private detail::expected_default_ctor_base<T, E> {
+ static_assert(!std::is_reference<T>::value, "T must not be a reference");
+ static_assert(!std::is_same<T, std::remove_cv<in_place_t>::type>::value,
+ "T must not be in_place_t");
+ static_assert(!std::is_same<T, std::remove_cv<unexpect_t>::type>::value,
+ "T must not be unexpect_t");
+ static_assert(
+ !std::is_same<T, typename std::remove_cv<unexpected<E>>::type>::value,
+ "T must not be unexpected<E>");
+ static_assert(!std::is_reference<E>::value, "E must not be a reference");
+
+ T *valptr() { return std::addressof(this->m_val); }
+ const T *valptr() const { return std::addressof(this->m_val); }
+ unexpected<E> *errptr() { return std::addressof(this->m_unexpect); }
+ const unexpected<E> *errptr() const {
+ return std::addressof(this->m_unexpect);
+ }
+
+ template <class U = T,
+ detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
+ TL_EXPECTED_11_CONSTEXPR U &val() {
+ return this->m_val;
+ }
+ TL_EXPECTED_11_CONSTEXPR unexpected<E> &err() { return this->m_unexpect; }
+
+ template <class U = T,
+ detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
+ constexpr const U &val() const {
+ return this->m_val;
+ }
+ constexpr const unexpected<E> &err() const { return this->m_unexpect; }
+
+ using impl_base = detail::expected_move_assign_base<T, E>;
+ using ctor_base = detail::expected_default_ctor_base<T, E>;
+
+public:
+ typedef T value_type;
+ typedef E error_type;
+ typedef unexpected<E> unexpected_type;
+
+#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && \
+ !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55)
+ template <class F> TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) & {
+ return and_then_impl(*this, std::forward<F>(f));
+ }
+ template <class F> TL_EXPECTED_11_CONSTEXPR auto and_then(F &&f) && {
+ return and_then_impl(std::move(*this), std::forward<F>(f));
+ }
+ template <class F> constexpr auto and_then(F &&f) const & {
+ return and_then_impl(*this, std::forward<F>(f));
+ }
+
+#ifndef TL_EXPECTED_NO_CONSTRR
+ template <class F> constexpr auto and_then(F &&f) const && {
+ return and_then_impl(std::move(*this), std::forward<F>(f));
+ }
+#endif
+
+#else
+ template <class F>
+ TL_EXPECTED_11_CONSTEXPR auto
+ and_then(F &&f) & -> decltype(and_then_impl(std::declval<expected &>(),
+ std::forward<F>(f))) {
+ return and_then_impl(*this, std::forward<F>(f));
+ }
+ template <class F>
+ TL_EXPECTED_11_CONSTEXPR auto
+ and_then(F &&f) && -> decltype(and_then_impl(std::declval<expected &&>(),
+ std::forward<F>(f))) {
+ return and_then_impl(std::move(*this), std::forward<F>(f));
+ }
+ template <class F>
+ constexpr auto and_then(F &&f) const & -> decltype(and_then_impl(
+ std::declval<expected const &>(), std::forward<F>(f))) {
+ return and_then_impl(*this, std::forward<F>(f));
+ }
+
+#ifndef TL_EXPECTED_NO_CONSTRR
+ template <class F>
+ constexpr auto and_then(F &&f) const && -> decltype(and_then_impl(
+ std::declval<expected const &&>(), std::forward<F>(f))) {
+ return and_then_impl(std::move(*this), std::forward<F>(f));
+ }
+#endif
+#endif
+
+#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && \
+ !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55)
+ template <class F> TL_EXPECTED_11_CONSTEXPR auto map(F &&f) & {
+ return expected_map_impl(*this, std::forward<F>(f));
+ }
+ template <class F> TL_EXPECTED_11_CONSTEXPR auto map(F &&f) && {
+ return expected_map_impl(std::move(*this), std::forward<F>(f));
+ }
+ template <class F> constexpr auto map(F &&f) const & {
+ return expected_map_impl(*this, std::forward<F>(f));
+ }
+ template <class F> constexpr auto map(F &&f) const && {
+ return expected_map_impl(std::move(*this), std::forward<F>(f));
+ }
+#else
+ template <class F>
+ TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(
+ std::declval<expected &>(), std::declval<F &&>()))
+ map(F &&f) & {
+ return expected_map_impl(*this, std::forward<F>(f));
+ }
+ template <class F>
+ TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(std::declval<expected>(),
+ std::declval<F &&>()))
+ map(F &&f) && {
+ return expected_map_impl(std::move(*this), std::forward<F>(f));
+ }
+ template <class F>
+ constexpr decltype(expected_map_impl(std::declval<const expected &>(),
+ std::declval<F &&>()))
+ map(F &&f) const & {
+ return expected_map_impl(*this, std::forward<F>(f));
+ }
+
+#ifndef TL_EXPECTED_NO_CONSTRR
+ template <class F>
+ constexpr decltype(expected_map_impl(std::declval<const expected &&>(),
+ std::declval<F &&>()))
+ map(F &&f) const && {
+ return expected_map_impl(std::move(*this), std::forward<F>(f));
+ }
+#endif
+#endif
+
+#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && \
+ !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55)
+ template <class F> TL_EXPECTED_11_CONSTEXPR auto transform(F &&f) & {
+ return expected_map_impl(*this, std::forward<F>(f));
+ }
+ template <class F> TL_EXPECTED_11_CONSTEXPR auto transform(F &&f) && {
+ return expected_map_impl(std::move(*this), std::forward<F>(f));
+ }
+ template <class F> constexpr auto transform(F &&f) const & {
+ return expected_map_impl(*this, std::forward<F>(f));
+ }
+ template <class F> constexpr auto transform(F &&f) const && {
+ return expected_map_impl(std::move(*this), std::forward<F>(f));
+ }
+#else
+ template <class F>
+ TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(
+ std::declval<expected &>(), std::declval<F &&>()))
+ transform(F &&f) & {
+ return expected_map_impl(*this, std::forward<F>(f));
+ }
+ template <class F>
+ TL_EXPECTED_11_CONSTEXPR decltype(expected_map_impl(std::declval<expected>(),
+ std::declval<F &&>()))
+ transform(F &&f) && {
+ return expected_map_impl(std::move(*this), std::forward<F>(f));
+ }
+ template <class F>
+ constexpr decltype(expected_map_impl(std::declval<const expected &>(),
+ std::declval<F &&>()))
+ transform(F &&f) const & {
+ return expected_map_impl(*this, std::forward<F>(f));
+ }
+
+#ifndef TL_EXPECTED_NO_CONSTRR
+ template <class F>
+ constexpr decltype(expected_map_impl(std::declval<const expected &&>(),
+ std::declval<F &&>()))
+ transform(F &&f) const && {
+ return expected_map_impl(std::move(*this), std::forward<F>(f));
+ }
+#endif
+#endif
+
+#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && \
+ !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55)
+ template <class F> TL_EXPECTED_11_CONSTEXPR auto map_error(F &&f) & {
+ return map_error_impl(*this, std::forward<F>(f));
+ }
+ template <class F> TL_EXPECTED_11_CONSTEXPR auto map_error(F &&f) && {
+ return map_error_impl(std::move(*this), std::forward<F>(f));
+ }
+ template <class F> constexpr auto map_error(F &&f) const & {
+ return map_error_impl(*this, std::forward<F>(f));
+ }
+ template <class F> constexpr auto map_error(F &&f) const && {
+ return map_error_impl(std::move(*this), std::forward<F>(f));
+ }
+#else
+ template <class F>
+ TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &>(),
+ std::declval<F &&>()))
+ map_error(F &&f) & {
+ return map_error_impl(*this, std::forward<F>(f));
+ }
+ template <class F>
+ TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &&>(),
+ std::declval<F &&>()))
+ map_error(F &&f) && {
+ return map_error_impl(std::move(*this), std::forward<F>(f));
+ }
+ template <class F>
+ constexpr decltype(map_error_impl(std::declval<const expected &>(),
+ std::declval<F &&>()))
+ map_error(F &&f) const & {
+ return map_error_impl(*this, std::forward<F>(f));
+ }
+
+#ifndef TL_EXPECTED_NO_CONSTRR
+ template <class F>
+ constexpr decltype(map_error_impl(std::declval<const expected &&>(),
+ std::declval<F &&>()))
+ map_error(F &&f) const && {
+ return map_error_impl(std::move(*this), std::forward<F>(f));
+ }
+#endif
+#endif
+#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && \
+ !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55)
+ template <class F> TL_EXPECTED_11_CONSTEXPR auto transform_error(F &&f) & {
+ return map_error_impl(*this, std::forward<F>(f));
+ }
+ template <class F> TL_EXPECTED_11_CONSTEXPR auto transform_error(F &&f) && {
+ return map_error_impl(std::move(*this), std::forward<F>(f));
+ }
+ template <class F> constexpr auto transform_error(F &&f) const & {
+ return map_error_impl(*this, std::forward<F>(f));
+ }
+ template <class F> constexpr auto transform_error(F &&f) const && {
+ return map_error_impl(std::move(*this), std::forward<F>(f));
+ }
+#else
+ template <class F>
+ TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &>(),
+ std::declval<F &&>()))
+ transform_error(F &&f) & {
+ return map_error_impl(*this, std::forward<F>(f));
+ }
+ template <class F>
+ TL_EXPECTED_11_CONSTEXPR decltype(map_error_impl(std::declval<expected &&>(),
+ std::declval<F &&>()))
+ transform_error(F &&f) && {
+ return map_error_impl(std::move(*this), std::forward<F>(f));
+ }
+ template <class F>
+ constexpr decltype(map_error_impl(std::declval<const expected &>(),
+ std::declval<F &&>()))
+ transform_error(F &&f) const & {
+ return map_error_impl(*this, std::forward<F>(f));
+ }
+
+#ifndef TL_EXPECTED_NO_CONSTRR
+ template <class F>
+ constexpr decltype(map_error_impl(std::declval<const expected &&>(),
+ std::declval<F &&>()))
+ transform_error(F &&f) const && {
+ return map_error_impl(std::move(*this), std::forward<F>(f));
+ }
+#endif
+#endif
+ template <class F> expected TL_EXPECTED_11_CONSTEXPR or_else(F &&f) & {
+ return or_else_impl(*this, std::forward<F>(f));
+ }
+
+ template <class F> expected TL_EXPECTED_11_CONSTEXPR or_else(F &&f) && {
+ return or_else_impl(std::move(*this), std::forward<F>(f));
+ }
+
+ template <class F> expected constexpr or_else(F &&f) const & {
+ return or_else_impl(*this, std::forward<F>(f));
+ }
+
+#ifndef TL_EXPECTED_NO_CONSTRR
+ template <class F> expected constexpr or_else(F &&f) const && {
+ return or_else_impl(std::move(*this), std::forward<F>(f));
+ }
+#endif
+ constexpr expected() = default;
+ constexpr expected(const expected &rhs) = default;
+ constexpr expected(expected &&rhs) = default;
+ expected &operator=(const expected &rhs) = default;
+ expected &operator=(expected &&rhs) = default;
+
+ template <class... Args,
+ detail::enable_if_t<std::is_constructible<T, Args &&...>::value> * =
+ nullptr>
+ constexpr expected(in_place_t, Args &&...args)
+ : impl_base(in_place, std::forward<Args>(args)...),
+ ctor_base(detail::default_constructor_tag{}) {}
+
+ template <class U, class... Args,
+ detail::enable_if_t<std::is_constructible<
+ T, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
+ constexpr expected(in_place_t, std::initializer_list<U> il, Args &&...args)
+ : impl_base(in_place, il, std::forward<Args>(args)...),
+ ctor_base(detail::default_constructor_tag{}) {}
+
+ template <class G = E,
+ detail::enable_if_t<std::is_constructible<E, const G &>::value> * =
+ nullptr,
+ detail::enable_if_t<!std::is_convertible<const G &, E>::value> * =
+ nullptr>
+ explicit constexpr expected(const unexpected<G> &e)
+ : impl_base(unexpect, e.value()),
+ ctor_base(detail::default_constructor_tag{}) {}
+
+ template <
+ class G = E,
+ detail::enable_if_t<std::is_constructible<E, const G &>::value> * =
+ nullptr,
+ detail::enable_if_t<std::is_convertible<const G &, E>::value> * = nullptr>
+ constexpr expected(unexpected<G> const &e)
+ : impl_base(unexpect, e.value()),
+ ctor_base(detail::default_constructor_tag{}) {}
+
+ template <
+ class G = E,
+ detail::enable_if_t<std::is_constructible<E, G &&>::value> * = nullptr,
+ detail::enable_if_t<!std::is_convertible<G &&, E>::value> * = nullptr>
+ explicit constexpr expected(unexpected<G> &&e) noexcept(
+ std::is_nothrow_constructible<E, G &&>::value)
+ : impl_base(unexpect, std::move(e.value())),
+ ctor_base(detail::default_constructor_tag{}) {}
+
+ template <
+ class G = E,
+ detail::enable_if_t<std::is_constructible<E, G &&>::value> * = nullptr,
+ detail::enable_if_t<std::is_convertible<G &&, E>::value> * = nullptr>
+ constexpr expected(unexpected<G> &&e) noexcept(
+ std::is_nothrow_constructible<E, G &&>::value)
+ : impl_base(unexpect, std::move(e.value())),
+ ctor_base(detail::default_constructor_tag{}) {}
+
+ template <class... Args,
+ detail::enable_if_t<std::is_constructible<E, Args &&...>::value> * =
+ nullptr>
+ constexpr explicit expected(unexpect_t, Args &&...args)
+ : impl_base(unexpect, std::forward<Args>(args)...),
+ ctor_base(detail::default_constructor_tag{}) {}
+
+ template <class U, class... Args,
+ detail::enable_if_t<std::is_constructible<
+ E, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
+ constexpr explicit expected(unexpect_t, std::initializer_list<U> il,
+ Args &&...args)
+ : impl_base(unexpect, il, std::forward<Args>(args)...),
+ ctor_base(detail::default_constructor_tag{}) {}
+
+ template <class U, class G,
+ detail::enable_if_t<!(std::is_convertible<U const &, T>::value &&
+ std::is_convertible<G const &, E>::value)> * =
+ nullptr,
+ detail::expected_enable_from_other<T, E, U, G, const U &, const G &>
+ * = nullptr>
+ explicit TL_EXPECTED_11_CONSTEXPR expected(const expected<U, G> &rhs)
+ : ctor_base(detail::default_constructor_tag{}) {
+ if (rhs.has_value()) {
+ this->construct(*rhs);
+ } else {
+ this->construct_error(rhs.error());
+ }
+ }
+
+ template <class U, class G,
+ detail::enable_if_t<(std::is_convertible<U const &, T>::value &&
+ std::is_convertible<G const &, E>::value)> * =
+ nullptr,
+ detail::expected_enable_from_other<T, E, U, G, const U &, const G &>
+ * = nullptr>
+ TL_EXPECTED_11_CONSTEXPR expected(const expected<U, G> &rhs)
+ : ctor_base(detail::default_constructor_tag{}) {
+ if (rhs.has_value()) {
+ this->construct(*rhs);
+ } else {
+ this->construct_error(rhs.error());
+ }
+ }
+
+ template <
+ class U, class G,
+ detail::enable_if_t<!(std::is_convertible<U &&, T>::value &&
+ std::is_convertible<G &&, E>::value)> * = nullptr,
+ detail::expected_enable_from_other<T, E, U, G, U &&, G &&> * = nullptr>
+ explicit TL_EXPECTED_11_CONSTEXPR expected(expected<U, G> &&rhs)
+ : ctor_base(detail::default_constructor_tag{}) {
+ if (rhs.has_value()) {
+ this->construct(std::move(*rhs));
+ } else {
+ this->construct_error(std::move(rhs.error()));
+ }
+ }
+
+ template <
+ class U, class G,
+ detail::enable_if_t<(std::is_convertible<U &&, T>::value &&
+ std::is_convertible<G &&, E>::value)> * = nullptr,
+ detail::expected_enable_from_other<T, E, U, G, U &&, G &&> * = nullptr>
+ TL_EXPECTED_11_CONSTEXPR expected(expected<U, G> &&rhs)
+ : ctor_base(detail::default_constructor_tag{}) {
+ if (rhs.has_value()) {
+ this->construct(std::move(*rhs));
+ } else {
+ this->construct_error(std::move(rhs.error()));
+ }
+ }
+
+ template <
+ class U = T,
+ detail::enable_if_t<!std::is_convertible<U &&, T>::value> * = nullptr,
+ detail::expected_enable_forward_value<T, E, U> * = nullptr>
+ explicit TL_EXPECTED_MSVC2015_CONSTEXPR expected(U &&v)
+ : expected(in_place, std::forward<U>(v)) {}
+
+ template <
+ class U = T,
+ detail::enable_if_t<std::is_convertible<U &&, T>::value> * = nullptr,
+ detail::expected_enable_forward_value<T, E, U> * = nullptr>
+ TL_EXPECTED_MSVC2015_CONSTEXPR expected(U &&v)
+ : expected(in_place, std::forward<U>(v)) {}
+
+ template <
+ class U = T, class G = T,
+ detail::enable_if_t<std::is_nothrow_constructible<T, U &&>::value> * =
+ nullptr,
+ detail::enable_if_t<!std::is_void<G>::value> * = nullptr,
+ detail::enable_if_t<
+ (!std::is_same<expected<T, E>, detail::decay_t<U>>::value &&
+ !detail::conjunction<std::is_scalar<T>,
+ std::is_same<T, detail::decay_t<U>>>::value &&
+ std::is_constructible<T, U>::value &&
+ std::is_assignable<G &, U>::value &&
+ std::is_nothrow_move_constructible<E>::value)> * = nullptr>
+ expected &operator=(U &&v) {
+ if (has_value()) {
+ val() = std::forward<U>(v);
+ } else {
+ err().~unexpected<E>();
+ ::new (valptr()) T(std::forward<U>(v));
+ this->m_has_val = true;
+ }
+
+ return *this;
+ }
+
+ template <
+ class U = T, class G = T,
+ detail::enable_if_t<!std::is_nothrow_constructible<T, U &&>::value> * =
+ nullptr,
+ detail::enable_if_t<!std::is_void<U>::value> * = nullptr,
+ detail::enable_if_t<
+ (!std::is_same<expected<T, E>, detail::decay_t<U>>::value &&
+ !detail::conjunction<std::is_scalar<T>,
+ std::is_same<T, detail::decay_t<U>>>::value &&
+ std::is_constructible<T, U>::value &&
+ std::is_assignable<G &, U>::value &&
+ std::is_nothrow_move_constructible<E>::value)> * = nullptr>
+ expected &operator=(U &&v) {
+ if (has_value()) {
+ val() = std::forward<U>(v);
+ } else {
+ auto tmp = std::move(err());
+ err().~unexpected<E>();
+
+#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
+ try {
+ ::new (valptr()) T(std::forward<U>(v));
+ this->m_has_val = true;
+ } catch (...) {
+ err() = std::move(tmp);
+ throw;
+ }
+#else
+ ::new (valptr()) T(std::forward<U>(v));
+ this->m_has_val = true;
+#endif
+ }
+
+ return *this;
+ }
+
+ template <class G = E,
+ detail::enable_if_t<std::is_nothrow_copy_constructible<G>::value &&
+ std::is_assignable<G &, G>::value> * = nullptr>
+ expected &operator=(const unexpected<G> &rhs) {
+ if (!has_value()) {
+ err() = rhs;
+ } else {
+ this->destroy_val();
+ ::new (errptr()) unexpected<E>(rhs);
+ this->m_has_val = false;
+ }
+
+ return *this;
+ }
+
+ template <class G = E,
+ detail::enable_if_t<std::is_nothrow_move_constructible<G>::value &&
+ std::is_move_assignable<G>::value> * = nullptr>
+ expected &operator=(unexpected<G> &&rhs) noexcept {
+ if (!has_value()) {
+ err() = std::move(rhs);
+ } else {
+ this->destroy_val();
+ ::new (errptr()) unexpected<E>(std::move(rhs));
+ this->m_has_val = false;
+ }
+
+ return *this;
+ }
+
+ template <class... Args, detail::enable_if_t<std::is_nothrow_constructible<
+ T, Args &&...>::value> * = nullptr>
+ void emplace(Args &&...args) {
+ if (has_value()) {
+ val().~T();
+ } else {
+ err().~unexpected<E>();
+ this->m_has_val = true;
+ }
+ ::new (valptr()) T(std::forward<Args>(args)...);
+ }
+
+ template <class... Args, detail::enable_if_t<!std::is_nothrow_constructible<
+ T, Args &&...>::value> * = nullptr>
+ void emplace(Args &&...args) {
+ if (has_value()) {
+ val().~T();
+ ::new (valptr()) T(std::forward<Args>(args)...);
+ } else {
+ auto tmp = std::move(err());
+ err().~unexpected<E>();
+
+#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
+ try {
+ ::new (valptr()) T(std::forward<Args>(args)...);
+ this->m_has_val = true;
+ } catch (...) {
+ err() = std::move(tmp);
+ throw;
+ }
+#else
+ ::new (valptr()) T(std::forward<Args>(args)...);
+ this->m_has_val = true;
+#endif
+ }
+ }
+
+ template <class U, class... Args,
+ detail::enable_if_t<std::is_nothrow_constructible<
+ T, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
+ void emplace(std::initializer_list<U> il, Args &&...args) {
+ if (has_value()) {
+ T t(il, std::forward<Args>(args)...);
+ val() = std::move(t);
+ } else {
+ err().~unexpected<E>();
+ ::new (valptr()) T(il, std::forward<Args>(args)...);
+ this->m_has_val = true;
+ }
+ }
+
+ template <class U, class... Args,
+ detail::enable_if_t<!std::is_nothrow_constructible<
+ T, std::initializer_list<U> &, Args &&...>::value> * = nullptr>
+ void emplace(std::initializer_list<U> il, Args &&...args) {
+ if (has_value()) {
+ T t(il, std::forward<Args>(args)...);
+ val() = std::move(t);
+ } else {
+ auto tmp = std::move(err());
+ err().~unexpected<E>();
+
+#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
+ try {
+ ::new (valptr()) T(il, std::forward<Args>(args)...);
+ this->m_has_val = true;
+ } catch (...) {
+ err() = std::move(tmp);
+ throw;
+ }
+#else
+ ::new (valptr()) T(il, std::forward<Args>(args)...);
+ this->m_has_val = true;
+#endif
+ }
+ }
+
+private:
+ using t_is_void = std::true_type;
+ using t_is_not_void = std::false_type;
+ using t_is_nothrow_move_constructible = std::true_type;
+ using move_constructing_t_can_throw = std::false_type;
+ using e_is_nothrow_move_constructible = std::true_type;
+ using move_constructing_e_can_throw = std::false_type;
+
+ void swap_where_both_have_value(expected & /*rhs*/, t_is_void) noexcept {
+ // swapping void is a no-op
+ }
+
+ void swap_where_both_have_value(expected &rhs, t_is_not_void) {
+ using std::swap;
+ swap(val(), rhs.val());
+ }
+
+ void swap_where_only_one_has_value(expected &rhs, t_is_void) noexcept(
+ std::is_nothrow_move_constructible<E>::value) {
+ ::new (errptr()) unexpected_type(std::move(rhs.err()));
+ rhs.err().~unexpected_type();
+ std::swap(this->m_has_val, rhs.m_has_val);
+ }
+
+ void swap_where_only_one_has_value(expected &rhs, t_is_not_void) {
+ swap_where_only_one_has_value_and_t_is_not_void(
+ rhs, typename std::is_nothrow_move_constructible<T>::type{},
+ typename std::is_nothrow_move_constructible<E>::type{});
+ }
+
+ void swap_where_only_one_has_value_and_t_is_not_void(
+ expected &rhs, t_is_nothrow_move_constructible,
+ e_is_nothrow_move_constructible) noexcept {
+ auto temp = std::move(val());
+ val().~T();
+ ::new (errptr()) unexpected_type(std::move(rhs.err()));
+ rhs.err().~unexpected_type();
+ ::new (rhs.valptr()) T(std::move(temp));
+ std::swap(this->m_has_val, rhs.m_has_val);
+ }
+
+ void swap_where_only_one_has_value_and_t_is_not_void(
+ expected &rhs, t_is_nothrow_move_constructible,
+ move_constructing_e_can_throw) {
+ auto temp = std::move(val());
+ val().~T();
+#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
+ try {
+ ::new (errptr()) unexpected_type(std::move(rhs.err()));
+ rhs.err().~unexpected_type();
+ ::new (rhs.valptr()) T(std::move(temp));
+ std::swap(this->m_has_val, rhs.m_has_val);
+ } catch (...) {
+ val() = std::move(temp);
+ throw;
+ }
+#else
+ ::new (errptr()) unexpected_type(std::move(rhs.err()));
+ rhs.err().~unexpected_type();
+ ::new (rhs.valptr()) T(std::move(temp));
+ std::swap(this->m_has_val, rhs.m_has_val);
+#endif
+ }
+
+ void swap_where_only_one_has_value_and_t_is_not_void(
+ expected &rhs, move_constructing_t_can_throw,
+ e_is_nothrow_move_constructible) {
+ auto temp = std::move(rhs.err());
+ rhs.err().~unexpected_type();
+#ifdef TL_EXPECTED_EXCEPTIONS_ENABLED
+ try {
+ ::new (rhs.valptr()) T(std::move(val()));
+ val().~T();
+ ::new (errptr()) unexpected_type(std::move(temp));
+ std::swap(this->m_has_val, rhs.m_has_val);
+ } catch (...) {
+ rhs.err() = std::move(temp);
+ throw;
+ }
+#else
+ ::new (rhs.valptr()) T(std::move(val()));
+ val().~T();
+ ::new (errptr()) unexpected_type(std::move(temp));
+ std::swap(this->m_has_val, rhs.m_has_val);
+#endif
+ }
+
+public:
+ template <class OT = T, class OE = E>
+ detail::enable_if_t<detail::is_swappable<OT>::value &&
+ detail::is_swappable<OE>::value &&
+ (std::is_nothrow_move_constructible<OT>::value ||
+ std::is_nothrow_move_constructible<OE>::value)>
+ swap(expected &rhs) noexcept(
+ std::is_nothrow_move_constructible<T>::value
+ &&detail::is_nothrow_swappable<T>::value
+ &&std::is_nothrow_move_constructible<E>::value
+ &&detail::is_nothrow_swappable<E>::value) {
+ if (has_value() && rhs.has_value()) {
+ swap_where_both_have_value(rhs, typename std::is_void<T>::type{});
+ } else if (!has_value() && rhs.has_value()) {
+ rhs.swap(*this);
+ } else if (has_value()) {
+ swap_where_only_one_has_value(rhs, typename std::is_void<T>::type{});
+ } else {
+ using std::swap;
+ swap(err(), rhs.err());
+ }
+ }
+
+ constexpr const T *operator->() const {
+ TL_ASSERT(has_value());
+ return valptr();
+ }
+ TL_EXPECTED_11_CONSTEXPR T *operator->() {
+ TL_ASSERT(has_value());
+ return valptr();
+ }
+
+ template <class U = T,
+ detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
+ constexpr const U &operator*() const & {
+ TL_ASSERT(has_value());
+ return val();
+ }
+ template <class U = T,
+ detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
+ TL_EXPECTED_11_CONSTEXPR U &operator*() & {
+ TL_ASSERT(has_value());
+ return val();
+ }
+ template <class U = T,
+ detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
+ constexpr const U &&operator*() const && {
+ TL_ASSERT(has_value());
+ return std::move(val());
+ }
+ template <class U = T,
+ detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
+ TL_EXPECTED_11_CONSTEXPR U &&operator*() && {
+ TL_ASSERT(has_value());
+ return std::move(val());
+ }
+
+ constexpr bool has_value() const noexcept { return this->m_has_val; }
+ constexpr explicit operator bool() const noexcept { return this->m_has_val; }
+
+ template <class U = T,
+ detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
+ TL_EXPECTED_11_CONSTEXPR const U &value() const & {
+ if (!has_value())
+ detail::throw_exception(bad_expected_access<E>(err().value()));
+ return val();
+ }
+ template <class U = T,
+ detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
+ TL_EXPECTED_11_CONSTEXPR U &value() & {
+ if (!has_value())
+ detail::throw_exception(bad_expected_access<E>(err().value()));
+ return val();
+ }
+ template <class U = T,
+ detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
+ TL_EXPECTED_11_CONSTEXPR const U &&value() const && {
+ if (!has_value())
+ detail::throw_exception(bad_expected_access<E>(std::move(err()).value()));
+ return std::move(val());
+ }
+ template <class U = T,
+ detail::enable_if_t<!std::is_void<U>::value> * = nullptr>
+ TL_EXPECTED_11_CONSTEXPR U &&value() && {
+ if (!has_value())
+ detail::throw_exception(bad_expected_access<E>(std::move(err()).value()));
+ return std::move(val());
+ }
+
+ constexpr const E &error() const & {
+ TL_ASSERT(!has_value());
+ return err().value();
+ }
+ TL_EXPECTED_11_CONSTEXPR E &error() & {
+ TL_ASSERT(!has_value());
+ return err().value();
+ }
+ constexpr const E &&error() const && {
+ TL_ASSERT(!has_value());
+ return std::move(err().value());
+ }
+ TL_EXPECTED_11_CONSTEXPR E &&error() && {
+ TL_ASSERT(!has_value());
+ return std::move(err().value());
+ }
+
+ template <class U> constexpr T value_or(U &&v) const & {
+ static_assert(std::is_copy_constructible<T>::value &&
+ std::is_convertible<U &&, T>::value,
+ "T must be copy-constructible and convertible to from U&&");
+ return bool(*this) ? **this : static_cast<T>(std::forward<U>(v));
+ }
+ template <class U> TL_EXPECTED_11_CONSTEXPR T value_or(U &&v) && {
+ static_assert(std::is_move_constructible<T>::value &&
+ std::is_convertible<U &&, T>::value,
+ "T must be move-constructible and convertible to from U&&");
+ return bool(*this) ? std::move(**this) : static_cast<T>(std::forward<U>(v));
+ }
+};
+
+namespace detail {
+template <class Exp> using exp_t = typename detail::decay_t<Exp>::value_type;
+template <class Exp> using err_t = typename detail::decay_t<Exp>::error_type;
+template <class Exp, class Ret> using ret_t = expected<Ret, err_t<Exp>>;
+
+#ifdef TL_EXPECTED_CXX14
+template <class Exp, class F,
+ detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
+ class Ret = decltype(detail::invoke(std::declval<F>(),
+ *std::declval<Exp>()))>
+constexpr auto and_then_impl(Exp &&exp, F &&f) {
+ static_assert(detail::is_expected<Ret>::value, "F must return an expected");
+
+ return exp.has_value()
+ ? detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp))
+ : Ret(unexpect, std::forward<Exp>(exp).error());
+}
+
+template <class Exp, class F,
+ detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
+ class Ret = decltype(detail::invoke(std::declval<F>()))>
+constexpr auto and_then_impl(Exp &&exp, F &&f) {
+ static_assert(detail::is_expected<Ret>::value, "F must return an expected");
+
+ return exp.has_value() ? detail::invoke(std::forward<F>(f))
+ : Ret(unexpect, std::forward<Exp>(exp).error());
+}
+#else
+template <class> struct TC;
+template <class Exp, class F,
+ class Ret = decltype(detail::invoke(std::declval<F>(),
+ *std::declval<Exp>())),
+ detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr>
+auto and_then_impl(Exp &&exp, F &&f) -> Ret {
+ static_assert(detail::is_expected<Ret>::value, "F must return an expected");
+
+ return exp.has_value()
+ ? detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp))
+ : Ret(unexpect, std::forward<Exp>(exp).error());
+}
+
+template <class Exp, class F,
+ class Ret = decltype(detail::invoke(std::declval<F>())),
+ detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr>
+constexpr auto and_then_impl(Exp &&exp, F &&f) -> Ret {
+ static_assert(detail::is_expected<Ret>::value, "F must return an expected");
+
+ return exp.has_value() ? detail::invoke(std::forward<F>(f))
+ : Ret(unexpect, std::forward<Exp>(exp).error());
+}
+#endif
+
+#ifdef TL_EXPECTED_CXX14
+template <class Exp, class F,
+ detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
+ class Ret = decltype(detail::invoke(std::declval<F>(),
+ *std::declval<Exp>())),
+ detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+constexpr auto expected_map_impl(Exp &&exp, F &&f) {
+ using result = ret_t<Exp, detail::decay_t<Ret>>;
+ return exp.has_value() ? result(detail::invoke(std::forward<F>(f),
+ *std::forward<Exp>(exp)))
+ : result(unexpect, std::forward<Exp>(exp).error());
+}
+
+template <class Exp, class F,
+ detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
+ class Ret = decltype(detail::invoke(std::declval<F>(),
+ *std::declval<Exp>())),
+ detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+auto expected_map_impl(Exp &&exp, F &&f) {
+ using result = expected<void, err_t<Exp>>;
+ if (exp.has_value()) {
+ detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp));
+ return result();
+ }
+
+ return result(unexpect, std::forward<Exp>(exp).error());
+}
+
+template <class Exp, class F,
+ detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
+ class Ret = decltype(detail::invoke(std::declval<F>())),
+ detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+constexpr auto expected_map_impl(Exp &&exp, F &&f) {
+ using result = ret_t<Exp, detail::decay_t<Ret>>;
+ return exp.has_value() ? result(detail::invoke(std::forward<F>(f)))
+ : result(unexpect, std::forward<Exp>(exp).error());
+}
+
+template <class Exp, class F,
+ detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
+ class Ret = decltype(detail::invoke(std::declval<F>())),
+ detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+auto expected_map_impl(Exp &&exp, F &&f) {
+ using result = expected<void, err_t<Exp>>;
+ if (exp.has_value()) {
+ detail::invoke(std::forward<F>(f));
+ return result();
+ }
+
+ return result(unexpect, std::forward<Exp>(exp).error());
+}
+#else
+template <class Exp, class F,
+ detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
+ class Ret = decltype(detail::invoke(std::declval<F>(),
+ *std::declval<Exp>())),
+ detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+
+constexpr auto expected_map_impl(Exp &&exp, F &&f)
+ -> ret_t<Exp, detail::decay_t<Ret>> {
+ using result = ret_t<Exp, detail::decay_t<Ret>>;
+
+ return exp.has_value() ? result(detail::invoke(std::forward<F>(f),
+ *std::forward<Exp>(exp)))
+ : result(unexpect, std::forward<Exp>(exp).error());
+}
+
+template <class Exp, class F,
+ detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
+ class Ret = decltype(detail::invoke(std::declval<F>(),
+ *std::declval<Exp>())),
+ detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+
+auto expected_map_impl(Exp &&exp, F &&f) -> expected<void, err_t<Exp>> {
+ if (exp.has_value()) {
+ detail::invoke(std::forward<F>(f), *std::forward<Exp>(exp));
+ return {};
+ }
+
+ return unexpected<err_t<Exp>>(std::forward<Exp>(exp).error());
+}
+
+template <class Exp, class F,
+ detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
+ class Ret = decltype(detail::invoke(std::declval<F>())),
+ detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+
+constexpr auto expected_map_impl(Exp &&exp, F &&f)
+ -> ret_t<Exp, detail::decay_t<Ret>> {
+ using result = ret_t<Exp, detail::decay_t<Ret>>;
+
+ return exp.has_value() ? result(detail::invoke(std::forward<F>(f)))
+ : result(unexpect, std::forward<Exp>(exp).error());
+}
+
+template <class Exp, class F,
+ detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
+ class Ret = decltype(detail::invoke(std::declval<F>())),
+ detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+
+auto expected_map_impl(Exp &&exp, F &&f) -> expected<void, err_t<Exp>> {
+ if (exp.has_value()) {
+ detail::invoke(std::forward<F>(f));
+ return {};
+ }
+
+ return unexpected<err_t<Exp>>(std::forward<Exp>(exp).error());
+}
+#endif
+
+#if defined(TL_EXPECTED_CXX14) && !defined(TL_EXPECTED_GCC49) && \
+ !defined(TL_EXPECTED_GCC54) && !defined(TL_EXPECTED_GCC55)
+template <class Exp, class F,
+ detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
+ class Ret = decltype(detail::invoke(std::declval<F>(),
+ std::declval<Exp>().error())),
+ detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+constexpr auto map_error_impl(Exp &&exp, F &&f) {
+ using result = expected<exp_t<Exp>, detail::decay_t<Ret>>;
+ return exp.has_value()
+ ? result(*std::forward<Exp>(exp))
+ : result(unexpect, detail::invoke(std::forward<F>(f),
+ std::forward<Exp>(exp).error()));
+}
+template <class Exp, class F,
+ detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
+ class Ret = decltype(detail::invoke(std::declval<F>(),
+ std::declval<Exp>().error())),
+ detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+auto map_error_impl(Exp &&exp, F &&f) {
+ using result = expected<exp_t<Exp>, monostate>;
+ if (exp.has_value()) {
+ return result(*std::forward<Exp>(exp));
+ }
+
+ detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
+ return result(unexpect, monostate{});
+}
+template <class Exp, class F,
+ detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
+ class Ret = decltype(detail::invoke(std::declval<F>(),
+ std::declval<Exp>().error())),
+ detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+constexpr auto map_error_impl(Exp &&exp, F &&f) {
+ using result = expected<exp_t<Exp>, detail::decay_t<Ret>>;
+ return exp.has_value()
+ ? result()
+ : result(unexpect, detail::invoke(std::forward<F>(f),
+ std::forward<Exp>(exp).error()));
+}
+template <class Exp, class F,
+ detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
+ class Ret = decltype(detail::invoke(std::declval<F>(),
+ std::declval<Exp>().error())),
+ detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+auto map_error_impl(Exp &&exp, F &&f) {
+ using result = expected<exp_t<Exp>, monostate>;
+ if (exp.has_value()) {
+ return result();
+ }
+
+ detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
+ return result(unexpect, monostate{});
+}
+#else
+template <class Exp, class F,
+ detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
+ class Ret = decltype(detail::invoke(std::declval<F>(),
+ std::declval<Exp>().error())),
+ detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+constexpr auto map_error_impl(Exp &&exp, F &&f)
+ -> expected<exp_t<Exp>, detail::decay_t<Ret>> {
+ using result = expected<exp_t<Exp>, detail::decay_t<Ret>>;
+
+ return exp.has_value()
+ ? result(*std::forward<Exp>(exp))
+ : result(unexpect, detail::invoke(std::forward<F>(f),
+ std::forward<Exp>(exp).error()));
+}
+
+template <class Exp, class F,
+ detail::enable_if_t<!std::is_void<exp_t<Exp>>::value> * = nullptr,
+ class Ret = decltype(detail::invoke(std::declval<F>(),
+ std::declval<Exp>().error())),
+ detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+auto map_error_impl(Exp &&exp, F &&f) -> expected<exp_t<Exp>, monostate> {
+ using result = expected<exp_t<Exp>, monostate>;
+ if (exp.has_value()) {
+ return result(*std::forward<Exp>(exp));
+ }
+
+ detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
+ return result(unexpect, monostate{});
+}
+
+template <class Exp, class F,
+ detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
+ class Ret = decltype(detail::invoke(std::declval<F>(),
+ std::declval<Exp>().error())),
+ detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+constexpr auto map_error_impl(Exp &&exp, F &&f)
+ -> expected<exp_t<Exp>, detail::decay_t<Ret>> {
+ using result = expected<exp_t<Exp>, detail::decay_t<Ret>>;
+
+ return exp.has_value()
+ ? result()
+ : result(unexpect, detail::invoke(std::forward<F>(f),
+ std::forward<Exp>(exp).error()));
+}
+
+template <class Exp, class F,
+ detail::enable_if_t<std::is_void<exp_t<Exp>>::value> * = nullptr,
+ class Ret = decltype(detail::invoke(std::declval<F>(),
+ std::declval<Exp>().error())),
+ detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+auto map_error_impl(Exp &&exp, F &&f) -> expected<exp_t<Exp>, monostate> {
+ using result = expected<exp_t<Exp>, monostate>;
+ if (exp.has_value()) {
+ return result();
+ }
+
+ detail::invoke(std::forward<F>(f), std::forward<Exp>(exp).error());
+ return result(unexpect, monostate{});
+}
+#endif
+
+#ifdef TL_EXPECTED_CXX14
+template <class Exp, class F,
+ class Ret = decltype(detail::invoke(std::declval<F>(),
+ std::declval<Exp>().error())),
+ detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+constexpr auto or_else_impl(Exp &&exp, F &&f) {
+ static_assert(detail::is_expected<Ret>::value, "F must return an expected");
+ return exp.has_value() ? std::forward<Exp>(exp)
+ : detail::invoke(std::forward<F>(f),
+ std::forward<Exp>(exp).error());
+}
+
+template <class Exp, class F,
+ class Ret = decltype(detail::invoke(std::declval<F>(),
+ std::declval<Exp>().error())),
+ detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+detail::decay_t<Exp> or_else_impl(Exp &&exp, F &&f) {
+ return exp.has_value() ? std::forward<Exp>(exp)
+ : (detail::invoke(std::forward<F>(f),
+ std::forward<Exp>(exp).error()),
+ std::forward<Exp>(exp));
+}
+#else
+template <class Exp, class F,
+ class Ret = decltype(detail::invoke(std::declval<F>(),
+ std::declval<Exp>().error())),
+ detail::enable_if_t<!std::is_void<Ret>::value> * = nullptr>
+auto or_else_impl(Exp &&exp, F &&f) -> Ret {
+ static_assert(detail::is_expected<Ret>::value, "F must return an expected");
+ return exp.has_value() ? std::forward<Exp>(exp)
+ : detail::invoke(std::forward<F>(f),
+ std::forward<Exp>(exp).error());
+}
+
+template <class Exp, class F,
+ class Ret = decltype(detail::invoke(std::declval<F>(),
+ std::declval<Exp>().error())),
+ detail::enable_if_t<std::is_void<Ret>::value> * = nullptr>
+detail::decay_t<Exp> or_else_impl(Exp &&exp, F &&f) {
+ return exp.has_value() ? std::forward<Exp>(exp)
+ : (detail::invoke(std::forward<F>(f),
+ std::forward<Exp>(exp).error()),
+ std::forward<Exp>(exp));
+}
+#endif
+} // namespace detail
+
+template <class T, class E, class U, class F>
+constexpr bool operator==(const expected<T, E> &lhs,
+ const expected<U, F> &rhs) {
+ return (lhs.has_value() != rhs.has_value())
+ ? false
+ : (!lhs.has_value() ? lhs.error() == rhs.error() : *lhs == *rhs);
+}
+template <class T, class E, class U, class F>
+constexpr bool operator!=(const expected<T, E> &lhs,
+ const expected<U, F> &rhs) {
+ return (lhs.has_value() != rhs.has_value())
+ ? true
+ : (!lhs.has_value() ? lhs.error() != rhs.error() : *lhs != *rhs);
+}
+template <class E, class F>
+constexpr bool operator==(const expected<void, E> &lhs,
+ const expected<void, F> &rhs) {
+ return (lhs.has_value() != rhs.has_value())
+ ? false
+ : (!lhs.has_value() ? lhs.error() == rhs.error() : true);
+}
+template <class E, class F>
+constexpr bool operator!=(const expected<void, E> &lhs,
+ const expected<void, F> &rhs) {
+ return (lhs.has_value() != rhs.has_value())
+ ? true
+ : (!lhs.has_value() ? lhs.error() == rhs.error() : false);
+}
+
+template <class T, class E, class U>
+constexpr bool operator==(const expected<T, E> &x, const U &v) {
+ return x.has_value() ? *x == v : false;
+}
+template <class T, class E, class U>
+constexpr bool operator==(const U &v, const expected<T, E> &x) {
+ return x.has_value() ? *x == v : false;
+}
+template <class T, class E, class U>
+constexpr bool operator!=(const expected<T, E> &x, const U &v) {
+ return x.has_value() ? *x != v : true;
+}
+template <class T, class E, class U>
+constexpr bool operator!=(const U &v, const expected<T, E> &x) {
+ return x.has_value() ? *x != v : true;
+}
+
+template <class T, class E>
+constexpr bool operator==(const expected<T, E> &x, const unexpected<E> &e) {
+ return x.has_value() ? false : x.error() == e.value();
+}
+template <class T, class E>
+constexpr bool operator==(const unexpected<E> &e, const expected<T, E> &x) {
+ return x.has_value() ? false : x.error() == e.value();
+}
+template <class T, class E>
+constexpr bool operator!=(const expected<T, E> &x, const unexpected<E> &e) {
+ return x.has_value() ? true : x.error() != e.value();
+}
+template <class T, class E>
+constexpr bool operator!=(const unexpected<E> &e, const expected<T, E> &x) {
+ return x.has_value() ? true : x.error() != e.value();
+}
+
+template <class T, class E,
+ detail::enable_if_t<(std::is_void<T>::value ||
+ std::is_move_constructible<T>::value) &&
+ detail::is_swappable<T>::value &&
+ std::is_move_constructible<E>::value &&
+ detail::is_swappable<E>::value> * = nullptr>
+void swap(expected<T, E> &lhs,
+ expected<T, E> &rhs) noexcept(noexcept(lhs.swap(rhs))) {
+ lhs.swap(rhs);
+}
+} // namespace tl
+
+#endif
diff --git a/vcpkg.json b/vcpkg.json
index d08a7c1cd0..c153f7a858 100644
--- a/vcpkg.json
+++ b/vcpkg.json
@@ -40,7 +40,9 @@
"icu",
"ngspice",
"wxpython",
- "libgit2"
+ "libgit2",
+ "nng",
+ "protobuf"
],
"overrides": [
{