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