个人中心
文章发布
退出
作者热门文章
- iOS/Objective-C 元类和类别
- objective-c - -1001 错误，当 NSURLSession 通过 httpproxy 和/etc/hosts
- java - 使用网络类获取 url 地址
- ios - 推送通知中不播放声音
27
4
我需要以树状方式互连的通用对象的表示。这棵树及其对象应具有以下特征:
Codable 协议(protocol)来编码
作为这个问题末尾的一个例子，我创建了一个满足所有要求但只有一个要求的 Playground :从 JSON 解码树
一棵树由节点组成，在本例中为 TreePartNode s，它们正在实现 TreePartNodeBase 协议(protocol)。这个例子中的树是一个 AnyTreePartNode 的数组，它们也实现了 TreePartNodeBase 协议(protocol)并包装了一个实现 TreePartNodeBase 协议(protocol)的对象，它应该是一个通用的 TreePartNode ( TreePartNode<Trunk> ， TreePartNode<Branch> 或 TreePartNode<Apple> )。
TreePartNode 具有 treePart 类型的属性 AnyTreePart 。 AnyTreePart(类似于 AnyTreePartNode )包装了一个实现 TreePart 协议(protocol)( Trunk 、 Branch 或 Apple )的对象。
所有这些类都实现了 Codable 和 Equatable 。
import Foundation
///////////// TreePart -> implemented by Trunk, Branch, Apple and AnyTreePart
protocol TreePart: Codable {
var name: String { get set }
func isEqualTo( _ other: TreePart ) -> Bool
func asEquatable() -> AnyTreePart
}
extension TreePart where Self: Equatable {
func isEqualTo( _ other: TreePart ) -> Bool {
guard let otherTreePart = other as? Self else { return false }
return self == otherTreePart
}
func asEquatable() -> AnyTreePart {
return AnyTreePart( self )
}
}
///////////// AnyTreePart -> wrapper for Trunk, Branch and Apple
class AnyTreePart: TreePart, Codable {
var wrappedTreePart: TreePart
var name: String {
get {
return self.wrappedTreePart.name
}
set {
self.wrappedTreePart.name = newValue
}
}
init( _ treePart: TreePart ) {
self.wrappedTreePart = treePart
}
// MARK: Codable
enum CodingKeys: String, CodingKey {
case trunk,
branch,
apple
}
required convenience init( from decoder: Decoder ) throws {
let container = try decoder.container( keyedBy: CodingKeys.self )
var treePart: TreePart?
if let trunk = try container.decodeIfPresent( Trunk.self, forKey: .trunk ) {
treePart = trunk
}
if let branch = try container.decodeIfPresent( Branch.self, forKey: .branch ) {
treePart = branch
}
if let apple = try container.decodeIfPresent( Apple.self, forKey: .apple ) {
treePart = apple
}
guard let foundTreePart = treePart else {
let context = DecodingError.Context( codingPath: [CodingKeys.trunk, CodingKeys.branch, CodingKeys.apple], debugDescription: "Could not find the treePart key" )
throw DecodingError.keyNotFound( CodingKeys.trunk, context )
}
self.init( foundTreePart )
}
func encode( to encoder: Encoder ) throws {
var container = encoder.container( keyedBy: CodingKeys.self )
switch self.wrappedTreePart {
case let trunk as Trunk:
try container.encode( trunk, forKey: .trunk )
case let branch as Branch:
try container.encode( branch, forKey: .branch )
case let apple as Apple:
try container.encode( apple, forKey: .apple )
default:
fatalError( "Encoding error: No encoding implementation for \( type( of: self.wrappedTreePart ) )" )
}
}
}
extension AnyTreePart: Equatable {
static func ==( lhs: AnyTreePart, rhs: AnyTreePart ) -> Bool {
return lhs.wrappedTreePart.isEqualTo( rhs.wrappedTreePart )
}
}
///////////// TreePartNodeBase -> implemented by TreePartNode<T: TreePart> and AnyTreePartNode
protocol TreePartNodeBase: class {
var treePart: AnyTreePart { get set }
var uuid: UUID { get }
var parent: AnyTreePartNode? { get set }
var weakChildren: NSPointerArray { get }
func isEqualTo( _ other: TreePartNodeBase ) -> Bool
func asEquatable() -> AnyTreePartNode
}
extension TreePartNodeBase where Self: Equatable {
func isEqualTo( _ other: TreePartNodeBase ) -> Bool {
guard let otherTreePartNode = other as? Self else { return false }
return self == otherTreePartNode &&
self.treePart == other.treePart &&
self.uuid == other.uuid &&
self.parent == other.parent &&
self.children == other.children
}
func asEquatable() -> AnyTreePartNode {
return AnyTreePartNode( self )
}
}
extension TreePartNodeBase {
var children: [AnyTreePartNode] {
guard let allNodes = self.weakChildren.allObjects as? [AnyTreePartNode] else {
fatalError( "The children nodes are not of type \( type( of: AnyTreePartNode.self ) )" )
}
return allNodes
}
}
///////////// AnyTreePartNode -> wrapper of TreePartNode<T: TreePart>
class AnyTreePartNode: TreePartNodeBase, Codable {
unowned var wrappedTreePartNode: TreePartNodeBase
var treePart: AnyTreePart {
get {
return self.wrappedTreePartNode.treePart
}
set {
self.wrappedTreePartNode.treePart = newValue
}
}
var uuid: UUID {
return self.wrappedTreePartNode.uuid
}
/// The parent node
weak var parent: AnyTreePartNode? {
get {
return self.wrappedTreePartNode.parent
}
set {
self.wrappedTreePartNode.parent = newValue
}
}
/// The weak references to the children of this node
var weakChildren: NSPointerArray {
return self.wrappedTreePartNode.weakChildren
}
init( _ treePartNode: TreePartNodeBase ) {
self.wrappedTreePartNode = treePartNode
}
// MARK: Codable
enum CodingKeys: String, CodingKey {
case trunkNode,
branchNode,
appleNode
}
required convenience init( from decoder: Decoder ) throws {
let container = try decoder.container( keyedBy: CodingKeys.self )
// even if an empty Trunk is created, the decoder crashes
self.init( TreePartNode<Trunk>( Trunk() ) )
// This attempt of decoding possible nodes doesn't work
/*
if let trunkNode: TreePartNode<Trunk> = try container
.decodeIfPresent( TreePartNode<Trunk>.self, forKey: .trunkNode ) {
self.init( trunkNode )
} else if let branchNode: TreePartNode<Branch> = try container
.decodeIfPresent( TreePartNode<Branch>.self, forKey: .branchNode ) {
self.init( branchNode )
} else if let appleNode: TreePartNode<Apple> = try cont«ainer
.decodeIfPresent( TreePartNode<Apple>.self, forKey: .appleNode ) {
self.init( appleNode )
} else {
let context = DecodingError.Context( codingPath: [CodingKeys.trunkNode,
CodingKeys.branchNode,
CodingKeys.appleNode],
debugDescription: "Could not find the treePart node key" )
throw DecodingError.keyNotFound( CodingKeys.trunkNode, context )
}
*/
// TODO recreating the connections between the nodes should happen after all objects are decoded and will be done based on the UUIDs
}
func encode( to encoder: Encoder ) throws {
var container = encoder.container( keyedBy: CodingKeys.self )
switch self.wrappedTreePartNode {
case let trunkNode as TreePartNode<Trunk>:
try container.encode( trunkNode, forKey: .trunkNode )
case let branchNode as TreePartNode<Branch>:
try container.encode( branchNode, forKey: .branchNode )
case let appleNode as TreePartNode<Apple>:
try container.encode( appleNode, forKey: .appleNode )
default:
fatalError( "Encoding error: No encoding implementation for \( type( of: self.wrappedTreePartNode ) )" )
}
}
}
extension AnyTreePartNode: Equatable {
static func ==( lhs: AnyTreePartNode, rhs: AnyTreePartNode ) -> Bool {
return lhs.wrappedTreePartNode.isEqualTo( rhs.wrappedTreePartNode )
}
}
// enables printing of the wrapped tree part and its child elements
extension AnyTreePartNode: CustomStringConvertible {
var description: String {
var text = "\( type( of: self.wrappedTreePartNode.treePart.wrappedTreePart ))"
if !self.children.isEmpty {
text += " { " + self.children.map { $0.description }.joined( separator: ", " ) + " }"
}
return text
}
}
///////////// TreeParts (Trunk, Branch and Apple)
class Trunk: TreePart, Codable, Equatable {
var name: String
var color: String
init( name: String = "trunk",
color: String = "#CCC" ) {
self.name = name
self.color = color
}
static func ==(lhs: Trunk, rhs: Trunk) -> Bool {
return lhs.name == rhs.name &&
lhs.color == rhs.color
}
}
class Branch: TreePart, Codable, Equatable {
var name: String
var length: Int
init( name: String = "branch",
length: Int = 4 ) {
self.name = name
self.length = length
}
static func ==(lhs: Branch, rhs: Branch) -> Bool {
return lhs.name == rhs.name &&
lhs.length == rhs.length
}
}
class Apple: TreePart, Codable, Equatable {
var name: String
var size: Int
init( name: String = "apple",
size: Int = 2 ) {
self.name = name
self.size = size
}
static func ==(lhs: Apple, rhs: Apple) -> Bool {
return lhs.name == rhs.name &&
lhs.size == rhs.size
}
}
///////////// TreePartNode -> The node in the tree that contains the TreePart
class TreePartNode<T: TreePart>: TreePartNodeBase, Codable {
var equatableSelf: AnyTreePartNode!
var uuid: UUID
var treePart: AnyTreePart
var weakChildren = NSPointerArray.weakObjects()
private var parentUuid : UUID?
private var childrenUuids : [UUID]?
weak var parent: AnyTreePartNode? {
willSet {
if newValue == nil {
// unrelated code
// ... removes the references to this object in the parent node, if it exists
}
}
}
init( _ treePart: AnyTreePart,
uuid: UUID = UUID() ) {
self.treePart = treePart
self.uuid = uuid
self.equatableSelf = self.asEquatable()
}
convenience init( _ treePart: T,
uuid: UUID = UUID() ) {
self.init( treePart.asEquatable(),
uuid: uuid )
}
init( _ treePart: AnyTreePart,
uuid: UUID,
parentUuid: UUID?,
childrenUuids: [UUID]?) {
self.treePart = treePart
self.uuid = uuid
self.parentUuid = parentUuid
self.childrenUuids = childrenUuids
self.equatableSelf = self.asEquatable()
}
private func add( child: AnyTreePartNode ) {
child.parent = self.equatableSelf
self.weakChildren.addObject( child )
}
private func set( parent: AnyTreePartNode ) {
self.parent = parent
parent.weakChildren.addObject( self.equatableSelf )
}
// MARK: Codable
enum CodingKeys: String, CodingKey {
case treePart,
uuid,
parent,
children,
parentPort
}
required convenience init( from decoder: Decoder ) throws {
let container = try decoder.container( keyedBy: CodingKeys.self )
// non-optional values
let uuid: UUID = try container.decode( UUID.self, forKey: .uuid )
let treePart: AnyTreePart = try container.decode( AnyTreePart.self, forKey: .treePart )
// optional values
let childrenUuids: [UUID]? = try container.decodeIfPresent( [UUID].self, forKey: .children )
let parentUuid: UUID? = try container.decodeIfPresent( UUID.self, forKey: .parent )
self.init( treePart,
uuid: uuid,
parentUuid: parentUuid,
childrenUuids: childrenUuids)
}
func encode( to encoder: Encoder ) throws {
var container = encoder.container( keyedBy: CodingKeys.self )
// non-optional values
try container.encode( self.treePart, forKey: .treePart )
try container.encode( self.uuid, forKey: .uuid )
// optional values
if !self.children.isEmpty {
try container.encode( self.children.map { $0.uuid }, forKey: .children )
}
try container.encodeIfPresent( self.parent?.uuid, forKey: .parent )
}
}
extension TreePartNode: Equatable {
static func ==( lhs: TreePartNode, rhs: TreePartNode ) -> Bool {
return lhs.treePart == rhs.treePart &&
lhs.parent == rhs.parent &&
lhs.children == rhs.children
}
}
// enables printing of the wrapped tree part and its child elements
extension TreePartNode: CustomStringConvertible {
var description: String {
var text = "\( type( of: self.treePart.wrappedTreePart ))"
if !self.children.isEmpty {
text += " { " + self.children.map { $0.description }.joined( separator: ", " ) + " }"
}
return text
}
}
// MARK: functions for adding connections to other TreeParts for each specific TreePart type
extension TreePartNode where T: Trunk {
func add( child branch: TreePartNode<Branch> ) {
self.add( child: branch.equatableSelf )
}
}
extension TreePartNode where T: Branch {
func add( child apple: TreePartNode<Apple> ) {
self.add( child: apple.equatableSelf )
}
func add( child branch: TreePartNode<Branch> ) {
self.add( child: branch.equatableSelf )
}
func set( parent branch: TreePartNode<Branch> ) {
self.set( parent: branch.equatableSelf )
}
func set( parent trunk: TreePartNode<Trunk> ) {
self.set( parent: trunk.equatableSelf )
}
}
extension TreePartNode where T: Apple {
func set( parent branch: TreePartNode<Branch> ) {
self.set( parent: branch.equatableSelf )
}
}
////////////// Helper
extension NSPointerArray {
func addObject( _ object: AnyObject? ) {
guard let strongObject = object else { return }
let pointer = Unmanaged.passUnretained( strongObject ).toOpaque()
self.addPointer( pointer )
}
}
////////////// Test (The actual usage of the implementation above)
let trunk = Trunk()
let branch1 = Branch()
let branch2 = Branch()
let branch3 = Branch()
let apple1 = Apple()
let apple2 = Apple()
let trunkNode = TreePartNode<Trunk>( trunk )
let branchNode1 = TreePartNode<Branch>( branch1 )
let branchNode2 = TreePartNode<Branch>( branch2 )
let branchNode3 = TreePartNode<Branch>( branch3 )
let appleNode1 = TreePartNode<Apple>( apple1 )
let appleNode2 = TreePartNode<Apple>( apple2 )
trunkNode.add( child: branchNode1 )
trunkNode.add( child: branchNode2 )
branchNode2.add( child: branchNode3 )
branchNode1.add( child: appleNode1 )
branchNode3.add( child: appleNode2 )
let tree = [trunkNode.equatableSelf,
branchNode1.equatableSelf,
branchNode2.equatableSelf,
branchNode3.equatableSelf,
appleNode1.equatableSelf,
appleNode2.equatableSelf]
print( "expected result when printing the decoded trunk node: \(trunkNode)" )
let encoder = JSONEncoder()
let decoder = JSONDecoder()
encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
// This is how the encoded tree looks like
let jsonTree = """
[
{
"trunkNode" : {
"children" : [
"399B35A7-3307-4EF6-8B4C-1B83A8F734CD",
"60582654-13B9-40D0-8275-3C6649614069"
],
"treePart" : {
"trunk" : {
"color" : "#CCC",
"name" : "trunk"
}
},
"uuid" : "55748AEB-271E-4560-9EE8-F00C670C8896"
}
},
{
"branchNode" : {
"children" : [
"0349C0DF-FE58-4D8E-AA72-7466749EB1D6"
],
"parent" : "55748AEB-271E-4560-9EE8-F00C670C8896",
"treePart" : {
"branch" : {
"length" : 4,
"name" : "branch"
}
},
"uuid" : "399B35A7-3307-4EF6-8B4C-1B83A8F734CD"
}
},
{
"branchNode" : {
"children" : [
"6DB14BD5-3E4A-40C4-8EBF-FBD3CC6050C7"
],
"parent" : "55748AEB-271E-4560-9EE8-F00C670C8896",
"treePart" : {
"branch" : {
"length" : 4,
"name" : "branch"
}
},
"uuid" : "60582654-13B9-40D0-8275-3C6649614069"
}
},
{
"branchNode" : {
"children" : [
"9FCCDBF6-27A7-4E21-8681-5F3E63330504"
],
"parent" : "60582654-13B9-40D0-8275-3C6649614069",
"treePart" : {
"branch" : {
"length" : 4,
"name" : "branch"
}
},
"uuid" : "6DB14BD5-3E4A-40C4-8EBF-FBD3CC6050C7"
}
},
{
"appleNode" : {
"parent" : "399B35A7-3307-4EF6-8B4C-1B83A8F734CD",
"treePart" : {
"apple" : {
"name" : "apple",
"size" : 2
}
},
"uuid" : "0349C0DF-FE58-4D8E-AA72-7466749EB1D6"
}
},
{
"appleNode" : {
"parent" : "6DB14BD5-3E4A-40C4-8EBF-FBD3CC6050C7",
"treePart" : {
"apple" : {
"name" : "apple",
"size" : 2
}
},
"uuid" : "9FCCDBF6-27A7-4E21-8681-5F3E63330504"
}
}
]
""".data(using: .utf8)!
do {
print( "begin decoding" )
/* This currently produces an error: Playground execution aborted: error: Execution was interrupted, reason: signal SIGABRT. The process has been left at the point where it was interrupted, use "thread return -x" to return to the state before expression evaluation.
let decodedTree = try decoder.decode( [AnyTreePartNode].self, from: jsonTree )
print( decodedTree.first( where: { $0.wrappedTreePartNode.treePart.wrappedTreePart is Trunk } )! )
*/
} catch let error {
print( error )
}
AnyTreePartNode 中的解码函数应该如何解码 JSON？我错过了什么？
最佳答案
我只是从 unowned var wrappedTreePartNode: TreePartNodeBase 行中删除 unowned并编译相同的代码。
结果:
打印解码后的中继节点时的预期结果:Trunk { Branch { Apple }, Branch { Branch { Apple } } }开始解码[树干，分支，分支，分支，苹果，苹果]
代码:
//
// ViewController.swift
// TestDrive
//
// Created by Mahipal on 25/04/18.
// Copyright © 2018 Vandana. All rights reserved.
//
import UIKit
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view, typically from a nib.
////////////// Test (The actual usage of the implementation above)
let trunk = Trunk()
let branch1 = Branch()
let branch2 = Branch()
let branch3 = Branch()
let apple1 = Apple()
let apple2 = Apple()
let trunkNode = TreePartNode<Trunk>( trunk )
let branchNode1 = TreePartNode<Branch>( branch1 )
let branchNode2 = TreePartNode<Branch>( branch2 )
let branchNode3 = TreePartNode<Branch>( branch3 )
let appleNode1 = TreePartNode<Apple>( apple1 )
let appleNode2 = TreePartNode<Apple>( apple2 )
trunkNode.add( child: branchNode1 )
trunkNode.add( child: branchNode2 )
branchNode2.add( child: branchNode3 )
branchNode1.add( child: appleNode1 )
branchNode3.add( child: appleNode2 )
let tree = [trunkNode.equatableSelf,
branchNode1.equatableSelf,
branchNode2.equatableSelf,
branchNode3.equatableSelf,
appleNode1.equatableSelf,
appleNode2.equatableSelf]
print( "expected result when printing the decoded trunk node: \(trunkNode)" )
let encoder = JSONEncoder()
let decoder = JSONDecoder()
encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
// This is how the encoded tree looks like
let jsonTree = """
[
{
"trunkNode" : {
"children" : [
"399B35A7-3307-4EF6-8B4C-1B83A8F734CD",
"60582654-13B9-40D0-8275-3C6649614069"
],
"treePart" : {
"trunk" : {
"color" : "#CCC",
"name" : "trunk"
}
},
"uuid" : "55748AEB-271E-4560-9EE8-F00C670C8896"
}
},
{
"branchNode" : {
"children" : [
"0349C0DF-FE58-4D8E-AA72-7466749EB1D6"
],
"parent" : "55748AEB-271E-4560-9EE8-F00C670C8896",
"treePart" : {
"branch" : {
"length" : 4,
"name" : "branch"
}
},
"uuid" : "399B35A7-3307-4EF6-8B4C-1B83A8F734CD"
}
},
{
"branchNode" : {
"children" : [
"6DB14BD5-3E4A-40C4-8EBF-FBD3CC6050C7"
],
"parent" : "55748AEB-271E-4560-9EE8-F00C670C8896",
"treePart" : {
"branch" : {
"length" : 4,
"name" : "branch"
}
},
"uuid" : "60582654-13B9-40D0-8275-3C6649614069"
}
},
{
"branchNode" : {
"children" : [
"9FCCDBF6-27A7-4E21-8681-5F3E63330504"
],
"parent" : "60582654-13B9-40D0-8275-3C6649614069",
"treePart" : {
"branch" : {
"length" : 4,
"name" : "branch"
}
},
"uuid" : "6DB14BD5-3E4A-40C4-8EBF-FBD3CC6050C7"
}
},
{
"appleNode" : {
"parent" : "399B35A7-3307-4EF6-8B4C-1B83A8F734CD",
"treePart" : {
"apple" : {
"name" : "apple",
"size" : 2
}
},
"uuid" : "0349C0DF-FE58-4D8E-AA72-7466749EB1D6"
}
},
{
"appleNode" : {
"parent" : "6DB14BD5-3E4A-40C4-8EBF-FBD3CC6050C7",
"treePart" : {
"apple" : {
"name" : "apple",
"size" : 2
}
},
"uuid" : "9FCCDBF6-27A7-4E21-8681-5F3E63330504"
}
}
]
""".data(using: .utf8)!
do {
print( "begin decoding" )
// This currently produces an error: Playground execution aborted: error: Execution was interrupted, reason: signal SIGABRT. The process has been left at the point where it was interrupted, use "thread return -x" to return to the state before expression evaluation.
let decodedTree = try decoder.decode( [AnyTreePartNode].self, from: jsonTree )
print( decodedTree )
} catch let error {
print( error )
}
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
}
import Foundation
///////////// TreePart -> implemented by Trunk, Branch, Apple and AnyTreePart
protocol TreePart: Codable {
var name: String { get set }
func isEqualTo( _ other: TreePart ) -> Bool
func asEquatable() -> AnyTreePart
}
extension TreePart where Self: Equatable {
func isEqualTo( _ other: TreePart ) -> Bool {
guard let otherTreePart = other as? Self else { return false }
return self == otherTreePart
}
func asEquatable() -> AnyTreePart {
return AnyTreePart( self )
}
}
///////////// AnyTreePart -> wrapper for Trunk, Branch and Apple
class AnyTreePart: TreePart, Codable {
var wrappedTreePart: TreePart
var name: String {
get {
return self.wrappedTreePart.name
}
set {
self.wrappedTreePart.name = newValue
}
}
init( _ treePart: TreePart ) {
self.wrappedTreePart = treePart
}
// MARK: Codable
enum CodingKeys: String, CodingKey {
case trunk,
branch,
apple
}
required convenience init( from decoder: Decoder ) throws {
let container = try decoder.container( keyedBy: CodingKeys.self )
var treePart: TreePart?
if let trunk = try container.decodeIfPresent( Trunk.self, forKey: .trunk ) {
treePart = trunk
}
if let branch = try container.decodeIfPresent( Branch.self, forKey: .branch ) {
treePart = branch
}
if let apple = try container.decodeIfPresent( Apple.self, forKey: .apple ) {
treePart = apple
}
guard let foundTreePart = treePart else {
let context = DecodingError.Context( codingPath: [CodingKeys.trunk, CodingKeys.branch, CodingKeys.apple], debugDescription: "Could not find the treePart key" )
throw DecodingError.keyNotFound( CodingKeys.trunk, context )
}
self.init( foundTreePart )
}
func encode( to encoder: Encoder ) throws {
var container = encoder.container( keyedBy: CodingKeys.self )
switch self.wrappedTreePart {
case let trunk as Trunk:
try container.encode( trunk, forKey: .trunk )
case let branch as Branch:
try container.encode( branch, forKey: .branch )
case let apple as Apple:
try container.encode( apple, forKey: .apple )
default:
fatalError( "Encoding error: No encoding implementation for \( type( of: self.wrappedTreePart ) )" )
}
}
}
extension AnyTreePart: Equatable {
static func ==( lhs: AnyTreePart, rhs: AnyTreePart ) -> Bool {
return lhs.wrappedTreePart.isEqualTo( rhs.wrappedTreePart )
}
}
///////////// TreePartNodeBase -> implemented by TreePartNode<T: TreePart> and AnyTreePartNode
protocol TreePartNodeBase: class {
var treePart: AnyTreePart { get set }
var uuid: UUID { get }
var parent: AnyTreePartNode? { get set }
var weakChildren: NSPointerArray { get }
func isEqualTo( _ other: TreePartNodeBase ) -> Bool
func asEquatable() -> AnyTreePartNode
}
extension TreePartNodeBase where Self: Equatable {
func isEqualTo( _ other: TreePartNodeBase ) -> Bool {
guard let otherTreePartNode = other as? Self else { return false }
return self == otherTreePartNode &&
self.treePart == other.treePart &&
self.uuid == other.uuid &&
self.parent == other.parent &&
self.children == other.children
}
func asEquatable() -> AnyTreePartNode {
return AnyTreePartNode( self )
}
}
extension TreePartNodeBase {
var children: [AnyTreePartNode] {
guard let allNodes = self.weakChildren.allObjects as? [AnyTreePartNode] else {
fatalError( "The children nodes are not of type \( type( of: AnyTreePartNode.self ) )" )
}
return allNodes
}
}
///////////// AnyTreePartNode -> wrapper of TreePartNode<T: TreePart>
class AnyTreePartNode: TreePartNodeBase, Codable {
var wrappedTreePartNode: TreePartNodeBase
var treePart: AnyTreePart {
get {
return self.wrappedTreePartNode.treePart
}
set {
self.wrappedTreePartNode.treePart = newValue
}
}
var uuid: UUID {
return self.wrappedTreePartNode.uuid
}
/// The parent node
weak var parent: AnyTreePartNode? {
get {
return self.wrappedTreePartNode.parent
}
set {
self.wrappedTreePartNode.parent = newValue
}
}
/// The weak references to the children of this node
var weakChildren: NSPointerArray {
return self.wrappedTreePartNode.weakChildren
}
init( _ treePartNode: TreePartNodeBase ) {
self.wrappedTreePartNode = treePartNode
}
// MARK: Codable
enum CodingKeys: String, CodingKey {
case trunkNode,
branchNode,
appleNode
}
required convenience init( from decoder: Decoder ) throws {
let container = try decoder.container( keyedBy: CodingKeys.self)
// This attempt of decoding possible nodes doesn't work
if let trunkNode: TreePartNode<Trunk> = try container.decodeIfPresent( TreePartNode<Trunk>.self, forKey: .trunkNode ) {
self.init( trunkNode )
} else if let branchNode: TreePartNode<Branch> = try container
.decodeIfPresent( TreePartNode<Branch>.self, forKey: .branchNode ) {
self.init( branchNode )
} else if let appleNode: TreePartNode<Apple> = try container
.decodeIfPresent( TreePartNode<Apple>.self, forKey: .appleNode ) {
self.init( appleNode )
} else {
let context = DecodingError.Context( codingPath: [CodingKeys.trunkNode,
CodingKeys.branchNode,
CodingKeys.appleNode],
debugDescription: "Could not find the treePart node key" )
throw DecodingError.keyNotFound( CodingKeys.trunkNode, context )
}
// TODO recreating the connections between the nodes should happen after all objects are decoded and will be done based on the UUIDs
}
func encode( to encoder: Encoder ) throws {
var container = encoder.container( keyedBy: CodingKeys.self )
switch self.wrappedTreePartNode {
case let trunkNode as TreePartNode<Trunk>:
try container.encode( trunkNode, forKey: .trunkNode )
case let branchNode as TreePartNode<Branch>:
try container.encode( branchNode, forKey: .branchNode )
case let appleNode as TreePartNode<Apple>:
try container.encode( appleNode, forKey: .appleNode )
default:
fatalError( "Encoding error: No encoding implementation for \( type( of: self.wrappedTreePartNode ) )" )
}
}
}
extension AnyTreePartNode: Equatable {
static func ==( lhs: AnyTreePartNode, rhs: AnyTreePartNode ) -> Bool {
return lhs.wrappedTreePartNode.isEqualTo( rhs.wrappedTreePartNode )
}
}
// enables printing of the wrapped tree part and its child elements
extension AnyTreePartNode: CustomStringConvertible {
var description: String {
var text = "\( type( of: self.wrappedTreePartNode.treePart.wrappedTreePart ))"
if !self.children.isEmpty {
text += " { " + self.children.map { $0.description }.joined( separator: ", " ) + " }"
}
return text
}
}
///////////// TreeParts (Trunk, Branch and Apple)
class Trunk: TreePart, Codable, Equatable {
var name: String
var color: String
init( name: String = "trunk",
color: String = "#CCC" ) {
self.name = name
self.color = color
}
static func ==(lhs: Trunk, rhs: Trunk) -> Bool {
return lhs.name == rhs.name &&
lhs.color == rhs.color
}
}
class Branch: TreePart, Codable, Equatable {
var name: String
var length: Int
init( name: String = "branch",
length: Int = 4 ) {
self.name = name
self.length = length
}
static func ==(lhs: Branch, rhs: Branch) -> Bool {
return lhs.name == rhs.name &&
lhs.length == rhs.length
}
}
class Apple: TreePart, Codable, Equatable {
var name: String
var size: Int
init( name: String = "apple",
size: Int = 2 ) {
self.name = name
self.size = size
}
static func ==(lhs: Apple, rhs: Apple) -> Bool {
return lhs.name == rhs.name &&
lhs.size == rhs.size
}
}
///////////// TreePartNode -> The node in the tree that contains the TreePart
class TreePartNode<T: TreePart>: TreePartNodeBase, Codable {
var equatableSelf: AnyTreePartNode!
var uuid: UUID
var treePart: AnyTreePart
var weakChildren = NSPointerArray.weakObjects()
private var parentUuid : UUID?
private var childrenUuids : [UUID]?
weak var parent: AnyTreePartNode? {
willSet {
if newValue == nil {
// unrelated code
// ... removes the references to this object in the parent node, if it exists
}
}
}
init( _ treePart: AnyTreePart,
uuid: UUID = UUID() ) {
self.treePart = treePart
self.uuid = uuid
self.equatableSelf = self.asEquatable()
}
convenience init( _ treePart: T,
uuid: UUID = UUID() ) {
self.init( treePart.asEquatable(),
uuid: uuid )
}
init( _ treePart: AnyTreePart,
uuid: UUID,
parentUuid: UUID?,
childrenUuids: [UUID]?) {
self.treePart = treePart
self.uuid = uuid
self.parentUuid = parentUuid
self.childrenUuids = childrenUuids
self.equatableSelf = self.asEquatable()
}
private func add( child: AnyTreePartNode ) {
child.parent = self.equatableSelf
self.weakChildren.addObject( child )
}
private func set( parent: AnyTreePartNode ) {
self.parent = parent
parent.weakChildren.addObject( self.equatableSelf )
}
// MARK: Codable
enum CodingKeys: String, CodingKey {
case treePart,
uuid,
parent,
children,
parentPort
}
required convenience init( from decoder: Decoder ) throws {
let container = try decoder.container( keyedBy: CodingKeys.self )
// non-optional values
let uuid: UUID = try container.decode( UUID.self, forKey: .uuid )
let treePart: AnyTreePart = try container.decode( AnyTreePart.self, forKey: .treePart )
// optional values
let childrenUuids: [UUID]? = try container.decodeIfPresent( [UUID].self, forKey: .children )
let parentUuid: UUID? = try container.decodeIfPresent( UUID.self, forKey: .parent )
self.init( treePart,
uuid: uuid,
parentUuid: parentUuid,
childrenUuids: childrenUuids)
}
func encode( to encoder: Encoder ) throws {
var container = encoder.container( keyedBy: CodingKeys.self )
// non-optional values
try container.encode( self.treePart, forKey: .treePart )
try container.encode( self.uuid, forKey: .uuid )
// optional values
if !self.children.isEmpty {
try container.encode( self.children.map { $0.uuid }, forKey: .children )
}
try container.encodeIfPresent( self.parent?.uuid, forKey: .parent )
}
}
extension TreePartNode: Equatable {
static func ==( lhs: TreePartNode, rhs: TreePartNode ) -> Bool {
return lhs.treePart == rhs.treePart &&
lhs.parent == rhs.parent &&
lhs.children == rhs.children
}
}
// enables printing of the wrapped tree part and its child elements
extension TreePartNode: CustomStringConvertible {
var description: String {
var text = "\( type( of: self.treePart.wrappedTreePart ))"
if !self.children.isEmpty {
text += " { " + self.children.map { $0.description }.joined( separator: ", " ) + " }"
}
return text
}
}
// MARK: functions for adding connections to other TreeParts for each specific TreePart type
extension TreePartNode where T: Trunk {
func add( child branch: TreePartNode<Branch> ) {
self.add( child: branch.equatableSelf )
}
}
extension TreePartNode where T: Branch {
func add( child apple: TreePartNode<Apple> ) {
self.add( child: apple.equatableSelf )
}
func add( child branch: TreePartNode<Branch> ) {
self.add( child: branch.equatableSelf )
}
func set( parent branch: TreePartNode<Branch> ) {
self.set( parent: branch.equatableSelf )
}
func set( parent trunk: TreePartNode<Trunk> ) {
self.set( parent: trunk.equatableSelf )
}
}
extension TreePartNode where T: Apple {
func set( parent branch: TreePartNode<Branch> ) {
self.set( parent: branch.equatableSelf )
}
}
////////////// Helper
extension NSPointerArray {
func addObject( _ object: AnyObject? ) {
guard let strongObject = object else { return }
let pointer = Unmanaged.passUnretained( strongObject ).toOpaque()
self.addPointer( pointer )
}
}
关于ios - 在 Swift 4 中解码泛型类的可编码树，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/50011841/
27
4
0
关于 B 树与 B+ 树，网上有一个比较经典的问题：为什么 MongoDb 使用 B 树，而 MySQL 索引使用 B+ 树? 但实际上 MongoDb 真的用的是 B 树吗?
如何将 R* Tree 实现为持久(基于磁盘)树？保存 R* 树索引或保存叶值的文件的体系结构是什么？ 注意:此外，如何在这种持久性 R* 树中执行插入、更新和删除操作？ 注意事项二:我已经实现了一个
目前，我正在努力用 Java 表示我用 SML 编写的 AST 树，这样我就可以随时用 Java 遍历它。 我想知道是否应该在 Java 中创建一个 Node 类，其中包含我想要表示的数据，以及一个数
我之前用过这个库http://www.cs.umd.edu/~mount/ANN/ .但是，它们不提供范围查询实现。我猜是否有一个 C++ 范围查询实现(圆形或矩形)，用于查询二维数据。 谢谢。 最佳
在进一步分析为什么MySQL数据库索引选择使用B+树之前，我相信很多小伙伴对数据结构中的树还是有些许模糊的，因此我们由浅入深一步步探讨树的演进过程，在一步步引出B树以及为什么MySQL数据库索引选择
书接上回，今天和大家一起动手来自己实现树。 相信通过前面的章节学习，大家已经明白树是什么了，今天我们主要针对二叉树，分别使用顺序存储和链式存储来实现树。 01、数组实现 我们在上一节中说过，
书节上回，我们接着聊二叉树，N叉树，以及树的存储。 01、满二叉树 如果一个二叉树，除最后一层节点外，每一层的节点数都达到最大值，即每个节点都有两个子节点，同时所有叶子节点都在最后一层，则这个
树是一种非线性数据结构，是以分支关系定义的层次结构，因此形态上和自然界中的倒挂的树很像，而数据结构中树根向上树叶向下。 什么是树？ 01、定义 树是由n（n>=0）个元素节点组成的
操作系统的那棵“树” 今天从一颗 开始，我们看看如何从小树苗长成一颗苍天大树。 运转CPU CPU运转起来很简单，就是不断的从内存取值执行。 CPU没有好好运转 IO是个耗费时间的活，如果CPU在取值
我想为海洋生物学类(class)制作一个简单的系统发育树作为教育示例。我有一个具有分类等级的物种列表: Group <- c("Benthos","Benthos","Benthos","Be
我从这段代码中删除节点时遇到问题，如果我插入数字 12 并尝试删除它，它不会删除它，我尝试调试，似乎当它尝试删除时，它出错了树的。但是，如果我尝试删除它已经插入主节点的节点，它将删除它，或者我插入数字
B+ 树的叶节点链接在一起。将 B+ 树的指针结构视为有向图，它不是循环的。但是忽略指针的方向并将其视为链接在一起的无向叶节点会在图中创建循环。 在 Haskell 中，如何将叶子构造为父内部节点的子
我在 GWT 中使用树控件。我有一个自定义小部件，我将其添加为 TreeItem: Tree testTree = new Tree(); testTree.addItem(myWidget); 我想
它有点像混合树/链表结构。这是我定义结构的方式 struct node { nodeP sibling; nodeP child; nodeP parent; char
我编写了使用队列遍历树的代码，但是下面的出队函数生成错误，head = p->next 是否有问题？我不明白为什么这部分是错误的。 void Levelorder(void) { node *tmp,
例如，我想解析以下数组: var array1 = ["a.b.c.d", "a.e.f.g", "a.h", "a.i.j", "a.b.k"] 进入: var json1 = { "nod
问题 -> 给定一棵二叉树和一个和，确定该树是否具有从根到叶的路径，使得沿路径的所有值相加等于给定的和。 我的解决方案 -> public class Solution { public bo
我有一个创建 java 树的任务，它包含三列:运动名称、运动类别中的运动计数和上次更新。类似的东西显示在下面的图像上: 如您所见，有 4 种运动:水上运动、球类运动、跳伞运动和舞蹈运动。当我展开 sk
我想在 H2 数据库中实现 B+ Tree，但我想知道，B+ Tree 功能在 H2 数据库中可用吗？ 最佳答案 H2 已经使用了 B+ 树(PageBtree 类)。 关于mysql - H2数据库
假设我们有 5 个字符串数组: String[] array1 = {"hello", "i", "cat"}; String[] array2 = {"hello", "i", "am"}; Str
我是一名优秀的程序员,十分优秀！