java.lang.Object
- Torello.Java.VarType<SOME_DATA_STRUCTURE,FileNode>
- - Torello.Java.RTC<SOME_DATA_STRUCTURE>

Type Parameters:

SOME_DATA_STRUCTURE - This is the type that that will be returned by the the FileNode method that has been invoked, using an RTC instance.
```
public class RTC<SOME_DATA_STRUCTURE>
extends VarType<SOME_DATA_STRUCTURE,FileNode>
```
This class actually extends the parent-type class VarType. For that class, there is a Generic Type-Parameter named 'INSERT_TYPE'. When class VarType is used for to help a user specify what data-structure should be returned from any of the relevant FileNode methods, that Type-Parameter 'INSERT_TYPE' will always be 'FileNode'.

This class extends VarType, and specifies that, in all cases, the Generic Type-Parameter 'INSERT_TYPE' should be set to 'FileNode'.

Where to Use:
This class provides myriad combinations for returning data from any of the FileNode 'flatten' methods, or the 'getDirContents' methods.

See Also:

FileNode
Hi-Lited Source-Code:
- View Here: Torello/Java/RTC.java
- Open New Browser-Tab: Torello/Java/RTC.java
File Size: 93,678 Bytes Line Count: 2,538 '\n' Characters Found

Field Summary

Fields
Modifier and Type	Field
`protected static Comparator<FileNode>`	`BY_DATE`
`protected static Comparator<FileNode>`	`BY_FILE_SIZE`
`protected static Comparator<FileNode>`	`BY_FILENAME`
`protected static Comparator<FileNode>`	`BY_FULLPATH`

Fields inherited from class Torello.Java.VarType
finisher, inserter, isReusable

Constructor Summary

Constructors
Constructor

RTC(Consumer<FileNode> inserter, Supplier<SOME_DATA_STRUCTURE> finisher, boolean isReusable)

Method Summary

FileNode Instances

Modifier and Type	Method
`static RTC<FileNode[]>`	`ARRAY()`
`static RTC<ArrayList<FileNode>>`	`ARRAYLIST()`
`static RTC<HashSet<FileNode>>`	`HASHSET()`
`static RTC<Iterator<FileNode>>`	`ITERATOR()`
`static RTC<ReadOnlyArrayList<FileNode>>`	`ROAL()`
`static RTC<ReadOnlyHashSet<FileNode>>`	`ROHS()`
`static RTC<Stream<FileNode>>`	`STREAM()`
`static RTC<Vector<FileNode>>`	`VECTOR()`

FileNode Instances, sorted by File-Name
Modifier and Type	Method
`static RTC<FileNode[]>`	`SORTED_BY_FILENAME_ARRAY()`
`static RTC<ArrayList<FileNode>>`	`SORTED_BY_FILENAME_ARRAYLIST()`
`static RTC<Iterator<FileNode>>`	`SORTED_BY_FILENAME_ITERATOR()`
`static RTC<ReadOnlyArrayList<FileNode>>`	`SORTED_BY_FILENAME_ROAL()`
`static RTC<ReadOnlyTreeSet<FileNode>>`	`SORTED_BY_FILENAME_ROTS()`
`static RTC<Stream<FileNode>>`	`SORTED_BY_FILENAME_STREAM()`
`static RTC<TreeSet<FileNode>>`	`SORTED_BY_FILENAME_TREESET()`
`static RTC<Vector<FileNode>>`	`SORTED_BY_FILENAME_VECTOR()`

FileNode Instances, sorted by Full-Path File-Name
Modifier and Type	Method
`static RTC<FileNode[]>`	`SORTED_BY_FULLPATH_ARRAY()`
`static RTC<ArrayList<FileNode>>`	`SORTED_BY_FULLPATH_ARRAYLIST()`
`static RTC<Iterator<FileNode>>`	`SORTED_BY_FULLPATH_ITERATOR()`
`static RTC<ReadOnlyArrayList<FileNode>>`	`SORTED_BY_FULLPATH_ROAL()`
`static RTC<ReadOnlyTreeSet<FileNode>>`	`SORTED_BY_FULLPATH_ROTS()`
`static RTC<Stream<FileNode>>`	`SORTED_BY_FULLPATH_STREAM()`
`static RTC<TreeSet<FileNode>>`	`SORTED_BY_FULLPATH_TREESET()`
`static RTC<Vector<FileNode>>`	`SORTED_BY_FULLPATH_VECTOR()`

FileNode Instances, sorted by On-Disk File-Size
Modifier and Type	Method
`static RTC<FileNode[]>`	`SORTED_BY_SIZE_ARRAY()`
`static RTC<ArrayList<FileNode>>`	`SORTED_BY_SIZE_ARRAYLIST()`
`static RTC<Iterator<FileNode>>`	`SORTED_BY_SIZE_ITERATOR()`
`static RTC<ReadOnlyArrayList<FileNode>>`	`SORTED_BY_SIZE_ROAL()`
`static RTC<ReadOnlyTreeSet<FileNode>>`	`SORTED_BY_SIZE_ROTS()`
`static RTC<Stream<FileNode>>`	`SORTED_BY_SIZE_STREAM()`
`static RTC<TreeSet<FileNode>>`	`SORTED_BY_SIZE_TREESET()`
`static RTC<Vector<FileNode>>`	`SORTED_BY_SIZE_VECTOR()`

FileNode Instances, sorted by Date
Modifier and Type	Method
`static RTC<FileNode[]>`	`SORTED_BY_DATE_ARRAY()`
`static RTC<ArrayList<FileNode>>`	`SORTED_BY_DATE_ARRAYLIST()`
`static RTC<Iterator<FileNode>>`	`SORTED_BY_DATE_ITERATOR()`
`static RTC<ReadOnlyArrayList<FileNode>>`	`SORTED_BY_DATE_ROAL()`
`static RTC<ReadOnlyTreeSet<FileNode>>`	`SORTED_BY_DATE_ROTS()`
`static RTC<Stream<FileNode>>`	`SORTED_BY_DATE_STREAM()`
`static RTC<TreeSet<FileNode>>`	`SORTED_BY_DATE_TREESET()`
`static RTC<Vector<FileNode>>`	`SORTED_BY_DATE_VECTOR()`

File-Name as String
Modifier and Type	Method
`static RTC<String[]>`	`FILENAME_ARRAY()`
`static RTC<ArrayList<String>>`	`FILENAME_ARRAYLIST()`
`static RTC<HashSet<String>>`	`FILENAME_HASHSET()`
`static RTC<Iterator<String>>`	`FILENAME_ITERATOR()`
`static RTC<ReadOnlyArrayList<String>>`	`FILENAME_ROAL()`
`static RTC<ReadOnlyHashSet<String>>`	`FILENAME_ROHS()`
`static RTC<Stream<String>>`	`FILENAME_STREAM()`
`static RTC<Vector<String>>`	`FILENAME_VECTOR()`

File-Name as String, sorted
Modifier and Type	Method
`static RTC<String[]>`	`SORTED_FILENAME_ARRAY()`
`static RTC<ArrayList<String>>`	`SORTED_FILENAME_ARRAYLIST()`
`static RTC<Iterator<String>>`	`SORTED_FILENAME_ITERATOR()`
`static RTC<ReadOnlyArrayList<String>>`	`SORTED_FILENAME_ROAL()`
`static RTC<ReadOnlyTreeSet<String>>`	`SORTED_FILENAME_ROTS()`
`static RTC<Stream<String>>`	`SORTED_FILENAME_STREAM()`
`static RTC<TreeSet<String>>`	`SORTED_FILENAME_TREESET()`
`static RTC<Vector<String>>`	`SORTED_FILENAME_VECTOR()`

File-Name as String, sorted by On-Disk File-Size
Modifier and Type	Method
`static RTC<String[]>`	`SORTED_BY_SIZE_FILENAME_ARRAY()`
`static RTC<ArrayList<String>>`	`SORTED_BY_SIZE_FILENAME_ARRAYLIST()`
`static RTC<Iterator<String>>`	`SORTED_BY_SIZE_FILENAME_ITERATOR()`
`static RTC<ReadOnlyArrayList<String>>`	`SORTED_BY_SIZE_FILENAME_ROAL()`
`static RTC<ReadOnlyTreeSet<String>>`	`SORTED_BY_SIZE_FILENAME_ROTS()`
`static RTC<Stream<String>>`	`SORTED_BY_SIZE_FILENAME_STREAM()`
`static RTC<TreeSet<String>>`	`SORTED_BY_SIZE_FILENAME_TREESET()`
`static RTC<Vector<String>>`	`SORTED_BY_SIZE_FILENAME_VECTOR()`

File-Name as String, sorted by Date
Modifier and Type	Method
`static RTC<String[]>`	`SORTED_BY_DATE_FILENAME_ARRAY()`
`static RTC<ArrayList<String>>`	`SORTED_BY_DATE_FILENAME_ARRAYLIST()`
`static RTC<Iterator<String>>`	`SORTED_BY_DATE_FILENAME_ITERATOR()`
`static RTC<ReadOnlyArrayList<String>>`	`SORTED_BY_DATE_FILENAME_ROAL()`
`static RTC<ReadOnlyTreeSet<String>>`	`SORTED_BY_DATE_FILENAME_ROTS()`
`static RTC<Stream<String>>`	`SORTED_BY_DATE_FILENAME_STREAM()`
`static RTC<TreeSet<String>>`	`SORTED_BY_DATE_FILENAME_TREESET()`
`static RTC<Vector<String>>`	`SORTED_BY_DATE_FILENAME_VECTOR()`

Full-Path File-Name as String
Modifier and Type	Method
`static RTC<String[]>`	`FULLPATH_ARRAY()`
`static RTC<ArrayList<String>>`	`FULLPATH_ARRAYLIST()`
`static RTC<HashSet<String>>`	`FULLPATH_HASHSET()`
`static RTC<Iterator<String>>`	`FULLPATH_ITERATOR()`
`static RTC<ReadOnlyArrayList<String>>`	`FULLPATH_ROAL()`
`static RTC<ReadOnlyHashSet<String>>`	`FULLPATH_ROHS()`
`static RTC<Stream<String>>`	`FULLPATH_STREAM()`
`static RTC<Vector<String>>`	`FULLPATH_VECTOR()`

Full-Path File-Name as String, sorted
Modifier and Type	Method
`static RTC<String[]>`	`SORTED_FULLPATH_ARRAY()`
`static RTC<ArrayList<String>>`	`SORTED_FULLPATH_ARRAYLIST()`
`static RTC<Iterator<String>>`	`SORTED_FULLPATH_ITERATOR()`
`static RTC<ReadOnlyArrayList<String>>`	`SORTED_FULLPATH_ROAL()`
`static RTC<ReadOnlyTreeSet<String>>`	`SORTED_FULLPATH_ROTS()`
`static RTC<Stream<String>>`	`SORTED_FULLPATH_STREAM()`
`static RTC<TreeSet<String>>`	`SORTED_FULLPATH_TREESET()`
`static RTC<Vector<String>>`	`SORTED_FULLPATH_VECTOR()`

