From 5ff21f9c2d026adb9e4c59ca3b926dc67fe6d869 Mon Sep 17 00:00:00 2001 From: JamesJCode <13408010-JamesJCode@users.noreply.gitlab.com> Date: Fri, 27 Dec 2024 01:49:16 +0000 Subject: [PATCH] Add ki::any and ki::any_cast for any_casts across translation units ki::any is a standards-compliant implementation, based on the GCC standard library. However, it uses type_info::hash_code() to check the validitiy of a ki:any_cast, rather than comparing the type_info objects directly. This comparison, used in the standard implementations, is fragile across translation unit boundaries when built with Clang. --- common/tool/tool_manager.cpp | 4 +- include/ki_any.h | 623 +++++++++++++++++++++++ include/tool/tool_action.h | 10 +- include/tool/tool_event.h | 13 +- include/tool/tool_manager.h | 40 +- qa/tests/common/CMakeLists.txt | 1 + qa/tests/common/test_ki_any.cpp | 840 ++++++++++++++++++++++++++++++++ 7 files changed, 1499 insertions(+), 32 deletions(-) create mode 100644 include/ki_any.h create mode 100644 qa/tests/common/test_ki_any.cpp diff --git a/common/tool/tool_manager.cpp b/common/tool/tool_manager.cpp index b46d38a66a..0ff0385364 100644 --- a/common/tool/tool_manager.cpp +++ b/common/tool/tool_manager.cpp @@ -290,7 +290,7 @@ bool TOOL_MANAGER::InvokeTool( const std::string& aToolName ) } -bool TOOL_MANAGER::doRunAction( const std::string& aActionName, bool aNow, const std::any& aParam, +bool TOOL_MANAGER::doRunAction( const std::string& aActionName, bool aNow, const ki::any& aParam, COMMIT* aCommit ) { TOOL_ACTION* action = m_actionMgr->FindAction( aActionName ); @@ -325,7 +325,7 @@ VECTOR2D TOOL_MANAGER::GetCursorPosition() const } -bool TOOL_MANAGER::doRunAction( const TOOL_ACTION& aAction, bool aNow, const std::any& aParam, +bool TOOL_MANAGER::doRunAction( const TOOL_ACTION& aAction, bool aNow, const ki::any& aParam, COMMIT* aCommit ) { if( m_shuttingDown ) diff --git a/include/ki_any.h b/include/ki_any.h new file mode 100644 index 0000000000..35a9645d9a --- /dev/null +++ b/include/ki_any.h @@ -0,0 +1,623 @@ +/* +* This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 1992-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 . + */ + +// This code is a modified version of the GCC standard library implementation (see original licence below): + +// Copyright (C) 2014-2024 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library 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, or (at your option) +// any later version. +// +// This library 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. +// +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. +// +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + + +/** An implementation of std::any_cast, which uses type_info::hash_code to check validity of + * cast types. This is required as Clang compares types as being equivalent based on their + * type_info pointer locations. These are not guaranteed to be the same with identical types + * linked in multiple targets from shared libraries. The current Clang implementation of + * type_info::hash_code is based on the type names, which should be consistent across translation + * units. + */ +#ifndef INCLUDE_KI_ANY_H_ +#define INCLUDE_KI_ANY_H_ + +#include +#include +#include +#include + +namespace ki +{ + +/* + * Disambiguation helpers + */ + +template +inline constexpr bool is_in_place_type_v = false; + +template +inline constexpr bool is_in_place_type_v> = true; + +/** + * @brief Exception class thrown by a failed @c any_cast + */ +class bad_any_cast final : public std::bad_cast +{ +public: + const char* what() const noexcept override { return "bad ki::any_cast"; } +}; + +/** + * @brief A type-safe container of any type. + * + * An `any` object's state is either empty or it stores a contained object + * of CopyConstructible type. + */ +class any +{ + // Holds either a pointer to a heap object or the contained object itself + union Storage + { + constexpr Storage() : m_ptr{ nullptr } {} + + // Prevent trivial copies of this type as the buffer might hold a non-POD + Storage( const Storage& ) = delete; + Storage& operator=( const Storage& ) = delete; + + void* m_ptr; + unsigned char m_buffer[sizeof( m_ptr )]; + }; + + template , + bool Fits = ( sizeof( T ) <= sizeof( Storage ) ) + && ( alignof( T ) <= alignof( Storage ) )> + using Use_Internal_Storage = std::integral_constant; + + template + struct Manager_Internal; // uses small-object optimization + + template + struct Manager_External; // creates contained object on the heap + + template + using Manager = std::conditional_t::value, Manager_Internal, + Manager_External>; + + template > + using decay_if_not_any = std::enable_if_t, V>; + + /// @brief Emplace with an object created from @p args as the contained object + template > + void do_emplace( Args&&... args ) + { + reset(); + Mgr::do_create( m_storage, std::forward( args )... ); + m_manager = &Mgr::m_manage_fn; + } + + /// @brief Emplace with an object created from @p il and @p args as the contained object + template > + void do_emplace( std::initializer_list il, Args&&... args ) + { + reset(); + Mgr::do_create( m_storage, il, std::forward( args )... ); + m_manager = &Mgr::m_manage_fn; + } + + template + using any_constructible = + std::enable_if && std::is_constructible_v, + Res>; + + template + using any_constructible_t = typename any_constructible::type; + + template + using any_emplace_t = typename any_constructible::type; + +public: + /// @brief Default constructor, creates an empty object + constexpr any() noexcept : m_manager( nullptr ) {} + + /// @brief Copy constructor, copies the state of @p other + any( const any& other ) + { + if( !other.has_value() ) + { + m_manager = nullptr; + } + else + { + Arg arg; + arg.m_any = this; + other.m_manager( Op_Clone, &other, &arg ); + } + } + + /// @brief Move constructor, transfer the state from @p other + any( any&& other ) noexcept + { + if( !other.has_value() ) + { + m_manager = nullptr; + } + else + { + Arg arg; + arg.m_any = this; + other.m_manager( Op_Xfer, &other, &arg ); + } + } + + /// @brief Construct with a copy of @p value as the contained object + template , typename Mgr = Manager, + std::enable_if_t && !is_in_place_type_v, bool> = + true> + + any( T&& value ) : m_manager( &Mgr::m_manage_fn ) + { + Mgr::do_create( m_storage, std::forward( value ) ); + } + + /// @brief Construct with an object created from @p args as the contained object + template , typename Mgr = Manager, + any_constructible_t = false> + explicit any( std::in_place_type_t, Args&&... args ) : m_manager( &Mgr::m_manage_fn ) + { + Mgr::do_create( m_storage, std::forward( args )... ); + } + + /// @brief Construct with an object created from @p il and @p args as the contained object + template , + typename Mgr = Manager, + any_constructible_t&, Args&&...> = false> + explicit any( std::in_place_type_t, std::initializer_list il, Args&&... args ) : + m_manager( &Mgr::m_manage_fn ) + { + Mgr::do_create( m_storage, il, std::forward( args )... ); + } + + /// @brief Destructor, calls @c reset() + ~any() { reset(); } + + /// @brief Copy the state of another object + any& operator=( const any& rhs ) + { + *this = any( rhs ); + return *this; + } + + /// @brief Move assignment operator + any& operator=( any&& rhs ) noexcept + { + if( !rhs.has_value() ) + { + reset(); + } + else if( this != &rhs ) + { + reset(); + Arg arg; + arg.m_any = this; + rhs.m_manager( Op_Xfer, &rhs, &arg ); + } + + return *this; + } + + /// Store a copy of @p rhs as the contained object + template + std::enable_if_t>, any&> operator=( T&& rhs ) + { + *this = any( std::forward( rhs ) ); + return *this; + } + + /// Emplace with an object created from @p args as the contained object + template + any_emplace_t, Args...> emplace( Args&&... args ) + { + using V = std::decay_t; + do_emplace( std::forward( args )... ); + return *any::Manager::do_access( m_storage ); + } + + /// Emplace with an object created from @p il and @p args as the contained object + template + any_emplace_t, std::initializer_list&, Args&&...> + emplace( std::initializer_list il, Args&&... args ) + { + using V = std::decay_t; + do_emplace( il, std::forward( args )... ); + return *any::Manager::do_access( m_storage ); + } + + /// If not empty, destroys the contained object + void reset() noexcept + { + if( has_value() ) + { + m_manager( Op_Destroy, this, nullptr ); + m_manager = nullptr; + } + } + + /// Exchange state with another object + void swap( any& rhs ) noexcept + { + if( !has_value() && !rhs.has_value() ) + return; + + if( has_value() && rhs.has_value() ) + { + if( this == &rhs ) + return; + + any tmp; + Arg arg; + arg.m_any = &tmp; + rhs.m_manager( Op_Xfer, &rhs, &arg ); + arg.m_any = &rhs; + m_manager( Op_Xfer, this, &arg ); + arg.m_any = this; + tmp.m_manager( Op_Xfer, &tmp, &arg ); + } + else + { + any* empty = !has_value() ? this : &rhs; + any* full = !has_value() ? &rhs : this; + Arg arg; + arg.m_any = empty; + full->m_manager( Op_Xfer, full, &arg ); + } + } + + /// Reports whether there is a contained object or not + bool has_value() const noexcept { return m_manager != nullptr; } + + + /// The @c typeid of the contained object, or @c typeid(void) if empty + const std::type_info& type() const noexcept + { + if( !has_value() ) + return typeid( void ); + + Arg arg; + m_manager( Op_Get_Type_Info, this, &arg ); + return *arg.m_typeinfo; + } + + /// @cond undocumented + template + static constexpr bool is_valid_any_cast() + { + return std::is_reference_v || std::is_copy_constructible_v; + } + /// @endcond + +private: + enum Op + { + Op_Access, + Op_Get_Type_Info, + Op_Clone, + Op_Destroy, + Op_Xfer + }; + + union Arg + { + void* m_obj; + const std::type_info* m_typeinfo; + any* m_any; + }; + + void ( *m_manager )( Op, const any*, Arg* ); + Storage m_storage; + + /// @cond undocumented + template + friend void* any_caster( const any* any ); + /// @endcond + + // Manages in-place contained object + template + struct Manager_Internal + { + static void m_manage_fn( Op which, const any* any, Arg* arg ); + + template + static void do_create( Storage& storage, U&& value ) + { + void* addr = &storage.m_buffer; + ::new( addr ) T( std::forward( value ) ); + } + + template + static void do_create( Storage& storage, Args&&... args ) + { + void* addr = &storage.m_buffer; + ::new( addr ) T( std::forward( args )... ); + } + + static T* do_access( const Storage& storage ) + { + // The contained object is in storage.m_buffer + const void* addr = &storage.m_buffer; + return static_cast( const_cast( addr ) ); + } + }; + + // Manages externally (heap) contained object + template + struct Manager_External + { + static void m_manage_fn( Op which, const any* any, Arg* arg ); + + template + static void do_create( Storage& storage, U&& value ) + { + storage.m_ptr = new T( std::forward( value ) ); + } + template + static void do_create( Storage& storage, Args&&... args ) + { + storage.m_ptr = new T( std::forward( args )... ); + } + static T* do_access( const Storage& storage ) + { + // The contained object is in *storage.m_ptr + return static_cast( storage.m_ptr ); + } + }; +}; + +/// Exchange the states of two @c any objects +inline void swap( any& x, any& y ) noexcept +{ + x.swap( y ); +} + +/// Create a `any` holding a `T` constructed from `args...` +template +std::enable_if_t, Args...>, any> +make_any( Args&&... args ) +{ + return any( std::in_place_type, std::forward( args )... ); +} + +/// Create an `any` holding a `T` constructed from `il` and `args...`. +template +std::enable_if_t< + std::is_constructible_v, std::initializer_list&, Args...>, + any> +make_any( std::initializer_list il, Args&&... args ) +{ + return any( std::in_place_type, il, std::forward( args )... ); +} + +/** + * @brief Access the contained object + * + * @tparam ValueType A const-reference or CopyConstructible type. + * @param any The object to access. + * @return The contained object. + * @throw bad_any_cast If + * any.type() != typeid(remove_reference_t) + * + */ +template +ValueType any_cast( const any& any ) +{ + using U = std::remove_cvref_t; + + static_assert( any::is_valid_any_cast(), + "Template argument must be a reference or CopyConstructible type" ); + static_assert( std::is_constructible_v, + "Template argument must be constructible from a const value" ); + + auto p = any_cast( &any ); + + if( p ) + return static_cast( *p ); + + throw bad_any_cast{}; +} + +/** + * @brief Access the contained object. + * + * @tparam ValueType A reference or CopyConstructible type. + * @param any The object to access. + * @return The contained object. + * @throw bad_any_cast If + * any.type() != typeid(remove_reference_t) + * + * @{ + */ +template +ValueType any_cast( any& any ) +{ + using U = std::remove_cvref_t; + + static_assert( any::is_valid_any_cast(), + "Template argument must be a reference or CopyConstructible type" ); + static_assert( std::is_constructible_v, + "Template argument must be constructible from an lvalue" ); + + auto p = any_cast( &any ); + + if( p ) + return static_cast( *p ); + + throw bad_any_cast{}; +} + +template +ValueType any_cast( any&& any ) +{ + using U = std::remove_cvref_t; + + static_assert( any::is_valid_any_cast(), + "Template argument must be a reference or CopyConstructible type" ); + static_assert( std::is_constructible_v, + "Template argument must be constructible from an rvalue" ); + + auto p = any_cast( &any ); + + if( p ) + return static_cast( std::move( *p ) ); + + throw bad_any_cast{}; +} + +/// @} + +/// @cond undocumented +template +void* any_caster( const any* any ) +{ + // any_cast returns non-null if any->type() == typeid(T) and + // typeid(T) ignores cv-qualifiers so remove them: + using U = std::remove_cv_t; + + if constexpr( !std::is_same_v, U> ) + { + // The contained value has a decayed type, so if decay_t is not U, + // then it's not possible to have a contained value of type U + return nullptr; + } + else if constexpr( !std::is_copy_constructible_v ) + { + // Only copy constructible types can be used for contained values + return nullptr; + } + else if( any->m_manager == &any::Manager::m_manage_fn + || any->type().hash_code() == typeid( T ).hash_code() ) + { + return any::Manager::do_access( any->m_storage ); + } + + return nullptr; +} +/// @endcond + +/** + * @brief Access the contained object. + * + * @tparam ValueType The type of the contained object. + * @param any A pointer to the object to access. + * @return The address of the contained object if + * any != nullptr && any.type() == typeid(ValueType) + * , otherwise a null pointer. + * + * @{ + */ +template +const ValueType* any_cast( const any* any ) noexcept +{ + static_assert( !std::is_void_v ); + + // As an optimization, don't bother instantiating any_caster for + // function types, since std::any can only hold objects + if constexpr( std::is_object_v ) + { + if( any ) + return static_cast( any_caster( any ) ); + } + + return nullptr; +} + +template +ValueType* any_cast( any* any ) noexcept +{ + static_assert( !std::is_void_v ); + + if constexpr( std::is_object_v ) + if( any ) + return static_cast( any_caster( any ) ); + return nullptr; +} +/// @} + +template +void any::Manager_Internal::m_manage_fn( Op which, const any* any, Arg* arg ) +{ + // The contained object is in m_storage.m_buffer + auto ptr = reinterpret_cast( &any->m_storage.m_buffer ); + switch( which ) + { + case Op_Access: arg->m_obj = const_cast( ptr ); break; + case Op_Get_Type_Info: arg->m_typeinfo = &typeid( T ); break; + case Op_Clone: + ::new( &arg->m_any->m_storage.m_buffer ) T( *ptr ); + arg->m_any->m_manager = any->m_manager; + break; + case Op_Destroy: ptr->~T(); break; + case Op_Xfer: + ::new( &arg->m_any->m_storage.m_buffer ) T( std::move( *const_cast( ptr ) ) ); + ptr->~T(); + arg->m_any->m_manager = any->m_manager; + const_cast( any )->m_manager = nullptr; + break; + } +} + +template +void any::Manager_External::m_manage_fn( Op which, const any* any, Arg* arg ) +{ + // The contained object is *m_storage.m_ptr + auto ptr = static_cast( any->m_storage.m_ptr ); + switch( which ) + { + case Op_Access: arg->m_obj = const_cast( ptr ); break; + case Op_Get_Type_Info: arg->m_typeinfo = &typeid( T ); break; + case Op_Clone: + arg->m_any->m_storage.m_ptr = new T( *ptr ); + arg->m_any->m_manager = any->m_manager; + break; + case Op_Destroy: delete ptr; break; + case Op_Xfer: + arg->m_any->m_storage.m_ptr = any->m_storage.m_ptr; + arg->m_any->m_manager = any->m_manager; + const_cast( any )->m_manager = nullptr; + break; + } +} + +} // namespace ki + +#endif // INCLUDE_KI_ANY_H_ diff --git a/include/tool/tool_action.h b/include/tool/tool_action.h index 5c242d1e08..e709c559d4 100644 --- a/include/tool/tool_action.h +++ b/include/tool/tool_action.h @@ -28,12 +28,12 @@ #ifndef __TOOL_ACTION_H #define __TOOL_ACTION_H -#include #include #include #include #include +#include #include class TOOL_EVENT; @@ -251,7 +251,7 @@ protected: std::optional m_group; - std::any m_param; + ki::any m_param; }; /** @@ -377,9 +377,9 @@ public: try { - param = std::any_cast( m_param ); + param = ki::any_cast( m_param ); } - catch( const std::bad_any_cast& e ) + catch( const ki::bad_any_cast& e ) { wxASSERT_MSG( false, wxString::Format( "Requested parameter type %s from action with parameter type %s.", @@ -455,7 +455,7 @@ protected: std::optional m_uiid; // ID to use when interacting with the UI (if empty, generate one) TOOL_ACTION_FLAGS m_flags; - std::any m_param; // Generic parameter + ki::any m_param; // Generic parameter }; #endif diff --git a/include/tool/tool_event.h b/include/tool/tool_event.h index 4ff93b9e05..4aedc6b05f 100644 --- a/include/tool/tool_event.h +++ b/include/tool/tool_event.h @@ -27,11 +27,12 @@ #ifndef __TOOL_EVENT_H #define __TOOL_EVENT_H -#include #include #include #include +#include + #include #include #include @@ -466,9 +467,9 @@ public: try { - param = std::any_cast( m_param ); + param = ki::any_cast( m_param ); } - catch( const std::bad_any_cast& ) + catch( const ki::bad_any_cast& ) { wxCHECK_MSG( false, T(), wxString::Format( "Requested parameter type %s from event " "with parameter type %s.", @@ -492,9 +493,9 @@ public: try { - param = std::any_cast( m_param ); + param = ki::any_cast( m_param ); } - catch( const std::bad_any_cast& ) + catch( const ki::bad_any_cast& ) { wxCHECK_MSG( false, param, wxString::Format( "Requested parameter type %s from event " "with parameter type %s.", @@ -617,7 +618,7 @@ private: COMMIT* m_commit; ///< Generic parameter used for passing non-standard data. - std::any m_param; + ki::any m_param; ///< The first tool to receive the event TOOL_BASE* m_firstResponder; diff --git a/include/tool/tool_manager.h b/include/tool/tool_manager.h index b4745cc88c..a8939312c9 100644 --- a/include/tool/tool_manager.h +++ b/include/tool/tool_manager.h @@ -150,15 +150,15 @@ public: bool RunAction( const std::string& aActionName, T aParam ) { // Use a cast to ensure the proper type is stored inside the parameter - std::any a( static_cast( aParam ) ); + ki::any a( static_cast( aParam ) ); return doRunAction( aActionName, true, a, nullptr ); } bool RunAction( const std::string& aActionName ) { - // Default initialize the parameter argument to an empty std::any - std::any a; + // Default initialize the parameter argument to an empty ki_any + ki::any a; return doRunAction( aActionName, true, a, nullptr ); } @@ -178,7 +178,7 @@ public: bool RunAction( const TOOL_ACTION& aAction, T aParam ) { // Use a cast to ensure the proper type is stored inside the parameter - std::any a( static_cast( aParam ) ); + ki::any a( static_cast( aParam ) ); return doRunAction( aAction, true, a, nullptr ); } @@ -197,23 +197,23 @@ public: bool RunSynchronousAction( const TOOL_ACTION& aAction, COMMIT* aCommit, T aParam ) { // Use a cast to ensure the proper type is stored inside the parameter - std::any a( static_cast( aParam ) ); + ki::any a( static_cast( aParam ) ); return doRunAction( aAction, true, a, aCommit ); } bool RunSynchronousAction( const TOOL_ACTION& aAction, COMMIT* aCommit ) { - // Default initialize the parameter argument to an empty std::any - std::any a; + // Default initialize the parameter argument to an empty ki_any + ki::any a; return doRunAction( aAction, true, a, aCommit ); } bool RunAction( const TOOL_ACTION& aAction ) { - // Default initialize the parameter argument to an empty std::any - std::any a; + // Default initialize the parameter argument to an empty ki_any + ki::any a; return doRunAction( aAction, true, a, nullptr ); } @@ -235,15 +235,15 @@ public: bool PostAction( const std::string& aActionName, T aParam ) { // Use a cast to ensure the proper type is stored inside the parameter - std::any a( static_cast( aParam ) ); + ki::any a( static_cast( aParam ) ); return doRunAction( aActionName, false, a, nullptr ); } bool PostAction( const std::string& aActionName ) { - // Default initialize the parameter argument to an empty std::any - std::any a; + // Default initialize the parameter argument to an empty ki_any + ki::any a; return doRunAction( aActionName, false, a, nullptr ); } @@ -262,23 +262,23 @@ public: bool PostAction( const TOOL_ACTION& aAction, T aParam ) { // Use a cast to ensure the proper type is stored inside the parameter - std::any a( static_cast( aParam ) ); + ki::any a( static_cast( aParam ) ); return doRunAction( aAction, false, a, nullptr ); } void PostAction( const TOOL_ACTION& aAction ) { - // Default initialize the parameter argument to an empty std::any - std::any a; + // Default initialize the parameter argument to an empty ki_any + ki::any a; doRunAction( aAction, false, a, nullptr ); } bool PostAction( const TOOL_ACTION& aAction, COMMIT* aCommit ) { - // Default initialize the parameter argument to an empty std::any - std::any a; + // Default initialize the parameter argument to an empty ki_any + ki::any a; return doRunAction( aAction, false, a, aCommit ); } @@ -537,8 +537,10 @@ private: /** * Helper function to actually run an action. */ - bool doRunAction( const TOOL_ACTION& aAction, bool aNow, const std::any& aParam, COMMIT* aCommit ); - bool doRunAction( const std::string& aActionName, bool aNow, const std::any& aParam, COMMIT* aCommit ); + bool doRunAction( const TOOL_ACTION& aAction, bool aNow, const ki::any& aParam, + COMMIT* aCommit ); + bool doRunAction( const std::string& aActionName, bool aNow, const ki::any& aParam, + COMMIT* aCommit ); /** * Pass an event at first to the active tools, then to all others. diff --git a/qa/tests/common/CMakeLists.txt b/qa/tests/common/CMakeLists.txt index 5619b23c59..2c3cabf860 100644 --- a/qa/tests/common/CMakeLists.txt +++ b/qa/tests/common/CMakeLists.txt @@ -39,6 +39,7 @@ set( QA_COMMON_SRCS test_eda_text.cpp test_embedded_file_compress.cpp test_increment.cpp + test_ki_any.cpp test_lib_table.cpp test_markup_parser.cpp test_kicad_string.cpp diff --git a/qa/tests/common/test_ki_any.cpp b/qa/tests/common/test_ki_any.cpp new file mode 100644 index 0000000000..f0320f443d --- /dev/null +++ b/qa/tests/common/test_ki_any.cpp @@ -0,0 +1,840 @@ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 1992-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 . + */ + +// Tests taken from GCC: +// Copyright (C) 2014-2024 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library 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, or (at your option) +// any later version. + +// This library 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +#include + +#include +#include +#include +#include + +#include + +using ki::any; +using ki::any_cast; + +////////////////////////////////////////// +// Exception hierarchy +////////////////////////////////////////// +/// +static_assert(std::is_base_of::value, + "ki::bad_any_cast must derive from std::bad_cast"); + +////////////////////////////////////////// +// Type requirements +////////////////////////////////////////// + +static_assert(std::is_assignable::value); +static_assert(!std::is_assignable>::value); +static_assert(std::is_constructible::value); +static_assert(!std::is_constructible>::value); +static_assert(!std::is_assignable&>::value); +static_assert(!std::is_constructible&>::value); +static_assert(!std::is_assignable&>::value); +static_assert(!std::is_constructible&>::value); + +struct NoDefaultCtor +{ + NoDefaultCtor() = delete; +}; + +static_assert(!std::is_constructible_v>); + +static_assert(!std::is_constructible_v&>); + +static_assert(!std::is_constructible_v&&>); + +static_assert(!std::is_constructible_v&>); + +static_assert(!std::is_constructible_v&&>); + +static_assert( std::is_copy_constructible_v> ); + +struct A { + A(const A&) = default; + explicit A(any value); +}; +static_assert(std::is_copy_constructible_v); + +BOOST_AUTO_TEST_SUITE( ki_any ) + +struct combined { + std::vector v; + std::tuple t; + template + combined(std::initializer_list il, Args&&... args) + : v(il), t(std::forward(args)...) + { + } +}; + + +BOOST_AUTO_TEST_CASE( AnyCast_1 ) +{ + using std::string; + using std::strcmp; + + any x(5); // x holds int + BOOST_CHECK(any_cast(x) == 5); // cast to value + any_cast(x) = 10; // cast to reference + BOOST_CHECK(any_cast(x) == 10); + + x = "Meow"; // x holds const char* + BOOST_CHECK(strcmp(any_cast(x), "Meow") == 0); + any_cast(x) = "Harry"; + BOOST_CHECK(strcmp(any_cast(x), "Harry") == 0); + + x = string("Meow"); // x holds string + string s, s2("Jane"); + s = std::move(any_cast(x)); // move from any + BOOST_CHECK(s == "Meow"); + any_cast(x) = std::move(s2); // move to any + BOOST_CHECK(any_cast(x) == "Jane"); + + string cat("Meow"); + const any y(cat); // const y holds string + BOOST_CHECK(any_cast(y) == cat); +} + + +BOOST_AUTO_TEST_CASE( AnyCast_2 ) +{ + using ki::bad_any_cast; + any x(1); + auto p = any_cast(&x); + BOOST_CHECK(p == nullptr); + + x = 1.0; + p = any_cast(&x); + BOOST_CHECK(p != nullptr); + + x = any(); + p = any_cast(&x); + BOOST_CHECK(p == nullptr); + + try { + any_cast(x); + BOOST_CHECK(false); + } catch (const bad_any_cast&) { + } +} + +static int move_count = 0; + +BOOST_AUTO_TEST_CASE( AnyCast_3 ) +{ + struct MoveEnabled + { + MoveEnabled(MoveEnabled&&) + { + ++move_count; + } + MoveEnabled() = default; + MoveEnabled(const MoveEnabled&) = default; + }; + MoveEnabled m; + MoveEnabled m2 = any_cast(any(m)); + BOOST_CHECK(move_count == 1); + MoveEnabled&& m3 = any_cast(any(m)); + BOOST_CHECK(move_count == 1); +} + + +BOOST_AUTO_TEST_CASE( AnyCast_4 ) +{ + struct ExplicitCopy + { + ExplicitCopy() = default; + explicit ExplicitCopy(const ExplicitCopy&) = default; + }; + any x = ExplicitCopy(); + ExplicitCopy ec{any_cast(x)}; + ExplicitCopy ec2{any_cast(std::move(x))}; +} + + +BOOST_AUTO_TEST_CASE( AnyCast_5 ) +{ + struct noncopyable { + noncopyable(noncopyable const&) = delete; + }; + + any a; + auto p = any_cast(&a); + BOOST_CHECK( p == nullptr ); +} + + +BOOST_AUTO_TEST_CASE( AnyCast_6 ) +{ + // The contained value of a std::any is always an object type, + // but any_cast does not forbid checking for function types. + + any a(1); + void (*p1)() = any_cast(&a); + BOOST_CHECK( p1 == nullptr ); + int (*p2)(int) = any_cast(&a); + BOOST_CHECK( p2 == nullptr ); + int (*p3)() = any_cast(&std::as_const(a)); + BOOST_CHECK( p3 == nullptr ); + + try { + any_cast(a); + BOOST_CHECK( false ); + } catch (const ki::bad_any_cast&) { + } + + try { + any_cast(std::move(a)); + BOOST_CHECK( false ); + } catch (const ki::bad_any_cast&) { + } + + try { + any_cast(std::as_const(a)); + BOOST_CHECK( false ); + } catch (const ki::bad_any_cast&) { + } +} + + +BOOST_AUTO_TEST_CASE( AnyCast_7 ) +{ + int arr[3]; + any a(arr); + + BOOST_CHECK( a.type() == typeid(int*) ); // contained value is decayed + int (*p1)[3] = any_cast(&a); + BOOST_CHECK( a.type() != typeid(int[3]) ); // so any_cast should return nullptr + BOOST_CHECK( p1 == nullptr ); + int (*p2)[] = any_cast(&a); + BOOST_CHECK( a.type() != typeid(int[]) ); // so any_cast should return nullptr + BOOST_CHECK( p2 == nullptr ); + const int (*p3)[] = any_cast(&std::as_const(a)); + BOOST_CHECK( p3 == nullptr ); +} + + +struct LocationAware +{ + LocationAware() { } + ~LocationAware() { BOOST_CHECK(self == this); } + LocationAware(const LocationAware&) { } + LocationAware& operator=(const LocationAware&) { return *this; } + LocationAware(LocationAware&&) noexcept { } + LocationAware& operator=(LocationAware&&) noexcept { return *this; } + + void* const self = this; +}; +static_assert(std::is_nothrow_move_constructible::value, ""); +static_assert(!std::is_trivially_copyable::value, ""); + + +BOOST_AUTO_TEST_CASE( NonTrivialType_1 ) +{ + LocationAware l; + any a = l; +} + + +BOOST_AUTO_TEST_CASE( NonTrivialType_2 ) +{ + LocationAware l; + any a = l; + any b = a; + { + any tmp = std::move(a); + a = std::move(b); + b = std::move(tmp); + } +} + + +BOOST_AUTO_TEST_CASE( NonTrivialType_3 ) +{ + LocationAware l; + any a = l; + any b = a; + swap(a, b); +} + + +BOOST_AUTO_TEST_CASE( MakeAny ) +{ + const int i = 42; + auto o = ki::make_any(i); + int& i2 = any_cast(o); + BOOST_CHECK( i2 == 42 ); + BOOST_CHECK( &i2 != &i ); + auto o2 = ki::make_any>(1, 2); + std::tuple& t = any_cast&>(o2); + BOOST_CHECK( std::get<0>(t) == 1 && std::get<1>(t) == 2); + auto o3 = ki::make_any>({42, 666}); + std::vector& v = any_cast&>(o3); + BOOST_CHECK(v[0] == 42 && v[1] == 666); + auto o4 = ki::make_any({42, 666}); + combined& c = any_cast(o4); + BOOST_CHECK(c.v[0] == 42 && c.v[1] == 666 + && std::get<0>(c.t) == 0 && std::get<1>(c.t) == 0 ); + auto o5 = ki::make_any({1, 2}, 3, 4); + combined& c2 = any_cast(o5); + BOOST_CHECK(c2.v[0] == 1 && c2.v[1] == 2 + && std::get<0>(c2.t) == 3 && std::get<1>(c2.t) == 4 ); +} + + +BOOST_AUTO_TEST_CASE( TypeObserver ) +{ + any x; + BOOST_CHECK( x.type() == typeid(void) ); + x = 1; + BOOST_CHECK( x.type() == typeid(int) ); + x = any(); + BOOST_CHECK( x.type() == typeid(void) ); +} + + +BOOST_AUTO_TEST_CASE( Swap ) +{ + any x(1); + any y; + swap(x, y); + BOOST_CHECK( !x.has_value() ); + BOOST_CHECK( y.has_value() ); +} + + +BOOST_AUTO_TEST_CASE( Modifiers ) +{ + any x(1); + any y; + x.swap(y); + BOOST_CHECK( !x.has_value() ); + BOOST_CHECK( y.has_value() ); + x.swap(y); + BOOST_CHECK( x.has_value() ); + BOOST_CHECK( !y.has_value() ); + + x.reset(); + BOOST_CHECK( !x.has_value() ); +} + + +BOOST_AUTO_TEST_CASE( Construction_InPlace_1 ) +{ + const int i = 42; + any o(std::in_place_type, i); + int& i2 = any_cast(o); + BOOST_CHECK( i2 == 42 ); + BOOST_CHECK( &i2 != &i ); + any o2(std::in_place_type>, 1, 2); + std::tuple& t = any_cast&>(o2); + BOOST_CHECK( std::get<0>(t) == 1 && std::get<1>(t) == 2); + any o3(std::in_place_type>, {42, 666}); + std::vector& v = any_cast&>(o3); + BOOST_CHECK(v[0] == 42 && v[1] == 666); + any o4(std::in_place_type, {42, 666}); + combined& c = any_cast(o4); + BOOST_CHECK(c.v[0] == 42 && c.v[1] == 666 + && std::get<0>(c.t) == 0 && std::get<1>(c.t) == 0 ); + any o5(std::in_place_type, {1, 2}, 3, 4); + combined& c2 = any_cast(o5); + BOOST_CHECK(c2.v[0] == 1 && c2.v[1] == 2 + && std::get<0>(c2.t) == 3 && std::get<1>(c2.t) == 4 ); + any o6(std::in_place_type, i); + BOOST_CHECK(o6.type() == o.type()); + any o7(std::in_place_type, nullptr); + any o8(std::in_place_type, nullptr); + BOOST_CHECK(o7.type() == o8.type()); + any o9(std::in_place_type, nullptr); + any o10(std::in_place_type, nullptr); + BOOST_CHECK(o9.type() == o10.type()); +} + +bool moved = false; +bool copied = false; + +struct X +{ + X() = default; + X(const X&) { copied = true; } + X(X&&) { moved = true; } +}; + +struct X2 +{ + X2() = default; + X2(const X2&) { copied = true; } + X2(X2&&) noexcept { moved = true; } +}; + + +BOOST_AUTO_TEST_CASE( Construction_Basic_1 ) +{ + moved = false; + X x; + any a1(x); + BOOST_CHECK(moved == false); + any a2(std::move(x)); + BOOST_CHECK(moved == true); +} + + +BOOST_AUTO_TEST_CASE( Construction_Basic_2 ) +{ + moved = false; + X x; + any a1(x); + BOOST_CHECK(moved == false); + copied = false; + any a2(std::move(a1)); + BOOST_CHECK(copied == false); +} + + +BOOST_AUTO_TEST_CASE( Construction_Basic_3 ) +{ + moved = false; + X2 x; + any a1(x); + BOOST_CHECK(moved == false); + copied = false; + any a2(std::move(a1)); + BOOST_CHECK(copied == false); + BOOST_CHECK(moved == true); +} + + +BOOST_AUTO_TEST_CASE( Construction_Basic_4) +{ + any x; + BOOST_CHECK( !x.has_value() ); + + any y(x); + BOOST_CHECK( !x.has_value() ); + BOOST_CHECK( !y.has_value() ); + + any z(std::move(y)); + BOOST_CHECK( !y.has_value() ); + BOOST_CHECK( !z.has_value() ); +} + + +BOOST_AUTO_TEST_CASE( Construction_Basic_5) +{ + any x(1); + BOOST_CHECK( x.has_value() ); + + any y(x); + BOOST_CHECK( x.has_value() ); + BOOST_CHECK( y.has_value() ); + + any z(std::move(y)); + BOOST_CHECK( !y.has_value() ); + BOOST_CHECK( z.has_value() ); +} + + +BOOST_AUTO_TEST_CASE( Construction_InPlace_2 ) +{ + auto a = any(std::in_place_type, 5); + BOOST_CHECK( any_cast(any_cast(a)) == 5 ); + + auto b = any(std::in_place_type, {1}); + (void) any_cast>(any_cast(b)); +} + + +BOOST_AUTO_TEST_CASE( Construction_Pair ) +{ + any p = std::pair(1, 1); + auto pt = any_cast>(p); + BOOST_CHECK( any_cast(pt.first) == 1 ); + BOOST_CHECK( any_cast(pt.second) == 1 ); + + any t = std::tuple(1); + auto tt = any_cast>(t); + BOOST_CHECK( any_cast(std::get<0>(tt)) == 1 ); +} + + +// Alignment requiremnts of this type prevent it being stored in 'any' +struct alignas(2 * alignof(void*)) X3 { }; + +bool +stored_internally(void* obj, const ki::any& a) +{ + std::uintptr_t a_addr = reinterpret_cast(&a); + std::uintptr_t a_end = a_addr + sizeof(a); + std::uintptr_t obj_addr = reinterpret_cast(obj); + return (a_addr <= obj_addr) && (obj_addr < a_end); +} + + +BOOST_AUTO_TEST_CASE( Construction_Alignment ) +{ + any a = X3{}; + X3& x = any_cast(a); + BOOST_CHECK( !stored_internally(&x, a) ); + + a = 'X'; + char& c = any_cast(a); + BOOST_CHECK( stored_internally(&c, a) ); +} + +struct wrapper +{ + wrapper() = default; + + wrapper(const any& t); + + wrapper(const wrapper& w); + + auto& operator=(const any& t); + + auto& operator=(const wrapper& w) + { + value = w.value; + return *this; + } + + any value; +}; + +BOOST_AUTO_TEST_CASE( Construction_Wrapper ) +{ + wrapper a, b; + a = b; +} + +// Following tests commented out until Apple Clang build version >= 16 +/* +struct aggressive_aggregate +{ + int a; + int b; +}; + +BOOST_AUTO_TEST_CASE( Construction_Aggregate_1 ) +{ + any x{std::in_place_type, 1, 2}; + BOOST_CHECK(any_cast(x).a == 1); + BOOST_CHECK(any_cast(x).b == 2); + any y{std::in_place_type, 1}; + BOOST_CHECK(any_cast(y).a == 1); + BOOST_CHECK(any_cast(y).b == 0); + any z{std::in_place_type}; + BOOST_CHECK(any_cast(z).a == 0); + BOOST_CHECK(any_cast(z).b == 0); +} + +BOOST_AUTO_TEST_CASE( Construction_Aggregate_2 ) +{ + any x; + x.emplace(1, 2); + BOOST_CHECK(any_cast(x).a == 1); + BOOST_CHECK(any_cast(x).b == 2); + x.emplace(1); + BOOST_CHECK(any_cast(x).a == 1); + BOOST_CHECK(any_cast(x).b == 0); + x.emplace(); + BOOST_CHECK(any_cast(x).a == 0); + BOOST_CHECK(any_cast(x).b == 0); +} + +*/ + +std::set live_objects; + +struct A { + A() { live_objects.insert(this); } + ~A() { live_objects.erase(this); } + A(const A& a) { BOOST_CHECK(live_objects.count(&a)); live_objects.insert(this); } +}; + +BOOST_AUTO_TEST_CASE( Assign_1 ) +{ + any a; + a = a; + BOOST_CHECK( !a.has_value() ); + + a = A{}; + a = a; + BOOST_CHECK( a.has_value() ); + + a.reset(); + BOOST_CHECK( live_objects.empty() ); +} + + +BOOST_AUTO_TEST_CASE( Assign_2 ) +{ + struct X { + any a; + }; + + X x; + std::swap(x, x); // results in "self-move-assignment" of X::a + BOOST_CHECK( !x.a.has_value() ); + + x.a = A{}; + std::swap(x, x); // results in "self-move-assignment" of X::a + BOOST_CHECK( x.a.has_value() ); + + x.a.reset(); + BOOST_CHECK( live_objects.empty() ); +} + + +BOOST_AUTO_TEST_CASE( Assign_3 ) +{ + any a; + a.swap(a); + BOOST_CHECK( !a.has_value() ); + + a = A{}; + a.swap(a); + BOOST_CHECK( a.has_value() ); + + a.reset(); + BOOST_CHECK( live_objects.empty() ); +} + + +BOOST_AUTO_TEST_CASE( Assign_4 ) +{ + moved = false; + X x; + any a1; + a1 = x; + BOOST_CHECK(moved == false); + any a2; + copied = false; + a2 = std::move(x); + BOOST_CHECK(moved == true); + BOOST_CHECK(copied == false); +} + + +BOOST_AUTO_TEST_CASE( Assign_5 ) +{ + moved = false; + X x; + any a1; + a1 = x; + BOOST_CHECK(moved == false); + any a2; + copied = false; + a2 = std::move(a1); + BOOST_CHECK(moved == false); + BOOST_CHECK(copied == false); +} + + +BOOST_AUTO_TEST_CASE( Assign_6 ) +{ + moved = false; + X2 x; + any a1; + a1 = x; + BOOST_CHECK(copied && moved); + any a2; + moved = false; + copied = false; + a2 = std::move(a1); + BOOST_CHECK(moved == true); + BOOST_CHECK(copied == false); +} + +BOOST_AUTO_TEST_CASE( Assign_7 ) +{ + any x; + any y; + y = x; + BOOST_CHECK( !x.has_value() ); + BOOST_CHECK( !y.has_value() ); + + y = std::move(x); + BOOST_CHECK( !x.has_value() ); + BOOST_CHECK( !y.has_value() ); +} + +BOOST_AUTO_TEST_CASE( Assign_8 ) +{ + any x(1); + any y; + y = x; + BOOST_CHECK( x.has_value() ); + BOOST_CHECK( y.has_value() ); + + x = std::move(y); + BOOST_CHECK( x.has_value() ); + BOOST_CHECK( !y.has_value() ); + + x = y; + BOOST_CHECK( !x.has_value() ); + BOOST_CHECK( !y.has_value() ); +} + + +bool should_throw = false; +struct Bad +{ + Bad() = default; + Bad(const Bad&) {if (should_throw) throw 666;} +}; + +struct Bad2 +{ + Bad2() = default; + Bad2(const Bad2&) {if (should_throw) throw 666;} + Bad2(Bad2&&) noexcept {} +}; + +int del_count = 0; +struct Good +{ + Good() = default; + Good(const Good&) = default; + Good(Good&&) = default; + ~Good() {++del_count;} +}; + +BOOST_AUTO_TEST_CASE( Exceptions ) +{ + any a1 = Good(); + del_count = 0; + try { + Bad b; + any a2 = b; + should_throw = true; + a1 = a2; + } catch (...) { + auto x = any_cast(a1); + BOOST_CHECK( del_count == 0 ); + BOOST_CHECK( a1.has_value() ); + any_cast(a1); + } + any a3 = Good(); + del_count = 0; + try { + Bad2 b; + any a4 = b; + should_throw = true; + a3 = a4; + } catch (...) { + auto x = any_cast(a1); + BOOST_CHECK( del_count == 0 ); + BOOST_CHECK( a1.has_value() ); + any_cast(a1); + } +} + + +BOOST_AUTO_TEST_CASE( Emplace_1 ) +{ + const int i = 42; + any o; + o.emplace(i); + int& i2 = any_cast(o); + BOOST_CHECK( i2 == 42 ); + BOOST_CHECK( &i2 != &i ); + any o2; + o2.emplace>(1, 2); + std::tuple& t = any_cast&>(o2); + BOOST_CHECK( std::get<0>(t) == 1 && std::get<1>(t) == 2); + any o3; + o3.emplace>({42, 666}); + std::vector& v = any_cast&>(o3); + BOOST_CHECK(v[0] == 42 && v[1] == 666); + any o4; + o4.emplace({42, 666}); + combined& c = any_cast(o4); + BOOST_CHECK(c.v[0] == 42 && c.v[1] == 666 + && std::get<0>(c.t) == 0 && std::get<1>(c.t) == 0 ); + any o5; + o5.emplace({1, 2}, 3, 4); + combined& c2 = any_cast(o5); + BOOST_CHECK(c2.v[0] == 1 && c2.v[1] == 2 + && std::get<0>(c2.t) == 3 && std::get<1>(c2.t) == 4 ); + any o6; + o6.emplace(i); + BOOST_CHECK(o6.type() == o.type()); + any o7; + o7.emplace(nullptr); + any o8; + o8.emplace(nullptr); + BOOST_CHECK(o7.type() == o8.type()); + any o9; + o9.emplace(nullptr); + any o10; + o10.emplace(nullptr); + BOOST_CHECK(o9.type() == o10.type()); + any o11; + BOOST_CHECK(&o11.emplace(42) == &any_cast(o11)); + BOOST_CHECK(&o11.emplace>({1,2,3}) == + &any_cast&>(o11)); +} + + + +struct X_e +{ + X_e() = default; + X_e(const X_e&) { copied = true; } + X_e(X_e&&) { moved = true; } +}; + +struct X2_e +{ + X2_e() = default; + X2_e(const X2_e&) { copied = true; } + X2_e(X2_e&&) noexcept { moved = true; } +}; + + +BOOST_AUTO_TEST_SUITE_END()