Dépôt officiel du code source de l'ERP OpenConcerto

/*

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 * 

 * 

 * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.

 * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.

 * 

 * 

 * The contents of this file are subject to the terms of the GNU General Public License Version 3

 * The contents of this file are subject to the terms of the GNU General Public License Version 3

 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a

 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a

 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific

 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific

 * language governing permissions and limitations under the License.

 * language governing permissions and limitations under the License.

 * 

 * 

 * When distributing the software, include this License Header Notice in each file.

 * When distributing the software, include this License Header Notice in each file.

 */

 */

 package org.openconcerto.sql.element;

 package org.openconcerto.sql.element;

import static org.openconcerto.sql.TM.getTM;

import static org.openconcerto.sql.TM.getTM;

import org.openconcerto.sql.Configuration;

import org.openconcerto.sql.Configuration;

import org.openconcerto.sql.FieldExpander;

import org.openconcerto.sql.FieldExpander;

import org.openconcerto.sql.Log;

import org.openconcerto.sql.Log;

import org.openconcerto.sql.PropsConfiguration;

import org.openconcerto.sql.PropsConfiguration;

import org.openconcerto.sql.TM;

import org.openconcerto.sql.TM;

import org.openconcerto.sql.element.SQLElementLink.LinkType;

import org.openconcerto.sql.element.SQLElementLink.LinkType;

import org.openconcerto.sql.element.TreesOfSQLRows.LinkToCut;

import org.openconcerto.sql.element.TreesOfSQLRows.LinkToCut;

import org.openconcerto.sql.model.DBStructureItemNotFound;

import org.openconcerto.sql.model.DBStructureItemNotFound;

import org.openconcerto.sql.model.SQLField;

import org.openconcerto.sql.model.SQLField;

import org.openconcerto.sql.model.SQLRow;

import org.openconcerto.sql.model.SQLRow;

import org.openconcerto.sql.model.SQLRowAccessor;

import org.openconcerto.sql.model.SQLRowAccessor;

import org.openconcerto.sql.model.SQLRowMode;

import org.openconcerto.sql.model.SQLRowMode;

import org.openconcerto.sql.model.SQLRowValues;

import org.openconcerto.sql.model.SQLRowValues;

import org.openconcerto.sql.model.SQLRowValues.CreateMode;

import org.openconcerto.sql.model.SQLRowValues.CreateMode;

import org.openconcerto.sql.model.SQLRowValues.ForeignCopyMode;

import org.openconcerto.sql.model.SQLRowValues.ForeignCopyMode;

import org.openconcerto.sql.model.SQLRowValuesCluster;

import org.openconcerto.sql.model.SQLRowValuesCluster;

import org.openconcerto.sql.model.SQLRowValuesCluster.DiffResult;

import org.openconcerto.sql.model.SQLRowValuesCluster.DiffResult;

import org.openconcerto.sql.model.SQLRowValuesCluster.State;

import org.openconcerto.sql.model.SQLRowValuesCluster.State;

import org.openconcerto.sql.model.SQLRowValuesCluster.StopRecurseException;

import org.openconcerto.sql.model.SQLRowValuesCluster.StopRecurseException;

import org.openconcerto.sql.model.SQLRowValuesCluster.StoreMode;

import org.openconcerto.sql.model.SQLRowValuesCluster.StoreMode;

import org.openconcerto.sql.model.SQLRowValuesCluster.WalkOptions;

import org.openconcerto.sql.model.SQLRowValuesCluster.WalkOptions;

import org.openconcerto.sql.model.SQLRowValuesListFetcher;

import org.openconcerto.sql.model.SQLRowValuesListFetcher;

import org.openconcerto.sql.model.SQLSelect;

import org.openconcerto.sql.model.SQLSelect;

import org.openconcerto.sql.model.SQLSelect.ArchiveMode;

import org.openconcerto.sql.model.SQLSelect.ArchiveMode;

import org.openconcerto.sql.model.SQLSelect.LockStrength;

import org.openconcerto.sql.model.SQLSelect.LockStrength;

import org.openconcerto.sql.model.SQLSyntax;

import org.openconcerto.sql.model.SQLSyntax;

import org.openconcerto.sql.model.SQLTable;

import org.openconcerto.sql.model.SQLTable;

import org.openconcerto.sql.model.SQLTable.FieldGroup;

import org.openconcerto.sql.model.SQLTable.FieldGroup;

import org.openconcerto.sql.model.SQLTable.VirtualFields;

import org.openconcerto.sql.model.SQLTable.VirtualFields;

import org.openconcerto.sql.model.Where;

import org.openconcerto.sql.model.Where;

import org.openconcerto.sql.model.graph.Link;

import org.openconcerto.sql.model.graph.Link;

import org.openconcerto.sql.model.graph.Link.Direction;

import org.openconcerto.sql.model.graph.Link.Direction;

import org.openconcerto.sql.model.graph.Path;

import org.openconcerto.sql.model.graph.Path;

import org.openconcerto.sql.model.graph.PathBuilder;

import org.openconcerto.sql.model.graph.PathBuilder;

import org.openconcerto.sql.model.graph.SQLKey;

import org.openconcerto.sql.model.graph.SQLKey;

import org.openconcerto.sql.model.graph.SQLKey.Type;

import org.openconcerto.sql.model.graph.SQLKey.Type;

import org.openconcerto.sql.model.graph.Step;

import org.openconcerto.sql.model.graph.Step;

import org.openconcerto.sql.request.ComboSQLRequest;

import org.openconcerto.sql.request.ComboSQLRequest;

import org.openconcerto.sql.request.ListSQLRequest;

import org.openconcerto.sql.request.ListSQLRequest;

import org.openconcerto.sql.request.SQLCache;

import org.openconcerto.sql.request.SQLCache;

import org.openconcerto.sql.request.SQLFieldTranslator;

import org.openconcerto.sql.request.SQLFieldTranslator;

import org.openconcerto.sql.sqlobject.SQLTextCombo;

import org.openconcerto.sql.sqlobject.SQLTextCombo;

import org.openconcerto.sql.ui.light.CustomRowEditor;

import org.openconcerto.sql.ui.light.CustomRowEditor;

import org.openconcerto.sql.ui.light.GroupToLightUIConvertor;

import org.openconcerto.sql.ui.light.GroupToLightUIConvertor;

import org.openconcerto.sql.ui.light.LightEditFrame;

import org.openconcerto.sql.ui.light.LightEditFrame;

import org.openconcerto.sql.ui.light.LightUIPanelFiller;

import org.openconcerto.sql.ui.light.LightUIPanelFiller;

import org.openconcerto.sql.users.rights.UserRightsManager;

import org.openconcerto.sql.users.rights.UserRightsManager;

import org.openconcerto.sql.utils.SQLUtils;

import org.openconcerto.sql.utils.SQLUtils;

import org.openconcerto.sql.utils.SQLUtils.SQLFactory;

import org.openconcerto.sql.utils.SQLUtils.SQLFactory;

import org.openconcerto.sql.view.EditFrame;

import org.openconcerto.sql.view.EditFrame;

import org.openconcerto.sql.view.EditPanel.EditMode;

import org.openconcerto.sql.view.EditPanel.EditMode;

import org.openconcerto.sql.view.list.IListeAction;

import org.openconcerto.sql.view.list.IListeAction;

import org.openconcerto.sql.view.list.SQLTableModelColumn;

import org.openconcerto.sql.view.list.SQLTableModelColumn;

import org.openconcerto.sql.view.list.SQLTableModelColumnPath;

import org.openconcerto.sql.view.list.SQLTableModelColumnPath;

import org.openconcerto.sql.view.list.SQLTableModelSource;

import org.openconcerto.sql.view.list.SQLTableModelSource;

import org.openconcerto.sql.view.list.SQLTableModelSourceOffline;

import org.openconcerto.sql.view.list.SQLTableModelSourceOffline;

import org.openconcerto.sql.view.list.SQLTableModelSourceOnline;

import org.openconcerto.sql.view.list.SQLTableModelSourceOnline;

import org.openconcerto.ui.group.Group;

import org.openconcerto.ui.group.Group;

