Javadoc

Normalize spelling

Author: garydgregory

src/main/java/org/apache/commons/beanutils/BeanUtils.java

@@ -25,7 +25,7 @@
  *
  * <p>The implementations are provided by {@link BeanUtilsBean}.
  * These static utility methods use the default instance.
- * More sophisticated behaviour can be provided by using a <code>BeanUtilsBean</code> instance.</p>
+ * More sophisticated behavior can be provided by using a <code>BeanUtilsBean</code> instance.</p>
  *
  * @see BeanUtilsBean
  */

src/main/java/org/apache/commons/beanutils/DynaBeanMapDecorator.java

@@ -17,7 +17,7 @@
 package org.apache.commons.beanutils;
 
 /**
- * <p>Decorates a {@link DynaBean} to provide <code>Map</code> behaviour.</p>
+ * <p>Decorates a {@link DynaBean} to provide <code>Map</code> behavior.</p>
  *
  * <p>The motivation for this implementation is to provide access to {@link DynaBean}
  *    properties in technologies that are unaware of BeanUtils and {@link DynaBean}s -

src/main/java/org/apache/commons/beanutils/LazyDynaClass.java

@@ -22,7 +22,7 @@
  * <p>A <code>MutableDynaClass</code> is a specialized extension to <code>DynaClass</code>
  *    that allows properties to be added or removed dynamically.</p>
  *
- * <p>This implementation has one slightly unusual default behaviour - calling
+ * <p>This implementation has one slightly unusual default behavior - calling
  *    the <code>getDynaProperty(name)</code> method for a property which doesn't
  *    exist returns a <code>DynaProperty</code> rather than <code>null</code>. The
  *    reason for this is that <code>BeanUtils</code> calls this method to check if
@@ -31,7 +31,7 @@
  *    when any of its <code>set()</code> methods are called. For this reason the
  *    <code>isDynaProperty(name)</code> method has been added to this implementation
  *    in order to determine if a property actually exists. If the more <em>normal</em>
- *    behaviour of returning <code>null</code> is required, then this can be achieved
+ *    behavior of returning <code>null</code> is required, then this can be achieved
  *    by calling the <code>setReturnNull(true)</code>.</p>
  *
  * <p>The <code>add(name, type, readable, writable)</code> method is not implemented

src/main/java/org/apache/commons/beanutils/LazyDynaList.java

@@ -26,7 +26,7 @@
  *
  * <p>There are two main purposes for this class:</p>
  *    <ul>
- *        <li>To provide <em>Lazy List</em> behaviour - automatically
+ *        <li>To provide <em>Lazy List</em> behavior - automatically
  *            <em>growing</em> and <em>populating</em> the <code>List</code>
  *            with either <code>DynaBean</code>, <code>java.util.Map</code>
  *            or POJO Beans.</li>

src/main/java/org/apache/commons/beanutils/LazyDynaMap.java

@@ -25,10 +25,10 @@
  * <p>Its a <em>light weight</em> <code>DynaBean</code> implementation because there is no
  *    actual <code>DynaClass</code> associated with this <code>DynaBean</code> - in fact
  *    it implements the <code>DynaClass</code> interface itself providing <em>pseudo</em> DynaClass
- *    behaviour from the actual values stored in the <code>Map</code>.</p>
+ *    behavior from the actual values stored in the <code>Map</code>.</p>
  *
  * <p>As well providing rhe standard <code>DynaBean</code> access to the <code>Map</code>'s properties
- *    this class also provides the usual <em>Lazy</em> behaviour:</p>
+ *    this class also provides the usual <em>Lazy</em> behavior:</p>
  *    <ul>
  *       <li>Properties don't need to be pre-defined in a <code>DynaClass</code></li>
  *       <li>Indexed properties (<code>Lists</code> or <code>Arrays</code>) are automatically instantiated

src/main/java/org/apache/commons/beanutils/MethodUtils.java

@@ -921,7 +921,7 @@ public static Object invokeExactStaticMethod(
     /**
      * <p>Invoke a named method whose parameter type matches the object type.</p>
      *
-     * <p>The behaviour of this method is less deterministic
+     * <p>The behavior of this method is less deterministic
      * than <code>invokeExactMethod()</code>.
      * It loops through all methods with names that match
      * and then executes the first it finds with compatible parameters.</p>
@@ -961,7 +961,7 @@ public static Object invokeMethod(
     /**
      * <p>Invoke a named method whose parameter type matches the object type.</p>
      *
-     * <p>The behaviour of this method is less deterministic
+     * <p>The behavior of this method is less deterministic
      * than {@link #invokeExactMethod(Object object,String methodName,Object [] args)}.
      * It loops through all methods with names that match
      * and then executes the first it finds with compatible parameters.</p>
@@ -1008,7 +1008,7 @@ public static Object invokeMethod(
     /**
      * <p>Invoke a named method whose parameter type matches the object type.</p>
      *
-     * <p>The behaviour of this method is less deterministic
+     * <p>The behavior of this method is less deterministic
      * than {@link
      * #invokeExactMethod(Object object,String methodName,Object [] args,Class[] parameterTypes)}.
      * It loops through all methods with names that match
@@ -1062,7 +1062,7 @@ public static Object invokeMethod(
     /**
      * <p>Invoke a named static method whose parameter type matches the object type.</p>
      *
-     * <p>The behaviour of this method is less deterministic
+     * <p>The behavior of this method is less deterministic
      * than {@link #invokeExactMethod(Object, String, Object[], Class[])}.
      * It loops through all methods with names that match
      * and then executes the first it finds with compatible parameters.</p>
@@ -1103,7 +1103,7 @@ public static Object invokeStaticMethod(
     /**
      * <p>Invoke a named static method whose parameter type matches the object type.</p>
      *
-     * <p>The behaviour of this method is less deterministic
+     * <p>The behavior of this method is less deterministic
      * than {@link #invokeExactMethod(Object object,String methodName,Object [] args)}.
      * It loops through all methods with names that match
      * and then executes the first it finds with compatible parameters.</p>
@@ -1151,7 +1151,7 @@ public static Object invokeStaticMethod(
     /**
      * <p>Invoke a named static method whose parameter type matches the object type.</p>
      *
-     * <p>The behaviour of this method is less deterministic
+     * <p>The behavior of this method is less deterministic
      * than {@link
      * #invokeExactStaticMethod(Class objectClass,String methodName,Object [] args,Class[] parameterTypes)}.
      * It loops through all methods with names that match
@@ -1227,7 +1227,7 @@ public static final boolean isAssignmentCompatible(final Class<?> parameterType,
 
         if (parameterType.isPrimitive()) {
             // this method does *not* do widening - you must specify exactly
-            // is this the right behaviour?
+            // is this the right behavior?
             final Class<?> parameterWrapperClazz = getPrimitiveWrapper(parameterType);
             if (parameterWrapperClazz != null) {
                 return parameterWrapperClazz.equals(parameterization);

src/main/java/org/apache/commons/beanutils/PropertyUtilsBean.java

@@ -1824,16 +1824,16 @@ public void setProperty(final Object bean, final String name, final Object value
      * mapping and indexing operations do not make sense when accessing a map (even thought the returned object may be a Map or an Array).</li>
      * </ul>
      * <p>
-     * The default behaviour of beanutils 1.7.1 or later is for assigning to "a.b" to mean a.put(b, obj) always. However the behaviour of beanutils version
+     * The default behavior of beanutils 1.7.1 or later is for assigning to "a.b" to mean a.put(b, obj) always. However the behavior of beanutils version
      * 1.6.0, 1.6.1, 1.7.0 was for "a.b" to mean a.setB(obj) if such a method existed, and a.put(b, obj) otherwise. In version 1.5 it meant a.put(b, obj) always
-     * (ie the same as the behaviour in the current version). In versions prior to 1.5 it meant a.setB(obj) always. [yes, this is all <em>very</em> unfortunate]
+     * (ie the same as the behavior in the current version). In versions prior to 1.5 it meant a.setB(obj) always. [yes, this is all <em>very</em> unfortunate]
      * <p>
      * Users who would like to customize the meaning of "a.b" in method setNestedProperty when a is a Map can create a custom subclass of this class and
-     * override this method to implement the behaviour of their choice, such as restoring the pre-1.4 behaviour of this class if they wish. When overriding this
+     * override this method to implement the behavior of their choice, such as restoring the pre-1.4 behavior of this class if they wish. When overriding this
      * method, do not forget to deal with MAPPED_DELIM and INDEXED_DELIM characters in the propertyName.
      * <p>
      * Note, however, that the recommended solution for objects that implement Map but want their simple properties to come first is for <em>those</em> objects
-     * to override their get/put methods to implement that behaviour, and <em>not</em> to solve the problem by modifying the default behaviour of the
+     * to override their get/put methods to implement that behavior, and <em>not</em> to solve the problem by modifying the default behavior of the
      * PropertyUtilsBean class by overriding this method.
      *
      * @param bean         Map bean

src/main/java/org/apache/commons/beanutils/WeakFastHashMap.java

@@ -429,7 +429,7 @@ protected Map<K, V> cloneMap(final Map<? extends K, ? extends V> map) {
     }
 
     // Map modification
-    // These methods perform special behaviour in 'fast' mode.
+    // These methods perform special behavior in 'fast' mode.
     // The map is cloned, updated and then assigned back.
     // See the comments at the top as to why this won't always work.
 

src/main/java/org/apache/commons/beanutils/converters/StringConverter.java

@@ -32,7 +32,7 @@
  * that value.
  * <p>
  * It is possible to replace this converter with something that has a big
- * if/else statement that selects behaviour based on the real type of the
+ * if/else statement that selects behavior based on the real type of the
  * object being converted (or possibly has a map of converters, and looks
  * them up based on the class of the input object). However this is not part
  * of the existing ConvertUtils framework.

src/main/java/org/apache/commons/beanutils/locale/LocaleConvertUtilsBean.java

@@ -414,7 +414,7 @@ protected FastHashMap create(final Locale locale) {
         converter.put(String.class, new StringLocaleConverter(locale, applyLocalized));
 
         // conversion format patterns of java.sql.* types should correspond to default
-        // behaviour of toString and valueOf methods of these classes
+        // behavior of toString and valueOf methods of these classes
         converter.put(java.sql.Date.class, new SqlDateLocaleConverter(locale, "yyyy-MM-dd"));
         converter.put(java.sql.Time.class, new SqlTimeLocaleConverter(locale, "HH:mm:ss"));
         converter.put(java.sql.Timestamp.class, new SqlTimestampLocaleConverter(locale, "yyyy-MM-dd HH:mm:ss.S"));