EDIT

/**

* Copyright (C) 2018 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.cdm.vaadin.model.name;

import java.io.Serializable;

import eu.etaxonomy.cdm.model.common.RelationshipBase.Direction;

import eu.etaxonomy.cdm.model.name.NameRelationship;

import eu.etaxonomy.cdm.model.name.NameRelationshipType;

import eu.etaxonomy.cdm.model.name.TaxonName;

import eu.etaxonomy.cdm.model.reference.Reference;

/**

 * @author a.kohlbecker

 * @since May 3, 2018

 *

 */

public class NameRelationshipDTO implements Serializable {

    private static final long serialVersionUID = 966322755160849163L;

    NameRelationship nameRel;

    TaxonName otherName;

    NameRelationshipType type;

    Direction direction;

    Reference citation;

    String citationMicroReference;

    String ruleConsidered;

    /**

     * @param entity

     */

    public NameRelationshipDTO(Direction direction, NameRelationshipType type) {

        this.direction = direction;

        this.type = type;

    }

    public NameRelationshipDTO(Direction direction, NameRelationship nameRel) {

        this.direction = direction;

        otherName = otherNameFrom(nameRel);

        type = nameRel.getType();

        citation = nameRel.getCitation();

        citationMicroReference = nameRel.getCitationMicroReference();

        ruleConsidered = nameRel.getRuleConsidered();

    }

    /**

     * @return

     */

    protected TaxonName otherNameFrom(NameRelationship nameRel) {

        return this.direction.equals(Direction.relatedTo) ?  nameRel.getFromName() : nameRel.getToName();

    }

    protected TaxonName thisNameFrom(NameRelationship nameRel) {

        return this.direction.equals(Direction.relatedTo) ?  nameRel.getToName() : nameRel.getFromName();

    }

    /**

     * @return the otherName

     */

    public TaxonName getOtherName() {

        return otherName;

    }

    /**

     * @param otherName the otherName to set

     */

    public void setOtherName(TaxonName otherName) {

        this.otherName = otherName;

    }

    /**

     * @return the type

     */

    public NameRelationshipType getType() {

        return type;

    }

    /**

     * @param type the type to set

     */

    public void setType(NameRelationshipType type) {

        this.type = type;

    }

    /**

     * @return the direction

     */

    public Direction getDirection() {

        return direction;

    }

    /**

     * @param direction the direction to set

     */

    public void setDirection(Direction direction) {

        this.direction = direction;

    }

    /**

     * @return the citation

     */

    public Reference getCitation() {

        return citation;

    }

    /**

     * @param citation the citation to set

     */

    public void setCitation(Reference citation) {

        this.citation = citation;

    }

    /**

     * @return the citationMicroReference

     */

    public String getCitationMicroReference() {

        return citationMicroReference;

    }

    /**

     * @param citationMicroReference the citationMicroReference to set

     */

    public void setCitationMicroReference(String citationMicroReference) {

        this.citationMicroReference = citationMicroReference;

    }

    /**

     * @return the ruleConsidered

     */

    public String getRuleConsidered() {

        return ruleConsidered;

    }

    /**

     * @param ruleConsidered the ruleConsidered to set

     */

    public void setRuleConsidered(String ruleConsidered) {

        this.ruleConsidered = ruleConsidered;

    }

}

import java.util.stream.Collectors;

