FoldUtilities (Editor Code Folding)

java.lang.Object
- org.netbeans.api.editor.fold.FoldUtilities

```
public final class FoldUtilities
extends Object
```
Various utility methods for dealing with the folds.
Note: Until explicitly noted all the utility methods require a lock to be held on the FoldHierarchy during execution of the methods.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static List`	`childrenAsList(Fold fold)` Return children of the given fold as modifiable list.
`static List`	`childrenAsList(Fold fold, int index, int count)` Return children of the given fold as list.
`static Fold[]`	`childrenToArray(Fold fold)` Return children of the given fold as array.
`static Fold[]`	`childrenToArray(Fold fold, int index, int count)` Return children of the given fold as array.
`static void`	`collapse(FoldHierarchy hierarchy, Collection foldTypes)` Collapse all folds that having any of the fold types in the given collection.
`static void`	`collapse(FoldHierarchy hierarchy, FoldType type)` Collapse all folds of the given type.
`static void`	`collapseAll(FoldHierarchy hierarchy)` Collapse all folds in the hierarchy.
`static Iterator`	`collapsedFoldIterator(FoldHierarchy hierarchy, int startOffset, int endOffset)` Get iterator over the collapsed folds.
`static boolean`	`containsOffset(Fold fold, int offset)` Check whether fold contains the given offset.
`static void`	`expand(FoldHierarchy hierarchy, Collection foldTypes)` Expand all folds of the given type (or all folds if the type is null) found in the whole fold hierarchy.
`static void`	`expand(FoldHierarchy hierarchy, FoldType type)` Expand all folds of the given type.
`static void`	`expandAll(FoldHierarchy hierarchy)` Expand all folds in the hierarchy.
`static List`	`find(Fold fold, Collection foldTypes)` Find direct subfolds of the given fold having any of the fold types in the given collection.
`static List`	`find(Fold fold, FoldType foldType)` Find direct subfolds of the given fold having certain type.
`static Fold`	`findCollapsedFold(FoldHierarchy hierarchy, int startOffset, int endOffset)` Find a first collapsed fold by going from top-level folds to more nested ones within the requested bounds.
`static int`	`findFoldEndIndex(Fold fold, int offset)` Find index of the first child of the given fold that ends above the given offset ("contains" the offset).
`static int`	`findFoldStartIndex(Fold fold, int offset)` Find index of the child of the given fold that starts right at or below the given offset.
`static Fold`	`findNearestFold(FoldHierarchy hierarchy, int offset)` Find the fold nearest to the given offset.
`static Fold`	`findOffsetFold(FoldHierarchy hierarchy, int offset)` Find a deepest fold in the hierarchy which contains the offset or has it as one of its boundaries.
`static List`	`findRecursive(Fold fold)` Collect all children of the given fold recursively.
`static List`	`findRecursive(Fold fold, Collection foldTypes)` Recursively find any subfolds of the given fold having any of the fold types in the given collection.
`static List`	`findRecursive(Fold fold, FoldType foldType)` Recursively find any subfolds of the given fold having certain type.
`static FoldType.Domain`	`getFoldTypes(String mimeType)` Obtains available FoldType values for the specified MIME type.
`static boolean`	`isAutoCollapsed(FoldType ft, FoldHierarchy hierarchy)` Determines whether folds of that type are should be initially collapsed.
`static boolean`	`isEmpty(Fold fold)` Check whether the starting offset of the fold is the same like its ending offset.
`static boolean`	`isFoldingEnabled(String mimeType)` Determines whether folding is enabled for a given MIME type.
`static boolean`	`isRootFold(Fold fold)` Is the given fold a root fold?

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

- Method Detail
  - isRootFold
```
public static boolean isRootFold(Fold fold)
```
    Is the given fold a root fold?
    
    Parameters:
    
    fold - non-null fold which is either root fold or a regular fold.
    
    Returns:
    
    true if the given fold is root fold or false otherwise.
  - findFoldStartIndex
```
public static int findFoldStartIndex(Fold fold,
                                     int offset)
