fix(core,meta,blocks): complete rule-of-five on flagged types (sonar cpp:S3624)

- on_scope_exit, IoThreadGuard: = delete copy and move (double-calling
  the scope-exit function / re-binding a ref member would be wrong)
- MergeByIndex, Tensor (dynamic), GeneralRegistry, immutable, Graph,
  DynamicPort, StateMachine: add explicit ~T() = default to complete
  the rule-of-five that each type had already partly declared.
- Writer, Reader (CircularBuffer): the copy-and-swap operator=(T tmp)
  was effectively move-only (copy ctor implicitly deleted by the
  user-declared move ctor). Make it explicit: take Writer&&/Reader&&,
  and = delete the copy ctor/assignment so the shape of the type is
  honest.

Skipped (sonar false positives / already correct):
 indirect — already has ~indirect() = default; conditional copy ctor
   is intentional.
 Port — already has ~Port() = default; all 5 specials declared.
 InputSpan/OutputSpan — defaulted moves are correct; dtor uses a
   runtime instanceCount guard to avoid double-cleanup on moved-from.

Signed-off-by: Ralph J. Steinhagen <r.steinhagen@gsi.de>

Author: RalphSteinhagen

blocks/timing/include/gnuradio-4.0/GpsSource.hpp

@@ -44,6 +44,11 @@ for synchronising otherwise undisciplined SDRs using their PPS)">;
 
     struct IoThreadGuard { // must be last member — destroyed first, ensuring IO thread exits before _serialPort/_parser
         bool& done;
+        explicit IoThreadGuard(bool& done_) noexcept : done(done_) {}
+        IoThreadGuard(const IoThreadGuard&)            = delete;
+        IoThreadGuard(IoThreadGuard&&)                 = delete;
+        IoThreadGuard& operator=(const IoThreadGuard&) = delete;
+        IoThreadGuard& operator=(IoThreadGuard&&)      = delete;
         ~IoThreadGuard() { gr::atomic_ref(done).wait(false); }
     };
     IoThreadGuard _ioGuard{_ioThreadDone};

core/include/gnuradio-4.0/BlockMerging.hpp

@@ -159,6 +159,7 @@ class MergeByIndex : public Block<MergeByIndex<Left, OutId, Right, InId>> {
     MergeByIndex(const MergeByIndex& other)       = delete;
     MergeByIndex& operator=(MergeByIndex& other)  = delete;
     MergeByIndex& operator=(MergeByIndex&& other) = delete;
+    ~MergeByIndex()                               = default;
 
     MergeByIndex(MergeByIndex&& other) noexcept(std::is_nothrow_move_constructible_v<Left> && std::is_nothrow_move_constructible_v<Right>) : _leftBlock(std::move(other._leftBlock)), _rightBlock(std::move(other._rightBlock)) {}
 

core/include/gnuradio-4.0/BlockRegistry.hpp

@@ -68,6 +68,7 @@ class GeneralRegistry {
         std::swap(_blockTypeHandlers, tmp._blockTypeHandlers);
         return *this;
     }
+    ~GeneralRegistry() = default;
 
 #ifdef GR_ENABLE_BLOCK_REGISTRY
     template<BlockLike TBlock>

core/include/gnuradio-4.0/CircularBuffer.hpp

@@ -465,7 +465,10 @@ class CircularBuffer {
               _offset(std::exchange(other._offset, 0)),                                           //
               _internalSpan(std::exchange(other._internalSpan, std::span<T>{})) {};
 
-        Writer& operator=(Writer tmp) noexcept {
+        Writer(const Writer&)            = delete;
+        Writer& operator=(const Writer&) = delete;
+
+        Writer& operator=(Writer&& tmp) noexcept {
             std::swap(_buffer, tmp._buffer);
             std::swap(_nRequestedSamplesToPublish, tmp._nRequestedSamplesToPublish);
             std::swap(_index, tmp._index);
@@ -719,7 +722,10 @@ class CircularBuffer {
               _nRequestedSamplesToConsume(other._nRequestedSamplesToConsume),               //
               _nSamplesConsumed(other._nSamplesConsumed) {}
 
-        Reader& operator=(Reader tmp) noexcept {
+        Reader(const Reader&)            = delete;
+        Reader& operator=(const Reader&) = delete;
+
+        Reader& operator=(Reader&& tmp) noexcept {
             std::swap(_readIndex, tmp._readIndex);
             std::swap(_readIndexCached, tmp._readIndexCached);
             std::swap(_buffer, tmp._buffer);

core/include/gnuradio-4.0/Graph.hpp

@@ -361,6 +361,7 @@ struct Graph : Block<Graph> {
     Graph(Graph&)                   = delete; // there can be only one owner of Graph
     Graph& operator=(Graph&)        = delete; // there can be only one owner of Graph
     Graph& operator=(Graph&& other) = delete;
+    ~Graph()                        = default;
 
     [[nodiscard]] std::span<const std::shared_ptr<BlockModel>> blocks() const noexcept { return _blocks; }
     [[nodiscard]] std::span<std::shared_ptr<BlockModel>>       blocks() noexcept { return _blocks; }

core/include/gnuradio-4.0/LifeCycle.hpp

@@ -191,6 +191,9 @@ class StateMachine {
     }
 
     StateMachine(StateMachine&& other) noexcept { *this = std::move(other); }
+    ~StateMachine()                              = default;
+    StateMachine(const StateMachine&)            = delete;
+    StateMachine& operator=(const StateMachine&) = delete;
 
     StateMachine& operator=(StateMachine&& other) noexcept {
         // _other's state is put in STOPPED, so that a moved-from ~Block() becomes a no-op

core/include/gnuradio-4.0/Port.hpp

@@ -1197,6 +1197,7 @@ class DynamicPort {
 
     DynamicPort(const DynamicPort& arg)            = delete;
     DynamicPort& operator=(const DynamicPort& arg) = delete;
+    ~DynamicPort()                                 = default;
 
     DynamicPort(DynamicPort&& other) noexcept : priority(other.priority), min_samples(other.min_samples), max_samples(other.max_samples), metaInfo(other.metaInfo), _accessor(std::move(other._accessor)) {}
     auto& operator=(DynamicPort&& other) noexcept {

core/include/gnuradio-4.0/Tensor.hpp

@@ -1051,6 +1051,7 @@ struct Tensor<T, Ex...> : TensorBase<T, true, Ex...> { // fully or partially dyn
     using base_t::strides;
 
     Tensor(Tensor&& other) noexcept = default;
+    ~Tensor()                       = default;
     explicit Tensor(const T& v, std::pmr::memory_resource* mr = std::pmr::get_default_resource()) {
         base_t::_data = make_container(mr);
         base_t::fill(v);

meta/include/gnuradio-4.0/meta/immutable.hpp

@@ -32,6 +32,8 @@ class immutable {
     immutable<T>& operator=(const immutable<T>& other) = delete;
     immutable<T>& operator=(immutable<T>&& other)      = delete;
 
+    ~immutable() = default;
+
     const T& value() const { return _value; }
 
     operator const T&() const { return _value; }

meta/include/gnuradio-4.0/meta/utils.hpp

@@ -886,6 +886,10 @@ template<typename Fn>
 struct on_scope_exit {
     Fn function;
     on_scope_exit(Fn fn) : function(std::move(fn)) {}
+    on_scope_exit(const on_scope_exit&)            = delete;
+    on_scope_exit(on_scope_exit&&)                 = delete;
+    on_scope_exit& operator=(const on_scope_exit&) = delete;
+    on_scope_exit& operator=(on_scope_exit&&)      = delete;
     ~on_scope_exit() { function(); }
 };