import eu.etaxonomy.cdm.model.name.NameRelationship;

    private TaxonName persistedValidatedName;

    public NameRelationshipDTO getValidationFor() {

        NameRelationshipDTO nameRelDto  = null;

        NameRelationship validatingRelationship = validatingRelationship();

        if(validatingRelationship != null){

            nameRelDto = new NameRelationshipDTO(Direction.relatedTo, validatingRelationship);

            if(persistedValidatedName == null){

               persistedValidatedName = nameRelDto.getOtherName();

            }

        }

        return nameRelDto;

    }

    /**

     * @return

     */

    protected NameRelationship validatingRelationship() {

        Set<NameRelationship> toRelations = name.getRelationsToThisName();

        Set<NameRelationship> validatedNameRelations = toRelations.stream().filter(

                    nr -> nr.getType().equals(NameRelationshipType.VALIDATED_BY_NAME())

                ).collect(Collectors.toSet());

        if(validatedNameRelations.size() > 1){

            // TODO use non RuntimeException

            throw new RuntimeException("More than one validated name found.");

        } else if(validatedNameRelations.size() == 0) {

            return null;

        }

        return validatedNameRelations.iterator().next();

    }

    public void setValidationFor(NameRelationshipDTO nameRelDto) {

        if(nameRelDto != null && nameRelDto.getOtherName() == null){

            // treat as if there is no validation

            nameRelDto = null;

        }

        NameRelationship validatingRelationship = validatingRelationship();

        if(nameRelDto != null){

            // add or update ...

            if(validatingRelationship != null && persistedValidatedName != null && validatingRelationship.getFromName().equals(persistedValidatedName)){

                // validated name has not changed, so we can update the relation

                validatingRelationship.setCitation(nameRelDto.getCitation());

                validatingRelationship.setCitationMicroReference(nameRelDto.getCitationMicroReference());

                validatingRelationship.setRuleConsidered(nameRelDto.getRuleConsidered());

            } else {

                // need to remove the old relationship and to create a new one.

                // the actual removal will take place ....

                name.addRelationshipFromName(nameRelDto.getOtherName(), NameRelationshipType.VALIDATED_BY_NAME(),

                        nameRelDto.getCitation(), nameRelDto.getCitationMicroReference(), nameRelDto.getRuleConsidered());

                if(persistedValidatedName != null){

                    name.removeRelationWithTaxonName(persistedValidatedName, Direction.relatedTo, NameRelationshipType.VALIDATED_BY_NAME());

                }

            }

        } else {

            // remove ...

            if(persistedValidatedName != null && validatingRelationship != null){

                name.removeRelationWithTaxonName(persistedValidatedName, Direction.relatedTo, NameRelationshipType.VALIDATED_BY_NAME());

            }

        }

    }

        getView().getValidationField().getValidatedNameComboBox().getSelect().setCaptionGenerator(new CdmTitleCacheCaptionGenerator<TaxonName>());

        // reusing the basionymPagingProvider for the replaced synonyms to benefit from caching

        getView().getValidationField().getValidatedNameComboBox().loadFrom(basionymPagingProvider, basionymPagingProvider, basionymPagingProvider.getPageSize());

        getView().getValidationField().getValidatedNameComboBox().getSelect().addValueChangeListener(new ToOneRelatedEntityReloader<>(getView().getValidationField().getValidatedNameComboBox(), this));

        getView().getValidationField().getCitatonComboBox().getSelect().setCaptionGenerator(new CdmTitleCacheCaptionGenerator<Reference>());

        getView().getValidationField().getCitatonComboBox().loadFrom(referencePagingProvider, referencePagingProvider, referencePagingProvider.getPageSize());

        getView().getValidationField().getCitatonComboBox().getSelect().addValueChangeListener(new ToOneRelatedEntityReloader<>(getView().getValidationField().getCitatonComboBox(), this));

        ReloadableLazyComboBox<TaxonName> sourceField = (ReloadableLazyComboBox<TaxonName>)event.getSourceComponent();

        if(sourceField == getView().getValidationField().getValidatedNameComboBox().getSelect()){

            // validatedNameSourceField .. this is awkward, better use a map to correlate fields to popup editors!!!!

        } else {

            basionymSourceField = sourceField;

            basionymNamePopup = getNavigationManager().showInPopup(TaxonNamePopupEditor.class, getView());

            basionymNamePopup.grantToCurrentUser(EnumSet.of(CRUD.UPDATE, CRUD.DELETE));

            basionymNamePopup.withDeleteButton(true);

            getView().getModesActive().stream()

                    .filter(

                            m -> !TaxonNamePopupEditorMode.NOMENCLATURALREFERENCE_SECTION_EDITING_ONLY.equals(m))

                    .forEach(m -> basionymNamePopup.enableMode(m));

            basionymNamePopup.loadInEditor(event.getEntityUuid());

            basionymNamePopup.getBasionymToggle().setVisible(false);

        }

import eu.etaxonomy.cdm.model.common.RelationshipBase.Direction;

import eu.etaxonomy.cdm.model.name.NameRelationshipType;

import eu.etaxonomy.cdm.vaadin.model.name.NameRelationshipDTO;

