Nexus serialization

Sources/FirebladeECS/CodingStrategy.swift

@@ -5,7 +5,7 @@
 //  Created by Christian Treffs on 05.08.20.
 //
 
-public protocol CodingStrategy {
+public protocol CodingStrategy: Codable {
     func codingKey<C>(for componentType: C.Type) -> DynamicCodingKey where C: Component
 }
 

Sources/FirebladeECS/ComponentIdentifier.swift

@@ -21,6 +21,17 @@ extension ComponentIdentifier {
     internal static func makeRuntimeHash<C>(_ componentType: C.Type) -> Identifier where C: Component {
         ObjectIdentifier(componentType).hashValue
     }
+
+    typealias StableId = UInt64
+    internal static func makeStableTypeHash(component: Component) -> StableId {
+        let componentTypeString = String(describing: type(of: component))
+        return StringHashing.singer_djb2(componentTypeString)
+    }
+
+    internal static func makeStableInstanceHash(component: Component, entityId: EntityIdentifier) -> StableId {
+        let componentTypeString = String(describing: type(of: component)) + String(entityId.id)
+        return StringHashing.singer_djb2(componentTypeString)
+    }
 }
 
 extension ComponentIdentifier: Equatable { }

Sources/FirebladeECS/EntityIdentifierGenerator.swift

@@ -11,7 +11,7 @@
 /// It also allows entity ids to be marked as unused (to be re-usable).
 ///
 /// You should strive to keep entity ids tightly packed around `EntityIdentifier.Identifier.min` since it has an influence on the underlying memory layout.
-public protocol EntityIdentifierGenerator {
+public protocol EntityIdentifierGenerator: Codable {
     /// Initialize the generator providing entity ids to begin with when creating new entities.
     ///
     /// Entity ids provided should be passed to `nextId()` in last out order up until the collection is empty.
@@ -101,3 +101,4 @@ public struct LinearIncrementingEntityIdGenerator: EntityIdentifierGenerator {
         storage.markUnused(entityId: entityId)
     }
 }
+extension LinearIncrementingEntityIdGenerator.Storage: Codable { }

Sources/FirebladeECS/Nexus+Codable.swift

@@ -0,0 +1,24 @@
+//
+//  Nexus+Codable.swift
+//
+//
+//  Created by Christian Treffs on 14.07.20.
+//
+
+extension Nexus: Encodable {
+    public func encode(to encoder: Encoder) throws {
+        let serializedNexus = try self.serialize()
+        var container = encoder.singleValueContainer()
+        try container.encode(serializedNexus)
+    }
+}
+
+extension Nexus: Decodable {
+    public convenience init(from decoder: Decoder) throws {
+        self.init()
+
+        let container = try decoder.singleValueContainer()
+        let sNexus = try container.decode(SNexus.self)
+        try deserialize(from: sNexus, into: self)
+    }
+}

Sources/FirebladeECS/Nexus+Serialization.swift

@@ -0,0 +1,124 @@
+//
+//  Nexus+Serialization.swift
+//
+//
+//  Created by Christian Treffs on 26.06.20.
+//
+
+#if canImport(Foundation)
+import struct Foundation.Data
+
+extension Nexus {
+    final func serialize() throws -> SNexus {
+        var componentInstances: [ComponentIdentifier.StableId: SComponent<SNexus>] = [:]
+        var entityComponentsMap: [EntityIdentifier: Set<ComponentIdentifier.StableId>] = [:]
+
+        for entitId in self.componentIdsByEntity.keys {
+            entityComponentsMap[entitId] = []
+            let componentIds = self.get(components: entitId) ?? []
+
+            for componentId in componentIds {
+                let component = self.get(unsafe: componentId, for: entitId)
+                let componentStableInstanceHash = ComponentIdentifier.makeStableInstanceHash(component: component, entityId: entitId)
+                componentInstances[componentStableInstanceHash] = SComponent.component(component)
+                entityComponentsMap[entitId]?.insert(componentStableInstanceHash)
+            }
+        }
+
+        return SNexus(version: version,
+                      entities: entityComponentsMap,
+                      components: componentInstances)
+    }
+
+    final func deserialize(from sNexus: SNexus, into nexus: Nexus) throws {
+        for freeId in sNexus.entities.map { $0.key }.reversed() {
+            nexus.entityIdGenerator.markUnused(entityId: freeId)
+        }
+
+        for componentSet in sNexus.entities.values {
+            let entity = self.createEntity()
+            for sCompId in componentSet {
+                guard let sComp = sNexus.components[sCompId] else {
+                    throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: [], debugDescription: "Could not find component instance for \(sCompId)."))
+                }
+
+                switch sComp {
+                case let .component(comp):
+                    entity.assign(comp)
+                }
+            }
+        }
+    }
+}
+
+extension EntityIdentifier: Encodable {
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        try container.encode(id)
+    }
+}
+extension EntityIdentifier: Decodable {
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        let id = try container.decode(UInt32.self)
+        self.init(id)
+    }
+}
+
+internal struct SNexus {
+    let version: Version
+    let entities: [EntityIdentifier: Set<ComponentIdentifier.StableId>]
+    let components: [ComponentIdentifier.StableId: SComponent<SNexus>]
+}
+extension SNexus: Encodable { }
+extension SNexus: Decodable { }
+
+protocol ComponentEncoding {
+    static func encode(component: Component, to encoder: Encoder) throws
+}
+
+protocol ComponentDecoding {
+    static func decode(from decoder: Decoder) throws -> Component
+}
+typealias ComponentCodable = ComponentEncoding & ComponentDecoding
+
+extension SNexus: ComponentEncoding {
+    static func encode(component: Component, to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        let bytes = withUnsafeBytes(of: component) {
+            Data(bytes: $0.baseAddress!, count: MemoryLayout.stride(ofValue: component))
+        }
+        try container.encode(bytes)
+    }
+}
+
+extension SNexus: ComponentDecoding {
+    static func decode(from decoder: Decoder) throws -> Component {
+        let container = try decoder.singleValueContainer()
+        let instanceData = try container.decode(Data.self)
+        return instanceData.withUnsafeBytes {
+            $0.baseAddress!.load(as: Component.self)
+        }
+    }
+}
+
+enum SComponent<CodingStrategy: ComponentCodable> {
+    case component(Component)
+}
+
+extension SComponent: Encodable {
+    public func encode(to encoder: Encoder) throws {
+        switch self {
+        case let .component(comp):
+            try CodingStrategy.encode(component: comp, to: encoder)
+        }
+    }
+}
+
+extension SComponent: Decodable {
+    public init(from decoder: Decoder) throws {
+        self = .component(try CodingStrategy.decode(from: decoder))
+    }
+}
+
+#endif