import org.openconcerto.ui.light.ComboValueConvertor;

import org.openconcerto.ui.light.ComboValueConvertor;

import org.openconcerto.ui.light.IntValueConvertor;

import org.openconcerto.ui.light.IntValueConvertor;

import org.openconcerto.ui.light.LightUIComboBox;

import org.openconcerto.ui.light.LightUIComboBox;

import org.openconcerto.ui.light.LightUIElement;

import org.openconcerto.ui.light.LightUIElement;

import org.openconcerto.ui.light.LightUIFrame;

import org.openconcerto.ui.light.LightUIFrame;

import org.openconcerto.ui.light.LightUIPanel;

import org.openconcerto.ui.light.LightUIPanel;

import org.openconcerto.ui.light.StringValueConvertor;

import org.openconcerto.ui.light.StringValueConvertor;

import org.openconcerto.utils.CollectionMap2Itf.SetMapItf;

import org.openconcerto.utils.CollectionMap2Itf.SetMapItf;

import org.openconcerto.utils.CollectionUtils;

import org.openconcerto.utils.CollectionUtils;

import org.openconcerto.utils.CompareUtils;

import org.openconcerto.utils.CompareUtils;

import org.openconcerto.utils.ExceptionHandler;

import org.openconcerto.utils.ExceptionHandler;

import org.openconcerto.utils.ExceptionUtils;

import org.openconcerto.utils.ExceptionUtils;

import org.openconcerto.utils.LinkedListMap;

import org.openconcerto.utils.LinkedListMap;

import org.openconcerto.utils.ListMap;

import org.openconcerto.utils.ListMap;

import org.openconcerto.utils.NumberUtils;

import org.openconcerto.utils.NumberUtils;

import org.openconcerto.utils.RTInterruptedException;

import org.openconcerto.utils.RTInterruptedException;

import org.openconcerto.utils.RecursionType;

import org.openconcerto.utils.RecursionType;

import org.openconcerto.utils.ReflectUtils;

import org.openconcerto.utils.ReflectUtils;

import org.openconcerto.utils.SetMap;

import org.openconcerto.utils.SetMap;

import org.openconcerto.utils.Tuple2;

import org.openconcerto.utils.Tuple2;

import org.openconcerto.utils.Value;

import org.openconcerto.utils.Value;

import org.openconcerto.utils.cache.CacheResult;

import org.openconcerto.utils.cache.CacheResult;

import org.openconcerto.utils.cc.IClosure;

import org.openconcerto.utils.cc.IClosure;

import org.openconcerto.utils.cc.ITransformer;

import org.openconcerto.utils.cc.ITransformer;

import org.openconcerto.utils.cc.Transformer;

import org.openconcerto.utils.cc.Transformer;

import org.openconcerto.utils.change.ListChangeIndex;

import org.openconcerto.utils.change.ListChangeIndex;

import org.openconcerto.utils.change.ListChangeRecorder;

import org.openconcerto.utils.change.ListChangeRecorder;

import org.openconcerto.utils.i18n.Grammar;

import org.openconcerto.utils.i18n.Grammar;

import org.openconcerto.utils.i18n.Grammar_fr;

import org.openconcerto.utils.i18n.Grammar_fr;

import org.openconcerto.utils.i18n.NounClass;

import org.openconcerto.utils.i18n.NounClass;

import org.openconcerto.utils.i18n.Phrase;

import org.openconcerto.utils.i18n.Phrase;

import java.awt.Component;

import java.awt.Component;

import java.lang.reflect.Constructor;

import java.lang.reflect.Constructor;

import java.math.BigDecimal;

import java.math.BigDecimal;

import java.sql.SQLException;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collection;

import java.util.Collections;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashMap;

import java.util.HashSet;

import java.util.HashSet;

import java.util.IdentityHashMap;

import java.util.IdentityHashMap;

import java.util.Iterator;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.LinkedHashMap;

import java.util.LinkedList;

import java.util.LinkedList;

import java.util.List;

import java.util.List;

import java.util.ListIterator;

import java.util.ListIterator;

import java.util.Map;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Map.Entry;

import java.util.Set;

import java.util.Set;

import java.util.SortedMap;

import java.util.SortedMap;

import java.util.concurrent.atomic.AtomicReference;

import java.util.concurrent.atomic.AtomicReference;

import java.util.logging.Level;

import java.util.logging.Level;

import javax.swing.JComponent;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.JOptionPane;

import javax.swing.text.JTextComponent;

import javax.swing.text.JTextComponent;

import net.jcip.annotations.GuardedBy;

import net.jcip.annotations.GuardedBy;

import net.jcip.annotations.Immutable;

import net.jcip.annotations.Immutable;

/**

/**

 * Décrit comment manipuler un élément de la BD (pas forcément une seule table, voir

 * Décrit comment manipuler un élément de la BD (pas forcément une seule table, voir

 * privateForeignField).

 * privateForeignField).

 * 

 * 

 * @author ilm

 * @author ilm

 */

 */

public abstract class SQLElement {

public abstract class SQLElement {

    private static Phrase createPhrase(String singular, String plural) {

    private static Phrase createPhrase(String singular, String plural) {

        final NounClass nounClass;

        final NounClass nounClass;

        final String base;

        final String base;

        if (singular.startsWith("une ")) {

        if (singular.startsWith("une ")) {

            nounClass = NounClass.FEMININE;

            nounClass = NounClass.FEMININE;

            base = singular.substring(4);

            base = singular.substring(4);

        } else if (singular.startsWith("un ")) {

        } else if (singular.startsWith("un ")) {

            nounClass = NounClass.MASCULINE;

            nounClass = NounClass.MASCULINE;

            base = singular.substring(3);

            base = singular.substring(3);

        } else {

        } else {

            nounClass = null;

            nounClass = null;

            base = singular;

            base = singular;

        }

        }

        final Phrase res = new Phrase(Grammar_fr.getInstance(), base, nounClass);

        final Phrase res = new Phrase(Grammar_fr.getInstance(), base, nounClass);

        if (nounClass != null)

        if (nounClass != null)

            res.putVariantIfDifferent(Grammar.INDEFINITE_ARTICLE_SINGULAR, singular);

            res.putVariantIfDifferent(Grammar.INDEFINITE_ARTICLE_SINGULAR, singular);

        res.putVariantIfDifferent(Grammar.PLURAL, plural);

        res.putVariantIfDifferent(Grammar.PLURAL, plural);

        return res;

        return res;

    }

    }

    // from the most loss of information to the least.

    // from the most loss of information to the least.

    public static enum ReferenceAction {

    public static enum ReferenceAction {

        /** If a referenced row is archived, empty the foreign field */

        /** If a referenced row is archived, empty the foreign field */

        SET_EMPTY,

        SET_EMPTY,

        /** If a referenced row is archived, archive this row too */

        /** If a referenced row is archived, archive this row too */

        CASCADE,

        CASCADE,

        /** If a referenced row is to be archived, abort the operation */

        /** If a referenced row is to be archived, abort the operation */

        RESTRICT

        RESTRICT

    }

    }

    static final public String DEFAULT_COMP_ID = "default component code";

    static final public String DEFAULT_COMP_ID = "default component code";

    /**

    /**

     * If this value is passed to the constructor, {@link #createCode()} will only be called the

     * If this value is passed to the constructor, {@link #createCode()} will only be called the

     * first time {@link #getCode()} is. This allow the method to use objects passed to the

     * first time {@link #getCode()} is. This allow the method to use objects passed to the

     * constructor of a subclass.

     * constructor of a subclass.

     */

     */

    static final public String DEFERRED_CODE = new String("deferred code");

    static final public String DEFERRED_CODE = new String("deferred code");

    @GuardedBy("this")

    @GuardedBy("this")

    private SQLElementDirectory directory;

    private SQLElementDirectory directory;

    private Phrase defaultName;

    private Phrase defaultName;

    private final SQLTable primaryTable;

    private final SQLTable primaryTable;

    // used as a key in SQLElementDirectory so it should be immutable

    // used as a key in SQLElementDirectory so it should be immutable

    private String code;

    private String code;

    private ComboSQLRequest combo;