```
    Find index of the child of the given fold that starts right at or below the given offset.
    This method uses binary search and has log2(n) performance where n is number of children of the given fold.
    The efficiency may drop to linear if there would be many empty folds at the given offset.
    
    Parameters:
    
    fold - fold which children will be inspected.
    
    offset - >=0 offset in the document for which the representing child will be searched.
    
    Returns:
    
    index of the child fold that represents the given offset.
    An index is returned if offset >= getFold(index).getStartOffset() and offset <= getFold(index + 1).getStartOffset().
    -1 is returned if offset < getFold(0).getStartOffset() and in case the fold does not have any children.
  - findFoldEndIndex
```
public static int findFoldEndIndex(Fold fold,
                                   int offset)
```
    Find index of the first child of the given fold that ends above the given offset ("contains" the offset).
    This method uses binary search and has log2(n) performance where n is number of children of the given fold.
    The efficiency may drop to linear if there would be many empty folds at the given offset.
    
    Parameters:
    
    fold - fold which children will be inspected.
    
    offset - >=0 offset in the document for which the representing child will be searched.
    
    Returns:
    
    index of the child fold that contains or is above the given offset.
    A highest index is returned for which offset < getFold(index).getEndOffset()
    or fold.getFoldCount() in case there is no such fold.
  - isEmpty
```
public static boolean isEmpty(Fold fold)
```
    Check whether the starting offset of the fold is the same like its ending offset.
    
    Parameters:
    
    fold - fold that should be checked whether it's empty.
    
    Returns:
    
    true if the fold is empty or false otherwise.
  - collapseAll
```
public static void collapseAll(FoldHierarchy hierarchy)
```
    Collapse all folds in the hierarchy.
    This method does the necessary locking of the document and hierarchy.
    
    Parameters:
    
    hierarchy - hierarchy under which all folds should be collapsed.
  - collapse
```
public static void collapse(FoldHierarchy hierarchy,
                            FoldType type)
```
    Collapse all folds of the given type.
    This method does the necessary locking of the document and hierarchy.
    
    Parameters:
    
    hierarchy - hierarchy under which the folds should be collapsed.
    
    type - folds with this type will be collapsed.
  - collapse
```
public static void collapse(FoldHierarchy hierarchy,
                            Collection foldTypes)
```
    Collapse all folds that having any of the fold types in the given collection.
    This method does the necessary locking of the document and hierarchy.
    
    Parameters:
    
    hierarchy - hierarchy under which the folds should be collapsed.
    
    foldTypes - collection of fold types to search for.
  - expandAll
```
public static void expandAll(FoldHierarchy hierarchy)
```
    Expand all folds in the hierarchy.
    This method does the necessary locking of the document and hierarchy.
    
    Parameters:
    
    hierarchy - hierarchy under which all folds should be expanded.
  - expand
```
public static void expand(FoldHierarchy hierarchy,
                          FoldType type)
```
    Expand all folds of the given type.
    This method does the necessary locking of the document and hierarchy.
    
    Parameters:
    
    hierarchy - hierarchy under which the folds should be expanded.
    
    type - folds with this type will be expanded.
  - expand
```
public static void expand(FoldHierarchy hierarchy,
                          Collection foldTypes)
```
    Expand all folds of the given type (or all folds if the type is null) found in the whole fold hierarchy.
    This method does the necessary locking of the document and hierarchy.
    
    Parameters:
    
    hierarchy - hierarchy under which the folds should be expanded.
    
    foldTypes - collection of fold types to search for.
  - containsOffset
```
public static boolean containsOffset(Fold fold,
                                     int offset)
```
    Check whether fold contains the given offset.
    
    Parameters:
    
    fold - fold to be tested for containing the given offset
    
    offset - that will be tested for being contained in the given fold.
    
    Returns:
    
    true if offset >= fold.getStartOffset() && offset < fold.getEndOffset()
  - childrenToArray
```
public static Fold[] childrenToArray(Fold fold)
```
    Return children of the given fold as array.
    
    Parameters:
    
    fold - fold which children will be returned.
    
    Returns:
    
    non-null array of all child folds.
  - childrenToArray
```
public static Fold[] childrenToArray(Fold fold,
                                     int index,
                                     int count)
