NSCollectionViewDataSource method return different result in Objc and Swift ?

OK, got it. I saw the reverse (I didn't know of lazy.reverse() type of construction !)

I tried a simple change in adjustedToItemIndex (as per my own implementation), doesn't work either.

The problem seems to lie in part in indexPathsOfItemsBeingDragged. The items inside are no more pointing to the right ones after the first loop for fromIndexPath in indexPathsOfItemsBeingDragged.

PS: where are you based ? I'm in south of France.

Tested again my code. Does not seem to work ! I'm sure it was yesterday ?!

One sure thing is that the original Objective-C code runs perfectly well in this part. I believe we can find a steady solution, but it seems to take a little more time.

PS. I'm in Osaka (as shown in my profile). Visited Marseille last year. Near Marseille?

The problem seems to lie in part in indexPathsOfItemsBeingDragged. The items inside are no more pointing to the right ones after the first loop for fromIndexPath in indexPathsOfItemsBeingDragged.

I believe I have found the cause of the bug.

I misunderstood the method `enumerateIndexPathsWithOptions:usingBlock:` as a simple iterating method like `enumerateObjectsWithOptions:usingBlock:`.

And `indexPathsOfItemsBeingDragged` is a Set (NSSet), so its simple iteration retrieves elements in an unpredictable order, which is not the same as `enumerateIndexPathsWithOptions:usingBlock:`.

Executes the given block for each NSIndexPath in the set. The index paths are enumerated in the order defined by NSIndexPath's -compare: method. For CollectionView item index paths, this means all index paths in section 0, in ascending order, followed by all index paths in section 1, and so on. You may pass the NSEnumerationReverse option to enumerate in the reverse order. Set *stop = YES if desired, to halt the enumeration early.

Thus, we need sorting indexPathsOfItemsBeingDragged (by NSIndexPath's compare: method) before iterating, iterate in normal order, then iterate in reverse order.

I think I have found the issue.

In obj, the items are read in a given order in NSSet<NSIndexPath *> *indexPathsOfItemsBeingDragged

In swift, set is unordered, so it is not read in a predefined order. So, the reverse is probably ignored.

Is there a way to order a set ? Or should we build an array from the set and order it ?

Osaka, great. I've been in Japan a few times and enjoyed. (Tokyo last year).

Toulouse is 400 kms west of Marseille, along Pyrenees mountains.

Yes, I implemented it a bit differently (I do not see how to use the compare method) with a orderedArrayIndexPathsOfItemsBeingDragged and defining the sorting order approprietaly.

Now it works.

        if (self.indexPathsOfItemsBeingDragged != []) {
            if (self.groupByTag) {
                result = false
             } else {
                var toItemIndex = indexPath.item    /
                var orderedArrayIndexPathsOfItemsBeingDragged : Array<NSIndexPath> = []  
                orderedArrayIndexPathsOfItemsBeingDragged.appendContentsOf(indexPathsOfItemsBeingDragged)
                orderedArrayIndexPathsOfItemsBeingDragged.sortInPlace({i1, i2 in return (i1.item < i2.item)})    // ascending order
                var adjustedToItemIndex = indexPath.item - 1
                 for fromIndexPath in orderedArrayIndexPathsOfItemsBeingDragged {
                    let fromItemIndex = fromIndexPath.item
                    if fromItemIndex > toItemIndex {
                          imageCollection?.moveImageFileFromIndex(fromItemIndex, toIndex: toItemIndex)
                        imageCollectionView.animator().moveItemAtIndexPath(NSIndexPath(forItem: fromItemIndex, inSection: indexPath.section), toIndexPath: NSIndexPath(forItem: toItemIndex, inSection: indexPath.section))
                       ++toItemIndex
                    } 
                }


            // Walk backward through fromItemIndex values < toItemIndex, to keep our "from" and "to" indexes valid as we go, moving items one at a time.                          
               orderedArrayIndexPathsOfItemsBeingDragged.sortInPlace({i1, i2 in return (i1.item > i2.item)})  // reverse order

               for fromIndexPath in orderedArrayIndexPathsOfItemsBeingDragged {
                    let fromItemIndex = fromIndexPath.item
                    if (fromItemIndex < adjustedToItemIndex) {
                      imageCollection?.moveImageFileFromIndex(fromItemIndex, toIndex: adjustedToItemIndex)
                    let adjustedToIndexPath = NSIndexPath(forItem: adjustedToItemIndex, inSection: indexPath.section)
                    imageCollectionView.animator().moveItemAtIndexPath(NSIndexPath(forItem: fromItemIndex, inSection: indexPath.section), toIndexPath: adjustedToIndexPath)
                    --adjustedToItemIndex
                    }
                }
            /
            result = true;
            } 

As you know your comparison closure used in `sortInPlace` works when `row`s of all NSIndexPaths are the same, as in the sample code.

And using `lazy.reverse()` is a little more efficient than sorting a sorted array, worth remembering how and when to use it.

It works with enumerateIndexPathsWithOptions ! Very clean.

Just regret it is not yet in the documentation of NSCollection !