dartpy 7.0.0.dev0__cp312-cp312-manylinux_2_39_x86_64.whl

include/dart/common/Resource.hpp

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_COMMON_RESOURCE_HPP_
+#define DART_COMMON_RESOURCE_HPP_
+
+#include <memory>
+#include <string>
+
+#include <cstddef>
+
+namespace dart {
+namespace common {
+
+/// \brief Resource provides file-like access to a resource loaded from URI.
+///
+/// It is expected that each \a ResourceRetriever will provide a concrete /
+/// instantiation of the Resource class. This interface exposes an similar API
+/// to that of the the standard C file manipulation functions.
+class Resource
+{
+public:
+  /// \brief Position to seek relative to.
+  enum SeekType
+  {
+    SEEKTYPE_CUR, ///< Current position.
+    SEEKTYPE_END, ///< End of file.
+    SEEKTYPE_SET  ///< Begining of file.
+  };
+
+  virtual ~Resource() = default;
+
+  /// \brief Return the size of the resource, in bytes.
+  virtual std::size_t getSize() = 0;
+
+  /// \brief Return the current value of the position indicator.
+  /// \note This method has the same API as the standard ftell function.
+  virtual std::size_t tell() = 0;
+
+  /// \brief Set the position indicator to a new position.
+  /// \param[in] _offset Offset, in bytes, relative to _origin.
+  /// \param[in] _origin Position used as the reference of _offset.
+  /// \note This method has the same API as the standard fseek function.
+  virtual bool seek(ptrdiff_t _offset, SeekType _origin) = 0;
+
+  /// \brief Read _count element, each of size _size, into _buffer.
+  /// \param[out] _buffer Pointer to a block of memory with a size of at least
+  ///                     (_size * _count) bytes.
+  /// \param[in] _size Size, in bytes, of each element.
+  /// \param[in] _count Number of elements, each of _size bytes.
+  /// \note This method has the same API as the standard fread function.
+  virtual std::size_t read(void* _buffer, std::size_t _size, std::size_t _count)
+      = 0;
+
+  /// Reads all data from this resource, and returns it as a string.
+  ///
+  /// \return The string retrieved from the resource.
+  /// \throw std::runtime_error when failed to read sucessfully.
+  virtual std::string readAll();
+};
+
+using ResourcePtr = std::shared_ptr<Resource>;
+
+} // namespace common
+} // namespace dart
+
+#endif // ifndef DART_COMMON_RESOURCE_HPP_

include/dart/common/ResourceRetriever.hpp

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_COMMON_RESOURCERETRIEVER_HPP_
+#define DART_COMMON_RESOURCERETRIEVER_HPP_
+
+#include <dart/common/Resource.hpp>
+#include <dart/common/Uri.hpp>
+
+#include <memory>
+#include <string>
+
+namespace dart {
+namespace common {
+
+/// ResourceRetriever provides methods for testing for the existance of and
+/// accessing the content of a resource specified by URI.
+class ResourceRetriever
+{
+public:
+  virtual ~ResourceRetriever() = default;
+
+  /// Returns whether the resource specified by a URI exists.
+  virtual bool exists(const Uri& uri) = 0;
+
+  /// Returns the resource specified by a URI or nullptr on failure.
+  virtual ResourcePtr retrieve(const Uri& uri) = 0;
+
+  /// Reads all data from the resource of uri, and returns it as a string.
+  ///
+  /// \param[in] uri URI to the resource to be retrieved.
+  /// \return The string retrieved from the resource.
+  /// \throw std::runtime_error when failed to read sucessfully.
+  virtual std::string readAll(const Uri& uri);
+
+  /// Returns absolute file path to \c uri; an empty string if unavailable.
+  ///
+  /// This base class returns an empty string by default.
+  virtual std::string getFilePath(const Uri& uri);
+
+  // We don't const-qualify for exists, retrieve, readAll, and getFilePath here.
+  // Derived classes of ResourceRetriever will be interacting with external
+  // resources that you don't necessarily have control over so we cannot
+  // guarantee that you get the same result every time with the same input Uri.
+  // Indeed, const-qualification for those functions is pointless.
+};
+
+using ResourceRetrieverPtr = std::shared_ptr<ResourceRetriever>;
+
+} // namespace common
+} // namespace dart
+
+#endif // ifndef DART_COMMON_RESOURCERETRIEVER_HPP_

include/dart/common/SharedLibrary.hpp

