/* (c) Copyright 2003 Caleigo AB, All rights reserved. 
    * 
    * This library is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Lesser General Public
    * License as published by the Free Software Foundation; either
    * version 2.1 of the License, or (at your option) any later version.
    * 
    * This library is distributed in the hope that it will be useful,
    * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   * 
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   *  
   */
  
  package org.caleigo.core;
  
  import java.util.Map;
  import java.util.HashMap;
  import java.util.List;
  import java.util.ArrayList;
  import java.util.Stack;
  import java.util.Iterator;
  
  import org.caleigo.core.exception.InvalidDescriptorException;
  import org.caleigo.core.exception.InvalidFieldException;
  import org.caleigo.core.exception.InvalidQualifierException;
  import org.caleigo.core.exception.InvalidRelationException;
  import org.caleigo.toolkit.log.Log;
  import org.caleigo.toolkit.util.ResourceProvider;
  
  
  
  
  
  /***  The CompositeEntityDescriptor can be used to make composite entities based
   * on fields in base entity descriptors or another composite entity descriptor.
   * 
   * The entities will be Creatable, Delatable & Editable according to this
   * scheme:</br>
   * 
   * An entity is:</br>
   * 
   * -Deletable if the root group's primary key is present and the root field
   * group's entity descriptor is deletable.</br>
   * 
   * -Creatable if the root group's primary key is present and all required fields
   * in the root group are present and the root group's entity descriptor is
   * creatable.</br>
   * 
   * -Editable if any of the field group's primary key is present and there is,
   * in that group, at least one field that isn't read only.</br>
   *
   * 
   * Deleting an entity will delete the root field group's "base entity".</br>
   * 
   * Creating a new entity will fill the new entity with default values.</br>
   * 
   * Editing of a field is allowed if the field's composite field descriptor isn't
   * a read only field (the READ_ONLY_FIELD-flag) and the field group that the
   * field belongs to has a primary key present and that field group's base entity
   * descriptor is editable.
   * Therefor this CompositeEntityDescriptor is editable if any of it's field is
   * editable.
   * Upon saving each field group is saved separately, this is done by copying the
   * data to new entities that has the field group's underlying base entity
   * descriptor as entity descriptor.
   *
   * @author  Dennis Zikovic
   * @author  Niklas Norberg
   * @version 1.00
   * 
   *//* 
   *
   * WHEN        WHO               WHY & WHAT
   * ------------------------------------------------------------------------------
   * 2001-07-17  Dennis Zikovic    Creation
   * 2003-11-01  Niklas Norberg    Implementation
   * 2004-07-09  nno, dzi          Released
   */
  public final class CompositeEntityDescriptor extends AbstractEntityDescriptor implements ICompositeEntityDescriptor
  {
      // Data members ------------------------------------------------------------
      private CompositeFieldGroup mRootFieldGroup;
      private Qualifier mDefaultQualifier = null;
      
      // Constructors ------------------------------------------------------------
      
      /*** This constructor make joins with an entity descriptor and fields.
       * @param displayName screen name.
       * @param dataSourceClassName the class name of the underlying data source
       * that this composite entity descriptor use.
       * @param entityDescriptor all fields from this will be included if the
       * parameter joinedFieldDescriptors doesn't contain fields belonging to this
       * entity descriptor.
       * @param joinedFieldDescriptors an array of fields to join with and make
      * a selection from.
      */
     public CompositeEntityDescriptor(String displayName, String dataSourceClassName, IEntityDescriptor entityDescriptor, IFieldDescriptor[] joinedFieldDescriptors)
     {//1    //call constructor 99
         this("CUSTOM", displayName, dataSourceClassName, CUSTOM_ENTITY, createRootFieldGroup(entityDescriptor, joinedFieldDescriptors));
     }
     
     /*** This constructor creates a CompositeEntityDescriptor from a fieldArray.
      * Fields can be from different base entity descriptor's, if all belongs to
      * the same base entity descriptor the result will be a selection! The first
      * field descriptor's base entity descriptor will be the root group's
      * base entity descriptor.
      * @param displayName screen name.
      * @param dataSourceClassName the class name of the underlying data source
      * that this composite entity descriptor use.
      * @param fieldDescriptors fields that are to be joined/selected.
      */
     public CompositeEntityDescriptor(String displayName, String dataSourceClassName, IFieldDescriptor[] fieldDescriptors)
     {//2    //call constructor 99
         this("CUSTOM", displayName, dataSourceClassName, CUSTOM_ENTITY, createRootFieldGroup(fieldDescriptors));
     }
     
     /***  
      * @see CompositeEntityDescriptor#CompositeEntityDescriptor(String displayName, String dataSourceClassName, IFieldDescriptor[] fieldDescriptors)
      * @see AbstractEntityDescriptor#getEntityType() entityType.
      * @param codeName the code name should be used for programitic
      * identification.
      * @param entityType the entity type entities of this descriptor should have.
      */
     public CompositeEntityDescriptor(String codeName, String displayName, String dataSourceClassName, int entityType, IFieldDescriptor[] fieldDescriptors)
     {//3    //call constructor 99
         this(codeName, displayName, dataSourceClassName, entityType, createRootFieldGroup(fieldDescriptors));
     }
     
     /*** Called by the builder and other constructors, therefor private.
      * @param rootFieldGroup the root of the field group tree that this
      * composite entity descriptor wraps.
      */
     private CompositeEntityDescriptor(String codeName, String displayName, String dataSourceClassName, int entityType, CompositeFieldGroup rootFieldGroup)
     {//99    //call super-constructor in AbstractEntityDescriptor
         super(codeName, rootFieldGroup.getBaseEntityDescriptor().getSourceName(), displayName, 
             CustomEntity.class.getName(),
             dataSourceClassName,
             //can't do (due to hen and egg situation):
             //rootFieldGroup.getBaseEntityDescriptor().getDataSourceDescriptor()!=null?rootFieldGroup.getBaseEntityDescriptor().getDataSourceDescriptor().getClass().getName():null,
             entityType,
             buildFieldArray(rootFieldGroup),//throws InvalidFieldException if the root has no fields 
             buildRelationArray(rootFieldGroup)
             );
             
         mRootFieldGroup = rootFieldGroup;
         this.setICompositeEntityDescriptor();
         
         //nno-todo fix setting of default qualifiers 
 //        if(qualifiersTargetingRootGroup == null)
 //            mDefaultQualifier = null;
 //        else
 //            mDefaultQualifier = CompositeEntityDescriptor.makeDefaultQualifer(qualifiersTargetingRootGroup);
         
         //set flags and cache time
         int cacheTime = Integer.MAX_VALUE;
         int sizeFlag = 0;
         //this.setFlags(SELECTABLE OR LISTABLE OR CACHEABLE OR SCANABLE OR 0);
         for (Iterator iter = mRootFieldGroup.getFieldGroups(); iter.hasNext();)
         {
             CompositeFieldGroup group = (CompositeFieldGroup) iter.next();
             int nextSizeFlag = calculateSizeTypeFlags(group.getBaseEntityDescriptor());
             if (nextSizeFlag > sizeFlag)
                 sizeFlag = nextSizeFlag;
             int nextCacheTime = group.getBaseEntityDescriptor().getCacheTime();
             if (nextCacheTime < cacheTime)
                 cacheTime = nextCacheTime;
         }
         
         /*
         * Due to a a the hen and the egg which came first situation we can't
         * make these calls now the solution choosen was to skip these calls
         * here and overriding of the following methods:
         * isCreatable()
         * isEditable()
         * isDeletable()
         *
 		int changeTypeFlags = this.calculateEditableModeFlag() |
 							 this.calculateCreatableModeFlag() |
 							 this.calculateDelatableModeFlag();
         int changeTypeFlags = EDITABLE | CREATABLE | DELETABLE;
 		this.setFlags( sizeFlag | changeTypeFlags );
          * 
          * therefor we just set the size flag:
          */
         this.setFlags( sizeFlag );
         
         this.setCacheTime(cacheTime);
         
         //adjust flags for fields
         this.setFieldDescriptorFlags();
         
         //dbg System.out.println(printFlags(this));
 
     }
     
     // Mutable method ----------------------------------------------------------
     
     /*** This method sets the default qualifer for this composite entity
      * descriptor.
      * 
      * @param defaultQualifier the qualifer that directly qualifies this
      * composite entity descriptor
      */
     public void setDefaultQualifier(Qualifier defaultQualifier)
     {
         if( !defaultQualifier.canDirectlyQualify(this) )
             throw new InvalidQualifierException("This qualifier: " +
                     "can't directly qualify this composite entity descriptor");
         else
             mDefaultQualifier = defaultQualifier;
     }
     
     
     // Static Constructor help methods -----------------------------------------
     
     
 //    private static Qualifier makeDefaultQualifer(Qualifier[] qualifiersTargetingRootGroup)
 //    {
 //        for (int i = 0; i < qualifiersTargetingRootGroup.length; i++)
 //        {
 //            Qualifier qualifier = qualifiersTargetingRootGroup[i];            
 //        }
 //        return null;
 //    }
      
     /*** Constructor help-method */
     private static CompositeFieldGroup createRootFieldGroup(IFieldDescriptor[] fieldDescriptors)
     {
         //Check parameter:
         if(fieldDescriptors==null)
             throw new InvalidDescriptorException("The parameter: \"fieldDescriptors\" mustn't be null!");
         return createRootFieldGroup(fieldDescriptors[0].getEntityDescriptor(), fieldDescriptors);
     }
     
     /*** Constructor help-method */
     private static CompositeFieldGroup createRootFieldGroup(IEntityDescriptor entityDescriptor, IFieldDescriptor[] joinedFieldDescriptors)
     {
         if(entityDescriptor==null)
             throw new InvalidDescriptorException("The parameter: \"entityDescriptor\" mustn't be null!");
         
         CompositeFieldGroup newRootGroup;  
         if (entityDescriptor instanceof ICompositeEntityDescriptor)
         {//make a copy
             newRootGroup =
                 new CompositeFieldGroup(((ICompositeEntityDescriptor)entityDescriptor).getRootFieldGroup(),
                                         ((ICompositeEntityDescriptor)entityDescriptor).getRootFieldGroup().getRequired(),
                                         null, false, null, false, null );
         }
         else if (entityDescriptor instanceof IBaseEntityDescriptor)
         {//create a new root group and make a selection
             newRootGroup = createFieldGroup((IBaseEntityDescriptor)entityDescriptor, joinedFieldDescriptors);;
         }  
         else
             throw new InvalidDescriptorException("The parameter \"entityDescriptor\"  must be an " +
                 "instance of either ICompositeEntityDescriptor OR an IBaseEntityDescriptor.");
         
         //make joins
         addFields2Group( newRootGroup, joinedFieldDescriptors );
         
         return newRootGroup; 
     }
     
     /*** Constructor help-method:
      * Builds a field group with the choosen fields, duplicates and fields from
      * other base entities are ignored.
      * 
      * @param baseEntityDescriptor the created field group's
      * IBaseEntityDescriptor.
      * @param selectedFieldDescriptors this fields are included in the field
      * group, if null all fields in the parameter iBaseEntityDescriptor are
      * included.
      * @return a new CompositeFieldGroup-object.
      */
     private static CompositeFieldGroup createFieldGroup(IBaseEntityDescriptor baseEntityDescriptor, IFieldDescriptor[] selectedFieldDescriptors)
     {
         CompositeFieldGroup group = new CompositeFieldGroup(baseEntityDescriptor, baseEntityDescriptor.getCodeName(), null, false);
 
         boolean noFieldBelongs2TheBaseEntityDescriptor = true;
         if (selectedFieldDescriptors != null)
             for (int i = 0; i < selectedFieldDescriptors.length; i++)
             {
                 if ( baseEntityDescriptor.getFieldIndex(selectedFieldDescriptors[i]) > 0 )
                     noFieldBelongs2TheBaseEntityDescriptor = false;
             }
         
         if (noFieldBelongs2TheBaseEntityDescriptor)
         {
             //Add all fields from the base entity descriptor.
             selectedFieldDescriptors = new IFieldDescriptor[baseEntityDescriptor.getFieldCount()];
             for(int j=0; j<selectedFieldDescriptors.length; j++)
                 selectedFieldDescriptors[j] = baseEntityDescriptor.getFieldDescriptor(j);
         }
     
         Map fieldMap = new HashMap();
         // Scan and add selected field descriptors.
         for(int j=0; j<selectedFieldDescriptors.length; j++)
         {
             // Ignore field if not valid or already added.
             if(fieldMap.containsKey(selectedFieldDescriptors[j])
                     ||  !baseEntityDescriptor.contains(selectedFieldDescriptors[j]))
                 continue;
         
             IFieldDescriptor field = selectedFieldDescriptors[j];
             group.addFieldDescriptor(field);           
             fieldMap.put(selectedFieldDescriptors[j], null);
         }
     
         return group;
     }
     
     /*** Constructor help-method:
      * Add fields to a field group i.e. make joins.
      * Fields are added to either an existing field group (if that field's
      * base entity has a field group i.e.) otherwise a new field group are
      * created which is added to the root. 
      * 
      * @param rootFieldGroup the root in the join structure.
      * @param joinedFieldDescriptors fields that are joined.
      */
     private static void addFields2Group(CompositeFieldGroup rootFieldGroup, IFieldDescriptor[] joinedFieldDescriptors)
     {       
         Map groupMap = new HashMap();
         Map fieldMap = new HashMap();
 
         ICompositeFieldDescriptor[] fieldsInRootGroupNChildren = buildFieldArray(rootFieldGroup);
         for (int j=0; j<fieldsInRootGroupNChildren.length; j++)
         {
             ICompositeFieldDescriptor iCompositeFieldDescriptor = fieldsInRootGroupNChildren[j];
             ICompositeFieldGroup group = iCompositeFieldDescriptor.getFieldGroup();
             groupMap.put( group.getBaseEntityDescriptor(), group);
             IFieldDescriptor baseField = iCompositeFieldDescriptor.getSourceFieldDescriptor();
             fieldMap.put(baseField, null);
         }
     
         // Scan and add joining field descriptors.
         if (joinedFieldDescriptors != null)
             for(int j=0; j<joinedFieldDescriptors.length; j++)
             {
                 IFieldDescriptor baseField2Join = joinedFieldDescriptors[j];
                 if(baseField2Join instanceof ICompositeFieldDescriptor)
                 baseField2Join = ((ICompositeFieldDescriptor)baseField2Join).getSourceFieldDescriptor();
                 
                 // Ignore field if already added.
                 if( fieldMap.containsKey(baseField2Join) )
                     continue;
                             
                 // Get relevant field group or create a new one.
                 CompositeFieldGroup group = (CompositeFieldGroup)groupMap.get(baseField2Join.getEntityDescriptor());
                 if(group==null){
                     IEntityDescriptor baseEntityDescriptor = baseField2Join.getEntityDescriptor();
                     if (baseEntityDescriptor instanceof IBaseEntityDescriptor)
                     {
                         group = new CompositeFieldGroup((IBaseEntityDescriptor)baseEntityDescriptor,
                                                         baseEntityDescriptor.getCodeName(),
                                                         EntityRelationPath.create(rootFieldGroup.getBaseEntityDescriptor(), baseEntityDescriptor),
                                                         false);
                         groupMap.put(baseEntityDescriptor, group);
                         rootFieldGroup.addChildFieldGroup(rootFieldGroup, group, true);
                     }
                     else
                         throw new InvalidDescriptorException("The field must " +
                             "belong to an IBaseEntityDescriptor!");
                 }
             
                 group.addFieldDescriptor(baseField2Join);
                 fieldMap.put(baseField2Join, null);
             }
     }
     
     
     // Static help methods -----------------------------------------------------
     
     /*** Builds an array of all fields in the root field group and it's
      * descendent children.
      * @param rootFieldGroup the root in the ICompositeEntityDescriptor-object.
      * @return an array of fields in breadth-first order.
      */
     protected static ICompositeFieldDescriptor[] buildFieldArray(ICompositeFieldGroup rootFieldGroup)
     {
 		return (ICompositeFieldDescriptor[]) buildFieldArray(rootFieldGroup, new ArrayList()).toArray(new ICompositeFieldDescriptor[]{});
     }
     
     /*** Help-method, call the tree's nodes recursively. */
     protected static List buildFieldArray(ICompositeFieldGroup fieldGroup, List fieldList)
     {
         if(fieldGroup.getFieldCount()<=0)
                     throw new InvalidFieldException("The field group with " +
                         "entityIdentity == "+fieldGroup.getEntityIdentity() +
                         " must contain fields");
         for(int j=0; j<fieldGroup.getFieldCount(); j++)
             fieldList.add(fieldGroup.getFieldDescriptor(j));
         // call recursively
         for(int j=0; j<fieldGroup.getChildFieldGroupCount(); j++)
             fieldList = CompositeEntityDescriptor.buildFieldArray(fieldGroup.getChildFieldGroup(j), fieldList);
         
         return fieldList;
     }
     
     
     /*** Builds all relations that a composite entity desriptor should have.
      *  
      * @param rootFieldGroup the root of the wrapped field group tree.
      * @return an entity relation array that contains all possible relations in
      * a field group tree i.e. all slave-, reference- and id-fields-relation.
      * 
      * Obs that setting of entity relations on field relations are done in the
      * createEntityRelation()-method.
      */
     protected static IEntityRelation[] buildRelationArray(CompositeFieldGroup rootFieldGroup)
     {   
         //get lists with matching field groups with all it's relations.
         ArrayList fieldGroupWithBelongingReferenceRelationsList = new ArrayList();
         ArrayList fieldGroupWithBelongingTargetRelationsList = new ArrayList();
         buildRelationList( rootFieldGroup, fieldGroupWithBelongingReferenceRelationsList, fieldGroupWithBelongingTargetRelationsList);
         
         ArrayList entityRelationList = new ArrayList(fieldGroupWithBelongingReferenceRelationsList.size()+fieldGroupWithBelongingTargetRelationsList.size()+10);
         int relationCount;
         
         relationCount = fieldGroupWithBelongingTargetRelationsList.size();
         entityRelationTargetFieldLabel:
             for(int i=0;i<relationCount;i++)
             {
                 CompositeFieldGroup fieldGroup = (CompositeFieldGroup)((Object[])fieldGroupWithBelongingTargetRelationsList.get(i))[0];
                 IEntityRelation iEntityRelations2Copy = (IEntityRelation)((Object[])fieldGroupWithBelongingTargetRelationsList.get(i))[1];
                 
                 //Copy field relations
                 int fieldRelationCount = iEntityRelations2Copy.getFieldCount();
                 IFieldRelation iFieldRelations[] = new IFieldRelation[fieldRelationCount];;
 
                 for(int j=0;j<fieldRelationCount;j++)
                 {
                     IFieldDescriptor referenceField = iEntityRelations2Copy.getFieldRelation(j).getReferenceField();
                     IFieldDescriptor targetField = iEntityRelations2Copy.getFieldRelation(j).getTargetField();
                     
                     int index = fieldGroup.getIndexForWrappedField(targetField);
                     if( fieldGroup.getBaseEntityDescriptor().contains(targetField) &&
                             ( index >= 0 ) )
                     {
                         //link 2 base entity descriptor i.e. 2 a slave entity!
                         targetField = (ICompositeFieldDescriptor)fieldGroup.getFieldDescriptor(index);
                     }
                     else
                     {
                         //don't add relaton
 //                        Log.print(null, "\n\n relation not added, targetField: " +
 //                        targetField.getSourceName() + " \n\n");
                         continue entityRelationTargetFieldLabel;
                     }
                     
                     iFieldRelations[j] = new CompositeEntityDescriptor.CompositeFieldRelation(referenceField, targetField);
                 }
                 //obs the display names
                 entityRelationList.add(AbstractEntityDescriptor.createEntityRelation(iFieldRelations,
                         fieldGroup.getEntityIdentity()+"-"+iEntityRelations2Copy.getCodeName(),
                                 fieldGroup.getEntityIdentity()+"-"+iEntityRelations2Copy.getForwardDisplayName(),
                                 fieldGroup.getEntityIdentity()+"-"+iEntityRelations2Copy.getReverseDisplayName()));
             }
         
         relationCount = fieldGroupWithBelongingReferenceRelationsList.size();
         Map referenceFieldMap = new HashMap();
         entityRelationReferenceFieldLabel:
             for(int i=0;i<relationCount;i++)
             {
                 CompositeFieldGroup fieldGroup = (CompositeFieldGroup)((Object[])fieldGroupWithBelongingReferenceRelationsList.get(i))[0];
                 IEntityRelation iEntityRelations2Copy = (IEntityRelation)((Object[])fieldGroupWithBelongingReferenceRelationsList.get(i))[1];
                 
                 //Copy field relations
                 int fieldRelationCount = iEntityRelations2Copy.getFieldCount();
                 IFieldRelation iFieldRelations[] = new IFieldRelation[fieldRelationCount];;
 
                 for(int j=0;j<fieldRelationCount;j++)
                 {
                     IFieldDescriptor referenceField = iEntityRelations2Copy.getFieldRelation(j).getReferenceField();
                     IFieldDescriptor targetField = iEntityRelations2Copy.getFieldRelation(j).getTargetField();
                     
                     int index = fieldGroup.getIndexForWrappedField(referenceField);
                     if( fieldGroup.getBaseEntityDescriptor().contains(referenceField) &&
                             ( index >= 0 ) )
                     {
                         referenceField = (ICompositeFieldDescriptor)fieldGroup.getFieldDescriptor(index);
                         referenceFieldMap.put(referenceField, null);
                     }
                     else
                     {
                         //don't add relaton
 //                        Log.print(null, "\n\n relation not added, referenceField: " +
 //                                referenceField.getSourceName() + " \n\n");
                         continue entityRelationReferenceFieldLabel;
                     }
                     
                     iFieldRelations[j] = new CompositeEntityDescriptor.CompositeFieldRelation(referenceField, targetField);
                 }
                 //obs the display names
                 entityRelationList.add(AbstractEntityDescriptor.createEntityRelation(iFieldRelations,
                         fieldGroup.getEntityIdentity()+"-"+iEntityRelations2Copy.getCodeName(),
                                 fieldGroup.getEntityIdentity()+"-"+iEntityRelations2Copy.getForwardDisplayName(),
                                 fieldGroup.getEntityIdentity()+"-"+iEntityRelations2Copy.getReverseDisplayName()));
             }
         
         //Collect reference-relations that are from the composite to the field group's base entity descriptor
         buildRelationForIdFieldsList(rootFieldGroup, referenceFieldMap, entityRelationList);
         
         IEntityRelation[] entityRelation2Return = (IEntityRelation[])entityRelationList.toArray(new IEntityRelation[]{});
         return entityRelation2Return;
     }
     
     /*** Recursive method for collecting relations.
      * 
      * @param fieldGroup the field group to get relation's from.
      * @param referenceRelationList the list that holds and get matching field
      * groups and their belonging reference entity relation's.
      * @param targetRelationList the list that holds and get matching field
      * groups and their belonging target entity relation's.
      */
     protected static void buildRelationList(final CompositeFieldGroup fieldGroup, List referenceRelationList, List targetRelationList )
     {
         for(int j=0; j<fieldGroup.getBaseEntityDescriptor().getEntityRelationCount(); j++)
         {
             IEntityRelation iEntityRelation = fieldGroup.getBaseEntityDescriptor().getEntityRelation(j);
             
             // Only add relation if all relation fields are present among the
             // field group's wrapped fields.
             int fieldRelationCount = iEntityRelation.getFieldCount();
             ArrayList referenceFieldsInRelationList = new ArrayList(fieldRelationCount);
             ArrayList targetFieldsInRelationList    = new ArrayList(fieldRelationCount);
             for(int k=0;k<fieldRelationCount;k++)
             {
                 IFieldDescriptor referenceField = iEntityRelation.getFieldRelation(k).getReferenceField();
                 IFieldDescriptor targetField = iEntityRelation.getFieldRelation(k).getTargetField();
                 if( fieldGroup.getBaseEntityDescriptor().contains(referenceField) )
                     referenceFieldsInRelationList.add(referenceField);
                 if( fieldGroup.getBaseEntityDescriptor().contains(targetField) )
                     targetFieldsInRelationList.add(targetField);
             }
             
             IFieldDescriptor[] referenceFieldsInRelation = (IFieldDescriptor[])referenceFieldsInRelationList.toArray(new IFieldDescriptor[]{});
             IFieldDescriptor[] targetFieldsInRelation = (IFieldDescriptor[])targetFieldsInRelationList.toArray(new IFieldDescriptor[]{});
             
             //make descisions wether 2 add or not
             if ( fieldGroup.determentIfAllFieldsArePresent(referenceFieldsInRelation))
             {
                 Object[] objects2StoreRelationDataIn = new Object[2];
                 objects2StoreRelationDataIn[0] = fieldGroup;
                 objects2StoreRelationDataIn[1] = iEntityRelation;
                 referenceRelationList.add(objects2StoreRelationDataIn);
             }
             if ( fieldGroup.determentIfAllFieldsArePresent(targetFieldsInRelation))
             {
                 Object[] objects2StoreRelationDataIn = new Object[2];
                 objects2StoreRelationDataIn[0] = fieldGroup;
                 objects2StoreRelationDataIn[1] = iEntityRelation;
                 targetRelationList.add(objects2StoreRelationDataIn);
             }
         }
         // call recursively
         for(int j=0; j<fieldGroup.getChildFieldGroupCount(); j++)
         {
             CompositeFieldGroup child = (CompositeFieldGroup)fieldGroup.getChildFieldGroup(j);
             CompositeEntityDescriptor.buildRelationList(child, referenceRelationList, targetRelationList);
         }
     }
     
     /*** Method makes recursive call to itself and make reference relation for
      * id fields from the composite to the field group's base entity descriptor.
      * 
      * @param fieldGroup field group to look for exactly one id field in.
      * @param referenceFieldMap map containing composite field descriptors that
      * already are referencefields.
      * @param relationList the list to append the found relations to.
      */
     protected static void buildRelationForIdFieldsList(final CompositeFieldGroup fieldGroup, final Map referenceFieldMap, List relationList)
     {
         makeReferenceRelation:
             for (int i = 0; i < fieldGroup.getFieldCount(); i++)
             {
                 ICompositeFieldDescriptor compositeFieldDescriptor = (ICompositeFieldDescriptor)fieldGroup.getFieldDescriptor(i);
                 if( compositeFieldDescriptor.isIdentityField() &&
                         !referenceFieldMap.containsKey(compositeFieldDescriptor) )
                 {
                     //check that the id field is the only id field in the base entity descriptor behind.
                     for (int j = 0; j < fieldGroup.getBaseEntityDescriptor().getFieldCount(); j++)
                     {
                         if( fieldGroup.getBaseEntityDescriptor().getFieldDescriptor(j).isIdentityField() &&
                                 fieldGroup.getBaseEntityDescriptor().getFieldDescriptor(j) != compositeFieldDescriptor.getSourceFieldDescriptor()    )
                             break makeReferenceRelation;
                     }
                     IFieldDescriptor referenceField = compositeFieldDescriptor;
                     IFieldDescriptor targetField = compositeFieldDescriptor.getSourceFieldDescriptor();
                     IFieldRelation[] fieldRelationArray = new IFieldRelation[]{new CompositeEntityDescriptor.CompositeFieldRelation(referenceField, targetField)};
                     //obs the display names
                     relationList.add( AbstractEntityDescriptor.createEntityRelation( fieldRelationArray,
                                                                 fieldGroup.getEntityIdentity()+targetField.getCodeName(),
                                                                 fieldGroup.getEntityIdentity()+referenceField.getCodeName(),
                                                                 fieldGroup.getBaseEntityDescriptor().getCodeName()+targetField.getCodeName() ) );
                 }
             }
         //call recursively
         for(int j=0; j<fieldGroup.getChildFieldGroupCount(); j++)
         {
             CompositeFieldGroup child = (CompositeFieldGroup)fieldGroup.getChildFieldGroup(j);
             CompositeEntityDescriptor.buildRelationForIdFieldsList(child, referenceFieldMap, relationList);
         }
     }
     
     //Help methods -------------------------------------------------------------
     
     /*** Set ownership of all field groups, after this is done a mutable call to
      * any of the mutable private method's will result in an exception!
      */
     private void setICompositeEntityDescriptor()
     {
 		Iterator groupIterator = mRootFieldGroup.getFieldGroups();
         while (groupIterator.hasNext())
         {
             CompositeFieldGroup group = (CompositeFieldGroup)groupIterator.next();
             group.setICompositeEntityDescriptor(this);
         }
     }
     
     
     /*** Calculate the EDITABLE flag based on:</br>
  	 * if any field group's primary key is present and there is, in that group,
      * at least one field that isn't read only - then consider as editable.
      * @return an int-flag that either has the value EDITABLE or 0(zero).
 	 */
     private int calculateEditableModeFlag()
     {		
 		Iterator groupIterator = mRootFieldGroup.getFieldGroups();
 		while (groupIterator.hasNext())
 		{
 			CompositeFieldGroup group = (CompositeFieldGroup)groupIterator.next();
 			if ( group.determentIfPrimaryKeyIsPresent() )
 				for (int i=0;i<group.getFieldCount();i++)
 					if( !group.getFieldDescriptor(i).isReadOnly() )
 						return AbstractEntityDescriptor.EDITABLE;
 		}
 		return 0;
     }
     
     /*** Calculate the CREATABLE flag based on:</br>
      * if the root group's primary key is present and all required fields in the
      * root group are present and the root group's entity descriptor is
      * creatable - then consider as creatable.
      * @return an int-flag that either has the value CREATABLE or 0(zero).
      */
     private int calculateCreatableModeFlag()
     {
         // primary key + all required + creatable => creatable
 		
 		List list = new ArrayList(mRootFieldGroup.getBaseEntityDescriptor().getFieldCount());
         for(int i=0;i<mRootFieldGroup.getBaseEntityDescriptor().getFieldCount();i++)
         {
             IFieldDescriptor fieldDescriptor = mRootFieldGroup.getBaseEntityDescriptor().getFieldDescriptor(i);
             if ( fieldDescriptor.isRequired() )
             {
                 list.add(fieldDescriptor);
             }
         }
 		IFieldDescriptor[] requiredFields = (IFieldDescriptor[])list.toArray(new IFieldDescriptor[list.size()]);
 		
         if ( mRootFieldGroup.determentIfPrimaryKeyIsPresent() &&
 				mRootFieldGroup.determentIfAllFieldsArePresent( requiredFields ) &&
 			mRootFieldGroup.getBaseEntityDescriptor().isEditable() )
             return  AbstractEntityDescriptor.CREATABLE;
         else
         	return 0;
     }
     
     
     /*** Calculate the DELATABLE flag based on:
      * if the root group's primary key is present and the root field group's
      * entity descriptor is deletable - then consider as deletable..
      * @return an int-flag that either has the value DELETABLE or 0(zero).
      */
     private int calculateDelatableModeFlag()
     {
         if ( mRootFieldGroup.determentIfPrimaryKeyIsPresent() &&
         		mRootFieldGroup.getBaseEntityDescriptor().isDeletable() )
 			return  AbstractEntityDescriptor.DELETABLE ;
 		else
 			return 0;
     }
     
     /*** This method adjust flags on fields. It turns off and set some flags for
      * all fields not belonging to the root field group. 
      */
     private void setFieldDescriptorFlags(){
         
         Iterator iter = this.getRootFieldGroup().getFieldGroups();
         
         //skip root field group
         if(iter.hasNext())
             iter.next();
         
         while(iter.hasNext())
         {
             CompositeFieldGroup nextGroup = (CompositeFieldGroup)iter.next();
             for (int i = 0; i < nextGroup.getFieldCount(); i++)
             {
                 CompositeFieldGroup.CompositeFieldDescriptor field = (CompositeFieldGroup.CompositeFieldDescriptor)nextGroup.getFieldDescriptor(i);
                 //int xy = this.calculateFieldDescriptorFlags(field);
                 int oldFlags = field.mFlags;
                 int newFlags = oldFlags;
                 if (field.isIdentityField())
                 {
                     //newFlags = oldFlags & ~ ( IFieldDescriptor.IDENTITY_FIELD | IFieldDescriptor.REQUIRED );
                     //we don't want to have foreign id fields editable that could case saving something you don't realise you have edit
                     newFlags = ( oldFlags & ~ ( IFieldDescriptor.IDENTITY_FIELD | IFieldDescriptor.REQUIRED ) ) | IFieldDescriptor.READ_ONLY_FIELD | IFieldDescriptor.AUTOGEN;
                 }
                 else
                     //newFlags = (oldFlags | IFieldDescriptor.READ_ONLY_FIELD) & ~IFieldDescriptor.REQUIRED;
                     newFlags = oldFlags & ~IFieldDescriptor.REQUIRED;
                 field.mFlags = newFlags;
                 //xy = this.calculateFieldDescriptorFlags(field);
             }
             
         }
     }
     
     /*** Calculate which flag's are set.
      * @param entityDescriptor the IEntityDescriptor that are examined. 
      * @return an int representing all flag's that are set.
      */
     protected static int calculateEntityDescriptorFlags(IEntityDescriptor entityDescriptor)
     {    
         int flags = calculateSizeTypeFlags(entityDescriptor);
         
         //zero or more of these are allowed
         if(entityDescriptor.isCreatable())
             flags |= AbstractEntityDescriptor.CREATABLE;
         if(entityDescriptor.isEditable())
             flags |= AbstractEntityDescriptor.EDITABLE;
         if(entityDescriptor.isDeletable())
             flags |= AbstractEntityDescriptor.DELETABLE;
         
         return flags;
     }
     
     /*** Calculate which of the size type flag's that are set.
      * @param entityDescriptor the IEntityDescriptor that are examined. 
      * @return an int representing the size type flag that are set.
      */
     protected static int calculateSizeTypeFlags(IEntityDescriptor entityDescriptor)
     {    
         int flags = 0;
         // only one of these are allowed
         if(entityDescriptor.isSelectable())
             flags = AbstractEntityDescriptor.SELECTABLE;
         else if(entityDescriptor.isListable())
             flags = AbstractEntityDescriptor.LISTABLE;
         else if(entityDescriptor.isCacheable())
             flags = AbstractEntityDescriptor.CACHEABLE;
         else if(entityDescriptor.isScanable())
             flags = AbstractEntityDescriptor.SCANABLE;
                  
         return flags;
     }
     
     /*** @return and integer representing all flags for the field. */
     //protected static int calculateFieldDescriptorFlags(IFieldDescriptor field)
     public static int calculateFieldDescriptorFlags(IFieldDescriptor field)
     {    
         int flags = 0;
         if(field.isAutoGenerated())
             flags |= IFieldDescriptor.AUTOGEN;
         if(field.isHiddenField())
             flags |= IFieldDescriptor.HIDDEN_FIELD;
         if(field.isHintField())
             flags |= IFieldDescriptor.HINT_FIELD;
         if(field.isIdentityField())
             flags |= IFieldDescriptor.IDENTITY_FIELD;
         if(field.isIndexed())
             flags |= IFieldDescriptor.INDEXED;
         if(field.isNameField())
             flags |= IFieldDescriptor.NAME_FIELD;
         if(field.isNaturalOrder())
             flags |= IFieldDescriptor.NATURAL_ORDER;
         if(field.isOverviewField())
             flags |= IFieldDescriptor.OVERVIEW_FIELD;
         if(field.isReadOnly())
             flags |= IFieldDescriptor.READ_ONLY_FIELD;
         if(field.isRequired())
             flags |= IFieldDescriptor.REQUIRED;
         return flags;
     }
     
     /*** Increases (+1) the last number (if any) in a String. If there are
      * no number "1" will be added to the String i.e. "alias12" -> "alias13" and
      * "alias" -> "alias1" .
      * @return a new String with increased number.
      */
     public static String increaseStringEndingWithNumber(String anIdentity){
         int j=anIdentity.length();
         while (Character.isDigit(anIdentity.charAt(j-1)))
             j--;
         int aliasNbr = 1;
         if (j<anIdentity.length())
             aliasNbr = Integer.parseInt( anIdentity.substring( j, anIdentity.length() ) ) + 1;
         return anIdentity.substring(0, j) + aliasNbr;
     }
     
     
     
     
     // D E B U G   M E T H O D S    --------------------------------------------
     
     
     /*** Makes a descriptive log string for the provided entity object.
      * Will display the data for all field descriptors. 
      */
     public static String makeLogString(IEntity entity)
     {
         if (entity==null)
             return "entity==null";
         IEntityDescriptor entityDescriptor = entity.getEntityDescriptor();
         int fieldCount = entityDescriptor.getFieldCount();
         IFieldDescriptor[] fields = new IFieldDescriptor[fieldCount];
         for (int i=0;i<fieldCount;i++)
             fields[i] = entityDescriptor.getFieldDescriptor(i);
         return AbstractEntity.makeLogString(entity, fields);
     }
     
     /*** Makes a descriptive log string that tells what flags are set on the
      * provided entity object.
      * 
      * @param entityDescriptor
      */
     public static String printFlags(IEntityDescriptor entityDescriptor)
     {
         StringBuffer dbgStringBuffer = new StringBuffer(); 
         dbgStringBuffer.append("The entityDescriptor: "+entityDescriptor.getCodeName()+" has the following flags set to:");
         dbgStringBuffer.append(" isSelectable(): "  + entityDescriptor.isSelectable());
         dbgStringBuffer.append(", isListable(): "  + entityDescriptor.isListable());
         dbgStringBuffer.append(", isCacheable(): "  + entityDescriptor.isCacheable());
         dbgStringBuffer.append(", isScanable(): "  + entityDescriptor.isScanable());
         dbgStringBuffer.append(", isEditable(): "  + entityDescriptor.isEditable());
         dbgStringBuffer.append(", isCreatable(): " + entityDescriptor.isCreatable());
         dbgStringBuffer.append(", isDeletable(): " + entityDescriptor.isDeletable());
         dbgStringBuffer.append('.');
         return dbgStringBuffer.toString();
     }
     
     
     
     // Superclass overrides ----------------------------------------------------
     
     /*** Creates an entity of the type described by this descriptor and
      * loads it with default data.
      */
     public IEntity createEntity()
     {
         // Create entity.
         IEntity entity = new CustomEntity(this);
             
         // Set default data.
         for(int j=0; j<this.getFieldCount(); j++)
             entity.setData(this.getFieldDescriptor(j), this.getFieldDescriptor(j).getDefaultValue());
         
         return entity;
     }
     
     /*** Creates an entity of the type described by this descriptor and
      * loads it with data from the provided property source.
      */
     public IEntity createEntity(IDataProvider propertySource)
     {   
         //Create entity.
         IEntity entity = new CustomEntity(this);
         
         //Load entity with data from the propertySource.
         entity.setData(propertySource);
         
         return entity;
     }    
     
     /*** Returns the data source descriptor that this entity is a part of. */
     public IDataSourceDescriptor getDataSourceDescriptor()
     {
         return ((ICompositeFieldDescriptor)mRootFieldGroup.getFieldDescriptor(0)).getSourceFieldDescriptor().getEntityDescriptor().getDataSourceDescriptor();
     }
     
     /*** Creates and returns the store action for composite entity objects of the
      * custom type: composite entity descriptor.
      * 
      * @return The IEntityAction object that is used to store entity
      * objects for the called entity. 
      */
     protected IEntityAction createStoreAction()
     {
         return new CompositeStoreEntityAction(this);
     }
     
     /*** Creates and returns the delete action for composite entity objects of
      * the custom type: composite entity descriptor.
      * 
      * @return The IEntityAction object that is used to delete entity
      * objects for the called entity.
      */
      protected IEntityAction createDeleteAction()
      {
          return new CompositeDeleteEntityAction(this);
      }
      
      /*** Returns true if entities described by the called descriptor may be 
       * created. If a store operation is called on a non-persistent entity
       * of the described type an exception should be thrown.
       */
      public boolean isCreatable()
      {
          return (this.calculateCreatableModeFlag() & AbstractEntityDescriptor.CREATABLE)==AbstractEntityDescriptor.CREATABLE &&
          !this.getDataSourceDescriptor().isReadOnly();
      }
      
      /*** Returns true if entities described by the called descriptor may be 
       * updated. If a store operation is called on a persistent entity
       * of the described type an exception should be thrown.
       */
      public boolean isEditable()
      {
          return (this.calculateEditableModeFlag() & AbstractEntityDescriptor.EDITABLE)==AbstractEntityDescriptor.EDITABLE &&
          !this.getDataSourceDescriptor().isReadOnly();
      }
      
      /*** Returns true if entities described by the called descriptor may be 
       * deleted. If a store operation is called on a persistent entity
       * of the described type an exception should be thrown.
       */
      public boolean isDeletable()
      {
          return (this.calculateDelatableModeFlag() & AbstractEntityDescriptor.DELETABLE)==AbstractEntityDescriptor.DELETABLE &&
          !this.getDataSourceDescriptor().isReadOnly();
      }
     
     
     
     
     // ICompositeEntityDescriptor implementation -------------------------------
     
     /*** Returns the root field group for the tree of
      * field groups that defines this CompositeEntityDescriptor.
      */
     public ICompositeFieldGroup getRootFieldGroup()
     {
         return mRootFieldGroup;
     }
     
     /*** Returns a qualifier that defines the default filter for this entity.
      * Setting is done in the constructors. If a constructor without a 
      * qualifier-parameter is choosen or the parameter is null, the default
      * value is null i.e. no discarding of the entities are made.
      * 
      * It might make sence e.g. to filter out all orders older than a 
      * discontinued date.
      */
     public Qualifier getDefaultQualifier()
     {
         return mDefaultQualifier;
     }
     
     
     
     
     
     // Internal classes --------------------------------------------------------
     
     //nno-todo add methods get methods for field group's so adding of fields
     // and new field groups can be made to an existing tree
     
     /*** The FieldGroupBuilder is a builder that builds a tree (of fields- and 
      * field-groups) in a top-down manner. But most users shouldn't have to
      * worry about internal structur and that's why we provide the builder.
      */
     public static class Builder
     {
         // Data members --------------------------------------------------------
         
         /*** Stack for fields group's. */
         private Stack mFieldGroup_Stack;
         
         // Constructors --------------------------------------------------------
         
         public Builder(IEntityDescriptor entityDescriptor)
         {
             this(entityDescriptor, entityDescriptor.getCodeName(), false);
         }
         
         
         public Builder(IEntityDescriptor entityDescriptor, String entityIdentity)
         {
             this(entityDescriptor, entityIdentity, false);
         }
         
         /*** Instantiate a new FieldGroupBuilder and begins the first group and 
          * make it the tree's root. Next step would be to call one of the
          * addField()-methods and then maybe one of  the beginGroup()-methods. 
          * 
          * @param entityDescriptor 
          * @param entityIdentity id for the root field group.
          * @param required determines what kind of joins that are to be made:
          * left/right/full outer join / inner join.
          * @see ICompositeEntityDescriptor.ICompositeFieldGroup#getRequired()
          */
         public Builder(IEntityDescriptor entityDescriptor, String entityIdentity, boolean required)
         {
             mFieldGroup_Stack = new Stack();
             mFieldGroup_Stack.add(createCompositeFieldGroup(entityDescriptor, entityIdentity, null, required));
         }
         
 
         // Access methods ------------------------------------------------------
         
         public void beginFieldGroup(IEntityDescriptor entityDescriptor)
         {
             this.beginFieldGroup(entityDescriptor, null, null, false);
         }
         
         public void beginFieldGroup(IEntityDescriptor entityDescriptor, String entityIdentity)
         {
             this.beginFieldGroup(entityDescriptor, entityIdentity, null, false);
         }
         
         public void beginFieldGroup(IEntityDescriptor entityDescriptor, IEntityRelationPath parentToChildPath)
         {
             this.beginFieldGroup(entityDescriptor, null, parentToChildPath, false);
         }
         
         public void beginFieldGroup(IEntityDescriptor entityDescriptor, String entityIdentity, boolean required)
         {
             this.beginFieldGroup(entityDescriptor, entityIdentity, null, required);
         }
         
         public void beginFieldGroup(IEntityDescriptor entityDescriptor, String entityIdentity, IEntityRelationPath parentToChildPath)
         {
             this.beginFieldGroup(entityDescriptor, entityIdentity, parentToChildPath, false);
         }
         
         /*** Create a new field group and add it to the current field group as a
          * child, i.e. let this newly created field group be the parent of
          * future childs i.e. make a new tree branch.
          * @see CompositeEntityDescriptor.CompositeFieldGroup#CompositeFieldGroup(IBaseEntityDescriptor iBaseEntityDescriptor, String entityIdentity, IEntityRelationPath parentRelationPath, boolean required)
          *
          * @param entityDescriptor is the entity descriptor that all added
          * fields should be belong to. All added child field group will be
          * joined to this one.???????????????????????????????????????????????????????????????????????????????????????????
          * @param entityIdentity is the named identity of the created field
          * group. It's optional. This will normally be the code name of
          * the base entity descriptor unless multiple instances of the
          * descriptor exists in the field group structure.
          * @param parentRelationPath is the path that connects this field group's
          * parent with this field group.
          * @param required determines whether or not this field group's fields
          * are required or not in joins.
          * @see ICompositeEntityDescriptor.ICompositeFieldGroup#getRequired()
          */
         public void beginFieldGroup(IEntityDescriptor entityDescriptor, String entityIdentity, IEntityRelationPath parentToChildPath, boolean required)
         {   
             CompositeFieldGroup parent = (CompositeFieldGroup)mFieldGroup_Stack.peek();
             //nno-todo test and check what happens in the composite case
             if (parentToChildPath == null)//calculate a new one automagically
             {
                 //obs! the direction of the path i.e. from the parent to the child
                 parentToChildPath = EntityRelationPath.create(parent.getBaseEntityDescriptor(), entityDescriptor);
             }
             CompositeFieldGroup newFieldGroup = createCompositeFieldGroup(entityDescriptor, entityIdentity, parentToChildPath, required);
             boolean resolveEntityIdentityConflicts = false;
             if(entityIdentity == null)
                 resolveEntityIdentityConflicts = true;
             parent.addChildFieldGroup((CompositeFieldGroup)mFieldGroup_Stack.elementAt(0), newFieldGroup, resolveEntityIdentityConflicts);
             mFieldGroup_Stack.push(newFieldGroup); 
         }
         
         public void addFieldDescriptor(IFieldDescriptor field)
         {
             this.addFieldDescriptor(field, field.getCodeName(), field.getDisplayName());
         }
         
         public void addFieldDescriptor(IFieldDescriptor field, String codeName, String displayName)
         {
             CompositeFieldGroup currentFieldGroup = (CompositeFieldGroup)mFieldGroup_Stack.peek();
             // OBS: Calling like this avoid problems with flag calculation
 			currentFieldGroup.addFieldDescriptor(field, codeName, displayName);
         }
         
         /*** Add a field to the current field group.
          * Call to this method is allowed both before and after adding field
          * groups (with any of the beginFieldGroup-methods). Compare to files
          * and directories in file-systems!
          * @see CompositeEntityDescriptor.CompositeFieldGroup#addFieldDescriptor(IFieldDescriptor field, String codeName, String displayName, int flags)
          */
         public void addFieldDescriptor(IFieldDescriptor field, String codeName, String displayName, int flags)
         {
             CompositeFieldGroup currentFieldGroup = (CompositeFieldGroup)mFieldGroup_Stack.peek();
             currentFieldGroup.addFieldDescriptor(field, codeName, displayName, flags);
         }
         
         /*** Ends the current field group and climp up one level in the tree.
          * Throws an InvalidDescriptorException if the current field group
          * doesn't contain any fields!
          * Extra closings at the top level are ignored.
          */
         public void endFieldGroup()
         {
             // extra closing's do nada
             if(mFieldGroup_Stack.size()<=1) 
                 return;
             
             //climb up one level in the tree
             CompositeFieldGroup currentFieldGroup = (CompositeFieldGroup)mFieldGroup_Stack.pop();
             
             //throw exception if group is empty! (Could have been: just remove the group.)
             if (currentFieldGroup.getFieldCount() == 0)
                 throw new InvalidDescriptorException("A field group must contain fields!");
         }
         
         /*** @return a created ICompositeEntityDescriptor which wraps a field
          * group tree and it's current children (fields and field-groups).
          * After calling this method it's ok to add more children and then call
          * it again.
          * @see CompositeEntityDescriptor#CompositeEntityDescriptor(String codeName, String displayName, String dataSourceClassName, int entityType, IFieldDescriptor[] fieldDescriptors, Qualifier defaultQualifier)
          */
         public ICompositeEntityDescriptor createCompositeEntityDescriptor(String codeName, String displayName, String dataSourceClassName, int entityType)
         {
             //make a copy and use that when constructing the new CompositeEntityDescriptor
             CompositeFieldGroup rootFieldGroup = (CompositeFieldGroup)mFieldGroup_Stack.elementAt(0);
             CompositeFieldGroup newRootFieldGroup = new CompositeFieldGroup(rootFieldGroup, rootFieldGroup.getRequired(), null, false, null, false, null );
             return new CompositeEntityDescriptor(codeName, displayName, dataSourceClassName, entityType, newRootFieldGroup);
         }
         
         
         // Help methods --------------------------------------------------------
         
         
         /*** Help method that creates a new CompositeFieldGroup-object were the
          * parameter entityDescriptor either can be an instance of
          * iCompositeEntityDescriptor or iBaseEntityDescriptor.
          */
         private static CompositeFieldGroup createCompositeFieldGroup(IEntityDescriptor entityDescriptor, String entityIdentity, IEntityRelationPath parentRelationPath, boolean required)
         {
             CompositeFieldGroup newFieldGroup;
             if (entityDescriptor instanceof IBaseEntityDescriptor)
                 newFieldGroup = new CompositeFieldGroup((IBaseEntityDescriptor)entityDescriptor, entityIdentity, parentRelationPath, required);
             else if (entityDescriptor instanceof ICompositeEntityDescriptor)
             {
                 //make a copy of the internal structure and reset members
                 newFieldGroup = new CompositeFieldGroup(
                         ((ICompositeEntityDescriptor)entityDescriptor).getRootFieldGroup(),
                                     required, null, false, null, false, null );
                 newFieldGroup.mEntityIdentity = entityIdentity;
                 newFieldGroup.mParentRelationPath = parentRelationPath;
             }
             else
                 throw new InvalidDescriptorException("Can only handle " +
                     "IEntityDescriptor that is an instance of either " +
                     "IBaseEntityDescriptor or ICompositeEntityDescriptor!");
                 
             return newFieldGroup;
         }
                 
     }//FieldGroupBuilder
     
     
     
     
     
     
     
     /*** The ICompositeFieldGroup is used to group sets of fields belonging to a
      * single entity-descriptor (of the class ICompositeEntityDescriptor)
      * together and to define their relation with each other.
      * Note that several field groups may have the same base entity descriptor
      * but represent different records in the data space.
      */
     public static final class CompositeFieldGroup implements ICompositeFieldGroup
     {
         // Data members --------------------------------------------------------
         
         /*** The \"base entity descriptor\" for this field group. */
         private IBaseEntityDescriptor mIBaseEntityDescriptor;
         
         /*** Used in SQL as alias. */
         private String mEntityIdentity;
         
         /*** The IEntityRelationPath that make the join between the fields 
          * that this group contain and it's parent to be! The direction should
          * be from the parent to the child.
          * OBS a null path will cause an exception.
          */
         private IEntityRelationPath mParentRelationPath;
 
         /*** Default value is false which should result in FULL OUTER JOIN's. */
         private boolean mRequired = false;
                 
         /*** Container for the fields belonging to this CompositeFieldGroup.*/
         private List mFieldDescriptorList = new ArrayList();
 
         /*** Container for the field groups belonging to this CompositeFieldGroup.*/
         private List mFieldGroupList = new ArrayList();
         
         /*** The ICompositeEntityDescriptor that is wrapping this field group's
          * fields (and maybe fields form other field groups)
          * 
          * OBS! Here we have an Hen and the egg which came first situation!
          * Since the field groups are created first and included as one of
          * the parameters when constructing the CompositeEntityDescriptor
          * this member can't be set until we are done constructing the
          * wrapping CompositeEntityDescriptor-object (and is therefor NOT valid
          * before the field group (with others) are wrapped up in an
          * CompositeEntityDescriptor-object!
          */
         private CompositeEntityDescriptor mCompositeEntityDescriptor = null;
         //null as long as this field group doesn't "belong" to a "wrapping" CompositeEntityDescriptor;
         
         
         /*** Creates a CompositeFieldGroup-object.
          * 
          * @param iBaseEntityDescriptor is the base entity that all added fields
          * should be belong to. All added child field group will be joined
          * to this one.
          * @param entityIdentity is the named identity of the created field
          * group. It's optional. This will normally be the code name of
          * the base entity descriptor unless multiple instances of the
          * descriptor exists in the field group structure.
          * @param parentRelationPath is the path that connects this group and
          * another group i.e. the parent.
          * @param required determines whether or not this field group's fields
          * are required or not in joins.
          * @see ICompositeEntityDescriptor.ICompositeFieldGroup#getRequired()
          */
         private CompositeFieldGroup(IBaseEntityDescriptor iBaseEntityDescriptor, String entityIdentity, IEntityRelationPath parentRelationPath, boolean required)
         {
             mIBaseEntityDescriptor = iBaseEntityDescriptor;
             mEntityIdentity = entityIdentity;
             mParentRelationPath = parentRelationPath;// only null for a root!
             mRequired = required;
         }
         
         /*** Creates a CompositeFieldGroup-object by making a copy of an existing
          * ICompositeFieldGroup-structure. It also make a copy of the parameter
          * childFieldGroup if not <null>. This new child copy will be added to
          * nodeFieldGroup if this parameter isn't <null> or in the <null> case
          * to the root field group.
          * 
          * @param rootFieldGroup copied to a new root.
          * @param rootRequired 
          * @param nodeFieldGroup virtual node to add child to.
          * @param nodeRequired
          * @param childFieldGroup copied child will be added to node (or root). 
          * @param childRequired
          * @param parentToChildPath the relation path between the node (or root) and the child.
          * @see org.caleigo.core.ICompositeEntityDescriptor.ICompositeFieldGroup#getRequired() rootRequired, nodeRequired, childRequired.
          */
         private CompositeFieldGroup(ICompositeFieldGroup rootFieldGroup, boolean rootRequired, ICompositeFieldGroup nodeFieldGroup, boolean nodeRequired, ICompositeFieldGroup childFieldGroup, boolean childRequired, IEntityRelationPath parentToChildPath)
         {   
             //set fields in this new root field group
             this(rootFieldGroup.getBaseEntityDescriptor(), rootFieldGroup.getEntityIdentity(), null, rootRequired);
             
             // hold on to the group that the child should be added to
             ICompositeFieldGroup virtualParent = nodeFieldGroup!=null?nodeFieldGroup:rootFieldGroup;
             CompositeFieldGroup realParent = null;
             
             //traverse and copy tree
             Stack stackForCopiedTree = new Stack();
             Stack stackFornewTree = new Stack();
             stackForCopiedTree.push(rootFieldGroup);
             stackFornewTree.push(this);
             //
             while (!stackForCopiedTree.empty())
             {
                 ICompositeFieldGroup iCompositeFieldGroup2Copy = (ICompositeFieldGroup)stackForCopiedTree.pop();
                 CompositeFieldGroup compositeFieldGroupInNewTree = (CompositeFieldGroup)stackFornewTree.pop();
                 
                 if (virtualParent == iCompositeFieldGroup2Copy)
                     realParent = compositeFieldGroupInNewTree;
                 
                 //copy fields and data BUT UNWRAP FIRST!!!
                 for (int j=0;j<iCompositeFieldGroup2Copy.getFieldCount();j++)
                 {
                     compositeFieldGroupInNewTree.addFieldDescriptor(
                                 iCompositeFieldGroup2Copy.getFieldDescriptor(j).getSourceFieldDescriptor(),
                                 iCompositeFieldGroup2Copy.getFieldDescriptor(j).getCodeName(),
                                 iCompositeFieldGroup2Copy.getFieldDescriptor(j).getDisplayName(),
                                 calculateFieldDescriptorFlags(iCompositeFieldGroup2Copy.getFieldDescriptor(j))
                                 );
                 }
                 
                 //Copy field groups
                 // The order is irrelevant as long as we take each field group
                 // exactly ONCE and copy all it's child field groups. So either
                 //for (int j=iCompositeFieldGroup2Copy.getChildFieldGroupCount()-1;j>-1;j--)//breadfirst
                 // OR
                 for (int j=0;j<iCompositeFieldGroup2Copy.getChildFieldGroupCount();j++)//deapfirst
                 {
                     ICompositeFieldGroup icfg = iCompositeFieldGroup2Copy.getChildFieldGroup(j);
                     CompositeFieldGroup cfg;
                     boolean req;
                     if (nodeFieldGroup == icfg)
                         req = nodeRequired;
                     else
                         req = icfg.getRequired();
                     cfg = new CompositeFieldGroup(icfg.getBaseEntityDescriptor(),
                                                     icfg.getEntityIdentity(),
                                                     icfg.getParentRelationPath(),
                                                     req);
                     //add group
                     compositeFieldGroupInNewTree.addChildFieldGroup(this, cfg, true);
                     //put them on the two stack's
                     stackForCopiedTree.push(icfg);
                     stackFornewTree.push(cfg);
                 }
             }
             //merge via a one level recursive call
             if (childFieldGroup != null && realParent!= null)
             {
                 CompositeFieldGroup duplicatedChild = new CompositeFieldGroup(childFieldGroup, childRequired, null, false, null, false, null );
                 duplicatedChild.mParentRelationPath = parentToChildPath;
                 realParent.addChildFieldGroup(this, duplicatedChild, true);
             }
         
         }
         
         // Help methods --------------------------------------------------------
         
         /*** Resolve naming conflicts for the member variable: "mEntityIdentity".
          */
         private int resolveEntityIdentityConflicts(CompositeFieldGroup rootFieldGroup, boolean resolveEntityIdentityConflicts)
         {
             //Traverse tree and solve naming conflicts
             int changes = 0;
             Iterator groupIterator = rootFieldGroup.getFieldGroups();
             HashMap takenIDs = new HashMap();
             while (groupIterator.hasNext())
             {
                 CompositeFieldGroup groupBeeingChecked = (CompositeFieldGroup)groupIterator.next();
                 String entityIdentity2Check = groupBeeingChecked.getEntityIdentity();
                 if (takenIDs.containsKey(entityIdentity2Check))
                 {
                     String oldEntityIdentity = entityIdentity2Check;
                     
                     //iterate til uniq    
                     do
                         entityIdentity2Check = increaseStringEndingWithNumber(entityIdentity2Check);
                     while ( takenIDs.containsKey(entityIdentity2Check) );
                     
                     //change mEntityIdentity or throw an exception
                     if (resolveEntityIdentityConflicts)
                     {
                         changes++;
                         groupBeeingChecked.mEntityIdentity = entityIdentity2Check;
                         Log.printWarning(this, "Changed the entity identity on " +
                             "field group from: \""+oldEntityIdentity+"\" to \""+
                             entityIdentity2Check+"\" due to resolving problems!");
                     }
                     else
                         throw new InvalidDescriptorException("There is a naming " +
                             "conflict, the entity identity: "+oldEntityIdentity+
                             " is occupied! Solve this by manually by renaming "+
                             "it to e.g. " + entityIdentity2Check);
                 }
                 takenIDs.put(entityIdentity2Check, null);  
             }
 
             //dbg-printing Traverse the tree and prints all field groups
             //System.out.println("\n\n");
             //groupIterator = rootFieldGroup.getFieldGroups();
             //while (groupIterator.hasNext())
             //    System.out.println((ICompositeFieldGroup)groupIterator.next());
             //System.out.println("\n\n");
 
             return changes;
         }
         
         // Help methods --------------------------------------------------------
         
         /*** Collect all nodes in a field group tree.
          * @param fieldGroup root of the field group tree.
          * @return an array with all groups sorted in bread first order.
          */
         private static ICompositeFieldGroup[] getFieldGroupsBreadFirst(ICompositeFieldGroup fieldGroup)
         {            
 			return (ICompositeFieldGroup[])getFieldGroupsBreadFirst(fieldGroup, new ArrayList()).toArray(new ICompositeFieldGroup[]{});
         }
         
         /*** Help-method, call the tree's nodes recursively in bread first order.
          */
         private static List getFieldGroupsBreadFirst(ICompositeFieldGroup fieldGroup, List fieldGroupList)
         {
             fieldGroupList.add(fieldGroup);
             for(int j=0; j<fieldGroup.getChildFieldGroupCount(); j++)
                 fieldGroupList = getFieldGroupsBreadFirst(fieldGroup.getChildFieldGroup(j), fieldGroupList);
             return fieldGroupList;
         }
         
         /*** Get the index for the composite field descriptor that wraps
          * the field descriptor given as parameter.
          * 
          * @param fieldDescriptor a wrapped IFieldDescriptor.
          * @return an int representing the index for the
          * ICompositeFieldDescriptor that wraps the parameter fieldDescriptor.
          * A negative number is returned if no ICompositeFieldDescriptor wraps
          * the parameter fieldDescriptor.
          */
         private int getIndexForWrappedField(IFieldDescriptor fieldDescriptor)
         {
             int index = this.getFieldCount()-1;
             while(index >= 0)
             {
                 if(fieldDescriptor == ((ICompositeFieldDescriptor)this.getFieldDescriptor(index)).getSourceFieldDescriptor())
                     break;
                 --index;
             }
             return index;
         }
           
         /*** Determents if a primary-key is present among the fields belonging to
          * this field group.
          */
         private boolean determentIfPrimaryKeyIsPresent()
         {
             IFieldDescriptor[] idFieldsThatNeed2BePresent = Relations.getIdentityFields(this.getBaseEntityDescriptor());
             return determentIfAllFieldsArePresent(idFieldsThatNeed2BePresent);
         }
         
 		/*** Determents if this field group's wrapped fields cover all fields in
          * the array given as parameter.
 		 */
 		private boolean determentIfAllFieldsArePresent(IFieldDescriptor[] fieldsThatNeed2BePresent)
 		{
 			for(int i=0;i<fieldsThatNeed2BePresent.length;i++)
 			{
 				boolean presentInGroup = false;
 				for(int j=0;j<this.getFieldCount();j++)
 				{
 					presentInGroup = false;
 					if( fieldsThatNeed2BePresent[i] == ((ICompositeFieldDescriptor)this.getFieldDescriptor(j)).getSourceFieldDescriptor() )
 					{
 						presentInGroup = true;
 						break;
 					}
 				}
 				if(presentInGroup == false)
 					  return false;
 			}
 			return true;
 		}
         
         /*** After a call to this method the object should be considered
          * immutable, therefore each mutable method must call the
          * checkForHolder method.
          * @see #checkForHolder()
          */
         private void setICompositeEntityDescriptor(CompositeEntityDescriptor compositeEntityDescriptor)
         {
             checkForHolder();
             mCompositeEntityDescriptor = compositeEntityDescriptor;
         }
         
         /*** Method to make sure that the object is in a stable condition.
          * Should be called firstly in every mutable method to make sure that
          * this object hasn't been wrapped by an CompositeEntityDescriptor.
          */
         private void checkForHolder()
         {
             if (mCompositeEntityDescriptor != null)
                 throw new RuntimeException("Mutable call to a CompositeFieldGroup that already belongs to a wrapping CompositeEntityDescriptor!");
         }
         
         
         // Access methods ------------------------------------------------------
         
         
         /*** Adds the passed field to this field group.
          * 
          * @param field the fieldDescriptor to add.
          * 
          * @see #addFieldDescriptor(IFieldDescriptor field, String codeName, String displayName, int flags)
          */
         private void addFieldDescriptor(IFieldDescriptor field)
         {
             //checkForHolder();//unnecessary called later
             this.addFieldDescriptor(field, field.getCodeName(), field.getDisplayName());
         }
         
 		/*** Adds the passed field to this field group.
 		 * Unwapping N Wrapping of fields are always done in this implementation!
 		 *
 		 * @param field the fieldDescriptor to add.
 		 * @param codeName the new codeName
 		 * @param displayName the new displayName
 		 * 
 		 * @see #addFieldDescriptor(IFieldDescriptor field, String codeName, String displayName, int flags)
 		 */
 		private void addFieldDescriptor(IFieldDescriptor field, String codeName, String displayName)
 		{
 			//checkForHolder();//unnecessary called later
             
 			int flags;
 			// OBS due to the ICompositeFieldDescriptor.isReadOnly()-method we
 			//always have to calculate the flags from the underlying source-field
 			if (field instanceof ICompositeFieldDescriptor)
 				flags = calculateFieldDescriptorFlags( ((ICompositeFieldDescriptor)field).getSourceFieldDescriptor() );
 			else
 				flags = calculateFieldDescriptorFlags( field );
         
 			this.addFieldDescriptor(field, codeName, displayName, flags);
 		}
         
         /*** Adds the passed field to this field group.
          * Unwapping N Wrapping of fields are always done in this implementation!
          *
          * @param field the fieldDescriptor to add.
          * @param codeName the new codeName.
          * @param displayName the new displayName.
          * @param flags an int that represent the flags that are to be set for
          * this field.
          * 
          * @see IFieldDescriptor#IDENTITY_FIELD
          * @see IFieldDescriptor#NATURAL_ORDER
          * @see IFieldDescriptor#REQUIRED
          * @see IFieldDescriptor#INDEXED
          * @see IFieldDescriptor#AUTOGEN
          * @see IFieldDescriptor#NAME_FIELD
          * @see IFieldDescriptor#OVERVIEW_FIELD
          * @see IFieldDescriptor#HINT_FIELD
          * @see IFieldDescriptor#HIDDEN_FIELD
          * @see IFieldDescriptor#READ_ONLY_FIELD
          */
         private void addFieldDescriptor(IFieldDescriptor field, String codeName, String displayName, int flags)
         {
             checkForHolder();
 
             // Unwrap field if neccessary.
             if (field instanceof ICompositeFieldDescriptor)
                 field = ((ICompositeFieldDescriptor)field).getSourceFieldDescriptor();
             
             // Validate the field descriptor.
             if ( field.getEntityDescriptor()!=this.getBaseEntityDescriptor() )
                 throw new InvalidFieldException("The field must be part of the " +
                     "\"base entity descriptor\": "+
                     this.getBaseEntityDescriptor()+"!");
                     
             // Wrap field and add it.
             ICompositeEntityDescriptor.ICompositeFieldDescriptor wrappedField =
                     this.new CompositeFieldDescriptor(field, codeName, displayName, flags);
             mFieldDescriptorList.add(wrappedField);
         }
         
         /*** Add field group children to this field group.
          * @param rootFieldGroup is used to solve entity-identity conflicts (if
          * any exist and the parameter resolveEntityIdentityConflicts == true).
          * @param fieldGroup the field group to add.
          * @param resolveEntityIdentityConflicts determines if solving of 
          * eventually entity-identity conflicts are to be solved, if false and 
          * conflicts exist an exception is thrown.
          */
         private void addChildFieldGroup(CompositeFieldGroup rootFieldGroup, CompositeFieldGroup fieldGroup, boolean resolveEntityIdentityConflicts)
         {
             checkForHolder();
             
             //Validate the RelationPath via getParentRelationPath()
 //            if(     fieldGroup.getParentRelationPath()==null ||
 //                    !( ( fieldGroup.getParentRelationPath().getFirstEntityDescriptor()==this.getBaseEntityDescriptor() &&
 //                         fieldGroup.getParentRelationPath().getLastEntityDescriptor()==fieldGroup.getBaseEntityDescriptor() ) ||
 //                       ( fieldGroup.getParentRelationPath().getFirstEntityDescriptor()==fieldGroup.getBaseEntityDescriptor() &&
 //                         fieldGroup.getParentRelationPath().getLastEntityDescriptor()==this.getBaseEntityDescriptor() )
 //                      ) ) 
 //                throw new InvalidRelationException("Relation path must link parent and child entities!");
             if(     fieldGroup.getParentRelationPath()==null ||
                     !( ( fieldGroup.getParentRelationPath().getFirstEntityDescriptor()==this.getBaseEntityDescriptor() &&
                          fieldGroup.getParentRelationPath().getLastEntityDescriptor()==fieldGroup.getBaseEntityDescriptor() )
                       ) ) 
                 throw new InvalidRelationException("Relation path must link parent and child entities " +
                         "and the direction must be FROM the parent TO the child!");
             if ( fieldGroup.getParentRelationPath().getRelationCount() == 0)
                 throw new InvalidRelationException("Relation path mustn't be a \"null\"-path!");
             
             mFieldGroupList.add(fieldGroup);
             
             //Resolve entity identity i.e. solve naming conflicts
             int changes = resolveEntityIdentityConflicts(fieldGroup, resolveEntityIdentityConflicts);
             if (changes > 0)
                 Log.print(this, changes+" changes were made to solve naming conflicts with field group's entity identities!");
             
         }
         
               
         // ICompositeFieldGroup implementation ---------------------------------
         
         /*** Returns the entity descriptor of the field group. All fields must 
          * belong to that entity descriptor. A composite entity may however 
          * have several fieldgroups with the same entity descriptor, but all
          * must have unique entity identity strings.
          */
         public IBaseEntityDescriptor getBaseEntityDescriptor()
         {
             return mIBaseEntityDescriptor;
         }
         
         /*** Returns the named identity of the called field groups entity 
          * descriptor. This will normally be the code name of the entity
          * descriptor unless multiple instances of the descriptor exists.
          */
         public String getEntityIdentity()
         {
             if(mEntityIdentity!=null)
                 return mEntityIdentity;
             else
                 return this.getBaseEntityDescriptor().getCodeName();
         }
         
         /*** Returns the relation path from the parent field group to this field
          * group.
          */
         public IEntityRelationPath getParentRelationPath()
         {
             return mParentRelationPath;
         }
         
         //nno-todo whoops have to take care of use of calculated field descriptors.
         /*** Returns the number of field descriptors that the called field group
          * contains. This includes both data and calculated field descriptors.
          */
         public int getFieldCount()
         {
             return mFieldDescriptorList.size();
         }
     
         /*** Returns a specific field descriptor from the the called field group
          * by its ordial index. May cast OutOfBoundException.
          */
         public ICompositeFieldDescriptor getFieldDescriptor(int index)
         {
             return (ICompositeFieldDescriptor)mFieldDescriptorList.get(index);
         }
         
         /*** Returns the number of field groups that the called field group
          * contains. This includes both data and calculated field descriptors.
          */
         public int getChildFieldGroupCount()
         {
             return mFieldGroupList.size();
         }
     
         /*** Returns a specific field group from the the called field group
          * by its ordial index. May cast OutOfBoundException.
          */
         public ICompositeFieldGroup getChildFieldGroup(int index)
         {
             return (ICompositeFieldGroup)mFieldGroupList.get(index);
         }
         
         public boolean getRequired()
         {
             return mRequired;
         }
         
         /*** @return an iterator that iterates over all field group's that has
          * this field group as root.
          */
         public java.util.Iterator getFieldGroups()
         {
             return org.caleigo.toolkit.util.Iterators.iterate(getFieldGroupsBreadFirst(this));
         }
         
         
         // super class overrides -----------------------------------------------
         
         public String toString()
         {
             return "FieldGroup-"+this.getEntityIdentity();
         }
         
         
         
     
         // Internal classes ----------------------------------------------------
     
         /*** The ICompositeFieldDescriptor wraps another field descriptor and in
          * many ways acts as a proxy for it. It can be used to alter properties
          * such as code and display names. 
          */
         protected class CompositeFieldDescriptor implements ICompositeFieldDescriptor
         {
             // Data members ----------------------------------------------------
             private IFieldDescriptor mRemoteFieldDescriptor;
             private String mCodeName;
             private String mDisplayName;
             private int mFlags;
             
             // Constructors ----------------------------------------------------
             
             protected CompositeFieldDescriptor(IFieldDescriptor field, String codeName, String displayName, int flags)
             {
                 mRemoteFieldDescriptor = field;
                 mCodeName = codeName;
                 mDisplayName = displayName;
                 mFlags = flags;
             }
         
             // IFieldDescriptor implementation ---------------------------------
             
             /*** Return the code name for the field. The code name should be used
              * for programatic identification. This is safer and recommended
              * compared to the use of field indexes. The code name is also the
              * name of the data property for the field in entities. 
              */
             public String getCodeName()
             {
                 return mCodeName;
             }
     
             /*** Returns the source name for the field. The source name is an
              * identifier for the field in the data service layer.
              */
             public String getSourceName()
             {
                 return mRemoteFieldDescriptor.getSourceName();
             }
     
             /*** Returns the display name for the field. The reurned value has been
              * passed through the ResourceProvider to allow localisation.
              */
             public String getDisplayName()
             {
                 return mDisplayName;
             }
     
             /*** Returns the data type for the field.
              */
             public DataType getDataType()
             {
                 return mRemoteFieldDescriptor.getDataType();
             }
     
             /*** Returns the length of the data type if the type is a scalar type.
              */
             public int getLength()
             {
                 return mRemoteFieldDescriptor.getLength();
             }
     
             /*** Return the default value for the field or null if none is set.
              * This default value will automaticalli be set as the default value
              * for created entities that the field is part of.
              */
             public Object getDefaultValue()            
             {
                 return mRemoteFieldDescriptor.getDefaultValue();
             }
     
             public boolean isIdentityField()
             {
                 return (mFlags & IDENTITY_FIELD)!=0;
             }
     
             public boolean isReferenceField()
             {
                 return this.getReferenceFieldRelation()!=null;
             }
     
             public boolean isRequired()
             {
                 return (mFlags & REQUIRED)!=0;
             }
     
             public boolean isIndexed()
             {
                 return (mFlags & INDEXED)!=0;
             }
     
             public boolean isAutoGenerated()
             {
                 return (mFlags & AUTOGEN)!=0;
             }
 
             public boolean isNameField()
             {
                 return (mFlags & NAME_FIELD)!=0;
             }
     
             public boolean isOverviewField()
             {
                 return (mFlags & OVERVIEW_FIELD)!=0;
             }
     
             public boolean isHintField()
             {
                 return (mFlags & HINT_FIELD)!=0;
             }
     
             public boolean isHiddenField()
             {
                 return (mFlags & HIDDEN_FIELD)!=0;
             }
             
             /*** @return true
              * if the the read only flag (READ_ONLY_FIELD) is set for this field
              * OR
              * if the field's field group's EntityDescriptor isn't editable
              * OR
              * if the field's field group's primary key isn't present among the
              * fields.
              * 
              * OBS, Watch out the behaviour when this method are called before
              * the field descriptor's field group's base entity descriptor's
              * data source descriptor has been initialized!
              */
             public boolean isReadOnly()
             {     
                 boolean readonlyFlag =((mFlags & READ_ONLY_FIELD)!=0);
                 boolean groupisNOTEditable;
                 //nno-todo Not nice but have to do for now. Solves problem
                 //when the data source descriptor hasn't been initialized!
                 if(mIBaseEntityDescriptor.getDataSourceDescriptor() == null)
                     groupisNOTEditable = false;
                 else
                     groupisNOTEditable = (CompositeFieldGroup.this.mIBaseEntityDescriptor.isEditable() == false) ;
                 boolean keyForGroupisNOTPresent = (CompositeFieldGroup.this.determentIfPrimaryKeyIsPresent() == false);
                 return  readonlyFlag || groupisNOTEditable || keyForGroupisNOTPresent;
                   
             }
             
             /*** Access method that returns true if the field is the natural order 
              * field for the entities it is a part of. If no natural order field is 
              * defined the identity field will be used for natural order.
              */ 
             public boolean isNaturalOrder()
             {
                 return (mFlags & NATURAL_ORDER)!=0;
             }
 
             /*** Access method that returns the entity descriptor that the described 
              * field is part of.
              */
             public IEntityDescriptor getEntityDescriptor()
             {
                 return CompositeFieldGroup.this.mCompositeEntityDescriptor;
             }
     
             /*** This method returns true if the called field descriptor can validate
              * data described by the field in the context of the provided IDataProvider
              * object. The minimum requiriment is that described field data can be 
              * provided but in some cases other data resources is also required.
              */
             public boolean canValidate(IDataProvider dataProvider)
             {
                 //nno-todo what about valiadators?
                 return mRemoteFieldDescriptor.canValidate(dataProvider);
             }
             
             /*** This method validates the provided data object as described by the 
              * called field descriptor in the context of the provided IDataProvider 
              * object.
              */
             public ValidationResult validateData(Object data, IDataProvider dataProvider)
             {
                 ValidationResult result = ValidationResult.VALID_RESULT;
     
                 // Perform base validations.
                 result = this.performBaseValidation(data);
     
 //                // Check validity using registered validators.
 //                for(int j=0; result.isValid() && mValidatorList!=null && j<mValidatorList.size(); j++)
 //                    if(!((IDataValidator)mValidatorList.get(j)).isDataValid(data, dataProvider))
 //                        result = new ValidationResult(this, ((IDataValidator)mValidatorList.get(j)).getInvalidMessage(data, dataProvider));
     
                 return result;
             }
             
             
             /*** Performs basic validations that are relevant for all fields like
              * checking for null values in reguired field data.
              */
             public ValidationResult performBaseValidation(Object dataValue)
             {
                 // Validate null value.
                 if(dataValue==null && this.isRequired() && !this.isAutoGenerated())
                     return new ValidationResult(this, ResourceProvider.getString(this.getEntityDescriptor().getCodeName(), mCodeName+".RequiredMSG", "The "+this.getDisplayName()+" field may not be empty."));
     
                 // Validate length.
                 if(this.getDataType()==DataType.STRING && dataValue!=null && ((String)dataValue).length()>this.getLength() && this.getLength()>0)
                     return new ValidationResult(this, ResourceProvider.getString(this.getEntityDescriptor().getCodeName(), mCodeName+".ToLongMSG", "The "+this.getDisplayName()+" field is to long. It may only contain "+this.getLength()+" characters."));        
     
                 return ValidationResult.VALID_RESULT;
             }
             
     
             /*** Access method that returns the field relation that the called field  
              * is a reference to. If the called field descriptor is not a reference 
              * field then null is returned.
              */
             public IFieldRelation getReferenceFieldRelation()
             {
                 IFieldRelation refRelation = null;
                 java.util.Iterator it = this.getFieldRelations();
                 while(refRelation==null && it.hasNext())
                 {
                     IFieldRelation relation = (IFieldRelation)it.next();
                     if(relation.getReferenceField()==this)
                         refRelation = relation;
                 }
                 return refRelation;
             }
     
             /*** Access method that returns an iterator for all IFieldRelation 
              * objects that the called field descriptor is part of.
              */
             public java.util.Iterator getFieldRelations()
             {
                 Iterator it = this.getEntityDescriptor().getEntityRelations();
                 int count = 0;
                 while(it.hasNext())
                 {
                     IEntityRelation iEntityRelations = (IEntityRelation)it.next();
                     count = count + iEntityRelations.getFieldCount();
                 }
                 
                 IFieldRelation iFieldRelations[]  = new IFieldRelation[count];
                 
                 it = this.getEntityDescriptor().getEntityRelations();
                 int c = 0;
                 while(it.hasNext())
                 {
                     IEntityRelation iEntityRelation = (IEntityRelation)it.next();
                     for (int i = 0; i < iEntityRelation.getFieldCount(); i++)
                     {
                         iFieldRelations[c++] = iEntityRelation.getFieldRelation(i);
                         
                     }
                 }
                 
                 return org.caleigo.toolkit.util.Iterators.iterate(iFieldRelations);
             }
                 
             // ICompositeFieldDescriptor implementation ------------------------
             
             /*** Access method to the wrapped/remote field descriptor.
              */
             public IFieldDescriptor getRemoteFieldDescriptor()
             {
                 return mRemoteFieldDescriptor;
             }
             
             /*** Access method to the source field descriptor. This corresponds to 
              * looping through all remotes to the first non composite field.
              */
             public IFieldDescriptor getSourceFieldDescriptor()
             {
                 if(mRemoteFieldDescriptor instanceof ICompositeFieldDescriptor)
                     return ((ICompositeFieldDescriptor)mRemoteFieldDescriptor).getSourceFieldDescriptor();
                 else
                     return mRemoteFieldDescriptor;
             }
             
             /*** @return The ICompositeFieldGroup this composite field descriptor
              * belongs to.
              */
             public ICompositeFieldGroup getFieldGroup()
             {
                 return CompositeFieldGroup.this;
             }
             
             public String toString()
             {
             	return "Composite-"+getSourceFieldDescriptor();
             }      
             
             
             //Nested classes ---------------------------------------------------
             
             protected class FieldRelationIterator implements java.util.Iterator
             {
                 private int mEntityRelationIndex;
                 private int mFieldRelationIndex;
                 private Object mNextObject;
                 
                 public FieldRelationIterator()
                 {
                     mEntityRelationIndex = 0;
                     mFieldRelationIndex = 0;
                     this.next();
                 }
 
                 public Object next()
                 {
                     Object retObject = mNextObject;
                     
                     mNextObject = null;
                     while(mNextObject==null && mEntityRelationIndex<getEntityDescriptor().getEntityRelationCount())
                     {
                         // Scan all fields in the current entity relation.
                         while(mNextObject==null && mFieldRelationIndex<getEntityDescriptor().getEntityRelation(mEntityRelationIndex).getFieldCount())
                         {
                             // Check if field is part of the field relation
                             IFieldRelation rel = getEntityDescriptor().getEntityRelation(mEntityRelationIndex).getFieldRelation(mFieldRelationIndex);
                             if(rel.getReferenceField()==CompositeFieldDescriptor.this || rel.getTargetField()==CompositeFieldDescriptor.this)
                                 mNextObject = rel;
                             
                             // Advance to the next field relation.
                             mFieldRelationIndex++;
                         }
                         
                         // Advance to the next entity relation.
                         if(mFieldRelationIndex>=getEntityDescriptor().getEntityRelation(mEntityRelationIndex).getFieldCount())
                         {
                             mEntityRelationIndex++;
                             mFieldRelationIndex = 0;
                         }
                     }
 
                     return retObject;
                 }
 
                 public boolean hasNext() 
                 {
                     return mNextObject!=null;
                 }
 
                 public void remove() 
                 {
                     throw new java.lang.UnsupportedOperationException();
                 }
             }//FieldRelationIterator
             
             
         }//CompositeFieldDescriptor
     
     }//CompositeFieldGroup
     
     
     
     
     
     /*** Basic implementation of the IFieldRelation for Composite Field Relations.
      * @see IFieldRelation
      * @see FieldRelation
      * 
      * This implementation of the IFieldRelation requires that the classes
      * of the linked descriptors has been loaded and initialized.
      *
      * @author  Niklas Norberg
      * @version 1.00
      *
      *//* 
      *
      * WHEN        WHO               WHY & WHAT
      * -----------------------------------------------------------------------------
      * 2003-12-03  Niklas Norberg    Creation: copied FieldRelation.java and
      *                                          outcommented code.
      */
     protected static class CompositeFieldRelation implements IFieldRelation
     {
         // Data members ------------------------------------------------------------
         private IEntityRelation mEntityRelation;
         
 //        private transient IFieldDescriptor mReferenceField;
 //        private transient IFieldDescriptor mTargetField;
         private IFieldDescriptor mReferenceField;
         private IFieldDescriptor mTargetField;
         
         // Constructors ------------------------------------------------------------
         
         /*** Constructor for FieldRelation. Note package scope to avoid missuse.
          */
         CompositeFieldRelation(IFieldDescriptor referenceFieldDescriptor,
                 IFieldDescriptor targetFieldDescriptor)
         {
             mReferenceField = referenceFieldDescriptor;
             mTargetField = targetFieldDescriptor;
         }
         
         // Superclass overrides ----------------------------------------------------
         public boolean equals(Object obj)
         {
             if(obj==null || !(obj instanceof IFieldRelation))
                 return false;
             
             IFieldRelation relation = (IFieldRelation)obj;
                     
             return this.getReferenceField()==relation.getReferenceField()
                     && this.getTargetField()==relation.getTargetField();
         }
         
         // IFieldRelation implementation -------------------------------------------
         
         /*** Access method that return the IEntityRelation that the called
          * IFieldRelation is a part of.
          */ 
         public IEntityRelation getEntityRelation()
         {
             return mEntityRelation;
         }
         
         /*** Access method that return the IFieldDescriptor that is the 
          * source/reference field that addresses another field. In RDB terms the
          * reference field is or should be defined as a foreign key.  
          */ 
         public IFieldDescriptor getReferenceField()
         {
             return mReferenceField;
         }
         
         /*** Access method that return the IFieldDescriptor that is the 
          * target field that are addressed by the reference field. In RDB terms the
          * target field is usually a primary-key field.  
          */ 
         public IFieldDescriptor getTargetField()
         {
             return mTargetField;
         }
         
         // Help methods ------------------------------------------------------------
         
         /*** Mutation method with restricted access to avoid missuse.
          */
         void setEntityRelation(IEntityRelation relation)
         {
             mEntityRelation = relation;
         }
         
     }
     
     
     
     /*** The default store action used by the CompositeEntityDescriptor class.
     * @author Niklas Norberg
     */
     public static class CompositeStoreEntityAction extends AbstractTransactionEntityAction implements IUnaryEntityAction
     {
         
         IEntity insertedBaseEntity = null;
         
         // Constructors --------------------------------------------------------
         public CompositeStoreEntityAction(ICompositeEntityDescriptor entityDescriptor)
         {
         	super(entityDescriptor, STORE_ACTION, "Store", null);      
         }
         
         
         // Superclass overrides -----------------------------------------------
     
         /*** Prepare method for the action where the action is expected to add 
         * the data operations needed to perform the action.
         */
         public void prepareTransaction(IDataBundle data, IDataTransaction transaction)
         {
             IEntity iEntity = (IEntity)data.getData(0);
             
             this.prepareEntityData(iEntity);
             this.validateData(data);
             
             
             //transaction.addStore(iEntity);
             //that code-line from AbstractEntityDescriptor.java is replaced with:
             
             //validate descriptor
             ICompositeEntityDescriptor iCompositeEntityDescriptor;
             if( !(iEntity.getEntityDescriptor() instanceof  ICompositeEntityDescriptor) )
                 throw new InvalidDescriptorException("The entities descriptor must be an ICompositeEntityDescriptor");
             else
                 iCompositeEntityDescriptor = (ICompositeEntityDescriptor)iEntity.getEntityDescriptor();
             
             //update all dirty field groups or insert the root group
             if(iEntity.isPersistent())
             {   //executeUpdate
                 
                 //iterate over all field groups searching for dirty fields
                 for (Iterator groupIterator = iCompositeEntityDescriptor.getRootFieldGroup().getFieldGroups(); groupIterator.hasNext();)
                 {
                     ICompositeEntityDescriptor.ICompositeFieldGroup group = (ICompositeEntityDescriptor.ICompositeFieldGroup) groupIterator.next();
                     
                     //tmp variable used for checking and copying (and for shortening code-lines)!
                     ICompositeEntityDescriptor.ICompositeFieldDescriptor compositeFieldDescriptor;
                                 
                     //check if there is a dirty field in the iterated group
                     int posInGroup = 0;
                     while(posInGroup < group.getFieldCount())
                     {
                         compositeFieldDescriptor = (ICompositeEntityDescriptor.ICompositeFieldDescriptor)group.getFieldDescriptor(posInGroup);
                         if( iEntity.isFieldDirty( compositeFieldDescriptor ) )
                             break;
                         posInGroup++;
                     }
                     
                     if( posInGroup < group.getFieldCount() )
                     {//store data for this field group
                         
                         //get a primary-key for the iterated group
                         CompositeQualifier key = getKeyForFieldGroup(group, iEntity);
                         
                         //load the base entity used for storing
                         IEntity baseEntity = group.getBaseEntityDescriptor().loadEntity(key);
                                 
                         //copy data from the composite-entity -> the loaded base entity
                         while(posInGroup < group.getFieldCount())
                         {
                             compositeFieldDescriptor = (ICompositeEntityDescriptor.ICompositeFieldDescriptor)group.getFieldDescriptor(posInGroup);
                             if( iEntity.isFieldDirty( compositeFieldDescriptor ) )
                                 baseEntity.setData(compositeFieldDescriptor.getSourceFieldDescriptor(),iEntity.getData(compositeFieldDescriptor));
                             posInGroup++;
                         }
                         
                         //AND FINALLY ADD THE BASE ENTITY CONTAINING COPIED DATA 2 TRANSACTION
                         transaction.addStore(baseEntity);
                     
                     }
                 }
             }
             else
             {//executeInsert
                 
                 //Only insert entity for the root field group
                 ICompositeEntityDescriptor.ICompositeFieldGroup rootGroup = iCompositeEntityDescriptor.getRootFieldGroup();
                                     
                 //create the base entity used 2 store
                 IEntity baseEntity = rootGroup.getBaseEntityDescriptor().createEntity();
                                             
                 //copy data from the composite-entity -> the created base entity
                 int posInGroup = 0;
                 while(posInGroup < rootGroup.getFieldCount())
                 {
                     ICompositeEntityDescriptor.ICompositeFieldDescriptor compositeFieldDescriptor;
                     compositeFieldDescriptor = (ICompositeEntityDescriptor.ICompositeFieldDescriptor)rootGroup.getFieldDescriptor(posInGroup);
                     if( iEntity.isFieldDirty( compositeFieldDescriptor ) )
                         baseEntity.setData(compositeFieldDescriptor.getSourceFieldDescriptor(),iEntity.getData(compositeFieldDescriptor));
                     posInGroup++;
                 }
                                     
                 //AND FINALLY ADD THE BASE ENTITY CONTAINING COPIED DATA 2 TRANSACTION
                 transaction.addStore(baseEntity);
                 insertedBaseEntity = baseEntity;
                 
             }
             
         }
         
         /*** Clean up method for the action where the action can clean up data
          * operations, if necessary via an overriding method in an implementing
          * class,  which were performed by the action. E.g. resetting flags etc.
          */
         public void cleanUpTransaction(IDataBundle data, IDataTransaction transaction)
         {
             IEntity entity = (IEntity)data.getData(0);
             
             // validate descriptor
             ICompositeEntityDescriptor compositeEntityDescriptor;
             if( !(entity.getEntityDescriptor() instanceof  ICompositeEntityDescriptor) )
                 throw new InvalidDescriptorException("The entities descriptor must be an ICompositeEntityDescriptor");
             else
                 compositeEntityDescriptor = (ICompositeEntityDescriptor)entity.getEntityDescriptor();
             
             if(insertedBaseEntity != null)
             {
                 //copy over IdentityField-data from the the created base entity -> composite-entity
                 for (int i = 0; i < compositeEntityDescriptor.getRootFieldGroup().getFieldCount(); i++)
                 {
                     ICompositeEntityDescriptor.ICompositeFieldDescriptor compositeFieldDescriptor = (ICompositeEntityDescriptor.ICompositeFieldDescriptor)compositeEntityDescriptor.getRootFieldGroup().getFieldDescriptor(i);
                     if(compositeFieldDescriptor.isIdentityField())
                         entity.setData(compositeFieldDescriptor ,insertedBaseEntity.getData(compositeFieldDescriptor.getSourceFieldDescriptor()));
                 }
                 insertedBaseEntity = null;
             }
             
             //Reload the entity and copy over data 2 get refreshing!
             
 //            // get a primary-key for the root group
 //            //CompositeQualifier key = getKeyForFieldGroup(iCompositeEntityDescriptor.getRootFieldGroup(), iEntity);          
 //            CompositeQualifier key = new CompositeQualifier();
 //            for(int i=0;i<compositeEntityDescriptor.getRootFieldGroup().getFieldCount();i++)
 //            {
 //               ICompositeEntityDescriptor.ICompositeFieldDescriptor compositeFieldDescriptor;
 //               compositeFieldDescriptor = (ICompositeEntityDescriptor.ICompositeFieldDescriptor)compositeEntityDescriptor.getRootFieldGroup().getFieldDescriptor(i);
 //               if( compositeFieldDescriptor.isIdentityField() )
 //               {
 //                   key.add(new RelationQualifier(compositeFieldDescriptor, entity.getData(compositeFieldDescriptor)));
 //                   break;
 //               }
 //            }        
 //            IDataService iDataService = iCompositeEntityDescriptor.getDataSourceDescriptor().getDefaultDataSource().getDataService();
 //            if (iDataService instanceof CachedDataService)
 //                iDataService = ((CachedDataService)iDataService).getSourceDataService();
 //            IEntity tmpIEntity = iDataService.load(iCompositeEntityDescriptor, key);
 //            
 //            //copy over all data
 //            for (int i = 0; i < iEntity.getEntityDescriptor().getFieldCount(); i++)
 //            {
 //                iEntity.setData(iEntity.getEntityDescriptor().getFieldDescriptor(i), tmpIEntity.getData(tmpIEntity.getEntityDescriptor().getFieldDescriptor(i)));
 //            }
             
             entity.refresh();
             
             entity.setStatusFlag(IEntity.PERSISTENT);
             entity.clearStatusFlag(IEntity.DIRTY | IEntity.EMPTY);
             
 //            //reload sub-entities to make changes appear in them
 //            Iterator groupIterator = compositeEntityDescriptor.getRootFieldGroup().getFieldGroups();
 //            while (groupIterator.hasNext())
 //            {
 //                ICompositeFieldGroup fieldGroup = (ICompositeFieldGroup) groupIterator.next();
 //                CompositeQualifier key = getKeyForFieldGroup(fieldGroup, entity);
 //                //IEntity subEntity = fieldGroup.getBaseEntityDescriptor().loadEntity(key);
 //                
 //                IDataService dataService = compositeEntityDescriptor.getDataSourceDescriptor().getDefaultDataSource().getDataService();
 //                if (dataService instanceof CachedDataService )
 //                    dataService = ((CachedDataService)dataService).getSourceDataService();
 //                IEntity tmpIEntity = dataService.load(fieldGroup.getBaseEntityDescriptor(), key);
 //            }
               
         }
         
         /*** This method is called by the action objects constructor once and only 
          * once. The method is expected to define the action data requriments
          * (IDataBundleDescriptor) using the diferent add methods for descriptors
          * defined in this class.
          */
         public final void defineDataDescriptor()
         {
             this.addEntityDescriptor(this.getEntityDescriptor(), this.getEntityDescriptor().getCodeName(), this.getEntityDescriptor().getDisplayName(), null);
         }
         
 //      IUnaryEntityAction implementation -----------------------------------
         public void perform(IEntity entity)
         {
             IDataBundle data = this.getDataBundleDescriptor().createActionData();
             data.setData(0, entity);
             this.perform(data);
         }
         
         // Help methods --------------------------------------------------------
         
         /*** Simple help method that is called when an action are triggered 
          * emmidiatelly before the action is validated. The method is 
          * provided for optional override and does nothing by default.
          */
         protected void prepareEntityData(IEntity entity)
         {
         }
     
     }//CompositeStoreEntityAction
     
     
     
     /*** The default delete action used by the CompositeEntityDescriptor class.
      * @author Niklas Norberg
      */
     public static class CompositeDeleteEntityAction extends AbstractTransactionEntityAction implements IUnaryEntityAction
     {
         // Constructors --------------------------------------------------------
         public CompositeDeleteEntityAction(ICompositeEntityDescriptor entityDescriptor)
         {
             super(entityDescriptor, DELETE_ACTION, "Delete", null);
         }
 
         // Superclass overrides -----------------------------------------------
 
         /*** Prepare method for the action where the action is expected to add 
          * the data operations needed to perform the action.
          */
         public void prepareTransaction(IDataBundle data, IDataTransaction transaction)
         {
             if(((IEntity)data.getData(0)).isPersistent())
             {
                 IEntity iEntity = (IEntity)data.getData(0);
                 
                 //transaction.addDelete(iEntity);
                 //that code-line from AbstractEntityDescriptor.java is replaced with:
     
                 //validate descriptor
                 ICompositeEntityDescriptor iCompositeEntityDescriptor;
                 if( !(iEntity.getEntityDescriptor() instanceof  ICompositeEntityDescriptor) )
                     throw new InvalidDescriptorException("The entities descriptor must be an ICompositeEntityDescriptor");
                 else
                     iCompositeEntityDescriptor = (ICompositeEntityDescriptor)iEntity.getEntityDescriptor();
                
                 ICompositeEntityDescriptor.ICompositeFieldGroup rootGroup = iCompositeEntityDescriptor.getRootFieldGroup();
                 
                 //create an primary-key for the iterated group
                 CompositeQualifier key = getKeyForFieldGroup(rootGroup, iEntity);
                     
                 //load the base entity to delete
                 IEntity baseEntity = rootGroup.getBaseEntityDescriptor().loadEntity(key);
                 
                 //AND FINALLY ADD THE BASE ENTITY TO BE DELETED TO THE TRANSACTION
                 transaction.addDelete(baseEntity);
             }
         }
 
         /*** Clean up method for the action where the action can clean up data
          * operations, if necessary via an overriding method in an implementing
          * class,  which were performed by the action. E.g. resetting flags etc.
          */
         public void cleanUpTransaction(IDataBundle data, IDataTransaction transaction)
         {
             IEntity iEntity = (IEntity)data.getData(0);
             iEntity.clearStatusFlag(IEntity.PERSISTENT);
         }
         
         /*** This method is called by the action objects constructor once and only 
         * once. The method is expected to define the action data requriments
         * (IDataBundleDescriptor) using the diferent add methods for descriptors
         * defined in this class.
         */
         public final void defineDataDescriptor()
         {
             this.addEntityDescriptor(this.getEntityDescriptor(), this.getEntityDescriptor().getCodeName(), this.getEntityDescriptor().getDisplayName(), null);
         }
      
 
         // IUnaryEntityAction implementation -----------------------------------
         public void perform(IEntity entity)
         {
             IDataBundle data = this.getDataBundleDescriptor().createActionData();
             data.setData(0, entity);
             this.perform(data);
         }
     
     }//CompositeDeleteEntityAction
     
     
     public static CompositeQualifier getKeyForFieldGroup(
                             ICompositeEntityDescriptor.ICompositeFieldGroup group, 
                             IEntity iEntity)
     {
         // create an primary-key for the field group
         CompositeQualifier key = new CompositeQualifier();
         IFieldDescriptor[] keyFieldDescriptors = Relations.getIdentityFields(group.getBaseEntityDescriptor());
         for (int k = 0; k < keyFieldDescriptors.length; k++)
             for(int i=0;i<group.getFieldCount();i++)
             {
                 ICompositeEntityDescriptor.ICompositeFieldDescriptor compositeFieldDescriptor;
                 compositeFieldDescriptor = (ICompositeEntityDescriptor.ICompositeFieldDescriptor)group.getFieldDescriptor(i);
                 if( compositeFieldDescriptor.getSourceFieldDescriptor() == keyFieldDescriptors[k] )
                 {
                     key.add(new RelationQualifier(keyFieldDescriptors[k], iEntity.getData(compositeFieldDescriptor)));
                     break;
                 }
             }
         return key;      
     }
          
 }//CompositeEntityDescriptor