Sources/FirebladeECS/Nexus.swift

@@ -6,6 +6,11 @@
 //
 
 public final class Nexus {
+    /// The version of this Nexus implementation.
+    ///
+    /// Used for serialization.
+    final let version = Version(0, 18, 0)
+
     /// - Key: ComponentIdentifier aka component type.
     /// - Value: Array of component instances of same type (uniform).
     ///          New component instances are appended.

Sources/FirebladeECS/Version.swift

@@ -0,0 +1,163 @@
+//
+//  Version.swift
+//
+//
+//  Created by Christian Treffs on 14.07.20.
+//
+
+/// A struct representing a semantic version.
+///
+/// See <https://semver.org> for details.
+public struct Version {
+    /// Major version.
+    public let major: UInt
+
+    /// Minor version.
+    public let minor: UInt
+
+    /// Patch version.
+    public let patch: UInt
+
+    /// Pre-release identifiers.
+    public let prereleaseIdentifiers: [String]
+
+    /// Build metadata identifiers.
+    public let buildMetadataIdentifiers: [String]
+
+    public init(_ major: UInt, _ minor: UInt, _ patch: UInt, prereleaseIdentifiers: [String] = [], buildMetadataIdentifiers: [String] = []) {
+        self.major = major
+        self.minor = minor
+        self.patch = patch
+        self.prereleaseIdentifiers = prereleaseIdentifiers
+        self.buildMetadataIdentifiers = buildMetadataIdentifiers
+    }
+
+    public init?(decoding versionString: String) {
+        let prereleaseStartIndex = versionString.firstIndex(of: "-")
+        let metadataStartIndex = versionString.firstIndex(of: "+")
+
+        let requiredEndIndex = prereleaseStartIndex ?? metadataStartIndex ?? versionString.endIndex
+        let requiredCharacters = versionString.prefix(upTo: requiredEndIndex)
+        let requiredComponents: [UInt] = requiredCharacters
+            .split(separator: ".", maxSplits: 2, omittingEmptySubsequences: false)
+            .map(String.init)
+            .compactMap(UInt.init)
+
+        guard requiredComponents.count == 3 else { return nil }
+
+        self.major = requiredComponents[0]
+        self.minor = requiredComponents[1]
+        self.patch = requiredComponents[2]
+
+        func identifiers(start: String.Index?, end: String.Index) -> [String] {
+            guard let start = start else { return [] }
+            let identifiers = versionString[versionString.index(after: start)..<end]
+            return identifiers.split(separator: ".").map(String.init)
+        }
+
+        self.prereleaseIdentifiers = identifiers(
+            start: prereleaseStartIndex,
+            end: metadataStartIndex ?? versionString.endIndex)
+        self.buildMetadataIdentifiers = identifiers(
+            start: metadataStartIndex,
+            end: versionString.endIndex)
+    }
+
+    public var versionString: String {
+        var versionString = "\(major).\(minor).\(patch)"
+        if !prereleaseIdentifiers.isEmpty {
+            versionString += "-" + prereleaseIdentifiers.joined(separator: ".")
+        }
+        if !buildMetadataIdentifiers.isEmpty {
+            versionString += "+" + buildMetadataIdentifiers.joined(separator: ".")
+        }
+        return versionString
+    }
+}
+
+extension Version: Equatable { }
+extension Version: Comparable {
+    func isEqualWithoutPrerelease(_ other: Version) -> Bool {
+        major == other.major && minor == other.minor && patch == other.patch
+    }
+
+    public static func < (lhs: Version, rhs: Version) -> Bool {
+        let lhsComparators = [lhs.major, lhs.minor, lhs.patch]
+        let rhsComparators = [rhs.major, rhs.minor, rhs.patch]
+
+        if lhsComparators != rhsComparators {
+            return lhsComparators.lexicographicallyPrecedes(rhsComparators)
+        }
+
+        guard lhs.prereleaseIdentifiers.count > 0 else {
+            return false // Non-prerelease lhs >= potentially prerelease rhs
+        }
+
+        guard rhs.prereleaseIdentifiers.count > 0 else {
+            return true // Prerelease lhs < non-prerelease rhs
+        }
+
+        let zippedIdentifiers = zip(lhs.prereleaseIdentifiers, rhs.prereleaseIdentifiers)
+        for (lhsPrereleaseIdentifier, rhsPrereleaseIdentifier) in zippedIdentifiers {
+            if lhsPrereleaseIdentifier == rhsPrereleaseIdentifier {
+                continue
+            }
+
+            let typedLhsIdentifier: Any = Int(lhsPrereleaseIdentifier) ?? lhsPrereleaseIdentifier
+            let typedRhsIdentifier: Any = Int(rhsPrereleaseIdentifier) ?? rhsPrereleaseIdentifier
+
+            switch (typedLhsIdentifier, typedRhsIdentifier) {
+            case let (int1 as Int, int2 as Int): return int1 < int2
+            case let (string1 as String, string2 as String): return string1 < string2
+            case (is Int, is String): return true // Int prereleases < String prereleases
+            case (is String, is Int): return false
+
+            default:
+                return false
+            }
+        }
+
+        return lhs.prereleaseIdentifiers.count < rhs.prereleaseIdentifiers.count
+    }
+}
+
+extension Version: ExpressibleByStringLiteral {
+    public init(stringLiteral versionString: String) {
+        guard let version = Version(decoding: versionString) else {
+            fatalError("Malformed version string '\(versionString)'.")
+        }
+        self = version
+    }
+}
+
+extension Version: CustomStringConvertible {
+    public var description: String {
+        versionString
+    }
+}
+
+extension Version: CustomDebugStringConvertible {
+    public var debugDescription: String {
+        versionString
+    }
+}
+
+extension Version: Decodable {
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        let versionString = try container.decode(String.self)
+        guard let version = Version(decoding: versionString) else {
+            throw DecodingError.dataCorruptedError(in: container,
+                                                   debugDescription: "Malformed version string '\(versionString)'.")
+        }
+
+        self = version
+    }
+}
+
+extension Version: Encodable {
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        try container.encode(versionString)
+    }
+}