Rename occurences Libusb -> LibUsb

src/libusbwrap/LibUsbWrapper.cpp

@@ -17,91 +17,91 @@
 
  */
 
-#include "LibusbWrapper.hpp"
+#include "LibUsbWrapper.hpp"
 
 #include "libusb.h"
 
 namespace libusbwrap {
 
-// LibusbDeviceDeleter implementation
-void LibusbDeviceDeleter::operator()(libusb_device* dev) const {
+// LibUsbDeviceDeleter
+void LibUsbDeviceDeleter::operator()(libusb_device* dev) const {
     if (dev && wrapper) {
         wrapper->unrefDevice(dev);
     }
 }
 
-// LibusbWrapper implementation - thin forwarding to libusb C API
+// LibUsbWrapper
 
-int LibusbWrapper::init(libusb_context** ctx) {
+int LibUsbWrapper::init(libusb_context** ctx) {
     return libusb_init(ctx);
 }
 
-void LibusbWrapper::exit(libusb_context* ctx) {
+void LibUsbWrapper::exit(libusb_context* ctx) {
     libusb_exit(ctx);
 }
 
-ssize_t LibusbWrapper::getDeviceList(libusb_context* ctx, libusb_device*** list) {
+ssize_t LibUsbWrapper::getDeviceList(libusb_context* ctx, libusb_device*** list) {
     return libusb_get_device_list(ctx, list);
 }
 
-void LibusbWrapper::freeDeviceList(libusb_device** list, int unrefDevices) {
+void LibUsbWrapper::freeDeviceList(libusb_device** list, int unrefDevices) {
     libusb_free_device_list(list, unrefDevices);
 }
 
-void LibusbWrapper::refDevice(libusb_device* dev) {
+void LibUsbWrapper::refDevice(libusb_device* dev) {
     libusb_ref_device(dev);
 }
 
-void LibusbWrapper::unrefDevice(libusb_device* dev) {
+void LibUsbWrapper::unrefDevice(libusb_device* dev) {
     libusb_unref_device(dev);
 }
 
-int LibusbWrapper::getDeviceDescriptor(libusb_device* dev, libusb_device_descriptor* desc) {
+int LibUsbWrapper::getDeviceDescriptor(libusb_device* dev, libusb_device_descriptor* desc) {
     return libusb_get_device_descriptor(dev, desc);
 }
 
-int LibusbWrapper::open(libusb_device* dev, libusb_device_handle** handle) {
+int LibUsbWrapper::open(libusb_device* dev, libusb_device_handle** handle) {
     return libusb_open(dev, handle);
 }
 
-void LibusbWrapper::close(libusb_device_handle* handle) {
+void LibUsbWrapper::close(libusb_device_handle* handle) {
     libusb_close(handle);
 }
 
-int LibusbWrapper::getSpeed(libusb_device* dev) {
+int LibUsbWrapper::getSpeed(libusb_device* dev) {
     return libusb_get_device_speed(dev);
 }
 
-uint8_t LibusbWrapper::getBusNumber(libusb_device* dev) {
+uint8_t LibUsbWrapper::getBusNumber(libusb_device* dev) {
     return libusb_get_bus_number(dev);
 }
 
-uint8_t LibusbWrapper::getPortNumber(libusb_device* dev) {
+uint8_t LibUsbWrapper::getPortNumber(libusb_device* dev) {
     return libusb_get_port_number(dev);
 }
 
-int LibusbWrapper::kernelDriverActive(libusb_device_handle* handle, int interfaceNo) {
+int LibUsbWrapper::kernelDriverActive(libusb_device_handle* handle, int interfaceNo) {
     return libusb_kernel_driver_active(handle, interfaceNo);
 }
 
-int LibusbWrapper::detachKernelDriver(libusb_device_handle* handle, int interfaceNo) {
+int LibUsbWrapper::detachKernelDriver(libusb_device_handle* handle, int interfaceNo) {
     return libusb_detach_kernel_driver(handle, interfaceNo);
 }
 
-int LibusbWrapper::claimInterface(libusb_device_handle* handle, int interfaceNo) {
+int LibUsbWrapper::claimInterface(libusb_device_handle* handle, int interfaceNo) {
     return libusb_claim_interface(handle, interfaceNo);
 }
 
-int LibusbWrapper::releaseInterface(libusb_device_handle* handle, int interfaceNo) {
+int LibUsbWrapper::releaseInterface(libusb_device_handle* handle, int interfaceNo) {
     return libusb_release_interface(handle, interfaceNo);
 }
 
-int LibusbWrapper::bulkTransfer(libusb_device_handle* handle, uint8_t endpoint, unsigned char* data, int length,
-                                 int* transferred, unsigned int timeout) {
+int LibUsbWrapper::bulkTransfer(libusb_device_handle* handle, uint8_t endpoint, unsigned char* data, int length,
+                                int* transferred, unsigned int timeout) {
     return libusb_bulk_transfer(handle, endpoint, data, length, transferred, timeout);
 }
 
-const char* LibusbWrapper::errorName(int errorCode) {
+const char* LibUsbWrapper::errorName(int errorCode) {
     return libusb_error_name(errorCode);
 }
 

src/libusbwrap/LibUsbWrapper.hpp

@@ -19,10 +19,8 @@
 
 #pragma once
 
-#include <cstddef>
 #include <cstdint>
 #include <memory>
-#include <string>
 
 // Forward declarations to avoid pulling in libusb.h in header
 struct libusb_context;
@@ -33,26 +31,24 @@ struct libusb_device_descriptor;
 namespace libusbwrap {
 
 // Forward declaration
-class ILibusbWrapper;
+class ILibUsbWrapper;
 
 // Custom deleter for libusb_device that uses the wrapper
-// Implementation in LibusbWrapper.cpp
-struct LibusbDeviceDeleter {
-    std::shared_ptr<ILibusbWrapper> wrapper;
+struct LibUsbDeviceDeleter {
+    std::shared_ptr<ILibUsbWrapper> wrapper;
     void operator()(libusb_device* dev) const;
 };
-using LibusbDevicePtr = std::unique_ptr<libusb_device, LibusbDeviceDeleter>;
+
+using LibUsbDevicePtr = std::unique_ptr<libusb_device, LibUsbDeviceDeleter>;
 
 /**
  * @brief Thin wrapper around libusb C API
  *
  * This class provides a 1:1 mapping to libusb C functions.
- * NO LOGIC - just wraps the C calls directly.
- * All logic (RAII, error handling, etc.) belongs in UsbDevice/UsbDeviceFactory.
  */
-class ILibusbWrapper {
+class ILibUsbWrapper {
    public:
-    virtual ~ILibusbWrapper() = default;
+    virtual ~ILibUsbWrapper() = default;
 
     // Context management (raw pointers - caller manages lifecycle)
     virtual int init(libusb_context** ctx) = 0;
@@ -60,20 +56,20 @@ class ILibusbWrapper {
 
     // Device enumeration (raw pointers - caller manages lifecycle)
     virtual ssize_t getDeviceList(libusb_context* ctx, libusb_device*** list) = 0;
-    virtual void freeDeviceList(libusb_device** list, int unrefDevices) = 0;
-    virtual void refDevice(libusb_device* dev) = 0;
-    virtual void unrefDevice(libusb_device* dev) = 0;
+    virtual void freeDeviceList(libusb_device** list, int unrefDevices)       = 0;
+    virtual void refDevice(libusb_device* dev)                                = 0;
+    virtual void unrefDevice(libusb_device* dev)                              = 0;
 
     // Device descriptor
     virtual int getDeviceDescriptor(libusb_device* dev, libusb_device_descriptor* desc) = 0;
 
     // Device opening/closing (raw pointers - caller manages lifecycle)
     virtual int open(libusb_device* dev, libusb_device_handle** handle) = 0;
-    virtual void close(libusb_device_handle* handle) = 0;
+    virtual void close(libusb_device_handle* handle)                    = 0;
 
     // Device information
-    virtual int getSpeed(libusb_device* dev) = 0;
-    virtual uint8_t getBusNumber(libusb_device* dev) = 0;
+    virtual int getSpeed(libusb_device* dev)          = 0;
+    virtual uint8_t getBusNumber(libusb_device* dev)  = 0;
     virtual uint8_t getPortNumber(libusb_device* dev) = 0;
 
     // Kernel driver management
@@ -81,7 +77,7 @@ class ILibusbWrapper {
     virtual int detachKernelDriver(libusb_device_handle* handle, int interfaceNo) = 0;
 
     // Interface management
-    virtual int claimInterface(libusb_device_handle* handle, int interfaceNo) = 0;
+    virtual int claimInterface(libusb_device_handle* handle, int interfaceNo)   = 0;
     virtual int releaseInterface(libusb_device_handle* handle, int interfaceNo) = 0;
 
     // Data transfer
@@ -95,7 +91,7 @@ class ILibusbWrapper {
 /**
  * @brief Concrete implementation - thin wrapper forwarding to libusb C API
  */
-class LibusbWrapper : public ILibusbWrapper {
+class LibUsbWrapper : public ILibUsbWrapper {
    public:
     int init(libusb_context** ctx) override;
     void exit(libusb_context* ctx) override;

src/libusbwrap/UsbDevice.cpp

@@ -24,21 +24,19 @@
 
 #include "libusb.h"
 #include "libusbwrap/LibUsbTypes.hpp"
-#include "libusbwrap/LibusbWrapper.hpp"
+#include "libusbwrap/LibUsbWrapper.hpp"
 #include "libusbwrap/interface/IUsbDevice.hpp"
 
 namespace libusbwrap {
 
 // Default constructor delegates to DI constructor
 UsbDevice::UsbDevice(libusb_device* device, const libusb_device_descriptor& desc)
-    : UsbDevice(device, desc, std::make_shared<LibusbWrapper>()) {}
+    : UsbDevice(device, desc, std::make_shared<LibUsbWrapper>()) {}
 
 // Constructor with dependency injection
 UsbDevice::UsbDevice(libusb_device* device, const libusb_device_descriptor& desc,
-                     std::shared_ptr<ILibusbWrapper> libusbWrapper)
-    : mLibusb(libusbWrapper),
-      mDevice(device, LibusbDeviceDeleter{libusbWrapper}),
-      mDeviceDescriptor(desc) {
+                     std::shared_ptr<ILibUsbWrapper> libusbWrapper)
+    : mLibUsb(libusbWrapper), mDevice(device, LibUsbDeviceDeleter{libusbWrapper}), mDeviceDescriptor(desc) {
     if (!mDevice) {
         throw std::invalid_argument("device is nullptr");
     }
@@ -46,13 +44,13 @@ UsbDevice::UsbDevice(libusb_device* device, const libusb_device_descriptor& desc
 
 UsbDevice::~UsbDevice() {
     if (mIsOpen && mDeviceHandle) {
-        mLibusb->close(mDeviceHandle);
+        mLibUsb->close(mDeviceHandle);
     }
-    // mDevice auto-deleted by unique_ptr (calls LibusbDeviceDeleter)
+    // mDevice auto-deleted by unique_ptr (calls LibUsbDeviceDeleter)
 }
 
 bool UsbDevice::open() {
-    int openStatus = mLibusb->open(mDevice.get(), &mDeviceHandle);
+    int openStatus = mLibUsb->open(mDevice.get(), &mDeviceHandle);
     if (openStatus != 0) {
         mLastError = static_cast<Error>(openStatus);
         return false;
@@ -64,7 +62,7 @@ bool UsbDevice::open() {
 
 void UsbDevice::close() {
     if (mDeviceHandle) {
-        mLibusb->close(mDeviceHandle);
+        mLibUsb->close(mDeviceHandle);
         mDeviceHandle = nullptr;
         mIsOpen       = false;
     }
@@ -72,9 +70,9 @@ void UsbDevice::close() {
 
 bool UsbDevice::detachKernelDriver(int interfaceNo) {
     // TODO: cover the other status codes that can be returned
-    int kernelDriverStatus = mLibusb->kernelDriverActive(mDeviceHandle, interfaceNo);
+    int kernelDriverStatus = mLibUsb->kernelDriverActive(mDeviceHandle, interfaceNo);
     if (kernelDriverStatus == 1) {  // kernel driver is active, we have to detach to continue...
-        int detachStatus = mLibusb->detachKernelDriver(mDeviceHandle, interfaceNo);
+        int detachStatus = mLibUsb->detachKernelDriver(mDeviceHandle, interfaceNo);
         if (detachStatus != 0) {
             mLastError = static_cast<Error>(detachStatus);
             return false;
@@ -86,7 +84,7 @@ bool UsbDevice::detachKernelDriver(int interfaceNo) {
 
 bool UsbDevice::claimInterface(int interfaceNo) {
     // TODO: cover the other status codes that can be returned
-    int claimInterfaceStatus = mLibusb->claimInterface(mDeviceHandle, interfaceNo);
+    int claimInterfaceStatus = mLibUsb->claimInterface(mDeviceHandle, interfaceNo);
     if (claimInterfaceStatus != 0) {
         mLastError = static_cast<Error>(claimInterfaceStatus);
         return false;
@@ -95,7 +93,7 @@ bool UsbDevice::claimInterface(int interfaceNo) {
 }
 
 bool UsbDevice::releaseInterface(int interfaceNo) {
-    int releaseInterfaceStatus = mLibusb->releaseInterface(mDeviceHandle, interfaceNo);
+    int releaseInterfaceStatus = mLibUsb->releaseInterface(mDeviceHandle, interfaceNo);
     if (releaseInterfaceStatus != 0) {
         mLastError = static_cast<Error>(releaseInterfaceStatus);
         return false;
@@ -105,7 +103,7 @@ bool UsbDevice::releaseInterface(int interfaceNo) {
 
 bool UsbDevice::bulkTransfer(uint8_t endpoint, const std::vector<uint8_t>& data, int* tx, unsigned int timeout) {
     // TODO: implement error handling for incomplete transactions (tx length != data length)
-    int bulkTransferStatus = mLibusb->bulkTransfer(mDeviceHandle, endpoint, const_cast<unsigned char*>(data.data()),
+    int bulkTransferStatus = mLibUsb->bulkTransfer(mDeviceHandle, endpoint, const_cast<unsigned char*>(data.data()),
                                                    data.size(), tx, timeout);
     if (bulkTransferStatus != 0) {
         mLastError = static_cast<Error>(bulkTransferStatus);
@@ -119,15 +117,15 @@ const usbId UsbDevice::getUsbId() {
 }
 
 const device::Speed UsbDevice::getSpeed() {
-    return static_cast<device::Speed>(mLibusb->getSpeed(mDevice.get()));
+    return static_cast<device::Speed>(mLibUsb->getSpeed(mDevice.get()));
 }
 
 const uint8_t UsbDevice::getBusNumber() {
-    return mLibusb->getBusNumber(mDevice.get());
+    return mLibUsb->getBusNumber(mDevice.get());
 }
 
 const uint8_t UsbDevice::getPortNumber() {
-    return mLibusb->getPortNumber(mDevice.get());
+    return mLibUsb->getPortNumber(mDevice.get());
 }
 
 const Error UsbDevice::getLastError() {
@@ -135,6 +133,6 @@ const Error UsbDevice::getLastError() {
 }
 
 const std::string UsbDevice::getLastErrorString() {
-    return std::string(mLibusb->errorName(static_cast<int>(mLastError)));
+    return std::string(mLibUsb->errorName(static_cast<int>(mLastError)));
 }
 }  // namespace libusbwrap

src/libusbwrap/UsbDevice.hpp

@@ -24,19 +24,19 @@
 
 #include "libusb.h"
 #include "libusbwrap/LibUsbTypes.hpp"
-#include "libusbwrap/LibusbWrapper.hpp"
+#include "libusbwrap/LibUsbWrapper.hpp"
 #include "libusbwrap/interface/IUsbDevice.hpp"
 
 namespace libusbwrap {
 
 class UsbDevice : public IUsbDevice {
    public:
-    // Default constructor (uses real LibusbWrapper)
+    // Default constructor (uses real LibUsbWrapper)
     UsbDevice(libusb_device* device, const libusb_device_descriptor& desc);
 
     // Constructor for testing (inject mock wrapper)
     UsbDevice(libusb_device* device, const libusb_device_descriptor& desc,
-              std::shared_ptr<ILibusbWrapper> libusbWrapper);
+              std::shared_ptr<ILibUsbWrapper> libusbWrapper);
 
     ~UsbDevice() override;
 
@@ -66,11 +66,11 @@ class UsbDevice : public IUsbDevice {
     const std::string getLastErrorString() override;
 
    private:
-    std::shared_ptr<ILibusbWrapper> mLibusb;  // Injectable wrapper
+    std::shared_ptr<ILibUsbWrapper> mLibUsb;  // Injectable wrapper
 
     // RAII wrappers (UsbDevice owns the lifecycle logic)
-    LibusbDevicePtr mDevice;                       // unique_ptr with custom deleter
-    libusb_device_handle* mDeviceHandle = nullptr;  // Managed by UsbDevice (calls mLibusb->close())
+    LibUsbDevicePtr mDevice;                        // unique_ptr with custom deleter
+    libusb_device_handle* mDeviceHandle = nullptr;  // Managed by UsbDevice (calls mLibUsb->close())
 
     libusb_device_descriptor mDeviceDescriptor{0};
     std::atomic<bool> mIsOpen = false;

src/libusbwrap/UsbDeviceFactory.cpp

@@ -27,23 +27,22 @@
 #include <vector>
 
 #include "libusb.h"
-#include "libusbwrap/LibusbWrapper.hpp"
+#include "libusbwrap/LibUsbWrapper.hpp"
 #include "libusbwrap/UsbDevice.hpp"
 #include "libusbwrap/interface/IUsbDevice.hpp"
 
 namespace libusbwrap {
 
 // Default constructor delegates to DI constructor
-UsbDeviceFactory::UsbDeviceFactory() : UsbDeviceFactory(std::make_shared<LibusbWrapper>()) {}
+UsbDeviceFactory::UsbDeviceFactory() : UsbDeviceFactory(std::make_shared<LibUsbWrapper>()) {}
 
 // Constructor with dependency injection
-UsbDeviceFactory::UsbDeviceFactory(std::shared_ptr<ILibusbWrapper> libusbWrapper)
-    : mLibusb(std::move(libusbWrapper)) {}
+UsbDeviceFactory::UsbDeviceFactory(std::shared_ptr<ILibUsbWrapper> libusbWrapper) : mLibUsb(std::move(libusbWrapper)) {}
 
 UsbDeviceFactory::~UsbDeviceFactory() {
     mDeviceList.clear();  // Release devices first
     if (mContext) {
-        mLibusb->exit(mContext);
+        mLibUsb->exit(mContext);
     }
 }
 
@@ -60,7 +59,7 @@ std::vector<std::unique_ptr<IUsbDevice>> UsbDeviceFactory::findDevices(uint16_t
 ssize_t UsbDeviceFactory::refreshDeviceList() {
     libusb_device** list{nullptr};
 
-    ssize_t count = mLibusb->getDeviceList(mContext, &list);
+    ssize_t count = mLibUsb->getDeviceList(mContext, &list);
     mDeviceList.clear();
 
     if (count < 0) {
@@ -69,13 +68,13 @@ ssize_t UsbDeviceFactory::refreshDeviceList() {
         spdlog::warn("No USB devices found");
     } else {
         for (ssize_t i = 0; i < count; i++) {
-            mLibusb->refDevice(list[i]);  // Increment refcount
-            // Create LibusbDevicePtr with deleter that uses the wrapper
-            mDeviceList.emplace_back(list[i], LibusbDeviceDeleter{mLibusb});
+            mLibUsb->refDevice(list[i]);  // Increment refcount
+            // Create LibUsbDevicePtr with deleter that uses the wrapper
+            mDeviceList.emplace_back(list[i], LibUsbDeviceDeleter{mLibUsb});
         }
     }
 
-    mLibusb->freeDeviceList(list, false);  // Don't unref (we did that above)
+    mLibUsb->freeDeviceList(list, false);  // Don't unref (we did that above)
     return count;
 }
 
@@ -86,7 +85,7 @@ std::vector<std::unique_ptr<IUsbDevice>> UsbDeviceFactory::buildMaskedDeviceVect
     for (auto& dev : mDeviceList) {
         libusb_device_descriptor desc{};
 
-        int ret = mLibusb->getDeviceDescriptor(dev.get(), &desc);
+        int ret = mLibUsb->getDeviceDescriptor(dev.get(), &desc);
         spdlog::trace("Detected Device {:04x}:{:04x} ", desc.idVendor, desc.idProduct);
 
         if (ret >= 0 && ((desc.idVendor & vidMask) == vid) && ((desc.idProduct & pidMask) == pid)) {
@@ -94,14 +93,14 @@ std::vector<std::unique_ptr<IUsbDevice>> UsbDeviceFactory::buildMaskedDeviceVect
             libusb_device* raw_dev = dev.release();
 
             // Create UsbDevice with same wrapper instance
-            matchedDevices.push_back(std::make_unique<UsbDevice>(raw_dev, desc, mLibusb));
+            matchedDevices.push_back(std::make_unique<UsbDevice>(raw_dev, desc, mLibUsb));
         }
     }
     return matchedDevices;
 }
 
 bool UsbDeviceFactory::init() {
-    int err = mLibusb->init(&mContext);
+    int err = mLibUsb->init(&mContext);
 
     if (err != (int)Error::SUCCESS) {
         spdlog::error("Could not initialize libusb");

src/libusbwrap/UsbDeviceFactory.hpp

@@ -23,7 +23,7 @@
 #include <memory>
 
 #include "libusb.h"
-#include "libusbwrap/LibusbWrapper.hpp"
+#include "libusbwrap/LibUsbWrapper.hpp"
 #include "libusbwrap/UsbDevice.hpp"
 #include "libusbwrap/interface/IUsbDeviceFactory.hpp"
 
@@ -33,11 +33,11 @@ constexpr const uint16_t LIBUSB_BITMASK_ALL = 0xffff;
 
 class UsbDeviceFactory : public IUsbDeviceFactory {
    public:
-    // Default constructor (uses real LibusbWrapper)
+    // Default constructor (uses real LibUsbWrapper)
     UsbDeviceFactory();
 
     // Constructor for testing (inject mock wrapper)
-    explicit UsbDeviceFactory(std::shared_ptr<ILibusbWrapper> libusbWrapper);
+    explicit UsbDeviceFactory(std::shared_ptr<ILibUsbWrapper> libusbWrapper);
 
     virtual ~UsbDeviceFactory();
 
@@ -67,13 +67,12 @@ class UsbDeviceFactory : public IUsbDeviceFactory {
    private:
     // methods
     ssize_t refreshDeviceList();
-    std::vector<std::unique_ptr<IUsbDevice>> buildMaskedDeviceVector(uint16_t vidMask,
-                                                                     uint16_t pidMask, uint16_t vid,
+    std::vector<std::unique_ptr<IUsbDevice>> buildMaskedDeviceVector(uint16_t vidMask, uint16_t pidMask, uint16_t vid,
                                                                      uint16_t pid);
     // members
-    std::shared_ptr<ILibusbWrapper> mLibusb;
+    std::shared_ptr<ILibUsbWrapper> mLibUsb;
     libusb_context* mContext{nullptr};  // Factory manages lifecycle
-    std::vector<LibusbDevicePtr> mDeviceList{};
+    std::vector<LibUsbDevicePtr> mDeviceList{};
     bool mDeviceListInitialized = false;
 };
 }  // namespace libusbwrap

src/meson.build

@@ -7,7 +7,7 @@ ptprnt_hpps = files(
     'graphics/LabelBuilder.hpp',
     'graphics/Monochrome.hpp',
     'libusbwrap/LibUsbTypes.hpp',
-    'libusbwrap/LibusbWrapper.hpp',
+    'libusbwrap/LibUsbWrapper.hpp',
     'libusbwrap/UsbDevice.hpp',
     'libusbwrap/UsbDeviceFactory.hpp',
     'libusbwrap/interface/IUsbDevice.hpp',
@@ -27,7 +27,7 @@ ptprnt_srcs = files(
     'graphics/Label.cpp',
     'graphics/LabelBuilder.cpp',
     'graphics/Monochrome.cpp',
-    'libusbwrap/LibusbWrapper.cpp',
+    'libusbwrap/LibUsbWrapper.cpp',
     'libusbwrap/UsbDevice.cpp',
     'libusbwrap/UsbDeviceFactory.cpp',
     'printers/FakePrinter.cpp',