dartpy 7.0.0.dev0__cp312-cp312-manylinux_2_39_x86_64.whl

include/dart/common/Empty.hpp

@@ -0,0 +1,55 @@
+/*
+ * 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_EMPTY_HPP_
+#define DART_COMMON_EMPTY_HPP_
+
+namespace dart {
+namespace common {
+
+/// This is an empty structure which can be used as a template argument when a
+/// zero-cost placeholder is needed.
+struct Empty
+{
+};
+
+/// Used to tag arguments as blank for in variadic joiner classes such as
+/// common::CompositeJoiner and dynamics::NodeManagerJoiner
+enum NoArgTag
+{
+  NoArg
+};
+
+} // namespace common
+} // namespace dart
+
+#endif // DART_COMMON_EMPTY_HPP_

include/dart/common/Factory.hpp

@@ -0,0 +1,146 @@
+/*
+ * 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_FACTORY_HPP_
+#define DART_COMMON_FACTORY_HPP_
+
+#include <dart/common/Singleton.hpp>
+#include <dart/common/StlHelpers.hpp>
+
+#include <functional>
+#include <memory>
+#include <unordered_map>
+#include <unordered_set>
+
+namespace dart {
+namespace common {
+
+/// Implementation of the Abstract Factory Pattern.
+///
+/// Example:
+/// \code
+/// using CdFactory = Factory<std::string, CollisionDetector>;
+///
+/// auto factory = CdFactory();
+/// factory.registerCreator<FclCollisionDetector>("fcl");
+/// auto fclCd = CdFactory::create("fcl");
+/// \endcode
+template <
+    typename KeyT,
+    typename BaseT,
+    typename HeldT = std::shared_ptr<BaseT>,
+    typename... Args>
+class Factory
+{
+public:
+  struct EnumClassHash;
+
+  using This = Factory<KeyT, BaseT, HeldT>;
+  using Creator = std::function<HeldT(Args...)>;
+  template <typename Key>
+  using HashType = typename std::conditional<
+      std::is_enum<Key>::value,
+      EnumClassHash,
+      std::hash<Key>>::type;
+  using CreatorMap = std::unordered_map<KeyT, Creator, HashType<KeyT>>;
+
+  /// Default constructor.
+  Factory() = default;
+
+  /// Destructor
+  virtual ~Factory() = default;
+
+  /// Registers a object creator function with a key.
+  void registerCreator(const KeyT& key, Creator creator);
+
+  /// Registers the default object creator function with a key.
+  template <typename Derived>
+  void registerCreator(const KeyT& key);
+
+  /// Unregisters the object creator function that is registered with a key. Do
+  /// nothing if there is no creator function associated with the key.
+  void unregisterCreator(const KeyT& key);
+
+  /// Unregisters all the object creator functions.
+  void unregisterAllCreators();
+
+  /// Returns true if an object creator function is registered with the key.
+  /// Otherwise, returns false.
+  bool canCreate(const KeyT& key);
+
+  /// Creates an object of the class that is registered with a key. Returns
+  /// nullptr if there is no object creator function associated with the key.
+  HeldT create(const KeyT& key, Args&&... args);
+  // TODO(JS): Add create() for creating smart_pointers
+  // (see: https://github.com/dartsim/dart/pull/845)
+
+  /// Get a set of the keys that are available for this Creator
+  std::unordered_set<KeyT> getKeys() const;
+
+private:
+  template <typename Derived>
+  static HeldT defaultCreator(Args&&... args);
+
+  /// Object creator function map.
+  CreatorMap mCreatorMap;
+};
+
+/// Helper class to register a object creator function to the Singleton.
+template <
+    typename KeyT,
+    typename BaseT,
+    typename DerivedT,
+    typename HeldT = std::shared_ptr<BaseT>,
+    typename... Args>
+class FactoryRegistrar final
+{
+public:
+  using This = FactoryRegistrar<KeyT, BaseT, DerivedT, HeldT>;
+  using FactoryType = Factory<KeyT, BaseT, HeldT, Args...>;
+  using SingletonFactory = Singleton<FactoryType>;
+  using Creator = typename FactoryType::Creator;
+
+  /// Constructor. Interanlly, this constructor registers Derived class with
+  /// the key and the default creator function.
+  FactoryRegistrar(const KeyT& key, Creator creator);
+
+  /// Constructor. Interanlly, this constructor registers Derived class with
+  /// the key and the default creator function.
+  explicit FactoryRegistrar(const KeyT& key);
+};
+
+} // namespace common
+} // namespace dart
+
+#include <dart/common/detail/Factory-impl.hpp>
+
+#endif // DART_COMMON_FACTORY_HPP_

include/dart/common/Filesystem.hpp

@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2011-2025, The DART development contributors:
+ * https://github.com/dartsim/dart/blob/main/LICENSE
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. 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_FILESYSTEM_HPP_
+#define DART_COMMON_FILESYSTEM_HPP_
+
+#include <dart/common/Platform.hpp>
+
+#if !defined(DART_INCLUDE_STD_FILESYSTEM_EXPERIMENTAL)
+
+  // Check for feature test macro for <filesystem>
+  #if defined(__cpp_lib_filesystem)
+    #define DART_INCLUDE_STD_FILESYSTEM_EXPERIMENTAL 0
+
+  // Check for feature test macro for <experimental/filesystem>
+  #elif defined(__cpp_lib_experimental_filesystem)
+    #define DART_INCLUDE_STD_FILESYSTEM_EXPERIMENTAL 1
+
+  // We can't check if headers exist...
+  // Let's assume experimental to be safe
+  #elif !defined(__has_include)
+    #define DART_INCLUDE_STD_FILESYSTEM_EXPERIMENTAL 1
+
+  // Check if the header "<filesystem>" exists
+  #elif __has_include(<filesystem>)
+
+    // If we're compiling on Visual Studio and are not compiling with C++17, we
+    // need to use experimental
+    #ifdef _MSC_VER
+
+      // Check and include header that defines "_HAS_CXX17"
+      #if __has_include(<yvals_core.h>)
+        #include <yvals_core.h>
+
+        // Check for enabled C++17 support
+        #if defined(_HAS_CXX17) && _HAS_CXX17
+          // We're using C++17, so let's use the normal version
+          #define DART_INCLUDE_STD_FILESYSTEM_EXPERIMENTAL 0
+        #endif
+      #endif
+
+      // If the marco isn't defined yet, that means any of the other VS specific
+      // checks failed, so we need to use experimental
+      #ifndef DART_INCLUDE_STD_FILESYSTEM_EXPERIMENTAL
+        #define DART_INCLUDE_STD_FILESYSTEM_EXPERIMENTAL 1
+      #endif
+
+    // Not on Visual Studio. Let's use the normal version
+    #else // #ifdef _MSC_VER
+      #define DART_INCLUDE_STD_FILESYSTEM_EXPERIMENTAL 0
+    #endif
+
+  // Check if the header "<filesystem>" exists
+  #elif __has_include(<experimental/filesystem>)
+    #define DART_INCLUDE_STD_FILESYSTEM_EXPERIMENTAL 1
+
+  // Fail if neither header is available with a nice error message
+  #else
+    #error Could not find system header "<filesystem>" or "<experimental/filesystem>"
+  #endif
+
+  // We priously determined that we need the exprimental version
+  #if DART_INCLUDE_STD_FILESYSTEM_EXPERIMENTAL
+    // Include it
+    #include <experimental/filesystem>
+
+namespace dart::common {
+
+namespace filesystem = ::std::experimental::filesystem;
+using error_code = ::std::error_code;
+
+} // namespace dart::common
+
+  // We have a decent compiler and can use the normal version
+  #else
+    // Include it
+    #include <filesystem>
+
+namespace dart::common {
+namespace filesystem = ::std::filesystem;
+using error_code = ::std::error_code;
+} // namespace dart::common
+
+  #endif
+
+#endif // #ifndef DART_INCLUDE_STD_FILESYSTEM_EXPERIMENTAL
+
+#endif // #ifndef DART_COMMON_FILESYSTEM_HPP_

include/dart/common/FreeListAllocator.hpp

@@ -0,0 +1,162 @@
+/*
+ * 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_FREELISTALLOCATOR_HPP_
+#define DART_COMMON_FREELISTALLOCATOR_HPP_
+
+#include <dart/common/MemoryAllocator.hpp>
+#include <dart/common/MemoryAllocatorDebugger.hpp>
+
+#include <mutex>
+
+namespace dart::common {
+
+/// Most general heap memory allocator for allocating memory of various sizes.
+///
+/// This allocator preallocates a large chunk of contiguous memory on
+/// construction, using the base memory allocator and returns the fraction of
+/// the allocated memories by request. This way the class controls the timing
+/// and frequency of dynamic memory allocations to minimize the performance hit
+/// by dynamic memory allocation by the system.
+///
+/// As the name saying, this class manages the information of which part of the
+/// preallocated memory is actually used using the free list data structure.
+///
+/// If the preallocated memory is all used up, then this class allocates
+/// additional memory chunck using the base allocator.
+class FreeListAllocator : public MemoryAllocator
+{
+public:
+  using Debug = MemoryAllocatorDebugger<FreeListAllocator>;
+
+  /// Constructor
+  ///
+  /// \param[in] baseAllocator: (optional) Base memory allocator.
+  /// \param[in] initialAllocation: (optional) Bytes to initially allocate.
+  explicit FreeListAllocator(
+      MemoryAllocator& baseAllocator = MemoryAllocator::GetDefault(),
+      size_t initialAllocation = 1048576 /* 1 MB */);
+
+  /// Destructor
+  ~FreeListAllocator() override;
+
+  DART_STRING_TYPE(FreeListAllocator);
+
+  /// Returns the base allocator
+  [[nodiscard]] const MemoryAllocator& getBaseAllocator() const;
+
+  /// Returns the base allocator
+  [[nodiscard]] MemoryAllocator& getBaseAllocator();
+
+  // Documentation inherited
+  [[nodiscard]] void* allocate(size_t bytes) noexcept override;
+
+  // Documentation inherited
+  void deallocate(void* pointer, size_t bytes) override;
+
+  // Documentation inherited
+  void print(std::ostream& os = std::cout, int indent = 0) const override;
+
+private:
+  struct MemoryBlockHeader
+  {
+    /// Memory block size in bytes
+    size_t mSize;
+
+    /// Pointer to previous memory block
+    MemoryBlockHeader* mPrev;
+
+    /// Pointer to next memory block
+    MemoryBlockHeader* mNext;
+
+    /// Whether this block is used
+    bool mIsAllocated;
+
+    /// Whether the next memory block is contiguous
+    bool mIsNextContiguous;
+
+    /// Constructor
+    explicit MemoryBlockHeader(
+        size_t size,
+        MemoryBlockHeader* prev,
+        MemoryBlockHeader* next,
+        bool isNextContiguous);
+
+    /// Casts to size_t
+    size_t asSizeT() const;
+
+    /// Casts to unsigned char*
+    unsigned char* asCharPtr();
+
+    /// Casts to const unsigned char*
+    const unsigned char* asCharPtr() const;
+
+    /// Splits the memory block
+    void split(size_t sizeToSplit);
+
+    /// Merges this memory block with the given memory block
+    void merge(MemoryBlockHeader* other);
+
+#if DART_BUILD_MODE_DEBUG
+    /// [Debug only] Returns whether this memory block is valid
+    bool isValid() const;
+#endif
+  };
+
+  /// Allocates a new memory block for \c sizeToAllocate bytes
+  ///
+  /// \param[in] sizeToAllocate: The bytes to allocate.
+  /// \return The success
+  bool allocateMemoryBlock(size_t sizeToAllocate);
+
+  /// The base allocator
+  MemoryAllocator& mBaseAllocator;
+
+  /// Mutex for private variables except the base allocator
+  mutable std::mutex mMutex;
+
+  /// Pointer to the first memory block
+  MemoryBlockHeader* mFirstMemoryBlock{nullptr};
+
+  /// Pointer to the current free memory block
+  MemoryBlockHeader* mFreeBlock{nullptr};
+
+  /// The total allocated block size in bytes
+  size_t mTotalAllocatedBlockSize{0};
+
+  /// The total allocated size in bytes
+  size_t mTotalAllocatedSize{0};
+};
+
+} // namespace dart::common
+
+#endif // DART_COMMON_FREELISTALLOCATOR_HPP_