Full-Path File-Name as String, sorted by On-Disk File-Size
Modifier and Type	Method
`static RTC<String[]>`	`SORTED_BY_SIZE_FULLPATH_ARRAY()`
`static RTC<ArrayList<String>>`	`SORTED_BY_SIZE_FULLPATH_ARRAYLIST()`
`static RTC<Iterator<String>>`	`SORTED_BY_SIZE_FULLPATH_ITERATOR()`
`static RTC<ReadOnlyArrayList<String>>`	`SORTED_BY_SIZE_FULLPATH_ROAL()`
`static RTC<ReadOnlyTreeSet<String>>`	`SORTED_BY_SIZE_FULLPATH_ROTS()`
`static RTC<Stream<String>>`	`SORTED_BY_SIZE_FULLPATH_STREAM()`
`static RTC<TreeSet<String>>`	`SORTED_BY_SIZE_FULLPATH_TREESET()`
`static RTC<Vector<String>>`	`SORTED_BY_SIZE_FULLPATH_VECTOR()`

Full-Path File-Name as String, sorted by Date
Modifier and Type	Method
`static RTC<String[]>`	`SORTED_BY_DATE_FULLPATH_ARRAY()`
`static RTC<ArrayList<String>>`	`SORTED_BY_DATE_FULLPATH_ARRAYLIST()`
`static RTC<Iterator<String>>`	`SORTED_BY_DATE_FULLPATH_ITERATOR()`
`static RTC<ReadOnlyArrayList<String>>`	`SORTED_BY_DATE_FULLPATH_ROAL()`
`static RTC<ReadOnlyTreeSet<String>>`	`SORTED_BY_DATE_FULLPATH_ROTS()`
`static RTC<Stream<String>>`	`SORTED_BY_DATE_FULLPATH_STREAM()`
`static RTC<TreeSet<String>>`	`SORTED_BY_DATE_FULLPATH_TREESET()`
`static RTC<Vector<String>>`	`SORTED_BY_DATE_FULLPATH_VECTOR()`

Put Into Pre-Existing Data-Structure: FileNode Instances,
Modifier and Type	Method
`static RTC<ArrayList<FileNode>>`	`ARRAYLIST (ArrayList<FileNode> al)`
`static RTC<HashSet<FileNode>>`	`HASHSET (HashSet<FileNode> hs)`
`static RTC<ROArrayListBuilder<FileNode>>`	`ROAL_BUILDER (ROArrayListBuilder<FileNode> roalb)`
`static RTC<ROHashSetBuilder<FileNode>>`	`ROHS_BUILDER (ROHashSetBuilder<FileNode> rohsb)`
`static RTC<Stream.Builder<FileNode>>`	`STREAM_BUILDER (Stream.Builder<FileNode> b)`
`static RTC<Vector<FileNode>>`	`VECTOR (Vector<FileNode> v)`

Put Into Pre-Existing Data-Structure: FileNode Instances, sorted by File-Name
Modifier and Type	Method
`static RTC<ArrayList<FileNode>>`	`SORTED_BY_FILENAME_ARRAYLIST (ArrayList<FileNode> al)`
`static RTC<ROArrayListBuilder<FileNode>>`	`SORTED_BY_FILENAME_ROAL_BUILDER (ROArrayListBuilder<FileNode> roalb)`
`static RTC<ROTreeSetBuilder<FileNode>>`	`SORTED_BY_FILENAME_ROTS_BUILDER (ROTreeSetBuilder<FileNode> rotsb)`
`static RTC<TreeSet<FileNode>>`	`SORTED_BY_FILENAME_TREESET (TreeSet<FileNode> ts)`
`static RTC<Vector<FileNode>>`	`SORTED_BY_FILENAME_VECTOR (Vector<FileNode> v)`

Put Into Pre-Existing Data-Structure: FileNode Instances, sorted by Full-Path File-Name
Modifier and Type	Method
`static RTC<ArrayList<FileNode>>`	`SORTED_BY_FULLPATH_ARRAYLIST (ArrayList<FileNode> al)`
`static RTC<ROArrayListBuilder<FileNode>>`	`SORTED_BY_FULLPATH_ROAL_BUILDER (ROArrayListBuilder<FileNode> roalb)`
`static RTC<ROTreeSetBuilder<FileNode>>`	`SORTED_BY_FULLPATH_ROTS_BUILDER (ROTreeSetBuilder<FileNode> rotsb)`
`static RTC<TreeSet<FileNode>>`	`SORTED_BY_FULLPATH_TREESET (TreeSet<FileNode> ts)`
`static RTC<Vector<FileNode>>`	`SORTED_BY_FULLPATH_VECTOR (Vector<FileNode> v)`

Put Into Pre-Existing Data-Structure: FileNode Instances, sorted by On-Disk File-Size
Modifier and Type	Method
`static RTC<ArrayList<FileNode>>`	`SORTED_BY_SIZE_ARRAYLIST (ArrayList<FileNode> al)`
`static RTC<ROArrayListBuilder<FileNode>>`	`SORTED_BY_SIZE_ROAL_BUILDER (ROArrayListBuilder<FileNode> roalb)`
`static RTC<ROTreeSetBuilder<FileNode>>`	`SORTED_BY_SIZE_ROTS_BUILDER (ROTreeSetBuilder<FileNode> rotsb)`
`static RTC<TreeSet<FileNode>>`	`SORTED_BY_SIZE_TREESET (TreeSet<FileNode> ts)`
`static RTC<Vector<FileNode>>`	`SORTED_BY_SIZE_VECTOR (Vector<FileNode> v)`

Put Into Pre-Existing Data-Structure: FileNode Instances, sorted by Date
Modifier and Type	Method
`static RTC<ArrayList<FileNode>>`	`SORTED_BY_DATE_ARRAYLIST (ArrayList<FileNode> al)`
`static RTC<ROArrayListBuilder<FileNode>>`	`SORTED_BY_DATE_ROAL_BUILDER (ROArrayListBuilder<FileNode> roalb)`
`static RTC<ROTreeSetBuilder<FileNode>>`	`SORTED_BY_DATE_ROTS_BUILDER (ROTreeSetBuilder<FileNode> rotsb)`
`static RTC<TreeSet<FileNode>>`	`SORTED_BY_DATE_TREESET (TreeSet<FileNode> ts)`
`static RTC<Vector<FileNode>>`	`SORTED_BY_DATE_VECTOR (Vector<FileNode> v)`

Put Into Pre-Existing Data-Structure: File-Name as String
Modifier and Type	Method
`static RTC<ArrayList<String>>`	`FILENAME_ARRAYLIST (ArrayList<String> al)`
`static RTC<HashSet<String>>`	`FILENAME_HASHSET (HashSet<String> hs)`
`static RTC<ROArrayListBuilder<String>>`	`FILENAME_ROAL_BUILDER (ROArrayListBuilder<String> roalb)`
`static RTC<ROHashSetBuilder<String>>`	`FILENAME_ROHS_BUILDER (ROHashSetBuilder<String> rohsb)`
`static RTC<Stream.Builder<String>>`	`FILENAME_STREAM_BUILDER (Stream.Builder<String> b)`
`static RTC<Vector<String>>`	`FILENAME_VECTOR (Vector<String> v)`

Put Into Pre-Existing Data-Structure: File-Name as String, sorted
Modifier and Type	Method
`static RTC<ArrayList<String>>`	`SORTED_FILENAME_ARRAYLIST (ArrayList<String> al)`
`static RTC<ROArrayListBuilder<String>>`	`SORTED_FILENAME_ROAL_BUILDER (ROArrayListBuilder<String> roalb)`
`static RTC<ROTreeSetBuilder<String>>`	`SORTED_FILENAME_ROTS_BUILDER (ROTreeSetBuilder<String> rotsb)`
`static RTC<TreeSet<String>>`	`SORTED_FILENAME_TREESET (TreeSet<String> ts)`
`static RTC<Vector<String>>`	`SORTED_FILENAME_VECTOR (Vector<String> v)`

Put Into Pre-Existing Data-Structure: Full-Path File-Name as String
Modifier and Type	Method
`static RTC<ArrayList<String>>`	`FULLPATH_ARRAYLIST (ArrayList<String> al)`
`static RTC<HashSet<String>>`	`FULLPATH_HASHSET (HashSet<String> hs)`
`static RTC<ROArrayListBuilder<String>>`	`FULLPATH_ROAL_BUILDER (ROArrayListBuilder<String> roalb)`
`static RTC<ROHashSetBuilder<String>>`	`FULLPATH_ROHS_BUILDER (ROHashSetBuilder<String> rohsb)`
`static RTC<Stream.Builder<String>>`	`FULLPATH_STREAM_BUILDER (Stream.Builder<String> b)`
`static RTC<Vector<String>>`	`FULLPATH_VECTOR (Vector<String> v)`

Put Into Pre-Existing Data-Structure: Full-Path File-Name as String, sorted
Modifier and Type	Method
`static RTC<ArrayList<String>>`	`SORTED_FULLPATH_ARRAYLIST (ArrayList<String> al)`
`static RTC<ROArrayListBuilder<String>>`	`SORTED_FULLPATH_ROAL_BUILDER (ROArrayListBuilder<String> roalb)`
`static RTC<ROTreeSetBuilder<String>>`	`SORTED_FULLPATH_ROTS_BUILDER (ROTreeSetBuilder<String> rotsb)`
`static RTC<TreeSet<String>>`	`SORTED_FULLPATH_TREESET (TreeSet<String> ts)`
`static RTC<Vector<String>>`	`SORTED_FULLPATH_VECTOR (Vector<String> v)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

BY_DATE

🡇 ⇈ ⮫ 🗕 🗗 🗖

protected static final java.util.Comparator<FileNode> BY_DATE

Comparator for sorting instances of FileNode by their lastModified field.

Code:

Exact Field Declaration Expression:

 protected static final Comparator<FileNode> BY_DATE =
         Comparator.comparingLong((FileNode fn) -> fn.lastModified);

BY_FILE_SIZE

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

protected static final java.util.Comparator<FileNode> BY_FILE_SIZE

Comparator for sorting instances of FileNode by their fileSize field.

Code:

Exact Field Declaration Expression:

 protected static final Comparator<FileNode> BY_FILE_SIZE =
         Comparator.comparingLong((FileNode fn) -> fn.fileSize);

BY_FULLPATH

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

protected static final java.util.Comparator<FileNode> BY_FULLPATH

Comparator for sorting instances of FileNode by their "Complete" Full-Path Name.

Code:

Exact Field Declaration Expression:

 protected static final Comparator<FileNode> BY_FULLPATH =
         (FileNode fn1, FileNode fn2) -> fn1.getFullPathName().compareTo(fn2.getFullPathName());

BY_FILENAME

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

protected static final java.util.Comparator<FileNode> BY_FILENAME

Comparator for sorting instances of FileNode by their "Simple" File-Name.

Code:

Exact Field Declaration Expression:

 protected static final Comparator<FileNode> BY_FILENAME =
         (FileNode fn1, FileNode fn2) -> fn1.name.compareTo(fn2.name);

Constructor Detail
- RTC
  
  🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
```
public RTC(java.util.function.Consumer<FileNode> inserter,
           java.util.function.Supplier<SOME_DATA_STRUCTURE> finisher,
           boolean isReusable)