    private ComboSQLRequest combo;

    private ListSQLRequest list;

    private ListSQLRequest list;

    private SQLTableModelSourceOnline tableSrc;

    private SQLTableModelSourceOnline tableSrc;

    private final ListChangeRecorder<IListeAction> rowActions;

    private final ListChangeRecorder<IListeAction> rowActions;

    private final LinkedListMap<String, ITransformer<Tuple2<SQLElement, String>, SQLComponent>> components;

    private final LinkedListMap<String, ITransformer<Tuple2<SQLElement, String>, SQLComponent>> components;

    // links

    // links

    private SQLElementLinks ownedLinks;

    private SQLElementLinks ownedLinks;

    private SQLElementLinks otherLinks;

    private SQLElementLinks otherLinks;

    // keep it for now as joins are disallowed (see initFF())

    // keep it for now as joins are disallowed (see initFF())

    private String parentFF;

    private String parentFF;

    // lazy creation

    // lazy creation

    @GuardedBy("this")

    @GuardedBy("this")

    private SQLCache<SQLRow, Object> modelCache;

    private SQLCache<SQLRow, Object> modelCache;

    private final List<SQLTableModelColumn> additionalListCols;

    private final List<SQLTableModelColumn> additionalListCols;

    @GuardedBy("this")

    @GuardedBy("this")

    private List<String> mdPath;

    private List<String> mdPath;

    private Group defaultGroup;

    private Group defaultGroup;

    private Group groupForCreation;

    private Group groupForCreation;

    private Group groupForModification;

    private Group groupForModification;

    @Deprecated

    @Deprecated

    public SQLElement(String singular, String plural, SQLTable primaryTable) {

    public SQLElement(String singular, String plural, SQLTable primaryTable) {

        this(primaryTable, createPhrase(singular, plural));

        this(primaryTable, createPhrase(singular, plural));

    }

    }

    public SQLElement(SQLTable primaryTable) {

    public SQLElement(SQLTable primaryTable) {

        this(primaryTable, null);

        this(primaryTable, null);

    }

    }

    public SQLElement(final SQLTable primaryTable, final Phrase name) {

    public SQLElement(final SQLTable primaryTable, final Phrase name) {

        this(primaryTable, name, null);

        this(primaryTable, name, null);

    }

    }

    public SQLElement(final SQLTable primaryTable, final Phrase name, final String code) {

    public SQLElement(final SQLTable primaryTable, final Phrase name, final String code) {

        super();

        super();

        if (primaryTable == null) {

        if (primaryTable == null) {

            throw new DBStructureItemNotFound("table is null for " + this.getClass());

            throw new DBStructureItemNotFound("table is null for " + this.getClass());

        }

        }

        this.primaryTable = primaryTable;

        this.primaryTable = primaryTable;

        this.setDefaultName(name);

        this.setDefaultName(name);

        this.code = code == null ? createCode() : code;

        this.code = code == null ? createCode() : code;

        this.combo = null;

        this.combo = null;

        this.list = null;

        this.list = null;

        this.rowActions = new ListChangeRecorder<IListeAction>(new ArrayList<IListeAction>());

        this.rowActions = new ListChangeRecorder<IListeAction>(new ArrayList<IListeAction>());

        this.resetRelationships();

        this.resetRelationships();

        this.components = new LinkedListMap<String, ITransformer<Tuple2<SQLElement, String>, SQLComponent>>();

        this.components = new LinkedListMap<String, ITransformer<Tuple2<SQLElement, String>, SQLComponent>>();

        this.modelCache = null;

        this.modelCache = null;

        // the components should always be in the same order

        // the components should always be in the same order

        this.additionalListCols = new ArrayList<SQLTableModelColumn>();

        this.additionalListCols = new ArrayList<SQLTableModelColumn>();

        this.mdPath = Collections.emptyList();

        this.mdPath = Collections.emptyList();

    }

    }

    public void destroy() {

    public void destroy() {

    }

    }

    /**

    /**

     * Should return the code for this element. This method is only called if the <code>code</code>

     * Should return the code for this element. This method is only called if the <code>code</code>

     * parameter of the constructor is <code>null</code>. This implementation returns a string

     * parameter of the constructor is <code>null</code>. This implementation returns a string

     * containing the {@link Class#getName() full name} of the class and the {@link #getTable()

     * containing the {@link Class#getName() full name} of the class and the {@link #getTable()

     * table} name to handle a single class being used for multiple tables. NOTE: this method is

     * table} name to handle a single class being used for multiple tables. NOTE: this method is

     * also needed, since a subclass constructor cannot pass <code>this.getClass().getName()</code>

     * also needed, since a subclass constructor cannot pass <code>this.getClass().getName()</code>

     * as the code parameter to <code>super</code>.

     * as the code parameter to <code>super</code>.

     * 

     * 

     * @return the default code for this element.

     * @return the default code for this element.

     */

     */

    protected String createCode() {

    protected String createCode() {

        return getClass().getName() + "-" + getTable().getName();

        return getClass().getName() + "-" + getTable().getName();

    }

    }

    public Group getGroupForCreation() {

    public Group getGroupForCreation() {

        if (this.groupForCreation != null) {

        if (this.groupForCreation != null) {

            return this.groupForCreation;

            return this.groupForCreation;

        }

        }

        return getDefaultGroup();

        return getDefaultGroup();

    }

    }

    public Group getGroupForModification() {

    public Group getGroupForModification() {

        if (this.groupForModification != null) {

        if (this.groupForModification != null) {

            return this.groupForModification;

            return this.groupForModification;

        }

        }

        return getDefaultGroup();

        return getDefaultGroup();

    }

    }

    public Group getDefaultGroup() {

    public Group getDefaultGroup() {

        return this.defaultGroup;

        return this.defaultGroup;

    }

    }

    public void setDefaultGroup(Group defaultGroup) {

    public void setDefaultGroup(Group defaultGroup) {

        this.defaultGroup = defaultGroup;

        this.defaultGroup = defaultGroup;

    }

    }

    /**

    /**

     * Get the group based on the edit mode

     * Get the group based on the edit mode

     * 

     * 

     * @param editMode

     * @param editMode

     * @return

     * @return

     */

     */

    public Group getEditGroup(final EditMode editMode) {

    public Group getEditGroup(final EditMode editMode) {

        if (editMode.equals(EditMode.CREATION)) {

        if (editMode.equals(EditMode.CREATION)) {

            return this.getGroupForCreation();

            return this.getGroupForCreation();

        } else {

        } else {

            return this.getGroupForModification();

            return this.getGroupForModification();

        }

        }

    }

    }

    /**

    /**

     * Override this function in an element to show default values in edit frame

     * Override this function in an element to show default values in edit frame

     * 

     * 

     * @param token - The security token of session

     * @param token - The security token of session

     * 

     * 

     * @return a default SQLRowValues

     * @return a default SQLRowValues

     */

     */

    public SQLRowValues createDefaultRowValues(final String token) {

    public SQLRowValues createDefaultRowValues(final String token) {

        return new SQLRowValues(getTable());

        return new SQLRowValues(getTable());

    }

    }

    /**

    /**

     * Create the edition frame for this SQLElement

     * Create the edition frame for this SQLElement

     * 

     * 

     * @param configuration current configuration

     * @param configuration current configuration

     * @param parentFrame parent frame of the edit frame

     * @param parentFrame parent frame of the edit frame

     * @param editMode edition mode (CREATION, MODIFICATION, READONLY)

     * @param editMode edition mode (CREATION, MODIFICATION, READONLY)

     * @param sqlRow SQLRowAccessor use for fill the edition frame

     * @param sqlRow SQLRowAccessor use for fill the edition frame

     * @param sessionSecurityToken String, use for find session with an instance of LightServer

     * @param sessionSecurityToken String, use for find session with an instance of LightServer

     * @return the edition frame of this SQLElement

     * @return the edition frame of this SQLElement

     */

     */

