001package Torello.Java; 002 003import java.util.*; 004 005import java.util.stream.Stream; 006import java.util.function.Consumer; 007import java.util.function.Supplier; 008import java.util.function.Function; 009 010import Torello.Java.ReadOnly.*; 011 012/** 013 * This class actually extends the parent-type class {@link VarType}. For that class, there is a 014 * Generic Type-Parameter named {@code 'INSERT_TYPE'}. When class {@link VarType} is used for to 015 * help a user specify what data-structure should be returned from any of the relevant 016 * {@code FileNode} methods, that Type-Parameter {@code 'INSERT_TYPE'} will always be 017 * {@code 'FileNode'}. 018 * 019 * <BR /><BR />This class extends {@link VarType}, and specifies that, in all cases, the Generic 020 * Type-Parameter {@code 'INSERT_TYPE'} should be set to {@code 'FileNode'}. 021 * 022 * <BR /><BR /><B CLASS=JDDescLabel>Where to Use:</B> 023 * 024 * <BR />This class provides myriad combinations for returning data from any of the 025 * {@link FileNode} <B STYLE='color: red;'><CODE>'flatten'</CODE></B> methods, or the 026 * <B STYLE='color: red;'><CODE>'getDirContents'</CODE></B> methods. 027 * 028 * @param <SOME_DATA_STRUCTURE> This is the type that that will be returned by the the 029 * {@link FileNode} method that has been invoked, using an {@code RTC} instance. 030 * 031 * @see FileNode 032 */ 033public class RTC<SOME_DATA_STRUCTURE> 034 extends VarType<SOME_DATA_STRUCTURE, FileNode> 035{ 036 /** 037 * Constructs an instance of this class. If there is some combination of sorter or 038 * file meta-information transformation that is not actually included on this list, this 039 * constructor can be used to build an {@code 'RTC'} of your own devices. 040 * 041 * @param inserter This {@code java.util.Consumer} is used to accept and insert 042 * {@code FileNode} matches into whatever data-structure is being utilized. 043 * 044 * @param finisher This {@code java.util.Supplier} will be invoked, just once, at the end 045 * of the insertion process to do any additional sorting, building or transformation that need 046 * to be done before returning the finalized data-structure. 047 */ 048 public RTC(Consumer<FileNode> inserter, Supplier<SOME_DATA_STRUCTURE> finisher) 049 { super(inserter, finisher); } 050 051 /** 052 * {@code Comparator} for sorting instances of {@link FileNode} by their 053 * {@link FileNode#lastModified lastModified} field. 054 */ 055 protected static final Comparator<FileNode> BY_DATE = 056 Comparator.comparingLong((FileNode fn) -> fn.lastModified); 057 058 /** 059 * {@code Comparator} for sorting instances of {@link FileNode} by their 060 * {@link FileNode#fileSize fileSize} field. 061 */ 062 protected static final Comparator<FileNode> BY_FILE_SIZE = 063 Comparator.comparingLong((FileNode fn) -> fn.fileSize); 064 065 /** 066 * {@code Comparator} for sorting instances of {@link FileNode} by their "Complete" 067 * {@link FileNode#getFullPathName() Full-Path Name}. 068 */ 069 protected static final Comparator<FileNode> BY_FULLPATH = 070 (FileNode fn1, FileNode fn2) -> fn1.getFullPathName().compareTo(fn2.getFullPathName()); 071 072 /** 073 * {@code Comparator} for sorting instances of {@link FileNode} by their "Simple" 074 * {@link FileNode#name File-Name}. 075 */ 076 protected static final Comparator<FileNode> BY_FILENAME = 077 (FileNode fn1, FileNode fn2) -> fn1.name.compareTo(fn2.name); 078 079 private static final FileNode[] ZERO_LEN_ARR_FN = new FileNode[0]; 080 private static final String[] ZERO_LEN_ARR_STR = new String[0]; 081 082 083 084 // ******************************************************************************************** 085 // ******************************************************************************************** 086 // ******************************************************************************************** 087 // private static final VarTypeBuilder<FileNode> vlb = new VarTypeBuilder<>(FileNode.class); 088 // ******************************************************************************************** 089 // ******************************************************************************************** 090 // ******************************************************************************************** 091 092 093 094 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 095 // Vector 096 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 097 098 /** Requests: Vector<FileNode> */ 099 public static RTC<Vector<FileNode>> VECTOR() 100 { 101 final Vector<FileNode> v = new Vector<>(); 102 return new RTC<>(v::add, () -> v); 103 } 104 105 /** Requests: Vector<FileNode> */ 106 public static RTC<Vector<FileNode>> VECTOR(final Vector<FileNode> inV) 107 { 108 final Vector<FileNode> v = (inV != null) ? inV : new Vector<>(); 109 return new RTC<>(v::add, () -> v); 110 } 111 112 113 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 114 // ArrayList 115 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 116 117 /** Requests: ArrayList<FileNode> */ 118 public static RTC<ArrayList<FileNode>> ARRAYLIST() 119 { 120 final ArrayList<FileNode> al = new ArrayList<>(); 121 return new RTC<>(al::add, () -> al); 122 } 123 124 /** Requests: ArrayList<FileNode> */ 125 public static RTC<ArrayList<FileNode>> ARRAYLIST(final ArrayList<FileNode> inAL) 126 { 127 final ArrayList<FileNode> al = (inAL != null) ? inAL : new ArrayList<>(); 128 return new RTC<>(al::add, () -> al); 129 } 130 131 132 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 133 // HashSet 134 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 135 136 /** Requests: HashSet<FileNode> */ 137 public static RTC<HashSet<FileNode>> HASHSET() 138 { 139 final HashSet<FileNode> hs = new HashSet<>(); 140 return new RTC<>(hs::add, () -> hs); 141 } 142 143 /** Requests: HashSet<FileNode> */ 144 public static RTC<HashSet<FileNode>> HASHSET(final HashSet<FileNode> inHS) 145 { 146 final HashSet<FileNode> hs = (inHS != null) ? inHS : new HashSet<>(); 147 return new RTC<>(hs::add, () -> hs); 148 } 149 150 151 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 152 // Stream 153 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 154 155 /** Requests: Stream<FileNode> */ 156 public static RTC<Stream<FileNode>> STREAM() 157 { 158 final Stream.Builder<FileNode> b = Stream.builder(); 159 return new RTC<>(b::accept, () -> b.build()); 160 } 161 162 163 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 164 // Stream.Builder 165 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 166 167 /** Requests: Stream.Builder<FileNode> */ 168 public static RTC<Stream.Builder<FileNode>> STREAM_BUILDER(final Stream.Builder<FileNode> inB) 169 { 170 final Stream.Builder<FileNode> b = (inB != null) ? inB : Stream.builder(); 171 return new RTC<>(b::accept, () -> b); 172 } 173 174 175 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 176 // FileNode[] 177 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 178 179 /** Requests: FileNode[] */ 180 public static RTC<FileNode[]> ARRAY() 181 { 182 final Stream.Builder<FileNode> b = Stream.builder(); 183 return new RTC<>(b::accept, () -> b.build().toArray(FileNode[]::new)); 184 } 185 186 187 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 188 // Iterator<FileNode> 189 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 190 191 /** Requests: Iterator<FileNode> */ 192 public static RTC<Iterator<FileNode>> ITERATOR() 193 { 194 final ArrayList<FileNode> al = new ArrayList<>(); 195 return new RTC<>(al::add, () -> al.iterator()); 196 } 197 198 199 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 200 // ReadOnlyArrayList 201 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 202 203 /** Requests: ReadOnlyArrayList<FileNode> */ 204 public static RTC<ReadOnlyArrayList<FileNode>> ROAL() 205 { 206 final ROArrayListBuilder<FileNode> roalb = new ROArrayListBuilder<>(); 207 return new RTC<>(roalb::add, () -> roalb.build()); 208 } 209 210 /** Requests: ROArrayListBuilder<FileNode> */ 211 public static RTC<ROArrayListBuilder<FileNode>> 212 ROAL_BUILDER(final ROArrayListBuilder<FileNode> inROALB) 213 { 214 final ROArrayListBuilder<FileNode> roalb = (inROALB != null) 215 ? inROALB 216 : new ROArrayListBuilder<>(); 217 218 return new RTC<>(roalb::add, () -> roalb); 219 } 220 221 222 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 223 // ReadOnlyHashSet 224 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 225 226 /** Requests: ReadOnlyHashSet<FileNode> */ 227 public static RTC<ReadOnlyHashSet<FileNode>> ROHS() 228 { 229 final ROHashSetBuilder<FileNode> rohsb = new ROHashSetBuilder<>(); 230 return new RTC<>(rohsb::add, () -> rohsb.build()); 231 } 232 233 /** Requests: ROHashSetBuilder<FileNode> */ 234 public static RTC<ROHashSetBuilder<FileNode>> 235 ROHS_BUILDER(final ROHashSetBuilder<FileNode> inROHSB) 236 { 237 final ROHashSetBuilder<FileNode> rohsb = (inROHSB != null) 238 ? inROHSB 239 : new ROHashSetBuilder<>(); 240 241 return new RTC<>(rohsb::add, () -> rohsb); 242 } 243 244 245 246 // ******************************************************************************************** 247 // ******************************************************************************************** 248 // ******************************************************************************************** 249 // private static final VarTypeBuilderWithSort<FileNode> vlbws1 = 250 // new VarTypeBuilderWithSort<>(BY_DATE, FileNode.class); 251 // ******************************************************************************************** 252 // ******************************************************************************************** 253 // ******************************************************************************************** 254 255 256 257 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 258 // Sorted By Date: Vector 259 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 260 261 /** Requests: Vector<FileNode> */ 262 public static RTC<Vector<FileNode>> SORTED_BY_DATE_VECTOR() 263 { 264 final Vector<FileNode> v = new Vector<>(); 265 return new RTC<>(v::add, () -> { v.sort(BY_DATE); return v; }); 266 } 267 268 /** Requests: Vector<FileNode> */ 269 public static RTC<Vector<FileNode>> SORTED_BY_DATE_VECTOR(final Vector<FileNode> inV) 270 { 271 final Vector<FileNode> v = (inV != null) ? inV : new Vector<>(); 272 return new RTC<>(v::add, () -> { v.sort(BY_DATE); return v; }); 273 } 274 275 276 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 277 // Sorted By Date: ArrayList 278 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 279 280 /** Requests: ArrayList<FileNode> */ 281 public static RTC<ArrayList<FileNode>> SORTED_BY_DATE_ARRAYLIST() 282 { 283 final ArrayList<FileNode> al = new ArrayList<>(); 284 return new RTC<>(al::add, () -> { al.sort(BY_DATE); return al; }); 285 } 286 287 /** Requests: ArrayList<FileNode> */ 288 public static RTC<ArrayList<FileNode>> SORTED_BY_DATE_ARRAYLIST(final ArrayList<FileNode> inAL) 289 { 290 final ArrayList<FileNode> al = (inAL != null) ? inAL : new ArrayList<>(); 291 return new RTC<>(al::add, () -> { al.sort(BY_DATE); return al; }); 292 } 293 294 295 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 296 // Sorted By Date: TreeSet 297 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 298 299 /** Requests: TreeSet<FileNode> */ 300 public static RTC<TreeSet<FileNode>> SORTED_BY_DATE_TREESET() 301 { 302 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE); 303 return new RTC<>(ts::add, () -> ts); 304 } 305 306 /** Requests: TreeSet<FileNode> */ 307 public static RTC<TreeSet<FileNode>> SORTED_BY_DATE_TREESET(final TreeSet<FileNode> inTS) 308 { 309 final TreeSet<FileNode> ts = (inTS != null) ? inTS : new TreeSet<>(BY_DATE); 310 return new RTC<>(ts::add, () -> ts); 311 } 312 313 314 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 315 // Sorted By Date: Stream 316 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 317 318 /** Requests: Stream<FileNode> */ 319 public static RTC<Stream<FileNode>> SORTED_BY_DATE_STREAM() 320 { 321 final Stream.Builder<FileNode> b = Stream.builder(); 322 return new RTC<>(b::accept, () -> b.build().sorted(BY_DATE)); 323 } 324 325 326 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 327 // Sorted By Date: FileNode[] 328 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 329 330 /** Requests: FileNode[] */ 331 public static RTC<FileNode[]> SORTED_BY_DATE_ARRAY() 332 { 333 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE); 334 return new RTC<>(ts::add, () -> ts.toArray(ZERO_LEN_ARR_FN)); 335 } 336 337 338 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 339 // Sorted By Date: Iterator<FileNode> 340 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 341 342 /** Requests: Iterator<FileNode> */ 343 public static RTC<Iterator<FileNode>> SORTED_BY_DATE_ITERATOR() 344 { 345 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE); 346 return new RTC<>(ts::add, () -> ts.iterator()); 347 } 348 349 350 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 351 // Sorted By Date: ReadOnlyArrayList 352 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 353 354 /** Requests: ReadOnlyArrayList<FileNode> */ 355 public static RTC<ReadOnlyArrayList<FileNode>> SORTED_BY_DATE_ROAL() 356 { 357 final ROArrayListBuilder<FileNode> roalb = new ROArrayListBuilder<>(); 358 return new RTC<>(roalb::add, () -> { roalb.sort(BY_DATE); return roalb.build(); }); 359 } 360 361 /** Requests: ROArrayListBuilder<FileNode> */ 362 public static RTC<ROArrayListBuilder<FileNode>> 363 SORTED_BY_DATE_ROAL_BUILDER(final ROArrayListBuilder<FileNode> inROALB) 364 { 365 final ROArrayListBuilder<FileNode> roalb = (inROALB != null) 366 ? inROALB 367 : new ROArrayListBuilder<>(); 368 369 return new RTC<>(roalb::add, () -> { roalb.sort(BY_DATE); return roalb; }); 370 } 371 372 373 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 374 // Sorted By Date: ReadOnlyTreeSet 375 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 376 377 /** Requests: ReadOnlyTreeSet<FileNode> */ 378 public static RTC<ReadOnlyTreeSet<FileNode>> SORTED_BY_DATE_ROTS() 379 { 380 final ROTreeSetBuilder<FileNode> rotsb = new ROTreeSetBuilder<>(); 381 return new RTC<>(rotsb::add, () -> rotsb.build()); 382 } 383 384 /** Requests: ROTreeSetBuilder<FileNode> */ 385 public static RTC<ROTreeSetBuilder<FileNode>> 386 SORTED_BY_DATE_ROTS_BUILDER(final ROTreeSetBuilder<FileNode> inROTSB) 387 { 388 final ROTreeSetBuilder<FileNode> rotsb = (inROTSB != null) 389 ? inROTSB 390 : new ROTreeSetBuilder<>(); 391 392 return new RTC<>(rotsb::add, () -> rotsb); 393 } 394 395 396 397 // ******************************************************************************************** 398 // ******************************************************************************************** 399 // ******************************************************************************************** 400 // private static final VarTypeBuilderWithSort<FileNode> vlbws2 401 // = new VarTypeBuilderWithSort<>(BY_FILE_SIZE, FileNode.class); 402 // ******************************************************************************************** 403 // ******************************************************************************************** 404 // ******************************************************************************************** 405 406 407 408 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 409 // Sorted By File-Size: Vector 410 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 411 412 /** Requests: Vector<FileNode> */ 413 public static RTC<Vector<FileNode>> SORTED_BY_SIZE_VECTOR() 414 { 415 final Vector<FileNode> v = new Vector<>(); 416 return new RTC<>(v::add, () -> { v.sort(BY_FILE_SIZE); return v; }); 417 } 418 419 /** Requests: Vector<FileNode> */ 420 public static RTC<Vector<FileNode>> SORTED_BY_SIZE_VECTOR(final Vector<FileNode> inV) 421 { 422 final Vector<FileNode> v = (inV != null) ? inV : new Vector<>(); 423 return new RTC<>(v::add, () -> { v.sort(BY_FILE_SIZE); return v; }); 424 } 425 426 427 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 428 // Sorted By File-Size: ArrayList 429 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 430 431 /** Requests: ArrayList<FileNode> */ 432 public static RTC<ArrayList<FileNode>> SORTED_BY_SIZE_ARRAYLIST() 433 { 434 final ArrayList<FileNode> al = new ArrayList<>(); 435 return new RTC<>(al::add, () -> { al.sort(BY_FILE_SIZE); return al; }); 436 } 437 438 /** Requests: ArrayList<FileNode> */ 439 public static RTC<ArrayList<FileNode>> SORTED_BY_SIZE_ARRAYLIST(final ArrayList<FileNode> inAL) 440 { 441 final ArrayList<FileNode> al = (inAL != null) ? inAL : new ArrayList<>(); 442 return new RTC<>(al::add, () -> { al.sort(BY_FILE_SIZE); return al; }); 443 } 444 445 446 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 447 // Sorted By File-Size: TreeSet 448 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 449 450 /** Requests: TreeSet<FileNode> */ 451 public static RTC<TreeSet<FileNode>> SORTED_BY_SIZE_TREESET() 452 { 453 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE); 454 return new RTC<>(ts::add, () -> ts); 455 } 456 457 /** Requests: TreeSet<FileNode> */ 458 public static RTC<TreeSet<FileNode>> SORTED_BY_SIZE_TREESET(final TreeSet<FileNode> inTS) 459 { 460 final TreeSet<FileNode> ts = (inTS != null) ? inTS : new TreeSet<>(BY_FILE_SIZE); 461 return new RTC<>(ts::add, () -> ts); 462 } 463 464 465 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 466 // Sorted By File-Size: Stream 467 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 468 469 /** Requests: Stream<FileNode> */ 470 public static RTC<Stream<FileNode>> SORTED_BY_SIZE_STREAM() 471 { 472 final Stream.Builder<FileNode> b = Stream.builder(); 473 return new RTC<>(b::accept, () -> b.build().sorted(BY_FILE_SIZE)); 474 } 475 476 477 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 478 // Sorted By File-Size: FileNode[] 479 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 480 481 /** Requests: FileNode[] */ 482 public static RTC<FileNode[]> SORTED_BY_SIZE_ARRAY() 483 { 484 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE); 485 return new RTC<>(ts::add, () -> ts.toArray(ZERO_LEN_ARR_FN)); 486 } 487 488 489 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 490 // Sorted By File-Size: Iterator<FileNode> 491 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 492 493 /** Requests: Iterator<FileNode> */ 494 public static RTC<Iterator<FileNode>> SORTED_BY_SIZE_ITERATOR() 495 { 496 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE); 497 return new RTC<>(ts::add, () -> ts.iterator()); 498 } 499 500 501 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 502 // Sorted By File-Size: ReadOnlyArrayList 503 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 504 505 /** Requests: ReadOnlyArrayList<FileNode> */ 506 public static RTC<ReadOnlyArrayList<FileNode>> SORTED_BY_SIZE_ROAL() 507 { 508 final ROArrayListBuilder<FileNode> roalb = new ROArrayListBuilder<>(); 509 return new RTC<>(roalb::add, () -> { roalb.sort(BY_FILE_SIZE); return roalb.build(); }); 510 } 511 512 /** Requests: ROArrayListBuilder<FileNode> */ 513 public static RTC<ROArrayListBuilder<FileNode>> 514 SORTED_BY_SIZE_ROAL_BUILDER(final ROArrayListBuilder<FileNode> inROALB) 515 { 516 final ROArrayListBuilder<FileNode> roalb = (inROALB != null) 517 ? inROALB 518 : new ROArrayListBuilder<>(); 519 520 return new RTC<>(roalb::add, () -> { roalb.sort(BY_FILE_SIZE); return roalb; }); 521 } 522 523 524 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 525 // Sorted By File-Size: ReadOnlyTreeSet 526 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 527 528 /** Requests: ReadOnlyTreeSet<FileNode> */ 529 public static RTC<ReadOnlyTreeSet<FileNode>> SORTED_BY_SIZE_ROTS() 530 { 531 final ROTreeSetBuilder<FileNode> rotsb = new ROTreeSetBuilder<>(BY_FILE_SIZE); 532 return new RTC<>(rotsb::add, () -> rotsb.build()); 533 } 534 535 /** Requests: ROTreeSetBuilder<FileNode> */ 536 public static RTC<ROTreeSetBuilder<FileNode>> 537 SORTED_BY_SIZE_ROTS_BUILDER(final ROTreeSetBuilder<FileNode> inROTSB) 538 { 539 final ROTreeSetBuilder<FileNode> rotsb = (inROTSB != null) 540 ? inROTSB 541 : new ROTreeSetBuilder<>(BY_FILE_SIZE); 542 543 return new RTC<>(rotsb::add, () -> rotsb); 544 } 545 546 547 548 // ******************************************************************************************** 549 // ******************************************************************************************** 550 // ******************************************************************************************** 551 // private static final VarTypeBuilderWithSort<FileNode> vlbws3 = 552 // new VarTypeBuilderWithSort<>(BY_FULLPATH, FileNode.class); 553 // ******************************************************************************************** 554 // ******************************************************************************************** 555 // ******************************************************************************************** 556 557 558 559 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 560 // Sorted By Full-Path Name: Vector 561 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 562 563 /** Requests: Vector<FileNode> */ 564 public static RTC<Vector<FileNode>> SORTED_BY_FULLPATH_VECTOR() 565 { 566 final Vector<FileNode> v = new Vector<>(); 567 return new RTC<>(v::add, () -> { v.sort(BY_FULLPATH); return v; }); 568 } 569 570 /** Requests: Vector<FileNode> */ 571 public static RTC<Vector<FileNode>> SORTED_BY_FULLPATH_VECTOR(final Vector<FileNode> inV) 572 { 573 final Vector<FileNode> v = (inV != null) ? inV : new Vector<>(); 574 return new RTC<>(v::add, () -> { v.sort(BY_FULLPATH); return v; }); 575 } 576 577 578 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 579 // Sorted By Full-Path Name: ArrayList 580 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 581 582 /** Requests: ArrayList<FileNode> */ 583 public static RTC<ArrayList<FileNode>> SORTED_BY_FULLPATH_ARRAYLIST() 584 { 585 final ArrayList<FileNode> al = new ArrayList<>(); 586 return new RTC<>(al::add, () -> { al.sort(BY_FULLPATH); return al; }); 587 } 588 589 /** Requests: ArrayList<FileNode> */ 590 public static RTC<ArrayList<FileNode>> 591 SORTED_BY_FULLPATH_ARRAYLIST(final ArrayList<FileNode> inAL) 592 { 593 final ArrayList<FileNode> al = (inAL != null) ? inAL : new ArrayList<>(); 594 return new RTC<>(al::add, () -> { al.sort(BY_FULLPATH); return al; }); 595 } 596 597 598 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 599 // Sorted By Full-Path Name: TreeSet 600 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 601 602 /** Requests: TreeSet<FileNode> */ 603 public static RTC<TreeSet<FileNode>> SORTED_BY_FULLPATH_TREESET() 604 { 605 final TreeSet<FileNode> ts = new TreeSet<>(BY_FULLPATH); 606 return new RTC<>(ts::add, () -> ts); 607 } 608 609 /** Requests: TreeSet<FileNode> */ 610 public static RTC<TreeSet<FileNode>> SORTED_BY_FULLPATH_TREESET(final TreeSet<FileNode> inTS) 611 { 612 final TreeSet<FileNode> ts = (inTS != null) ? inTS : new TreeSet<>(BY_FULLPATH); 613 return new RTC<>(ts::add, () -> ts); 614 } 615 616 617 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 618 // Sorted By Full-Path Name: Stream 619 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 620 621 /** Requests: Stream<FileNode> */ 622 public static RTC<Stream<FileNode>> SORTED_BY_FULLPATH_STREAM() 623 { 624 final Stream.Builder<FileNode> b = Stream.builder(); 625 return new RTC<>(b::accept, () -> b.build().sorted(BY_FULLPATH)); 626 } 627 628 629 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 630 // Sorted By Full-Path Name: FileNode[] 631 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 632 633 /** Requests: FileNode[] */ 634 public static RTC<FileNode[]> SORTED_BY_FULLPATH_ARRAY() 635 { 636 final TreeSet<FileNode> ts = new TreeSet<>(BY_FULLPATH); 637 return new RTC<>(ts::add, () -> ts.toArray(ZERO_LEN_ARR_FN)); 638 } 639 640 641 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 642 // Sorted By Full-Path Name: Iterator<FileNode> 643 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 644 645 /** Requests: Iterator<FileNode> */ 646 public static RTC<Iterator<FileNode>> SORTED_BY_FULLPATH_ITERATOR() 647 { 648 final TreeSet<FileNode> ts = new TreeSet<>(BY_FULLPATH); 649 return new RTC<>(ts::add, () -> ts.iterator()); 650 } 651 652 653 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 654 // Sorted By Full-Path Name: ReadOnlyArrayList 655 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 656 657 /** Requests: ReadOnlyArrayList<FileNode> */ 658 public static RTC<ReadOnlyArrayList<FileNode>> SORTED_BY_FULLPATH_ROAL() 659 { 660 final ROArrayListBuilder<FileNode> roalb = new ROArrayListBuilder<>(); 661 return new RTC<>(roalb::add, () -> { roalb.sort(BY_FULLPATH); return roalb.build(); }); 662 } 663 664 /** Requests: ROArrayListBuilder<FileNode> */ 665 public static RTC<ROArrayListBuilder<FileNode>> 666 SORTED_BY_FULLPATH_ROAL_BUILDER(final ROArrayListBuilder<FileNode> inROALB) 667 { 668 final ROArrayListBuilder<FileNode> roalb = (inROALB != null) 669 ? inROALB 670 : new ROArrayListBuilder<>(); 671 672 return new RTC<>(roalb::add, () -> { roalb.sort(BY_FULLPATH); return roalb; }); 673 } 674 675 676 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 677 // Sorted By Full-Path Name: ReadOnlyTreeSet 678 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 679 680 /** Requests: ReadOnlyTreeSet<FileNode> */ 681 public static RTC<ReadOnlyTreeSet<FileNode>> SORTED_BY_FULLPATH_ROTS() 682 { 683 final ROTreeSetBuilder<FileNode> rotsb = new ROTreeSetBuilder<>(BY_FULLPATH); 684 return new RTC<>(rotsb::add, () -> rotsb.build()); 685 } 686 687 /** Requests: ROTreeSetBuilder<FileNode> */ 688 public static RTC<ROTreeSetBuilder<FileNode>> 689 SORTED_BY_FULLPATH_ROTS_BUILDER(final ROTreeSetBuilder<FileNode> inROTSB) 690 { 691 final ROTreeSetBuilder<FileNode> rotsb = (inROTSB != null) 692 ? inROTSB 693 : new ROTreeSetBuilder<>(BY_FULLPATH); 694 695 return new RTC<>(rotsb::add, () -> rotsb); 696 } 697 698 699 700 // ******************************************************************************************** 701 // ******************************************************************************************** 702 // ******************************************************************************************** 703 // private static final VarTypeBuilderWithSort<FileNode> vlbws4 = 704 // new VarTypeBuilderWithSort<>(BY_FILENAME, FileNode.class); 705 // ******************************************************************************************** 706 // ******************************************************************************************** 707 // ******************************************************************************************** 708 709 710 711 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 712 // Sorted By File-Name: Vector 713 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 714 715 /** Requests: Vector<FileNode> */ 716 public static RTC<Vector<FileNode>> SORTED_BY_FILENAME_VECTOR() 717 { 718 final Vector<FileNode> v = new Vector<>(); 719 return new RTC<>(v::add, () -> { v.sort(BY_FILENAME); return v; }); 720 } 721 722 /** Requests: Vector<FileNode> */ 723 public static RTC<Vector<FileNode>> SORTED_BY_FILENAME_VECTOR(final Vector<FileNode> inV) 724 { 725 final Vector<FileNode> v = (inV != null) ? inV : new Vector<>(); 726 return new RTC<>(v::add, () -> { v.sort(BY_FILENAME); return v; }); 727 } 728 729 730 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 731 // Sorted By File-Name: ArrayList 732 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 733 734 /** Requests: ArrayList<FileNode> */ 735 public static RTC<ArrayList<FileNode>> SORTED_BY_FILENAME_ARRAYLIST() 736 { 737 final ArrayList<FileNode> al = new ArrayList<>(); 738 return new RTC<>(al::add, () -> { al.sort(BY_FILENAME); return al; }); 739 } 740 741 /** Requests: ArrayList<FileNode> */ 742 public static RTC<ArrayList<FileNode>> 743 SORTED_BY_FILENAME_ARRAYLIST(final ArrayList<FileNode> inAL) 744 { 745 final ArrayList<FileNode> al = (inAL != null) ? inAL : new ArrayList<>(); 746 return new RTC<>(al::add, () -> { al.sort(BY_FILENAME); return al; }); 747 } 748 749 750 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 751 // Sorted By File-Name: TreeSet 752 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 753 754 /** Requests: TreeSet<FileNode> */ 755 public static RTC<TreeSet<FileNode>> SORTED_BY_FILENAME_TREESET() 756 { 757 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILENAME); 758 return new RTC<>(ts::add, () -> ts); 759 } 760 761 /** Requests: TreeSet<FileNode> */ 762 public static RTC<TreeSet<FileNode>> SORTED_BY_FILENAME_TREESET(final TreeSet<FileNode> inTS) 763 { 764 final TreeSet<FileNode> ts = (inTS != null) ? inTS : new TreeSet<>(BY_FILENAME); 765 return new RTC<>(ts::add, () -> ts); 766 } 767 768 769 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 770 // Sorted By File-Name: Stream 771 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 772 773 /** Requests: Stream<FileNode> */ 774 public static RTC<Stream<FileNode>> SORTED_BY_FILENAME_STREAM() 775 { 776 final Stream.Builder<FileNode> b = Stream.builder(); 777 return new RTC<>(b::accept, () -> b.build().sorted(BY_FILENAME)); 778 } 779 780 781 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 782 // Sorted By File-Name: FileNode[] 783 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 784 785 /** Requests: FileNode[] */ 786 public static RTC<FileNode[]> SORTED_BY_FILENAME_ARRAY() 787 { 788 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILENAME); 789 return new RTC<>(ts::add, () -> ts.toArray(ZERO_LEN_ARR_FN)); 790 } 791 792 793 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 794 // Sorted By File-Name: Iterator<FileNode> 795 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 796 797 /** Requests: Iterator<FileNode> */ 798 public static RTC<Iterator<FileNode>> SORTED_BY_FILENAME_ITERATOR() 799 { 800 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILENAME); 801 return new RTC<>(ts::add, () -> ts.iterator()); 802 } 803 804 805 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 806 // Sorted By File-Name: ReadOnlyArrayList 807 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 808 809 /** Requests: ReadOnlyArrayList<FileNode> */ 810 public static RTC<ReadOnlyArrayList<FileNode>> SORTED_BY_FILENAME_ROAL() 811 { 812 final ROArrayListBuilder<FileNode> roalb = new ROArrayListBuilder<>(); 813 return new RTC<>(roalb::add, () -> { roalb.sort(BY_FILENAME); return roalb.build(); }); 814 } 815 816 /** Requests: ROArrayListBuilder<FileNode> */ 817 public static RTC<ROArrayListBuilder<FileNode>> 818 SORTED_BY_FILENAME_ROAL_BUILDER(final ROArrayListBuilder<FileNode> inROALB) 819 { 820 final ROArrayListBuilder<FileNode> roalb = (inROALB != null) 821 ? inROALB 822 : new ROArrayListBuilder<>(); 823 824 return new RTC<>(roalb::add, () -> { roalb.sort(BY_FILENAME); return roalb; }); 825 } 826 827 828 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 829 // Sorted By File-Name: ReadOnlyTreeSet 830 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 831 832 /** Requests: ReadOnlyTreeSet<FileNode> */ 833 public static RTC<ReadOnlyTreeSet<FileNode>> SORTED_BY_FILENAME_ROTS() 834 { 835 final ROTreeSetBuilder<FileNode> rotsb = new ROTreeSetBuilder<>(BY_FILENAME); 836 return new RTC<>(rotsb::add, () -> rotsb.build()); 837 } 838 839 /** Requests: ROTreeSetBuilder<FileNode> */ 840 public static RTC<ROTreeSetBuilder<FileNode>> 841 SORTED_BY_FILENAME_ROTS_BUILDER(final ROTreeSetBuilder<FileNode> inROTSB) 842 { 843 final ROTreeSetBuilder<FileNode> rotsb = (inROTSB != null) 844 ? inROTSB 845 : new ROTreeSetBuilder<>(BY_FILENAME); 846 847 return new RTC<>(rotsb::add, () -> rotsb); 848 } 849 850 851 852 // ******************************************************************************************** 853 // ******************************************************************************************** 854 // ******************************************************************************************** 855 // private static final VarTypeBuilderWithApply<FileNode, String> vlbwa1 = 856 // new VarTypeBuilderWithApply<>((FileNode fn) -> fn.name, String.class); 857 // ******************************************************************************************** 858 // ******************************************************************************************** 859 // ******************************************************************************************** 860 861 862 863 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 864 // File-Names as String: Vector 865 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 866 867 /** Requests: Vector<String> */ 868 public static RTC<Vector<String>> FILENAME_VECTOR() 869 { 870 final Vector<String> v = new Vector<>(); 871 return new RTC<>((FileNode fn) -> v.add(fn.name), () -> v); 872 } 873 874 /** Requests: Vector<String> */ 875 public static RTC<Vector<String>> FILENAME_VECTOR(final Vector<String> inV) 876 { 877 final Vector<String> v = (inV != null) ? inV : new Vector<>(); 878 return new RTC<>((FileNode fn) -> v.add(fn.name), () -> v); 879 } 880 881 882 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 883 // File-Names as String: ArrayList 884 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 885 886 /** Requests: ArrayList<String> */ 887 public static RTC<ArrayList<String>> FILENAME_ARRAYLIST() 888 { 889 final ArrayList<String> al = new ArrayList<>(); 890 return new RTC<>((FileNode fn) -> al.add(fn.name), () -> al); 891 } 892 893 /** Requests: ArrayList<String> */ 894 public static RTC<ArrayList<String>> FILENAME_ARRAYLIST(final ArrayList<String> inAL) 895 { 896 final ArrayList<String> al = (inAL != null) ? inAL : new ArrayList<>(); 897 return new RTC<>((FileNode fn) -> al.add(fn.name), () -> al); 898 } 899 900 901 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 902 // File-Names as String: HashSet 903 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 904 905 /** Requests: HashSet<String> */ 906 public static RTC<HashSet<String>> FILENAME_HASHSET() 907 { 908 final HashSet<String> hs = new HashSet<>(); 909 return new RTC<>((FileNode fn) -> hs.add(fn.name), () -> hs); 910 } 911 912 /** Requests: HashSet<String> */ 913 public static RTC<HashSet<String>> FILENAME_HASHSET(final HashSet<String> inHS) 914 { 915 final HashSet<String> hs = (inHS != null) ? inHS : new HashSet<>(); 916 return new RTC<>((FileNode fn) -> hs.add(fn.name), () -> hs); 917 } 918 919 920 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 921 // File-Names as String: Stream 922 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 923 924 /** Requests: Stream<String> */ 925 public static RTC<Stream<String>> FILENAME_STREAM() 926 { 927 final Stream.Builder<String> b = Stream.builder(); 928 return new RTC<>((FileNode fn) -> b.accept(fn.name), () -> b.build()); 929 } 930 931 932 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 933 // File-Names as String: Stream.Builder 934 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 935 936 /** Requests: Stream.Builder<String> */ 937 public static RTC<Stream.Builder<String>> 938 FILENAME_STREAM_BUILDER(final Stream.Builder<String> inB) 939 { 940 final Stream.Builder<String> b = (inB != null) ? inB : Stream.builder(); 941 return new RTC<>((FileNode fn) -> b.accept(fn.name), () -> b); 942 } 943 944 945 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 946 // File-Names as String: String[] 947 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 948 949 /** Requests: String[] */ 950 public static RTC<String[]> FILENAME_ARRAY() 951 { 952 final Stream.Builder<String> b = Stream.builder(); 953 954 return new RTC<>( 955 (FileNode fn) -> b.accept(fn.name), 956 () -> b.build().toArray(String[]::new) 957 ); 958 } 959 960 961 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 962 // Iterator<FileNode> 963 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 964 965 /** Requests: Iterator<String> */ 966 public static RTC<Iterator<String>> FILENAME_ITERATOR() 967 { 968 final ArrayList<String> al = new ArrayList<>(); 969 return new RTC<>((FileNode fn) -> al.add(fn.name), () -> al.iterator()); 970 } 971 972 973 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 974 // File-Names as String: ReadOnlyArrayList 975 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 976 977 /** Requests: ReadOnlyArrayList<String> */ 978 public static RTC<ReadOnlyArrayList<String>> FILENAME_ROAL() 979 { 980 final ROArrayListBuilder<String> roalb = new ROArrayListBuilder<>(); 981 return new RTC<>((FileNode fn) -> roalb.add(fn.name), () -> roalb.build()); 982 } 983 984 /** Requests: ROArrayListBuilder<String> */ 985 public static RTC<ROArrayListBuilder<String>> 986 FILENAME_ROAL_BUILDER(final ROArrayListBuilder<String> inROALB) 987 { 988 final ROArrayListBuilder<String> roalb = (inROALB != null) 989 ? inROALB 990 : new ROArrayListBuilder<>(); 991 992 return new RTC<>((FileNode fn) -> roalb.add(fn.name), () -> roalb); 993 } 994 995 996 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 997 // File-Names as String: ReadOnlyHashSet 998 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 999 1000 /** Requests: ReadOnlyHashSet<String> */ 1001 public static RTC<ReadOnlyHashSet<String>> FILENAME_ROHS() 1002 { 1003 final ROHashSetBuilder<String> rohsb = new ROHashSetBuilder<>(); 1004 return new RTC<>((FileNode fn) -> rohsb.add(fn.name), () -> rohsb.build()); 1005 } 1006 1007 /** Requests: ROHashSetBuilder<String> */ 1008 public static RTC<ROHashSetBuilder<String>> 1009 FILENAME_ROHS_BUILDER(final ROHashSetBuilder<String> inROHSB) 1010 { 1011 final ROHashSetBuilder<String> rohsb = (inROHSB != null) 1012 ? inROHSB 1013 : new ROHashSetBuilder<>(); 1014 1015 return new RTC<>((FileNode fn) -> rohsb.add(fn.name), () -> rohsb); 1016 } 1017 1018 1019 1020 // ******************************************************************************************** 1021 // ******************************************************************************************** 1022 // ******************************************************************************************** 1023 // private static final VarTypeBuilderWithApply<FileNode, String> vlbwa2 = 1024 // new VarTypeBuilderWithApply<>((FileNode fn) -> fn.getFullPathName(), String.class); 1025 // ******************************************************************************************** 1026 // ******************************************************************************************** 1027 // ******************************************************************************************** 1028 1029 1030 1031 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1032 // Complete (Full-Path) File-Names as String: Vector 1033 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1034 1035 /** Requests: Vector<String> */ 1036 public static RTC<Vector<String>> FULLPATH_VECTOR() 1037 { 1038 final Vector<String> v = new Vector<>(); 1039 return new RTC<>((FileNode fn) -> v.add(fn.getFullPathName()), () -> v); 1040 } 1041 1042 /** Requests: Vector<String> */ 1043 public static RTC<Vector<String>> FULLPATH_VECTOR(final Vector<String> inV) 1044 { 1045 final Vector<String> v = (inV != null) ? inV : new Vector<>(); 1046 return new RTC<>((FileNode fn) -> v.add(fn.getFullPathName()), () -> v); 1047 } 1048 1049 1050 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1051 // Complete (Full-Path) File-Names as String: ArrayList 1052 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1053 1054 /** Requests: ArrayList<String> */ 1055 public static RTC<ArrayList<String>> FULLPATH_ARRAYLIST() 1056 { 1057 final ArrayList<String> al = new ArrayList<>(); 1058 return new RTC<>((FileNode fn) -> al.add(fn.getFullPathName()), () -> al); 1059 } 1060 1061 /** Requests: ArrayList<String> */ 1062 public static RTC<ArrayList<String>> FULLPATH_ARRAYLIST 1063 (final ArrayList<String> inAL) 1064 { 1065 final ArrayList<String> al = (inAL != null) ? inAL : new ArrayList<>(); 1066 return new RTC<>((FileNode fn) -> al.add(fn.getFullPathName()), () -> al); 1067 } 1068 1069 1070 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1071 // Complete (Full-Path) File-Names as String: HashSet 1072 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1073 1074 /** Requests: HashSet<String> */ 1075 public static RTC<HashSet<String>> FULLPATH_HASHSET() 1076 { 1077 final HashSet<String> hs = new HashSet<>(); 1078 return new RTC<>((FileNode fn) -> hs.add(fn.getFullPathName()), () -> hs); 1079 } 1080 1081 /** Requests: HashSet<String> */ 1082 public static RTC<HashSet<String>> FULLPATH_HASHSET(final HashSet<String> inHS) 1083 { 1084 final HashSet<String> hs = (inHS != null) ? inHS : new HashSet<>(); 1085 return new RTC<>((FileNode fn) -> hs.add(fn.getFullPathName()), () -> hs); 1086 } 1087 1088 1089 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1090 // Complete (Full-Path) File-Names as String: Stream 1091 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1092 1093 /** Requests: Stream<String> */ 1094 public static RTC<Stream<String>> FULLPATH_STREAM() 1095 { 1096 final Stream.Builder<String> b = Stream.builder(); 1097 return new RTC<>((FileNode fn) -> b.accept(fn.getFullPathName()), () -> b.build()); 1098 } 1099 1100 1101 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1102 // Complete (Full-Path) File-Names as String: Stream.Builder 1103 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1104 1105 /** Requests: Stream.Builder<String> */ 1106 public static RTC<Stream.Builder<String>> 1107 FULLPATH_STREAM_BUILDER(final Stream.Builder<String> inB) 1108 { 1109 final Stream.Builder<String> b = (inB != null) ? inB : Stream.builder(); 1110 return new RTC<>((FileNode fn) -> b.accept(fn.getFullPathName()), () -> b); 1111 } 1112 1113 1114 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1115 // Complete (Full-Path) File-Names as String: String[] 1116 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1117 1118 /** Requests: String[] */ 1119 public static RTC<String[]> FULLPATH_ARRAY() 1120 { 1121 final Stream.Builder<String> b = Stream.builder(); 1122 1123 return new RTC<>( 1124 (FileNode fn) -> b.accept(fn.getFullPathName()), 1125 () -> b.build().toArray(String[]::new) 1126 ); 1127 } 1128 1129 1130 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1131 // Complete (Full-Path) File-Names as String: Iterator<String> 1132 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1133 1134 /** Requests: Iterator<String> */ 1135 public static RTC<Iterator<String>> FULLPATH_ITERATOR() 1136 { 1137 final ArrayList<String> al = new ArrayList<>(); 1138 return new RTC<>((FileNode fn) -> al.add(fn.getFullPathName()), () -> al.iterator()); 1139 } 1140 1141 1142 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1143 // Complete (Full-Path) File-Names as String: ReadOnlyArrayList 1144 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1145 1146 /** Requests: ReadOnlyArrayList<String> */ 1147 public static RTC<ReadOnlyArrayList<String>> FULLPATH_ROAL() 1148 { 1149 final ROArrayListBuilder<String> roalb = new ROArrayListBuilder<>(); 1150 1151 return new RTC<>( 1152 (FileNode fn) -> roalb.add(fn.getFullPathName()), 1153 () -> roalb.build() 1154 ); 1155 } 1156 1157 /** Requests: ROArrayListBuilder<String> */ 1158 public static RTC<ROArrayListBuilder<String>> 1159 FULLPATH_ROAL_BUILDER(final ROArrayListBuilder<String> inROALB) 1160 { 1161 final ROArrayListBuilder<String> roalb = (inROALB != null) 1162 ? inROALB 1163 : new ROArrayListBuilder<>(); 1164 1165 return new RTC<>((FileNode fn) -> roalb.add(fn.getFullPathName()), () -> roalb); 1166 } 1167 1168 1169 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1170 // Complete (Full-Path) File-Names as String: ReadOnlyHashSet 1171 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1172 1173 /** Requests: ReadOnlyHashSet<String> */ 1174 public static RTC<ReadOnlyHashSet<String>> FULLPATH_ROHS() 1175 { 1176 final ROHashSetBuilder<String> rohsb = new ROHashSetBuilder<>(); 1177 1178 return new RTC<>( 1179 (FileNode fn) -> rohsb.add(fn.getFullPathName()), 1180 () -> rohsb.build() 1181 ); 1182 } 1183 1184 /** Requests: ROHashSetBuilder<String> */ 1185 public static RTC<ROHashSetBuilder<String>> 1186 FULLPATH_ROHS_BUILDER(final ROHashSetBuilder<String> inROHSB) 1187 { 1188 final ROHashSetBuilder<String> rohsb = (inROHSB != null) 1189 ? inROHSB 1190 : new ROHashSetBuilder<>(); 1191 1192 return new RTC<>((FileNode fn) -> rohsb.add(fn.getFullPathName()), () -> rohsb); 1193 } 1194 1195 1196 1197 // ******************************************************************************************** 1198 // ******************************************************************************************** 1199 // ******************************************************************************************** 1200 // private static final VarTypeBuilderWithApplyAndSort<FileNode, String> vlbwaas1 = 1201 // new VarTypeBuilderWithApplyAndSort<> 1202 // ((FileNode fn) -> fn.name, String::compareTo, String.class); 1203 // ******************************************************************************************** 1204 // ******************************************************************************************** 1205 // ******************************************************************************************** 1206 1207 1208 1209 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1210 // Sorted Vector<String> (of FileName's) 1211 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1212 1213 /** Requests: Vector<String> */ 1214 public static RTC<Vector<String>> SORTED_FILENAME_VECTOR() 1215 { 1216 final Vector<String> v = new Vector<>(); 1217 1218 return new RTC<>( 1219 (FileNode fn) -> v.add(fn.name), 1220 () -> { v.sort(String::compareTo); return v; } 1221 ); 1222 } 1223 1224 /** Requests: Vector<String> */ 1225 public static RTC<Vector<String>> SORTED_FILENAME_VECTOR(final Vector<String> inV) 1226 { 1227 final Vector<String> v = (inV != null) ? inV : new Vector<>(); 1228 1229 return new RTC<>( 1230 (FileNode fn) -> v.add(fn.name), 1231 () -> { v.sort(String::compareTo); return v; } 1232 ); 1233 } 1234 1235 1236 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1237 // Sorted ArrayList<String> (of FileName's) 1238 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1239 1240 /** Requests: ArrayList<String> */ 1241 public static RTC<ArrayList<String>> SORTED_FILENAME_ARRAYLIST() 1242 { 1243 final ArrayList<String> al = new ArrayList<>(); 1244 1245 return new RTC<>( 1246 (FileNode fn) -> al.add(fn.name), 1247 () -> { al.sort(String::compareTo); return al; } 1248 ); 1249 } 1250 1251 /** Requests: ArrayList<String> */ 1252 public static RTC<ArrayList<String>> SORTED_FILENAME_ARRAYLIST(final ArrayList<String> inAL) 1253 { 1254 final ArrayList<String> al = (inAL != null) ? inAL : new ArrayList<>(); 1255 1256 return new RTC<>( 1257 (FileNode fn) -> al.add(fn.name), 1258 () -> { al.sort(String::compareTo); return al; } 1259 ); 1260 } 1261 1262 1263 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1264 // Sorted TreeSet<String> (of FileName's) 1265 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1266 1267 /** Requests: TreeSet<String> */ 1268 public static RTC<TreeSet<String>> SORTED_FILENAME_TREESET() 1269 { 1270 final TreeSet<String> ts = new TreeSet<>(String::compareTo); 1271 return new RTC<>((FileNode fn) -> ts.add(fn.name), () -> ts); 1272 } 1273 1274 /** Requests: TreeSet<String> */ 1275 public static RTC<TreeSet<String>> SORTED_FILENAME_TREESET(final TreeSet<String> inTS) 1276 { 1277 final TreeSet<String> ts = (inTS != null) ? inTS : new TreeSet<>(String::compareTo); 1278 return new RTC<>((FileNode fn) -> ts.add(fn.name), () -> ts); 1279 } 1280 1281 1282 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1283 // Sorted Stream<String> (of FileName's) 1284 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1285 1286 /** Requests: Stream<String> */ 1287 public static RTC<Stream<String>> SORTED_FILENAME_STREAM() 1288 { 1289 final Stream.Builder<String> b = Stream.builder(); 1290 1291 return new RTC<>( 1292 (FileNode fn) -> b.accept(fn.name), 1293 () -> b.build().sorted(String::compareTo) 1294 ); 1295 } 1296 1297 1298 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1299 // Sorted String[] (of FileName's) 1300 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1301 1302 /** Requests: String[] */ 1303 public static RTC<String[]> SORTED_FILENAME_ARRAY() 1304 { 1305 final TreeSet<String> ts = new TreeSet<>(String::compareTo); 1306 1307 return new RTC<>( 1308 (FileNode fn) -> ts.add(fn.name), 1309 () -> ts.toArray(ZERO_LEN_ARR_STR) 1310 ); 1311 } 1312 1313 1314 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1315 // Sorted Iterator<String> (of FileName's) 1316 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1317 1318 /** Requests: Iterator<String> */ 1319 public static RTC<Iterator<String>> SORTED_FILENAME_ITERATOR() 1320 { 1321 final TreeSet<String> ts = new TreeSet<>(String::compareTo); 1322 1323 return new RTC<>( 1324 (FileNode fn) -> ts.add(fn.name), 1325 () -> ts.iterator() 1326 ); 1327 } 1328 1329 1330 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1331 // Sorted ReadOnlyArrayList<String> (of FileName's) 1332 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1333 1334 /** Requests: ReadOnlyArrayList<String> */ 1335 public static RTC<ReadOnlyArrayList<String>> SORTED_FILENAME_ROAL() 1336 { 1337 final ROArrayListBuilder<String> roalb = new ROArrayListBuilder<>(); 1338 1339 return new RTC<>( 1340 (FileNode fn) -> roalb.add(fn.name), 1341 () -> { roalb.sort(String::compareTo); return roalb.build(); } 1342 ); 1343 } 1344 1345 /** Requests: ROArrayListBuilder<String> */ 1346 public static RTC<ROArrayListBuilder<String>> 1347 SORTED_FILENAME_ROAL_BUILDER(final ROArrayListBuilder<String> inROALB) 1348 { 1349 final ROArrayListBuilder<String> roalb = (inROALB != null) 1350 ? inROALB 1351 : new ROArrayListBuilder<>(); 1352 1353 return new RTC<>( 1354 (FileNode fn) -> roalb.add(fn.name), 1355 () -> { roalb.sort(String::compareTo); return roalb; } 1356 ); 1357 } 1358 1359 1360 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1361 // Sorted ReadOnlyTreeSet<String> (of FileName's) 1362 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1363 1364 /** Requests: ReadOnlyTreeSet<String> */ 1365 public static RTC<ReadOnlyTreeSet<String>> 1366 SORTED_FILENAME_ROTS() 1367 { 1368 final ROTreeSetBuilder<String> rotsb = new ROTreeSetBuilder<>(String::compareTo); 1369 return new RTC<>((FileNode fn) -> rotsb.add(fn.name), () -> rotsb.build()); 1370 } 1371 1372 /** Requests: ROTreeSetBuilder<String> */ 1373 public static RTC<ROTreeSetBuilder<String>> 1374 SORTED_FILENAME_ROTS_BUILDER(final ROTreeSetBuilder<String> inROTSB) 1375 { 1376 final ROTreeSetBuilder<String> rotsb = (inROTSB != null) 1377 ? inROTSB 1378 : new ROTreeSetBuilder<>(String::compareTo); 1379 1380 return new RTC<>((FileNode fn) -> rotsb.add(fn.name), () -> rotsb); 1381 } 1382 1383 1384 1385 // ******************************************************************************************** 1386 // ******************************************************************************************** 1387 // ******************************************************************************************** 1388 // private static final VarTypeBuilderWithApplyAndSort<FileNode, String> vlbwaas2 1389 // = new VarTypeBuilderWithApplyAndSort<> 1390 // ((FileNode fn) -> fn.getFullPathName(), String::compareTo, String.class); 1391 // ******************************************************************************************** 1392 // ******************************************************************************************** 1393 // ******************************************************************************************** 1394 1395 1396 1397 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1398 // Sorted Vector<String> (of Full-Path / Complete File-Name's) 1399 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1400 1401 /** Requests: Vector<String> */ 1402 public static RTC<Vector<String>> SORTED_FULLPATH_VECTOR() 1403 { 1404 final Vector<String> v = new Vector<>(); 1405 1406 return new RTC<>( 1407 (FileNode fn) -> v.add(fn.getFullPathName()), 1408 () -> { v.sort(String::compareTo); return v; } 1409 ); 1410 } 1411 1412 /** Requests: Vector<String> */ 1413 public static RTC<Vector<String>> SORTED_FULLPATH_VECTOR(final Vector<String> inV) 1414 { 1415 final Vector<String> v = (inV != null) ? inV : new Vector<>(); 1416 1417 return new RTC<>( 1418 (FileNode fn) -> v.add(fn.getFullPathName()), 1419 () -> { v.sort(String::compareTo); return v; } 1420 ); 1421 } 1422 1423 1424 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1425 // Sorted ArrayList<String> (of Full-Path / Complete File-Name's) 1426 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1427 1428 /** Requests: ArrayList<String> */ 1429 public static RTC<ArrayList<String>> SORTED_FULLPATH_ARRAYLIST() 1430 { 1431 final ArrayList<String> al = new ArrayList<>(); 1432 1433 return new RTC<>( 1434 (FileNode fn) -> al.add(fn.getFullPathName()), 1435 () -> { al.sort(String::compareTo); return al; } 1436 ); 1437 } 1438 1439 /** Requests: ArrayList<String> */ 1440 public static RTC<ArrayList<String>> SORTED_FULLPATH_ARRAYLIST(final ArrayList<String> inAL) 1441 { 1442 final ArrayList<String> al = (inAL != null) ? inAL : new ArrayList<>(); 1443 1444 return new RTC<>( 1445 (FileNode fn) -> al.add(fn.getFullPathName()), 1446 () -> { al.sort(String::compareTo); return al; } 1447 ); 1448 } 1449 1450 1451 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1452 // Sorted TreeSet<String> (of Full-Path / Complete File-Name's) 1453 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1454 1455 /** Requests: TreeSet<String> */ 1456 public static RTC<TreeSet<String>> SORTED_FULLPATH_TREESET() 1457 { 1458 final TreeSet<String> ts = new TreeSet<>(String::compareTo); 1459 return new RTC<>((FileNode fn) -> ts.add(fn.getFullPathName()), () -> ts); 1460 } 1461 1462 /** Requests: TreeSet<String> */ 1463 public static RTC<TreeSet<String>> SORTED_FULLPATH_TREESET(final TreeSet<String> inTS) 1464 { 1465 final TreeSet<String> ts = (inTS != null) ? inTS : new TreeSet<>(String::compareTo); 1466 return new RTC<>((FileNode fn) -> ts.add(fn.getFullPathName()), () -> ts); 1467 } 1468 1469 1470 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1471 // Sorted Stream<String> (of Full-Path / Complete File-Name's) 1472 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1473 1474 /** Requests: Stream<String> */ 1475 public static RTC<Stream<String>> SORTED_FULLPATH_STREAM() 1476 { 1477 final Stream.Builder<String> b = Stream.builder(); 1478 1479 return new RTC<>( 1480 (FileNode fn) -> b.accept(fn.getFullPathName()), 1481 () -> b.build().sorted(String::compareTo) 1482 ); 1483 } 1484 1485 1486 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1487 // Sorted String[] (of Full-Path / Complete File-Name's) 1488 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1489 1490 /** Requests: String[] */ 1491 public static RTC<String[]> SORTED_FULLPATH_ARRAY() 1492 { 1493 final TreeSet<String> ts = new TreeSet<>(String::compareTo); 1494 1495 return new RTC<>( 1496 (FileNode fn) -> ts.add(fn.getFullPathName()), 1497 () -> ts.toArray(ZERO_LEN_ARR_STR) 1498 ); 1499 } 1500 1501 1502 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1503 // Sorted Iterator<String> (of Full-Path / Complete File-Name's) 1504 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1505 1506 /** Requests: Iterator<String> */ 1507 public static RTC<Iterator<String>> SORTED_FULLPATH_ITERATOR() 1508 { 1509 final TreeSet<String> ts = new TreeSet<>(String::compareTo); 1510 1511 return new RTC<>( 1512 (FileNode fn) -> ts.add(fn.getFullPathName()), 1513 () -> ts.iterator() 1514 ); 1515 } 1516 1517 1518 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1519 // Sorted ReadOnlyArrayList<String> (of Full-Path / Complete File-Name's) 1520 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1521 1522 /** Requests: ReadOnlyArrayList<String> */ 1523 public static RTC<ReadOnlyArrayList<String>> SORTED_FULLPATH_ROAL() 1524 { 1525 final ROArrayListBuilder<String> roalb = new ROArrayListBuilder<>(); 1526 1527 return new RTC<>( 1528 (FileNode fn) -> roalb.add(fn.getFullPathName()), 1529 () -> { roalb.sort(String::compareTo); return roalb.build(); } 1530 ); 1531 } 1532 1533 /** Requests: ROArrayListBuilder<String> */ 1534 public static RTC<ROArrayListBuilder<String>> 1535 SORTED_FULLPATH_ROAL_BUILDER(final ROArrayListBuilder<String> inROALB) 1536 { 1537 final ROArrayListBuilder<String> roalb = (inROALB != null) 1538 ? inROALB 1539 : new ROArrayListBuilder<>(); 1540 1541 return new RTC<>( 1542 (FileNode fn) -> roalb.add(fn.getFullPathName()), 1543 () -> { roalb.sort(String::compareTo); return roalb; } 1544 ); 1545 } 1546 1547 1548 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1549 // Sorted ReadOnlyTreeSet<String> (of Full-Path / Complete File-Name's) 1550 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1551 1552 /** Requests: ReadOnlyTreeSet<String> */ 1553 public static RTC<ReadOnlyTreeSet<String>> 1554 SORTED_FULLPATH_ROTS() 1555 { 1556 final ROTreeSetBuilder<String> rotsb = new ROTreeSetBuilder<>(String::compareTo); 1557 return new RTC<>((FileNode fn) -> rotsb.add(fn.getFullPathName()), () -> rotsb.build()); 1558 } 1559 1560 /** Requests: ROTreeSetBuilder<String> */ 1561 public static RTC<ROTreeSetBuilder<String>> 1562 SORTED_FULLPATH_ROTS_BUILDER(final ROTreeSetBuilder<String> inROTSB) 1563 { 1564 final ROTreeSetBuilder<String> rotsb = (inROTSB != null) 1565 ? inROTSB 1566 : new ROTreeSetBuilder<>(String::compareTo); 1567 1568 return new RTC<>((FileNode fn) -> rotsb.add(fn.getFullPathName()), () -> rotsb); 1569 } 1570 1571 1572 1573 // ******************************************************************************************** 1574 // ******************************************************************************************** 1575 // ******************************************************************************************** 1576 // private static final VarTypeBuilderWithSortAndApply<FileNode, String> vlbwsaa1 = 1577 // new VarTypeBuilderWithSortAndApply<> 1578 // (BY_DATE, (FileNode fn) -> fn.name, String.class); 1579 // ******************************************************************************************** 1580 // ******************************************************************************************** 1581 // ******************************************************************************************** 1582 1583 1584 1585 // *** *** 1586 private static <T> T toFileNames( 1587 TreeSet<FileNode> ts, 1588 Supplier<T> constructor, 1589 Function<T, Consumer<String>> createAnInserter 1590 ) 1591 { 1592 T dataStructure = constructor.get(); 1593 Consumer<String> inserter = createAnInserter.apply(dataStructure); 1594 for (FileNode fn : ts) inserter.accept(fn.name); 1595 return dataStructure; 1596 } 1597 // *** *** 1598 1599 1600 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1601 // Soted *** BY-DATE *** Vector<String> (of FileName's) 1602 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1603 1604 /** Requests: Vector<String> */ 1605 public static RTC<Vector<String>> SORTED_BY_DATE_FILENAME_VECTOR() 1606 { 1607 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE); 1608 1609 return new RTC<>( 1610 ts::add, 1611 () -> toFileNames(ts, Vector<String>::new, (Vector<String> v) -> v::add) 1612 ); 1613 } 1614 1615 1616 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1617 // Soted *** BY-DATE *** ArrayList<String> (of FileName's) 1618 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1619 1620 /** Requests: ArrayList<String> */ 1621 public static RTC<ArrayList<String>> SORTED_BY_DATE_FILENAME_ARRAYLIST() 1622 { 1623 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE); 1624 1625 return new RTC<>( 1626 ts::add, 1627 () -> toFileNames(ts, ArrayList<String>::new, (ArrayList<String> al) -> al::add) 1628 ); 1629 } 1630 1631 1632 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1633 // Soted *** BY-DATE *** TreeSet<String> (of FileName's) 1634 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1635 1636 /** Requests: TreeSet<String> */ 1637 public static RTC<TreeSet<String>> SORTED_BY_DATE_FILENAME_TREESET() 1638 { 1639 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE); 1640 1641 return new RTC<>( 1642 ts::add, 1643 () -> toFileNames(ts, TreeSet<String>::new, (TreeSet<String> tsRet) -> tsRet::add) 1644 ); 1645 } 1646 1647 1648 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1649 // Soted *** BY-DATE *** Stream<String> (of FileName's) 1650 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1651 1652 /** Requests: Stream<String> */ 1653 public static RTC<Stream<String>> SORTED_BY_DATE_FILENAME_STREAM() 1654 { 1655 final Stream.Builder<FileNode> b = Stream.builder(); 1656 1657 return new RTC<>( 1658 b::accept, 1659 () -> b.build().sorted(BY_DATE).map((FileNode fn) -> fn.name) 1660 ); 1661 } 1662 1663 1664 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1665 // Soted *** BY-DATE *** String[] (of FileName's) 1666 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1667 1668 /** Requests: String[] */ 1669 public static RTC<String[]> SORTED_BY_DATE_FILENAME_ARRAY() 1670 { 1671 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE); 1672 1673 return new RTC<>( 1674 ts::add, 1675 1676 () -> 1677 { 1678 String[] retArr = new String[ts.size()]; 1679 int i = 0; 1680 1681 for (FileNode fn : ts) retArr[i++] = fn.name; 1682 return retArr; 1683 } 1684 ); 1685 } 1686 1687 1688 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1689 // Soted *** BY-DATE *** Iterator<String> (of FileName's) 1690 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1691 1692 /** Requests: Iterator<String> */ 1693 public static RTC<Iterator<String>> SORTED_BY_DATE_FILENAME_ITERATOR() 1694 { 1695 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE); 1696 1697 return new RTC<>( 1698 ts::add, 1699 1700 () -> toFileNames( 1701 ts, 1702 TreeSet<String>::new, 1703 (TreeSet<String> tsRet) -> tsRet::add 1704 ) 1705 .iterator() 1706 ); 1707 } 1708 1709 1710 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1711 // Soted *** BY-DATE *** ReadOnlyArrayList<String> (of FileName's) 1712 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1713 1714 /** Requests: ReadOnlyArrayList<String> */ 1715 public static RTC<ReadOnlyArrayList<String>> SORTED_BY_DATE_FILENAME_ROAL() 1716 { 1717 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE); 1718 1719 return new RTC<>( 1720 ts::add, 1721 1722 () -> toFileNames( 1723 ts, 1724 ROArrayListBuilder<String>::new, 1725 (ROArrayListBuilder<String> roalb) -> roalb::add 1726 ) 1727 .build() 1728 ); 1729 } 1730 1731 1732 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1733 // Soted *** BY-DATE *** ReadOnlyTreeSet<String> (of FileName's) 1734 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1735 1736 /** Requests: ReadOnlyTreeSet<String> */ 1737 public static RTC<ReadOnlyTreeSet<String>> SORTED_BY_DATE_FILENAME_ROTS() 1738 { 1739 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE); 1740 1741 return new RTC<>( 1742 ts::add, 1743 1744 () -> toFileNames( 1745 ts, 1746 ROTreeSetBuilder<String>::new, 1747 (ROTreeSetBuilder<String> rotsb) -> rotsb::add 1748 ) 1749 .build() 1750 ); 1751 } 1752 1753 1754 1755 // ******************************************************************************************** 1756 // ******************************************************************************************** 1757 // ******************************************************************************************** 1758 // private static final VarTypeBuilderWithSortAndApply<FileNode, String> vlbwsaa2 = 1759 // new VarTypeBuilderWithSortAndApply<> 1760 // (BY_DATE, (FileNode fn) -> fn.getFullPathName(), String.class); 1761 // ******************************************************************************************** 1762 // ******************************************************************************************** 1763 // ******************************************************************************************** 1764 1765 1766 1767 // *** *** 1768 private static <T> T toFullPaths( 1769 TreeSet<FileNode> ts, 1770 Supplier<T> constructor, 1771 Function<T, Consumer<String>> createAnInserter 1772 ) 1773 { 1774 T dataStructure = constructor.get(); 1775 Consumer<String> inserter = createAnInserter.apply(dataStructure); 1776 for (FileNode fn : ts) inserter.accept(fn.getFullPathName()); 1777 return dataStructure; 1778 } 1779 // *** *** 1780 1781 1782 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1783 // Soted *** BY-DATE *** Vector<String> (of Full-Path / Complete File-Names) 1784 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1785 1786 /** Requests: Vector<String> */ 1787 public static RTC<Vector<String>> SORTED_BY_DATE_FULLPATH_VECTOR() 1788 { 1789 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE); 1790 1791 return new RTC<>( 1792 ts::add, 1793 () -> toFullPaths(ts, Vector<String>::new, (Vector<String> v) -> v::add) 1794 ); 1795 } 1796 1797 1798 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1799 // Soted *** BY-DATE *** ArrayList<String> (of Full-Path / Complete File-Names) 1800 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1801 1802 /** Requests: ArrayList<String> */ 1803 public static RTC<ArrayList<String>> SORTED_BY_DATE_FULLPATH_ARRAYLIST() 1804 { 1805 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE); 1806 1807 return new RTC<>( 1808 ts::add, 1809 () -> toFullPaths(ts, ArrayList<String>::new, (ArrayList<String> al) -> al::add) 1810 ); 1811 } 1812 1813 1814 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1815 // Soted *** BY-DATE *** TreeSet<String> (of Full-Path / Complete File-Names) 1816 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1817 1818 /** Requests: TreeSet<String> */ 1819 public static RTC<TreeSet<String>> SORTED_BY_DATE_FULLPATH_TREESET() 1820 { 1821 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE); 1822 1823 return new RTC<>( 1824 ts::add, 1825 () -> toFullPaths(ts, TreeSet<String>::new, (TreeSet<String> tsRet) -> tsRet::add) 1826 ); 1827 } 1828 1829 1830 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1831 // Soted *** BY-DATE *** Stream<String> (of Full-Path / Complete File-Names) 1832 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1833 1834 /** Requests: Stream<String> */ 1835 public static RTC<Stream<String>> SORTED_BY_DATE_FULLPATH_STREAM() 1836 { 1837 final Stream.Builder<FileNode> b = Stream.builder(); 1838 1839 return new RTC<>( 1840 b::accept, 1841 () -> b.build().sorted(BY_DATE).map((FileNode fn) -> fn.getFullPathName()) 1842 ); 1843 } 1844 1845 1846 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1847 // Soted *** BY-DATE *** String[] (of Full-Path / Complete File-Names) 1848 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1849 1850 /** Requests: String[] */ 1851 public static RTC<String[]> SORTED_BY_DATE_FULLPATH_ARRAY() 1852 { 1853 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE); 1854 1855 return new RTC<>( 1856 ts::add, 1857 1858 () -> 1859 { 1860 String[] retArr = new String[ts.size()]; 1861 int i = 0; 1862 1863 for (FileNode fn : ts) retArr[i++] = fn.getFullPathName(); 1864 return retArr; 1865 } 1866 ); 1867 } 1868 1869 1870 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1871 // Soted *** BY-DATE *** Iterator<String> (of Full-Path / Complete File-Names) 1872 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1873 1874 /** Requests: Iterator<String> */ 1875 public static RTC<Iterator<String>> SORTED_BY_DATE_FULLPATH_ITERATOR() 1876 { 1877 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE); 1878 1879 return new RTC<>( 1880 ts::add, 1881 1882 () -> toFullPaths( 1883 ts, 1884 TreeSet<String>::new, 1885 (TreeSet<String> tsRet) -> tsRet::add 1886 ) 1887 .iterator() 1888 ); 1889 } 1890 1891 1892 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1893 // Soted *** BY-DATE *** ReadOnlyArrayList<String> (of Full-Path / Complete File-Names) 1894 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1895 1896 /** Requests: ReadOnlyArrayList<String> */ 1897 public static RTC<ReadOnlyArrayList<String>> SORTED_BY_DATE_FULLPATH_ROAL() 1898 { 1899 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE); 1900 1901 return new RTC<>( 1902 ts::add, 1903 1904 () -> toFullPaths( 1905 ts, 1906 ROArrayListBuilder<String>::new, 1907 (ROArrayListBuilder<String> roalb) -> roalb::add 1908 ) 1909 .build() 1910 ); 1911 } 1912 1913 1914 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1915 // Soted *** BY-DATE *** ReadOnlyTreeSet<String> (of Full-Path / Complete File-Names) 1916 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1917 1918 /** Requests: ReadOnlyTreeSet<String> */ 1919 public static RTC<ReadOnlyTreeSet<String>> SORTED_BY_DATE_FULLPATH_ROTS() 1920 { 1921 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE); 1922 1923 return new RTC<>( 1924 ts::add, 1925 1926 () -> toFullPaths( 1927 ts, 1928 ROTreeSetBuilder<String>::new, 1929 (ROTreeSetBuilder<String> rotsb) -> rotsb::add 1930 ) 1931 .build() 1932 ); 1933 } 1934 1935 1936 1937 // ******************************************************************************************** 1938 // ******************************************************************************************** 1939 // ******************************************************************************************** 1940 // private static final VarTypeBuilderWithSortAndApply<FileNode, String> vlbwsaa3 = 1941 // new VarTypeBuilderWithSortAndApply<> 1942 // (BY_FILE_SIZE, (FileNode fn) -> fn.name, String.class); 1943 // ******************************************************************************************** 1944 // ******************************************************************************************** 1945 // ******************************************************************************************** 1946 1947 1948 1949 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1950 // Soted *** BY-FILE-SIZE *** Vector<String> (of FileName's) 1951 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1952 1953 /** Requests: Vector<String> */ 1954 public static RTC<Vector<String>> SORTED_BY_SIZE_FILENAME_VECTOR() 1955 { 1956 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE); 1957 1958 return new RTC<>( 1959 ts::add, 1960 () -> toFileNames(ts, Vector<String>::new, (Vector<String> v) -> v::add) 1961 ); 1962 } 1963 1964 1965 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1966 // Soted *** BY-FILE-SIZE *** ArrayList<String> (of FileName's) 1967 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1968 1969 /** Requests: ArrayList<String> */ 1970 public static RTC<ArrayList<String>> SORTED_BY_SIZE_FILENAME_ARRAYLIST() 1971 { 1972 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE); 1973 1974 return new RTC<>( 1975 ts::add, 1976 () -> toFileNames(ts, ArrayList<String>::new, (ArrayList<String> al) -> al::add) 1977 ); 1978 } 1979 1980 1981 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1982 // Soted *** BY-FILE-SIZE *** TreeSet<String> (of FileName's) 1983 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1984 1985 /** Requests: TreeSet<String> */ 1986 public static RTC<TreeSet<String>> SORTED_BY_SIZE_FILENAME_TREESET() 1987 { 1988 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE); 1989 1990 return new RTC<>( 1991 ts::add, 1992 () -> toFileNames(ts, TreeSet<String>::new, (TreeSet<String> tsRet) -> tsRet::add) 1993 ); 1994 } 1995 1996 1997 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 1998 // Soted *** BY-FILE-SIZE *** Stream<String> (of FileName's) 1999 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2000 2001 /** Requests: Stream<String> */ 2002 public static RTC<Stream<String>> SORTED_BY_SIZE_FILENAME_STREAM() 2003 { 2004 final Stream.Builder<FileNode> b = Stream.builder(); 2005 2006 return new RTC<>( 2007 b::accept, 2008 () -> b.build().sorted(BY_FILE_SIZE).map((FileNode fn) -> fn.name) 2009 ); 2010 } 2011 2012 2013 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2014 // Soted *** BY-FILE-SIZE *** String[] (of FileName's) 2015 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2016 2017 /** Requests: String[] */ 2018 public static RTC<String[]> SORTED_BY_SIZE_FILENAME_ARRAY() 2019 { 2020 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE); 2021 2022 return new RTC<>( 2023 ts::add, 2024 2025 () -> 2026 { 2027 String[] retArr = new String[ts.size()]; 2028 int i = 0; 2029 2030 for (FileNode fn : ts) retArr[i++] = fn.name; 2031 return retArr; 2032 } 2033 ); 2034 } 2035 2036 2037 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2038 // Soted *** BY-FILE-SIZE *** Iterator<String> (of FileName's) 2039 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2040 2041 /** Requests: Iterator<String> */ 2042 public static RTC<Iterator<String>> SORTED_BY_SIZE_FILENAME_ITERATOR() 2043 { 2044 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE); 2045 2046 return new RTC<>( 2047 ts::add, 2048 2049 () -> toFileNames( 2050 ts, 2051 TreeSet<String>::new, 2052 (TreeSet<String> tsRet) -> tsRet::add 2053 ) 2054 .iterator() 2055 ); 2056 } 2057 2058 2059 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2060 // Soted *** BY-FILE-SIZE *** ReadOnlyArrayList<String> (of FileName's) 2061 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2062 2063 /** Requests: ReadOnlyArrayList<String> */ 2064 public static RTC<ReadOnlyArrayList<String>> SORTED_BY_SIZE_FILENAME_ROAL() 2065 { 2066 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE); 2067 2068 return new RTC<>( 2069 ts::add, 2070 2071 () -> toFileNames( 2072 ts, 2073 ROArrayListBuilder<String>::new, 2074 (ROArrayListBuilder<String> roalb) -> roalb::add 2075 ) 2076 .build() 2077 ); 2078 } 2079 2080 2081 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2082 // Soted *** BY-FILE-SIZE *** ReadOnlyTreeSet<String> (of FileName's) 2083 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2084 2085 /** Requests: ReadOnlyTreeSet<String> */ 2086 public static RTC<ReadOnlyTreeSet<String>> SORTED_BY_SIZE_FILENAME_ROTS() 2087 { 2088 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE); 2089 2090 return new RTC<>( 2091 ts::add, 2092 2093 () -> toFileNames( 2094 ts, 2095 ROTreeSetBuilder<String>::new, 2096 (ROTreeSetBuilder<String> rotsb) -> rotsb::add 2097 ) 2098 .build() 2099 ); 2100 } 2101 2102 2103 2104 // ******************************************************************************************** 2105 // ******************************************************************************************** 2106 // ******************************************************************************************** 2107 // private static final VarTypeBuilderWithSortAndApply<FileNode, String> vlbwsaa4 = 2108 // new VarTypeBuilderWithSortAndApply<> 2109 // (BY_FILE_SIZE, (FileNode fn) -> fn.getFullPathName(), String.class); 2110 // ******************************************************************************************** 2111 // ******************************************************************************************** 2112 // ******************************************************************************************** 2113 2114 2115 2116 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2117 // Soted *** BY-FILE-SIZE *** Vector<String> (of Full-Path / Complete File-Names) 2118 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2119 2120 /** Requests: Vector<String> */ 2121 public static RTC<Vector<String>> SORTED_BY_SIZE_FULLPATH_VECTOR() 2122 { 2123 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE); 2124 2125 return new RTC<>( 2126 ts::add, 2127 () -> toFullPaths(ts, Vector<String>::new, (Vector<String> v) -> v::add) 2128 ); 2129 } 2130 2131 2132 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2133 // Soted *** BY-FILE-SIZE *** ArrayList<String> (of Full-Path / Complete File-Names) 2134 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2135 2136 /** Requests: ArrayList<String> */ 2137 public static RTC<ArrayList<String>> SORTED_BY_SIZE_FULLPATH_ARRAYLIST() 2138 { 2139 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE); 2140 2141 return new RTC<>( 2142 ts::add, 2143 () -> toFullPaths(ts, ArrayList<String>::new, (ArrayList<String> al) -> al::add) 2144 ); 2145 } 2146 2147 2148 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2149 // Soted *** BY-FILE-SIZE *** TreeSet<String> (of Full-Path / Complete File-Names) 2150 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2151 2152 /** Requests: TreeSet<String> */ 2153 public static RTC<TreeSet<String>> SORTED_BY_SIZE_FULLPATH_TREESET() 2154 { 2155 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE); 2156 2157 return new RTC<>( 2158 ts::add, 2159 () -> toFullPaths(ts, TreeSet<String>::new, (TreeSet<String> tsRet) -> tsRet::add) 2160 ); 2161 } 2162 2163 2164 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2165 // Soted *** BY-FILE-SIZE *** Stream<String> (of Full-Path / Complete File-Names) 2166 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2167 2168 /** Requests: Stream<String> */ 2169 public static RTC<Stream<String>> SORTED_BY_SIZE_FULLPATH_STREAM() 2170 { 2171 final Stream.Builder<FileNode> b = Stream.builder(); 2172 2173 return new RTC<>( 2174 b::accept, 2175 () -> b.build().sorted(BY_FILE_SIZE).map((FileNode fn) -> fn.getFullPathName()) 2176 ); 2177 } 2178 2179 2180 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2181 // Soted *** BY-FILE-SIZE *** String[] (of Full-Path / Complete File-Names) 2182 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2183 2184 /** Requests: String[] */ 2185 public static RTC<String[]> SORTED_BY_SIZE_FULLPATH_ARRAY() 2186 { 2187 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE); 2188 2189 return new RTC<>( 2190 ts::add, 2191 2192 () -> 2193 { 2194 String[] retArr = new String[ts.size()]; 2195 int i = 0; 2196 2197 for (FileNode fn : ts) retArr[i++] = fn.getFullPathName(); 2198 return retArr; 2199 } 2200 ); 2201 } 2202 2203 2204 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2205 // Soted *** BY-FILE-SIZE *** Iterator<String> (of Full-Path / Complete File-Names) 2206 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2207 2208 /** Requests: Iterator<String> */ 2209 public static RTC<Iterator<String>> SORTED_BY_SIZE_FULLPATH_ITERATOR() 2210 { 2211 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE); 2212 2213 return new RTC<>( 2214 ts::add, 2215 2216 () -> toFullPaths( 2217 ts, 2218 TreeSet<String>::new, 2219 (TreeSet<String> tsRet) -> tsRet::add 2220 ) 2221 .iterator() 2222 ); 2223 } 2224 2225 2226 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2227 // Soted *** BY-FILE-SIZE *** ReadOnlyArrayList<String> (of Full-Path / Complete File-Names) 2228 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2229 2230 /** Requests: ReadOnlyArrayList<String> */ 2231 public static RTC<ReadOnlyArrayList<String>> SORTED_BY_SIZE_FULLPATH_ROAL() 2232 { 2233 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE); 2234 2235 return new RTC<>( 2236 ts::add, 2237 2238 () -> toFullPaths( 2239 ts, 2240 ROArrayListBuilder<String>::new, 2241 (ROArrayListBuilder<String> roalb) -> roalb::add 2242 ) 2243 .build() 2244 ); 2245 } 2246 2247 2248 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2249 // Soted *** BY-FILE-SIZE *** ReadOnlyTreeSet<String> (of Full-Path / Complete File-Names) 2250 // *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 2251 2252 /** Requests: ReadOnlyTreeSet<String> */ 2253 public static RTC<ReadOnlyTreeSet<String>> SORTED_BY_SIZE_FULLPATH_ROTS() 2254 { 2255 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE); 2256 2257 return new RTC<>( 2258 ts::add, 2259 2260 () -> toFullPaths( 2261 ts, 2262 ROTreeSetBuilder<String>::new, 2263 (ROTreeSetBuilder<String> rotsb) -> rotsb::add 2264 ) 2265 .build() 2266 ); 2267 } 2268}