import eu.etaxonomy.vaadin.component.NameRelationField;

    private final static int GRID_ROWS = 16;

    private NameRelationField validationField;

    private Boolean isInferredExCombinationAuthorship;

        basionymToggle.addValueChangeListener(e -> {

            updateAuthorshipFields();

        });

            updateAuthorshipFields();

        // --------------- Basionyms

        // --------------- ReplacedSynonyms

        // --------------- Validation

        row++;

        validationField = new NameRelationField("Validation", Direction.relatedTo, NameRelationshipType.VALIDATED_BY_NAME());

        validationField.setWidth(100, Unit.PERCENTAGE);

        ToOneRelatedEntityCombobox<TaxonName> validatedNameComboBox = validationField.getValidatedNameComboBox();

        validatedNameComboBox.addClickListenerAddEntity(e -> getViewEventBus().publish(

                this,

                new TaxonNameEditorAction(EditorActionType.ADD, null, validatedNameComboBox, this)

                ));

        validatedNameComboBox.addClickListenerAddEntity(e -> {

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

                getViewEventBus().publish(this,

                    new TaxonNameEditorAction(

                            EditorActionType.EDIT,

                            validatedNameComboBox.getValue().getUuid(),

                            validatedNameComboBox,

                            this)

                );

            }

        });

        ToOneRelatedEntityCombobox<Reference> validationCitatonComboBox = validationField.getCitatonComboBox();

        validationCitatonComboBox.addClickListenerAddEntity(e -> getViewEventBus().publish(

                this,

                new ReferenceEditorAction(EditorActionType.ADD, null, validationCitatonComboBox, this)

                ));

        validationCitatonComboBox.addClickListenerAddEntity(e -> {

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

                getViewEventBus().publish(this,

                    new ReferenceEditorAction(

                            EditorActionType.EDIT,

                            validationCitatonComboBox.getValue().getUuid(),

                            validationCitatonComboBox,

                            this)

                );

            }

        });

        addField(validationField, "validationFor", 0, row, 3, row);

        grid.setComponentAlignment(validationField, Alignment.TOP_RIGHT);

        row++;

        exCombinationAuthorshipField = new TeamOrPersonField("Ex-combination author(s)", TeamOrPersonBaseCaptionGenerator.CacheType.NOMENCLATURAL_TITLE);

        exCombinationAuthorshipField.setWidth(100,  Unit.PERCENTAGE);

        addField(exCombinationAuthorshipField, "exCombinationAuthorship", 0, row, GRID_COLS-1, row);

        // -----------------------------------------------------------------------------

        registerAdvancedModeComponents(exCombinationAuthorshipField);

    protected TeamOrPersonBase inferExCombinationAuthors() {

        NameRelationshipDTO nameRelationDTO = validationField.getValue();

        if(nameRelationDTO != null && nameRelationDTO.getOtherName() != null){

            TaxonName validatedName = nameRelationDTO.getOtherName();

            if(validatedName.getCombinationAuthorship() != null) {

                return validatedName.getCombinationAuthorship();

            } else if(validatedName.getNomenclaturalReference() != null){

                return validatedName.getNomenclaturalReference().getAuthorship();

            }

        }

        return null;

    }

        boolean showValidationSection = taxonNameDTO.getValidationFor() != null || taxonNameDTO.getExCombinationAuthorship() != null;

        validationToggle.setValue(showValidationSection);

        validationToggle.setReadOnly(showValidationSection);

//        validationField.setVisible(showValidation);

