Attachment #161773 for bug #139753

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 139753
Collapse All | Expand All




<!-- ACTUAL CHANGES BEGIN HERE: -->

  <changes>
      <change id="org.openide.loaders.DataFolder.default.sortmode">
          <api name="loaders"/>
          <summary>Introduces system property to set the default ordering of DataFolder's children.</summary>
          <version major="7" minor="67"/>
          <date day="26" month="8" year="2016"/>
          <author login="markiewb"/>
          <compatibility addition="yes" binary="compatible" source="compatible"
                         semantic="compatible" deprecation="no" deletion="no"
                         modification="no"/>
          <description>
              <p>
                  Added support for the configuration of default sorting of DataObjects.
                  Use system property <code>org.openide.loaders.DataFolder.default.sortmode</code>.
                  The value of type char determines the sorting of children (folders and files) of a DataFolder. 
                  <code>
                      'N': by name - default
                      'L': by name (natural ordering, f.e. A9 before A10);
                      'C': by class
                      'M': by last modified date
                      'S': by size;
                      'X': by extension;
                      'O': no ordering
                  </code>   
              </p>
          </description>
          <class package="org.openide.loaders" name="DataFolder"/>
          <issue number="139753"/>
      </change>
      <change id="org.openide.loaders.DataFolder.SortMode.NATURAL">
          <api name="loaders"/>
          <summary>Introduces SortMode for natural sorting.</summary>




        between successive refreshes of contents of a folder. Can be used to tweak
        performance of folder refresh. Defaults to 10.
    </api>

    <api type="export" group="systemproperty" name="org.openide.loaders.DataFolder.default.sortmode" category="private" > 
        The value of type char determines the sorting of children (folders and files) of a DataFolder. 
        <pre>
                'N': by name - default
                'L': by name (natural ordering, f.e. A9 before A10);
                'C': by class
                'M': by last modified date
                'S': by size;
                'X': by extension;
                'O': no ordering
        </pre>        
    </api>
    
    <api group="systemproperty" category="friend" name="netbeans.dataobject.insecure.operation" type="export" >
        If set to <b>true</b>, the <code>DataObject.copy, move, createFromTemplate</code> 

Lines 1-6 Link Here

