deep copy for array of objects in swift

Question

I have this class named Meal

class Meal {
    var name : String = ""
    var cnt : Int = 0
    var price : String = ""
    var img : String = ""
    var id : String = ""

    init(name:String , cnt : Int, price : String, img : String, id : String) {
        self.name = name
        self.cnt = cnt
        self.price = price
        self.img = img
        self.id = id
    }
}

and I have an array of Meal :

var ordered = [Meal]()

I want to duplicate that array and then do some changes to the Meal instances in one of them without changing the Meal instances in the second one, how would I make a deep copy of it?

This search result didn't help me How do I make a exact duplicate copy of an array?

Answer 1

Since ordered is a swift array, the statement

 var orderedCopy = ordered

will effectively make a copy of the original array.

However, since Meal is a class, the new array will contain references to the same meals referred in the original one.

If you want to copy the meals content too, so that changing a meal in one array will not change a meal in the other array, then you must define Meal as a struct, not as a class:

struct Meal { 
  ...

From the Apple book:

Use struct to create a structure. Structures support many of the same behaviors as classes, including methods and initializers. One of the most important differences between structures and classes is that structures are always copied when they are passed around in your code, but classes are passed by reference.

Answer 2

To improve on @Kametrixom answer check this: For normal objects what can be done is to implement a protocol that supports copying, and make the object class implements this protocol like this:

protocol Copying {
    init(original: Self)
}

extension Copying {
    func copy() -> Self {
        return Self.init(original: self)
    }
}

And then the Array extension for cloning:

extension Array where Element: Copying {
    func clone() -> Array {
        var copiedArray = Array<Element>()
        for element in self {
            copiedArray.append(element.copy())
        }
        return copiedArray
    }
}

and that is pretty much it, to view code and a sample check this gist

Answer 3

You either have to, as @MarioZannone mentioned, make it a struct, because structs get copied automatically, or you may not want a struct and need a class. For this you have to define how to copy your class. There is the NSCopying protocol which unifies that on the ObjC world, but that makes your Swift code "unpure" in that you have to inherit from NSObject. I suggest however to define your own copying protocol like this:

protocol Copying {
    init(original: Self)
}

extension Copying {
    func copy() -> Self {
        return Self.init(original: self)
    }
}

which you can implement like this:

class Test : Copying {
    var x : Int

    init() {
        x = 0
    }

    // required initializer for the Copying protocol
    required init(original: Test) {
        x = original.x
    }
}

Within the initializer you have to copy all the state from the passed original Test on to self. Now that you implemented the protocol correctly, you can do something like this:

let original = Test()
let stillOriginal = original
let copyOriginal = original.copy()

original.x = 10

original.x         // 10
stillOriginal.x    // 10
copyOriginal.x     // 0

This is basically the same as NSCopying just without ObjC

EDIT: Sadly this yet so beautiful protocol works very poorly with subclassing...

Answer 4

A simple and quick way is to map the original array into the new copy:

let copyOfPersons: [Person] = allPersons.map({(originalPerson) -> Person in
        let newPerson = Person(name: originalPerson.name, age: originalPerson.age)
        return newPerson
    })

The new Persons will have different pointers but same values.

Answer 5

Based on previous answer here

If you have nested objects, i.e. subclasses to a class then what you want is True Deep Copy.

//Example
var dogsForAdoption: Array<Dog>

class Dog{
   var breed: String
   var owner: Person
}

So this means implementing NSCopying in every class(Dog, Person etc).

Would you do that for say 20 of your classes? what about 30..50..100? You get it right? We need native "it just works!" way. But nope we don't have one. Yet.

As of now, Feb 2021, there is no proper solution of this issue. We have many workarounds though.

Here is the one I have been using, and one with less limitations in my opinion.

1. Make your class conforms to codable

class Dog: Codable{
    var breed : String = "JustAnyDog"
    var owner: Person
}

2. Create this helper class

class DeepCopier {
    //Used to expose generic 
    static func Copy<T:Codable>(of object:T) -> T?{
       do{
           let json = try JSONEncoder().encode(object)
           return try JSONDecoder().decode(T.self, from: json)
       }
       catch let error{
           print(error)
           return nil
       }
    }
}

3. Call this method whenever you need true deep copy of your object, like this:

 //Now suppose  
 let dog = Dog()
 guard let clonedDog = DeepCopier.Copy(of: dog) else{
    print("Could not detach Dog")
    return
 }
//Change/mutate object properties as you want
 clonedDog.breed = "rottweiler"
//Also clonedDog.owner != dog.owner, as both the owner : Person have dfferent memory allocations   

As you can see we are piggy backing on Swift's JSONEncoder and JSONDecoder, using power of Codable, making true deep copy no matter how many nested objects are there under our object. Just make sure all your Classes conform to Codable.

Though its NOT an ideal solution, but its one of the most effective workaround.