Array filled in dispatch queue but when I try and use contents in method its empty

I have pulled JSON data from an API and decoded using the JSON decoder.I have then tried to populate my array data structure with the JSON data in the dispatch queue so I can use it in other methods but when I try to access the data in other methods or functions it states the array is empty

This is how I have decoded the JSON data and tried filling the array in the dispatch queue

 if let url = URL(string:"https://parseapi.back4app.com/classes/restaurants"){
            var request = URLRequest(url: url)
            request.httpMethod = "GET"
            request.setValue("app id", forHTTPHeaderField: "X-Parse-Application-Id")
            request.setValue("REST API key", forHTTPHeaderField: "X-Parse-REST-API-Key")
            let session = URLSession.shared
            session.dataTask(with: request) { [self] (data, response, err) in
                guard let jsonData = data else {
                    return
                }
                do {
                    let decoder = JSONDecoder()
                    let restaurantList = try decoder.decode(restaurants.self, from: jsonData)
                    self.restaurantStruct = restaurantList
                    DispatchQueue.main.async {
                        self.fillArray()
                    }
                }
                catch let jsonErr {
                    print("Error decoding JSON", jsonErr)
                }
            }
            .resume()
        }

This is the fillArray method I wrote

 func fillArray(){
        var counter = 0
        for anitem in restaurantStruct!.results{
            //print("\(counter) : \(anitem)")
            restaurantArray.insert(["restaurant" : anitem.restaurant, "name" : anitem.name, "description" : anitem.description , "calories" : anitem.calories , "price" : anitem.price , "ImageUrl" : anitem.ImageUrl , "type" : anitem.type], at: counter)
           
            counter += 1
        }
    }

func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
        if(collectionView == categoryCollectionView){
            let cell = collectionView.dequeueReusableCell(withReuseIdentifier: "myCell", for: indexPath) as! CategoryCollectionViewCell
            cell.label.text = categories[indexPath.row]["Category"]
            cell.imageView.image = UIImage(named:categories[indexPath.row]["Image"]!)
            return cell
        }
       
        else{
            let menu = getRestaurantMenu("TFC")
            print(menu)
            let cell = collectionView.dequeueReusableCell(withReuseIdentifier: "myCell2", for: indexPath) as! CollectionViewCell
    
           
            return cell
        }
        
    }

I don't (yet) have a solution, but after discussion in comments, I thought it would be helpful to provide some code that might help in the debugging process, and comments are too limited for that.

First you need to determine if your collection view is even working as you expect. To determine that we'll need some local data, add these to your ViewController source file. They can be globals

// debugRestuarantsJSON should be exactly the same format you're 
// expecting from your REST call.
fileprivate let debugRestaurantsJSON = "Paste valid restaurants JSON text here"
fileprivate let debugRestaurantsData = debugRestaurantsJSON.data(using: .utf8)

Then let's extract the bulk of your dataTask completion handler into it's own method so we can use it for the debugging data:

private func setRestaurantData(from restaurantJSONData: Data?)
{
    guard let jsonData = restaurantJSONData else { return }

    do {
        let decoder = JSONDecoder()
        let restaurantList = try decoder.decode(restaurants.self, from: jsonData)
        self.restaurantStruct = restaurantList
        self.fillArray()
    }
    catch let jsonErr {
      print("Error decoding JSON", jsonErr)
    }
}

Note that I removed DispatchQueue.main.async from the call to fillArray(), so if you altered fillArray to make UI calls, such as the one I suggested in comments to call setNeedsDisplay(), remove those.

And let's wrap your dataTask call inside a method too:

private func requestRestaurantData(from urlString: String)
{
    if let url = URL(string: urlString)
    {
        var request = URLRequest(url: url)
        request.httpMethod = "GET"
        request.setValue("app id", forHTTPHeaderField: "X-Parse-Application-Id")
        request.setValue("REST API key", forHTTPHeaderField: "X-Parse-REST-API-Key")
        let session = URLSession.shared
        session.dataTask(with: request)
        { (data, response, err) in
            if let err = err {
                print("URL request failed: \(err.localizedDescription)")
            }
            else { self.setRestaurantData(from: data) }
        }
        .resume()
     }
}

I added a check for the case when err is not nil to handle network/HTTP errors, and it expects the URL as a String parameter. It also uses the setRestuarantData(from:) method we created earlier. Otherwise it's the same as your code.

Instead of calling requestRestaurantData(from:) directly where you originally called your dataTask in your code, let's provide one more level of indirection:

enum RestaurantRequestType {
    case normal, debugSync, debugAsync
}

func requestRestaurantData(_ requestType: RestaurantRequestType = .normal)
{
    switch requestType
    {
        case .normal:
            requestRestaurantData(
                from: "https://parseapi.back4app.com/classes/restaurants"
            )
            
        case .debugSync:
            setRestaurantData(from: debugRestaurantsData)
            
        case .debugAsync:
            DispatchQueue.main.async {
                self.setRestaurantData(from: debugRestaurantsData)
            }
    }
}

Now in your code where you originally called dataTask, replace it with

    requestRestaurantData(.normal)

That should give exactly the same behavior you already have. Just make sure you didn't break anything in making those changes. In other words, your UICollectionView will still not contain the restaurant data. That's to be expected, but everything else that was working before should still work.

Then change from .normal to .debugSync. That will synchronously fill the array before requestRestaurantData(_:) returns. If the only problem is setting the view's data from an asynchronous task, your view should now display the debug data. If it doesn't, you're fundamentally not setting up the view or its data correctly, and that has to be fixed before proceeding.

Let's assume that your view does show the debug data. Now change from .debugSync to .debugAsync. That will fill the array in an asynchronous task, so it will behave more like dataTask, but without the network access. It will also have a shorter latency, because it won't need to wait for network response. It'll just execute in one of the next few iterations of the main runloop, probably on the very next one if no other tasks are queued up.

If your view isn't updated using .debugAsync, which I suspect will be the case, you know that you're not informing the view, its delegate, or since it's a UICollectionView, its dataSource that there's new data, so it needs to update/redraw. My current thought is that is you'll need to call the reloadData method for your UICollectionView:

private func setRestaurantData(from restaurantJSONData: Data?)
{
    guard let jsonData = restaurantJSONData else { return }

    do {
        let decoder = JSONDecoder()
        let restaurantList = try decoder.decode(restaurants.self, from: jsonData)
        self.restaurantStruct = restaurantList
        self.fillArray()
       
        // ADD THE FOLLOWING LINE - replace yourUICollectionView appropriately
        DispatchQueue.main.async { self.yourUICollectionView.reloadData() }
    }
    catch let jsonErr {
      print("Error decoding JSON", jsonErr)
    }
}

If that doesn't work, then there will be more debugging to do. Comment to let me know.

Eventually when you get that working, change from .debugAsync to .normal. Assuming network connectivity and the server is running, your view should work. If not, there is some completely different problem than I'm thinking of. But I'm pretty sure that if it works with .debugAsync it will work with .normal.

Once you get it working, you can remove the debugging code. I would leave the non-debugging extracted methods in place though.