```
  Constructs an instance of this class. If there is some combination of sorter or file meta-information transformation that is not actually included on this list, this constructor can be used to build an 'RTC' of your own devices.
  
  Parameters:
  
  inserter - This java.util.Consumer is used to accept and insert FileNode matches into whatever data-structure is being utilized.
  
  finisher - This java.util.Supplier will be invoked, just once, at the end of the insertion process to do any additional sorting, building or transformation that need to be done before returning the finalized data-structure.

Method Detail

VECTOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
```
public static RTC<java.util.Vector<FileNode>> VECTOR()
```
Reqesting Container-Type: java.util.Vector

Container Contents-Type: FileNode instance

Container Construction: Constructs new Data-Container Instance
Code:
Exact Method Body:

final Vector<FileNode> v = new Vector<>(); return new RTC<>(v::add, () -> v, false);

VECTOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Vector<FileNode>> VECTOR
            (java.util.Vector<FileNode> v)

Reqesting Container-Type:	`java.util.Vector`
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(v, NULL_MSG_v);
 return new RTC<>(v::add, () -> v, true);

ARRAYLIST

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
```
public static RTC<java.util.ArrayList<FileNode>> ARRAYLIST()
```
Reqesting Container-Type: java.util.ArrayList

Container Contents-Type: FileNode instance

Container Construction: Constructs new Data-Container Instance
Code:
Exact Method Body:

final ArrayList<FileNode> al = new ArrayList<>(); return new RTC<>(al::add, () -> al, false);

ARRAYLIST

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.ArrayList<FileNode>> ARRAYLIST
            (java.util.ArrayList<FileNode> al)

Reqesting Container-Type:	`java.util.ArrayList`
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(al, NULL_MSG_al);
 return new RTC<>(al::add, () -> al, true);

HASHSET

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
```
public static RTC<java.util.HashSet<FileNode>> HASHSET()
```
Reqesting Container-Type: java.util.HashSet

Container Contents-Type: FileNode instance

Container Construction: Constructs new Data-Container Instance
Code:
Exact Method Body:

final HashSet<FileNode> hs = new HashSet<>(); return new RTC<>(hs::add, () -> hs, false);

HASHSET

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.HashSet<FileNode>> HASHSET
            (java.util.HashSet<FileNode> hs)

Reqesting Container-Type:	`java.util.HashSet`
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(hs, NULL_MSG_hs);
 return new RTC<>(hs::add, () -> hs, true);

STREAM

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
```
public static RTC<java.util.stream.Stream<FileNode>> STREAM()
```
Reqesting Container-Type: java.util.stream.Stream

Container Contents-Type: FileNode instance

Container Construction: Constructs new Data-Container Instance
Code:
Exact Method Body:

final Stream.Builder<FileNode> b = Stream.builder(); return new RTC<>(b::accept, b::build, false);

STREAM_BUILDER

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.stream.Stream.Builder<FileNode>> STREAM_BUILDER
            (java.util.stream.Stream.Builder<FileNode> b)

Reqesting Container-Type:	`java.util.stream.Stream`
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(b, NULL_MSG_b);
 return new RTC<>(b::accept, () -> b, true);

ARRAY

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<FileNode[]> ARRAY()

Reqesting Container-Type:	`Java-Array`
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final Stream.Builder<FileNode> b = Stream.builder();

 return new RTC<>(
     b::accept,
     () -> b.build().toArray(FileNode[]::new),
     false
 );

ITERATOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
```
public static RTC<java.util.Iterator<FileNode>> ITERATOR()
```
Reqesting Container-Type: java.util.Iterator

Container Contents-Type: FileNode instance

Container Construction: Constructs new Data-Container Instance
Code:
Exact Method Body:

final ArrayList<FileNode> al = new ArrayList<>(); return new RTC<>(al::add, al::iterator, false);

ROAL

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
```
public static RTC<ReadOnlyArrayList<FileNode>> ROAL()
```
Reqesting Container-Type: Torello.Java.ReadOnly.ReadOnlyArrayList

Container Contents-Type: FileNode instance

Container Construction: Constructs new Data-Container Instance
Code:
Exact Method Body:

final ROArrayListBuilder<FileNode> roalb = new ROArrayListBuilder<>(); return new RTC<>(roalb::add, roalb::build, false);

ROAL_BUILDER

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ROArrayListBuilder<FileNode>> ROAL_BUILDER
            (ROArrayListBuilder<FileNode> roalb)

Reqesting Container-Type:	`Torello.Java.ReadOnly.ROArrayListBuilder`
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(roalb, NULL_MSG_roalb);
 return new RTC<>(roalb::add, () -> roalb, true);

ROHS

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
```
public static RTC<ReadOnlyHashSet<FileNode>> ROHS()
```
Reqesting Container-Type: Torello.Java.ReadOnly.ReadOnlyHashSet

Container Contents-Type: FileNode instance

Container Construction: Constructs new Data-Container Instance
Code:
Exact Method Body:

final ROHashSetBuilder<FileNode> rohsb = new ROHashSetBuilder<>(); return new RTC<>(rohsb::add, rohsb::build, false);

ROHS_BUILDER

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
```
public static RTC<ROHashSetBuilder<FileNode>> ROHS_BUILDER
            (ROHashSetBuilder<FileNode> rohsb)
```
Reqesting Container-Type: Torello.Java.ReadOnly.ROHashSetBuilder

Container Contents-Type: FileNode instance

Container Construction: Accepts Data-Container as a Parameter
Code:
Exact Method Body:

Objects.requireNonNull(rohsb, NULL_MSG_rohsb); return new RTC<>(rohsb::add, () -> rohsb, true);

SORTED_BY_DATE_VECTOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Vector<FileNode>> SORTED_BY_DATE_VECTOR()

Reqesting Container-Type:	`java.util.Vector`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final Vector<FileNode> v = new Vector<>();

 return new RTC<>(
     v::add,
     () -> { v.sort(BY_DATE); return v; },
     false
 );

SORTED_BY_DATE_VECTOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Vector<FileNode>> SORTED_BY_DATE_VECTOR
            (java.util.Vector<FileNode> v)

Reqesting Container-Type:	`java.util.Vector`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(v, NULL_MSG_v);
 return new RTC<>(
     v::add,
     () -> { v.sort(BY_DATE); return v; },
     true
 );

SORTED_BY_DATE_ARRAYLIST

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.ArrayList<FileNode>> SORTED_BY_DATE_ARRAYLIST()

Reqesting Container-Type:	`java.util.ArrayList`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ArrayList<FileNode> al = new ArrayList<>();

 return new RTC<>(
     al::add,
     () -> { al.sort(BY_DATE); return al; },
     false
 );

SORTED_BY_DATE_ARRAYLIST

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.ArrayList<FileNode>> SORTED_BY_DATE_ARRAYLIST
            (java.util.ArrayList<FileNode> al)

Reqesting Container-Type:	`java.util.ArrayList`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(al, NULL_MSG_al);

 return new RTC<>(
     al::add,
     () -> { al.sort(BY_DATE); return al; },
     true
 );

SORTED_BY_DATE_TREESET

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.TreeSet<FileNode>> SORTED_BY_DATE_TREESET()

Reqesting Container-Type:	`java.util.TreeSet`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE);
 return new RTC<>(ts::add, () -> ts, false);

SORTED_BY_DATE_TREESET

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.TreeSet<FileNode>> SORTED_BY_DATE_TREESET
            (java.util.TreeSet<FileNode> ts)

Reqesting Container-Type:	`java.util.TreeSet`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(ts, NULL_MSG_ts);
 return new RTC<>(ts::add, () -> ts, true);

SORTED_BY_DATE_STREAM

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.stream.Stream<FileNode>> SORTED_BY_DATE_STREAM
            ()

Reqesting Container-Type:	`java.util.stream.Stream`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final Stream.Builder<FileNode> b = Stream.builder();

 return new RTC<>(
     b::accept,
     () -> b.build().sorted(BY_DATE),
     false
 );

SORTED_BY_DATE_ARRAY

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
```
public static RTC<FileNode[]> SORTED_BY_DATE_ARRAY()
```
Reqesting Container-Type: Java-Array

Sorting Container-Contents: Sorted by Date

Container Contents-Type: FileNode instance

Container Construction: Constructs new Data-Container Instance
Code:
Exact Method Body:

final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE); return new RTC<>( ts::add, () -> ts.toArray(ZERO_LEN_ARR_FN), false );

SORTED_BY_DATE_ITERATOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Iterator<FileNode>> SORTED_BY_DATE_ITERATOR()

Reqesting Container-Type:	`java.util.Iterator`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE);
 return new RTC<>(ts::add, ts::iterator, false);

SORTED_BY_DATE_ROAL

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyArrayList<FileNode>> SORTED_BY_DATE_ROAL()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyArrayList`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ROArrayListBuilder<FileNode> roalb = new ROArrayListBuilder<>();

 return new RTC<>(
     roalb::add,
     () -> { roalb.sort(BY_DATE); return roalb.build(); },
     false
 );

SORTED_BY_DATE_ROAL_BUILDER

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ROArrayListBuilder<FileNode>> SORTED_BY_DATE_ROAL_BUILDER
            (ROArrayListBuilder<FileNode> roalb)

Reqesting Container-Type:	`Torello.Java.ReadOnly.ROArrayListBuilder`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(roalb, NULL_MSG_roalb);

 return new RTC<>(
     roalb::add,
     () -> { roalb.sort(BY_DATE); return roalb; },
     true
 );

