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.
        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.