    public LightEditFrame createEditFrame(final PropsConfiguration configuration, final LightUIFrame parentFrame, final EditMode editMode, final SQLRowAccessor sqlRow,

    public LightEditFrame createEditFrame(final PropsConfiguration configuration, final LightUIFrame parentFrame, final EditMode editMode, final SQLRowAccessor sqlRow,

            final String sessionSecurityToken) {

            final String sessionSecurityToken) {

        final Group editGroup = this.getEditGroup(editMode);

        final Group editGroup = this.getEditGroup(editMode);

        if (editGroup == null) {

        if (editGroup == null) {

            Log.get().severe("The edit group is null for this element : " + this);

            Log.get().severe("The edit group is null for this element : " + this);

            return null;

            return null;

        }

        }

        final GroupToLightUIConvertor convertor = this.getGroupToLightUIConvertor(configuration, editMode, sqlRow, sessionSecurityToken);

        final GroupToLightUIConvertor convertor = this.getGroupToLightUIConvertor(configuration, editMode, sqlRow, sessionSecurityToken);

        final LightEditFrame editFrame = convertor.convert(editGroup, sqlRow, parentFrame, editMode);

        final LightEditFrame editFrame = convertor.convert(editGroup, sqlRow, parentFrame, editMode);

        if (editMode.equals(EditMode.CREATION)) {

        if (editMode.equals(EditMode.CREATION)) {

            editFrame.createTitlePanel(this.getCreationFrameTitle());

            editFrame.createTitlePanel(this.getCreationFrameTitle());

        } else if (editMode.equals(EditMode.MODIFICATION)) {

        } else if (editMode.equals(EditMode.MODIFICATION)) {

            editFrame.createTitlePanel(this.getModificationFrameTitle(sqlRow));

            editFrame.createTitlePanel(this.getModificationFrameTitle(sqlRow));

            new LightUIPanelFiller(editFrame.getContentPanel()).fillFromRow(configuration, this, sqlRow, sessionSecurityToken);

            new LightUIPanelFiller(editFrame.getContentPanel()).fillFromRow(configuration, this, sqlRow, sessionSecurityToken);

        } else if (editMode.equals(EditMode.READONLY)) {

        } else if (editMode.equals(EditMode.READONLY)) {

            editFrame.createTitlePanel(this.getReadOnlyFrameTitle(sqlRow));

            editFrame.createTitlePanel(this.getReadOnlyFrameTitle(sqlRow));

            new LightUIPanelFiller(editFrame.getContentPanel()).fillFromRow(configuration, this, sqlRow, sessionSecurityToken);

            new LightUIPanelFiller(editFrame.getContentPanel()).fillFromRow(configuration, this, sqlRow, sessionSecurityToken);

        }

        }

        this.setEditFrameModifiers(editFrame, sessionSecurityToken);

        this.setEditFrameModifiers(editFrame, sessionSecurityToken);

        return editFrame;

        return editFrame;

    }

    }

    /**

    /**

     * Get title for read only mode

     * Get title for read only mode

     * 

     * 

     * @param sqlRow - SQLRowValues use for fill the edition frame

     * @param sqlRow - SQLRowValues use for fill the edition frame

     * @return The title for read only mode

     * @return The title for read only mode

     */

     */

    protected String getReadOnlyFrameTitle(final SQLRowAccessor sqlRow) {

    protected String getReadOnlyFrameTitle(final SQLRowAccessor sqlRow) {

        return EditFrame.getReadOnlyMessage(this);

        return EditFrame.getReadOnlyMessage(this);

    }

    }

    /**

    /**

     * Get title for modification mode

     * Get title for modification mode

     * 

     * 

     * @param sqlRow - SQLRowValues use for fill the edition frame

     * @param sqlRow - SQLRowValues use for fill the edition frame

     * @return The title for read only mode

     * @return The title for read only mode

     */

     */

    protected String getModificationFrameTitle(final SQLRowAccessor sqlRow) {

    protected String getModificationFrameTitle(final SQLRowAccessor sqlRow) {

        return EditFrame.getModifyMessage(this);

        return EditFrame.getModifyMessage(this);

    }

    }

    /**

    /**

     * Get title for creation mode

     * Get title for creation mode

     * 

     * 

     * @param sqlRow - SQLRowValues use for fill the edition frame

     * @param sqlRow - SQLRowValues use for fill the edition frame

     * @return The title for read only mode

     * @return The title for read only mode

     */

     */

    protected String getCreationFrameTitle() {

    protected String getCreationFrameTitle() {

        return EditFrame.getCreateMessage(this);

        return EditFrame.getCreateMessage(this);

    }

    }

    /**

    /**

     * 

     * 

     * @param configuration - The user SQL configuration

     * @param configuration - The user SQL configuration

     * @param editMode - Edit mode of the frame

     * @param editMode - Edit mode of the frame

     * @param sqlRow - The row to update

     * @param sqlRow - The row to update

     * @param token - The session security token

     * @param token - The session security token

     * 

     * 

     * @return An initialized GroupToLightUIConvertor

     * @return An initialized GroupToLightUIConvertor

     */

     */

    public GroupToLightUIConvertor getGroupToLightUIConvertor(final PropsConfiguration configuration, final EditMode editMode, final SQLRowAccessor sqlRow, final String token) {

    public GroupToLightUIConvertor getGroupToLightUIConvertor(final PropsConfiguration configuration, final EditMode editMode, final SQLRowAccessor sqlRow, final String token) {

        final GroupToLightUIConvertor convertor = new GroupToLightUIConvertor(configuration);

        final GroupToLightUIConvertor convertor = new GroupToLightUIConvertor(configuration);

        // if (editMode.equals(EditMode.CREATION)) {

        // if (editMode.equals(EditMode.CREATION)) {

        convertor.putAllCustomEditorProvider(this.getCustomRowEditors(configuration, token));

        convertor.putAllCustomEditorProvider(this.getCustomRowEditors(configuration, token));

        // } else {

        // } else {

        // convertor.putAllCustomEditorProvider(this.getCustomRowEditors(configuration, sqlRow,

        // convertor.putAllCustomEditorProvider(this.getCustomRowEditors(configuration, sqlRow,

        // token));

        // token));

        // }

        // }

        return convertor;

        return convertor;

    }

    }

    /**

    /**

     * Override this function in an element and put new value in map for use ComboValueConvertor.

     * Override this function in an element and put new value in map for use ComboValueConvertor.

     * This one allow you to change value store in database by an other one.

     * This one allow you to change value store in database by an other one.

     * 

     * 

     * @return Map which contains all ComboValueConvertors use for this SQLElement edition. Key: ID

     * @return Map which contains all ComboValueConvertors use for this SQLElement edition. Key: ID

     *         of group item / Value: ComboValueConvertor

     *         of group item / Value: ComboValueConvertor

     */

     */

    // TODO: use renderer instead of ValueConvertor

    // TODO: use renderer instead of ValueConvertor

    public Map<String, ComboValueConvertor<?>> getComboConvertors() {

    public Map<String, ComboValueConvertor<?>> getComboConvertors() {

        return new HashMap<String, ComboValueConvertor<?>>();

        return new HashMap<String, ComboValueConvertor<?>>();

    }

    }

    /**

    /**

     * Override this function in an element and put new value in map for use ConvertorModifier. This

     * Override this function in an element and put new value in map for use ConvertorModifier. This

     * one allow you to apply some change on LightUIElement before send it to client

     * one allow you to apply some change on LightUIElement before send it to client

     * 

     * 

     */

     */

    // TODO: implement with IClosure

    // TODO: implement with IClosure

    public void setEditFrameModifiers(final LightEditFrame frame, final String sessionToken) {

    public void setEditFrameModifiers(final LightEditFrame frame, final String sessionToken) {

    }

    }