SORTED_BY_DATE_ROTS

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyTreeSet<FileNode>> SORTED_BY_DATE_ROTS()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyTreeSet`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ROTreeSetBuilder<FileNode> rotsb = new ROTreeSetBuilder<>();
 return new RTC<>(rotsb::add, rotsb::build, false);

SORTED_BY_DATE_ROTS_BUILDER

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ROTreeSetBuilder<FileNode>> SORTED_BY_DATE_ROTS_BUILDER
            (ROTreeSetBuilder<FileNode> rotsb)

Reqesting Container-Type:	`Torello.Java.ReadOnly.ROTreeSetBuilder`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(rotsb, NULL_MSG_rotsb);
 return new RTC<>(rotsb::add, () -> rotsb, true);

SORTED_BY_SIZE_VECTOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Vector<FileNode>> SORTED_BY_SIZE_VECTOR()

Reqesting Container-Type:	`java.util.Vector`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final Vector<FileNode> v = new Vector<>();

 return new RTC<>(
     v::add,
     () -> { v.sort(BY_FILE_SIZE); return v; },
     false
 );

SORTED_BY_SIZE_VECTOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Vector<FileNode>> SORTED_BY_SIZE_VECTOR
            (java.util.Vector<FileNode> v)

Reqesting Container-Type:	`java.util.Vector`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(v, NULL_MSG_v);

 return new RTC<>(
     v::add,
     () -> { v.sort(BY_FILE_SIZE); return v; },
     true
 );

SORTED_BY_SIZE_ARRAYLIST

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.ArrayList<FileNode>> SORTED_BY_SIZE_ARRAYLIST()

Reqesting Container-Type:	`java.util.ArrayList`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ArrayList<FileNode> al = new ArrayList<>();

 return new RTC<>(
     al::add,
     () -> { al.sort(BY_FILE_SIZE); return al; },
     false
 );

SORTED_BY_SIZE_ARRAYLIST

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.ArrayList<FileNode>> SORTED_BY_SIZE_ARRAYLIST
            (java.util.ArrayList<FileNode> al)

Reqesting Container-Type:	`java.util.ArrayList`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(al, NULL_MSG_al);

 return new RTC<>(
     al::add,
     () -> { al.sort(BY_FILE_SIZE); return al; },
     true
 );

SORTED_BY_SIZE_TREESET

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.TreeSet<FileNode>> SORTED_BY_SIZE_TREESET()

Reqesting Container-Type:	`java.util.TreeSet`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE);
 return new RTC<>(ts::add, () -> ts, false);

SORTED_BY_SIZE_TREESET

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.TreeSet<FileNode>> SORTED_BY_SIZE_TREESET
            (java.util.TreeSet<FileNode> ts)

Reqesting Container-Type:	`java.util.TreeSet`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(ts, NULL_MSG_ts);
 return new RTC<>(ts::add, () -> ts, true);

SORTED_BY_SIZE_STREAM

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.stream.Stream<FileNode>> SORTED_BY_SIZE_STREAM
            ()

Reqesting Container-Type:	`java.util.stream.Stream`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final Stream.Builder<FileNode> b = Stream.builder();

 return new RTC<>(
     b::accept,
     () -> b.build().sorted(BY_FILE_SIZE),
     false
 );

SORTED_BY_SIZE_ARRAY

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<FileNode[]> SORTED_BY_SIZE_ARRAY()

Reqesting Container-Type:	`Java-Array`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE);

 return new RTC<>(
     ts::add,
     () -> ts.toArray(ZERO_LEN_ARR_FN),
     false
 );

SORTED_BY_SIZE_ITERATOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Iterator<FileNode>> SORTED_BY_SIZE_ITERATOR()

Reqesting Container-Type:	`java.util.Iterator`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE);
 return new RTC<>(ts::add, ts::iterator, false);

SORTED_BY_SIZE_ROAL

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyArrayList<FileNode>> SORTED_BY_SIZE_ROAL()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyArrayList`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ROArrayListBuilder<FileNode> roalb = new ROArrayListBuilder<>();

 return new RTC<>(
     roalb::add,
     () -> { roalb.sort(BY_FILE_SIZE); return roalb.build(); },
     false
 );

SORTED_BY_SIZE_ROAL_BUILDER

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ROArrayListBuilder<FileNode>> SORTED_BY_SIZE_ROAL_BUILDER
            (ROArrayListBuilder<FileNode> roalb)

Reqesting Container-Type:	`Torello.Java.ReadOnly.ROArrayListBuilder`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(roalb, NULL_MSG_roalb);

 return new RTC<>(
     roalb::add,
     () -> { roalb.sort(BY_FILE_SIZE); return roalb; },
     true
 );

SORTED_BY_SIZE_ROTS

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyTreeSet<FileNode>> SORTED_BY_SIZE_ROTS()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyTreeSet`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ROTreeSetBuilder<FileNode> rotsb = new ROTreeSetBuilder<>(BY_FILE_SIZE);
 return new RTC<>(rotsb::add, rotsb::build, false);

SORTED_BY_SIZE_ROTS_BUILDER

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ROTreeSetBuilder<FileNode>> SORTED_BY_SIZE_ROTS_BUILDER
            (ROTreeSetBuilder<FileNode> rotsb)

Reqesting Container-Type:	`Torello.Java.ReadOnly.ROTreeSetBuilder`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(rotsb, NULL_MSG_rotsb);
 return new RTC<>(rotsb::add, () -> rotsb, true);

SORTED_BY_FULLPATH_VECTOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Vector<FileNode>> SORTED_BY_FULLPATH_VECTOR()

Reqesting Container-Type:	`java.util.Vector`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final Vector<FileNode> v = new Vector<>();

 return new RTC<>(
     v::add,
     () -> { v.sort(BY_FULLPATH); return v; },
     false
 );

SORTED_BY_FULLPATH_VECTOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Vector<FileNode>> SORTED_BY_FULLPATH_VECTOR
            (java.util.Vector<FileNode> v)

Reqesting Container-Type:	`java.util.Vector`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(v, NULL_MSG_v);

 return new RTC<>(
     v::add,
     () -> { v.sort(BY_FULLPATH); return v; },
     true
 );

SORTED_BY_FULLPATH_ARRAYLIST

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.ArrayList<FileNode>> SORTED_BY_FULLPATH_ARRAYLIST
            ()

Reqesting Container-Type:	`java.util.ArrayList`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ArrayList<FileNode> al = new ArrayList<>();

 return new RTC<>(
     al::add,
     () -> { al.sort(BY_FULLPATH); return al; },
     false
 );

SORTED_BY_FULLPATH_ARRAYLIST

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.ArrayList<FileNode>> SORTED_BY_FULLPATH_ARRAYLIST
            (java.util.ArrayList<FileNode> al)

Reqesting Container-Type:	`java.util.ArrayList`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(al, NULL_MSG_al);

 return new RTC<>(
     al::add,
     () -> { al.sort(BY_FULLPATH); return al; },
     true
 );

SORTED_BY_FULLPATH_TREESET

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.TreeSet<FileNode>> SORTED_BY_FULLPATH_TREESET()

Reqesting Container-Type:	`java.util.TreeSet`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FULLPATH);
 return new RTC<>(ts::add, () -> ts, false);

SORTED_BY_FULLPATH_TREESET

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.TreeSet<FileNode>> SORTED_BY_FULLPATH_TREESET
            (java.util.TreeSet<FileNode> ts)

Reqesting Container-Type:	`java.util.TreeSet`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(ts, NULL_MSG_ts);
 return new RTC<>(ts::add, () -> ts, true);

SORTED_BY_FULLPATH_STREAM

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.stream.Stream<FileNode>> SORTED_BY_FULLPATH_STREAM
            ()

Reqesting Container-Type:	`java.util.stream.Stream`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final Stream.Builder<FileNode> b = Stream.builder();

 return new RTC<>(
     b::accept,
     () -> b.build().sorted(BY_FULLPATH),
     false
 );

SORTED_BY_FULLPATH_ARRAY

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<FileNode[]> SORTED_BY_FULLPATH_ARRAY()

Reqesting Container-Type:	`Java-Array`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FULLPATH);

 return new RTC<>(
     ts::add,
     () -> ts.toArray(ZERO_LEN_ARR_FN),
     false
 );

SORTED_BY_FULLPATH_ITERATOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Iterator<FileNode>> SORTED_BY_FULLPATH_ITERATOR
            ()

Reqesting Container-Type:	`java.util.Iterator`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FULLPATH);
 return new RTC<>(ts::add, ts::iterator, false);

SORTED_BY_FULLPATH_ROAL

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyArrayList<FileNode>> SORTED_BY_FULLPATH_ROAL()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyArrayList`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ROArrayListBuilder<FileNode> roalb = new ROArrayListBuilder<>();

 return new RTC<>(
     roalb::add,
     () -> { roalb.sort(BY_FULLPATH); return roalb.build(); },
     false
 );

SORTED_BY_FULLPATH_ROAL_BUILDER

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ROArrayListBuilder<FileNode>> SORTED_BY_FULLPATH_ROAL_BUILDER
            (ROArrayListBuilder<FileNode> roalb)

Reqesting Container-Type:	`Torello.Java.ReadOnly.ROArrayListBuilder`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(roalb, NULL_MSG_roalb);

 return new RTC<>(
     roalb::add,
     () -> { roalb.sort(BY_FULLPATH); return roalb; },
     true
 );

SORTED_BY_FULLPATH_ROTS

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyTreeSet<FileNode>> SORTED_BY_FULLPATH_ROTS()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyTreeSet`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ROTreeSetBuilder<FileNode> rotsb = new ROTreeSetBuilder<>(BY_FULLPATH);
 return new RTC<>(rotsb::add, rotsb::build, false);

SORTED_BY_FULLPATH_ROTS_BUILDER

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ROTreeSetBuilder<FileNode>> SORTED_BY_FULLPATH_ROTS_BUILDER
            (ROTreeSetBuilder<FileNode> rotsb)

Reqesting Container-Type:	`Torello.Java.ReadOnly.ROTreeSetBuilder`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(rotsb, NULL_MSG_rotsb);
 return new RTC<>(rotsb::add, () -> rotsb, true);

SORTED_BY_FILENAME_VECTOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Vector<FileNode>> SORTED_BY_FILENAME_VECTOR()

Reqesting Container-Type:	`java.util.Vector`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final Vector<FileNode> v = new Vector<>();

 return new RTC<>(
     v::add, 
     () -> { v.sort(BY_FILENAME); return v; },
     false
 );

SORTED_BY_FILENAME_VECTOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Vector<FileNode>> SORTED_BY_FILENAME_VECTOR
            (java.util.Vector<FileNode> v)

Reqesting Container-Type:	`java.util.Vector`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(v, NULL_MSG_v);

 return new RTC<>(
     v::add,
     () -> { v.sort(BY_FILENAME); return v; },
     true
 );

SORTED_BY_FILENAME_ARRAYLIST

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.ArrayList<FileNode>> SORTED_BY_FILENAME_ARRAYLIST
            ()

Reqesting Container-Type:	`java.util.ArrayList`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ArrayList<FileNode> al = new ArrayList<>();

 return new RTC<>(
     al::add, 
     () -> { al.sort(BY_FILENAME); return al; },
     false
 );

SORTED_BY_FILENAME_ARRAYLIST

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.ArrayList<FileNode>> SORTED_BY_FILENAME_ARRAYLIST
            (java.util.ArrayList<FileNode> al)

Reqesting Container-Type:	`java.util.ArrayList`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(al, NULL_MSG_al);

 return new RTC<>(
     al::add,
     () -> { al.sort(BY_FILENAME); return al; },
     true
 );

SORTED_BY_FILENAME_TREESET

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.TreeSet<FileNode>> SORTED_BY_FILENAME_TREESET()

Reqesting Container-Type:	`java.util.TreeSet`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILENAME);
 return new RTC<>(ts::add, () -> ts, false);

SORTED_BY_FILENAME_TREESET

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.TreeSet<FileNode>> SORTED_BY_FILENAME_TREESET
            (java.util.TreeSet<FileNode> ts)

Reqesting Container-Type:	`java.util.TreeSet`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(ts, NULL_MSG_ts);
 return new RTC<>(ts::add, () -> ts, true);

SORTED_BY_FILENAME_STREAM

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.stream.Stream<FileNode>> SORTED_BY_FILENAME_STREAM
            ()

Reqesting Container-Type:	`java.util.stream.Stream`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final Stream.Builder<FileNode> b = Stream.builder();

 return new RTC<>(
     b::accept,
     () -> b.build().sorted(BY_FILENAME),
     false
 );

SORTED_BY_FILENAME_ARRAY

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<FileNode[]> SORTED_BY_FILENAME_ARRAY()

Reqesting Container-Type:	`Java-Array`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILENAME);

 return new RTC<>(
     ts::add,
     () -> ts.toArray(ZERO_LEN_ARR_FN),
     false
 );

SORTED_BY_FILENAME_ITERATOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Iterator<FileNode>> SORTED_BY_FILENAME_ITERATOR
            ()

Reqesting Container-Type:	`java.util.Iterator`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILENAME);
 return new RTC<>(ts::add, ts::iterator, false);

SORTED_BY_FILENAME_ROAL

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyArrayList<FileNode>> SORTED_BY_FILENAME_ROAL()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyArrayList`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ROArrayListBuilder<FileNode> roalb = new ROArrayListBuilder<>();

 return new RTC<>(
     roalb::add,
     () -> { roalb.sort(BY_FILENAME); return roalb.build(); },
     false
 );

