Package org.infinispan.commons.util

Class Immutables

  • Direct Known Subclasses:
    CoreImmutables
    public class Immutables
extends Object
    Factory for generating immutable type wrappers.
    Since:
    4.0
    Author:
    Jason T. Greene, Galder Zamarreño, Tristan Tarrant

    • Constructor Detail

      • Immutables

        public Immutables()

    • Method Detail

      • isImmutable

        public static boolean isImmutable​(Object o)
        Whether or not this collection type is immutable
        Parameters:
        o - a Collection, Set, List, or Map
        Returns:
        true if immutable, false if not

      • immutableListConvert

        public static <T> List<T> immutableListConvert​(Collection<? extends T> source)
        Converts a Collection to an immutable List by copying it.
        Parameters:
        source - the collection to convert
        Returns:
        a copied/converted immutable list

      • immutableListCopy

        public static <T> List<T> immutableListCopy​(List<T> list)
        Creates an immutable copy of the list.
        Parameters:
        list - the list to copy
        Returns:
        the immutable copy

      • immutableTypedProperties

        public static TypedProperties immutableTypedProperties​(TypedProperties properties)
        Creates an immutable copy of the properties.
        Parameters:
        properties - the TypedProperties to copy
        Returns:
        the immutable copy

      • immutableListWrap

        public static <T> List<T> immutableListWrap​(T... array)
        Wraps an array with an immutable list. There is no copying involved.
        Type Parameters:
        T -
        Parameters:
        array - the array to wrap
        Returns:
        a list containing the array

      • immutableListMerge

        public static <T> List<T> immutableListMerge​(List<? extends T> list1,
                                             List<? extends T> list2)
        Creates a new immutable list containing the union (combined entries) of both lists.
        Parameters:
        list1 - contains the first elements of the new list
        list2 - contains the successor elements of the new list
        Returns:
        a new immutable merged copy of list1 and list2

      • immutableListAdd

        public static <T> ImmutableListCopy<T> immutableListAdd​(List<T> list,
                                                        int position,
                                                        T element)

      • immutableListReplace

        public static <T> ImmutableListCopy<T> immutableListReplace​(List<T> list,
                                                            int position,
                                                            T element)

      • immutableListRemove

        public static <T> List<T> immutableListRemove​(List<T> list,
                                              int position)

      • immutableSetConvert

        public static <T> Set<T> immutableSetConvert​(Collection<? extends T> collection)
        Converts a Collections into an immutable Set by copying it.
        Parameters:
        collection - the collection to convert/copy
        Returns:
        a new immutable set containing the elements in collection

      • immutableSetWrap

        public static <T> Set<T> immutableSetWrap​(Set<? extends T> set)
        Wraps a set with an immutable set. There is no copying involved.
        Parameters:
        set - the set to wrap
        Returns:
        an immutable set wrapper that delegates to the original set

      • immutableSetCopy

        public static <T> Set<T> immutableSetCopy​(Set<T> set)
        Creates an immutable copy of the specified set.
        Parameters:
        set - the set to copy from
        Returns:
        an immutable set copy

      • immutableMapWrap

        public static <K,​V> Map<K,​V> immutableMapWrap​(Map<? extends K,​? extends V> map)
        Wraps a map with an immutable map. There is no copying involved.
        Parameters:
        map - the map to wrap
        Returns:
        an immutable map wrapper that delegates to the original map

      • immutableMapCopy

        public static <K,​V> Map<K,​V> immutableMapCopy​(Map<K,​V> map)
        Creates an immutable copy of the specified map.
        Parameters:
        map - the map to copy from
        Returns:
        an immutable map copy

      • immutableCollectionCopy

        public static <T> Collection<T> immutableCollectionCopy​(Collection<T> collection)
        Creates a new immutable copy of the specified Collection.
        Parameters:
        collection - the collection to copy
        Returns:
        an immutable copy

      • immutableCollectionWrap

        public static <T> Collection<T> immutableCollectionWrap​(Collection<? extends T> collection)
        Wraps a collection with an immutable collection. There is no copying involved.
        Parameters:
        collection - the collection to wrap
        Returns:
        an immutable collection wrapper that delegates to the original collection

      • immutableEntry

        public static <K,​V> Map.Entry<K,​V> immutableEntry​(Map.Entry<K,​V> entry)
        Wraps a Map.Entry} with an immutable Map.Entry}. There is no copying involved.
        Parameters:
        entry - the mapping to wrap.
        Returns:
        an immutable Map.Entry} wrapper that delegates to the original mapping.

      • immutableEntry

        public static <K,​V> Map.Entry<K,​V> immutableEntry​(K key,
                                                              V value)
        Wraps a key and value with an immutable Map.Entry}. There is no copying involved.
        Parameters:
        key - the key to wrap.
        value - the value to wrap.
        Returns:
        an immutable Map.Entry} wrapper that delegates to the original mapping.