    public List<CustomRowEditor> getCustomRowEditors(final Configuration configuration, final String sessionToken) {

    public List<CustomRowEditor> getCustomRowEditors(final Configuration configuration, final String sessionToken) {

        final Map<String, ComboValueConvertor<?>> comboConvertors = this.getComboConvertors();

        final Map<String, ComboValueConvertor<?>> comboConvertors = this.getComboConvertors();

        final List<CustomRowEditor> result = new ArrayList<>();

        final List<CustomRowEditor> result = new ArrayList<>();

        for (final Entry<String, ComboValueConvertor<?>> entry : comboConvertors.entrySet()) {

        for (final Entry<String, ComboValueConvertor<?>> entry : comboConvertors.entrySet()) {

            final String itemId = entry.getKey();

            final String itemId = entry.getKey();

            result.add(new CustomRowEditor(itemId) {

            result.add(new CustomRowEditor(itemId) {

                final ComboValueConvertor<?> convertor = entry.getValue();

                final ComboValueConvertor<?> convertor = entry.getValue();

                @Override

                @Override

                public LightUIElement createUIElement() {

                public LightUIElement createUIElement() {

                    final LightUIComboBox uiCombo = new LightUIComboBox(getItemId());

                    final LightUIComboBox uiCombo = new LightUIComboBox(getItemId());

                    this.convertor.fillCombo(uiCombo, null);

                    this.convertor.fillCombo(uiCombo, null);

                    return uiCombo;

                    return uiCombo;

                }

                }

                @Override

                @Override

                public void fillFrom(LightUIElement uiElement, SQLRowAccessor sqlRow) {

                public void fillFrom(LightUIElement uiElement, SQLRowAccessor sqlRow) {

                    final LightUIComboBox uiCombo = (LightUIComboBox) uiElement;

                    final LightUIComboBox uiCombo = (LightUIComboBox) uiElement;

                    final SQLField field = configuration.getFieldMapper().getSQLFieldForItem(getItemId());

                    final SQLField field = configuration.getFieldMapper().getSQLFieldForItem(getItemId());

                    if (this.convertor instanceof StringValueConvertor) {

                    if (this.convertor instanceof StringValueConvertor) {

                        ((StringValueConvertor) this.convertor).fillCombo(uiCombo, sqlRow.getString(field.getFieldName()));

                        ((StringValueConvertor) this.convertor).fillCombo(uiCombo, sqlRow.getString(field.getFieldName()));

                    } else if (this.convertor instanceof IntValueConvertor) {

                    } else if (this.convertor instanceof IntValueConvertor) {

                        if (sqlRow.getObject(field.getFieldName()) != null) {

                        if (sqlRow.getObject(field.getFieldName()) != null) {

                            ((IntValueConvertor) this.convertor).fillCombo(uiCombo, sqlRow.getInt(field.getFieldName()));

                            ((IntValueConvertor) this.convertor).fillCombo(uiCombo, sqlRow.getInt(field.getFieldName()));

                        }

                        }

                    }

                    }

                }

                }

                @Override

                @Override

                public void store(LightUIElement uiElement, SQLRowValues sqlRow) {

                public void store(LightUIElement uiElement, SQLRowValues sqlRow) {

                    final LightUIComboBox combobox = (LightUIComboBox) uiElement;

                    final LightUIComboBox combobox = (LightUIComboBox) uiElement;

                    final String fieldName = configuration.getFieldMapper().getSQLFieldForItem(getItemId()).getName();

                    final String fieldName = configuration.getFieldMapper().getSQLFieldForItem(getItemId()).getName();

                    if (combobox.hasSelectedValue()) {

                    if (combobox.hasSelectedValue()) {

                        if (this.convertor instanceof StringValueConvertor) {

                        if (this.convertor instanceof StringValueConvertor) {

                            sqlRow.put(fieldName, ((StringValueConvertor) this.convertor).getIdFromIndex(combobox.getSelectedValue().getId()));

                            sqlRow.put(fieldName, ((StringValueConvertor) this.convertor).getIdFromIndex(combobox.getSelectedValue().getId()));

                        } else if (this.convertor instanceof IntValueConvertor) {

                        } else if (this.convertor instanceof IntValueConvertor) {

                            sqlRow.put(fieldName, combobox.getSelectedValue().getId());

                            sqlRow.put(fieldName, combobox.getSelectedValue().getId());

                        } else {

                        } else {

                            throw new IllegalArgumentException("the save is not implemented for the class: " + this.convertor.getClass().getName() + " - ui id: " + getItemId());

                            throw new IllegalArgumentException("the save is not implemented for the class: " + this.convertor.getClass().getName() + " - ui id: " + getItemId());

                        }

                        }

                    } else {

                    } else {

                        sqlRow.put(fieldName, null);

                        sqlRow.put(fieldName, null);

                    }

                    }

                }

                }

            });

            });

        }

        }

        return result;

        return result;

    }

    }

    /**

    /**

     * Override this function in an element to execute some code just after inserted new row in

     * Override this function in an element to execute some code just after inserted new row in

     * database

     * database

     *

     *

     * @param editFrame - The edit frame of this SQLRow

     * @param editFrame - The edit frame of this SQLRow

     * @param sqlRow - The row which was just inserted

     * @param sqlRow - The row which was just inserted

     * @param sessionToken Security token of session which allow to find session in LightServer

     * @param sessionToken Security token of session which allow to find session in LightServer

     *        instance

     *        instance

     * 

     * 

     * @throws Exception

     * @throws Exception

     */

     */

    public void doAfterLightInsert(final LightEditFrame editFrame, final SQLRow sqlRow, final String sessionToken) throws Exception {

    public void doAfterLightInsert(final LightEditFrame editFrame, final SQLRow sqlRow, final String sessionToken) throws Exception {

    }

    }

    /**

    /**

     * Override this function in an element to execute some code just after deleted a row in

     * Override this function in an element to execute some code just after deleted a row in

     * database

     * database

     *

     *

     * @param frame - The current frame

     * @param frame - The current frame

     * @param sqlRow - The row which was deleted

     * @param sqlRow - The row which was deleted

     * @param sessionToken Security token of session which allow to find session in LightServer

     * @param sessionToken Security token of session which allow to find session in LightServer

     *        instance

     *        instance

     * 

     * 

     * @throws Exception

     * @throws Exception

     */

     */

    public void doAfterLightDelete(final LightUIFrame frame, final SQLRowValues sqlRow, final String sessionToken) throws Exception {

    public void doAfterLightDelete(final LightUIFrame frame, final SQLRowValues sqlRow, final String sessionToken) throws Exception {

    }

    }

    /**

    /**

     * Override this function in an element to execute some code before inserted new row in database

     * Override this function in an element to execute some code before inserted new row in database

     *

     *

     * @param frame - The current frame

     * @param frame - The current frame

     * @param sqlRow - The row which will be deleted

     * @param sqlRow - The row which will be deleted

     * @param sessionToken - Security token of session which allow to find session in LightServer

     * @param sessionToken - Security token of session which allow to find session in LightServer

     *        instance

     *        instance

     * 

     * 

     * @throws Exception

     * @throws Exception

     */

     */

    public void doBeforeLightDelete(final LightUIFrame frame, final SQLRowValues sqlRow, final String sessionToken) throws Exception {

    public void doBeforeLightDelete(final LightUIFrame frame, final SQLRowValues sqlRow, final String sessionToken) throws Exception {

    }

    }

    /**

    /**

     * Override this function in an element to execute some code before inserted new row in database

     * Override this function in an element to execute some code before inserted new row in database

     * 

     * 

     * @param editFrame - The edit frame of this SQLRowValues

     * @param editFrame - The edit frame of this SQLRowValues

     * @param sqlRow - The row which was just inserted

     * @param sqlRow - The row which was just inserted

     * @param sessionToken - Security token of session which allow to find session in LightServer

     * @param sessionToken - Security token of session which allow to find session in LightServer

     *        instance

     *        instance

     * 

     * 

     * @throws Exception

     * @throws Exception

     */

     */

    public void doBeforeLightInsert(final LightEditFrame editFrame, final SQLRowValues sqlRow, final String sessionToken) throws Exception {

    public void doBeforeLightInsert(final LightEditFrame editFrame, final SQLRowValues sqlRow, final String sessionToken) throws Exception {

    }

    }

    /**

    /**

     * Get ShowAs values of this SQLElement

     * Get ShowAs values of this SQLElement

     * 

     * 

     * @param id - The id which you want to expand

     * @param id - The id which you want to expand

     * 

     * 

     * @return A SQLRowValues with data

     * @return A SQLRowValues with data

     */

     */