SORTED_BY_FILENAME_ROAL_BUILDER

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ROArrayListBuilder<FileNode>> SORTED_BY_FILENAME_ROAL_BUILDER
            (ROArrayListBuilder<FileNode> roalb)

Reqesting Container-Type:	`Torello.Java.ReadOnly.ROArrayListBuilder`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(roalb, NULL_MSG_roalb);

 return new RTC<>(
     roalb::add,
     () -> { roalb.sort(BY_FILENAME); return roalb; },
     true
 );

SORTED_BY_FILENAME_ROTS

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyTreeSet<FileNode>> SORTED_BY_FILENAME_ROTS()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyTreeSet`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ROTreeSetBuilder<FileNode> rotsb = new ROTreeSetBuilder<>(BY_FILENAME);
 return new RTC<>(rotsb::add, rotsb::build, false);

SORTED_BY_FILENAME_ROTS_BUILDER

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ROTreeSetBuilder<FileNode>> SORTED_BY_FILENAME_ROTS_BUILDER
            (ROTreeSetBuilder<FileNode> rotsb)

Reqesting Container-Type:	`Torello.Java.ReadOnly.ROTreeSetBuilder`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	`FileNode` instance
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(rotsb, NULL_MSG_rotsb);
 return new RTC<>(rotsb::add, () -> rotsb, true);

FILENAME_VECTOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
```
public static RTC<java.util.Vector<java.lang.String>> FILENAME_VECTOR()
```
Reqesting Container-Type: java.util.Vector

Container Contents-Type: Simple File-Name, as a java.lang.String

Container Construction: Constructs new Data-Container Instance
Code:
Exact Method Body:

final Vector<String> v = new Vector<>(); return new RTC<>((FileNode fn) -> v.add(fn.name), () -> v, false);

FILENAME_VECTOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Vector<java.lang.String>> FILENAME_VECTOR
            (java.util.Vector<java.lang.String> v)

Reqesting Container-Type:	`java.util.Vector`
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(v, NULL_MSG_v);
 return new RTC<>((FileNode fn) -> v.add(fn.name), () -> v, true);

FILENAME_ARRAYLIST

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.ArrayList<java.lang.String>> FILENAME_ARRAYLIST
            ()

Reqesting Container-Type:	`java.util.ArrayList`
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ArrayList<String> al = new ArrayList<>();
 return new RTC<>((FileNode fn) -> al.add(fn.name), () -> al, false);

FILENAME_ARRAYLIST

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.ArrayList<java.lang.String>> FILENAME_ARRAYLIST
            (java.util.ArrayList<java.lang.String> al)

Reqesting Container-Type:	`java.util.ArrayList`
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(al, NULL_MSG_al);
 return new RTC<>((FileNode fn) -> al.add(fn.name), () -> al, true);

FILENAME_HASHSET

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
```
public static RTC<java.util.HashSet<java.lang.String>> FILENAME_HASHSET()
```
Reqesting Container-Type: java.util.HashSet

Container Contents-Type: Simple File-Name, as a java.lang.String

Container Construction: Constructs new Data-Container Instance
Code:
Exact Method Body:

final HashSet<String> hs = new HashSet<>(); return new RTC<>((FileNode fn) -> hs.add(fn.name), () -> hs, false);

FILENAME_HASHSET

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.HashSet<java.lang.String>> FILENAME_HASHSET
            (java.util.HashSet<java.lang.String> hs)

Reqesting Container-Type:	`java.util.HashSet`
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(hs, NULL_MSG_hs);
 return new RTC<>((FileNode fn) -> hs.add(fn.name), () -> hs, true);

FILENAME_STREAM

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.stream.Stream<java.lang.String>> FILENAME_STREAM
            ()

Reqesting Container-Type:	`java.util.stream.Stream`
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final Stream.Builder<String> b = Stream.builder();

 return new RTC<>(
     (FileNode fn) -> b.accept(fn.name),
     b::build,
     false
 );

FILENAME_STREAM_BUILDER

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.stream.Stream.Builder<java.lang.String>> FILENAME_STREAM_BUILDER
            (java.util.stream.Stream.Builder<java.lang.String> b)

Reqesting Container-Type:	`java.util.stream.Stream`
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(b, NULL_MSG_b);
 return new RTC<>((FileNode fn) -> b.accept(fn.name), () -> b, true);

FILENAME_ARRAY

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.lang.String[]> FILENAME_ARRAY()

Reqesting Container-Type:	`Java-Array`
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final Stream.Builder<String> b = Stream.builder();

 return new RTC<>(
     (FileNode fn)   -> b.accept(fn.name),
     ()              -> b.build().toArray(String[]::new),
     false
 );

FILENAME_ITERATOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Iterator<java.lang.String>> FILENAME_ITERATOR()

Reqesting Container-Type:	`java.util.Iterator`
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ArrayList<String> al = new ArrayList<>();

 return new RTC<>(
     (FileNode fn) -> al.add(fn.name),
     al::iterator,
     false
 );

FILENAME_ROAL

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyArrayList<java.lang.String>> FILENAME_ROAL()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyArrayList`
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ROArrayListBuilder<String> roalb = new ROArrayListBuilder<>();

 return new RTC<>(
     (FileNode fn) -> roalb.add(fn.name),
     roalb::build,
     false
 );

FILENAME_ROAL_BUILDER

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ROArrayListBuilder<java.lang.String>> FILENAME_ROAL_BUILDER
            (ROArrayListBuilder<java.lang.String> roalb)

Reqesting Container-Type:	`Torello.Java.ReadOnly.ROArrayListBuilder`
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(roalb, NULL_MSG_roalb);
 return new RTC<>((FileNode fn) -> roalb.add(fn.name), () -> roalb, true);

FILENAME_ROHS

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyHashSet<java.lang.String>> FILENAME_ROHS()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyHashSet`
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ROHashSetBuilder<String> rohsb = new ROHashSetBuilder<>();

 return new RTC<>(
     (FileNode fn) -> rohsb.add(fn.name),
     rohsb::build,
     false
 );

FILENAME_ROHS_BUILDER

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ROHashSetBuilder<java.lang.String>> FILENAME_ROHS_BUILDER
            (ROHashSetBuilder<java.lang.String> rohsb)

Reqesting Container-Type:	`Torello.Java.ReadOnly.ROHashSetBuilder`
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(rohsb, NULL_MSG_rohsb);
 return new RTC<>((FileNode fn) -> rohsb.add(fn.name), () -> rohsb, true);

FULLPATH_VECTOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
```
public static RTC<java.util.Vector<java.lang.String>> FULLPATH_VECTOR()
```
Reqesting Container-Type: java.util.Vector

Container Contents-Type: Full-Path Name, as a java.lang.String

Container Construction: Constructs new Data-Container Instance
Code:
Exact Method Body:

final Vector<String> v = new Vector<>(); return new RTC<>((FileNode fn) -> v.add(fn.getFullPathName()), () -> v, false);

FULLPATH_VECTOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Vector<java.lang.String>> FULLPATH_VECTOR
            (java.util.Vector<java.lang.String> v)

Reqesting Container-Type:	`java.util.Vector`
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(v, NULL_MSG_v);
 return new RTC<>((FileNode fn) -> v.add(fn.getFullPathName()), () -> v, true);

FULLPATH_ARRAYLIST

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.ArrayList<java.lang.String>> FULLPATH_ARRAYLIST
            ()

Reqesting Container-Type:	`java.util.ArrayList`
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ArrayList<String> al = new ArrayList<>();
 return new RTC<>((FileNode fn) -> al.add(fn.getFullPathName()), () -> al, false);

FULLPATH_ARRAYLIST

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.ArrayList<java.lang.String>> FULLPATH_ARRAYLIST
            (java.util.ArrayList<java.lang.String> al)

Reqesting Container-Type:	`java.util.ArrayList`
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(al, NULL_MSG_al);
 return new RTC<>((FileNode fn) -> al.add(fn.getFullPathName()), () -> al, true);

FULLPATH_HASHSET

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
```
public static RTC<java.util.HashSet<java.lang.String>> FULLPATH_HASHSET()
```
Reqesting Container-Type: java.util.HashSet

Container Contents-Type: Full-Path Name, as a java.lang.String

Container Construction: Constructs new Data-Container Instance
Code:
Exact Method Body:

final HashSet<String> hs = new HashSet<>(); return new RTC<>((FileNode fn) -> hs.add(fn.getFullPathName()), () -> hs, false);

FULLPATH_HASHSET

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.HashSet<java.lang.String>> FULLPATH_HASHSET
            (java.util.HashSet<java.lang.String> hs)

Reqesting Container-Type:	`java.util.HashSet`
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(hs, NULL_MSG_hs);
 return new RTC<>((FileNode fn) -> hs.add(fn.getFullPathName()), () -> hs, true);

FULLPATH_STREAM

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.stream.Stream<java.lang.String>> FULLPATH_STREAM
            ()

Reqesting Container-Type:	`java.util.stream.Stream`
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final Stream.Builder<String> b = Stream.builder();

 return new RTC<>(
     (FileNode fn) -> b.accept(fn.getFullPathName()),
     b::build,
     false
 );

FULLPATH_STREAM_BUILDER

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.stream.Stream.Builder<java.lang.String>> FULLPATH_STREAM_BUILDER
            (java.util.stream.Stream.Builder<java.lang.String> b)

Reqesting Container-Type:	`java.util.stream.Stream`
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(b, NULL_MSG_b);
 return new RTC<>((FileNode fn) -> b.accept(fn.getFullPathName()), () -> b, true);

FULLPATH_ARRAY

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.lang.String[]> FULLPATH_ARRAY()

Reqesting Container-Type:	`Java-Array`
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final Stream.Builder<String> b = Stream.builder();

 return new RTC<>(
     (FileNode fn)   -> b.accept(fn.getFullPathName()),
     ()              -> b.build().toArray(String[]::new),
     false
 );

FULLPATH_ITERATOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Iterator<java.lang.String>> FULLPATH_ITERATOR()

Reqesting Container-Type:	`java.util.Iterator`
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ArrayList<String> al = new ArrayList<>();

 return new RTC<>(
     (FileNode fn) -> al.add(fn.getFullPathName()),
     al::iterator,
     false
 );

FULLPATH_ROAL

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyArrayList<java.lang.String>> FULLPATH_ROAL()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyArrayList`
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ROArrayListBuilder<String> roalb = new ROArrayListBuilder<>();

 return new RTC<>(
     (FileNode fn) -> roalb.add(fn.getFullPathName()),
     roalb::build,
     false
 );