```
    Return children of the given fold as array.
    
    Parameters:
    
    fold - fold which children will be returned.
    
    index - >=0 index of the first child to be returned.
    
    count - >=0 number of children to be returned. index + count <= Fold.getFoldCount().
    
    Returns:
    
    non-null array of selected child folds.
  - childrenAsList
```
public static List childrenAsList(Fold fold)
```
    Return children of the given fold as modifiable list.
    FoldUtilities.findRecursive(Fold) can be used to collect children recursively.
    
    Parameters:
    
    fold - fold which children will be returned.
    
    Returns:
    
    non-null modifiable list of all child folds.
  - childrenAsList
```
public static List childrenAsList(Fold fold,
                                  int index,
                                  int count)
```
    Return children of the given fold as list.
    
    Parameters:
    
    fold - fold which children will be returned.
    
    index - >=0 index of the first child to be returned.
    
    count - >=0 number of children to be returned. index + count <= Fold.getFoldCount().
    
    Returns:
    
    non-null list of selected child folds.
    The list can potentially be further modified by the caller without any effect on the fold hierarchy.
  - find
```
public static List find(Fold fold,
                        FoldType foldType)
```
    Find direct subfolds of the given fold having certain type.
    Complexity corresponds to number of direct child folds under the given fold.
    
    Parameters:
    
    fold - direct children of this fold will be searched. The search is *not* recursive in grandchildren etc.
    
    foldType - non-null fold type to search for.
    
    Returns:
    
    non-null list of folds matching the criteria.
    The list can potentially be further modified by the caller without any effect on the fold hierarchy.
  - find
```
public static List find(Fold fold,
                        Collection foldTypes)
```
    Find direct subfolds of the given fold having any of the fold types in the given collection.
    Complexity corresponds to number of direct child folds under the given fold.
    
    Parameters:
    
    fold - direct children of this fold will be searched. The search is *not* recursive in grandchildren etc.
    
    foldTypes - collection of fold types to search for.
    
    Returns:
    
    non-null list of folds matching the criteria.
    The list can potentially be further modified by the caller without any effect on the fold hierarchy.
  - findRecursive
```
public static List findRecursive(Fold fold)
```
    Collect all children of the given fold recursively.
    Complexity corresponds to number of all child folds (including grandchildren etc.) under the given fold.
    
    Parameters:
    
    fold - all children of this fold will be collected.
    
    Returns:
    
    non-null list of folds matching the criteria.
    The list can potentially be further modified by the caller without any effect on the fold hierarchy.
  - findRecursive
```
public static List findRecursive(Fold fold,
                                 FoldType foldType)
```
    Recursively find any subfolds of the given fold having certain type.
    Complexity corresponds to number of all child folds (including grandchildren etc.) under the given fold.
    
    Parameters:
    
    fold - all children of this fold will be searched. The search is recursive into grandchildren etc.
    
    foldType - non-null fold type to search for.
    
    Returns:
    
    non-null list of folds matching the criteria.
    The list can potentially be further modified by the caller without any effect on the fold hierarchy.
  - findRecursive
```
public static List findRecursive(Fold fold,
                                 Collection foldTypes)
```
    Recursively find any subfolds of the given fold having any of the fold types in the given collection.
    Complexity corresponds to number of all child folds (including grandchildren etc.) under the given fold.
    
    Parameters:
    
    fold - all children of this fold will be searched. The search is recursive into grandchildren etc.
    
    foldTypes - collection of fold types to search for.
    
    Returns:
    
    non-null list of folds matching the criteria.
    The list can potentially be further modified by the caller without any effect on the fold hierarchy.
  - findNearestFold
```
public static Fold findNearestFold(FoldHierarchy hierarchy,
                                   int offset)
