Project

Clover coverage report - JBind Project
Coverage timestamp: Fr Mai 28 2004 11:17:36 CEST
file stats:	LOC:	564		Methods:	31
	NCLOC:	407		Classes:	3
This license of Clover is provided to support the development of JBind only. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover.
Source file
Conditionals
Statements
Methods
TOTAL
DataCartridge.java
65,4%
97,1%
96,8%
87,3%
 /*
  * JBind
  *
  * Copyright (c) by Stefan Wachter. All rights reserved.
  *
  * Usage, modification, and redistribution is subject to license terms that are
  * available at 'http://www.jbind.org'. The JBind license is like the
  * 'Apache Software License V 1.1'.
  */
 package org.jbind.xml.schema.compiler;
 
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.IOException;
 import java.io.Reader;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.StringTokenizer;
 import java.util.TreeMap;
 
 import org.jbind.message.IMessage;
 import org.jbind.util.collection.ConcatIterator;
 import org.jbind.util.reflect.ReflectUtil;
 import org.jbind.xml.base.IAttribute;
 import org.jbind.xml.base.IBindingAttributes;
 import org.jbind.xml.base.IRange;
 import org.jbind.xml.base.IRef;
 import org.jbind.xml.base.RefComparator;
 import org.jbind.xml.base.StringUtil;
 import org.jbind.xml.core.bridge.IXPathMethod;
 import org.jbind.xml.core.cmp.IAttributesModel;
 import org.jbind.xml.core.cmp.IBinding;
 import org.jbind.xml.core.cmp.IComponent;
 import org.jbind.xml.core.cmp.IContentModel;
 import org.jbind.xml.core.cmp.ISourceInfo;
 import org.jbind.xml.core.constraint.ConstraintType;
 import org.jbind.xml.core.constraint.IIdRefOrIdRefsConstraint;
 import org.jbind.xml.core.constraint.IReferenceConstraint;
 import org.jbind.xml.core.constraint.ITypeKeyRefConstraint;
 import org.jbind.xml.core.content.IAttrRefOrDecl;
 import org.jbind.xml.core.content.IDataRefOrDecl;
 import org.jbind.xml.core.content.IElemRefOrDecl;
 import org.jbind.xml.core.type.IAnyType;
 import org.jbind.xml.msg.XmlException;
 import org.jbind.xml.msg.XmlMessages;
 
 public abstract class DataCartridge extends BaseCartridge {
 
   public DataCartridge(String aCartridgeAttributePrefix, String aNamePrefix, String aNameSuffix) {
     super(aCartridgeAttributePrefix, aNamePrefix, aNameSuffix);
   }
 
   public boolean overwrite() {
     return true;
   }
 
   public boolean isUpToDate(Reader aReader, IFileInfo aFileInfo) throws IOException {
     BufferedReader reader = new BufferedReader(aReader);
     StringTokenizer stringTokenizer = new StringTokenizer(aFileInfo.getGeneratedCode(), "\n");
     while (true) {
       String previousLine = reader.readLine();
       if (null == previousLine) {
         if (stringTokenizer.hasMoreElements()) {
           return false;
         } else {
           return true;
         }
       }
       if (!stringTokenizer.hasMoreElements()) {
         return false;
       }
       String generatedLine = (String)stringTokenizer.nextElement();
       if (!previousLine.equals(generatedLine)) {
         return false;
       }
     }
   }
 
   public IMessage getEditHint(File aFile, IComponent aComponent) {
     assert false;
     return null;
   }
 
   public IBinding createGlobalAttrDeclBinding(IComponent aComponent, String aRootPackage, boolean aUseBuiltInClassesOnly) {
     return new PackageBinding(aRootPackage, this, aComponent);
   }
   public IBinding createGlobalGroupDeclBinding(IComponent aComponent, String aRootPackage, boolean aUseBuiltInClassesOnly) {
     return new GlobalBinding(aRootPackage, this, aComponent);
   }
   public IBinding createGlobalElemDeclBinding(IComponent aComponent, String aRootPackage, boolean aUseBuiltInClassesOnly) {
     return new PackageBinding(aRootPackage, this, aComponent);
   }
   public IBinding createGlobalAttrGroupBinding(IComponent aComponent, String aRootPackage, boolean aUseBuiltInClassesOnly) {
     return new GlobalBinding(aRootPackage, this, aComponent);
   }
   public IBinding createBuiltInBinding(IComponent aComponent) {
     return new BuiltInBinding(aComponent, doGetBuiltInPackage(), getNamePrefix(aComponent), getNameSuffix(aComponent));
   }
   public IBinding createInnerAttrRefBinding(IComponent aComponent, IBinding aParentBinding, boolean aUseBuiltInClassesOnly) {
     return aParentBinding;
   }
   public IBinding createInnerAttrDeclBinding(IComponent aComponent, IBinding aParentBinding, boolean aUseBuiltInClassesOnly) {
     return aParentBinding;
   }
   public IBinding createInnerAttrWildcardBinding(IComponent aComponent, IBinding aParentBinding, boolean aUseBuiltInClassesOnly) {
     return aParentBinding;
   }
   public IBinding createInnerGroupRefOrDeclBinding(IComponent aComponent, IBinding aParentBinding, boolean aUseBuiltInClassesOnly) {
     return aParentBinding;
   }
   public IBinding createInnerElemRefBinding(IComponent aComponent, IBinding aParentBinding, boolean aUseBuiltInClassesOnly) {
     return aParentBinding;
   }
   public IBinding createInnerElemDeclBinding(IComponent aComponent, IBinding aParentBinding, boolean aUseBuiltInClassesOnly) {
     return aParentBinding;
   }
   public IBinding createInnerElemWildcardBinding(IComponent aComponent, IBinding aParentBinding, boolean aUseBuiltInClassesOnly) {
     return aParentBinding;
   }
   public IBinding createInnerAttrGroupBinding(IComponent aComponent, IBinding aParentBinding, boolean aUseBuiltInClassesOnly) {
     return aParentBinding;
   }
 
   protected abstract String doGetBuiltInPackage();
 
   protected boolean doVisitAnyTypeStart(IAnyType aType) throws XmlException {
     writeMultiLn(typeComment(aType));
     writeLn(declaration(aType) + " {");
     addIndent();
     writeMultiLn(begin(aType));
     setOuterComponent(aType);
     if (!treatMethods(aType)) {
       return true;
     }
     setNotEmpty();
 
     /**
      * Maps property names to their components. Used to indicate naming problems
      * during generation.
      */
     Map propertyNames = new HashMap();
 
     MethodVariant pv = null;
 
     //
     // elements
     //
 
     // The elements are sorted to guarantee the same sequence of generation.
     Map elementInfos = new TreeMap(RefComparator.INSTANCE);
     collectElementInfos(aType, elementInfos, false);
 
     for (Iterator i = elementInfos.values().iterator(); i.hasNext(); ) {
       ElementInfo elementInfo = (ElementInfo)i.next();
       IElemRefOrDecl elemRefOrDecl = elementInfo.elemRefOrDecl;
 
       // check if the property name is unique
       String propertyName = propertyName(elemRefOrDecl);
       ISourceInfo previous = (ISourceInfo)propertyNames.put(propertyName, elemRefOrDecl);
       if (null != previous) {
         throw new XmlException(XmlMessages.ambiguousProperty(propertyName, previous.getLocation(), elemRefOrDecl));
       }
 
       boolean useDataClass = useDataClass(elemRefOrDecl);
 
       if (elementInfo.isSingle && (!elementInfo.isInheritedSingle || treatInherited())) {
         if (MethodVariant.NONE != (pv = MethodVariant.getMethodVariant(elemRefOrDecl, IBindingAttributes.GETTER, "normal"))) {
           writeMultiLn(elementGetter(aType, elemRefOrDecl, pv, useDataClass));
         }
         if (MethodVariant.NONE != (pv = MethodVariant.getMethodVariant(elemRefOrDecl, IBindingAttributes.CHECKER, "none"))) {
           writeMultiLn(elementChecker(aType, elemRefOrDecl, pv));
         }
         if (MethodVariant.NONE != (pv = MethodVariant.getMethodVariant(elemRefOrDecl, IBindingAttributes.REMOVER, "none"))) {
           writeMultiLn(elementRemover(aType, elemRefOrDecl, pv));
         }
       }
 
       if (!elementInfo.isInherited || treatInherited()) {
         if (MethodVariant.NONE != (pv = MethodVariant.getMethodVariant(elemRefOrDecl, IBindingAttributes.CREATOR, "none"))) {
           writeMultiLn(elementCreator(aType, elemRefOrDecl, pv));
         }
       }
 
       if (!elementInfo.isInherited || treatInherited()) {
         if (MethodVariant.NONE != (pv = MethodVariant.getMethodVariant(elemRefOrDecl, IBindingAttributes.CREATOR_WITH_TYPE, "none"))) {
           writeMultiLn(elementCreatorWithType(aType, elemRefOrDecl, pv));
         }
       }
 
       if (elementInfo.isMultiple && (!elementInfo.isInheritedMultiple || treatInherited())) {
         if (MethodVariant.NONE != (pv = MethodVariant.getMethodVariant(elemRefOrDecl, IBindingAttributes.ITERATOR, "normal"))) {
           writeMultiLn(elementIterator(aType, elemRefOrDecl, pv, useDataClass));
         }
       }
 
     }
 
     IAnyType baseType = aType.getBaseType();
 
     //
     // attributes
     //
 
     for (Iterator i = aType.getAttributesModel().iterAttributes();
             i.hasNext(); ) {
       IAttrRefOrDecl attr = (IAttrRefOrDecl)i.next();
       IRef ref = attr.getGlobalRef();
       IAttrRefOrDecl baseAttr = getBaseAttributeDecl(ref, aType);
 
       // check if the property name is unique
       String propertyName = propertyName(attr);
       ISourceInfo previous = (ISourceInfo)propertyNames.put(propertyName, attr);
       if (null != previous) {
         throw new XmlException(XmlMessages.ambiguousProperty(propertyName, previous.getLocation(), attr));
       }
 
       boolean useDataClass = useDataClass(baseAttr);
 
       // indicates if the attribute is inherited
       boolean inherited = baseType.getAttributesModel().hasAttribute(ref);
 
       if (!inherited || treatInherited()) {
         if (MethodVariant.NONE != (pv = MethodVariant.getMethodVariant(baseAttr, IBindingAttributes.GETTER, "normal"))) {
           writeMultiLn(attributeGetter(aType, baseAttr, pv, useDataClass));
         }
         if (MethodVariant.NONE != (pv = MethodVariant.getMethodVariant(baseAttr, IBindingAttributes.SETTER, "none"))) {
           writeMultiLn(attributeSetter(aType, baseAttr, pv, useDataClass));
         }
         if (MethodVariant.NONE != (pv = MethodVariant.getMethodVariant(baseAttr, IBindingAttributes.ITERATOR, "normal"))) {
           writeMultiLn(attributeIterator(aType, baseAttr, pv, useDataClass));
         }
         if (MethodVariant.NONE != (pv = MethodVariant.getMethodVariant(baseAttr, IBindingAttributes.CHECKER, "none"))) {
           writeMultiLn(attributeChecker(aType, baseAttr, pv));
         }
         if (MethodVariant.NONE != (pv = MethodVariant.getMethodVariant(baseAttr, IBindingAttributes.REMOVER, "none"))) {
           writeMultiLn(attributeRemover(aType, baseAttr, pv));
         }
       }
     }
 
     //
     // reference constraints
     //
 
     List l = new ArrayList();
     for (Iterator i = aType.getConstraints().getConstraintList(ConstraintType.TYPE_KEY_REF).iterator();
             i.hasNext(); ) {
       ITypeKeyRefConstraint c = (ITypeKeyRefConstraint)i.next();
       String propertyName = c.getLocalStringBindingAttribute(IBindingAttributes.NAME);
       if (null == propertyName) {
         propertyName = c.getName();
       }
       String comment = "keyRef (" + c.getName() + ")";
       l.add(new RefConstraintInfo(c, c.getConstraintKey(), StringUtil.firstUpper(StringUtil.toJavaIdentifier(propertyName)), comment, c.getDataType()));
     }
     Iterator i1 = aType.getConstraints().getConstraintList(ConstraintType.ID_REF).iterator();
     Iterator i2 = aType.getConstraints().getConstraintList(ConstraintType.ID_REFS).iterator();
     for (Iterator i = new ConcatIterator(i1, i2); i.hasNext(); ) {
       IIdRefOrIdRefsConstraint c = (IIdRefOrIdRefsConstraint)i.next();
       String propertyName = c.getAttrRefOrDecl().getLocalStringBindingAttribute(IBindingAttributes.NAME);
       if (null == propertyName) {
         propertyName = c.getAttrRefOrDecl().getGlobalRef().getLocalPart();
       }
       String comment = null;
       if (c.isSingleNotMultipleReference()) {
         comment = "IDREF(" + c.getAttrRefOrDecl().getGlobalRef().getLocalPart() + ")";
       } else {
         comment = "IDREFS(" + c.getAttrRefOrDecl().getGlobalRef().getLocalPart() + ")";
       }
 
       l.add(new RefConstraintInfo(c, c.getConstraintKey(), StringUtil.firstUpper(StringUtil.toJavaIdentifier(propertyName)), comment, c.getDataType()));
     }
     for (Iterator i = l.iterator(); i.hasNext(); ) {
       RefConstraintInfo constraintInfo = (RefConstraintInfo)i.next();
       IReferenceConstraint constraint = constraintInfo.referenceConstraint;
       // indicates if the constraint is inherited
       boolean inherited = baseType.getConstraints().hasConstraint(constraint);
       if (!inherited || treatInherited()) {
         if (constraint.isSingleNotMultipleReference()) {
           if (MethodVariant.NONE != (pv = MethodVariant.getMethodVariant(constraint, IBindingAttributes.REFERENCE_GETTER, "normal"))) {
             writeMultiLn(referenceGetter(aType, constraintInfo, pv));
           }
         }
         if (!constraint.isSingleNotMultipleReference()) {
           if (MethodVariant.NONE != (pv = MethodVariant.getMethodVariant(constraint, IBindingAttributes.REFERENCE_ITERATOR, "normal"))) {
             writeMultiLn(referenceIterator(aType, constraintInfo, pv));
           }
         }
       }
     }
 
     ArrayList xPathMethods = new ArrayList(aType.getXPathMethods().values());
     Collections.sort(xPathMethods, new Comparator() {
       public int compare(Object anObject1, Object anObject2) {
         IXPathMethod m1 = (IXPathMethod)anObject1;
         IXPathMethod m2 = (IXPathMethod)anObject2;
         return m1.getName().compareTo(m2.getName());
       }
     });
 
     for (Iterator i = xPathMethods.iterator(); i.hasNext(); ) {
       IXPathMethod m = (IXPathMethod)i.next();
       boolean inherited = null != baseType.getXPathMethods().get(m.getName());
       if (!inherited || treatInherited()) {
         writeMultiLn(xPathMethod(aType, m, pv));
       }
     }
 
     return true;
   }
 
   protected void doVisitAnyTypeEnd(IAnyType aType) {
     removeIndent();
     writeLn("}");
   }
 
   /**
    * Collects the property infos of all element declarations of this type and
    * all of its super types. Element declararations may have be removed from a
    * type be restriction. Yet, the corresponding methods must be generated in
    * the data class.
    */
   private void collectElementInfos(IAnyType aType, Map aMap, boolean aSuperType) {
     if (null != aType) {
       collectElementInfos(aType.getBaseType(), aMap, true);
       IContentModel contentModel = aType.getContentModel();
       for (Iterator i = contentModel.iterElements(); i.hasNext(); ) {
         IElemRefOrDecl e = (IElemRefOrDecl)i.next();
         IRef ref = e.getGlobalRef();
         ElementInfo ei = (ElementInfo)aMap.get(ref);
         if (null == ei) {
           ei = new ElementInfo(e);
           aMap.put(ref, ei);
         }
         IRange range = contentModel.getRange(ref);
         boolean isSingle = range.compareMaxOccurs(1);
         boolean isMultiple = range.isUnbounded() || (range.getMaxOccurs() > 1);
         ei.isSingle |= isSingle;
         ei.isMultiple |= isMultiple;
         ei.isInheritedSingle |= isSingle && aSuperType;
         ei.isInheritedMultiple |= isMultiple && aSuperType;
         ei.isInherited |= aSuperType;
       }
     }
   }
 
   protected boolean useDataClass(IDataRefOrDecl aRefOrDecl) {
     boolean res = false;
     IAttribute a = null;
     a = aRefOrDecl.getBindingAttribute(IBindingAttributes.USE_DATA_CLASS);
     if (a != null) {
       res = a.getBoolean();
     } else {
       a = aRefOrDecl.getType().getDefaultedLocalBindingAttribute(IBindingAttributes.HAS_BEHAVIOUR);
       if (a != null) {
         res = a.getBoolean();
       }
     }
     return res;
   }
 
   /**
    * Gets the property name of the decl. The first letter of the property name
    * is guaranteed to be an upper case letter.
    *
    * @param anAttrOrElem <i>(required)</i>.
    * @return <i>(required)</i>.
    */
   protected String propertyName(IDataRefOrDecl anAttrOrElem) {
     String res = anAttrOrElem.getLocalStringBindingAttribute(IBindingAttributes.NAME);
     if (null == res) {
       res = StringUtil.firstUpper(anAttrOrElem.getName());
     }
     return StringUtil.firstUpper(StringUtil.toJavaIdentifier(res));
   }
 
   /**
    * Gets the base attribute declaration for a reference. The base attribute
    * declaration is the attribute declaration from that base type that has no base
    * type that also has the attribute.
    */
   private IAttrRefOrDecl getBaseAttributeDecl(IRef aRef, IAnyType aType) {
     IAttrRefOrDecl res = null;
     for (IAnyType t = aType; ; t = t.getBaseType()) {
       IAttributesModel m = t.getAttributesModel();
       IAttrRefOrDecl a = m.getAttrRefOrDecl(aRef);
       if (null == a) {
         break;
       }
       res = a;
     }
     return res;
   }
 
   //
   // Hook methods
   //
 
   protected abstract String typeComment(IAnyType aType);
   protected abstract String declaration(IAnyType aType);
   protected abstract String begin(IAnyType aType);
 
   protected abstract String elementGetter(IAnyType aType, IElemRefOrDecl aRefOrDecl, MethodVariant aPropertyVariant, boolean aUseDataClass);
   protected abstract String elementChecker(IAnyType aType, IElemRefOrDecl aRefOrDecl, MethodVariant aPropertyVariant);
   protected abstract String elementRemover(IAnyType aType, IElemRefOrDecl aRefOrDecl, MethodVariant aPropertyVariant);
   protected abstract String elementCreator(IAnyType aType, IElemRefOrDecl aRefOrDecl, MethodVariant aPropertyVariant);
   protected abstract String elementCreatorWithType(IAnyType aType, IElemRefOrDecl aRefOrDecl, MethodVariant aPropertyVariant);
   protected abstract String elementIterator(IAnyType aType, IElemRefOrDecl aRefOrDecl, MethodVariant aPropertyVariant, boolean aUseDataClass);
 
   protected abstract String attributeGetter(IAnyType aType, IAttrRefOrDecl aRefOrDecl, MethodVariant aPropertyVariant, boolean aUseDataClass);
   protected abstract String attributeChecker(IAnyType aType, IAttrRefOrDecl aRefOrDecl, MethodVariant aPropertyVariant);
   protected abstract String attributeRemover(IAnyType aType, IAttrRefOrDecl aRefOrDecl, MethodVariant aPropertyVariant);
   protected abstract String attributeSetter(IAnyType aType, IAttrRefOrDecl aRefOrDecl, MethodVariant aPropertyVariant, boolean aUseDataClass);
   protected abstract String attributeIterator(IAnyType aType, IAttrRefOrDecl aRefOrDecl, MethodVariant aPropertyVariant, boolean aUseDataClass);
 
   protected abstract String referenceGetter(IAnyType aType, RefConstraintInfo aConstraintInfo, MethodVariant aPropertyVariant);
   protected abstract String referenceIterator(IAnyType aType, RefConstraintInfo aConstraintInfo, MethodVariant aPropertyVariant);
 
   protected abstract String xPathMethod(IAnyType aType, IXPathMethod aMethod, MethodVariant aPropertyVariant);
 
   /**
    * Checks if code for methods is to be created. No method code is generated for
    * abstract data classes. Yet the abstract data class itself is to be created
    * because it may contain inner classes that are not abstract.
    *
    * @param aType <i>(required)</i>.
    * @return Returns <code>true</code> iff code for methods is to be created.
    */
   protected abstract boolean treatMethods(IAnyType aType);
 
   protected abstract boolean treatInherited();
 
   protected static class RefConstraintInfo {
 
     IReferenceConstraint referenceConstraint;
     /**
      * Key of the reference constraint. The key must be unique within the
      * type the reference constraint belongs to. The key is used by the methods
      * that are generated to access their referenced data.
      */
     String constraintKey;
     String propertyName;
     String comment;
     IAnyType dataType;
     RefConstraintInfo(IReferenceConstraint aConstraint, String aConstraintKey, String aPropertyName, String aComment, IAnyType aDataType) {
       referenceConstraint = aConstraint;
       constraintKey = aConstraintKey;
       propertyName = aPropertyName;
       comment = aComment;
       dataType = aDataType;
     }
   }
 
   /**
    *
    */
   private static class ElementInfo {
 
     public IElemRefOrDecl elemRefOrDecl;
     /**
      * Indicates that the element is already present in a super type.
      */
     public boolean isInherited = false;
 
     /**
      * Inidicates that the element is already present in a super type where it
      * had a maximum occurence of 1.
      */
     public boolean isInheritedSingle = false;
 
     /**
      * Indicates that the element had somewhere in the derivation hierarchy
      * a maximum occurence of 1.
      */
     public boolean isSingle = false;
 
     /**
      * Indicates that the element had somewhere in the derivation hierarchy
      * a maximum number of occurences greater than 1.
      */
     public boolean isMultiple = false;
 
     /**
      * Indicates that the element is already present in a super type with a
      * maximum number of occurences greater than 1.
      */
     public boolean isInheritedMultiple = false;
 
     public ElementInfo(IElemRefOrDecl anElemRefOrDecl) {
       elemRefOrDecl = anElemRefOrDecl;
     }
   }
 
   protected String simpleTypeName(IAnyType aType, boolean aUseDataClass) {
     String res = null;
     if (!aUseDataClass) {
       Class c = aType.getSimpleStorageType();
       if (null != c) {
         res = ReflectUtil.getTypeName(c);
       }
     }
     if (null == res) {
       res = interfaceName(aType);
     }
     return res;
   }
 
   protected String interfaceName(IAnyType aType) {
     return getBehaviourInterfaceCartridge().getUsableFqName(aType.getInstanceType());
   }
 
   protected String ssoAccessor(Class aClass) {
     assert !aClass.isArray();
     String s = aClass.getName();
     assert !(s.lastIndexOf('$') >= 0);
     String n = s.substring(s.lastIndexOf('.') + 1);
     StringBuffer sb = null;
     if (aClass.isInterface() && n.startsWith("I") && Character.isUpperCase(n.charAt(1))) {
       sb = new StringBuffer(n.substring(1));
     } else {
       sb = new StringBuffer(n);
     }
     sb.setCharAt(0, Character.toUpperCase(sb.charAt(0)));
     return sb.toString();
   }
 
   protected String simpleStorageObjectTypeName(IAnyType aType) {
     return ReflectUtil.getWrapperClass(aType.getSimpleStorageType()).getName();
   }
 
   /**
    * Get the plural form of a property name. The plural form is constructed
    * by the following rules: if the property name ends with a &quot;y&quot; and the second
    * last character is not a vowel then the
    * &quot;y&quot; is replaced by &quot;ies&quot, if the property name ends with a
    * &quot;s&quot; then &quot;es&quot; is appended, otherwise a &quot;s&quot; is appended.
    *
    * @param aPropertyName <i>(required)</i>.
    * @return <i>(required)</i>.
    */
   protected String pluralForm(String aPropertyName) {
     String res = null;
     if (aPropertyName.endsWith("y") && (aPropertyName.length() > 1)) {
       char c = aPropertyName.charAt(aPropertyName.length() - 2);
       if ((c == 'a') || (c == 'e') || (c == 'i') || (c == 'o') || (c == 'u')) {
         res = aPropertyName + "s";
       } else {
         res = aPropertyName.substring(0, aPropertyName.length() - 1) + "ies";
       }
     } else if (aPropertyName.endsWith("s")) {
       res = aPropertyName + "es";
     } else {
       res = aPropertyName + "s";
     }
     return res;
   }
 
 }
 