FULLPATH_ROAL_BUILDER

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ROArrayListBuilder<java.lang.String>> FULLPATH_ROAL_BUILDER
            (ROArrayListBuilder<java.lang.String> roalb)

Reqesting Container-Type:	`Torello.Java.ReadOnly.ROArrayListBuilder`
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(roalb, NULL_MSG_roalb);
 return new RTC<>((FileNode fn) -> roalb.add(fn.getFullPathName()), () -> roalb, true);

FULLPATH_ROHS

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyHashSet<java.lang.String>> FULLPATH_ROHS()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyHashSet`
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ROHashSetBuilder<String> rohsb = new ROHashSetBuilder<>();

 return new RTC<>(
     (FileNode fn) -> rohsb.add(fn.getFullPathName()),
     rohsb::build,
     false
 );

FULLPATH_ROHS_BUILDER

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ROHashSetBuilder<java.lang.String>> FULLPATH_ROHS_BUILDER
            (ROHashSetBuilder<java.lang.String> rohsb)

Reqesting Container-Type:	`Torello.Java.ReadOnly.ROHashSetBuilder`
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(rohsb, NULL_MSG_rohsb);
 return new RTC<>((FileNode fn) -> rohsb.add(fn.getFullPathName()), () -> rohsb, true);

SORTED_FILENAME_VECTOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Vector<java.lang.String>> SORTED_FILENAME_VECTOR
            ()

Reqesting Container-Type:	`java.util.Vector`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final Vector<String> v = new Vector<>();

 return new RTC<>(
     (FileNode fn)   -> v.add(fn.name),
     ()              -> { v.sort(String::compareTo); return v; },
     false
 );

SORTED_FILENAME_VECTOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Vector<java.lang.String>> SORTED_FILENAME_VECTOR
            (java.util.Vector<java.lang.String> v)

Reqesting Container-Type:	`java.util.Vector`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(v, NULL_MSG_v);

 return new RTC<>(
     (FileNode fn)   -> v.add(fn.name),
     ()              -> { v.sort(String::compareTo); return v; },
     true
 );

SORTED_FILENAME_ARRAYLIST

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.ArrayList<java.lang.String>> SORTED_FILENAME_ARRAYLIST
            ()

Reqesting Container-Type:	`java.util.ArrayList`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ArrayList<String> al = new ArrayList<>();

 return new RTC<>(
     (FileNode fn)   -> al.add(fn.name),
     ()              -> { al.sort(String::compareTo); return al; },
     false
 );

SORTED_FILENAME_ARRAYLIST

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.ArrayList<java.lang.String>> SORTED_FILENAME_ARRAYLIST
            (java.util.ArrayList<java.lang.String> al)

Reqesting Container-Type:	`java.util.ArrayList`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(al, NULL_MSG_al);

 return new RTC<>(
     (FileNode fn)   -> al.add(fn.name),
     ()              -> { al.sort(String::compareTo); return al; },
     true
 );

SORTED_FILENAME_TREESET

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.TreeSet<java.lang.String>> SORTED_FILENAME_TREESET
            ()

Reqesting Container-Type:	`java.util.TreeSet`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<String> ts = new TreeSet<>(String::compareTo);
 return new RTC<>((FileNode fn) -> ts.add(fn.name), () -> ts, false);

SORTED_FILENAME_TREESET

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.TreeSet<java.lang.String>> SORTED_FILENAME_TREESET
            (java.util.TreeSet<java.lang.String> ts)

Reqesting Container-Type:	`java.util.TreeSet`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(ts, NULL_MSG_ts);
 return new RTC<>((FileNode fn) -> ts.add(fn.name), () -> ts, true);

SORTED_FILENAME_STREAM

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.stream.Stream<java.lang.String>> SORTED_FILENAME_STREAM
            ()

Reqesting Container-Type:	`java.util.stream.Stream`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final Stream.Builder<String> b = Stream.builder();

 return new RTC<>(
     (FileNode fn)   -> b.accept(fn.name),
     ()              -> b.build().sorted(String::compareTo),
     false
 );

SORTED_FILENAME_ARRAY

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.lang.String[]> SORTED_FILENAME_ARRAY()

Reqesting Container-Type:	`Java-Array`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<String> ts = new TreeSet<>(String::compareTo);

 return new RTC<>(
     (FileNode fn)   -> ts.add(fn.name),
     ()              -> ts.toArray(ZERO_LEN_ARR_STR),
     false
 );

SORTED_FILENAME_ITERATOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Iterator<java.lang.String>> SORTED_FILENAME_ITERATOR
            ()

Reqesting Container-Type:	`java.util.Iterator`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<String> ts = new TreeSet<>(String::compareTo);

 return new RTC<>(
     (FileNode fn) -> ts.add(fn.name),
     ts::iterator,
     false
 );

SORTED_FILENAME_ROAL

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyArrayList<java.lang.String>> SORTED_FILENAME_ROAL
            ()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyArrayList`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ROArrayListBuilder<String> roalb = new ROArrayListBuilder<>();

 return new RTC<>(
     (FileNode fn)   -> roalb.add(fn.name),
     ()              -> { roalb.sort(String::compareTo); return roalb.build(); },
     false
 );

SORTED_FILENAME_ROAL_BUILDER

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ROArrayListBuilder<java.lang.String>> SORTED_FILENAME_ROAL_BUILDER
            (ROArrayListBuilder<java.lang.String> roalb)

Reqesting Container-Type:	`Torello.Java.ReadOnly.ROArrayListBuilder`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(roalb, NULL_MSG_roalb);

 return new RTC<>(
     (FileNode fn)   -> roalb.add(fn.name),
     ()              -> { roalb.sort(String::compareTo); return roalb; },
     true
 );

SORTED_FILENAME_ROTS

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyTreeSet<java.lang.String>> SORTED_FILENAME_ROTS()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyTreeSet`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ROTreeSetBuilder<String> rotsb = new ROTreeSetBuilder<>(String::compareTo);

 return new RTC<>(
     (FileNode fn) -> rotsb.add(fn.name),
     rotsb::build,
     false
 );

SORTED_FILENAME_ROTS_BUILDER

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ROTreeSetBuilder<java.lang.String>> SORTED_FILENAME_ROTS_BUILDER
            (ROTreeSetBuilder<java.lang.String> rotsb)

Reqesting Container-Type:	`Torello.Java.ReadOnly.ROTreeSetBuilder`
Sorting Container-Contents:	Sorted by Simple File-Name
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(rotsb, NULL_MSG_rotsb);
 return new RTC<>((FileNode fn) -> rotsb.add(fn.name), () -> rotsb, true);

SORTED_FULLPATH_VECTOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Vector<java.lang.String>> SORTED_FULLPATH_VECTOR
            ()

Reqesting Container-Type:	`java.util.Vector`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final Vector<String> v = new Vector<>();

 return new RTC<>(
     (FileNode fn)   -> v.add(fn.getFullPathName()),
     ()              -> { v.sort(String::compareTo); return v; },
     false
 );

SORTED_FULLPATH_VECTOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Vector<java.lang.String>> SORTED_FULLPATH_VECTOR
            (java.util.Vector<java.lang.String> v)

Reqesting Container-Type:	`java.util.Vector`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(v, NULL_MSG_v);

 return new RTC<>(
     (FileNode fn)   -> v.add(fn.getFullPathName()),
     ()              -> { v.sort(String::compareTo); return v; },
     true
 );

SORTED_FULLPATH_ARRAYLIST

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.ArrayList<java.lang.String>> SORTED_FULLPATH_ARRAYLIST
            ()

Reqesting Container-Type:	`java.util.ArrayList`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ArrayList<String> al = new ArrayList<>();

 return new RTC<>(
     (FileNode fn)   -> al.add(fn.getFullPathName()),
     ()              -> { al.sort(String::compareTo); return al; },
     false
 );

SORTED_FULLPATH_ARRAYLIST

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.ArrayList<java.lang.String>> SORTED_FULLPATH_ARRAYLIST
            (java.util.ArrayList<java.lang.String> al)

Reqesting Container-Type:	`java.util.ArrayList`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(al, NULL_MSG_al);

 return new RTC<>(
     (FileNode fn)   -> al.add(fn.getFullPathName()),
     ()              -> { al.sort(String::compareTo); return al; },
     true
 );

SORTED_FULLPATH_TREESET

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.TreeSet<java.lang.String>> SORTED_FULLPATH_TREESET
            ()

Reqesting Container-Type:	`java.util.TreeSet`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<String> ts = new TreeSet<>(String::compareTo);
 return new RTC<>((FileNode fn) -> ts.add(fn.getFullPathName()), () -> ts, false);

SORTED_FULLPATH_TREESET

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.TreeSet<java.lang.String>> SORTED_FULLPATH_TREESET
            (java.util.TreeSet<java.lang.String> ts)

Reqesting Container-Type:	`java.util.TreeSet`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(ts, NULL_MSG_ts);
 return new RTC<>((FileNode fn) -> ts.add(fn.getFullPathName()), () -> ts, true);

SORTED_FULLPATH_STREAM

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.stream.Stream<java.lang.String>> SORTED_FULLPATH_STREAM
            ()

Reqesting Container-Type:	`java.util.stream.Stream`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final Stream.Builder<String> b = Stream.builder();

 return new RTC<>(
     (FileNode fn)   -> b.accept(fn.getFullPathName()),
     ()              -> b.build().sorted(String::compareTo),
     false
 );

SORTED_FULLPATH_ARRAY

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.lang.String[]> SORTED_FULLPATH_ARRAY()

Reqesting Container-Type:	`Java-Array`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<String> ts = new TreeSet<>(String::compareTo);

 return new RTC<>(
     (FileNode fn)   -> ts.add(fn.getFullPathName()),
     ()              -> ts.toArray(ZERO_LEN_ARR_STR),
     false
 );

SORTED_FULLPATH_ITERATOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Iterator<java.lang.String>> SORTED_FULLPATH_ITERATOR
            ()

Reqesting Container-Type:	`java.util.Iterator`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<String> ts = new TreeSet<>(String::compareTo);

 return new RTC<>(
     (FileNode fn)   -> ts.add(fn.getFullPathName()),
     ()              -> ts.iterator(),
     false
 );

SORTED_FULLPATH_ROAL

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyArrayList<java.lang.String>> SORTED_FULLPATH_ROAL
            ()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyArrayList`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ROArrayListBuilder<String> roalb = new ROArrayListBuilder<>();

 return new RTC<>(
     (FileNode fn)   -> roalb.add(fn.getFullPathName()),
     ()              -> { roalb.sort(String::compareTo); return roalb.build(); },
     false
 );