(-)openide.loaders/manifest.mf (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	OpenIDE-Module: org.openide.loaders	2	OpenIDE-Module: org.openide.loaders
3	OpenIDE-Module-Specification-Version: 7.66	3	OpenIDE-Module-Specification-Version: 7.67
4	OpenIDE-Module-Localizing-Bundle: org/openide/loaders/Bundle.properties	4	OpenIDE-Module-Localizing-Bundle: org/openide/loaders/Bundle.properties
5	OpenIDE-Module-Provides: org.netbeans.modules.templates.v1_0	5	OpenIDE-Module-Provides: org.netbeans.modules.templates.v1_0
6	OpenIDE-Module-Layer: org/netbeans/modules/openide/loaders/layer.xml	6	OpenIDE-Module-Layer: org/netbeans/modules/openide/loaders/layer.xml




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

        private static SortMode parseMode(Character c) {
            if (null == c) {
                return FOLDER_NAMES;
            }
            switch (c) {
                case 'N': return NAMES;
                case 'C': return CLASS;
                case 'O': return NONE;
                case 'M': return LAST_MODIFIED;
                case 'S': return SIZE;
                case 'X': return EXTENSIONS;
                case 'L': return NATURAL;
                case 'F':
                default:
                    return FOLDER_NAMES;
            }
        }

        /** Method to write the sort mode to a folder's attributes.
        * @param folder folder write this mode to
        */

        /** Reads sort mode for given folder.
        */
        static SortMode read (FileObject f) {
            String x = (String) f.getAttribute(EA_SORT_MODE);
            Character c = null;
            if (x != null && x.length() == 1) {
                c = x.charAt(0);
            } else {
                // no mode set, so use the default one
                // allowed values: see parseMode
                String mode = System.getProperty("org.openide.loaders.DataFolder.default.sortmode");
                if (mode != null && mode.length() == 1) {
                    c = mode.charAt(0);
                }
            }

            return parseMode(c);
            switch (c) {
            case 'N': return NAMES;
            case 'C': return CLASS;
            case 'O': return NONE;
            case 'M': return LAST_MODIFIED;
            case 'S': return SIZE;
            case 'X': return EXTENSIONS;
            case 'L': return NATURAL;
            case 'F':
            default:
                return FOLDER_NAMES;
            }
        }
    }






    /** for sorting data objects by names */
    private int compareNames(Object o1, Object o2) {     
        return findFileObject(o1).getNameExt().compareToIgnoreCase(findFileObject(o2).getNameExt());
    }

    /** for sorting folders first and then by names */

        if (folder1 != folder2) {
            return folder1 ? -1 : 1; // folders first
        } else if (folder1) { // && folder2
            return obj1.getNameExt().compareToIgnoreCase(obj2.getNameExt()); // by nameExt
        } else {
            String ext1 = obj1.getExt();
            String ext2 = obj2.getExt();
            if (ext1.equals(ext2)) { // same extensions
                return obj1.getName().compareToIgnoreCase(obj2.getName()); // by name
            } else { // different extensions
                return ext1.compareToIgnoreCase(ext2); // by extension
            }
        }
    }

        } else if (d2.after(d1)) {
            return 1;
        } else {
            return fo1.getNameExt().compareToIgnoreCase(fo2.getNameExt());
        }
    }


        } else if (s2 > s1) {
            return 1;
        } else {
            return fo1.getNameExt().compareToIgnoreCase(fo2.getNameExt());
        }
    }


        boolean unfinished1 = p1 < n1.length();
        boolean unfinished2 = p2 < n2.length();
        if (!unfinished1 && !unfinished2) {
            return name1.compareToIgnoreCase(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.compareToIgnoreCase(n2);
        }
    }





            "b 9.txt",
            "b 10.txt",
            "b0070.txt"
        }, FolderComparator.NATURAL);
    }

    @Test

            "a01b",
            "a02",
            "a2x"
        }, FolderComparator.NATURAL);
    }

    @Test

            "a001.txt",
            "A1.txt"
        }, new String[]{
            "A1.txt",
            "a001.txt",
            "a01.txt",
            "A1.txt",
        }, FolderComparator.NATURAL);
    }

    @Test
    public void testIncaseSensitive_NAMES() throws IOException {
        testNaturalComparator(new String[]{
            "CustomerInvoice.txt",
            "Customerappro.txt",
            "CustomerABC.txt",
            "Customerinterview.txt"
        }, new String[]{
            "CustomerABC.txt",
            "Customerappro.txt",
            "Customerinterview.txt",
            "CustomerInvoice.txt",
        }, FolderComparator.NAMES);
    }

    @Test
    public void testIncaseSensitive_NONE() throws IOException {
        testNaturalComparator(new String[]{
            "CustomerInvoice.txt",
            "Customerappro.txt",
            "CustomerABC.txt",
            "Customerinterview.txt"
        }, new String[]{
            "CustomerInvoice.txt",
            "Customerappro.txt",
            "CustomerABC.txt",
            "Customerinterview.txt",
        }, FolderComparator.NONE);
    }

    private void testNaturalComparator(String[] fileNames, String[] expectedOrder, int mode) throws IOException {
        FolderComparator c = new FolderComparator(mode);
        FileSystem fs = FileUtil.createMemoryFileSystem();
        FileObject root = fs.getRoot();
        List<DataObject> list = new ArrayList<DataObject>();

Return to bug 139753

Lines 109-114 Link Here

(-)openide.loaders/apichanges.xml (+28 lines)
109	<!-- ACTUAL CHANGES BEGIN HERE: -->	109	<!-- ACTUAL CHANGES BEGIN HERE: -->
110		110
111	<changes>	111	<changes>
		112	<change id="org.openide.loaders.DataFolder.default.sortmode">
		113	<api name="loaders"/>
		114	<summary>Introduces system property to set the default ordering of DataFolder's children.</summary>
		115	<version major="7" minor="67"/>
		116	<date day="26" month="8" year="2016"/>
		117	<author login="markiewb"/>
		118	<compatibility addition="yes" binary="compatible" source="compatible"
		119	semantic="compatible" deprecation="no" deletion="no"
		120	modification="no"/>
		121	<description>
		122	<p>
		123	Added support for the configuration of default sorting of DataObjects.
		124	Use system property <code>org.openide.loaders.DataFolder.default.sortmode</code>.
		125	The value of type char determines the sorting of children (folders and files) of a DataFolder.
		126	<code>
		127	'N': by name - default
		128	'L': by name (natural ordering, f.e. A9 before A10);
		129	'C': by class
		130	'M': by last modified date
		131	'S': by size;
		132	'X': by extension;
		133	'O': no ordering
		134	</code>
		135	</p>
		136	</description>
		137	<class package="org.openide.loaders" name="DataFolder"/>
		138	<issue number="139753"/>
		139	</change>
112	<change id="org.openide.loaders.DataFolder.SortMode.NATURAL">	140	<change id="org.openide.loaders.DataFolder.SortMode.NATURAL">
113	<api name="loaders"/>	141	<api name="loaders"/>
114	<summary>Introduces SortMode for natural sorting.</summary>	142	<summary>Introduces SortMode for natural sorting.</summary>

Lines 533-538 Link Here

(-)openide.loaders/arch.xml (+13 lines)
533	between successive refreshes of contents of a folder. Can be used to tweak	533	between successive refreshes of contents of a folder. Can be used to tweak
534	performance of folder refresh. Defaults to 10.	534	performance of folder refresh. Defaults to 10.
535	</api>	535	</api>
		536
		537	<api type="export" group="systemproperty" name="org.openide.loaders.DataFolder.default.sortmode" category="private" >
		538	The value of type char determines the sorting of children (folders and files) of a DataFolder.
		539	<pre>
		540	'N': by name - default
		541	'L': by name (natural ordering, f.e. A9 before A10);
		542	'C': by class
		543	'M': by last modified date
		544	'S': by size;
		545	'X': by extension;
		546	'O': no ordering
		547	</pre>
		548	</api>
536		549
537	<api group="systemproperty" category="friend" name="netbeans.dataobject.insecure.operation" type="export" >	550	<api group="systemproperty" category="friend" name="netbeans.dataobject.insecure.operation" type="export" >
538	If set to <b>true</b>, the <code>DataObject.copy, move, createFromTemplate</code>	551	If set to <b>true</b>, the <code>DataObject.copy, move, createFromTemplate</code>

Lines 1117-1122 Link Here

(-)openide.loaders/src/org/openide/loaders/DataFolder.java (-16 / +30 lines)
1117	*/	1117	*/
1118	public static final SortMode NATURAL = new FolderComparator(FolderComparator.NATURAL);	1118	public static final SortMode NATURAL = new FolderComparator(FolderComparator.NATURAL);
1119		1119
		1120	private static SortMode parseMode(Character c) {
		1121	if (null == c) {
		1122	return FOLDER_NAMES;
		1123	}
		1124	switch (c) {
		1125	case 'N': return NAMES;
		1126	case 'C': return CLASS;
		1127	case 'O': return NONE;
		1128	case 'M': return LAST_MODIFIED;
		1129	case 'S': return SIZE;
		1130	case 'X': return EXTENSIONS;
		1131	case 'L': return NATURAL;
		1132	case 'F':
		1133	default:
		1134	return FOLDER_NAMES;
		1135	}
		1136	}
		1137
1120	/** Method to write the sort mode to a folder's attributes.	1138	/** Method to write the sort mode to a folder's attributes.
1121	* @param folder folder write this mode to	1139	* @param folder folder write this mode to
1122	*/	1140	*/
Lines 1149-1172 Link Here
1149	/** Reads sort mode for given folder.	1167	/** Reads sort mode for given folder.
1150	*/	1168	*/
1151	static SortMode read (FileObject f) {	1169	static SortMode read (FileObject f) {
1152	String x = (String)f.getAttribute (EA_SORT_MODE);	1170	String x = (String) f.getAttribute(EA_SORT_MODE);
1153	if (x == null \|\| x.length () != 1) {	1171	Character c = null;
1154	return FOLDER_NAMES;	1172	if (x != null && x.length() == 1) {
		1173	c = x.charAt(0);
		1174	} else {
		1175	// no mode set, so use the default one
		1176	// allowed values: see parseMode
		1177	String mode = System.getProperty("org.openide.loaders.DataFolder.default.sortmode");
		1178	if (mode != null && mode.length() == 1) {
		1179	c = mode.charAt(0);
		1180	}
1155	}	1181	}
1156		1182
1157	char c = x.charAt (0);	1183	return parseMode(c);
1158	switch (c) {
1159	case 'N': return NAMES;
1160	case 'C': return CLASS;
1161	case 'O': return NONE;
1162	case 'M': return LAST_MODIFIED;
1163	case 'S': return SIZE;
1164	case 'X': return EXTENSIONS;
1165	case 'L': return NATURAL;
1166	case 'F':
1167	default:
1168	return FOLDER_NAMES;
1169	}
1170	}	1184	}
1171	}	1185	}
1172		1186

