Package com.exonum.binding.core.storage.indices

Class ListIndexProxy<E>

  • Type Parameters:
    E - the type of elements in this list
    All Implemented Interfaces:
    ListIndex<E>, StorageIndex, Iterable<E>
    public final class ListIndexProxy<E>
extends AbstractNativeProxy
implements ListIndex<E>
    A list index proxy is a contiguous list of elements. Elements may be added to or removed from the end of the list only.

    This list implementation does not permit null elements.

    The "destructive" methods of the list, i.e., those that change its contents, are specified to throw UnsupportedOperationException if this list has been created with a read-only database access.

    All method arguments are non-null by default.

    This class is not thread-safe and and its instances shall not be shared between threads.

    When the access goes out of scope, this list is destroyed. Subsequent use of the closed list is prohibited and will result in IllegalStateException.

    See Also:
    Access

    • Method Detail

      • newInstance

        public static <E> ListIndexProxy<E> newInstance​(IndexAddress address,
                                                AbstractAccess access,
                                                com.exonum.binding.common.serialization.Serializer<E> serializer)
        Creates a new ListIndexProxy.

        Warning: do not invoke this method from service code, use Access.getList(IndexAddress, Serializer).

        Type Parameters:
        E - the type of elements in this list
        Parameters:
        address - an index address
        access - a database access. Must be valid. If an access is read-only, "destructive" operations are not permitted.
        serializer - a serializer of elements
        Throws:
        IllegalStateException - if the access is not valid
        IllegalArgumentException - if the name is empty
        See Also:
        StandardSerializers

      • add

        public final void add​(T e)
        Description copied from interface: ListIndex
        Adds a new element to the end of the list.
        Specified by:
        add in interface ListIndex<T>
        Parameters:
        e - an element to append to the list

      • addAll

        public void addAll​(Collection<? extends T> elements)
        Description copied from interface: ListIndex
        Adds all elements from the specified collection to this list.

        If the collection contains an invalid element, this list is not modified.

        Specified by:
        addAll in interface ListIndex<T>
        Parameters:
        elements - elements to add to this list

      • set

        public final void set​(long index,
                      T e)
        Description copied from interface: ListIndex
        Replaces the element at the given index of the list with the specified element.
        Specified by:
        set in interface ListIndex<T>
        Parameters:
        index - an index of the element to replace
        e - an element to add

      • get

        public final T get​(long index)
        Description copied from interface: ListIndex
        Returns the element at the given index.
        Specified by:
        get in interface ListIndex<T>
        Parameters:
        index - an index of the element to return
        Returns:
        an element at the given index

      • getLast

        public final T getLast()
        Description copied from interface: ListIndex
        Returns the last element of the list.
        Specified by:
        getLast in interface ListIndex<T>
        Returns:
        the last element of the list

      • removeLast

        public T removeLast()
        Description copied from interface: ListIndex
        Removes the last element of the list and returns it.
        Specified by:
        removeLast in interface ListIndex<T>
        Returns:
        the last element of the list.

      • truncate

        public void truncate​(long newSize)
        Description copied from interface: ListIndex
        Truncates the list, reducing its size to newSize.

        If newSize < size(), keeps the first newSize elements, removing the rest. If newSize >= size(), has no effect.

        Specified by:
        truncate in interface ListIndex<T>
        Parameters:
        newSize - the maximum number of elements to keep

      • clear

        public final void clear()
        Description copied from interface: ListIndex
        Clears the list.
        Specified by:
        clear in interface ListIndex<T>

      • isEmpty

        public final boolean isEmpty()
        Description copied from interface: ListIndex
        Returns true if the list is empty, false — otherwise.
        Specified by:
        isEmpty in interface ListIndex<T>

      • size

        public final long size()
        Description copied from interface: ListIndex
        Returns the number of elements in the list.
        Specified by:
        size in interface ListIndex<T>

      • stream

        public Stream<T> stream()
        Description copied from interface: ListIndex
        Returns a stream of elements in this list. The returned stream is fail-fast and late-binding. The stream can be used as long as the source list is valid.
        Specified by:
        stream in interface ListIndex<T>

      • getAddress

        public IndexAddress getAddress()
        Description copied from interface: StorageIndex
        Returns the index address: its identifier in the database.

        Please note that the implementations may return either relative or absolute address. The address is not required to be equal to the one passed to the index constructor.

        Specified by:
        getAddress in interface StorageIndex