    public SQLRowValues getValuesOfShowAs(final Number id) {

    public SQLRowValues getValuesOfShowAs(final Number id) {

        final SQLRowValues tmp = new SQLRowValues(this.getTable());

        final SQLRowValues tmp = new SQLRowValues(this.getTable());

        final ListMap<String, String> showAs = this.getShowAs();

        final ListMap<String, String> showAs = this.getShowAs();

        for (final List<String> listStr : showAs.values()) {

        for (final List<String> listStr : showAs.values()) {

            tmp.putNulls(listStr);

            tmp.putNulls(listStr);

        }

        }

        this.getDirectory().getShowAs().expand(tmp);

        this.getDirectory().getShowAs().expand(tmp);

        final SQLRowValues fetched = SQLRowValuesListFetcher.create(tmp).fetchOne(id);

        final SQLRowValues fetched = SQLRowValuesListFetcher.create(tmp).fetchOne(id);

        if (fetched == null) {

        if (fetched == null) {

            throw new IllegalArgumentException("Impossible to find Row in database - table: " + this.getTable().getName() + ", id: " + id);

            throw new IllegalArgumentException("Impossible to find Row in database - table: " + this.getTable().getName() + ", id: " + id);

        }

        }

        return fetched;

        return fetched;

    }

    }

    /**

    /**

     * Must be called if foreign/referent keys are added or removed.

     * Must be called if foreign/referent keys are added or removed.

     */

     */

    public synchronized void resetRelationships() {

    public synchronized void resetRelationships() {

        if (this.areRelationshipsInited()) {

        if (this.areRelationshipsInited()) {

            // if we remove links, notify owned elements

            // if we remove links, notify owned elements

            for (final SQLElementLink l : this.ownedLinks.getByPath().values()) {

            for (final SQLElementLink l : this.ownedLinks.getByPath().values()) {

                l.getOwned().resetRelationshipsOf(this);

                l.getOwned().resetRelationshipsOf(this);

            }

            }

        }

        }

        this.ownedLinks = this instanceof JoinSQLElement ? new SQLElementLinks(SetMap.<LinkType, SQLElementLink> empty()) : null;

        this.ownedLinks = this instanceof JoinSQLElement ? new SQLElementLinks(SetMap.<LinkType, SQLElementLink> empty()) : null;

        this.otherLinks = this instanceof JoinSQLElement ? new SQLElementLinks(SetMap.<LinkType, SQLElementLink> empty()) : null;

        this.otherLinks = this instanceof JoinSQLElement ? new SQLElementLinks(SetMap.<LinkType, SQLElementLink> empty()) : null;

        this.parentFF = null;

        this.parentFF = null;

    }

    }

    private synchronized void resetRelationshipsOf(final SQLElement changed) {

    private synchronized void resetRelationshipsOf(final SQLElement changed) {

        // MAYBE optimize and only remove links for the passed argument

        // MAYBE optimize and only remove links for the passed argument

        this.otherLinks = null;

        this.otherLinks = null;

    }

    }

    protected synchronized final boolean areRelationshipsInited() {

    protected synchronized final boolean areRelationshipsInited() {

        return this.ownedLinks != null;

        return this.ownedLinks != null;

    }

    }

    // return Path from owner to owned

    // return Path from owner to owned

    private final Set<Path> createPaths(final boolean wantedOwned) {

    private final Set<Path> createPaths(final boolean wantedOwned) {

        // joins cannot have SQLElementLink

        // joins cannot have SQLElementLink

        if (this instanceof JoinSQLElement)

        if (this instanceof JoinSQLElement)

            return Collections.emptySet();

            return Collections.emptySet();

        final SQLTable thisTable = this.getTable();

        final SQLTable thisTable = this.getTable();

        final Set<Link> allLinks = thisTable.getDBSystemRoot().getGraph().getAllLinks(getTable());

        final Set<Link> allLinks = thisTable.getDBSystemRoot().getGraph().getAllLinks(getTable());

        final Set<Path> res = new HashSet<Path>();

        final Set<Path> res = new HashSet<Path>();

        for (final Link l : allLinks) {

        for (final Link l : allLinks) {

            final boolean owned;

            final boolean owned;

            final Path pathFromOwner;

            final Path pathFromOwner;

            final SQLElement sourceElem = this.getElementLenient(l.getSource());

            final SQLElement sourceElem = this.getElementLenient(l.getSource());

            if (sourceElem instanceof JoinSQLElement) {

            if (sourceElem instanceof JoinSQLElement) {

                final JoinSQLElement joinElem = (JoinSQLElement) sourceElem;

                final JoinSQLElement joinElem = (JoinSQLElement) sourceElem;

                pathFromOwner = joinElem.getPathFromOwner();

                pathFromOwner = joinElem.getPathFromOwner();

                // ATTN when source == target, the same path will both owned and not

                // ATTN when source == target, the same path will both owned and not

                owned = joinElem.getLinkToOwner().equals(l);

                owned = joinElem.getLinkToOwner().equals(l);

            } else if (l.getSource() == l.getTarget()) {

            } else if (l.getSource() == l.getTarget()) {

                owned = wantedOwned;

                owned = wantedOwned;

                pathFromOwner = new PathBuilder(l.getSource()).add(l, Direction.FOREIGN).build();

                pathFromOwner = new PathBuilder(l.getSource()).add(l, Direction.FOREIGN).build();

            } else {

            } else {

                owned = l.getSource() == thisTable;

                owned = l.getSource() == thisTable;

                pathFromOwner = new PathBuilder(l.getSource()).add(l).build();

                pathFromOwner = new PathBuilder(l.getSource()).add(l).build();

            }

            }

            if (owned == wantedOwned)

            if (owned == wantedOwned)

                res.add(pathFromOwner);

                res.add(pathFromOwner);

        }

        }

        return res;

        return res;

    }

    }

    // this implementation uses getParentFFName() and assumes that links to privates are COMPOSITION

    // this implementation uses getParentFFName() and assumes that links to privates are COMPOSITION

    final SetMap<LinkType, Path> getDefaultLinkTypes() {

    final SetMap<LinkType, Path> getDefaultLinkTypes() {

        final Set<Path> ownedPaths = createPaths(true);

        final Set<Path> ownedPaths = createPaths(true);

        final SetMap<LinkType, Path> res = new SetMap<LinkType, Path>();

        final SetMap<LinkType, Path> res = new SetMap<LinkType, Path>();

        final String parentFFName = getParentFFName();

        final String parentFFName = getParentFFName();

        if (parentFFName != null) {

        if (parentFFName != null) {

            final Path pathToParent = new PathBuilder(getTable()).addForeignField(parentFFName).build();

            final Path pathToParent = new PathBuilder(getTable()).addForeignField(parentFFName).build();

            if (!ownedPaths.remove(pathToParent))

            if (!ownedPaths.remove(pathToParent))

                throw new IllegalStateException("getParentFFName() " + pathToParent + " isn't in " + ownedPaths);

                throw new IllegalStateException("getParentFFName() " + pathToParent + " isn't in " + ownedPaths);

            res.add(LinkType.PARENT, pathToParent);

            res.add(LinkType.PARENT, pathToParent);

        }

        }

        final List<String> privateFields = this.getPrivateFields();

        final List<String> privateFields = this.getPrivateFields();

        if (!privateFields.isEmpty())

        if (!privateFields.isEmpty())

            Log.get().warning("getPrivateFields() is deprecated use setupLinks(), " + this + " : " + privateFields);

            Log.get().warning("getPrivateFields() is deprecated use setupLinks(), " + this + " : " + privateFields);

        // links to private are COMPOSITION by default (normal links to privates are few)

        // links to private are COMPOSITION by default (normal links to privates are few)

        final Iterator<Path> iter = ownedPaths.iterator();

        final Iterator<Path> iter = ownedPaths.iterator();

        while (iter.hasNext()) {

        while (iter.hasNext()) {

            final Path ownedPath = iter.next();

            final Path ownedPath = iter.next();

            if (getElement(ownedPath.getLast()).isPrivate()) {

            if (getElement(ownedPath.getLast()).isPrivate()) {

                iter.remove();

                iter.remove();

                res.add(LinkType.COMPOSITION, ownedPath);

                res.add(LinkType.COMPOSITION, ownedPath);

            } else if (ownedPath.length() == 1 && ownedPath.isSingleField() && privateFields.contains(ownedPath.getSingleField(0).getName())) {

            } else if (ownedPath.length() == 1 && ownedPath.isSingleField() && privateFields.contains(ownedPath.getSingleField(0).getName())) {

                throw new IllegalStateException("getPrivateFields() contains " + ownedPath + " which points to an element which isn't private");

                throw new IllegalStateException("getPrivateFields() contains " + ownedPath + " which points to an element which isn't private");

            }

            }

        }

        }

        res.addAll(LinkType.ASSOCIATION, ownedPaths);

        res.addAll(LinkType.ASSOCIATION, ownedPaths);

        return res;

        return res;

    }

    }

