crypto/hash/src/main/java/org/apache/shiro/crypto/hash/format/DefaultHashFormatFactory.java - shiro - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you 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.apache.shiro.crypto.hash.format;

 import org.apache.shiro.util.ClassUtils;
 import org.apache.shiro.util.StringUtils;
 import org.apache.shiro.util.UnknownClassException;

 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;

 /**
  * This default {@code HashFormatFactory} implementation heuristically determines a {@code HashFormat} class to
  * instantiate based on the input argument and returns a new instance of the discovered class.  The heuristics are
  * detailed in the {@link #getInstance(String) getInstance} method documentation.
  *
  * @since 1.2
  */
 public class DefaultHashFormatFactory implements HashFormatFactory {

     private Map<String, String> formatClassNames; //id - to - fully qualified class name

     private Set<String> searchPackages; //packages to search for HashFormat implementations

     public DefaultHashFormatFactory() {
         this.searchPackages = new HashSet<String>();
         this.formatClassNames = new HashMap<String, String>();
     }

     /**
      * Returns a {@code hashFormatAlias}-to-<code>fullyQualifiedHashFormatClassNameImplementation</code> map.
      * <p/>
      * This map will be used by the {@link #getInstance(String) getInstance} implementation:  that method's argument
      * will be used as a lookup key to this map.  If the map returns a value, that value will be used to instantiate
      * and return a new {@code HashFormat} instance.
      * <h3>Defaults</h3>
      * Shiro's default HashFormat implementations (as listed by the {@link ProvidedHashFormat} enum) will
      * be searched automatically independently of this map.  You only need to populate this map with custom
      * {@code HashFormat} implementations that are <em>not</em> already represented by a {@code ProvidedHashFormat}.
      * <h3>Efficiency</h3>
      * Populating this map will be more efficient than configuring {@link #getSearchPackages() searchPackages},
      * but search packages may be more convenient depending on the number of {@code HashFormat} implementations that
      * need to be supported by this factory.
      *
      * @return a {@code hashFormatAlias}-to-<code>fullyQualifiedHashFormatClassNameImplementation</code> map.
      */
     public Map<String, String> getFormatClassNames() {
         return formatClassNames;
     }

     /**
      * Sets the {@code hash-format-alias}-to-{@code fullyQualifiedHashFormatClassNameImplementation} map to be used in
      * the {@link #getInstance(String)} implementation.  See the {@link #getFormatClassNames()} JavaDoc for more
      * information.
      * <h3>Efficiency</h3>
      * Populating this map will be more efficient than configuring {@link #getSearchPackages() searchPackages},
      * but search packages may be more convenient depending on the number of {@code HashFormat} implementations that
      * need to be supported by this factory.
      *
      * @param formatClassNames the {@code hash-format-alias}-to-{@code fullyQualifiedHashFormatClassNameImplementation}
      *                         map to be used in the {@link #getInstance(String)} implementation.
      */
     public void setFormatClassNames(Map<String, String> formatClassNames) {
         this.formatClassNames = formatClassNames;
     }

     /**
      * Returns a set of package names that can be searched for {@link HashFormat} implementations according to
      * heuristics defined in the {@link #getHashFormatClass(String, String) getHashFormat(packageName, token)} JavaDoc.
      * <h3>Efficiency</h3>
      * Configuring this property is not as efficient as configuring a {@link #getFormatClassNames() formatClassNames}
      * map, but it may be more convenient depending on the number of {@code HashFormat} implementations that
      * need to be supported by this factory.
      *
      * @return a set of package names that can be searched for {@link HashFormat} implementations
      * @see #getHashFormatClass(String, String)
      */
     public Set<String> getSearchPackages() {
         return searchPackages;
     }

     /**
      * Sets a set of package names that can be searched for {@link HashFormat} implementations according to
      * heuristics defined in the {@link #getHashFormatClass(String, String) getHashFormat(packageName, token)} JavaDoc.
      * <h3>Efficiency</h3>
      * Configuring this property is not as efficient as configuring a {@link #getFormatClassNames() formatClassNames}
      * map, but it may be more convenient depending on the number of {@code HashFormat} implementations that
      * need to be supported by this factory.
      *
      * @param searchPackages a set of package names that can be searched for {@link HashFormat} implementations
      */
     public void setSearchPackages(Set<String> searchPackages) {
         this.searchPackages = searchPackages;
     }

     public HashFormat getInstance(String in) {
         if (in == null) {
             return null;
         }

         HashFormat hashFormat = null;
         Class clazz = null;

         //NOTE: this code block occurs BEFORE calling getHashFormatClass(in) on purpose as a performance
         //optimization.  If the input arg is an MCF-formatted string, there will be many unnecessary ClassLoader
         //misses which can be slow.  By checking the MCF-formatted option, we can significantly improve performance
         if (in.startsWith(ModularCryptFormat.TOKEN_DELIMITER)) {
             //odds are high that the input argument is not a fully qualified class name or a format key (e.g. 'hex',
             //base64' or 'shiro1').  Try to find the key and lookup via that:
             String test = in.substring(ModularCryptFormat.TOKEN_DELIMITER.length());
             String[] tokens = test.split("\\" + ModularCryptFormat.TOKEN_DELIMITER);
             //the MCF ID is always the first token in the delimited string:
             String possibleMcfId = (tokens != null && tokens.length > 0) ? tokens[0] : null;
             if (possibleMcfId != null) {
                 //found a possible MCF ID - test it using our heuristics to see if we can find a corresponding class:
                 clazz = getHashFormatClass(possibleMcfId);
             }
         }

         if (clazz == null) {
             //not an MCF-formatted string - use the unaltered input arg and go through our heuristics:
             clazz = getHashFormatClass(in);
         }

         if (clazz != null) {
             //we found a HashFormat class - instantiate it:
             hashFormat = newHashFormatInstance(clazz);
         }

         return hashFormat;
     }

     /**
      * Heuristically determine the fully qualified HashFormat implementation class name based on the specified
      * token.
      * <p/>
      * This implementation functions as follows (in order):
      * <ol>
      * <li>See if the argument can be used as a lookup key in the {@link #getFormatClassNames() formatClassNames}
      * map.  If a value (a fully qualified class name {@link HashFormat HashFormat} implementation) is found,
      * {@link ClassUtils#forName(String) lookup} the class and return it.</li>
      * <li>
      * Check to see if the token argument is a
      * {@link ProvidedHashFormat} enum value.  If so, acquire the corresponding {@code HashFormat} class and
      * return it.
      * </li>
      * <li>
      * Check to see if the token argument is itself a fully qualified class name.  If so, try to load the class
      * and return it.
      * </li>
      * <li>If the above options do not result in a discovered class, search all all configured
      * {@link #getSearchPackages() searchPackages} using heuristics defined in the
      * {@link #getHashFormatClass(String, String) getHashFormatClass(packageName, token)} method documentation
      * (relaying the {@code token} argument to that method for each configured package).
      * </li>
      * </ol>
      * <p/>
      * If a class is not discovered via any of the above means, {@code null} is returned to indicate the class
      * could not be found.
      *
      * @param token the string token from which a class name will be heuristically determined.
      * @return the discovered HashFormat class implementation or {@code null} if no class could be heuristically determined.
      */
     protected Class getHashFormatClass(String token) {

         Class clazz = null;

         //check to see if the token is a configured FQCN alias.  This is faster than searching packages,
         //so we try this first:
         if (this.formatClassNames != null) {
             String value = this.formatClassNames.get(token);
             if (value != null) {
                 //found an alias - see if the value is a class:
                 clazz = lookupHashFormatClass(value);
             }
         }

         //check to see if the token is one of Shiro's provided FQCN aliases (again, faster than searching):
         if (clazz == null) {
             ProvidedHashFormat provided = ProvidedHashFormat.byId(token);
             if (provided != null) {
                 clazz = provided.getHashFormatClass();
             }
         }

         if (clazz == null) {
             //check to see if 'token' was a FQCN itself:
             clazz = lookupHashFormatClass(token);
         }

         if (clazz == null) {
             //token wasn't a FQCN or a FQCN alias - try searching in configured packages:
             if (this.searchPackages != null) {
                 for (String packageName : this.searchPackages) {
                     clazz = getHashFormatClass(packageName, token);
                     if (clazz != null) {
                         //found it:
                         break;
                     }
                 }
             }
         }

         if (clazz != null) {
             assertHashFormatImpl(clazz);
         }

         return clazz;
     }

     /**
      * Heuristically determine the fully qualified {@code HashFormat} implementation class name in the specified
      * package based on the provided token.
      * <p/>
      * The token is expected to be a relevant fragment of an unqualified class name in the specified package.
      * A 'relevant fragment' can be one of the following:
      * <ul>
      * <li>The {@code HashFormat} implementation unqualified class name</li>
      * <li>The prefix of an unqualified class name ending with the text {@code Format}.  The first character of
      * this prefix can be upper or lower case and both options will be tried.</li>
      * <li>The prefix of an unqualified class name ending with the text {@code HashFormat}.  The first character of
      * this prefix can be upper or lower case and both options will be tried.</li>
      * <li>The prefix of an unqualified class name ending with the text {@code CryptoFormat}.  The first character
      * of this prefix can be upper or lower case and both options will be tried.</li>
      * </ul>
      * <p/>
      * Some examples:
      * <table>
      * <tr>
      * <th>Package Name</th>
      * <th>Token</th>
      * <th>Expected Output Class</th>
      * <th>Notes</th>
      * </tr>
      * <tr>
      * <td>{@code com.foo.whatever}</td>
      * <td>{@code MyBarFormat}</td>
      * <td>{@code com.foo.whatever.MyBarFormat}</td>
      * <td>Token is a complete unqualified class name</td>
      * </tr>
      * <tr>
      * <td>{@code com.foo.whatever}</td>
      * <td>{@code Bar}</td>
      * <td>{@code com.foo.whatever.BarFormat} <em>or</em> {@code com.foo.whatever.BarHashFormat} <em>or</em>
      * {@code com.foo.whatever.BarCryptFormat}</td>
      * <td>The token is only part of the unqualified class name - i.e. all characters in front of the {@code *Format}
      * {@code *HashFormat} or {@code *CryptFormat} suffix.  Note that the {@code *Format} variant will be tried before
      * {@code *HashFormat} and then finally {@code *CryptFormat}</td>
      * </tr>
      * <tr>
      * <td>{@code com.foo.whatever}</td>
      * <td>{@code bar}</td>
      * <td>{@code com.foo.whatever.BarFormat} <em>or</em> {@code com.foo.whatever.BarHashFormat} <em>or</em>
      * {@code com.foo.whatever.BarCryptFormat}</td>
      * <td>Exact same output as the above {@code Bar} input example. (The token differs only by the first character)</td>
      * </tr>
      * </table>
      *
      * @param packageName the package to search for matching {@code HashFormat} implementations.
      * @param token       the string token from which a class name will be heuristically determined.
      * @return the discovered HashFormat class implementation or {@code null} if no class could be heuristically determined.
      */
     protected Class getHashFormatClass(String packageName, String token) {
         String test = token;
         Class clazz = null;
         String pkg = packageName == null ? "" : packageName;

         //1. Assume the arg is a fully qualified class name in the classpath:
         clazz = lookupHashFormatClass(test);

         if (clazz == null) {
             test = pkg + "." + token;
             clazz = lookupHashFormatClass(test);
         }

         if (clazz == null) {
             test = pkg + "." + StringUtils.uppercaseFirstChar(token) + "Format";
             clazz = lookupHashFormatClass(test);
         }

         if (clazz == null) {
             test = pkg + "." + token + "Format";
             clazz = lookupHashFormatClass(test);
         }

         if (clazz == null) {
             test = pkg + "." + StringUtils.uppercaseFirstChar(token) + "HashFormat";
             clazz = lookupHashFormatClass(test);
         }

         if (clazz == null) {
             test = pkg + "." + token + "HashFormat";
             clazz = lookupHashFormatClass(test);
         }

         if (clazz == null) {
             test = pkg + "." + StringUtils.uppercaseFirstChar(token) + "CryptFormat";
             clazz = lookupHashFormatClass(test);
         }

         if (clazz == null) {
             test = pkg + "." + token + "CryptFormat";
             clazz = lookupHashFormatClass(test);
         }

         if (clazz == null) {
             return null; //ran out of options
         }

         assertHashFormatImpl(clazz);

         return clazz;
     }

     protected Class lookupHashFormatClass(String name) {
         try {
             return ClassUtils.forName(name);
         } catch (UnknownClassException ignored) {
         }

         return null;
     }

     protected final void assertHashFormatImpl(Class clazz) {
         if (!HashFormat.class.isAssignableFrom(clazz) || clazz.isInterface()) {
             throw new IllegalArgumentException("Discovered class [" + clazz.getName() + "] is not a " +
                     HashFormat.class.getName() + " implementation.");
         }

     }

     protected final HashFormat newHashFormatInstance(Class clazz) {
         assertHashFormatImpl(clazz);
         return (HashFormat) ClassUtils.newInstance(clazz);
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you 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.apache.shiro.crypto.hash.format;

	import org.apache.shiro.util.ClassUtils;
	import org.apache.shiro.util.StringUtils;
	import org.apache.shiro.util.UnknownClassException;

	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Map;
	import java.util.Set;

	/**
	* This default {@code HashFormatFactory} implementation heuristically determines a {@code HashFormat} class to
	* instantiate based on the input argument and returns a new instance of the discovered class. The heuristics are
	* detailed in the {@link #getInstance(String) getInstance} method documentation.
	*
	* @since 1.2
	*/
	public class DefaultHashFormatFactory implements HashFormatFactory {

	private Map<String, String> formatClassNames; //id - to - fully qualified class name

	private Set<String> searchPackages; //packages to search for HashFormat implementations

	public DefaultHashFormatFactory() {
	this.searchPackages = new HashSet<String>();
	this.formatClassNames = new HashMap<String, String>();
	}

	/**
	* Returns a {@code hashFormatAlias}-to-<code>fullyQualifiedHashFormatClassNameImplementation</code> map.
	* <p/>
	* This map will be used by the {@link #getInstance(String) getInstance} implementation: that method's argument
	* will be used as a lookup key to this map. If the map returns a value, that value will be used to instantiate
	* and return a new {@code HashFormat} instance.
	* <h3>Defaults</h3>
	* Shiro's default HashFormat implementations (as listed by the {@link ProvidedHashFormat} enum) will
	* be searched automatically independently of this map. You only need to populate this map with custom
	* {@code HashFormat} implementations that are <em>not</em> already represented by a {@code ProvidedHashFormat}.
	* <h3>Efficiency</h3>
	* Populating this map will be more efficient than configuring {@link #getSearchPackages() searchPackages},
	* but search packages may be more convenient depending on the number of {@code HashFormat} implementations that
	* need to be supported by this factory.
	*
	* @return a {@code hashFormatAlias}-to-<code>fullyQualifiedHashFormatClassNameImplementation</code> map.
	*/
	public Map<String, String> getFormatClassNames() {
	return formatClassNames;
	}

	/**
	* Sets the {@code hash-format-alias}-to-{@code fullyQualifiedHashFormatClassNameImplementation} map to be used in
	* the {@link #getInstance(String)} implementation. See the {@link #getFormatClassNames()} JavaDoc for more
	* information.
	* <h3>Efficiency</h3>
	* Populating this map will be more efficient than configuring {@link #getSearchPackages() searchPackages},
	* but search packages may be more convenient depending on the number of {@code HashFormat} implementations that
	* need to be supported by this factory.
	*
	* @param formatClassNames the {@code hash-format-alias}-to-{@code fullyQualifiedHashFormatClassNameImplementation}
	* map to be used in the {@link #getInstance(String)} implementation.
	*/
	public void setFormatClassNames(Map<String, String> formatClassNames) {
	this.formatClassNames = formatClassNames;
	}

	/**
	* Returns a set of package names that can be searched for {@link HashFormat} implementations according to
	* heuristics defined in the {@link #getHashFormatClass(String, String) getHashFormat(packageName, token)} JavaDoc.
	* <h3>Efficiency</h3>
	* Configuring this property is not as efficient as configuring a {@link #getFormatClassNames() formatClassNames}
	* map, but it may be more convenient depending on the number of {@code HashFormat} implementations that
	* need to be supported by this factory.
	*
	* @return a set of package names that can be searched for {@link HashFormat} implementations
	* @see #getHashFormatClass(String, String)
	*/
	public Set<String> getSearchPackages() {
	return searchPackages;
	}

	/**
	* Sets a set of package names that can be searched for {@link HashFormat} implementations according to
	* heuristics defined in the {@link #getHashFormatClass(String, String) getHashFormat(packageName, token)} JavaDoc.
	* <h3>Efficiency</h3>
	* Configuring this property is not as efficient as configuring a {@link #getFormatClassNames() formatClassNames}
	* map, but it may be more convenient depending on the number of {@code HashFormat} implementations that
	* need to be supported by this factory.
	*
	* @param searchPackages a set of package names that can be searched for {@link HashFormat} implementations
	*/
	public void setSearchPackages(Set<String> searchPackages) {
	this.searchPackages = searchPackages;
	}

	public HashFormat getInstance(String in) {
	if (in == null) {
	return null;
	}

	HashFormat hashFormat = null;
	Class clazz = null;

	//NOTE: this code block occurs BEFORE calling getHashFormatClass(in) on purpose as a performance
	//optimization. If the input arg is an MCF-formatted string, there will be many unnecessary ClassLoader
	//misses which can be slow. By checking the MCF-formatted option, we can significantly improve performance
	if (in.startsWith(ModularCryptFormat.TOKEN_DELIMITER)) {
	//odds are high that the input argument is not a fully qualified class name or a format key (e.g. 'hex',
	//base64' or 'shiro1'). Try to find the key and lookup via that:
	String test = in.substring(ModularCryptFormat.TOKEN_DELIMITER.length());
	String[] tokens = test.split("\\" + ModularCryptFormat.TOKEN_DELIMITER);
	//the MCF ID is always the first token in the delimited string:
	String possibleMcfId = (tokens != null && tokens.length > 0) ? tokens[0] : null;
	if (possibleMcfId != null) {
	//found a possible MCF ID - test it using our heuristics to see if we can find a corresponding class:
	clazz = getHashFormatClass(possibleMcfId);
	}
	}

	if (clazz == null) {
	//not an MCF-formatted string - use the unaltered input arg and go through our heuristics:
	clazz = getHashFormatClass(in);
	}

	if (clazz != null) {
	//we found a HashFormat class - instantiate it:
	hashFormat = newHashFormatInstance(clazz);
	}

	return hashFormat;
	}

	/**
	* Heuristically determine the fully qualified HashFormat implementation class name based on the specified
	* token.
	* <p/>
	* This implementation functions as follows (in order):
	* <ol>
	* <li>See if the argument can be used as a lookup key in the {@link #getFormatClassNames() formatClassNames}
	* map. If a value (a fully qualified class name {@link HashFormat HashFormat} implementation) is found,
	* {@link ClassUtils#forName(String) lookup} the class and return it.</li>
	* <li>
	* Check to see if the token argument is a
	* {@link ProvidedHashFormat} enum value. If so, acquire the corresponding {@code HashFormat} class and
	* return it.
	* </li>
	* <li>
	* Check to see if the token argument is itself a fully qualified class name. If so, try to load the class
	* and return it.
	* </li>
	* <li>If the above options do not result in a discovered class, search all all configured
	* {@link #getSearchPackages() searchPackages} using heuristics defined in the
	* {@link #getHashFormatClass(String, String) getHashFormatClass(packageName, token)} method documentation
	* (relaying the {@code token} argument to that method for each configured package).
	* </li>
	* </ol>
	* <p/>
	* If a class is not discovered via any of the above means, {@code null} is returned to indicate the class
	* could not be found.
	*
	* @param token the string token from which a class name will be heuristically determined.
	* @return the discovered HashFormat class implementation or {@code null} if no class could be heuristically determined.
	*/
	protected Class getHashFormatClass(String token) {

	Class clazz = null;

	//check to see if the token is a configured FQCN alias. This is faster than searching packages,
	//so we try this first:
	if (this.formatClassNames != null) {
	String value = this.formatClassNames.get(token);
	if (value != null) {
	//found an alias - see if the value is a class:
	clazz = lookupHashFormatClass(value);
	}
	}

	//check to see if the token is one of Shiro's provided FQCN aliases (again, faster than searching):
	if (clazz == null) {
	ProvidedHashFormat provided = ProvidedHashFormat.byId(token);
	if (provided != null) {
	clazz = provided.getHashFormatClass();
	}
	}

	if (clazz == null) {
	//check to see if 'token' was a FQCN itself:
	clazz = lookupHashFormatClass(token);
	}

	if (clazz == null) {
	//token wasn't a FQCN or a FQCN alias - try searching in configured packages:
	if (this.searchPackages != null) {
	for (String packageName : this.searchPackages) {
	clazz = getHashFormatClass(packageName, token);
	if (clazz != null) {
	//found it:
	break;
	}
	}
	}
	}

	if (clazz != null) {
	assertHashFormatImpl(clazz);
	}

	return clazz;
	}

	/**
	* Heuristically determine the fully qualified {@code HashFormat} implementation class name in the specified
	* package based on the provided token.
	* <p/>
	* The token is expected to be a relevant fragment of an unqualified class name in the specified package.
	* A 'relevant fragment' can be one of the following:
	* <ul>
	* <li>The {@code HashFormat} implementation unqualified class name</li>
	* <li>The prefix of an unqualified class name ending with the text {@code Format}. The first character of
	* this prefix can be upper or lower case and both options will be tried.</li>
	* <li>The prefix of an unqualified class name ending with the text {@code HashFormat}. The first character of
	* this prefix can be upper or lower case and both options will be tried.</li>
	* <li>The prefix of an unqualified class name ending with the text {@code CryptoFormat}. The first character
	* of this prefix can be upper or lower case and both options will be tried.</li>
	* </ul>
	* <p/>
	* Some examples:
	* <table>
	* <tr>
	* <th>Package Name</th>
	* <th>Token</th>
	* <th>Expected Output Class</th>
	* <th>Notes</th>
	* </tr>
	* <tr>
	* <td>{@code com.foo.whatever}</td>
	* <td>{@code MyBarFormat}</td>
	* <td>{@code com.foo.whatever.MyBarFormat}</td>
	* <td>Token is a complete unqualified class name</td>
	* </tr>
	* <tr>
	* <td>{@code com.foo.whatever}</td>
	* <td>{@code Bar}</td>
	* <td>{@code com.foo.whatever.BarFormat} <em>or</em> {@code com.foo.whatever.BarHashFormat} <em>or</em>
	* {@code com.foo.whatever.BarCryptFormat}</td>
	* <td>The token is only part of the unqualified class name - i.e. all characters in front of the {@code *Format}
	* {@code HashFormat} or {@code CryptFormat} suffix. Note that the {@code *Format} variant will be tried before
	* {@code HashFormat} and then finally {@code CryptFormat}</td>
	* </tr>
	* <tr>
	* <td>{@code com.foo.whatever}</td>
	* <td>{@code bar}</td>
	* <td>{@code com.foo.whatever.BarFormat} <em>or</em> {@code com.foo.whatever.BarHashFormat} <em>or</em>
	* {@code com.foo.whatever.BarCryptFormat}</td>
	* <td>Exact same output as the above {@code Bar} input example. (The token differs only by the first character)</td>
	* </tr>
	* </table>
	*
	* @param packageName the package to search for matching {@code HashFormat} implementations.
	* @param token the string token from which a class name will be heuristically determined.
	* @return the discovered HashFormat class implementation or {@code null} if no class could be heuristically determined.
	*/
	protected Class getHashFormatClass(String packageName, String token) {
	String test = token;
	Class clazz = null;
	String pkg = packageName == null ? "" : packageName;

	//1. Assume the arg is a fully qualified class name in the classpath:
	clazz = lookupHashFormatClass(test);

	if (clazz == null) {
	test = pkg + "." + token;
	clazz = lookupHashFormatClass(test);
	}

	if (clazz == null) {
	test = pkg + "." + StringUtils.uppercaseFirstChar(token) + "Format";
	clazz = lookupHashFormatClass(test);
	}

	if (clazz == null) {
	test = pkg + "." + token + "Format";
	clazz = lookupHashFormatClass(test);
	}

	if (clazz == null) {
	test = pkg + "." + StringUtils.uppercaseFirstChar(token) + "HashFormat";
	clazz = lookupHashFormatClass(test);
	}

	if (clazz == null) {
	test = pkg + "." + token + "HashFormat";
	clazz = lookupHashFormatClass(test);
	}

	if (clazz == null) {
	test = pkg + "." + StringUtils.uppercaseFirstChar(token) + "CryptFormat";
	clazz = lookupHashFormatClass(test);
	}

	if (clazz == null) {
	test = pkg + "." + token + "CryptFormat";
	clazz = lookupHashFormatClass(test);
	}

	if (clazz == null) {
	return null; //ran out of options
	}

	assertHashFormatImpl(clazz);

	return clazz;
	}

	protected Class lookupHashFormatClass(String name) {
	try {
	return ClassUtils.forName(name);
	} catch (UnknownClassException ignored) {
	}

	return null;
	}

	protected final void assertHashFormatImpl(Class clazz) {
	if (!HashFormat.class.isAssignableFrom(clazz) \|\| clazz.isInterface()) {
	throw new IllegalArgumentException("Discovered class [" + clazz.getName() + "] is not a " +
	HashFormat.class.getName() + " implementation.");
	}

	}

	protected final HashFormat newHashFormatInstance(Class clazz) {
	assertHashFormatImpl(clazz);
	return (HashFormat) ClassUtils.newInstance(clazz);
	}
	}