Class BitSetModule.AbstractBitSet<T>

    • Constructor Detail

      • AbstractBitSet

        AbstractBitSet​(Function1<java.lang.Integer,​T> fromInt,
                       Function1<T,​java.lang.Integer> toInt)
    • Method Detail

      • getWordsNum

        abstract int getWordsNum()
      • copyExpand

        abstract long[] copyExpand​(int wordsNum)
      • getWord

        abstract long getWord​(int index)
      • createEmpty

        BitSet<T> createEmpty()
      • createFromAll

        BitSet<T> createFromAll​(java.lang.Iterable<? extends T> values)
      • fromBitMaskNoCopy

        BitSet<T> fromBitMaskNoCopy​(long[] elements)
      • setElement

        private void setElement​(long[] words,
                                int element)
      • unsetElement

        private void unsetElement​(long[] words,
                                  int element)
      • shrink

        long[] shrink​(long[] elements)
      • addElement

        BitSet<T> addElement​(int element)
      • distinctBy

        public BitSet<T> distinctBy​(java.util.Comparator<? super T> comparator)
        Description copied from interface: Traversable
        Returns a new version of this which contains no duplicates. Elements are compared using the given comparator.
        Specified by:
        distinctBy in interface BitSet<T>
        Specified by:
        distinctBy in interface Set<T>
        Specified by:
        distinctBy in interface SortedSet<T>
        Specified by:
        distinctBy in interface Traversable<T>
        Parameters:
        comparator - A comparator
        Returns:
        a new Traversable containing this elements without duplicates
      • distinctBy

        public <U> BitSet<T> distinctBy​(java.util.function.Function<? super T,​? extends U> keyExtractor)
        Description copied from interface: Traversable
        Returns a new version of this which contains no duplicates. Elements mapped to keys which are compared using equals.

        The elements of the result are determined in the order of their occurrence - first match wins.

        Specified by:
        distinctBy in interface BitSet<T>
        Specified by:
        distinctBy in interface Set<T>
        Specified by:
        distinctBy in interface SortedSet<T>
        Specified by:
        distinctBy in interface Traversable<T>
        Type Parameters:
        U - key type
        Parameters:
        keyExtractor - A key extractor
        Returns:
        a new Traversable containing this elements without duplicates
      • drop

        public BitSet<T> drop​(int n)
        Description copied from interface: Traversable
        Drops the first n elements of this or all elements, if this length < n.
        Specified by:
        drop in interface BitSet<T>
        Specified by:
        drop in interface Set<T>
        Specified by:
        drop in interface SortedSet<T>
        Specified by:
        drop in interface Traversable<T>
        Parameters:
        n - The number of elements to drop.
        Returns:
        a new instance consisting of all elements of this except the first n ones, or else the empty instance, if this has less than n elements.
      • dropRight

        public BitSet<T> dropRight​(int n)
        Description copied from interface: Traversable
        Drops the last n elements of this or all elements, if this length < n.
        Specified by:
        dropRight in interface BitSet<T>
        Specified by:
        dropRight in interface Set<T>
        Specified by:
        dropRight in interface SortedSet<T>
        Specified by:
        dropRight in interface Traversable<T>
        Parameters:
        n - The number of elements to drop.
        Returns:
        a new instance consisting of all elements of this except the last n ones, or else the empty instance, if this has less than n elements.
      • dropWhile

        public BitSet<T> dropWhile​(java.util.function.Predicate<? super T> predicate)
        Description copied from interface: Traversable
        Drops elements while the predicate holds for the current element.

        Note: This is essentially the same as dropUntil(predicate.negate()). It is intended to be used with method references, which cannot be negated directly.

        Specified by:
        dropWhile in interface BitSet<T>
        Specified by:
        dropWhile in interface Set<T>
        Specified by:
        dropWhile in interface SortedSet<T>
        Specified by:
        dropWhile in interface Traversable<T>
        Parameters:
        predicate - A condition tested subsequently for this elements.
        Returns:
        a new instance consisting of all elements starting from the first one which does not satisfy the given predicate.
      • intersect

        public BitSet<T> intersect​(Set<? extends T> elements)
        Description copied from interface: Set
        Computes the intersection between this set and another set.

        See also Set.retainAll(Iterable).

        Specified by:
        intersect in interface BitSet<T>
        Specified by:
        intersect in interface Set<T>
        Specified by:
        intersect in interface SortedSet<T>
        Parameters:
        elements - the set to intersect with.
        Returns:
        A new Set consisting of all elements that are both in this set and in the given set that.
      • orElse

        public BitSet<T> orElse​(java.lang.Iterable<? extends T> other)
        Returns this BitSet if it is nonempty, otherwise BitSet created from iterable, using existing bitset properties.
        Specified by:
        orElse in interface Set<T>
        Specified by:
        orElse in interface SortedSet<T>
        Specified by:
        orElse in interface Traversable<T>
        Parameters:
        other - An alternative Traversable
        Returns:
        this BitSet if it is nonempty, otherwise BitSet created from iterable, using existing bitset properties.
      • orElse

        public BitSet<T> orElse​(java.util.function.Supplier<? extends java.lang.Iterable<? extends T>> supplier)
        Returns this BitSet if it is nonempty, otherwise BitSet created from result of evaluating supplier, using existing bitset properties.
        Specified by:
        orElse in interface Set<T>
        Specified by:
        orElse in interface SortedSet<T>
        Specified by:
        orElse in interface Traversable<T>
        Parameters:
        supplier - An alternative Traversable
        Returns:
        this BitSet if it is nonempty, otherwise BitSet created from result of evaluating supplier, using existing bitset properties.
      • slideBy

        public Iterator<BitSet<T>> slideBy​(java.util.function.Function<? super T,​?> classifier)
        Description copied from interface: Traversable
        Slides a non-overlapping window of a variable size over this Traversable.

        Each window contains elements with the same class, as determined by classifier. Two consecutive values in this Traversable will be in the same window only if classifier returns equal values for them. Otherwise, the values will constitute the last element of the previous window and the first element of the next window.

        Examples:

        
         [].slideBy(Function.identity()) = []
         [1,2,3,4,4,5].slideBy(Function.identity()) = [[1],[2],[3],[4,4],[5]]
         [1,2,3,10,12,5,7,20,29].slideBy(x -> x/10) = [[1,2,3],[10,12],[5,7],[20,29]]
         
        Specified by:
        slideBy in interface BitSet<T>
        Specified by:
        slideBy in interface Set<T>
        Specified by:
        slideBy in interface SortedSet<T>
        Specified by:
        slideBy in interface Traversable<T>
        Parameters:
        classifier - A function which classifies elements into classes
        Returns:
        A new Iterator of windows of the grouped elements
      • sliding

        public Iterator<BitSet<T>> sliding​(int size,
                                           int step)
        Description copied from interface: Traversable
        Slides a window of a specific size and step size over this Traversable.

        Examples:

         
         [].sliding(1,1) = []
         [1,2,3,4,5].sliding(2,3) = [[1,2],[4,5]]
         [1,2,3,4,5].sliding(2,4) = [[1,2],[5]]
         [1,2,3,4,5].sliding(2,5) = [[1,2]]
         [1,2,3,4].sliding(5,3) = [[1,2,3,4],[4]]
         
         
        Specified by:
        sliding in interface BitSet<T>
        Specified by:
        sliding in interface Set<T>
        Specified by:
        sliding in interface SortedSet<T>
        Specified by:
        sliding in interface Traversable<T>
        Parameters:
        size - a positive window size
        step - a positive step size
        Returns:
        a new Iterator of windows of a specific size using a specific step size
      • span

        public Tuple2<BitSet<T>,​BitSet<T>> span​(java.util.function.Predicate<? super T> predicate)
        Description copied from interface: Traversable
        Returns a tuple where the first element is the longest prefix of elements that satisfy the given predicate and the second element is the remainder.
        Specified by:
        span in interface BitSet<T>
        Specified by:
        span in interface Set<T>
        Specified by:
        span in interface SortedSet<T>
        Specified by:
        span in interface Traversable<T>
        Parameters:
        predicate - A predicate.
        Returns:
        a Tuple containing the longest prefix of elements that satisfy p and the remainder.
      • scan

        public BitSet<T> scan​(T zero,
                              java.util.function.BiFunction<? super T,​? super T,​? extends T> operation)
        Description copied from interface: Traversable
        Computes a prefix scan of the elements of the collection. Note: The neutral element z may be applied more than once.
        Specified by:
        scan in interface BitSet<T>
        Specified by:
        scan in interface Set<T>
        Specified by:
        scan in interface SortedSet<T>
        Specified by:
        scan in interface Traversable<T>
        Parameters:
        zero - neutral element for the operator op
        operation - the associative operator for the scan
        Returns:
        a new traversable collection containing the prefix scan of the elements in this traversable collection
      • partition

        public Tuple2<BitSet<T>,​BitSet<T>> partition​(java.util.function.Predicate<? super T> predicate)
        Description copied from interface: Traversable
        Creates a partition of this Traversable by splitting this elements in two in distinct traversables according to a predicate.
        Specified by:
        partition in interface BitSet<T>
        Specified by:
        partition in interface Set<T>
        Specified by:
        partition in interface SortedSet<T>
        Specified by:
        partition in interface Traversable<T>
        Parameters:
        predicate - A predicate which classifies an element if it is in the first or the second traversable.
        Returns:
        A disjoint union of two traversables. The first Traversable contains all elements that satisfy the given predicate, the second Traversable contains all elements that don't. The original order of elements is preserved.
      • filter

        public BitSet<T> filter​(java.util.function.Predicate<? super T> predicate)
        Description copied from interface: Traversable
        Returns a new traversable consisting of all elements which satisfy the given predicate.
        Specified by:
        filter in interface BitSet<T>
        Specified by:
        filter in interface Set<T>
        Specified by:
        filter in interface SortedSet<T>
        Specified by:
        filter in interface Traversable<T>
        Parameters:
        predicate - A predicate
        Returns:
        a new traversable
      • reject

        public BitSet<T> reject​(java.util.function.Predicate<? super T> predicate)
        Description copied from interface: Traversable
        Returns a new traversable consisting of all elements which do not satisfy the given predicate.

        The default implementation is equivalent to

        filter(predicate.negate()
        Specified by:
        reject in interface BitSet<T>
        Specified by:
        reject in interface Set<T>
        Specified by:
        reject in interface SortedSet<T>
        Specified by:
        reject in interface Traversable<T>
        Parameters:
        predicate - A predicate
        Returns:
        a new traversable
      • groupBy

        public <C> Map<C,​BitSet<T>> groupBy​(java.util.function.Function<? super T,​? extends C> classifier)
        Description copied from interface: Traversable
        Groups this elements by classifying the elements.
        Specified by:
        groupBy in interface BitSet<T>
        Specified by:
        groupBy in interface Set<T>
        Specified by:
        groupBy in interface SortedSet<T>
        Specified by:
        groupBy in interface Traversable<T>
        Type Parameters:
        C - classified class type
        Parameters:
        classifier - A function which classifies elements into classes
        Returns:
        A Map containing the grouped elements
        See Also:
        Traversable.arrangeBy(Function)
      • comparator

        public java.util.Comparator<T> comparator()
        Description copied from interface: Ordered
        Returns the comparator which defines the order of the elements contained in this collection.
        Specified by:
        comparator in interface Ordered<T>
        Returns:
        The comparator that defines the order of this collection's elements.
      • takeWhile

        public BitSet<T> takeWhile​(java.util.function.Predicate<? super T> predicate)
        Description copied from interface: Traversable
        Takes elements while the predicate holds for the current element.
        Specified by:
        takeWhile in interface BitSet<T>
        Specified by:
        takeWhile in interface Set<T>
        Specified by:
        takeWhile in interface SortedSet<T>
        Specified by:
        takeWhile in interface Traversable<T>
        Parameters:
        predicate - A condition tested subsequently for the contained elements.
        Returns:
        a new instance consisting of all elements before the first one which does not satisfy the given predicate.
      • addAll

        public BitSet<T> addAll​(java.lang.Iterable<? extends T> elements)
        Description copied from interface: Set
        Adds all of the given elements to this set, if not already contained.
        Specified by:
        addAll in interface BitSet<T>
        Specified by:
        addAll in interface Set<T>
        Specified by:
        addAll in interface SortedSet<T>
        Parameters:
        elements - The elements to be added.
        Returns:
        A new set containing all elements of this set and the given elements, if not already contained.
      • contains

        public boolean contains​(T t)
        Description copied from interface: Value
        Shortcut for exists(e -> Objects.equals(e, element)), tests if the given element is contained.
        Specified by:
        contains in interface Set<T>
        Specified by:
        contains in interface Value<T>
        Parameters:
        t - An Object of type A, may be null.
        Returns:
        true, if element is contained, false otherwise.
      • iterator

        public Iterator<T> iterator()
        Description copied from interface: Traversable
        An iterator by means of head() and tail(). Subclasses may want to override this method.
        Specified by:
        iterator in interface java.lang.Iterable<T>
        Specified by:
        iterator in interface Set<T>
        Specified by:
        iterator in interface Traversable<T>
        Specified by:
        iterator in interface Value<T>
        Returns:
        A new Iterator of this Traversable elements.
      • take

        public BitSet<T> take​(int n)
        Description copied from interface: Traversable
        Takes the first n elements of this or all elements, if this length < n.

        The result is equivalent to sublist(0, max(0, min(length(), n))) but does not throw if n < 0 or n > length().

        In the case of n < 0 the empty instance is returned, in the case of n > length() this is returned.

        Specified by:
        take in interface BitSet<T>
        Specified by:
        take in interface Set<T>
        Specified by:
        take in interface SortedSet<T>
        Specified by:
        take in interface Traversable<T>
        Parameters:
        n - The number of elements to take.
        Returns:
        A new instance consisting of the first n elements of this or all elements, if this has less than n elements.
      • takeRight

        public BitSet<T> takeRight​(int n)
        Description copied from interface: Traversable
        Takes the last n elements of this or all elements, if this length < n.

        The result is equivalent to sublist(max(0, min(length(), length() - n)), n), i.e. takeRight will not throw if n < 0 or n > length().

        In the case of n < 0 the empty instance is returned, in the case of n > length() this is returned.

        Specified by:
        takeRight in interface BitSet<T>
        Specified by:
        takeRight in interface Set<T>
        Specified by:
        takeRight in interface SortedSet<T>
        Specified by:
        takeRight in interface Traversable<T>
        Parameters:
        n - The number of elements to take.
        Returns:
        A new instance consisting of the last n elements of this or all elements, if this has less than n elements.
      • remove

        public BitSet<T> remove​(T t)
        Description copied from interface: Set
        Removes a specific element from this set, if present.
        Specified by:
        remove in interface BitSet<T>
        Specified by:
        remove in interface Set<T>
        Specified by:
        remove in interface SortedSet<T>
        Parameters:
        t - The element to be removed from this set.
        Returns:
        A new set consisting of the elements of this set, without the given element.
      • removeAll

        public BitSet<T> removeAll​(java.lang.Iterable<? extends T> elements)
        Description copied from interface: Set
        Removes all of the given elements from this set, if present.
        Specified by:
        removeAll in interface BitSet<T>
        Specified by:
        removeAll in interface Set<T>
        Specified by:
        removeAll in interface SortedSet<T>
        Parameters:
        elements - The elements to be removed from this set.
        Returns:
        A new set consisting of the elements of this set, without the given elements.
      • toString

        public java.lang.String toString()
        Description copied from interface: Value
        Clarifies that values have a proper toString() method implemented.

        See Object.toString().

        Specified by:
        toString in interface Value<T>
        Overrides:
        toString in class java.lang.Object
        Returns:
        A String representation of this object
      • equals

        public boolean equals​(java.lang.Object o)
        Description copied from interface: Traversable
        In Vavr there are four basic classes of collections:
        • Seq (sequential elements)
        • Set (distinct elements)
        • Map (indexed elements)
        • Multimap (indexed collections)
        Two collection instances of these classes are equal if and only if both collections
        • belong to the same basic collection class (Seq, Set, Map or Multimap)
        • contain the same elements
        • have the same element order, if the collections are of type Seq
        Two Map/Multimap elements, resp. entries, (key1, value1) and (key2, value2) are equal, if the keys are equal and the values are equal.

        Notes:

        • No collection instance equals null, e.g. Queue(1) not equals null.
        • Nulls are allowed and handled as expected, e.g. List(null, 1) equals Stream(null, 1) and HashMap((null, 1)) equals LinkedHashMap((null, 1)).
        • The element order is taken into account for Seq only. E.g. List(null, 1) not equals Stream(1, null) and HashMap((null, 1), ("a", null)) equals LinkedHashMap(("a", null), (null, 1)). The reason is, that we do not know which implementations we compare when having two instances of type Map, Multimap or Set (see Liskov Substitution Principle).
        • Other collection classes are equal if their types are equal and their elements are equal (in iteration order).
        • Iterator equality is defined to be object reference equality.
        Specified by:
        equals in interface Traversable<T>
        Specified by:
        equals in interface Value<T>
        Overrides:
        equals in class java.lang.Object
        Parameters:
        o - an object, may be null
        Returns:
        true, if this collection equals the given object according to the rules described above, false otherwise.
      • hashCode

        public int hashCode()
        Description copied from interface: Traversable
        Returns the hash code of this collection.
        We distinguish between two types of hashes, those for collections with predictable iteration order (like Seq) and those with arbitrary iteration order (like Set, Map and Multimap).
        In all cases the hash of an empty collection is defined to be 1.
        Collections with predictable iteration order are hashed as follows:
        
         int hash = 1;
         for (T t : this) { hash = hash * 31 + Objects.hashCode(t); }
         
        Collections with arbitrary iteration order are hashed in a way such that the hash of a fixed number of elements is independent of their iteration order.
        
         int hash = 1;
         for (T t : this) { hash += Objects.hashCode(t); }
         
        Please note that the particular hashing algorithms may change in a future version of Vavr.
        Generally, hash codes of collections aren't cached in Vavr (opposed to the size/length). Storing hash codes in order to reduce the time complexity would increase the memory footprint. Persistent collections are built upon tree structures, it allows us to implement efficient memory sharing. A drawback of tree structures is that they make it necessary to store collection attributes at each tree node (read: element).
        The computation of the hash code is linear in time, i.e. O(n). If the hash code of a collection is re-calculated often, e.g. when using a List as HashMap key, we might want to cache the hash code. This can be achieved by simply using a wrapper class, which is not included in Vavr but could be implemented like this:
        public final class Hashed<K> {
        
             private final K key;
             private final Lazy<Integer> hashCode;
        
             public Hashed(K key) {
                 this.key = key;
                 this.hashCode = Lazy.of(() -> Objects.hashCode(key));
             }
        
             public K key() {
                 return key;
             }
        
             &#64;Override
             public boolean equals(Object o) {
                 if (o == key) {
                     return true;
                 } else if (key != null && o instanceof Hashed) {
                     final Hashed that = (Hashed) o;
                     return key.equals(that.key);
                 } else {
                     return false;
                 }
             }
        
             &#64;Override
             public int hashCode() {
                 return hashCode.get();
             }
        
             &#64;Override
             public String toString() {
                 return "Hashed(" + (key == null ? "null" : key.toString()) + ")";
             }
         }
        Specified by:
        hashCode in interface Traversable<T>
        Specified by:
        hashCode in interface Value<T>
        Overrides:
        hashCode in class java.lang.Object
        Returns:
        The hash code of this collection