@@ -0,0 +1,201 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_COMMON_SHAREDLIBRARY_HPP_
+#define DART_COMMON_SHAREDLIBRARY_HPP_
+
+#include <dart/common/Deprecated.hpp>
+#include <dart/common/Filesystem.hpp>
+#include <dart/common/Platform.hpp>
+
+#include <memory>
+#include <string>
+
+#if DART_OS_LINUX
+
+  #define DYNLIB_HANDLE void*
+
+#elif DART_OS_MACOS
+
+  #define DYNLIB_HANDLE void*
+
+#elif DART_OS_WINDOWS
+
+  #include <dart/common/IncludeWindows.hpp>
+using hInstance = HINSTANCE__*;
+  #define DYNLIB_HANDLE hInstance
+
+#endif
+
+#if DART_OS_LINUX
+static constexpr const char* DART_SHARED_LIB_EXTENSION = "so";
+#elif DART_OS_MACOS
+static constexpr const char* DART_SHARED_LIB_EXTENSION = "dylib";
+#elif DART_OS_WINDOWS
+static constexpr const char* DART_SHARED_LIB_EXTENSION = "dll";
+#else
+  #error Unhandled platform
+#endif
+
+#if DART_OS_LINUX
+static constexpr const char* DART_SHARED_LIB_PREFIX = "lib";
+#elif DART_OS_MACOS
+static constexpr const char* DART_SHARED_LIB_PREFIX = "lib";
+#elif DART_OS_WINDOWS
+static constexpr const char* DART_SHARED_LIB_PREFIX = "";
+#else
+  #error Unhandled platform
+#endif
+
+namespace dart {
+namespace common {
+
+namespace detail {
+class SharedLibraryManager;
+} // namespace detail
+
+/// SharedLibrary is a RAII object wrapping a shared library.
+class SharedLibrary
+{
+protected:
+  enum ProtectedConstructionTag
+  {
+    ProtectedConstruction
+  };
+
+public:
+  /// Creates a SharedLibrary from a path to the shared library.
+  ///
+  /// \note SharedLibrary should be always created from this create function.
+  /// \param[in] path The path to the shared library. The path can be a relative
+  /// path or an absolute path. If the path doens't exist this function returns
+  /// nullptr. If the path exist, the path will be stored as the canonical path
+  /// where a canonical path is an absolute path that has no elements which are
+  /// symbolic links, and no dot or dot dot elements such as
+  /// "/path/../to/yourfile".
+  /// \return Pointer to the created SharedLibrary upon success in loading.
+  /// Otherwise, returns nullptr.
+  /// \deprecated Deprecated in 6.10. Please use create(const std::string&)
+  /// instead.
+  DART_DEPRECATED(6.10)
+  static std::shared_ptr<SharedLibrary> create(
+      const common::filesystem::path& path);
+
+  /// Creates a SharedLibrary from a path to the shared library.
+  ///
+  /// \note SharedLibrary should be always created from this create function.
+  /// \param[in] path The path to the shared library. The path can be a relative
+  /// path or an absolute path. If the path doens't exist this function returns
+  /// nullptr. If the path exist, the path will be stored as the canonical path
+  /// where a canonical path is an absolute path that has no elements which are
+  /// symbolic links, and no dot or dot dot elements such as
+  /// "/path/../to/yourfile".
+  /// \return Pointer to the created SharedLibrary upon success in loading.
+  /// Otherwise, returns nullptr.
+  static std::shared_ptr<SharedLibrary> create(const std::string& path);
+
+  /// Constructs from a path to the shared library.
+  ///
+  /// This constructor is only called by detail::SharedLibraryManager.
+  /// ProtectedConstructionTag is necessary to enforce creating SharedLibrary
+  /// using std::make_shared.
+  ///
+  /// \note Please use create() to contruct SharedLibrary instead of this
+  /// constructor.
+  /// \param[in] path The canonical path to the shared library.
+  /// \return Pointer to the created SharedLibrary upon success in loading.
+  /// Otherwise, returns nullptr.
+  /// \deprecated Deprecated in 6.10. Please use
+  /// SharedLibrary(ProtectedConstructionTag, const std::string&) instead.
+  DART_DEPRECATED(6.10)
+  explicit SharedLibrary(
+      ProtectedConstructionTag, const common::filesystem::path& path);
+
+  /// Constructs from a path to the shared library.
+  ///
+  /// This constructor is only called by detail::SharedLibraryManager.
+  /// ProtectedConstructionTag is necessary to enforce creating SharedLibrary
+  /// using std::make_shared.
+  ///
+  /// \note Please use create() to contruct SharedLibrary instead of this
+  /// constructor.
+  /// \param[in] path The canonical path to the shared library.
+  /// \return Pointer to the created SharedLibrary upon success in loading.
+  /// Otherwise, returns nullptr.
+  explicit SharedLibrary(ProtectedConstructionTag, const std::string& path);
+
+  /// Destructor.
+  virtual ~SharedLibrary();
+
+  /// Returns the path to the shared library file.
+  const common::filesystem::path& getCanonicalPath() const;
+
+  /// Returns the path to the shared library file.
+  const std::string& path() const;
+
+  /// Returns true if the shared library loading was successful.
+  bool isValid() const;
+
+  /// Returns a symbol from the shared library if it exists. Return nullptr
+  /// otherwise.
+  ///
+  /// You have to reinterpret_cast the return value to the appropriate type to
+  /// make use of the void* returned by this function.
+  void* getSymbol(const std::string& symbolName) const;
+
+protected:
+  friend class detail::SharedLibraryManager;
+
+  /// Canonical path to the shared library where a canonical path is an absolute
+  /// path that has no elements which are symbolic links, and no dot or dot dot
+  /// elements such as "/path/../to/yourfile".
+  /// \deprecated Use mCanonicalPath2 instead.
+  common::filesystem::path mCanonicalPath;
+  // TODO(JS): Remove in DART 7.
+
+  /// Canonical path to the shared library where a canonical path is an absolute
+  /// path that has no elements which are symbolic links, and no dot or dot dot
+  /// elements such as "/path/../to/yourfile".
+  std::string mPath;
+
+  /// Handle to the loaded library.
+  DYNLIB_HANDLE mInstance;
+
+private:
+  /// Returns the last loading error.
+  std::string getLastError() const;
+};
+
+} // namespace common
+} // namespace dart
+
+#endif // DART_COMMON_SHAREDLIBRARY_HPP_