    final List<ReferenceAction> getPossibleActions(final LinkType lt, final SQLElement targetElem) {

    final List<ReferenceAction> getPossibleActions(final LinkType lt, final SQLElement targetElem) {

        // MAYBE move required fields to SQLElement and use RESTRICT

        // MAYBE move required fields to SQLElement and use RESTRICT

        final List<ReferenceAction> res;

        final List<ReferenceAction> res;

        if (lt == LinkType.PARENT) {

        if (lt == LinkType.PARENT) {

            // SET_EMPTY would create an orphan

            // SET_EMPTY would create an orphan

            res = Arrays.asList(ReferenceAction.CASCADE, ReferenceAction.RESTRICT);

            res = Arrays.asList(ReferenceAction.CASCADE, ReferenceAction.RESTRICT);

        } else if (lt == LinkType.COMPOSITION) {

        } else if (lt == LinkType.COMPOSITION) {

            res = Arrays.asList(ReferenceAction.SET_EMPTY, ReferenceAction.RESTRICT);

            res = Arrays.asList(ReferenceAction.SET_EMPTY, ReferenceAction.RESTRICT);

        } else {

        } else {

            assert lt == LinkType.ASSOCIATION;

            assert lt == LinkType.ASSOCIATION;

            if (targetElem.isShared()) {

            if (targetElem.isShared()) {

                res = Arrays.asList(ReferenceAction.RESTRICT, ReferenceAction.SET_EMPTY);

                res = Arrays.asList(ReferenceAction.RESTRICT, ReferenceAction.SET_EMPTY);

            } else {

            } else {

                res = Arrays.asList(ReferenceAction.values());

                res = Arrays.asList(ReferenceAction.values());

            }

            }

        }

        }

        return res;

        return res;

    }

    }

    private synchronized void initFF() {

    private synchronized void initFF() {

        if (areRelationshipsInited())

        if (areRelationshipsInited())

            return;

            return;

        final SQLElementLinksSetup paths = new SQLElementLinksSetup(this);

        final SQLElementLinksSetup paths = new SQLElementLinksSetup(this);

        setupLinks(paths);

        setupLinks(paths);

        this.ownedLinks = new SQLElementLinks(paths.getResult());

        this.ownedLinks = new SQLElementLinks(paths.getResult());

        // try to fill old attributes

        // try to fill old attributes

        final SQLElementLink parentLink = this.getParentLink();

        final SQLElementLink parentLink = this.getParentLink();

        if (parentLink != null) {

        if (parentLink != null) {

            if (parentLink.getSingleField() != null)

            if (parentLink.getSingleField() != null)

                this.parentFF = parentLink.getSingleField().getName();

                this.parentFF = parentLink.getSingleField().getName();

            else

            else

                throw new UnsupportedOperationException("Parent field name not supported : " + parentLink);

                throw new UnsupportedOperationException("Parent field name not supported : " + parentLink);

        } else {

        } else {

            this.parentFF = null;

            this.parentFF = null;

        }

        }

        assert assertPrivateDefaultValues();

        assert assertPrivateDefaultValues();

        // if we added links, let the owned know

        // if we added links, let the owned know

        final Set<SQLElement> toReset = new HashSet<SQLElement>();

        final Set<SQLElement> toReset = new HashSet<SQLElement>();

        for (final SQLElementLink l : this.ownedLinks.getByPath().values()) {

        for (final SQLElementLink l : this.ownedLinks.getByPath().values()) {

            toReset.add(l.getOwned());

            toReset.add(l.getOwned());

        }

        }

        for (final SQLElement e : toReset) {

        for (final SQLElement e : toReset) {

            e.resetRelationshipsOf(this);

            e.resetRelationshipsOf(this);

        }

        }

        this.ffInited();

        this.ffInited();

    }

    }

    // since by definition private cannot be shared, the default value must be empty

    // since by definition private cannot be shared, the default value must be empty

    private final boolean assertPrivateDefaultValues() {

    private final boolean assertPrivateDefaultValues() {

        final Set<SQLElementLink> privates = this.getOwnedLinks().getByType(LinkType.COMPOSITION);

        final Set<SQLElementLink> privates = this.getOwnedLinks().getByType(LinkType.COMPOSITION);

        for (final SQLElementLink e : privates) {

        for (final SQLElementLink e : privates) {

            if (!e.isJoin()) {

            if (!e.isJoin()) {

                final SQLField singleField = e.getSingleField();

                final SQLField singleField = e.getSingleField();

                final Number privateDefault = (Number) singleField.getParsedDefaultValue().getValue();

                final Number privateDefault = (Number) singleField.getParsedDefaultValue().getValue();

                final Number foreignUndef = e.getPath().getLast().getUndefinedIDNumber();

                final Number foreignUndef = e.getPath().getLast().getUndefinedIDNumber();

                assert NumberUtils.areNumericallyEqual(privateDefault, foreignUndef) : singleField + " not empty : " + privateDefault;

                assert NumberUtils.areNumericallyEqual(privateDefault, foreignUndef) : singleField + " not empty : " + privateDefault;

            }

            }

        }

        }

        return true;

        return true;

    }

    }

    public boolean isPrivate() {

    public boolean isPrivate() {

        return false;

        return false;

    }

    }

    /**

    /**

     * Set {@link LinkType type} and other information for each owned link of this element.

     * Set {@link LinkType type} and other information for each owned link of this element.

     * 

     * 

     * @param links the setup object.

     * @param links the setup object.

     */

     */

    protected void setupLinks(SQLElementLinksSetup links) {

    protected void setupLinks(SQLElementLinksSetup links) {

    }

    }

    /**

    /**

     * Was used to set the action of an {@link SQLElementLink}.

     * Was used to set the action of an {@link SQLElementLink}.

     * 

     * 

     * @deprecated use {@link SQLElementLinkSetup#setType(LinkType, ReferenceAction)}

     * @deprecated use {@link SQLElementLinkSetup#setType(LinkType, ReferenceAction)}

     */

     */

    protected void ffInited() {

    protected void ffInited() {

        // MAYBE use DELETE_RULE of Link

        // MAYBE use DELETE_RULE of Link

    }

    }

    private final Set<SQLField> getSingleFields(final SQLElementLinks links, final LinkType type) {

    private final Set<SQLField> getSingleFields(final SQLElementLinks links, final LinkType type) {

        final Set<SQLField> res = new HashSet<SQLField>();

        final Set<SQLField> res = new HashSet<SQLField>();

        for (final SQLElementLink l : links.getByType(type)) {

        for (final SQLElementLink l : links.getByType(type)) {

            final SQLField singleField = l.getSingleField();

            final SQLField singleField = l.getSingleField();

            if (singleField == null)

            if (singleField == null)

                throw new IllegalStateException("Not single field : " + l);

                throw new IllegalStateException("Not single field : " + l);

            res.add(singleField);

            res.add(singleField);

        }

        }

        return res;

        return res;

    }

    }