SORTED_FULLPATH_ROAL_BUILDER

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ROArrayListBuilder<java.lang.String>> SORTED_FULLPATH_ROAL_BUILDER
            (ROArrayListBuilder<java.lang.String> roalb)

Reqesting Container-Type:	`Torello.Java.ReadOnly.ROArrayListBuilder`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(roalb, NULL_MSG_roalb);

 return new RTC<>(
     (FileNode fn)   -> roalb.add(fn.getFullPathName()),
     ()              -> { roalb.sort(String::compareTo); return roalb; },
     true
 );

SORTED_FULLPATH_ROTS

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyTreeSet<java.lang.String>> SORTED_FULLPATH_ROTS()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyTreeSet`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final ROTreeSetBuilder<String> rotsb = new ROTreeSetBuilder<>(String::compareTo);

 return new RTC<>(
     (FileNode fn) -> rotsb.add(fn.getFullPathName()),
     rotsb::build,
     false
 );

SORTED_FULLPATH_ROTS_BUILDER

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ROTreeSetBuilder<java.lang.String>> SORTED_FULLPATH_ROTS_BUILDER
            (ROTreeSetBuilder<java.lang.String> rotsb)

Reqesting Container-Type:	`Torello.Java.ReadOnly.ROTreeSetBuilder`
Sorting Container-Contents:	Sorted by Full-Path Name
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Accepts Data-Container as a Parameter

Code:

Exact Method Body:

 Objects.requireNonNull(rotsb, NULL_MSG_rotsb);
 return new RTC<>((FileNode fn) -> rotsb.add(fn.getFullPathName()), () -> rotsb, true);

SORTED_BY_DATE_FILENAME_VECTOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Vector<java.lang.String>> SORTED_BY_DATE_FILENAME_VECTOR
            ()

Reqesting Container-Type:	`java.util.Vector`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE);

 return new RTC<>(
     ts::add,
     () -> toFileNames(ts, Vector<String>::new, (Vector<String> v) -> v::add),
     false
 );

SORTED_BY_DATE_FILENAME_ARRAYLIST

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.ArrayList<java.lang.String>> SORTED_BY_DATE_FILENAME_ARRAYLIST
            ()

Reqesting Container-Type:	`java.util.ArrayList`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE);

 return new RTC<>(
     ts::add,
     () -> toFileNames(ts, ArrayList<String>::new, (ArrayList<String> al) -> al::add),
     false
 );

SORTED_BY_DATE_FILENAME_TREESET

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.TreeSet<java.lang.String>> SORTED_BY_DATE_FILENAME_TREESET
            ()

Reqesting Container-Type:	`java.util.TreeSet`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE);

 return new RTC<>(
     ts::add,
     () -> toFileNames(ts, TreeSet<String>::new, (TreeSet<String> tsRet) -> tsRet::add),
     false
 );

SORTED_BY_DATE_FILENAME_STREAM

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.stream.Stream<java.lang.String>> SORTED_BY_DATE_FILENAME_STREAM
            ()

Reqesting Container-Type:	`java.util.stream.Stream`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final Stream.Builder<FileNode> b = Stream.builder();

 return new RTC<>(
     b::accept,
     () -> b.build().sorted(BY_DATE).map((FileNode fn) -> fn.name),
     false
 );

SORTED_BY_DATE_FILENAME_ARRAY

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.lang.String[]> SORTED_BY_DATE_FILENAME_ARRAY()

Reqesting Container-Type:	`Java-Array`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE);

 return new RTC<>(
     ts::add,

     () -> 
     {
         String[]    retArr  = new String[ts.size()];
         int         i       = 0;

         for (FileNode fn : ts) retArr[i++] = fn.name;
         return retArr;
     },

     false
 );

SORTED_BY_DATE_FILENAME_ITERATOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Iterator<java.lang.String>> SORTED_BY_DATE_FILENAME_ITERATOR
            ()

Reqesting Container-Type:	`java.util.Iterator`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE);

 return new RTC<>(
     ts::add,

     () -> toFileNames(
         ts,
         TreeSet<String>::new,
         (TreeSet<String> tsRet) -> tsRet::add
     )
     .iterator(),

     false
 );

SORTED_BY_DATE_FILENAME_ROAL

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyArrayList<java.lang.String>> SORTED_BY_DATE_FILENAME_ROAL
            ()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyArrayList`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE);

 return new RTC<>(
     ts::add,

     () -> toFileNames(
         ts,
         ROArrayListBuilder<String>::new,
         (ROArrayListBuilder<String> roalb) -> roalb::add
     )
     .build(),

     false
 );

SORTED_BY_DATE_FILENAME_ROTS

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyTreeSet<java.lang.String>> SORTED_BY_DATE_FILENAME_ROTS
            ()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyTreeSet`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE);

 return new RTC<>(
     ts::add,

     () -> toFileNames(
         ts,
         ROTreeSetBuilder<String>::new,
         (ROTreeSetBuilder<String> rotsb) -> rotsb::add
     )
     .build(),

     false
 );

SORTED_BY_DATE_FULLPATH_VECTOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Vector<java.lang.String>> SORTED_BY_DATE_FULLPATH_VECTOR
            ()

Reqesting Container-Type:	`java.util.Vector`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE);

 return new RTC<>(
     ts::add,
     () -> toFullPaths(ts, Vector<String>::new, (Vector<String> v) -> v::add),
     false
 );

SORTED_BY_DATE_FULLPATH_ARRAYLIST

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.ArrayList<java.lang.String>> SORTED_BY_DATE_FULLPATH_ARRAYLIST
            ()

Reqesting Container-Type:	`java.util.ArrayList`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE);

 return new RTC<>(
     ts::add,
     () -> toFullPaths(ts, ArrayList<String>::new, (ArrayList<String> al) -> al::add),
     false
 );

SORTED_BY_DATE_FULLPATH_TREESET

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.TreeSet<java.lang.String>> SORTED_BY_DATE_FULLPATH_TREESET
            ()

Reqesting Container-Type:	`java.util.TreeSet`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE);

 return new RTC<>(
     ts::add,
     () -> toFullPaths(ts, TreeSet<String>::new, (TreeSet<String> tsRet) -> tsRet::add),
     false
 );

SORTED_BY_DATE_FULLPATH_STREAM

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.stream.Stream<java.lang.String>> SORTED_BY_DATE_FULLPATH_STREAM
            ()

Reqesting Container-Type:	`java.util.stream.Stream`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final Stream.Builder<FileNode> b = Stream.builder();

 return new RTC<>(
     b::accept,
     () -> b.build().sorted(BY_DATE).map((FileNode fn) -> fn.getFullPathName()),
     false
 );

SORTED_BY_DATE_FULLPATH_ARRAY

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.lang.String[]> SORTED_BY_DATE_FULLPATH_ARRAY()

Reqesting Container-Type:	`Java-Array`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE);

 return new RTC<>(
     ts::add,

     () -> 
     {
         String[]    retArr  = new String[ts.size()];
         int         i       = 0;

         for (FileNode fn : ts) retArr[i++] = fn.getFullPathName();
         return retArr;
     },

     false
 );

SORTED_BY_DATE_FULLPATH_ITERATOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Iterator<java.lang.String>> SORTED_BY_DATE_FULLPATH_ITERATOR
            ()

Reqesting Container-Type:	`java.util.Iterator`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE);

 return new RTC<>(
     ts::add,

     () -> toFullPaths(
         ts,
         TreeSet<String>::new,
         (TreeSet<String> tsRet) -> tsRet::add
     )
     .iterator(),

     false
 );

SORTED_BY_DATE_FULLPATH_ROAL

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyArrayList<java.lang.String>> SORTED_BY_DATE_FULLPATH_ROAL
            ()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyArrayList`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE);

 return new RTC<>(
     ts::add,

     () -> toFullPaths(
         ts,
         ROArrayListBuilder<String>::new,
         (ROArrayListBuilder<String> roalb) -> roalb::add
     )
     .build(),

     false
 );

SORTED_BY_DATE_FULLPATH_ROTS

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyTreeSet<java.lang.String>> SORTED_BY_DATE_FULLPATH_ROTS
            ()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyTreeSet`
Sorting Container-Contents:	Sorted by Date
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_DATE);

 return new RTC<>(
     ts::add,

     () -> toFullPaths(
         ts,
         ROTreeSetBuilder<String>::new,
         (ROTreeSetBuilder<String> rotsb) -> rotsb::add
     )
     .build(),

     false
 );

SORTED_BY_SIZE_FILENAME_VECTOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Vector<java.lang.String>> SORTED_BY_SIZE_FILENAME_VECTOR
            ()

Reqesting Container-Type:	`java.util.Vector`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE);

 return new RTC<>(
     ts::add,
     () -> toFileNames(ts, Vector<String>::new, (Vector<String> v) -> v::add),
     false
 );

SORTED_BY_SIZE_FILENAME_ARRAYLIST

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.ArrayList<java.lang.String>> SORTED_BY_SIZE_FILENAME_ARRAYLIST
            ()

Reqesting Container-Type:	`java.util.ArrayList`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE);

 return new RTC<>(
     ts::add,
     () -> toFileNames(ts, ArrayList<String>::new, (ArrayList<String> al) -> al::add),
     false
 );

SORTED_BY_SIZE_FILENAME_TREESET

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.TreeSet<java.lang.String>> SORTED_BY_SIZE_FILENAME_TREESET
            ()

Reqesting Container-Type:	`java.util.TreeSet`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE);

 return new RTC<>(
     ts::add,
     () -> toFileNames(ts, TreeSet<String>::new, (TreeSet<String> tsRet) -> tsRet::add),
     false
 );

SORTED_BY_SIZE_FILENAME_STREAM

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.stream.Stream<java.lang.String>> SORTED_BY_SIZE_FILENAME_STREAM
            ()

Reqesting Container-Type:	`java.util.stream.Stream`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final Stream.Builder<FileNode> b = Stream.builder();

 return new RTC<>(
     b::accept,
     () -> b.build().sorted(BY_FILE_SIZE).map((FileNode fn) -> fn.name),
     false
 );

SORTED_BY_SIZE_FILENAME_ARRAY

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.lang.String[]> SORTED_BY_SIZE_FILENAME_ARRAY()

Reqesting Container-Type:	`Java-Array`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE);

 return new RTC<>(
     ts::add,

     () -> 
     {
         String[]    retArr  = new String[ts.size()];
         int         i       = 0;

         for (FileNode fn : ts) retArr[i++] = fn.name;
         return retArr;
     },

     false
 );

SORTED_BY_SIZE_FILENAME_ITERATOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Iterator<java.lang.String>> SORTED_BY_SIZE_FILENAME_ITERATOR
            ()

Reqesting Container-Type:	`java.util.Iterator`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE);

 return new RTC<>(
     ts::add,

     () -> toFileNames(
         ts,
         TreeSet<String>::new,
         (TreeSet<String> tsRet) -> tsRet::add
     )
     .iterator(),

     false
 );

SORTED_BY_SIZE_FILENAME_ROAL

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyArrayList<java.lang.String>> SORTED_BY_SIZE_FILENAME_ROAL
            ()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyArrayList`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE);

 return new RTC<>(
     ts::add,

     () -> toFileNames(
         ts,
         ROArrayListBuilder<String>::new,
         (ROArrayListBuilder<String> roalb) -> roalb::add
     )
     .build(),

     false
 );

