signaler.h

Go to the documentation of this file.

/****************************************************************************
 *   This file is part of the aGrUM/pyAgrum library.                        *
 *                                                                          *
 *   Copyright (c) 2005-2026 by                                             *
 *       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 *
 *       - Christophe GONZALES(_at_AMU)                                     *
 *                                                                          *
 *   The aGrUM/pyAgrum library is free software; you can redistribute it    *
 *   and/or modify it under the terms of either :                           *
 *                                                                          *
 *    - the GNU Lesser General Public License as published by               *
 *      the Free Software Foundation, either version 3 of the License,      *
 *      or (at your option) any later version,                              *
 *    - the MIT license (MIT),                                              *
 *    - or both in dual license, as here.                                   *
 *                                                                          *
 *   (see https://agrum.gitlab.io/articles/dual-licenses-lgplv3mit.html)    *
 *                                                                          *
 *   This aGrUM/pyAgrum library is distributed in the hope that it will be  *
 *   useful, but WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,          *
 *   INCLUDING BUT NOT LIMITED TO THE WARRANTIES MERCHANTABILITY or FITNESS *
 *   FOR A PARTICULAR PURPOSE  AND NONINFRINGEMENT. IN NO EVENT SHALL THE   *
 *   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
 *   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,        *
 *   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR  *
 *   OTHER DEALINGS IN THE SOFTWARE.                                        *
 *                                                                          *
 *   See LICENCES for more details.                                         *
 *                                                                          *
 *   SPDX-FileCopyrightText: Copyright 2005-2026                            *
 *       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 *
 *       - Christophe GONZALES(_at_AMU)                                     *
 *   SPDX-License-Identifier: LGPL-3.0-or-later OR MIT                      *
 *                                                                          *
 *   Contact  : info_at_agrum_dot_org                                       *
 *   homepage : http://agrum.gitlab.io                                      *
 *   gitlab   : https://gitlab.com/agrumery/agrum                           *
 *                                                                          *
 ****************************************************************************/

 
#ifndef GUM_SIGNALER_H
#define GUM_SIGNALER_H
 
#include <algorithm>
#include <functional>
#include <vector>
 
#include <agrum/agrum.h>
 
#include <agrum/base/core/signal/listener.h>
 
namespace gum {
 
  namespace __sig__ {
 
    // =========================================================================
    // IConnector<Args...> : Abstract interface for connectors with any args
    // =========================================================================
    template < typename... Args >
    class IConnector {
      public:
      virtual ~IConnector() = default;

      virtual Listener* target() const = 0;

      virtual void notify(const void* src, Args... args) = 0;

      virtual IConnector< Args... >* clone() const = 0;

      [[nodiscard]] virtual IConnector< Args... >* duplicate(Listener* newTarget) const = 0;
    };
 
    // =========================================================================
    // Connector<TargetClass, Args...> : Concrete connector implementation
    // =========================================================================
    template < class TargetClass, typename... Args >
    class Connector: public IConnector< Args... > {
      public:
      using ActionType = void (TargetClass::*)(const void*, Args...);

      Connector() : _target_(nullptr), _action_(nullptr) { GUM_CONSTRUCTOR(Connector); }

      Connector(TargetClass* target, ActionType action);

      Connector(const Connector& src);

      ~Connector() override { GUM_DESTRUCTOR(Connector); }

      Listener* target() const override;

      void notify(const void* src, Args... args) override;

      IConnector< Args... >* clone() const override;

      [[nodiscard]] IConnector< Args... >* duplicate(Listener* newTarget) const override;
 
      private:
      TargetClass* _target_;
      ActionType   _action_;
    };
 
    // =========================================================================
    // BasicSignaler<Args...> : Base signaler with connector management
    // =========================================================================
    template < typename... Args >
    class BasicSignaler: public ISignaler {
      protected:
      using ConnectorList = std::vector< IConnector< Args... >* >;

      BasicSignaler() { GUM_CONSTRUCTOR(BasicSignaler); }

      BasicSignaler(const BasicSignaler& other);
 
      public:
      ~BasicSignaler() override;

      bool hasListener() override;

      void detach(Listener* target);
 
      protected:
      friend class gum::Listener;

      void detachFromTarget(Listener* target) override;

      void duplicateTarget(const Listener* oldTarget, Listener* newTarget) override;
 
      ConnectorList _connectors_;
    };
 
  }   // namespace __sig__
 
  // ===========================================================================
  // Signaler<Args...> : The main variadic signaler class
  // ===========================================================================
  template < typename... Args >
  class Signaler: public __sig__::BasicSignaler< Args... > {
    public:
    Signaler() { GUM_CONSTRUCTOR(Signaler); }

    Signaler(const Signaler& other);

    ~Signaler() override { GUM_DESTRUCTOR(Signaler); }

    template < class TargetClass >
    void attach(TargetClass* target, void (TargetClass::*action)(const void*, Args...));

    void operator()(const void* src, Args... args);
  };
 
  // ===========================================================================
  // Signaler0 : Alias for Signaler<> (signal with no arguments)
  // ===========================================================================
  using Signaler0 = Signaler<>;
 
}   // namespace gum
 
// ===========================================================================
// Emit macros
// ===========================================================================

#define GUM_EMIT0(signal) (signal)(this)

#define GUM_EMIT_ARGS(signal, ...) (signal)(this, __VA_ARGS__)
 
// Legacy macros for backward compatibility (all map to GUM_EMIT_ARGS)
#define GUM_EMIT1(signal, arg1)                   GUM_EMIT_ARGS(signal, arg1)
#define GUM_EMIT2(signal, arg1, arg2)             GUM_EMIT_ARGS(signal, arg1, arg2)
#define GUM_EMIT3(signal, arg1, arg2, arg3)       GUM_EMIT_ARGS(signal, arg1, arg2, arg3)
#define GUM_EMIT4(signal, arg1, arg2, arg3, arg4) GUM_EMIT_ARGS(signal, arg1, arg2, arg3, arg4)
#define GUM_EMIT5(signal, arg1, arg2, arg3, arg4, arg5) \
  GUM_EMIT_ARGS(signal, arg1, arg2, arg3, arg4, arg5)
#define GUM_EMIT6(signal, arg1, arg2, arg3, arg4, arg5, arg6) \
  GUM_EMIT_ARGS(signal, arg1, arg2, arg3, arg4, arg5, arg6)
#define GUM_EMIT7(signal, arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
  GUM_EMIT_ARGS(signal, arg1, arg2, arg3, arg4, arg5, arg6, arg7)

#define GUM_CONNECT(sender, signal, receiver, target) (sender).signal.attach(&(receiver), &target)
 
#include <agrum/base/core/signal/signaler_tpl.h>
 
#endif   // GUM_SIGNALER_H