Add OBPath and OBPathStorage

Author: Kyle-Ye

Package.resolved

@@ -30,6 +30,12 @@ let includePath = SDKPath.appending("/usr/lib/swift")
 
 let sharedCSettings: [CSetting] = [
     .unsafeFlags(["-I", includePath], .when(platforms: .nonDarwinPlatforms)),
+    .unsafeFlags(["-fmodules"]),
+    .define("__COREFOUNDATION_FORSWIFTFOUNDATIONONLY__", to: "1", .when(platforms: .nonDarwinPlatforms)),
+]
+let sharedCxxSettings: [CXXSetting] = [
+    .unsafeFlags(["-I", includePath], .when(platforms: .nonDarwinPlatforms)),
+    .unsafeFlags(["-fcxx-modules"]),
     .define("__COREFOUNDATION_FORSWIFTFOUNDATIONONLY__", to: "1", .when(platforms: .nonDarwinPlatforms)),
 ]
 let sharedSwiftSettings: [SwiftSetting] = [
@@ -40,7 +46,8 @@ let sharedSwiftSettings: [SwiftSetting] = [
 
 let openBoxTarget = Target.target(
     name: "OpenBox",
-    cSettings: sharedCSettings
+    cSettings: sharedCSettings,
+    cxxSettings: sharedCxxSettings
 )
 let openBoxShimsTarget = Target.target(
     name: "OpenBoxShims",
@@ -69,7 +76,7 @@ let package = Package(
     name: "OpenBox",
     products: [
         .library(name: "OpenBox", type: .dynamic, targets: ["OpenBox"]),
-        .library(name: "OpenBoxShims", targets: ["OpenBoxShims"]),
+        .library(name: "OpenBoxShims", type: .dynamic, targets: ["OpenBoxShims"]),
     ],
     dependencies: [
         .package(url: "https://github.com/apple/swift-numerics", from: "1.0.2"),

Package.swift

@@ -0,0 +1,16 @@
+//
+//  OBPath.cpp
+//  OpenBox
+//
+//  Created by Kyle on 2025/3/25.
+//
+
+#include "OBPath.h"
+
+void OBPathRetain(OBPath path) {
+    // TODO
+}
+
+void OBPathRelease(OBPath path) {
+    // TODO
+}

Sources/OpenBox/Path/OBPath.cpp

@@ -0,0 +1,54 @@
+//
+//  OBPathStorage.cpp
+//  OpenBox
+
+#include "OBPathStorage.h"
+#include "PathStorage.hpp"
+#include "../Util/assert.hpp"
+
+using namespace OB;
+
+void OBPathStorageInit(OBPathStorage* dst, uint32_t capacity, OBPathStorage* source) {
+    if (source != nullptr) {
+        dst->storage = OB::Path::Storage(capacity, source->storage);
+    } else {
+        dst->storage = OB::Path::Storage(capacity);
+    }
+}
+
+void OBPathStorageDestroy(OBPathStorage storage) {
+    storage.storage.~Storage();
+}
+
+void OBPathStorageClear(OBPathStorage storage) {
+    storage.storage.clear();
+}
+
+// ...
+
+bool OBPathStorageIsEmpty(OBPathStorage storage) {
+    return storage.storage.isEmpty();
+}
+
+bool OBPathStorageEqualToStorage(OBPathStorage lhs, OBPathStorage rhs) {
+    return lhs.storage == rhs.storage;
+}
+
+bool OBPathStorageIsSingleElement(OBPathStorage storage) {
+    return storage.storage.flags().isSingleElement();
+}
+
+uint32_t OBPathStorageGetBezierOrder(OBPathStorage storage) {
+    return storage.storage.flags().bezierOrder();
+}
+
+#if OB_TARGET_OS_DARWIN
+
+CGRect OBPathStorageGetBoundingRect(OBPathStorage storage) {
+    precondition_failure("TODO");
+}
+
+CGPathRef OBPathStorageGetCGPath(OBPathStorage storage) {
+    precondition_failure("TODO");
+}
+#endif

Sources/OpenBox/Path/OBPathStorage.cpp

@@ -0,0 +1,63 @@
+//
+//  PathStorage.cpp
+//  OpenBox
+
+#include "PathStorage.hpp"
+#include "../Util/assert.hpp"
+
+namespace OB {
+namespace Path {
+atomic_long Storage::_last_identifier;
+
+Storage::Storage(uint32_t capacity, const Storage &storage): Storage(capacity) {
+    uint32_t originalCapity = flags().capacity();
+    StorageFlags sourceFlags = storage.flags();
+
+    _flags = _flags
+        .withExternal(false)
+        .withQuadBezierOrder(sourceFlags.isQuadBezierOrder())
+        .withCubicBezierOrder(sourceFlags.isCubicBezierOrder())
+        .withSingleElement(sourceFlags.isSingleElement())
+        // bit 4 and 5 is from sourceFlags
+        // bit 6 and bit 7 is zero
+        .withCapacity(sourceFlags.capacity());
+
+    const Storage* sourceStorage = storage.actual_storage();
+    uint64_t sourceSize = storage.actual_size();
+
+    if (originalCapity < sourceSize) {
+        // reserve_slow(sourceSize);
+        sourceStorage = external_storage();
+        if (flags().isExternal()) {
+            // sourceStorage = external_storage()->0;
+        }
+    }
+    memcpy((void *)external_storage(), (const void *)sourceStorage, sourceSize);
+    //    // Update our capacity info with the size
+    //    if (!(flags() & 0x1)) {
+    //        // Inline storage - update size bits
+    //        _flags = (flags() & ~(0xFFF << 8)) | (sourceSize << 8);
+    //    } else {
+    //        // External storage - store size externally
+    //        *reinterpret_cast<uint64_t*>(this + 0x18) = sourceSize;
+    //    }
+}
+
+Storage::~Storage() {
+    if (_unknonw != nullptr) {
+        _unknonw = nullptr;
+        // TODO
+    }
+}
+
+bool Storage::operator==(const Storage &other) const OB_NOEXCEPT {
+    // TODO
+    return false;
+}
+
+void Storage::clear() {
+    // TODO
+}
+
+} /* Path */
+} /* OB */