include/dart/common/IncludeWindows.hpp

@@ -0,0 +1,50 @@
+/*
+ * 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_INCLUDEWINDOWS_HPP_
+#define DART_COMMON_INCLUDEWINDOWS_HPP_
+
+#ifdef _WIN32
+  #ifdef NOMINMAX
+    #include <windows.h>
+    #undef near
+    #undef far
+  #else
+    #define NOMINMAX
+    #include <windows.h>
+    #undef NOMINMAX
+    #undef near
+    #undef far
+  #endif
+#endif
+
+#endif // DART_COMMON_INCLUDEWINDOWS_HPP_

include/dart/common/LocalResource.hpp

@@ -0,0 +1,76 @@
+/*
+ * 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_LOCALRESOURCE_HPP_
+#define DART_COMMON_LOCALRESOURCE_HPP_
+
+#include <dart/common/ClassWithVirtualBase.hpp>
+#include <dart/common/Resource.hpp>
+
+namespace dart {
+namespace common {
+
+DART_DECLARE_CLASS_WITH_VIRTUAL_BASE_BEGIN
+class LocalResource : public virtual Resource
+{
+public:
+  explicit LocalResource(const std::string& _path);
+  virtual ~LocalResource();
+
+  LocalResource(const LocalResource& _other) = delete;
+  LocalResource& operator=(const LocalResource& _other) = delete;
+
+  /// Returns true if the resource is open and in a valid state.
+  bool isGood() const;
+
+  // Documentation inherited.
+  std::size_t getSize() override;
+
+  // Documentation inherited.
+  std::size_t tell() override;
+
+  // Documentation inherited.
+  bool seek(ptrdiff_t _origin, SeekType _mode) override;
+
+  // Documentation inherited.
+  std::size_t read(
+      void* _buffer, std::size_t _size, std::size_t _count) override;
+
+private:
+  std::FILE* mFile;
+};
+DART_DECLARE_CLASS_WITH_VIRTUAL_BASE_END
+
+} // namespace common
+} // namespace dart
+
+#endif // ifndef DART_COMMON_LOCALRESOURCE_HPP_

include/dart/common/LocalResourceRetriever.hpp

@@ -0,0 +1,63 @@
+/*
+ * 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_LOCALRESOURCERETRIEVER_HPP_
+#define DART_COMMON_LOCALRESOURCERETRIEVER_HPP_
+
+#include <dart/common/ResourceRetriever.hpp>
+
+namespace dart {
+namespace common {
+
+/// LocalResourceRetriever provides access to local resources specified by
+/// file:// URIs by wrapping the standard C and C++ file manipulation routines.
+class LocalResourceRetriever : public virtual ResourceRetriever
+{
+public:
+  virtual ~LocalResourceRetriever() = default;
+
+  // Documentation inherited.
+  bool exists(const Uri& _uri) override;
+
+  // Documentation inherited.
+  ResourcePtr retrieve(const Uri& _uri) override;
+
+  // Documentation inherited.
+  std::string getFilePath(const Uri& uri) override;
+};
+
+using LocalResourceRetrieverPtr = std::shared_ptr<LocalResourceRetriever>;
+
+} // namespace common
+} // namespace dart
+
+#endif // ifndef DART_COMMON_LOCALRESOURCERETRIEVER_HPP_