SORTED_BY_SIZE_FILENAME_ROTS

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyTreeSet<java.lang.String>> SORTED_BY_SIZE_FILENAME_ROTS
            ()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyTreeSet`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	Simple File-Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE);

 return new RTC<>(
     ts::add,

     () -> toFileNames(
         ts,
         ROTreeSetBuilder<String>::new,
         (ROTreeSetBuilder<String> rotsb) -> rotsb::add
     )
     .build(),

     false
 );

SORTED_BY_SIZE_FULLPATH_VECTOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Vector<java.lang.String>> SORTED_BY_SIZE_FULLPATH_VECTOR
            ()

Reqesting Container-Type:	`java.util.Vector`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE);

 return new RTC<>(
     ts::add,
     () -> toFullPaths(ts, Vector<String>::new, (Vector<String> v) -> v::add),
     false
 );

SORTED_BY_SIZE_FULLPATH_ARRAYLIST

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.ArrayList<java.lang.String>> SORTED_BY_SIZE_FULLPATH_ARRAYLIST
            ()

Reqesting Container-Type:	`java.util.ArrayList`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE);

 return new RTC<>(
     ts::add,
     () -> toFullPaths(ts, ArrayList<String>::new, (ArrayList<String> al) -> al::add),
     false
 );

SORTED_BY_SIZE_FULLPATH_TREESET

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.TreeSet<java.lang.String>> SORTED_BY_SIZE_FULLPATH_TREESET
            ()

Reqesting Container-Type:	`java.util.TreeSet`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE);

 return new RTC<>(
     ts::add,
     () -> toFullPaths(ts, TreeSet<String>::new, (TreeSet<String> tsRet) -> tsRet::add),
     false
 );

SORTED_BY_SIZE_FULLPATH_STREAM

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.stream.Stream<java.lang.String>> SORTED_BY_SIZE_FULLPATH_STREAM
            ()

Reqesting Container-Type:	`java.util.stream.Stream`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final Stream.Builder<FileNode> b = Stream.builder();

 return new RTC<>(
     b::accept,
     () -> b.build().sorted(BY_FILE_SIZE).map((FileNode fn) -> fn.getFullPathName()),
     false
 );

SORTED_BY_SIZE_FULLPATH_ARRAY

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.lang.String[]> SORTED_BY_SIZE_FULLPATH_ARRAY()

Reqesting Container-Type:	`Java-Array`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE);

 return new RTC<>(
     ts::add,

     () -> 
     {
         String[]    retArr  = new String[ts.size()];
         int         i       = 0;

         for (FileNode fn : ts) retArr[i++] = fn.getFullPathName();
         return retArr;
     },

     false
 );

SORTED_BY_SIZE_FULLPATH_ITERATOR

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<java.util.Iterator<java.lang.String>> SORTED_BY_SIZE_FULLPATH_ITERATOR
            ()

Reqesting Container-Type:	`java.util.Iterator`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE);

 return new RTC<>(
     ts::add,

     () -> toFullPaths(
         ts,
         TreeSet<String>::new,
         (TreeSet<String> tsRet) -> tsRet::add
     )
     .iterator(),

     false
 );

SORTED_BY_SIZE_FULLPATH_ROAL

🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyArrayList<java.lang.String>> SORTED_BY_SIZE_FULLPATH_ROAL
            ()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyArrayList`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE);

 return new RTC<>(
     ts::add,

     () -> toFullPaths(
         ts,
         ROArrayListBuilder<String>::new,
         (ROArrayListBuilder<String> roalb) -> roalb::add
     )
     .build(),

     false
 );

SORTED_BY_SIZE_FULLPATH_ROTS

🡅 ⇈ ⮫ 🗕 🗗 🗖

public static RTC<ReadOnlyTreeSet<java.lang.String>> SORTED_BY_SIZE_FULLPATH_ROTS
            ()

Reqesting Container-Type:	`Torello.Java.ReadOnly.ReadOnlyTreeSet`
Sorting Container-Contents:	Sorted by File-Size
Container Contents-Type:	Full-Path Name, as a `java.lang.String`
Container Construction:	Constructs new Data-Container Instance

Code:

Exact Method Body:

 final TreeSet<FileNode> ts = new TreeSet<>(BY_FILE_SIZE);

 return new RTC<>(
     ts::add,

     () -> toFullPaths(
         ts,
         ROTreeSetBuilder<String>::new,
         (ROTreeSetBuilder<String> rotsb) -> rotsb::add
     )
     .build(),

     false
 );

Fields
Comparator	BY_DATE
Comparator	BY_FILENAME
Comparator	BY_FILE_SIZE
Comparator	BY_FULLPATH
Constructors
RTC(Consumer inserter, Supplier finisher, boolean isReusable)
Methods
RTC	ARRAY()
RTC	ARRAYLIST()
RTC	ARRAYLIST(ArrayList al)
RTC	FILENAME_ARRAY()
RTC	FILENAME_ARRAYLIST()
RTC	FILENAME_ARRAYLIST(ArrayList al)
RTC	FILENAME_HASHSET()
RTC	FILENAME_HASHSET(HashSet hs)
RTC	FILENAME_ITERATOR()
RTC	FILENAME_ROAL()
RTC	FILENAME_ROAL_BUILDER(ROArrayListBuilder roalb)
RTC	FILENAME_ROHS()
RTC	FILENAME_ROHS_BUILDER(ROHashSetBuilder rohsb)
RTC	FILENAME_STREAM()
RTC	FILENAME_STREAM_BUILDER(Builder b)
RTC	FILENAME_VECTOR()
RTC	FILENAME_VECTOR(Vector v)
RTC	FULLPATH_ARRAY()
RTC	FULLPATH_ARRAYLIST()
RTC	FULLPATH_ARRAYLIST(ArrayList al)
RTC	FULLPATH_HASHSET()
RTC	FULLPATH_HASHSET(HashSet hs)
RTC	FULLPATH_ITERATOR()
RTC	FULLPATH_ROAL()
RTC	FULLPATH_ROAL_BUILDER(ROArrayListBuilder roalb)
RTC	FULLPATH_ROHS()
RTC	FULLPATH_ROHS_BUILDER(ROHashSetBuilder rohsb)
RTC	FULLPATH_STREAM()
RTC	FULLPATH_STREAM_BUILDER(Builder b)
RTC	FULLPATH_VECTOR()
RTC	FULLPATH_VECTOR(Vector v)
RTC	HASHSET()
RTC	HASHSET(HashSet hs)

Class RTC<SOME_DATA_STRUCTURE>

Field Summary

Fields inherited from class Torello.Java.VarType

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

BY_DATE

BY_FILE_SIZE

BY_FULLPATH

BY_FILENAME

Constructor Detail

RTC

Method Detail

VECTOR

VECTOR

ARRAYLIST

ARRAYLIST

HASHSET

HASHSET

STREAM

STREAM_BUILDER

ARRAY

ITERATOR

ROAL

ROAL_BUILDER

ROHS

ROHS_BUILDER

SORTED_BY_DATE_VECTOR

SORTED_BY_DATE_VECTOR

SORTED_BY_DATE_ARRAYLIST

SORTED_BY_DATE_ARRAYLIST

SORTED_BY_DATE_TREESET

SORTED_BY_DATE_TREESET

SORTED_BY_DATE_STREAM

SORTED_BY_DATE_ARRAY

SORTED_BY_DATE_ITERATOR

SORTED_BY_DATE_ROAL

SORTED_BY_DATE_ROAL_BUILDER

SORTED_BY_DATE_ROTS

SORTED_BY_DATE_ROTS_BUILDER

SORTED_BY_SIZE_VECTOR

SORTED_BY_SIZE_VECTOR

SORTED_BY_SIZE_ARRAYLIST

SORTED_BY_SIZE_ARRAYLIST

SORTED_BY_SIZE_TREESET

SORTED_BY_SIZE_TREESET

SORTED_BY_SIZE_STREAM

SORTED_BY_SIZE_ARRAY

SORTED_BY_SIZE_ITERATOR

SORTED_BY_SIZE_ROAL

SORTED_BY_SIZE_ROAL_BUILDER

SORTED_BY_SIZE_ROTS

SORTED_BY_SIZE_ROTS_BUILDER

SORTED_BY_FULLPATH_VECTOR

SORTED_BY_FULLPATH_VECTOR

SORTED_BY_FULLPATH_ARRAYLIST

SORTED_BY_FULLPATH_ARRAYLIST

SORTED_BY_FULLPATH_TREESET

SORTED_BY_FULLPATH_TREESET

SORTED_BY_FULLPATH_STREAM

SORTED_BY_FULLPATH_ARRAY

SORTED_BY_FULLPATH_ITERATOR

SORTED_BY_FULLPATH_ROAL

SORTED_BY_FULLPATH_ROAL_BUILDER

SORTED_BY_FULLPATH_ROTS

SORTED_BY_FULLPATH_ROTS_BUILDER

SORTED_BY_FILENAME_VECTOR

SORTED_BY_FILENAME_VECTOR

SORTED_BY_FILENAME_ARRAYLIST

SORTED_BY_FILENAME_ARRAYLIST

SORTED_BY_FILENAME_TREESET

SORTED_BY_FILENAME_TREESET

SORTED_BY_FILENAME_STREAM

SORTED_BY_FILENAME_ARRAY

SORTED_BY_FILENAME_ITERATOR

SORTED_BY_FILENAME_ROAL

SORTED_BY_FILENAME_ROAL_BUILDER

SORTED_BY_FILENAME_ROTS

SORTED_BY_FILENAME_ROTS_BUILDER