EDIT

public class CdmFilterablePagingProvider<T extends IdentifiableEntity, V extends T> implements FilterablePagingProvider<V>, FilterableCountProvider {

    private Class<V> type = null;

        this(service, null);

     * With defaults for matchMode = MatchMode.ANYWHERE and orderHints = OrderHint.ORDER_BY_TITLE_CACHE

     *

    public CdmFilterablePagingProvider(IIdentifiableEntityService<T> service, Class<V> type) {

        super();

        this.type = type;

        this.service = service;

    }

        this(service, null, matchMode, orderHints);

    }

    public <S extends T> CdmFilterablePagingProvider(IIdentifiableEntityService<T> service, Class<V> type, MatchMode matchMode, List<OrderHint> orderHints) {

        this.type = type;

    public List<V> findEntities(int firstRow, String filter) {

        Pager<V> page = (Pager<V>) service.findByTitle(

                type,

        Pager<V> page = (Pager<V>) service.findByTitle(

                type,

import org.vaadin.viritin.fields.LazyComboBox;

import com.vaadin.ui.Button;

    private LazyComboBox<Person> personSelect = new LazyComboBox<Person>(Person.class);

    private Button personSelectConfirmButton = new Button("OK");

    private Button newPersonButton = new Button("New");

    private CssLayout selectOrNewContainer = new CssLayout();

        // select existing or create new person

        addStyledComponents(personSelect, personSelectConfirmButton, newPersonButton);

        personSelect.addValueChangeListener(e -> {

            if(personSelect.getValue() != null){

                personSelectConfirmButton.setEnabled(true);

            }

        });

        personSelectConfirmButton.setEnabled(false);

        personSelectConfirmButton.addClickListener(e -> {

            setValue(personSelect.getValue());

        });

        selectOrNewContainer.addComponents(personSelect, personSelectConfirmButton, newPersonButton);

        newPersonButton.addClickListener(e -> {

            setValue(Person.NewInstance());

        });

        // edit person

        selectOrNewContainer.setWidth(100, Unit.PERCENTAGE);

        personSelect.setWidthUndefined();

        root.addComponent(selectOrNewContainer);

        updateVisibilities(getValue());

//        if(person == null){

//            person = Person.NewInstance();

//        }

        updateVisibilities(newValue);

    }

    /**

     *

     */

    private void updateVisibilities(Person person) {

        selectOrNewContainer.setVisible(person == null);

        detailsContainer.setVisible(person != null);

        unlockSwitch.setVisible(person != null);

        cacheField.setVisible(person != null);

    /**

     * @return the personSelect

     */

    public LazyComboBox<Person> getPersonSelect() {

        return personSelect;

    }

    /**

     * @param personSelect the personSelect to set

     */

    public void setPersonSelect(LazyComboBox<Person> personSelect) {

        this.personSelect = personSelect;

    }

    /**

     * @return the allowNewEmptyEntity

     */

    public boolean isAllowNewEmptyEntity() {

        return allowNewEmptyEntity;

    }

    /**

     * @param allowNewEmptyEntity the allowNewEmptyEntity to set

     */

    public void setAllowNewEmptyEntity(boolean allowNewEmptyEntity) {

        this.allowNewEmptyEntity = allowNewEmptyEntity;

    }

import org.vaadin.viritin.fields.LazyComboBox;

import eu.etaxonomy.cdm.model.agent.AgentBase;

import eu.etaxonomy.cdm.service.CdmFilterablePagingProvider;

import eu.etaxonomy.cdm.vaadin.event.ToOneRelatedEntityReloader;

import eu.etaxonomy.cdm.vaadin.util.CdmTitleCacheCaptionGenerator;

import eu.etaxonomy.cdm.vaadin.view.name.CachingPresenter;

import eu.etaxonomy.vaadin.component.EntityFieldInstantiator;

    private LazyComboBox<TeamOrPersonBase> teamOrPersonSelect = new LazyComboBox<TeamOrPersonBase>(TeamOrPersonBase.class);

    private Button selectConfirmButton = new Button("OK");

    private CdmFilterablePagingProvider<AgentBase, Person> pagingProviderPerson;

        teamOrPersonSelect.setCaptionGenerator(new CdmTitleCacheCaptionGenerator<TeamOrPersonBase>());

        addStyledComponent(teamOrPersonSelect);

        addStyledComponents(selectConfirmButton, removeButton, personButton, teamButton);

        teamOrPersonSelect.addValueChangeListener(e -> {

            selectConfirmButton.setEnabled(teamOrPersonSelect.getValue() != null);

        });

        teamOrPersonSelect.setWidthUndefined();

        selectConfirmButton.setEnabled(teamOrPersonSelect.getValue() != null);

        selectConfirmButton.addClickListener(e -> {

            setValue(teamOrPersonSelect.getValue());

            updateToolBarButtonStates();

        });

        toolBar.addComponents(teamOrPersonSelect, selectConfirmButton,  removeButton, personButton, teamButton);

        teamOrPersonSelect.setVisible(val == null);

        selectConfirmButton.setVisible(val == null);

        removeButton.setVisible(val != null);

        if(newValue != null) {

            if(Person.class.isAssignableFrom(newValue.getClass())){

                // value is a Person:

                compositeWrapper.addComponent(personField);

                personField.setValue((Person) newValue);

                personField.registerParentFieldGroup(fieldGroup);

            }

            else if(Team.class.isAssignableFrom(newValue.getClass())){

                // otherwise it a Team

                compositeWrapper.addComponents(titleField, nomenclaturalTitleField, personsListEditor);

                titleField.bindTo(fieldGroup, "titleCache", "protectedTitleCache");

                nomenclaturalTitleField.bindTo(fieldGroup, "nomenclaturalTitle", "protectedNomenclaturalTitleCache");

                fieldGroup.setItemDataSource(new BeanItem<Team>((Team)newValue));

                fieldGroup.bind(personsListEditor, "teamMembers"); // here personField is set readonly since setTeamMembers does not exist

                personsListEditor.setReadOnly(false); // fixing the readonly state

                personsListEditor.registerParentFieldGroup(fieldGroup);

            } else {

                setComponentError(new UserError("TeamOrPersonField Error: Unsupported value type: " + newValue.getClass().getName()));

            }

    /**

     * @return the teamOrPersonSelect

     */

    public LazyComboBox<TeamOrPersonBase> getTeamOrPersonSelect() {

        return teamOrPersonSelect;

    }

    public void setFilterableTeamPagingProvider(CdmFilterablePagingProvider<AgentBase, TeamOrPersonBase> pagingProvider, CachingPresenter cachingPresenter){

        teamOrPersonSelect.loadFrom(pagingProvider, pagingProvider, pagingProvider.getPageSize());

        ToOneRelatedEntityReloader<TeamOrPersonBase> teamOrPersonReloader = new ToOneRelatedEntityReloader<TeamOrPersonBase>(teamOrPersonSelect, cachingPresenter);

        teamOrPersonSelect.addValueChangeListener(teamOrPersonReloader );

    }

    public void setFilterablePersonPagingProvider(CdmFilterablePagingProvider<AgentBase, Person> pagingProvider, CachingPresenter cachingPresenter){

        teamOrPersonSelect.addValueChangeListener(new ToOneRelatedEntityReloader<TeamOrPersonBase>(teamOrPersonSelect, cachingPresenter));

        personsListEditor.setEntityFieldInstantiator(new EntityFieldInstantiator<PersonField>() {

            @Override

            public PersonField createNewInstance() {

                PersonField f = new PersonField();

                f.setAllowNewEmptyEntity(true); // otherwise new entities can not be added to the personsListEditor

                f.getPersonSelect().loadFrom(pagingProvider, pagingProvider, pagingProvider.getPageSize());

                f.getPersonSelect().setCaptionGenerator(new CdmTitleCacheCaptionGenerator<Person>());

                f.getPersonSelect().addValueChangeListener(new ToOneRelatedEntityReloader<Person>(f.getPersonSelect(), cachingPresenter));

                return f;

            }

        });

    }

import com.vaadin.ui.Field;

    Field<CDM>  toOneRelatedEntityField;

    public ToOneRelatedEntityReloader( Field<CDM> toOneRelatedEntityField, CachingPresenter entityCache){

            } else if(

                    // pure object comparison is not reliable since the entity may have been changed

                    cachedEntity.getId() == value.getId() && cachedEntity.getClass() == value.getClass()){

            CdmFilterablePagingProvider<Collection, Collection> collectionPagingProvider = new CdmFilterablePagingProvider<Collection, Collection>(getRepo().getCollectionService());

            CdmFilterablePagingProvider<Reference, Reference> referencePagingProvider = new CdmFilterablePagingProvider<Reference, Reference>(getRepo().getReferenceService());

import eu.etaxonomy.cdm.model.agent.AgentBase;

import eu.etaxonomy.cdm.model.agent.Person;

import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;

        CdmFilterablePagingProvider<AgentBase, TeamOrPersonBase> termOrPersonPagingProvider = new CdmFilterablePagingProvider<AgentBase, TeamOrPersonBase>(getRepo().getAgentService(), TeamOrPersonBase.class);

        CdmFilterablePagingProvider<AgentBase, Person> personPagingProvider = new CdmFilterablePagingProvider<AgentBase, Person>(getRepo().getAgentService(), Person.class);

        getView().getCombinationAuthorshipField().setFilterableTeamPagingProvider(termOrPersonPagingProvider, this);

        getView().getCombinationAuthorshipField().setFilterablePersonPagingProvider(personPagingProvider, this);

        getView().getExCombinationAuthorshipField().setFilterableTeamPagingProvider(termOrPersonPagingProvider, this);

        getView().getExCombinationAuthorshipField().setFilterablePersonPagingProvider(personPagingProvider, this);

        getView().getBasionymAuthorshipField().setFilterableTeamPagingProvider(termOrPersonPagingProvider, this);

        getView().getBasionymAuthorshipField().setFilterablePersonPagingProvider(personPagingProvider, this);

        getView().getExBasionymAuthorshipField().setFilterableTeamPagingProvider(termOrPersonPagingProvider, this);

        getView().getExBasionymAuthorshipField().setFilterablePersonPagingProvider(personPagingProvider, this);

        CdmFilterablePagingProvider<Reference, Reference> referencePagingProvider = new CdmFilterablePagingProvider<Reference, Reference>(getRepo().getReferenceService());

        CdmFilterablePagingProvider<TaxonName, TaxonName> namePagingProvider = new CdmFilterablePagingProvider<TaxonName, TaxonName>(getRepo().getNameService());

    /**

     * {@inheritDoc}

     */

    @Override

    public int getWindowPixelWidth() {

        return 700;

    }

        grid.setSizeFull();

    /**

     * @return the exBasionymAuthorshipField

     */

    @Override

    public TeamOrPersonField getExBasionymAuthorshipField() {

        return exBasionymAuthorshipField;

    }

    /**

     * @return the basionymAuthorshipField

     */

    @Override

    public TeamOrPersonField getBasionymAuthorshipField() {

        return basionymAuthorshipField;

    }

    /**

     * @return the combinationAuthorshipField

     */

    @Override

    public TeamOrPersonField getCombinationAuthorshipField() {

        return combinationAuthorshipField;

    }

    /**

     * @return the exCombinationAuthorshipField

     */

    @Override

    public TeamOrPersonField getExCombinationAuthorshipField() {

        return exCombinationAuthorshipField;

    }

import eu.etaxonomy.cdm.vaadin.component.common.TeamOrPersonField;

    /**

     * @return the exBasionymAuthorshipField

     */

    public TeamOrPersonField getExBasionymAuthorshipField();

    /**

     * @return the basionymAuthorshipField

     */

    public TeamOrPersonField getBasionymAuthorshipField();

    /**

     * @return the combinationAuthorshipField

     */

    public TeamOrPersonField getCombinationAuthorshipField();

    /**

     * @return the exCombinationAuthorshipField

     */

    public TeamOrPersonField getExCombinationAuthorshipField();

        CdmFilterablePagingProvider<TaxonName, TaxonName> pagingProvider = new CdmFilterablePagingProvider<TaxonName, TaxonName>(

        CdmFilterablePagingProvider<Reference, Reference> pagingProvider = new CdmFilterablePagingProvider<Reference, Reference>(

                //.peek( f -> System.out.println("###> " + f.getCaption() + ": " + f.getValue()))

        // setDeepReadOnly(readOnly, getContent());

    @Override

    public String toString(){

        return this.getClass().getSimpleName() + ": " +

                ( getValue() != null ? getValue() : "null");

    }

/**

* Copyright (C) 2017 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.vaadin.component;

/**

 * @author a.kohlbecker

 * @since Dec 11, 2017

 *

 */

public abstract class EntityFieldInstantiator<F> {

    public abstract F createNewInstance();

}

    Boolean valueInitiallyWasNull = null;

    private EntityFieldInstantiator<F> entityFieldInstantiator;

        List<V> nestedValues = getValueFromNestedFields();

        if(isOrderedCollection){

        } else {

        }

     * update Value is only called in turn of UI changes like adding, removing, swapping rows

    private void updateValue() {

        setInternalValue(beanList, false);

        setInternalValue(newValue, true);

    }

    protected void setInternalValue(List<V> newValue, boolean doUpdateFields) {

        super.setInternalValue(newValue);

        if(valueInitiallyWasNull == null){

            valueInitiallyWasNull = newValue == null;

        }

        createFieldsForData();

    }

    private void createFieldsForData(){

        grid.removeAllComponents();

        grid.setRows(1);

        List<V> data = getValue();

        if(data == null || data.isEmpty()){

        } else {

            int row = 0;

            for(V val : data){

                row = addNewRow(row, val);

            }

    }

    /**

     * Obtains the List of values directly from the nested fields and ignores the

     * value of the <code>propertyDataSource</code>. This is useful when the ToManyRelatedEntitiesListSelect

     * is operating on a transient field, in which case the property is considered being read only by vaadin

     * so that the commit is doing nothing.

     *

     * See also {@link AbstractCdmEditorPresenter#handleTransientProperties(DTO bean)}

     *

     * @return

     */

    public List<V> getValueFromNestedFields() {

        List<V> nestedValues = new ArrayList<>();

        for(F f : getNestedFields()) {

            logger.trace(

                    String.format("getValueFromNestedFields() - %s:%s",

                       f != null ? f.getClass().getSimpleName() : "null",

                       f != null && f.getValue() != null ? f.getValue() : "null"

            ));

            V value = f.getValue();

            if(f != null /*&& value != null*/){

                nestedValues.add(f.getValue());

            }

         }

        return nestedValues;

            field.addValueChangeListener(e -> {

                updateValue();

            });

        F field;

        if(entityFieldInstantiator != null){

            field = entityFieldInstantiator.createNewInstance();

        } else {

            field = fieldType.newInstance();

        }

        /*

        List<V> list = (List<V>) getPropertyDataSource().getValue();

        Person p = Person.NewInstance();

        p.setTitleCache("Hacky", true);

        list.add((V) p);

        List<V> clonedList = new ArrayList<>(list);

        list.clear();

        for(V value : clonedList){

            if(value != null){

                list.add(value);

            }

        }

        //

        if(getValue().isEmpty() && valueInitiallyWasNull){

            setPropertyDataSource(null);

        }

         */

    /**

     * @return the enityFieldInstantiator

     */

    public EntityFieldInstantiator<F> getEntityFieldInstantiator() {

        return entityFieldInstantiator;

    }

    /**

     * @param enityFieldInstantiator the enityFieldInstantiator to set

     */

    public void setEntityFieldInstantiator(EntityFieldInstantiator<F> entityFieldInstantiator) {

        this.entityFieldInstantiator = entityFieldInstantiator;

    }

import eu.etaxonomy.cdm.cache.CdmEntityCache;

import eu.etaxonomy.cdm.cache.EntityCache;

import eu.etaxonomy.cdm.vaadin.view.name.CachingPresenter;

public abstract class AbstractCdmEditorPresenter<DTO extends CdmBase, V extends ApplicationView<?>> extends AbstractEditorPresenter<DTO, V>

    implements CachingPresenter {

    private CdmEntityCache cache = null;

        DTO cdmEntitiy;

            cdmEntitiy = loadCdmEntityById(integerID);

            cdmEntitiy = loadCdmEntityById(null);

        cache = new CdmEntityCache(cdmEntitiy);

        return cdmEntitiy;

    /**

     * {@inheritDoc}

     */

    @Override

    public EntityCache getCache() {

        if(((AbstractPopupEditor)getView()).isBeanLoaded()){

            return cache;

        } else {

            return null;

        }

    }