//        exCombinationAuthorshipField.setVisible(showExAuthors);

     * Updates all authorship fields if the an authorship field is empty this method attempts to infer the

     * authors from the related nomenclatural reference or taxon name.

     * <p>

     * Finally the {@link #updateFieldVisibility()} is invoked.

     *

        // ------------- Validation and ExCombinationAuthors

        isInferredExCombinationAuthorship = updateAuthorshipFieldData(

                taxonName.getExCombinationAuthorship(),

                inferExCombinationAuthors(),

                exCombinationAuthorshipField,

                validationField.getValidatedNameComboBox(),

                isInferredExCombinationAuthorship

                );

        Boolean withBasionymSection = BooleanUtils.isTrue(basionymToggle.getValue());

        Boolean withValidationSection = isSpeciesOrBelow && BooleanUtils.isTrue(validationToggle.getValue());

        basionymsComboboxSelect.setVisible(withBasionymSection);

        basionymAuthorshipField.setVisible(withBasionymSection && isInferredBasionymAuthorship != null && !isInferredBasionymAuthorship);

        exBasionymAuthorshipField.setVisible(withBasionymSection && isInferredExBasionymAuthorship != null && !isInferredExBasionymAuthorship);

        validationField.setVisible(withValidationSection);

        exCombinationAuthorshipField.setVisible(withValidationSection && isInferredExCombinationAuthorship != null && !isInferredExCombinationAuthorship);

    @Override

    public NameRelationField getValidationField(){

        return validationField;

    }

import eu.etaxonomy.vaadin.component.NameRelationField;

    /**

     * @return

     */

    NameRelationField getValidationField();

/**

* Copyright (C) 2018 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;

import com.vaadin.data.fieldgroup.BeanFieldGroup;

import com.vaadin.data.fieldgroup.FieldGroup;

import com.vaadin.server.FontAwesome;

import com.vaadin.ui.Button;

import com.vaadin.ui.Component;

import com.vaadin.ui.CssLayout;

import com.vaadin.ui.GridLayout;

import com.vaadin.ui.themes.ValoTheme;

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

import eu.etaxonomy.cdm.model.common.RelationshipBase.Direction;

import eu.etaxonomy.cdm.model.name.NameRelationshipType;

import eu.etaxonomy.cdm.model.name.TaxonName;

import eu.etaxonomy.cdm.model.reference.Reference;

import eu.etaxonomy.cdm.vaadin.component.TextFieldNFix;

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

import eu.etaxonomy.cdm.vaadin.model.name.NameRelationshipDTO;

/**

 * @author a.kohlbecker

 * @since May 3, 2018

 *

 */

public class NameRelationField extends CompositeCustomField<NameRelationshipDTO> {

    /**

     *

     */

    public static final String PRIMARY_STYLE = "v-name-relation-field";

    private static final long serialVersionUID = -7080885013120044655L;

    private CssLayout compositeWrapper = new CssLayout();

    private CssLayout toolBar= new CssLayout();

    private Button removeButton = new Button(FontAwesome.REMOVE);

    private Button newButton = new Button(FontAwesome.PLUS);

    private BeanFieldGroup<NameRelationshipDTO> fieldGroup = new BeanFieldGroup<>(NameRelationshipDTO.class);

    ToOneRelatedEntityCombobox<TaxonName> validatedNameComboBox;

    ToOneRelatedEntityCombobox<Reference> citatonComboBox;

    TextFieldNFix citationMicroReferenceField = new TextFieldNFix();

    TextFieldNFix ruleConsideredField = new TextFieldNFix();

    private Direction direction;

    private NameRelationshipType type;

    private GridLayout grid;

    /**

     * @param string

     */

    public NameRelationField(String caption, Direction direction, NameRelationshipType type) {

        this.direction = direction;

        this.type = type;

        setCaption(caption);

        setPrimaryStyleName(PRIMARY_STYLE);

        validatedNameComboBox = new ToOneRelatedEntityCombobox<TaxonName>("Validated name", TaxonName.class);

        citatonComboBox = new ToOneRelatedEntityCombobox<Reference>("Reference", Reference.class);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected void addDefaultStyles() {

        // TODO Auto-generated method stub

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public FieldGroup getFieldGroup() {

        return fieldGroup;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected Component initContent() {

        newButton.addClickListener(e -> {

            setValue(new NameRelationshipDTO(direction, type));

            updateToolBarButtonStates();

            });

        removeButton.addClickListener(e -> {

                setValue(null);

                updateToolBarButtonStates();

            });

        validatedNameComboBox.getSelect().addValueChangeListener(new ToOneRelatedEntityButtonUpdater<TaxonName>(validatedNameComboBox));

        citatonComboBox.getSelect().addValueChangeListener(new ToOneRelatedEntityButtonUpdater<Reference>(citatonComboBox));

        grid = new GridLayout(2, 3);

        grid.addComponent(validatedNameComboBox, 0, 0, 1, 0);

        validatedNameComboBox.setCaption("Validated name");

        citatonComboBox.setCaption("Reference");

        citationMicroReferenceField.setCaption("Reference detail");

        ruleConsideredField.setCaption("Rule considered");

        grid.addComponent(citatonComboBox, 0, 1, 0, 1);

        grid.addComponent(citationMicroReferenceField, 1, 1, 1, 1);

        grid.addComponent(ruleConsideredField, 0, 2, 1, 2);

        validatedNameComboBox.setWidth(100, Unit.PERCENTAGE);

        ruleConsideredField.setWidth(100, Unit.PERCENTAGE);

        citatonComboBox.setWidth(100, Unit.PERCENTAGE);

        grid.setColumnExpandRatio(0, 7);

        grid.setWidth(100, Unit.PERCENTAGE);

        toolBar.setStyleName(ValoTheme.LAYOUT_COMPONENT_GROUP + " toolbar");

        toolBar.addComponents(newButton, removeButton);

        compositeWrapper.setStyleName("margin-wrapper");

        compositeWrapper.addComponents(toolBar);

        addSizedComponents(compositeWrapper);

        addStyledComponents(validatedNameComboBox, citationMicroReferenceField, citatonComboBox, ruleConsideredField, newButton, removeButton);

        return compositeWrapper;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public Class<NameRelationshipDTO> getType() {

        return NameRelationshipDTO.class;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected void setInternalValue(NameRelationshipDTO newValue) {

        NameRelationshipDTO oldValue = getValue();

        super.setInternalValue(newValue);

        newValue = HibernateProxyHelper.deproxy(newValue);

        if(newValue != null) {

            compositeWrapper.addComponent(grid);

            getFieldGroup().bind(validatedNameComboBox, "otherName");

            getFieldGroup().bind(citationMicroReferenceField, "citationMicroReference");

            getFieldGroup().bind(citatonComboBox, "citation");

            getFieldGroup().bind(ruleConsideredField, "ruleConsidered");

            fieldGroup.setItemDataSource(newValue);

        } else {

            if(oldValue != null){

                compositeWrapper.removeComponent(grid);

                getFieldGroup().unbind(validatedNameComboBox);

                getFieldGroup().unbind(citationMicroReferenceField);

                getFieldGroup().unbind(citatonComboBox);

                getFieldGroup().unbind(ruleConsideredField);

                fieldGroup.setItemDataSource(newValue);

            }

        }

        updateToolBarButtonStates();

    }

   private void updateToolBarButtonStates(){

       boolean hasValue = getValue() != null;

       removeButton.setEnabled(hasValue);

       newButton.setEnabled(!hasValue);

   }

    /**

     * @return the validatedNameComboBox

     */

    public ToOneRelatedEntityCombobox<TaxonName> getValidatedNameComboBox() {

        return validatedNameComboBox;

    }

    /**

     * @return the citatonComboBox

     */

    public ToOneRelatedEntityCombobox<Reference> getCitatonComboBox() {

        return citatonComboBox;

    }

}

/**

* Copyright (C) 2018 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;

import org.vaadin.viritin.fields.CaptionGenerator;

import org.vaadin.viritin.fields.LazyComboBox.FilterableCountProvider;

import org.vaadin.viritin.fields.LazyComboBox.FilterablePagingProvider;

import eu.etaxonomy.cdm.model.name.TaxonName;

import eu.etaxonomy.cdm.model.reference.Reference;

import eu.etaxonomy.cdm.vaadin.model.name.NameRelationshipDTO;

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

/**

 * @author a.kohlbecker

 * @since May 3, 2018

 *

 */

public class NameRelationsListEditor extends ToManyRelatedEntitiesListSelect<NameRelationshipDTO, NameRelationField> {

    private static final long serialVersionUID = 6295557881702890211L;

    private ReloadableLazyComboBoxInstantiator<TaxonName> nameSelectInstantiator;

    private ReloadableLazyComboBoxInstantiator<Reference> referenceSelectInstantiator;

    /**

     * @param itemType

     * @param caption

     */

    public NameRelationsListEditor(String caption) {

        super(NameRelationshipDTO.class, null, caption);

        this.fieldType = NameRelationField.class;

        // addEmptyRowOnInitContent is false in this class since adding row is only possible after setting the PagingProviders

        addEmptyRowOnInitContent = false;

        nameSelectInstantiator = new ReloadableLazyComboBoxInstantiator<TaxonName>(TaxonName.class);

        referenceSelectInstantiator = new ReloadableLazyComboBoxInstantiator<Reference>(Reference.class);

    }

    /**

     * {@inheritDoc}

     */

//    @Override

//    protected NameRelationField newFieldInstance(NameRelationshipDTO val) throws InstantiationException, IllegalAccessException {

//

//        NameRelationField field = new NameRelationField(nameSelectInstantiator, referenceSelectInstantiator, val);

//        field.setWidth(100, Unit.PERCENTAGE);

//        return field;

//    }

    public void setTaxonNamePagingProviders(FilterablePagingProvider<TaxonName> filterablePagingProvider, FilterableCountProvider filterableCountProvider, int pageLength,

            CachingPresenter cachingPresenter){

        nameSelectInstantiator.setPagingProviders(filterablePagingProvider, filterableCountProvider, pageLength, cachingPresenter);

        setInternalValue(null);

    }

    /**

     * @param cdmTitleCacheCaptionGenerator

     */

    public void setTaxonNameCaptionGenerator(CaptionGenerator<TaxonName> captionGenerator) {

        nameSelectInstantiator.setCaptionGenerator(captionGenerator);

    }

    public void setReferencePagingProviders(FilterablePagingProvider<Reference> filterablePagingProvider, FilterableCountProvider filterableCountProvider, int pageLength,

            CachingPresenter cachingPresenter){

        referenceSelectInstantiator.setPagingProviders(filterablePagingProvider, filterableCountProvider, pageLength, cachingPresenter);

        setInternalValue(null);

    }

    /**

     * @param cdmTitleCacheCaptionGenerator

     */

    public void setReferenceCaptionGenerator(CaptionGenerator<Reference> captionGenerator) {

        referenceSelectInstantiator.setCaptionGenerator(captionGenerator);

    }

}

/**

* Copyright (C) 2018 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;

import org.vaadin.viritin.fields.CaptionGenerator;

import org.vaadin.viritin.fields.LazyComboBox.FilterableCountProvider;

import org.vaadin.viritin.fields.LazyComboBox.FilterablePagingProvider;

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

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

/**

 * @author a.kohlbecker

 * @since May 3, 2018

 *

 */

public class ReloadableLazyComboBoxInstantiator<V extends Object> {

    private FilterablePagingProvider<V> filterablePagingProvider = null;

    private FilterableCountProvider filterableCountProvider = null;

    private Integer pageLength = null;

    private CaptionGenerator<V> captionGenerator;

    private CachingPresenter cachingPresenter;

    private Class<V> itemType;

    public ReloadableLazyComboBoxInstantiator(Class<V> itemType){

        this.itemType = itemType;

    }

    /**

     * {@inheritDoc}

     */

    protected ReloadableLazyComboBox<V> newInstance(V val) throws InstantiationException, IllegalAccessException {

        ReloadableLazyComboBox<V> field = new ReloadableLazyComboBox<V>(itemType);

        // FIXME using the ToOneRelatedEntityReloader created a dependency to the cdm packages, this should be relaxed!!!

        field.addValueChangeListener(new ToOneRelatedEntityReloader(field, cachingPresenter));

        if(filterablePagingProvider == null || filterableCountProvider == null ||  pageLength == null) {

            throw new RuntimeException("The filterablePagingProvider, filterableCountProvider and pageLength must be set, use setPagingProviders().");

        }

        field.loadFrom(filterablePagingProvider, filterableCountProvider, pageLength);

        if(captionGenerator != null){

            field.setCaptionGenerator(captionGenerator);

        }

        field.setValue(val);

        return field;

    }

    public void setPagingProviders(FilterablePagingProvider<V> filterablePagingProvider, FilterableCountProvider filterableCountProvider, int pageLength,

            CachingPresenter cachingPresenter){

        this.filterablePagingProvider = filterablePagingProvider;

        this.filterableCountProvider = filterableCountProvider;

        this.pageLength = pageLength;

        this.cachingPresenter = cachingPresenter;

    }

    /**

     * @param cdmTitleCacheCaptionGenerator

     */

    public void setCaptionGenerator(CaptionGenerator<V> captionGenerator) {

        this.captionGenerator = captionGenerator;

    }

}

    private ReloadableLazyComboBoxInstantiator<V> fieldInstantiator;

        fieldInstantiator = new ReloadableLazyComboBoxInstantiator<V>(itemType);

        ReloadableLazyComboBox<V> field = fieldInstantiator.newInstance(val);

        fieldInstantiator.setPagingProviders(filterablePagingProvider, filterableCountProvider, pageLength, cachingPresenter);

        fieldInstantiator.setCaptionGenerator(captionGenerator);

  // ------------ NameRelationField ------------ //

  .v-name-relation-field {

      .toolbar {

            float: right;

            height: $v-unit-size;

      }

      .margin-wrapper {

          @include composite-field-wrapper;

      }

  }