    private synchronized void initRF() {

    private synchronized void initRF() {

        if (this.otherLinks != null)

        if (this.otherLinks != null)

            return;

            return;

        final Set<Path> otherPaths = this.createPaths(false);

        final Set<Path> otherPaths = this.createPaths(false);

        if (otherPaths.isEmpty()) {

        if (otherPaths.isEmpty()) {

            this.otherLinks = SQLElementLinks.empty();

            this.otherLinks = SQLElementLinks.empty();

        } else {

        } else {

            final SetMap<LinkType, SQLElementLink> tmp = new SetMap<LinkType, SQLElementLink>();

            final SetMap<LinkType, SQLElementLink> tmp = new SetMap<LinkType, SQLElementLink>();

            for (final Path p : otherPaths) {

            for (final Path p : otherPaths) {

                final SQLElement refElem = this.getElementLenient(p.getFirst());

                final SQLElement refElem = this.getElementLenient(p.getFirst());

                final SQLElementLink elementLink;

                final SQLElementLink elementLink;

                if (refElem == null) {

                if (refElem == null) {

                    // RESTRICT : play it safe

                    // RESTRICT : play it safe

                    elementLink = new SQLElementLink(null, p, this, LinkType.ASSOCIATION, null, ReferenceAction.RESTRICT);

                    elementLink = new SQLElementLink(null, p, this, LinkType.ASSOCIATION, null, ReferenceAction.RESTRICT);

                } else {

                } else {

                    elementLink = refElem.getOwnedLinks().getByPath(p);

                    elementLink = refElem.getOwnedLinks().getByPath(p);

                    assert elementLink.getOwned() == this;

                    assert elementLink.getOwned() == this;

                }

                }

                tmp.add(elementLink.getLinkType(), elementLink);

                tmp.add(elementLink.getLinkType(), elementLink);

            }

            }

            this.otherLinks = new SQLElementLinks(tmp);

            this.otherLinks = new SQLElementLinks(tmp);

        }

        }

    }

    }

    final void setDirectory(final SQLElementDirectory directory) {

    final void setDirectory(final SQLElementDirectory directory) {

        // since this method should only be called at the end of SQLElementDirectory.addSQLElement()

        // since this method should only be called at the end of SQLElementDirectory.addSQLElement()

        assert directory == null || directory.getElement(this.getTable()) == this;

        assert directory == null || directory.getElement(this.getTable()) == this;

        synchronized (this) {

        synchronized (this) {

            if (this.directory != directory) {

            if (this.directory != directory) {

                if (this.areRelationshipsInited())

                if (this.areRelationshipsInited())

                    this.resetRelationships();

                    this.resetRelationships();

                this.directory = directory;

                this.directory = directory;

            }

            }

        }

        }

    }

    }

    public synchronized final SQLElementDirectory getDirectory() {

    public synchronized final SQLElementDirectory getDirectory() {

        return this.directory;

        return this.directory;

    }

    }

    final SQLElement getElement(SQLTable table) {

    final SQLElement getElement(SQLTable table) {

        final SQLElement res = getElementLenient(table);

        final SQLElement res = getElementLenient(table);

        if (res == null)

        if (res == null)

            throw new IllegalStateException("no element for " + table.getSQLName());

            throw new IllegalStateException("no element for " + table.getSQLName());

        return res;

        return res;

    }

    }

    final SQLElement getElementLenient(SQLTable table) {

    final SQLElement getElementLenient(SQLTable table) {

        synchronized (this) {

        synchronized (this) {

            return this.getDirectory().getElement(table);

            return this.getDirectory().getElement(table);

        }

        }

    }

    }

    public final SQLElement getForeignElement(String foreignField) {

    public final SQLElement getForeignElement(String foreignField) {

        try {

        try {

            return this.getElement(this.getForeignTable(foreignField));

            return this.getElement(this.getForeignTable(foreignField));

        } catch (RuntimeException e) {

        } catch (RuntimeException e) {

            throw new IllegalStateException("no element for " + foreignField + " in " + this, e);

            throw new IllegalStateException("no element for " + foreignField + " in " + this, e);

        }

        }

    }

    }

    private final SQLTable getForeignTable(String foreignField) {

    private final SQLTable getForeignTable(String foreignField) {

        return this.getTable().getBase().getGraph().getForeignTable(this.getTable().getField(foreignField));

        return this.getTable().getBase().getGraph().getForeignTable(this.getTable().getField(foreignField));

    }

    }

    /**

    /**

     * Set the default name, used if no translations could be found.

     * Set the default name, used if no translations could be found.

     * 

     * 

     * @param name the default name, if <code>null</code> the {@link #getTable() table} name will be

     * @param name the default name, if <code>null</code> the {@link #getTable() table} name will be

     *        used.

     *        used.

     */

     */

    public final synchronized void setDefaultName(Phrase name) {

    public final synchronized void setDefaultName(Phrase name) {

        this.defaultName = name != null ? name : Phrase.getInvariant(getTable().getName());

        this.defaultName = name != null ? name : Phrase.getInvariant(getTable().getName());

    }

    }

    /**

    /**

     * The default name.

     * The default name.

     * 

     * 

     * @return the default name, never <code>null</code>.

     * @return the default name, never <code>null</code>.

     */

     */

    public final synchronized Phrase getDefaultName() {

    public final synchronized Phrase getDefaultName() {

        return this.defaultName;

        return this.defaultName;

    }

    }

    /**

    /**

     * The name of this element in the current locale.

     * The name of this element in the current locale.

     * 

     * 

     * @return the name of this, {@link #getDefaultName()} if there's no {@link #getDirectory()

     * @return the name of this, {@link #getDefaultName()} if there's no {@link #getDirectory()

     *         directory} or if it hasn't a name for this.

     *         directory} or if it hasn't a name for this.

     * @see SQLElementDirectory#getName(SQLElement)

     * @see SQLElementDirectory#getName(SQLElement)

     */

     */

    public final Phrase getName() {

    public final Phrase getName() {

        final SQLElementDirectory dir = this.getDirectory();

        final SQLElementDirectory dir = this.getDirectory();

        final SQLFieldTranslator trns = dir == null ? null : dir.getTranslator();

        final SQLFieldTranslator trns = dir == null ? null : dir.getTranslator();

        final Phrase res = trns == null ? null : trns.getElementName(this);

        final Phrase res = trns == null ? null : trns.getElementName(this);

        return res == null ? this.getDefaultName() : res;

        return res == null ? this.getDefaultName() : res;

    }

    }

    public String getPluralName() {

    public String getPluralName() {

        return this.getName().getVariant(Grammar.PLURAL);

        return this.getName().getVariant(Grammar.PLURAL);

    }

    }

    public String getSingularName() {

    public String getSingularName() {

        return this.getName().getVariant(Grammar.INDEFINITE_ARTICLE_SINGULAR);

        return this.getName().getVariant(Grammar.INDEFINITE_ARTICLE_SINGULAR);

    }

    }

    public ListMap<String, String> getShowAs() {

    public ListMap<String, String> getShowAs() {

        // nothing by default

        // nothing by default

        return null;

        return null;

    }

    }

    /**

    /**

     * Fields that can neither be inserted nor updated.

     * Fields that can neither be inserted nor updated.

     * 

     * 

     * @return fields that cannot be modified.

     * @return fields that cannot be modified.

     */

     */

    public Set<String> getReadOnlyFields() {

    public Set<String> getReadOnlyFields() {

        return Collections.emptySet();

        return Collections.emptySet();

    }

    }

    /**

    /**

     * Fields that can only be set on insertion.

     * Fields that can only be set on insertion.

     * 

     * 

     * @return fields that cannot be modified.

     * @return fields that cannot be modified.

     */

     */

    public Set<String> getInsertOnlyFields() {

    public Set<String> getInsertOnlyFields() {

        return Collections.emptySet();

        return Collections.emptySet();

    }

    }

    private synchronized final SQLCache<SQLRow, Object> getModelCache() {

    private synchronized final SQLCache<SQLRow, Object> getModelCache() {

        if (this.modelCache == null)

        if (this.modelCache == null)

            this.modelCache = new SQLCache<SQLRow, Object>(60, -1, "modelObjects of " + this.getCode());

            this.modelCache = new SQLCache<SQLRow, Object>(60, -1, "modelObjects of " + this.getCode());

        return this.modelCache;

        return this.modelCache;

    }

    }

    // *** update

    // *** update

    /**

    /**

     * Compute the necessary steps to transform <code>from</code> into <code>to</code>.

     * Compute the necessary steps to transform <code>from</code> into <code>to</code>.