<change id="org.openide.loaders.DataFolder.SortMode.NATURAL">

          <api name="loaders"/>

          <summary>Introduces SortMode for natural sorting.</summary>

          <version major="7" minor="65"/>

          <date day="21" month="10" year="2015"/>

          <author login="jhavlin"/>

          <compatibility addition="yes" binary="compatible" source="compatible"

                         semantic="compatible" deprecation="no" deletion="no"

                         modification="no"/>

          <description>

              <p>

                  Added support for natural sorting of DataObjects. This means

                  that the sort is case insensitive and number sequences are

                  sorted by value rather than lexicographically.

              </p>

          </description>

          <class package="org.openide.loaders" name="DataFolder"/>

          <issue number="242226"/>

      </change>

VALUE_sort_natural=Naturally By Name

        /**

         * Folder go first (sorted naturally by name) followed by files sorted

         * by natural name and extension. Natural means that number sequences

         * are evaluated and compared by value rather than lexicographically.

         *

         * @since org.openide.loaders 7.65

         */

        public static final SortMode NATURAL = new FolderComparator(FolderComparator.NATURAL);

            } else if (this == EXTENSIONS) {

                x = "X"; // NOI18N

            } else if (this == NATURAL) {

                x = "L"; // NOI18N

            case 'X': return EXTENSIONS;

            case 'L': return NATURAL;

    /** by natural name (f10.txt > f9.txt) */

    public static final int NATURAL = 7;

        case NATURAL:

            return compareNatural(obj1, obj2);

    private static int compareNatural(Object o1, Object o2) {

        FileObject fo1 = findFileObject(o1);

        FileObject fo2 = findFileObject(o2);

        // Folders first.

        boolean f1 = fo1.isFolder();

        boolean f2 = fo2.isFolder();

        if (f1 != f2) {

            return f1 ? -1 : 1;

        }

        int res = compareFileNameNatural(fo1.getNameExt(), fo2.getNameExt());

        return res;

    }

    private static int compareFileNameNatural(String name1, String name2) {

        String n1 = name1.toLowerCase();

        String n2 = name2.toLowerCase();

        int p1;  // pointer to first string

        int p2;  // pointer to second string

        for (p1 = 0, p2 = 0; p1 < n1.length() && p2 < n2.length(); ) {

            char c1 = n1.charAt(p1);

            char c2 = n2.charAt(p2);

            ReadNumericValueResult nv1 = readNumericValue(n1, p1);

            ReadNumericValueResult nv2 = readNumericValue(n2, p2);

            if (nv1 != null && nv2 != null) {

                if (nv1.getValue() == nv2.getValue()) {

                    p1 = nv1.getEndPos();

                    p2 = nv2.getEndPos();

                } else {

                    return nv1.getValue() - nv2.getValue();

                }

            } else {

                if (c1 != c2) {

                    return c1 - c2;

                } else {

                    p1 ++;

                    p2 ++;

                }

            }

        }

        boolean unfinished1 = p1 < n1.length();

        boolean unfinished2 = p2 < n2.length();

        if (!unfinished1 && !unfinished2) {

            return name1.compareTo(name2);

        } else if (unfinished1) {

            return 1; // first string is longer (prefix of second string)

        } else if (unfinished2) {

            return -1; // second string is longer (prefix of first string)

        } else {

            assert false : "Invalid state in natural comparator";       //NOI18N

            return n1.compareTo(n2);

        }

    }

    /**

     * Read numeric value token starting at position {@code pos}. It can be

     * delimited by whitespace (so it supports values in strings like "a1b", "a

     * 1b", "a1 b", "a 1 b").

     *

     * @param s Input string.

     * @param pos Position in the input string.

     *

     * @return The numeric value starting at that position and end position in

     * the string, or null if there is no numeric value (e.g. there is a

     * white-space only.).

     */

    private static ReadNumericValueResult readNumericValue(String s, int pos) {

        int val = 0;

        boolean num = false; // some number value was read

        boolean afterNum = false; // we are reading trailing whitespace

        int len = s.length();

        for (int i = pos; i < len; i++) {

            char c = s.charAt(i);

            if (c >= '0' && c <= '9') {

                if (afterNum) { // new, separated number encountered

                    return new ReadNumericValueResult(val, i);

                }

                val = val * 10 + (c - '0');

                num = true;

            } else if (Character.isWhitespace(c)) { // leading or trailing space

                if (num) {

                    afterNum = true; // in trailing whitespace after number

                }

            } else {

                return num ? new ReadNumericValueResult(val, i) : null;

            }

        }

        return num ? new ReadNumericValueResult(val, len) : null;

    }

    /**

     * Class for representing result returned from

     * {@link #readNumericValue(String, int)}.

     */

    private static class ReadNumericValueResult {

        private final int value;

        private final int endPos;

        public ReadNumericValueResult(int value, int endPos) {

            this.value = value;

            this.endPos = endPos;

        }

        public int getValue() {

            return value;

        }

        public int getEndPos() {

            return endPos;

        }

    }

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2015 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2015 Sun Microsystems, Inc.

 */

package org.openide.loaders;

import java.awt.EventQueue;

import java.io.IOException;

import java.lang.reflect.InvocationTargetException;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import static junit.framework.TestCase.assertEquals;

import static junit.framework.TestCase.assertNotNull;

import org.junit.Test;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileSystem;

import org.openide.filesystems.FileUtil;

/**

 *

 * @author jhavlin

 */

public class FolderComparatorTest {

    public FolderComparatorTest() {

    }

    @Test

    public void testNaturalComparatorBasic() throws IOException {

        testNaturalComparator(new String[]{

            "b 10.txt",

            "b 9.txt",

            "a2.txt",

            "a 4 9.txt",

            "a10.txt",

            "b0070.txt",

            "a 3.txt",

            "b08.txt"

        }, new String[]{

            "a2.txt",

            "a 3.txt",

            "a 4 9.txt",

            "a10.txt",

            "b08.txt",

            "b 9.txt",

            "b 10.txt",

            "b0070.txt"

        });

    }

    @Test

    public void testNaturalComparatorWithSuffixes() throws IOException {

        testNaturalComparator(new String[]{

            "a01b",

            "a2x",

            "a02",

            "a1"

        }, new String[]{

            "a1",

            "a01b",

            "a02",

            "a2x"

        });

    }

    @Test

    public void testUseCustomComparator() throws IOException,

            InterruptedException, InvocationTargetException {

        FileSystem fs = FileUtil.createMemoryFileSystem();

        fs.getRoot().createData("aaaa.txt");

        fs.getRoot().createData("bbb.txt");

        fs.getRoot().createData("cc.txt");

        fs.getRoot().createData("d.txt");

        fs.getRoot().refresh();

        DataFolder.SortMode custom = new DataFolder.SortMode() {

            @Override

            public int compare(DataObject o1, DataObject o2) {

                return o1.getName().length() - o2.getName().length();

            }

        };

        DataFolder df = DataFolder.findFolder(fs.getRoot());

        df.setSortMode(custom);

        EventQueue.invokeAndWait(new Runnable() {

            @Override

            public void run() {

            }

        });

        DataObject[] children = df.getChildren();

        assertEquals("d.txt", children[0].getName());

        assertEquals("cc.txt", children[1].getName());

        assertEquals("bbb.txt", children[2].getName());

        assertEquals("aaaa.txt", children[3].getName());

    }

    @Test

    public void testNaturalComparatorFallback() throws IOException {

        testNaturalComparator(new String[]{

            "a01.txt",

            "a001.txt",

            "A1.txt"

        }, new String[]{

            "A1.txt",

            "a001.txt",

            "a01.txt"

        });

    }

    private void testNaturalComparator(String[] fileNames,

            String[] expectedOrder) throws IOException {

        FolderComparator c = new FolderComparator(FolderComparator.NATURAL);

        FileSystem fs = FileUtil.createMemoryFileSystem();

        FileObject root = fs.getRoot();

        List<DataObject> list = new ArrayList<DataObject>();

        for (String n : fileNames) {

            FileObject fo = root.createData(n);

            assertNotNull(fo);

            list.add(DataObject.find(fo));

        }

        Collections.sort(list, c);

        for (int i = 0; i < expectedOrder.length; i++) {

            assertEquals(expectedOrder[i], list.get(i).getName());

        }

    }

}