Lines 150-156 Link Here

(-)openide.loaders/src/org/openide/loaders/FolderComparator.java (-8 / +8 lines)
150		150
151	/** for sorting data objects by names */	151	/** for sorting data objects by names */
152	private int compareNames(Object o1, Object o2) {	152	private int compareNames(Object o1, Object o2) {
153	return findFileObject(o1).getNameExt().compareTo(findFileObject(o2).getNameExt());	153	return findFileObject(o1).getNameExt().compareToIgnoreCase(findFileObject(o2).getNameExt());
154	}	154	}
155		155
156	/** for sorting folders first and then by names */	156	/** for sorting folders first and then by names */
Lines 177-190 Link Here
177	if (folder1 != folder2) {	177	if (folder1 != folder2) {
178	return folder1 ? -1 : 1; // folders first	178	return folder1 ? -1 : 1; // folders first
179	} else if (folder1) { // && folder2	179	} else if (folder1) { // && folder2
180	return obj1.getNameExt().compareTo(obj2.getNameExt()); // by nameExt	180	return obj1.getNameExt().compareToIgnoreCase(obj2.getNameExt()); // by nameExt
181	} else {	181	} else {
182	String ext1 = obj1.getExt();	182	String ext1 = obj1.getExt();
183	String ext2 = obj2.getExt();	183	String ext2 = obj2.getExt();
184	if (ext1.equals(ext2)) { // same extensions	184	if (ext1.equals(ext2)) { // same extensions
185	return obj1.getName().compareTo(obj2.getName()); // by name	185	return obj1.getName().compareToIgnoreCase(obj2.getName()); // by name
186	} else { // different extensions	186	} else { // different extensions
187	return ext1.compareTo(ext2); // by extension	187	return ext1.compareToIgnoreCase(ext2); // by extension
188	}	188	}
189	}	189	}
190	}	190	}
Lines 245-251 Link Here
245	} else if (d2.after(d1)) {	245	} else if (d2.after(d1)) {
246	return 1;	246	return 1;
247	} else {	247	} else {
248	return fo1.getNameExt().compareTo(fo2.getNameExt());	248	return fo1.getNameExt().compareToIgnoreCase(fo2.getNameExt());
249	}	249	}
250	}	250	}
251		251
Lines 269-275 Link Here
269	} else if (s2 > s1) {	269	} else if (s2 > s1) {
270	return 1;	270	return 1;
271	} else {	271	} else {
272	return fo1.getNameExt().compareTo(fo2.getNameExt());	272	return fo1.getNameExt().compareToIgnoreCase(fo2.getNameExt());
273	}	273	}
274	}	274	}
275		275
Lines 323-336 Link Here
323	boolean unfinished1 = p1 < n1.length();	323	boolean unfinished1 = p1 < n1.length();
324	boolean unfinished2 = p2 < n2.length();	324	boolean unfinished2 = p2 < n2.length();
325	if (!unfinished1 && !unfinished2) {	325	if (!unfinished1 && !unfinished2) {
326	return name1.compareTo(name2);	326	return name1.compareToIgnoreCase(name2);
327	} else if (unfinished1) {	327	} else if (unfinished1) {
328	return 1; // first string is longer (prefix of second string)	328	return 1; // first string is longer (prefix of second string)
329	} else if (unfinished2) {	329	} else if (unfinished2) {
330	return -1; // second string is longer (prefix of first string)	330	return -1; // second string is longer (prefix of first string)
331	} else {	331	} else {
332	assert false : "Invalid state in natural comparator"; //NOI18N	332	assert false : "Invalid state in natural comparator"; //NOI18N
333	return n1.compareTo(n2);	333	return n1.compareToIgnoreCase(n2);
334	}	334	}
335	}	335	}
336		336

