/**

  *    Copyright 2005-2011 Steve McDuff d-duff@users.sourceforge.net

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  * http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.deduced.generator.java;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.LinkedList;

 import java.util.List;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import org.apache.commons.collections.list.TreeList;

 import org.apache.commons.lang.StringEscapeUtils;

 import org.apache.commons.lang.StringUtils;

 import org.deduced.BasicTypes;

 import org.deduced.DeducedModelLayer;

 import org.deduced.DeducedSchemaLayer;

 import org.deduced.DeducedUtilities;

 import org.deduced.OrderedPropertyListType;

 import org.deduced.OrderedPropertyListTypeHolder;

 import org.deduced.OrderingPropertyCollectionType;

 import org.deduced.OrderingPropertyCollectionTypeHolder;

 import org.deduced.PropertyCollection;

 import org.deduced.PropertyCollectionListInstance;

 import org.deduced.PropertyCollectionListInstanceHolder;

 import org.deduced.PropertyCollectionType;

 import org.deduced.PropertyCollectionTypeHolder;

 import org.deduced.PropertyInstance;

 import org.deduced.PropertyInstanceHolder;

 import org.deduced.PropertyList;

 import org.deduced.PropertyMap;

 import org.deduced.PropertyPackage;

 import org.deduced.PropertyType;

 import org.deduced.PropertyTypeHolder;

 import org.deduced.generator.StringAdjuster;

 import org.deduced.implementation.DeducedSchemaLayerImplementation;

 import org.deduced.implementation.EnumerationPropertyTypeImplementation;

 import org.deduced.implementation.OrderedPropertyListTypeImplementation;

 import org.deduced.implementation.OrderingPropertyCollectionTypeImplementation;

 import org.deduced.implementation.PropertyCollectionListInstanceImplementation;

 import org.deduced.implementation.PropertyCollectionTypeImplementation;

 import org.deduced.implementation.PropertyInstanceImplementation;

 import org.deduced.implementation.PropertyPackageImplementation;

 import org.deduced.rule.DeductionRuleLibrary;

 import org.deduced.utilities.FileUtilities;

 import org.deduced.validation.model.NullableValidationModel;

 /**

  * Class used to host utility methods when generating Java classes

  * 

  * @author Steve McDuff

  */

 public class JavaNamingUtilities

 {

         /**

          * Logger

          */

         private static final Logger LOGGER = Logger

                 .getLogger(JavaNamingUtilities.class.getName());

         /**

          * singleton reference used to pass as a variable to velocity

          */

         public static final JavaNamingUtilities DEFAULT = new JavaNamingUtilities();

         /**

          * utility class to adjust method names

          */

         private static final StringAdjuster METHOD_NAME_ADJUSTER =

                 new StringAdjuster();

         /**

          * utility class to adjust member names

          */

         private static final StringAdjuster MEMBER_NAME_ADJUSTER =

                 new StringAdjuster();

         /**

          * utility class to adjust package names

          */

         private static final StringAdjuster PACKAGE_NAME_ADJUSTER =

                 new StringAdjuster();

         /**

          * utility class to adjust class names

          */

         private static final StringAdjuster CLASS_NAME_ADJUSTER =

                 new StringAdjuster();

         /**

          * utility class to adjust static variable names

          */

         private static final StringAdjuster STATIC_NAME_ADJUSTER =

                 new StringAdjuster();

         /**

          * package separator

          */

         public static final String PACKAGE_SEPARATOR = "."; //$NON-NLS-1$

         /**

          * prefix for getter method

          */

         public static final String GETTER_PREFIX = "get "; //$NON-NLS-1$

         /**

          * prefix for boolean getter method

          */

         public static final String BOOLEAN_GETTER_PREFIX = "is "; //$NON-NLS-1$

         /**

          * prefix for setter method

          */

         public static final String SETTER_PREFIX = "set "; //$NON-NLS-1$

         /**

          * suffix for property collection types

          */

         public static final String TYPE_SUFFIX = " Type"; //$NON-NLS-1$

         /**

          * suffix for the key list variable

          */

         public static final String KEY_LIST_SUFFIX = " key list"; //$NON-NLS-1$

         /**

          * suffix for a property instance

          */

         public static final String INSTANCE_SUFFIX = " instance"; //$NON-NLS-1$

         /**

          * suffix for a property instance

          */

         public static final String LITERAL_SUFFIX = " literal"; //$NON-NLS-1$

         /**

          * suffix for a type implementation class name

          */

         public static final String IMPLEMENTATION_SUFFIX = " implementation"; //$NON-NLS-1$

         /**

          * code used to initialize the string adjusters

          */

         static

         {

                 CLASS_NAME_ADJUSTER.setFirstLetterOfEachWordUpperCase(true);

                 CLASS_NAME_ADJUSTER.setUpperCaseFirstLetter(true);

                 CLASS_NAME_ADJUSTER.setWhiteSpaceReplaceString(""); //$NON-NLS-1$

                 CLASS_NAME_ADJUSTER.setAcceptingOnlyBaseCharacters(true);

                 STATIC_NAME_ADJUSTER.setAllInUpperCase(true);

                 STATIC_NAME_ADJUSTER.setWhiteSpaceReplaceString("_"); //$NON-NLS-1$

                 STATIC_NAME_ADJUSTER.setAcceptingOnlyBaseCharacters(true);

                 PACKAGE_NAME_ADJUSTER.setAllInLowerCase(true);

                 PACKAGE_NAME_ADJUSTER.setWhiteSpaceReplaceString(""); //$NON-NLS-1$

                 PACKAGE_NAME_ADJUSTER.setAcceptingOnlyBaseCharacters(true);

                 METHOD_NAME_ADJUSTER.setFirstLetterOfEachWordUpperCase(true);

                 METHOD_NAME_ADJUSTER.setLowerCaseFirstLetter(true);

                 METHOD_NAME_ADJUSTER.setWhiteSpaceReplaceString(""); //$NON-NLS-1$

                 METHOD_NAME_ADJUSTER.setAcceptingOnlyBaseCharacters(true);

                 MEMBER_NAME_ADJUSTER.setFirstLetterOfEachWordUpperCase(true);

                 MEMBER_NAME_ADJUSTER.setLowerCaseFirstLetter(true);

                 MEMBER_NAME_ADJUSTER.setWhiteSpaceReplaceString(""); //$NON-NLS-1$

                 MEMBER_NAME_ADJUSTER.setAcceptingOnlyBaseCharacters(true);

         }

         /**

          * get a java interface name from a type

          * 

          * @param type the type containing a name property

          * @return the java class name associated with it

          */

         public static String getInterfaceName(

                 PropertyCollection<?, ?> type)

         {

                 return getClassName(DeducedUtilities.getCollectionName(type));

         }

         /**

          * get a java implementation name from a type

          * 

          * @param type the type containing a name property

          * @return the java class name associated with it

          */

         public static String getImplementationName(

                 PropertyCollection<?, ?> type)

         {

                 return getClassName(DeducedUtilities.getCollectionName(type)

                         + IMPLEMENTATION_SUFFIX);

         }

         /**

          * adjust a string to print a java class name

          * 

          * @param baseName the base name

          * @return the java class name

          */

         public static String getClassName(

                 String baseName)

         {

                 return CLASS_NAME_ADJUSTER.adjustString(baseName);

         }

         /**

          * adjust a string to print a java class package declaration

          * 

          * @param packageName the package name name

          * @return the the package name declaration

          */

         public static String getPackageDeclaration(

                 String packageName)

         {

                 String retVal = "";

                 if (!StringUtils.isBlank(packageName))

                 {

                         retVal = "package " + packageName + ";";

                 }

                 return retVal;

         }

         /**

          * adjust a string to print a schema java class name

          * 

          * @param schemaName the base name

          * @return the java class name

          */

         public static String getSchemaClassName(

                 String schemaName)

         {

                 String retVal = schemaName;

                 int lastDotIndex = retVal.lastIndexOf('.');

                 if (lastDotIndex != -1)

                 {

                         int length = retVal.length();

                         retVal = retVal.substring(lastDotIndex, length);

                 }

                 retVal = getClassName(retVal);

                 if (retVal.isEmpty())

                 {

                         retVal = "DefaultSchemaClassName";

                 }

                 return retVal;

         }

         /**

          * adjust a string to print a fully qualified schema java class name

          * 

          * @param schemaName the base name

          * @return the schema java class name

          */

         public static String getFullyQualifiedSchemaClassName(

                 String schemaName)

         {

                 String className = getSchemaClassName(schemaName);

                 String packageName = getSchemaPackageName(schemaName);

                 String retVal = getFullyQualifiedJavaClassName(packageName, className);

                 return retVal;

         }

         /**

          * get a fully qualified Java Class Name based on the package name and the

          * class name

          * 

          * @param packageName the package name

          * @param className the class name

          * @return the fully qualified java class name

          */

         public static String getFullyQualifiedJavaClassName(

                 String packageName, String className)

         {

                 String retVal = className;

                 if (!StringUtils.isBlank(packageName))

                 {

                         retVal = packageName + PACKAGE_SEPARATOR + className;

                         retVal = retVal.replaceAll("\\.\\.*", ".");

                         retVal = retVal.replaceAll("^\\.*", "");

                 }

                 return retVal;

         }

         /**

          * adjust a string to print a schema package name

          * 

          * @param schemaName the base name

          * @return the package name

          */

         public static String getSchemaPackageName(

                 String schemaName)

         {

                 int lastDotIndex = schemaName.lastIndexOf('.');

                 String retVal = "";

                 if (lastDotIndex != -1)

                 {

                         retVal = schemaName.substring(0, lastDotIndex);

                 }

                 String[] packageSplit = retVal.split("\\.");

                 for (int i = 0; i < packageSplit.length; i++)

                 {

                         packageSplit[i] = getPackageName(packageSplit[i]);

                 }

                 List<String> packageNameList = Arrays.asList(packageSplit);

                 retVal =

                         concatenateStringListWithSeparatorSkipBlank(PACKAGE_SEPARATOR,

                                 packageNameList);

                 if (StringUtils.isEmpty(retVal))

                 {

                         // use a default value

                         retVal = "factory";

                 }

                 return retVal;

         }

         /**

          * adjust a string to print a schema folder name

          * 

          * @param schemaName the base name

          * @return the folder name

          */

         public static String getSchemaFolderName(

                 String schemaName)

         {

                 String retVal = getSchemaPackageName(schemaName);

                 retVal = retVal.replace('.', '/');

                 return retVal;

         }

         /**

          * adjust a string to print a static variable name

          * 

          * @param baseName the name to adjust

          * @return the static variable name

          */

         public static String getStaticVariableName(

                 String baseName)

         {

                 return STATIC_NAME_ADJUSTER.adjustString(baseName);

         }

         /**

          * adjust a string to print a method name

          * 

          * @param baseName the name to adjust

          * @return the method name

          */

         public static String getMethodName(

                 String baseName)

         {

                 return METHOD_NAME_ADJUSTER.adjustString(baseName);

         }

         /**

          * get the package name for the interface associated with a collection type

          * 

          * @param collectionType the collection type

          * 

          * @return the package name

          */

         public static String getInterfacePackageName(

                 PropertyCollection<?, ?> collectionType)

         {

                 List<PropertyCollection<?, ?>> packageList =

                         getPackageListFromType(collectionType);

                 return getPackageNameFromPackageList(packageList);

         }

         /**

          * get the package name from a package list

          * 

          * @param packageList the list of packages. Only the first package in the

          *            list is allowed to have a blank name. All other packages that

          *            have a blank name will trigger a IllegalArgumentException.

          * 

          * @return the package name. This value is never null. It will return a

          *         blank string "" if no inputs are specified.

          */

         public static String getPackageNameFromPackageList(

                 List<? extends PropertyCollection<?, ?>> packageList)

         {

                 String packageSeparator = PACKAGE_SEPARATOR;

                 return concatenatePackageNamesWithSeparator(packageList,

                         packageSeparator);

         }

         /**

          * concatenate package names with a separator between each package name

          * 

          * @param packageList the list of packages. Only the first package in the

          *            list is allowed to have a blank name. All other packages that

          *            have a blank name will trigger a IllegalArgumentException.

          * @param packageSeparator the separator

          * @return the concatenated name

          */

         private static String concatenatePackageNamesWithSeparator(

                 List<? extends PropertyCollection<?, ?>> packageList,

                 String packageSeparator)

         {

                 List<String> nameList = new ArrayList<String>();

                 if (packageList != null)

                 {

                         for (PropertyCollection<?, ?> currentPackage : packageList)

                         {

                                 nameList.add(getPackageNameFromPackage(currentPackage));

                         }

                 }

                 return concatenateStringListWithSeparatorSkipBlank(packageSeparator,

                         nameList);

         }

         /**

          * concatenate String List With Separator Skip Blank

          * 

          * @param separator the separator to use

          * @param stringList the list of string to concatenate

          * @return the concatenated string

          */

         public static String concatenateStringListWithSeparatorSkipBlank(

                 String separator, List<String> stringList)

         {

                 StringBuilder retVal = new StringBuilder();

                 boolean first = true;

                 for (String currentString : stringList)

                 {

                         if (!StringUtils.isBlank(currentString))

                         {

                                 if (first)

                                 {

                                         first = false;

                                 }

                                 else

                                 {

                                         retVal.append(separator);

                                 }

                                 retVal.append(currentString);

                         }

                 }

                 return retVal.toString();

         }

         /**

          * get the package name from a property package object

          * 

          * @param propertyPackage the property package

          * @return the name of this package only

          */

         public static String getPackageNameFromPackage(

                 PropertyCollection<?, ?> propertyPackage)

         {

                 String packageName =

                         DeducedUtilities.getCollectionName(propertyPackage);

                 return getPackageName(packageName);

         }

         /**

          * get an adjusted package name from a raw package name

          * 

          * @param nameToAdjust the package name to adjust

          * @return a valid java package name

          */

         public static String getPackageName(

                 String nameToAdjust)

         {

                 String adjustedPackageName =

                         PACKAGE_NAME_ADJUSTER.adjustString(nameToAdjust);

                 return adjustedPackageName;

         }

         /**

          * get the variable name used to reference a property package

          * 

          * @param propertyPackage the property package to reference

          * @return the variable name holding the package

          */

         public static String getPackageVariableName(

                 PropertyCollection<?, ?> propertyPackage)

         {

                 List<PropertyCollection<?, ?>> packageList =

                         getParentPackageListFromPackage(propertyPackage);

                 String concatenatedPackageName =

                         concatenatePackageNamesWithSeparator(packageList, " ");

                 if (StringUtils.isBlank(concatenatedPackageName))

                 {

                         concatenatedPackageName = "root";

                 }

                 return STATIC_NAME_ADJUSTER.adjustString(concatenatedPackageName

                         + " package");

         }

         /**

          * get the ordered list of packages leading up to a property package

          * 

          * @param propertyPackage the property package to reach

          * @return the ordered list of property package objects

          */

         @SuppressWarnings("unchecked")

         public static List<PropertyCollection<?, ?>> getParentPackageListFromPackage(

                 PropertyCollection<?, ?> propertyPackage)

         {

                 List<PropertyCollection<?, ?>> retVal = new TreeList();

                 PropertyCollection<?, ?> parent = propertyPackage;

                 while (parent != null)

                 {

                         if (DeducedUtilities.isInstanceOf(parent.type(),

                                 PropertyPackage.PROPERTY_PACKAGE_TYPE

                                         .getPropertyCollectionType()))

                         {

                                 // found a package, add it to the list

                                 retVal.add(0, parent);

                         }

                         else

                         {

                                 break;

                         }

                         parent = parent.parent();

                         if (parent != null)

                         {

                                 parent = parent.parent();

                         }

                 }

                 return retVal;

         }

         /**

          * get the ordered list of packages leading up to a property type

          * 

          * @param type the type

          * @return the ordered list of property package objects

          */

         public static List<PropertyCollection<?, ?>> getPackageListFromType(

                 PropertyCollection<?, ?> type)

         {

                 PropertyCollection<?, ?> packageParent = type;

                 if (packageParent != null)

                 {

                         packageParent = packageParent.parent();

                 }

                 if (packageParent != null)

                 {

                         packageParent = packageParent.parent();

                 }

                 return getParentPackageListFromPackage(packageParent);

         }

         /**

          * get an interface type holder variable name

          * 

          * @param collectionType the type

          * @return the type holder variable name

          */

         public static String getInterfaceTypeHolderName(

                 PropertyCollection<?, ?> collectionType)

         {

                 if (collectionType == null)

                 {

                         return null;

                 }

                 return getStaticVariableName(DeducedUtilities

                         .getCollectionName(collectionType) + TYPE_SUFFIX);

         }

         /**

          * get a fully qualified type interface name with the package name and type

          * name.

          * 

          * @param collectionType the type

          * @return the fully qualified type interface name

          */

         public static String getFullyQualifiedTypeInterfaceName(

                 PropertyCollection<?, ?> collectionType)

         {

                 String interfacePackageName = getInterfacePackageName(collectionType);

                 String interfaceName = getInterfaceName(collectionType);

                 String retVal =

                         extractFullyQualifiedJavaClassName(interfacePackageName,

                                 interfaceName);

                 return retVal;

         }

         /**

          * extract a fully qualified java class name from a package and a class

          * name. If the package name is empty, then the returned name will still be

          * valid as the package name will not be included in the result

          * 

          * @param packageName the package name

          * @param className the class name

          * @return the fully qualified java class

          */

         private static String extractFullyQualifiedJavaClassName(

                 String packageName, String className)

         {

                 String retVal = null;

                 if (StringUtils.isBlank(packageName))

                 {

                         retVal = className;

                 }

                 else

                 {

                         retVal = packageName + PACKAGE_SEPARATOR + className;

                 }

                 return retVal;

         }

         /**

          * get a fully qualified type implementation name with the package name and

          * type name.

          * 

          * @param collectionType the type

          * @return the fully qualified type implementation name

          */

         public static String getFullyQualifiedTypeImplementationName(

                 PropertyCollection<?, ?> collectionType)

         {

                 String retVal = null;

                 if (collectionType == PropertyList.PROPERTY_LIST_TYPE

                         .getPropertyCollectionType())

                 {

                         retVal = PropertyList.class.getName();

                 }

                 else

                 {

                         String implementationPackageName =

                                 getImplementationPackageName(collectionType);

                         String implementationName = getImplementationName(collectionType);

                         retVal =

                                 extractFullyQualifiedJavaClassName(implementationPackageName,

                                         implementationName);

                 }

                 return retVal;

         }

         /**

          * return the list of all the direct parent associated with a types

          * 

          * @param collectionType the type

          * @return the list of parent types

          */

         @SuppressWarnings("unchecked")

         public static List<PropertyCollection<?, ?>> getPropertyCollectionTypeParentList(

                 PropertyCollection<?, ?> collectionType)

         {

                 return PropertyCollectionTypeImplementation.getParentList(

                         collectionType).asValueList();

         }

         /**

          * return the ordering property collection type value instance

          * 

          * @param collectionType the type

          * @return the value instance, null if not applicable

          */

         @SuppressWarnings("unchecked")

         public static PropertyCollection<?, ?> getOrderingPropertyCollectionTypeValueInstance(

                 PropertyCollection<?, ?> collectionType)

         {

                 return OrderingPropertyCollectionTypeImplementation

                         .getValueInstance(collectionType);

         }

         /**

          * return the ordering property collection type ordering instance

          * 

          * @param collectionType the type

          * @return the ordering instance, null if not applicable

          */

         @SuppressWarnings("unchecked")

         public static PropertyCollection<?, ?> getOrderingPropertyCollectionTypeOrderingInstance(

                 PropertyCollection<?, ?> collectionType)

         {

                 return OrderingPropertyCollectionTypeImplementation

                         .getOrderingInstance(collectionType);

         }

         /**

          * return the list of property instance on a type

          * 

          * @param collectionType the type

          * @return the instance list

          */

         @SuppressWarnings("unchecked")

         public static List<PropertyCollection<?, ?>> getPropertyCollectionTypePropertyInstanceList(

                 PropertyCollection<?, ?> collectionType)

         {

                 return PropertyCollectionTypeImplementation.getPropertyInstanceList(

                         collectionType).asValueList();

         }

         /**

          * return the Full Property Collection Type Property Collection List

          * Instance List

          * 

          * @param collectionType the type

          * @return the Property Collection List Instance List

          */

         @SuppressWarnings("unchecked")

         public static List<PropertyCollection<?, ?>> getFullPropertyCollectionTypePropertyCollectionListInstanceList(

                 PropertyCollection<?, ?> collectionType)

         {

                 return DeductionRuleLibrary

                         .filter(

                                 getFullPropertyCollectionTypePropertyInstanceList(collectionType),

                                 DeductionRuleLibrary.not(DeductionRuleLibrary

                                         .instanceOf(PropertyCollectionListInstance.PROPERTY_COLLECTION_LIST_INSTANCE_TYPE

                                                 .getPropertyCollectionType())));

         }

         /**

          * return the Full Property Collection Type Property Instance List

          * 

          * @param collectionType the type

          * @return the Property Instance List

          */

         @SuppressWarnings("unchecked")

         public static List<PropertyCollection<?, ?>> getFullPropertyCollectionTypePropertyInstanceList(

                 PropertyCollection<?, ?> collectionType)

         {

                 List<PropertyCollection<?, ?>> retVal =

                         new ArrayList<PropertyCollection<?, ?>>();

                 List<PropertyCollection<?, ?>> fullPropertyCollectionTypeParentList =

                         getFullPropertyCollectionTypeParentList(collectionType);

                 for (PropertyCollection<?, ?> currentType : fullPropertyCollectionTypeParentList)

                 {

                         retVal.addAll(PropertyCollectionTypeImplementation

                                 .getPropertyInstanceList(currentType).asValueList());

                 }

                 return retVal;

         }

         /**

          * This method will get a flat list of all the property collection types in

          * the parent hierarchy starting from the collectionType specified. No

          * duplicate types will be included.

          * 

          * @param collectionType the starting collection type

          * @return the list of all the collection types implemented by the current

          *         type.

          */

         public static List<PropertyCollection<?, ?>> getFullPropertyCollectionTypeParentList(

                 PropertyCollection<?, ?> collectionType)

         {

                 List<PropertyCollection<?, ?>> retVal =

                         new ArrayList<PropertyCollection<?, ?>>();

                 addTypeToList(collectionType, retVal);

                 return retVal;

         }

         /**

          * Internal method to recursively add a type to a list of parent

          * 

          * @param collectionType they type to add

          * @param retVal the list to add the new type

          */

         private static void addTypeToList(

                 PropertyCollection<?, ?> collectionType,

                 List<PropertyCollection<?, ?>> retVal)

         {

                 if (collectionType != null && !retVal.contains(collectionType))

                 {

                         retVal.add(collectionType);

                         List<?> parentList =

                                 PropertyCollectionTypeImplementation.getParentList(

                                         collectionType).asValueList();

                         for (Object object : parentList)

                         {

                                 addTypeToList((PropertyCollection<?, ?>) object, retVal);

                         }

                 }

         }

         /**

          * test to see if the instance is actually a list

          * 

          * @param instance the instance

          * @return true if the instance is a list instance

          * @throws NullPointerException if the instance is null

          */

         public static boolean isListPropertyInstance(

                 PropertyCollection<?, ?> instance)

         {

                 return DeducedUtilities

                         .isInstanceOf(

                                 instance.type(),

                                 PropertyCollectionListInstance.PROPERTY_COLLECTION_LIST_INSTANCE_TYPE

                                         .getPropertyCollectionType());

         }

         /**

          * get the variable name for the instance holder

          * 

          * @param instance the property instance

          * @return the property instance holder variable name

          */

         public static String getInstanceHolderVariableName(

                 PropertyCollection<?, ?> instance)

         {

                 if (instance == null)

                 {

                         return null;

                 }

                 return getStaticVariableName(DeducedUtilities

                         .getCollectionName(instance) + INSTANCE_SUFFIX);

         }

         /**

          * get the variable name for the enumeration holder

          * 

          * @param instance the enumeration

          * @return the enumeration holder variable name

          */

         public static String getEnumerationHolderVariableName(

                 PropertyCollection<?, ?> instance)

         {

                 if (instance == null)

                 {

                         return null;

                 }

                 return getStaticVariableName(DeducedUtilities

                         .getCollectionName(instance) + LITERAL_SUFFIX);

         }

         /**

          * get the instance member variable name

          * 

          * @param instance the instance

          * @return the instance member variable name

          */

         public static String getInstanceMemberVariableName(

                 PropertyCollection<?, ?> instance)

         {

                 return getMemberName(DeducedUtilities.getCollectionName(instance));

         }

         /**

          * adjust a String to match the format required for

          * 

          * @param memberNameToAdjust the method name to adjust

          * @return the member name

          */

         public static String getMemberName(

                 String memberNameToAdjust)

         {

                 return MEMBER_NAME_ADJUSTER.adjustString(memberNameToAdjust);

         }

         /**

          * get the fully qualified instance type name. If the type of the instance

          * is a basic type and the value can't be null, then a basic java type name

          * will be returned instead of the object wrapper. For property collection

          * types, the interface name is returned. For lists, an abstract

          * PropertyList will be used.

          * 

          * @param instance the property instance

          * @return the fully qualified instance type name

          */

         public static String getFullyQualifiedInstanceTypeName(

                 PropertyCollection<?, ?> instance)

         {

                 PropertyCollection<?, ?> type =

                         PropertyInstanceImplementation.getInstanceType(instance);

                 if (isInstanceTypeNative(instance))

                 {

                         // found basic non-nullable type

                         Class<?> classFromType = BasicTypes.getNativeClassFromType(type);

                         return classFromType.getCanonicalName();

                 }

                 return getFullyQualifiedTypeName(type);

         }

         /**

          * check if the instance variable will be using a native type. Only

          * instances that reference a possibly native type that can't be set to null

          * will return true.

          * 

          * @param instance the property instance

          * @return true if the instance requires a native type

          */

         public static boolean isInstanceTypeNative(

                 PropertyCollection<?, ?> instance)

         {

                 PropertyCollection<?, ?> propertyInstanceValidationModel =

                         PropertyInstanceImplementation.getValidationModel(instance);

                 PropertyCollection<?, ?> type =

                         PropertyInstanceImplementation.getInstanceType(instance);

                 Object nullValidKey =

                         NullableValidationModel.IS_NULL_VALID_INSTANCE.getKey();

                 if (propertyInstanceValidationModel != null

                         && propertyInstanceValidationModel.containsKey(nullValidKey))

                 {

                         Boolean isNullValid =

                                 (Boolean) propertyInstanceValidationModel

                                         .getPropertyValue(nullValidKey);

                         if (isNullValid != null && !isNullValid.booleanValue())

                         {

                                 return BasicTypes.isTypeNative(type);

                         }

                 }

                 return false;

         }

         /**

          * debug

          * 

          * @param print string to print

          */

         public static void debug(

                 String print)

         {

                 if (LOGGER.isLoggable(Level.FINEST))

                 {

                         LOGGER.log(Level.FINEST, "Debug : " + print);

                 }

         }

         /**

          * get the fully qualified type name. For property collection types, the

          * interface name is returned. For lists, an abstract PropertyList will be

          * used.

          * 

          * @param type the property type

          * @return the fully qualified type name

          */

         public static String getFullyQualifiedTypeName(

                 PropertyCollection<?, ?> type)

         {

                 String returnValue = null;

                 if (type.type() == PropertyType.PROPERTY_TYPE_TYPE

                         .getPropertyCollectionType())

                 {

                         Class<?> classFromType = BasicTypes.getClassFromType(type);

                         returnValue = classFromType.getCanonicalName();

                 }

                 else if (type == PropertyList.PROPERTY_LIST_TYPE

                         .getPropertyCollectionType())

                 {

                         returnValue = PropertyList.class.getCanonicalName();

                 }

                 else if (type == PropertyList.PROPERTY_COLLECTION_TYPE

                         .getPropertyCollectionType())

                 {

                         returnValue = PropertyCollection.class.getCanonicalName();

                 }

                 else

                 {

                         returnValue = getFullyQualifiedTypeInterfaceName(type);

                 }

                 return returnValue;

         }

         /**

          * getPropertyInstanceInstanceType

          * 

          * @param instance the property instance

          * @return the instance type

          */

         public static PropertyCollection<?, ?> getPropertyInstanceInstanceType(

                 PropertyCollection<?, ?> instance)

         {

                 return PropertyInstanceImplementation.getInstanceType(instance);

         }

         /**

          * get OrderedPropertyListType OrderingType

          * 

          * @param type the potential ordered property list type

          * @return the ordering type

          */

         public static PropertyCollection<?, ?> getOrderedPropertyListTypeOrderingType(

                 PropertyCollection<?, ?> type)

         {

                 return OrderedPropertyListTypeImplementation.getOrderingType(type);

         }

         /**

          * get PropertyInstance IsReference

          * 

          * @param instance the property instance

          * @return the reference flag

          */

         public static Boolean getPropertyInstanceIsReference(

                 PropertyCollection<?, ?> instance)

         {

                 return PropertyInstanceImplementation.isReference(instance);

         }

         /**

          * get PropertyCollectionListInstance ListFixedInstance

          * 

          * @param instance the property collection list instance

          * @return the list fixed instance

          */

         public static PropertyCollection<?, ?> getPropertyCollectionListInstanceListFixedInstance(

                 PropertyCollection<?, ?> instance)

         {

                 return PropertyCollectionListInstanceImplementation

                         .getListFixedInstance(instance);

         }

         /**

          * get EnumerationPropertyType EnumerationLiteralList

          * 

          * @param instance the property collection list instance

          * @return the Enumeration Literal List

          */

         @SuppressWarnings("unchecked")

         public static List<PropertyCollection<?, ?>> getEnumerationPropertyTypeEnumerationLiteralList(

                 PropertyCollection<?, ?> instance)

         {

                 PropertyCollection enumerationLiteralList =

                         EnumerationPropertyTypeImplementation

                                 .getEnumerationLiteralList(instance);

                 if (enumerationLiteralList != null)

                 {

                         return enumerationLiteralList.asValueList();

                 }

                 return new LinkedList<PropertyCollection<?, ?>>();

         }

         /**

          * get DeducedSchemaLayer RootPackage

          * 

          * @param instance the schema layer

          * @return the root package

          */

         public static PropertyCollection<?, ?> getDeducedSchemaLayerRootPackage(

                 PropertyCollection<?, ?> instance)

         {

                 return DeducedSchemaLayerImplementation.getRootPackage(instance);

         }

         /**

          * get PropertyPackage PropertyPackageList

          * 

          * @param instance the package

          * @return the package list

          */

         public static PropertyCollection<?, ?> getPropertyPackagePropertyPackageList(

                 PropertyCollection<?, ?> instance)

         {

                 return PropertyPackageImplementation.getPropertyPackageList(instance);

         }

         /**

          * get PropertyPackage PropertyTypeList

          * 

          * @param instance the package

          * @return the type list

          */

         public static PropertyCollection<?, ?> getPropertyPackagePropertyTypeList(

                 PropertyCollection<?, ?> instance)

         {

                 return PropertyPackageImplementation.getPropertyTypeList(instance);

         }

         /**

          * get the string required to type cast a java.lang.Object to the required

          * object type. This method will return an empty string if the type is

          * already a java.lang.Object. For instance, for a

          * deduced.PropertyCollection, this method will return the string

          * "(deduced.PropertyCollection)"

          * 

          * @param type the type to cast the java.lang.Object from

          * @return the cast string

          */

         public static String getTypeCastString(

                 PropertyCollection<?, ?> type)

         {

                 if (type == BasicTypes.OBJECT_TYPE.getPropertyType())

                 {

                         return "";

                 }

                 return "(" + getFullyQualifiedTypeName(type) + ")";

         }

         /**

          * fetch the instance getter method name. Getter on boolean values will

          * always be prefixed by "is". For instance, the getter on a boolean

          * property called "boolean type allowed" will return

          * "isBooleanTypeAllowed". For other types, the "get" prefix will be used

          * such as "getBooleanTypeAllowed".

          * 

          * @param instance the instance

          * @return the getter method name

          */

         public static String getInstanceGetterMethodName(

                 PropertyCollection<?, ?> instance)

         {

                 String prefix = GETTER_PREFIX;

                 PropertyCollection<?, ?> propertyInstanceInstanceType =

                         PropertyInstanceImplementation.getInstanceType(instance);

                 String collectionName = DeducedUtilities.getCollectionName(instance);

                 if (propertyInstanceInstanceType == BasicTypes.BOOLEAN_TYPE

                         .getPropertyType())

                 {

                         if (collectionName.toLowerCase().startsWith("is"))

                         {

                                 prefix = "";

                         }

                         else

                         {

                                 prefix = BOOLEAN_GETTER_PREFIX;

                         }

                 }

                 return getMethodName(prefix + collectionName);

         }

         /**

          * fetch the instance setter method name. For instance, the setter on a

          * boolean property called "boolean type allowed" will return

          * "setBooleanTypeAllowed".

          * 

          * @param instance the instance

          * @return the setter method name

          */

         public static String getInstanceSetterMethodName(

                 PropertyCollection<?, ?> instance)

         {

                 return getMethodName(SETTER_PREFIX

                         + DeducedUtilities.getCollectionName(instance));

         }

         /**

          * get the package name for a property type implementation

          * 

          * @param type the property type

          * @return the package name. For instance, the package name for

          *         deduced.Property Collection Type will be "deduced.implementation"

          */

         public static String getImplementationPackageName(

                 PropertyCollection<?, ?> type)

         {

                 return getInterfacePackageName(type) + ".implementation";

         }

         /**

          * get the property collection type that owns a property instance

          * 

          * @param instance the property instance

          * @return the property collection type that owns the instance

          */

         public static PropertyCollection<?, ?> getPropertyInstanceParentPropertyCollectionType(

                 PropertyCollection<?, ?> instance)

         {

                 PropertyCollection<?, ?> parent = instance;

                 PropertyCollectionType propertyCollectionType =

                         PropertyCollectionType.PROPERTY_COLLECTION_TYPE_TYPE

                                 .getPropertyCollectionType();

                 while (parent != null

                         && !DeducedUtilities.isInstanceOf(parent.type(),

                                 propertyCollectionType))

                 {

                         parent = parent.parent();

                 }

                 return parent;

         }

         /**

          * get the java interface file name

          * 

          * @param type the property collection type

          * @return the interface file name

          */

         public static String getInterfaceFileName(

                 PropertyCollection<?, ?> type)

         {

                 return getInterfaceName(type) + ".java";

         }

         /**

          * get the java implementation file name

          * 

          * @param type the property collection type

          * @return the implementation file name

          */

         public static String getImplementationFileName(

                 PropertyCollection<?, ?> type)

         {

                 return getImplementationName(type) + ".java";

         }

         /**

          * get the java interface folder name

          * 

          * @param type the property collection type

          * @return the interface folder name

          */

         public static String getInterfaceFolderName(

                 PropertyCollection<?, ?> type)

         {

                 return getFolderNameFromPackageName(getInterfacePackageName(type));

         }

         /**

          * get the java implementation folder name

          * 

          * @param type the property collection type

          * @return the implementation folder name

          */

         public static String getImplementationFolderName(

                 PropertyCollection<?, ?> type)

         {

                 return getFolderNameFromPackageName(getImplementationPackageName(type));

         }

         /**

          * get a folder name based on a package name

          * 

          * @param packageName the package name

          * @return the folder name

          */

         public static String getFolderNameFromPackageName(

                 String packageName)

         {

                 return packageName.replace(PACKAGE_SEPARATOR,

                         FileUtilities.FOLDER_SEPARATOR);

         }

         /**

          * get the name of a type holder

          * 

          * @param type the type to refer to

          * @return the fully qualified type holder name

          */

         public static String getFullyQualifiedTypeHolderName(

                 PropertyCollection<?, ?> type)

         {

                 String retVal = null;

                 if (type.type() == PropertyType.PROPERTY_TYPE_TYPE

                         .getPropertyCollectionType())

                 {

                         // basic type found

                         String typeName = DeducedUtilities.getCollectionName(type);

                         String holderName =

                                 STATIC_NAME_ADJUSTER.adjustString(typeName + TYPE_SUFFIX);

                         retVal = "org.deduced.BasicTypes." + holderName;

                 }

                 else if (type == PropertyMap.PROPERTY_MAP_TYPE.getPropertyType())

                 {

                         retVal = "org.deduced.PropertyMap.PROPERTY_MAP_TYPE";

                 }

                 else if (type == PropertyList.PROPERTY_LIST_TYPE.getPropertyType())

                 {

                         retVal = "org.deduced.PropertyList.PROPERTY_LIST_TYPE";

                 }

                 else

                 {

                         String interfaceName = getFullyQualifiedTypeInterfaceName(type);

                         String typeHolder = getInterfaceTypeHolderName(type);

                         retVal = interfaceName + PACKAGE_SEPARATOR + typeHolder;

                 }

                 return retVal;

         }

         /**

          * get all the property collection type in a schema

          * 

          * @param schema the schema

          * @return the list of property collection type

          */

         public static List<PropertyCollection<?, ?>> getPropertyCollectionTypeListFromSchema(

                 PropertyCollection<?, ?> schema)

         {

                 PropertyCollection<?, ?> rootPackage =

                         (PropertyCollection<?, ?>) schema

                                 .getPropertyValue(DeducedSchemaLayer.ROOT_PACKAGE_INSTANCE

                                         .getKey());

                 List<PropertyCollection<?, ?>> packageList =

                         getRecursivePackageListFromPackage(rootPackage);

                 List<PropertyCollection<?, ?>> retVal =

                         new ArrayList<PropertyCollection<?, ?>>();

                 for (PropertyCollection<?, ?> currentPackage : packageList)

                 {

                         retVal

                                 .addAll(getPropertyCollectionTypeListFromPackage(currentPackage));

                 }

                 return retVal;

         }

         /**

          * get the list of property collection type from a package

          * 

          * @param propertyPackage the package

          * @return the list of property collection type

          */

         public static List<PropertyCollection<?, ?>> getPropertyCollectionTypeListFromPackage(

                 PropertyCollection<?, ?> propertyPackage)

         {

                 List<PropertyCollection<?, ?>> retVal =

                         new ArrayList<PropertyCollection<?, ?>>();

                 if (propertyPackage != null)

                 {

                         PropertyCollection<?, ?> propertyPackagePropertyTypeList =

                                 PropertyPackageImplementation

                                         .getPropertyTypeList(propertyPackage);

                         if (propertyPackagePropertyTypeList != null)

                         {

                                 List<?> typeList =

                                         propertyPackagePropertyTypeList.asValueList();

                                 for (Object object : typeList)

                                 {

                                         PropertyCollection<?, ?> type =

                                                 (PropertyCollection<?, ?>) object;

                                         if (DeducedUtilities.isTypeCollection(type.type()))

                                         {

                                                 retVal.add(type);

                                         }

                                 }

                         }

                 }

                 return retVal;

         }

         /**

          * get the recursive list of package from the specified package

          * 

          * @param propertyPackage the starting package

          * @return the list of all the packages in the hierarchy, including the

          *         starting package

          */

         public static List<PropertyCollection<?, ?>> getRecursivePackageListFromPackage(

                 PropertyCollection<?, ?> propertyPackage)

         {

                 List<PropertyCollection<?, ?>> retVal =

                         new ArrayList<PropertyCollection<?, ?>>();

                 internalGetRecursivePackageListFromPackage(propertyPackage, retVal);