include/dart/common/Signal.hpp

@@ -0,0 +1,250 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors
+ * All rights reserved.
+ *
+ * The list of contributors can be found at:
+ *   https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * This file is provided under the following "BSD-style" License:
+ *   Redistribution and use in source and binary forms, with or
+ *   without modification, are permitted provided that the following
+ *   conditions are met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *   POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DART_COMMON_SIGNAL_HPP_
+#define DART_COMMON_SIGNAL_HPP_
+
+#include <dart/common/Deprecated.hpp>
+#include <dart/common/detail/ConnectionBody.hpp>
+
+#include <functional>
+#include <memory>
+#include <set>
+
+namespace dart {
+namespace common {
+
+/// class Connection
+class Connection
+{
+public:
+  /// Default constructor
+  Connection();
+
+  /// Copy constructor
+  Connection(const Connection& other);
+
+  /// Move constructor
+  Connection(Connection&& other);
+
+  /// Assignment operator
+  Connection& operator=(const Connection& other);
+
+  /// Move assignment operator
+  Connection& operator=(Connection&& other);
+
+  /// Destructor
+  virtual ~Connection();
+
+  /// Get true if the slot is connected
+  [[nodiscard]] bool isConnected() const;
+
+  /// Disconnect the connection
+  void disconnect() const;
+  // TODO(JS): Make this non-const in the next major release
+
+  template <typename Signature, template <class> class Combiner>
+  friend class Signal;
+
+protected:
+  /// Constructor given connection body
+  Connection(
+      const std::weak_ptr<signal::detail::ConnectionBodyBase>& connectionBody);
+
+  /// Move constructor given connection body
+  Connection(
+      std::weak_ptr<signal::detail::ConnectionBodyBase>&& connectionBody);
+
+private:
+  /// Weak pointer to connection body in the signal
+  std::weak_ptr<signal::detail::ConnectionBodyBase> mWeakConnectionBody;
+};
+
+/// class ScopedConnection
+class ScopedConnection : public Connection
+{
+public:
+  /// Default constructor
+  ScopedConnection(const Connection& other);
+
+  /// Move constructor
+  ScopedConnection(Connection&& other);
+
+  /// Destructor
+  virtual ~ScopedConnection();
+};
+
+template <
+    typename _Signature,
+    template <class> class Combiner = signal::detail::DefaultCombiner>
+class Signal;
+
+/// Signal implements a signal/slot mechanism
+template <typename _Res, typename... _ArgTypes, template <class> class Combiner>
+class Signal<_Res(_ArgTypes...), Combiner>
+{
+public:
+  using ResultType = _Res;
+  using SlotType = std::function<ResultType(_ArgTypes...)>;
+  using SignalType = Signal<_Res(_ArgTypes...), Combiner>;
+
+  using ConnectionBodyType = signal::detail::ConnectionBody<Signal>;
+  using ConnectionSetType = std::set<
+      std::shared_ptr<ConnectionBodyType>,
+      std::owner_less<std::shared_ptr<ConnectionBodyType>>>;
+
+  /// Constructor
+  Signal();
+
+  /// Destructor
+  virtual ~Signal();
+
+  /// Connect a slot to the signal
+  Connection connect(const SlotType& slot);
+
+  /// Connect a slot to the signal
+  Connection connect(SlotType&& slot);
+
+  /// Disconnect given connection
+  void disconnect(const Connection& connection) const;
+
+  /// Disconnect a connection
+  void disconnect(const std::shared_ptr<ConnectionBodyType>& connectionBody);
+
+  /// Disconnect all the connections
+  void disconnectAll();
+
+  /// Cleanup all the disconnected connections
+  DART_DEPRECATED(6.10)
+  void cleanupConnections();
+  // This explicit connection cleaning is no longer necessary because now a
+  // connection gets removed when it's disconnected.
+
+  /// Get the number of connections
+  [[nodiscard]] std::size_t getNumConnections() const;
+
+  /// Raise the signal
+  template <typename... ArgTypes>
+  ResultType raise(ArgTypes&&... _args);
+
+  /// Raise the signal
+  template <typename... ArgTypes>
+  ResultType operator()(ArgTypes&&... _args);
+
+private:
+  /// Connection set
+  ConnectionSetType mConnectionBodies;
+};
+
+/// Signal implements a signal/slot mechanism for the slots don't return a value
+template <typename... _ArgTypes>
+class Signal<void(_ArgTypes...)>
+{
+public:
+  using SlotType = std::function<void(_ArgTypes...)>;
+  using SignalType = Signal<void(_ArgTypes...)>;
+
+  using ConnectionBodyType = signal::detail::ConnectionBody<Signal>;
+  using ConnectionSetType = std::set<
+      std::shared_ptr<ConnectionBodyType>,
+      std::owner_less<std::shared_ptr<ConnectionBodyType>>>;
+
+  /// Constructor
+  Signal();
+
+  /// Destructor
+  virtual ~Signal();
+
+  /// Connect a slot to the signal
+  Connection connect(const SlotType& slot);
+
+  /// Connect a slot to the signal
+  Connection connect(SlotType&& slot);
+
+  /// Disconnect given connection
+  void disconnect(const Connection& connection) const;
+
+  /// Disconnect given connection
+  void disconnect(const std::shared_ptr<ConnectionBodyType>& connectionBody);
+
+  /// Disconnect all the connections
+  void disconnectAll();
+
+  /// Cleanup all the disconnected connections
+  DART_DEPRECATED(6.10)
+  void cleanupConnections();
+  // This explicit connection cleaning is no longer necessary because now a
+  // connection gets removed when it's disconnected.
+
+  /// Get the number of connections
+  [[nodiscard]] std::size_t getNumConnections() const;
+
+  /// Raise the signal
+  template <typename... Args>
+  void raise(Args&&... args);
+
+  /// Raise the signal
+  template <typename... Args>
+  void operator()(Args&&... args);
+
+private:
+  /// Connection set
+  ConnectionSetType mConnectionBodies;
+};
+
+/// SlotRegister can be used as a public member for connecting slots to a
+/// private Signal member. In this way you won't have to write forwarding
+/// connect/disconnect boilerplate for your classes.
+template <typename T>
+class SlotRegister
+{
+public:
+  using SlotType = typename T::SlotType;
+  using SignalType = typename T::SignalType;
+
+  /// Constructor given signal
+  SlotRegister(SignalType& signal);
+
+  /// Connect a slot to the signal
+  Connection connect(const SlotType& slot);
+
+private:
+  /// Signal
+  SignalType& mSignal;
+};
+
+} // namespace common
+} // namespace dart
+
+#include <dart/common/detail/Signal.hpp>
+
+#endif // DART_COMMON_SIGNAL_HPP_