Lines 83-89 Link Here

(-)openide.loaders/test/unit/src/org/openide/loaders/FolderComparatorTest.java (-8 / +37 lines)
83	"b 9.txt",	83	"b 9.txt",
84	"b 10.txt",	84	"b 10.txt",
85	"b0070.txt"	85	"b0070.txt"
86	});	86	}, FolderComparator.NATURAL);
87	}	87	}
88		88
89	@Test	89	@Test
Lines 98-104 Link Here
98	"a01b",	98	"a01b",
99	"a02",	99	"a02",
100	"a2x"	100	"a2x"
101	});	101	}, FolderComparator.NATURAL);
102	}	102	}
103		103
104	@Test	104	@Test
Lines 141-155 Link Here
141	"a001.txt",	141	"a001.txt",
142	"A1.txt"	142	"A1.txt"
143	}, new String[]{	143	}, new String[]{
144	"A1.txt",
145	"a001.txt",	144	"a001.txt",
146	"a01.txt"	145	"a01.txt",
147	});	146	"A1.txt",
		147	}, FolderComparator.NATURAL);
148	}	148	}
149		149
150	private void testNaturalComparator(String[] fileNames,	150	@Test
151	String[] expectedOrder) throws IOException {	151	public void testIncaseSensitive_NAMES() throws IOException {
152	FolderComparator c = new FolderComparator(FolderComparator.NATURAL);	152	testNaturalComparator(new String[]{
		153	"CustomerInvoice.txt",
		154	"Customerappro.txt",
		155	"CustomerABC.txt",
		156	"Customerinterview.txt"
		157	}, new String[]{
		158	"CustomerABC.txt",
		159	"Customerappro.txt",
		160	"Customerinterview.txt",
		161	"CustomerInvoice.txt",
		162	}, FolderComparator.NAMES);
		163	}
		164
		165	@Test
		166	public void testIncaseSensitive_NONE() throws IOException {
		167	testNaturalComparator(new String[]{
		168	"CustomerInvoice.txt",
		169	"Customerappro.txt",
		170	"CustomerABC.txt",
		171	"Customerinterview.txt"
		172	}, new String[]{
		173	"CustomerInvoice.txt",
		174	"Customerappro.txt",
		175	"CustomerABC.txt",
		176	"Customerinterview.txt",
		177	}, FolderComparator.NONE);
		178	}
		179
		180	private void testNaturalComparator(String[] fileNames, String[] expectedOrder, int mode) throws IOException {
		181	FolderComparator c = new FolderComparator(mode);
153	FileSystem fs = FileUtil.createMemoryFileSystem();	182	FileSystem fs = FileUtil.createMemoryFileSystem();
154	FileObject root = fs.getRoot();	183	FileObject root = fs.getRoot();
155	List<DataObject> list = new ArrayList<DataObject>();	184	List<DataObject> list = new ArrayList<DataObject>();