```
    Find the fold nearest to the given offset. If the offset is positive or zero, finds the nearest fold that starts at or follows the offset. If the offset is negative, the method finds the nearest fold that ends at or before the negated offset value. Returns null if such a fold cannot be found, that is if no fold follows (or precedes, for negative offset values) the offset.
    The search deep-dives into hierarchy.
    
    Parameters:
    
    offset - offset in a document, or negated value of offset to indicate backwards search.
    
    Returns:
    
    fold in the hierarchy that is the nearest to the input offset. The most important is the lowest distance of the start (end) of the fold to the given offset. If there would be a nearest fold having a first child that starts at the same position like the parent then the parent would be returned. For backwards search, the deepest child will be returned.
    
    Since:
    
    1.45 backward search added
  - findOffsetFold
```
public static Fold findOffsetFold(FoldHierarchy hierarchy,
                                  int offset)
```
    Find a deepest fold in the hierarchy which contains the offset or has it as one of its boundaries.
    The search deep-dives into hierarchy.
    
    Parameters:
    
    offset - >=0 offset in a document.
    
    Returns:
    
    deepset fold in the hierarchy satisfying fold.getStartOffset() >= offset && offset <= fold.getEndOffset() or null if there is no such fold (except the root fold) satisfying the condition.
    For two consecutive folds (one ending at the offset and the next one starting at the offset) the latter fold would be returned.
  - findCollapsedFold
```
public static Fold findCollapsedFold(FoldHierarchy hierarchy,
                                     int startOffset,
                                     int endOffset)
```
    Find a first collapsed fold by going from top-level folds to more nested ones within the requested bounds. Once a collapsed fold is found it is returned (its children even if they would be collapsed are not inspected).
    
    Parameters:
    
    hierarchy - hierarchy in which to search.
    
    startOffset - >=0 only fold ending above it will be returned.
    
    endOffset - >=0 only fold starting below it will be returned.
    
    Returns:
    
    collapsed fold satisfying fold.getEndOffset() > startOffset and fold.getStartOffset() < endOffset or null if such fold does not exist.
  - collapsedFoldIterator
```
public static Iterator collapsedFoldIterator(FoldHierarchy hierarchy,
                                             int startOffset,
                                             int endOffset)
```
    Get iterator over the collapsed folds.
    
    Parameters:
    
    hierarchy - hierarchy in which to search.
    
    startOffset - >=0 only folds ending above it will be returned.
    
    endOffset - >=0 only folds starting before it will be returned.
    
    Returns:
    
    iterator over collapsed folds satisfying fold.getEndOffset() > startOffset and fold.getStartOffset() < endOffset
    If a particular collapsed fold gets returned then its children are not deep-dived for collapsed folds. Instead the search continues by a following sibling.
  - getFoldTypes
```
public static FoldType.Domain getFoldTypes(String mimeType)
```
    Obtains available FoldType values for the specified MIME type.
    
    Parameters:
    
    mimeType - mime type of the content
    
    Returns:
    
    available FoldTypes
    
    Since:
    
    1.35
  - isAutoCollapsed
```
public static boolean isAutoCollapsed(FoldType ft,
                                      FoldHierarchy hierarchy)
```
    Determines whether folds of that type are should be initially collapsed. The FoldType is evaluated in the context of a specific FoldHierarchy, that is a Component with a content of a certain MIME type.
    
    Parameters:
    
    ft - FoldType to inspect
    
    hierarchy - context for evaluation
    
    Returns:
    
    true, if folds of FoldType should be initially collapsed.
    
    Since:
    
    1.35
  - isFoldingEnabled
```
public static boolean isFoldingEnabled(String mimeType)
```
    Determines whether folding is enabled for a given MIME type. Use MimePath.EMPTY.getMimeType() to query for the default (all languages) setting.
    
    Parameters:
    
    mimeType - the MIME type of the content.
    
    Returns:
    
    true, if folding is enabled, false otherwise.
    
    Since:
    
    1.35

Class FoldUtilities

Method Summary

Methods inherited from class java.lang.Object

Method Detail

isRootFold

findFoldStartIndex

findFoldEndIndex

isEmpty

collapseAll

collapse

collapse

expandAll

expand

expand

containsOffset

childrenToArray

childrenToArray

childrenAsList

childrenAsList

find

find

findRecursive

findRecursive

findRecursive

findNearestFold

findOffsetFold

findCollapsedFold

collapsedFoldIterator

getFoldTypes

isAutoCollapsed

isFoldingEnabled