dartpy 7.0.0.dev0__cp312-cp312-manylinux_2_39_x86_64.whl

include/dart/common/String.hpp

@@ -0,0 +1,71 @@
+/*
+ * 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_STRING_HPP_
+#define DART_COMMON_STRING_HPP_
+
+#include <string>
+#include <vector>
+
+namespace dart::common {
+
+/// Converts string to upper cases
+std::string toUpper(std::string str);
+
+/// Converts string to upper cases in place
+void toUpperInPlace(std::string& str);
+
+/// Converts string to lower cases
+std::string toLower(std::string str);
+
+/// Converts string to lower cases in place
+void toLowerInPlace(std::string& str);
+
+/// Trims both sides of string
+std::string trim(
+    const std::string& str, const std::string& whitespaces = " \n\r\t");
+
+/// Trims left side of string
+std::string trimLeft(
+    const std::string& str, const std::string& whitespaces = " \n\r\t");
+
+/// Trims right side of string
+std::string trimRight(
+    const std::string& str, const std::string& whitespaces = " \n\r\t");
+
+/// Splits string given delimiters
+std::vector<std::string> split(
+    const std::string& str, const std::string& delimiters = " \n\r\t");
+
+} // namespace dart::common
+
+#endif // DART_COMMON_STRING_HPP_

include/dart/common/SubPtr.hpp

@@ -0,0 +1,17 @@
+// Automatically generated backward compatibility header
+// This file is DEPRECATED and will be removed in a future release
+//
+// DEPRECATED: SubPtr.hpp is deprecated.
+// Please use sub_ptr.hpp instead.
+//
+// This header will be removed in DART 8.0.
+
+#ifndef DART_SUPPRESS_DEPRECATED_HEADER_WARNING
+#if defined(_MSC_VER)
+#  pragma message("Warning: SubPtr.hpp is deprecated. Use sub_ptr.hpp instead.")
+#elif defined(__GNUC__) || defined(__clang__)
+#  warning "SubPtr.hpp is deprecated. Use sub_ptr.hpp instead."
+#endif
+#endif // DART_SUPPRESS_DEPRECATED_HEADER_WARNING
+
+#include "dart/common//sub_ptr.hpp"

include/dart/common/Subject.hpp

@@ -0,0 +1,84 @@
+/*
+ * 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_SUBJECT_HPP_
+#define DART_COMMON_SUBJECT_HPP_
+
+#include <set>
+
+namespace dart {
+namespace common {
+
+class Observer;
+
+/// The Subject class is a base class for any object that wants to report when
+/// it gets destroyed. This is useful for complex frameworks in which it is
+/// difficult or impossible to know when an object or resource might destroyed
+/// by some other part of the code, or when special cleanup might be needed
+/// upon the destruction of an object. Simply by inheriting the Subject class,
+/// any class can have the destruction notification feature.
+///
+/// Note that the Subject class should ALWAYS be virtually inherited. No other
+/// special considerations are needed when virtually inheriting the Subject
+/// class.
+///
+/// dart::sub_ptr is a templated smart pointer that will change itself into a
+/// nullptr when its Subject is destroyed. It offers one of the easiest ways to
+/// take advantage of the Subject/Observer pattern.
+class Subject
+{
+public:
+  friend class Observer;
+
+  /// Destructor will notify all Observers that it is destructing
+  virtual ~Subject();
+
+protected:
+  /// Send a destruction notification to all Observers. This will cause all
+  /// Observers to behave as if this Subject has been permanently deleted, so it
+  /// should only be called when that behavior is desired.
+  void sendDestructionNotification() const;
+
+  /// Add an Observer to the list of Observers
+  void addObserver(Observer* _observer) const;
+
+  /// Remove an Observer from the list of Observers
+  void removeObserver(Observer* _observer) const;
+
+  /// List of current Observers
+  mutable std::set<Observer*> mObservers;
+};
+
+} // namespace common
+} // namespace dart
+
+#endif // DART_COMMON_SUBJECT_HPP_

include/dart/common/Timer.hpp

@@ -0,0 +1,119 @@
+/*
+ * 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_TIMER_HPP_
+#define DART_COMMON_TIMER_HPP_
+
+#include <string>
+
+#ifdef _WIN32
+  #include <dart/common/IncludeWindows.hpp>
+#else
+  #include <sys/time.h>
+#endif
+
+#include <dart/common/Deprecated.hpp>
+
+namespace dart {
+namespace common {
+
+/// \brief The implementation of Timer class
+///
+/// This is a definition of mTimer class.
+/// For measure the time, gettimeofday() api is used
+///
+/// \deprecated Use Stopwatch instead.
+class DART_DEPRECATED(6.13) Timer
+{
+public:
+  /// \brief Default constructor
+  explicit Timer(const std::string& _name = "Noname Timer");
+
+  /// \brief Default destructor
+  virtual ~Timer();
+
+  /// \brief Start timer
+  void start();
+
+  /// \brief Returns whether the timer is started
+  bool isStarted() const;
+
+  /// \brief Stop the timer
+  void stop();
+
+  /// \brief Return elapsed time in seconds since startTimer()
+  /// \see start()
+  double getElapsedTime();
+
+  /// \brief Return last elapsed time in seconds
+  double getLastElapsedTime() const;
+
+  /// \brief Return total elapsed time in seconds
+  double getTotalElapsedTime() const;
+
+  /// \brief Print results
+  void print();
+
+  /// \brief Return the current time of the system in seconds
+  static double getWallTime();
+
+private:
+  int mCount;
+
+#ifdef _WIN32
+  struct StopWatch
+  {
+    LARGE_INTEGER start;
+    LARGE_INTEGER stop;
+  };
+  StopWatch mTimer;
+#else
+  timeval mTimeVal;
+  double mStartedTime;
+  double mStoppedTime;
+#endif
+
+  double mLastElapsedTime;
+  double mTotalElapsedTime;
+  std::string mName;
+  bool mIsStarted;
+
+#ifdef _WIN32
+  LARGE_INTEGER mFrequency;
+  double _convLIToSecs(const LARGE_INTEGER& _L);
+#endif
+};
+
+} // namespace common
+} // namespace dart
+
+#endif // DART_COMMON_TIMER_HPP_

include/dart/common/Uri.hpp

@@ -0,0 +1,229 @@
+/*
+ * 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_URI_HPP_
+#define DART_COMMON_URI_HPP_
+
+#include <string>
+
+namespace dart {
+namespace common {
+
+class UriComponent final
+{
+public:
+  using value_type = std::string;
+  using reference_type = value_type&;
+  using reference_const_type = const value_type&;
+  using pointer_type = value_type*;
+  using pointer_const_type = const value_type*;
+
+  UriComponent();
+  UriComponent(reference_const_type _value);
+
+  operator bool() const;
+
+  bool operator!() const;
+
+  UriComponent& operator=(reference_const_type _value);
+
+  reference_type operator*();
+  reference_const_type operator*() const;
+
+  pointer_type operator->();
+  pointer_const_type operator->() const;
+
+  void assign(reference_const_type _value);
+  void reset();
+
+  reference_type get();
+  reference_const_type get() const;
+
+  reference_type get_value_or(reference_type _default);
+  reference_const_type get_value_or(reference_const_type _default) const;
+
+private:
+  bool mExists;
+  std::string mValue;
+};
+
+/// The Uri struct provides URI parsing and merging functionality based on RFC
+/// 3986.
+///
+/// We have Uri as a struct rather than class to expose member variables. Many
+/// ResourceRetreiver classes rewrite URIs to other types of URIs (e.g, resolve
+/// 'package://' URIs to 'file://' URIs), which is easier to implement if you
+/// have direct access to the URI components.
+struct Uri final
+{
+  /// Scheme, e.g. 'http', 'file', 'package'
+  UriComponent mScheme;
+
+  /// Authority, e.g. 'google.com', 'en.wikipedia.org'
+  UriComponent mAuthority;
+
+  /// Path, e.g. '/index.html', '/foo/bar.txt'
+  UriComponent mPath;
+
+  /// Query string, i.e. the part of the URI after the ?
+  UriComponent mQuery;
+
+  /// Fragment, e.g. the part of the URI after the #
+  UriComponent mFragment;
+
+  /// Constructor
+  Uri() = default;
+
+  /// Constructor that takes a URI or local path. Internally, this is equivalent
+  /// to calling fromStringOrPath(_input) after default constructor.
+  ///
+  /// We don't declare this constructor as explicit in order to allow implicit
+  /// conversion from string so that you can pass in string parameter to a
+  /// function that takes Uri.
+  Uri(const std::string& _input);
+
+  /// Constructor that takes a URI or local path as const char*. The behavior is
+  /// identical to Uri(const std::string&).
+  Uri(const char* _input);
+
+  /// Clear the URI by reset()ing all components.
+  void clear();
+
+  /// Parse a URI from a string; return success. All the components will be
+  /// cleared on failure.
+  bool fromString(const std::string& _input);
+
+  /// Parse a local path (i.e. URI with no schema) from a string; return
+  /// success. Note that the input path should be absolute path. All the
+  /// components will be cleared on failure.
+  bool fromPath(const std::string& _path);
+
+  /// Parse a URI or local path (i.e. URI with no schema) from a string; return
+  /// success. We assume that any string without a scheme is a path. All the
+  /// components will be cleared on failure.
+  bool fromStringOrPath(const std::string& _input);
+
+  /// Resolve a relative path reference; return success. All the components will
+  /// be cleared on failure.
+  bool fromRelativeUri(
+      const std::string& _base,
+      const std::string& _relative,
+      bool _strict = false);
+
+  /// Resolve a relative path reference; return success. All the components will
+  /// be cleared on failure.
+  bool fromRelativeUri(
+      const char* _base, const char* _relative, bool _strict = false);
+
+  /// Resolve a relative path reference; return success. All the components will
+  /// be cleared on failure.
+  bool fromRelativeUri(
+      const Uri& _base, const std::string& _relative, bool _strict = false);
+
+  /// Resolve a relative path reference; return success. All the components will
+  /// be cleared on failure.
+  bool fromRelativeUri(
+      const Uri& _base, const char* _relative, bool _strict = false);
+
+  /// Resolve a relative path reference; return success. All the components will
+  /// be cleared on failure.
+  bool fromRelativeUri(
+      const Uri& _base, const Uri& _relative, bool _strict = false);
+
+  /// Combine the parts of the URI into a string.
+  std::string toString() const;
+
+  /// Create URI from a string; return an empty URI on failure.
+  static Uri createFromString(const std::string& _input);
+
+  /// Create file URI from a string; return an empty URI on failure.
+  static Uri createFromPath(const std::string& _path);
+
+  /// Create general URI or file URI from a string; return an empty URI on
+  /// failure.
+  static Uri createFromStringOrPath(const std::string& _input);
+
+  /// Create URI resolving a relative path reference; return an empty URI on
+  /// failure.
+  static Uri createFromRelativeUri(
+      const std::string& _base,
+      const std::string& _relative,
+      bool _strict = false);
+
+  /// Create URI resolving a relative path reference; return an empty URI on
+  /// failure.
+  static Uri createFromRelativeUri(
+      const Uri& _base, const std::string& _relative, bool _strict = false);
+
+  /// Create URI resolving a relative path reference; return an empty URI on
+  /// failure.
+  static Uri createFromRelativeUri(
+      const Uri& _base, const Uri& _relative, bool _strict = false);
+
+  /// Parse a URI from a string; return an empty string on failure.
+  static std::string getUri(const std::string& _input);
+
+  /// Resolve a relative path reference; return an empty string on failure.
+  static std::string getRelativeUri(
+      const std::string& _base,
+      const std::string& _relative,
+      bool _strict = false);
+
+  /// Resolve a relative path reference; return an empty string on failure.
+  static std::string getRelativeUri(
+      const Uri& _base, const std::string& _relative, bool _strict = false);
+
+  /// Resolve a relative path reference; return an empty string on failure.
+  static std::string getRelativeUri(
+      const Uri& _base, const Uri& _relative, bool _strict = false);
+
+  /// Get the path component of the URI as a string.
+  std::string getPath() const;
+
+  /// Get the path in the local filesystem as a string. You should use this
+  /// function rather than getPath() if you are trying to access a local file.
+  /// Note that this function is identical to getPath() for Unix systems, but
+  /// differ by the leading '/' on Windows.
+  std::string getFilesystemPath() const;
+
+private:
+  /// Implement section 5.2.3 of RFC 3986.
+  static std::string mergePaths(const Uri& _base, const Uri& _relative);
+
+  /// Implement section 5.2.4 of RFC 3986.
+  static std::string removeDotSegments(const std::string& _path);
+};
+
+} // namespace common
+} // namespace dart
+
+#endif // ifndef DART_COMMON_URI_HPP_

include/dart/common/VersionCounter.hpp

@@ -0,0 +1,68 @@
+/*
+ * 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_VERSIONCOUNTER_HPP_
+#define DART_COMMON_VERSIONCOUNTER_HPP_
+
+#include <cstddef>
+
+namespace dart {
+namespace common {
+
+/// VersionCounter is an interface for objects that count their versions
+class VersionCounter
+{
+public:
+  /// Default constructor
+  VersionCounter();
+
+  /// Increment the version for this object
+  virtual std::size_t incrementVersion();
+
+  /// Get the version number of this object
+  virtual std::size_t getVersion() const;
+
+  virtual ~VersionCounter() = default;
+
+protected:
+  void setVersionDependentObject(VersionCounter* dependent);
+
+  std::size_t mVersion;
+
+private:
+  VersionCounter* mDependent;
+};
+
+} // namespace common
+} // namespace dart
+
+#endif // DART_COMMON_VERSIONCOUNTER_HPP_

include/dart/common/Virtual.hpp

@@ -0,0 +1,51 @@
+/*
+ * 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_VIRTUAL_HPP_
+#define DART_COMMON_VIRTUAL_HPP_
+
+namespace dart {
+namespace common {
+
+/// This class is used to have CRTP functions inherit their template parameters
+/// virtually instead of directly.
+template <class T>
+class Virtual : public virtual T
+{
+public:
+  virtual ~Virtual() = default;
+};
+
+} // namespace common
+} // namespace dart
+
+#endif // DART_COMMON_VIRTUAL_HPP_