Package com.google.gwt.editor.client.adapters

## Class ListEditor<T,​E extends Editor<? super T>>

- java.lang.Object
- - com.google.gwt.editor.client.adapters.ListEditor<T,​E>

- Type Parameters:
    `T` - The type of data being managed
    `E` - The type of Editor
  All Implemented Interfaces:
    `CompositeEditor<java.util.List<T>,​T,​E>`, `Editor<java.util.List<T>>`, `HasEditorDelegate<java.util.List<T>>`, `ValueAwareEditor<java.util.List<T>>`
  Direct Known Subclasses:
    `HasDataEditor`

      public class ListEditor<T,​E extends Editor<? super T>>
      extends java.lang.Object
      implements CompositeEditor<java.util.List<T>,​T,​E>

  Manages a list of objects and their associated Editors.

  The ListEditor will have no backing list until `setValue(List)` is called with a non-null value.

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface com.google.gwt.editor.client.CompositeEditor

      `CompositeEditor.EditorChain<C,​E extends Editor<? super C>>`

    - ### Nested classes/interfaces inherited from interface com.google.gwt.editor.client.Editor

      `Editor.Ignore, Editor.Path`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor | Description
    --- | --- | ---
    `protected` | `ListEditor​(EditorSource<E> source)` | Create a ListEditor backed by an EditorSource.

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `E` | `createEditorForTraversal()` | Creates a temporary sub-Editor to use for traversal.
    `void` | `flush()` | Indicates that the Editor cycle is finished.
    `java.util.List<E>` | `getEditors()` | Returns an unmodifiable, live view of the Editors managed by the ListEditor.
    `java.util.List<T>` | `getList()` | Returns a live view of the ListEditor's backing data.
    `java.lang.String` | `getPathElement​(E subEditor)` | Used to implement `EditorDelegate.getPath()` for the component Editors.
    `static <T,​E extends Editor<? super T>> ListEditor<T,​E>` | `of​(EditorSource<E> source)` | Create a ListEditor backed by an EditorSource.
    `void` | `onPropertyChange​(java.lang.String... paths)` | Notifies the Editor that one or more value properties have changed.
    `void` | `setDelegate​(EditorDelegate<java.util.List<T>> delegate)` | Called by the EditorDriver to provide access to the EditorDelegate the Editor is peered with.
    `void` | `setEditorChain​(CompositeEditor.EditorChain<T,​E> chain)` | Called by the Editor framework to provide the `CompositeEditor.EditorChain`.
    `void` | `setValue​(java.util.List<T> value)` | Sets the ListEditor's backing data.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### ListEditor

          protected ListEditor​(EditorSource<E> source)

      Create a ListEditor backed by an EditorSource.
      Parameters:
        `source` - the EditorSource which will create sub-Editors

  - ### Method Detail

    - #### of

          public static <T,​E extends Editor<? super T>> ListEditor<T,​E> of​(EditorSource<E> source)

      Create a ListEditor backed by an EditorSource.
      Type Parameters:
        `T` - The type of data being managed
        `E` - The type of Editor
      Parameters:
        `source` - the EditorSource which will create sub-Editors
      Returns:
        a new instance of ListEditor

    - #### createEditorForTraversal

          public E createEditorForTraversal()

      Creates a temporary sub-Editor to use for traversal.
      Specified by:
        `createEditorForTraversal` in interface `CompositeEditor<java.util.List<T>,​T,​E extends Editor<? super T>>`
      Returns:
        an `Editor` of type E

    - #### flush

          public void flush()

      Description copied from interface: `ValueAwareEditor`
      Indicates that the Editor cycle is finished. This method will be called in a depth-first order by the EditorDriver, so Editors do not generally need to flush their sub-editors.
      Specified by:
        `flush` in interface `ValueAwareEditor<T>`

    - #### getEditors

          public java.util.List<E> getEditors()

      Returns an unmodifiable, live view of the Editors managed by the ListEditor.

      The returned list will be live until the next call to `setValue(List)` and shouldn't be used after that. Editors might (or might not) be reused after a call to `setValue(List)`.

      If there is no backing list, an empty list will be returned.

      Returns:
        a List of `Editors` of type E

    - #### getList

          public java.util.List<T> getList()

      Returns a live view of the ListEditor's backing data.

      The structure of the List may be mutated arbitrarily, subject to the limitations of the backing List, but the elements themselves should not be mutated except through `getEditors()` to avoid data inconsistency.

      Returns null if there is no backing list, and edits cannot be made.

           ListEditor<Foo, MyFooEditor> listEditor = ListEditor.of(...);
           listEditor.setValue(listOfFoo); // Usually called by EditorDriver
           listEditor.getList().set(1, new Foo());
           listEditor.getEditors().get(1).getFooFieldEditor().setValue(....);

      Returns:
        a live view of the ListEditor's backing data, or `null` if there is no backing list.

    - #### getPathElement

          public java.lang.String getPathElement​(E subEditor)

      Description copied from interface: `CompositeEditor`
      Used to implement `EditorDelegate.getPath()` for the component Editors.
      Specified by:
        `getPathElement` in interface `CompositeEditor<java.util.List<T>,​T,​E extends Editor<? super T>>`
      Parameters:
        `subEditor` - an instance of the Editor type previously passed into `CompositeEditor.EditorChain.attach(C, E)`
      Returns:
        the path element as a String

    - #### onPropertyChange

          public void onPropertyChange​(java.lang.String... paths)

      Description copied from interface: `ValueAwareEditor`
      Notifies the Editor that one or more value properties have changed. Not all backing services support property-based notifications.
      Specified by:
        `onPropertyChange` in interface `ValueAwareEditor<T>`
      Parameters:
        `paths` - a list of String paths

    - #### setDelegate

          public void setDelegate​(EditorDelegate<java.util.List<T>> delegate)

      Description copied from interface: `HasEditorDelegate`
      Called by the EditorDriver to provide access to the EditorDelegate the Editor is peered with.
      Specified by:
        `setDelegate` in interface `HasEditorDelegate<T>`
      Parameters:
        `delegate` - an `EditorDelegate` of type T

    - #### setEditorChain

          public void setEditorChain​(CompositeEditor.EditorChain<T,​E> chain)

      Description copied from interface: `CompositeEditor`
      Called by the Editor framework to provide the `CompositeEditor.EditorChain`.
      Specified by:
        `setEditorChain` in interface `CompositeEditor<java.util.List<T>,​T,​E extends Editor<? super T>>`
      Parameters:
        `chain` - an `CompositeEditor.EditorChain` instance

    - #### setValue

          public void setValue​(java.util.List<T> value)

      Sets the ListEditor's backing data.

      If a null is passed in, the ListEditor will have no backing list and edits cannot be made.

      Specified by:
        `setValue` in interface `ValueAwareEditor<T>`
      Parameters:
        `value` - a List of data objects of type T