This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-configuration.git
The following commit(s) were added to refs/heads/master by this push:
new a5395ad4 Javadoc: English, not Latin
new d9f131a3 Merge branch 'master' of
https://github.com/apache/commons-configuration.git
a5395ad4 is described below
commit a5395ad496cb296caf8faab9544df5c3062627c6
Author: Gary D. Gregory <garydgreg...@gmail.com>
AuthorDate: Tue Dec 31 08:51:47 2024 -0500
Javadoc: English, not Latin
Use longer lines
---
.../apache/commons/configuration2/AbstractConfiguration.java | 8 ++++----
.../configuration2/BaseHierarchicalConfiguration.java | 4 ++--
.../apache/commons/configuration2/CombinedConfiguration.java | 2 +-
.../apache/commons/configuration2/ConfigurationLookup.java | 2 +-
.../apache/commons/configuration2/ConfigurationUtils.java | 12 ++++++------
.../commons/configuration2/DynamicCombinedConfiguration.java | 2 +-
.../commons/configuration2/EnvironmentConfiguration.java | 2 +-
.../org/apache/commons/configuration2/INIConfiguration.java | 4 ++--
.../commons/configuration2/ImmutableConfiguration.java | 2 +-
.../configuration2/ImmutableHierarchicalConfiguration.java | 2 +-
.../org/apache/commons/configuration2/MapConfiguration.java | 6 +++---
.../commons/configuration2/PropertiesConfiguration.java | 6 +++---
.../configuration2/PropertiesConfigurationLayout.java | 2 +-
.../apache/commons/configuration2/SubnodeConfiguration.java | 2 +-
.../org/apache/commons/configuration2/XMLConfiguration.java | 6 +++---
.../org/apache/commons/configuration2/XMLDocumentHelper.java | 2 +-
.../configuration2/beanutils/BeanCreationContext.java | 2 +-
.../commons/configuration2/beanutils/BeanDeclaration.java | 6 +++---
.../commons/configuration2/beanutils/XMLBeanDeclaration.java | 2 +-
.../configuration2/builder/BasicBuilderParameters.java | 4 ++--
.../configuration2/builder/BasicConfigurationBuilder.java | 2 +-
.../configuration2/builder/ConfigurationBuilderEvent.java | 2 +-
.../configuration2/builder/DefaultParametersManager.java | 2 +-
.../builder/PropertiesBuilderParametersImpl.java | 2 +-
.../configuration2/builder/ReloadingDetectorFactory.java | 2 +-
.../builder/ReloadingFileBasedConfigurationBuilder.java | 2 +-
.../builder/combined/CombinedConfigurationBuilder.java | 6 +++---
.../builder/combined/ConfigurationDeclaration.java | 2 +-
.../builder/combined/MultiFileConfigurationBuilder.java | 2 +-
.../configuration2/convert/AbstractListDelimiterHandler.java | 2 +-
.../commons/configuration2/convert/ConversionHandler.java | 2 +-
.../configuration2/convert/DefaultConversionHandler.java | 4 ++--
.../commons/configuration2/convert/ListDelimiterHandler.java | 4 ++--
.../commons/configuration2/convert/PropertyConverter.java | 4 ++--
.../commons/configuration2/convert/ValueTransformer.java | 2 +-
.../configuration2/event/ConfigurationErrorEvent.java | 4 ++--
.../commons/configuration2/event/ConfigurationEvent.java | 2 +-
.../configuration2/interpol/ConfigurationInterpolator.java | 8 ++++----
.../org/apache/commons/configuration2/interpol/Lookup.java | 2 +-
.../java/org/apache/commons/configuration2/io/FileBased.java | 6 +++---
.../org/apache/commons/configuration2/io/FileHandler.java | 12 ++++++------
.../commons/configuration2/io/FileHandlerListener.java | 2 +-
.../apache/commons/configuration2/io/FileLocatorUtils.java | 6 +++---
.../apache/commons/configuration2/io/InputStreamSupport.java | 2 +-
.../reloading/CombinedReloadingController.java | 2 +-
.../org/apache/commons/configuration2/sync/Synchronizer.java | 2 +-
.../configuration2/tree/AbstractImmutableNodeHandler.java | 2 +-
.../configuration2/tree/ConfigurationNodeVisitor.java | 2 +-
.../commons/configuration2/tree/DefaultConfigurationKey.java | 2 +-
.../commons/configuration2/tree/DefaultExpressionEngine.java | 2 +-
.../apache/commons/configuration2/tree/ExpressionEngine.java | 4 ++--
.../commons/configuration2/tree/InMemoryNodeModel.java | 2 +-
.../org/apache/commons/configuration2/tree/NodeCombiner.java | 2 +-
.../org/apache/commons/configuration2/tree/NodeHandler.java | 2 +-
.../apache/commons/configuration2/tree/NodeKeyResolver.java | 2 +-
.../org/apache/commons/configuration2/tree/NodeModel.java | 4 ++--
.../org/apache/commons/configuration2/tree/NodeSelector.java | 2 +-
.../org/apache/commons/configuration2/tree/NodeTracker.java | 2 +-
.../apache/commons/configuration2/tree/NodeTreeWalker.java | 2 +-
.../apache/commons/configuration2/tree/TrackedNodeModel.java | 2 +-
.../commons/configuration2/TestSubnodeConfiguration.java | 2 +-
.../configuration2/tree/TestDefaultExpressionEngine.java | 2 +-
62 files changed, 101 insertions(+), 101 deletions(-)
diff --git
a/src/main/java/org/apache/commons/configuration2/AbstractConfiguration.java
b/src/main/java/org/apache/commons/configuration2/AbstractConfiguration.java
index 89600a74..f3926cae 100644
--- a/src/main/java/org/apache/commons/configuration2/AbstractConfiguration.java
+++ b/src/main/java/org/apache/commons/configuration2/AbstractConfiguration.java
@@ -74,7 +74,7 @@ import org.apache.commons.lang3.function.FailableSupplier;
* they contain a list delimiter character. If this is the case and if list
splitting is enabled, the string is split
* and multiple values are added for this property. List splitting is
controlled by a {@link ListDelimiterHandler}
* object which can be set using the {@link
#setListDelimiterHandler(ListDelimiterHandler)} method. It is disabled per
- * default. To enable this feature, set a suitable {@code
ListDelimiterHandler}, e.g. an instance of
+ * default. To enable this feature, set a suitable {@code
ListDelimiterHandler}, for example an instance of
* {@link
org.apache.commons.configuration2.convert.DefaultListDelimiterHandler
DefaultListDelimiterHandler} configured
* with the desired list delimiter character.</li>
* <li>Allows specifying how missing properties are treated. Per default the
get methods returning an object will return
@@ -87,7 +87,7 @@ import org.apache.commons.lang3.function.FailableSupplier;
* </ul>
* <p>
* Most methods defined by the {@code Configuration} interface are already
implemented in this class. Many method
- * implementations perform basic book-keeping tasks (e.g. firing events,
handling synchronization), and then delegate to
+ * implementations perform basic book-keeping tasks (for example firing
events, handling synchronization), and then delegate to
* other (protected) methods executing the actual work. Subclasses override
these protected methods to define or adapt
* behavior. The public entry point methods are final to prevent subclasses
from breaking basic functionality.
* </p>
@@ -217,7 +217,7 @@ public abstract class AbstractConfiguration extends
BaseEventSource implements C
/**
* Adds a special {@link EventListener} object to this configuration that
will log all internal errors. This method is
- * intended to be used by certain derived classes, for which it is known
that they can fail on property access (e.g.
+ * intended to be used by certain derived classes, for which it is known
that they can fail on property access (for example
* {@code DatabaseConfiguration}).
*
* @since 1.4
@@ -1305,7 +1305,7 @@ public abstract class AbstractConfiguration extends
BaseEventSource implements C
* Sets the {@code ConversionHandler} to be used by this instance. The
{@code ConversionHandler} is responsible for
* every kind of data type conversion. It is consulted by all get methods
returning results in specific data types. A
* newly created configuration uses a default {@code ConversionHandler}
implementation. This can be changed while
- * initializing the configuration (e.g. via a builder). Note that access
to this property is not synchronized.
+ * initializing the configuration (for example via a builder). Note that
access to this property is not synchronized.
*
* @param conversionHandler the {@code ConversionHandler} to be used (must
not be <strong>null</strong>)
* @throws IllegalArgumentException if the {@code ConversionHandler} is
<strong>null</strong>
diff --git
a/src/main/java/org/apache/commons/configuration2/BaseHierarchicalConfiguration.java
b/src/main/java/org/apache/commons/configuration2/BaseHierarchicalConfiguration.java
index 51fdbdce..0fd4f0d4 100644
---
a/src/main/java/org/apache/commons/configuration2/BaseHierarchicalConfiguration.java
+++
b/src/main/java/org/apache/commons/configuration2/BaseHierarchicalConfiguration.java
@@ -54,7 +54,7 @@ public class BaseHierarchicalConfiguration extends
AbstractHierarchicalConfigura
/**
* A specialized visitor base class that can be used for storing the tree
of configuration nodes. The basic idea is that
* each node can be associated with a reference object. This reference
object has a concrete meaning in a derived class,
- * e.g. an entry in a JNDI context or an XML element. When the
configuration tree is set up, the {@code load()} method
+ * for example an entry in a JNDI context or an XML element. When the
configuration tree is set up, the {@code load()} method
* is responsible for setting the reference objects. When the
configuration tree is later modified, new nodes do not
* have a defined reference object. This visitor class processes all nodes
and finds the ones without a defined
* reference object. For those nodes the {@code insert()} method is
called, which must be defined in concrete sub
@@ -663,7 +663,7 @@ public class BaseHierarchicalConfiguration extends
AbstractHierarchicalConfigura
}
/**
- * Initializes properties of a sub configuration. A sub configuration
inherits some settings from its parent, e.g. the
+ * Initializes properties of a sub configuration. A sub configuration
inherits some settings from its parent, for example the
* expression engine or the synchronizer. The corresponding values are
copied by this method.
*
* @param sub the sub configuration to be initialized
diff --git
a/src/main/java/org/apache/commons/configuration2/CombinedConfiguration.java
b/src/main/java/org/apache/commons/configuration2/CombinedConfiguration.java
index 433f78cb..2a10ab86 100644
--- a/src/main/java/org/apache/commons/configuration2/CombinedConfiguration.java
+++ b/src/main/java/org/apache/commons/configuration2/CombinedConfiguration.java
@@ -59,7 +59,7 @@ import org.apache.commons.lang3.StringUtils;
* <p>
* The big advantage of this class is that it creates a truly hierarchical
structure of all the properties stored in the
* contained configurations - even if some of them are no hierarchical
configurations per se. So all enhanced features
- * provided by a hierarchical configuration (e.g. choosing an expression
engine) are applicable.
+ * provided by a hierarchical configuration (for example choosing an
expression engine) are applicable.
* </p>
* <p>
* The class works by registering itself as an event listener at all added
configurations. So it gets notified whenever
diff --git
a/src/main/java/org/apache/commons/configuration2/ConfigurationLookup.java
b/src/main/java/org/apache/commons/configuration2/ConfigurationLookup.java
index 2895549f..50a2a2b3 100644
--- a/src/main/java/org/apache/commons/configuration2/ConfigurationLookup.java
+++ b/src/main/java/org/apache/commons/configuration2/ConfigurationLookup.java
@@ -59,7 +59,7 @@ public class ConfigurationLookup implements Lookup {
/**
* {@inheritDoc} This implementation calls {@code getProperty()} on the
associated configuration. The return value is
- * directly returned. Note that this may be a complex object, e.g. a
collection or an array.
+ * directly returned. Note that this may be a complex object, for example
a collection or an array.
*/
@Override
public Object lookup(final String variable) {
diff --git
a/src/main/java/org/apache/commons/configuration2/ConfigurationUtils.java
b/src/main/java/org/apache/commons/configuration2/ConfigurationUtils.java
index 96f2e1df..8f4886f9 100644
--- a/src/main/java/org/apache/commons/configuration2/ConfigurationUtils.java
+++ b/src/main/java/org/apache/commons/configuration2/ConfigurationUtils.java
@@ -82,7 +82,7 @@ public final class ConfigurationUtils {
* </p>
* <p>
* <em>Note:</em> This method is not able to handle some specifics of
configurations derived from
- * {@code AbstractConfiguration} (e.g. list delimiters). For a full
support of all of these features the {@code copy()}
+ * {@code AbstractConfiguration} (for example list delimiters). For a full
support of all of these features the {@code copy()}
* method of {@code AbstractConfiguration} should be used. In a future
release this method might become deprecated.
* </p>
*
@@ -101,7 +101,7 @@ public final class ConfigurationUtils {
* </p>
* <p>
* <em>Note:</em> This method is not able to handle some specifics of
configurations derived from
- * {@code AbstractConfiguration} (e.g. list delimiters). For a full
support of all of these features the {@code copy()}
+ * {@code AbstractConfiguration} (for example list delimiters). For a full
support of all of these features the {@code copy()}
* method of {@code AbstractConfiguration} should be used. In a future
release this method might become deprecated.
* </p>
*
@@ -253,7 +253,7 @@ public final class ConfigurationUtils {
* Converts the passed in {@code Configuration} object to a hierarchical
one using the specified
* {@code ExpressionEngine}. This conversion works by adding the keys
found in the configuration to a newly created
* hierarchical configuration. When adding new keys to a hierarchical
configuration the keys are interpreted by its
- * {@code ExpressionEngine}. If they contain special characters (e.g.
brackets) that are treated in a special way by the
+ * {@code ExpressionEngine}. If they contain special characters (for
example brackets) that are treated in a special way by the
* default expression engine, it may be necessary using a specific engine
that can deal with such characters. Otherwise
* <strong>null</strong> can be passed in for the {@code
ExpressionEngine}; then the default expression engine is used. If the
* passed in configuration is already hierarchical, it is directly
returned. (However, the {@code ExpressionEngine} is
@@ -296,7 +296,7 @@ public final class ConfigurationUtils {
* </p>
* <p>
* <em>Note:</em> This method is not able to handle some specifics of
configurations derived from
- * {@code AbstractConfiguration} (e.g. list delimiters). For a full
support of all of these features the {@code copy()}
+ * {@code AbstractConfiguration} (for example list delimiters). For a full
support of all of these features the {@code copy()}
* method of {@code AbstractConfiguration} should be used. In a future
release this method might become deprecated.
* </p>
*
@@ -315,7 +315,7 @@ public final class ConfigurationUtils {
* </p>
* <p>
* <em>Note:</em> This method is not able to handle some specifics of
configurations derived from
- * {@code AbstractConfiguration} (e.g. list delimiters). For a full
support of all of these features the {@code copy()}
+ * {@code AbstractConfiguration} (for example list delimiters). For a full
support of all of these features the {@code copy()}
* method of {@code AbstractConfiguration} should be used. In a future
release this method might become deprecated.
* </p>
*
@@ -398,7 +398,7 @@ public final class ConfigurationUtils {
/**
* Enables runtime exceptions for the specified configuration object. This
method can be used for configuration
- * implementations that may face errors on normal property access, e.g.
{@code DatabaseConfiguration} or
+ * implementations that may face errors on normal property access, for
example {@code DatabaseConfiguration} or
* {@code JNDIConfiguration}. Per default such errors are simply logged
and then ignored. This implementation will
* register a special {@link EventListener} that throws a runtime
exception (namely a
* {@code ConfigurationRuntimeException}) on each received error event.
diff --git
a/src/main/java/org/apache/commons/configuration2/DynamicCombinedConfiguration.java
b/src/main/java/org/apache/commons/configuration2/DynamicCombinedConfiguration.java
index f9662262..25715e2d 100644
---
a/src/main/java/org/apache/commons/configuration2/DynamicCombinedConfiguration.java
+++
b/src/main/java/org/apache/commons/configuration2/DynamicCombinedConfiguration.java
@@ -51,7 +51,7 @@ import org.apache.commons.configuration2.tree.NodeCombiner;
* <p>
* This Configuration implementation uses the configured {@code Synchronizer}
to guard itself against concurrent access.
* If there are multiple threads accessing an instance concurrently, a fully
functional {@code Synchronizer}
- * implementation (e.g. {@code ReadWriteSynchronizer}) has to be used to
ensure consistency and to avoid exceptions. The
+ * implementation (for example {@code ReadWriteSynchronizer}) has to be used
to ensure consistency and to avoid exceptions. The
* {@code Synchronizer} assigned to an instance is also passed to child
configuration objects when they are created.
* </p>
*
diff --git
a/src/main/java/org/apache/commons/configuration2/EnvironmentConfiguration.java
b/src/main/java/org/apache/commons/configuration2/EnvironmentConfiguration.java
index 120b9e58..53414002 100644
---
a/src/main/java/org/apache/commons/configuration2/EnvironmentConfiguration.java
+++
b/src/main/java/org/apache/commons/configuration2/EnvironmentConfiguration.java
@@ -33,7 +33,7 @@ import java.util.HashMap;
*
* <p>
* Usage of this class is easy: After an instance has been created the get
methods provided by the {@code Configuration}
- * interface can be used for querying environment variables, e.g.:
+ * interface can be used for querying environment variables, for example:
* </p>
*
* <pre>
diff --git
a/src/main/java/org/apache/commons/configuration2/INIConfiguration.java
b/src/main/java/org/apache/commons/configuration2/INIConfiguration.java
index a2fb891a..f8a9b713 100644
--- a/src/main/java/org/apache/commons/configuration2/INIConfiguration.java
+++ b/src/main/java/org/apache/commons/configuration2/INIConfiguration.java
@@ -173,7 +173,7 @@ import
org.apache.commons.configuration2.tree.TrackedNodeModel;
* This explains how the keys for the properties can be constructed. You can
also use other methods of
* {@link HierarchicalConfiguration} for querying or manipulating the
hierarchy of configuration nodes, for instance the
* {@code configurationAt()} method for obtaining the data of a specific
section. However, be careful that the storage
- * scheme described above is not violated (e.g. by adding multiple levels of
nodes or inserting duplicate section
+ * scheme described above is not violated (for example by adding multiple
levels of nodes or inserting duplicate section
* nodes). Otherwise, the special methods for ini configurations may not work
correctly!
* </p>
* <p>
@@ -772,7 +772,7 @@ public class INIConfiguration extends
BaseHierarchicalConfiguration implements F
* </pre>
*
* Note that a comment character is only recognized if there is at least
one whitespace character before it. So it can
- * appear in the property value, e.g.:
+ * appear in the property value, for example:
*
* <pre>
* C:\\Windows;C:\\Windows\\system32
diff --git
a/src/main/java/org/apache/commons/configuration2/ImmutableConfiguration.java
b/src/main/java/org/apache/commons/configuration2/ImmutableConfiguration.java
index 74e577ed..49dda640 100644
---
a/src/main/java/org/apache/commons/configuration2/ImmutableConfiguration.java
+++
b/src/main/java/org/apache/commons/configuration2/ImmutableConfiguration.java
@@ -266,7 +266,7 @@ public interface ImmutableConfiguration {
* Gets a collection of typed objects associated with the given
configuration key using the values in the specified
* default collection if the key does not map to an existing object. This
method is similar to {@code getList()},
* however, it allows specifying a target collection. Results are added to
this collection. This is useful if the data
- * retrieved should be added to a specific kind of collection, e.g. a set
to remove duplicates. The return value is as
+ * retrieved should be added to a specific kind of collection, for example
a set to remove duplicates. The return value is as
* follows:
* <ul>
* <li>If the key does not map to an existing object and the default value
is <strong>null</strong>, the method returns
diff --git
a/src/main/java/org/apache/commons/configuration2/ImmutableHierarchicalConfiguration.java
b/src/main/java/org/apache/commons/configuration2/ImmutableHierarchicalConfiguration.java
index 5c9424ed..bcd3313c 100644
---
a/src/main/java/org/apache/commons/configuration2/ImmutableHierarchicalConfiguration.java
+++
b/src/main/java/org/apache/commons/configuration2/ImmutableHierarchicalConfiguration.java
@@ -55,7 +55,7 @@ public interface ImmutableHierarchicalConfiguration extends
ImmutableConfigurati
int getMaxIndex(String key);
/**
- * Gets the name of the root element of this configuration. This
information may be of use in some cases, e.g. for
+ * Gets the name of the root element of this configuration. This
information may be of use in some cases, for example for
* sub configurations created using the {@code
immutableConfigurationsAt()} method. The exact meaning of the string
* returned by this method is specific to a concrete implementation. For
instance, an XML configuration might return the
* name of the document element.
diff --git
a/src/main/java/org/apache/commons/configuration2/MapConfiguration.java
b/src/main/java/org/apache/commons/configuration2/MapConfiguration.java
index 33d40ccf..143189a6 100644
--- a/src/main/java/org/apache/commons/configuration2/MapConfiguration.java
+++ b/src/main/java/org/apache/commons/configuration2/MapConfiguration.java
@@ -45,8 +45,8 @@ import
org.apache.commons.configuration2.ex.ConfigurationRuntimeException;
* <p>
* An important use case of this class is to treat a map as a {@code
Configuration} allowing access to its data through
* the richer interface. This can be a bit problematic in some cases because
the map may contain values that need not
- * adhere to the default storage scheme used by typical configuration
implementations, e.g. regarding lists. In such
- * cases care must be taken when manipulating the data through the {@code
Configuration} interface, e.g. by calling
+ * adhere to the default storage scheme used by typical configuration
implementations, for example regarding lists. In such
+ * cases care must be taken when manipulating the data through the {@code
Configuration} interface, for example by calling
* {@code addProperty()}; results may be different than expected.
* </p>
* <p>
@@ -54,7 +54,7 @@ import
org.apache.commons.configuration2.ex.ConfigurationRuntimeException;
* String is queried, it is passed to the current {@link
org.apache.commons.configuration2.convert.ListDelimiterHandler
* ListDelimiterHandler} which may generate multiple values. Note that per
default a list delimiter handler is set which
* does not do any list splitting, so this feature is disabled. It can be
enabled by setting a properly configured
- * {@code ListDelimiterHandler} implementation, e.g. a
+ * {@code ListDelimiterHandler} implementation, for example a
* {@link
org.apache.commons.configuration2.convert.DefaultListDelimiterHandler
DefaultListDelimiterHandler} object.
* </p>
* <p>
diff --git
a/src/main/java/org/apache/commons/configuration2/PropertiesConfiguration.java
b/src/main/java/org/apache/commons/configuration2/PropertiesConfiguration.java
index 41b947c8..6c594107 100644
---
a/src/main/java/org/apache/commons/configuration2/PropertiesConfiguration.java
+++
b/src/main/java/org/apache/commons/configuration2/PropertiesConfiguration.java
@@ -251,7 +251,7 @@ public class PropertiesConfiguration extends
BaseConfiguration implements FileBa
* The goal is to allow both of them be used interchangeably when reading
and writing properties files without losing or
* changing information.
* <p>
- * It also has the option to <em>not</em> use Unicode escapes. When using
UTF-8 encoding (which is e.g. the new default
+ * It also has the option to <em>not</em> use Unicode escapes. When using
UTF-8 encoding (which is for example the new default
* for resource bundle properties files since Java 9), Unicode escapes are
no longer required and avoiding them makes
* properties files more readable with regular text editors.
* <p>
@@ -272,7 +272,7 @@ public class PropertiesConfiguration extends
BaseConfiguration implements FileBa
/**
* Whether characters less than {@code \u0020} and characters greater
than {@code \u007E} in property keys or values
- * should be escaped using Unicode escape sequences. Not necessary
when e.g. writing as UTF-8.
+ * should be escaped using Unicode escape sequences. Not necessary
when for example writing as UTF-8.
*/
private final boolean escapeUnicode;
@@ -1436,7 +1436,7 @@ public class PropertiesConfiguration extends
BaseConfiguration implements FileBa
/**
* This method is invoked by the associated {@link
PropertiesConfigurationLayout} object for each property definition
- * detected in the parsed properties file. Its task is to check whether
this is a special property definition (e.g. the
+ * detected in the parsed properties file. Its task is to check whether
this is a special property definition (for example the
* {@code include} property). If not, the property must be added to this
configuration. The return value indicates
* whether the property should be treated as a normal property. If it is
<strong>false</strong>, the layout object will ignore
* this property.
diff --git
a/src/main/java/org/apache/commons/configuration2/PropertiesConfigurationLayout.java
b/src/main/java/org/apache/commons/configuration2/PropertiesConfigurationLayout.java
index 24f8def7..806eb702 100644
---
a/src/main/java/org/apache/commons/configuration2/PropertiesConfigurationLayout.java
+++
b/src/main/java/org/apache/commons/configuration2/PropertiesConfigurationLayout.java
@@ -41,7 +41,7 @@ import org.apache.commons.lang3.StringUtils;
* </p>
* <p>
* Instances of this class are associated with a {@code
PropertiesConfiguration} object. They are responsible for
- * analyzing properties files and for extracting as much information about the
file layout (e.g. empty lines, comments)
+ * analyzing properties files and for extracting as much information about the
file layout (for example empty lines, comments)
* as possible. When the properties file is written back again it should be
close to the original.
* </p>
* <p>
diff --git
a/src/main/java/org/apache/commons/configuration2/SubnodeConfiguration.java
b/src/main/java/org/apache/commons/configuration2/SubnodeConfiguration.java
index fa476f6b..7c7b1eeb 100644
--- a/src/main/java/org/apache/commons/configuration2/SubnodeConfiguration.java
+++ b/src/main/java/org/apache/commons/configuration2/SubnodeConfiguration.java
@@ -59,7 +59,7 @@ import
org.apache.commons.configuration2.tree.TrackedNodeModel;
* longer overlapping nodes, there is no way to have a synchronization here).
* </p>
* <p>
- * When a subnode configuration is created, it inherits the settings of its
parent configuration, e.g. some flags like
+ * When a subnode configuration is created, it inherits the settings of its
parent configuration, for example some flags like
* the {@code throwExceptionOnMissing} flag or the settings for handling list
delimiters) or the expression engine. If
* these settings are changed later in either the subnode or the parent
configuration, the changes are not visible for
* each other. So you could create a subnode configuration, and change its
expression engine without affecting the
diff --git
a/src/main/java/org/apache/commons/configuration2/XMLConfiguration.java
b/src/main/java/org/apache/commons/configuration2/XMLConfiguration.java
index 5e68a7f9..c5e8fe8b 100644
--- a/src/main/java/org/apache/commons/configuration2/XMLConfiguration.java
+++ b/src/main/java/org/apache/commons/configuration2/XMLConfiguration.java
@@ -79,11 +79,11 @@ import org.xml.sax.helpers.DefaultHandler;
* <p>
* Like other file based configuration classes this class maintains the name
and path to the loaded configuration file.
* These properties can be altered using several setter methods, but they are
not modified by {@code save()} and
- * {@code load()} methods. If XML documents contain relative paths to other
documents (e.g. to a DTD), these references
+ * {@code load()} methods. If XML documents contain relative paths to other
documents (for example to a DTD), these references
* are resolved based on the path set for this configuration.
* </p>
* <p>
- * By inheriting from {@link AbstractConfiguration} this class provides some
extended functionality, e.g. interpolation
+ * By inheriting from {@link AbstractConfiguration} this class provides some
extended functionality, for example interpolation
* of property values. Like in {@link PropertiesConfiguration} property values
can contain delimiter characters (the
* comma ',' per default) and are then split into multiple values. This works
for XML attributes and text content of
* elements as well. The delimiter can be escaped by a backslash. As an
example consider the following XML fragment:
@@ -103,7 +103,7 @@ import org.xml.sax.helpers.DefaultHandler;
* escaped, so that no splitting is performed.
* </p>
* <p>
- * The configuration API allows setting multiple values for a single
attribute, e.g. something like the following is
+ * The configuration API allows setting multiple values for a single
attribute, for example something like the following is
* legal (assuming that the default expression engine is used):
* </p>
*
diff --git
a/src/main/java/org/apache/commons/configuration2/XMLDocumentHelper.java
b/src/main/java/org/apache/commons/configuration2/XMLDocumentHelper.java
index 77f03d98..a09cedef 100644
--- a/src/main/java/org/apache/commons/configuration2/XMLDocumentHelper.java
+++ b/src/main/java/org/apache/commons/configuration2/XMLDocumentHelper.java
@@ -195,7 +195,7 @@ final class XMLDocumentHelper {
* Note that already a copy of this document is created. This is done for
the following reasons:
* <ul>
* <li>It is a defensive copy.</li>
- * <li>An identity transformation on a document may change certain nodes,
e.g. CDATA sections. When later on again
+ * <li>An identity transformation on a document may change certain nodes,
for example CDATA sections. When later on again
* copies of this document are created it has to be ensured that these
copies have the same structure than the original
* document stored in this instance.</li>
* </ul>
diff --git
a/src/main/java/org/apache/commons/configuration2/beanutils/BeanCreationContext.java
b/src/main/java/org/apache/commons/configuration2/beanutils/BeanCreationContext.java
index 6f123179..d6f622dd 100644
---
a/src/main/java/org/apache/commons/configuration2/beanutils/BeanCreationContext.java
+++
b/src/main/java/org/apache/commons/configuration2/beanutils/BeanCreationContext.java
@@ -22,7 +22,7 @@ package org.apache.commons.configuration2.beanutils;
* </p>
* <p>
* An object implementing this interface is passed to a {@link BeanFactory}.
The interface also contains methods for the
- * creation and initialization of nested beans (e.g. constructor arguments or
complex properties of the bean to be
+ * creation and initialization of nested beans (for example constructor
arguments or complex properties of the bean to be
* created).
* </p>
*
diff --git
a/src/main/java/org/apache/commons/configuration2/beanutils/BeanDeclaration.java
b/src/main/java/org/apache/commons/configuration2/beanutils/BeanDeclaration.java
index a6213b9e..dd61dfb6 100644
---
a/src/main/java/org/apache/commons/configuration2/beanutils/BeanDeclaration.java
+++
b/src/main/java/org/apache/commons/configuration2/beanutils/BeanDeclaration.java
@@ -30,9 +30,9 @@ import java.util.Map;
* </p>
* <p>
* This interface defines methods for retrieving all information about a bean
that should be created from a
- * configuration file, e.g. the bean's properties or the factory to use for
creating the instance. With different
+ * configuration file, for example the bean's properties or the factory to use
for creating the instance. With different
* implementations different "layouts" of bean declarations can be
supported. For instance if an XML
- * configuration file is used, all features of XML (e.g. attributes, nested
elements) can be used to define the bean. In
+ * configuration file is used, all features of XML (for example attributes,
nested elements) can be used to define the bean. In
* a properties file the declaration format is more limited. The purpose of
this interface is to abstract from the
* concrete declaration format.
* </p>
@@ -86,7 +86,7 @@ public interface BeanDeclaration {
/**
* Gets a map with declarations for beans that should be set as properties
of the newly created bean. This allows for
- * complex initialization scenarios: a bean for a bean that contains
complex properties (e.g. other beans) can have
+ * complex initialization scenarios: a bean for a bean that contains
complex properties (for example other beans) can have
* nested declarations for defining these complex properties. The returned
map's key are the names of the properties to
* initialize. The values are either {@code BeanDeclaration}
implementations or collections thereof. They will be
* treated like this declaration (in a recursive manner), and the
resulting beans are assigned to the corresponding
diff --git
a/src/main/java/org/apache/commons/configuration2/beanutils/XMLBeanDeclaration.java
b/src/main/java/org/apache/commons/configuration2/beanutils/XMLBeanDeclaration.java
index 13517805..230b85b4 100644
---
a/src/main/java/org/apache/commons/configuration2/beanutils/XMLBeanDeclaration.java
+++
b/src/main/java/org/apache/commons/configuration2/beanutils/XMLBeanDeclaration.java
@@ -60,7 +60,7 @@ import org.apache.commons.lang3.StringUtils;
* <dl>
* <dt>{@code config-class}</dt>
* <dd>Here the full qualified name of the bean's class can be specified. An
instance of this class will be created. If
- * this attribute is not specified, the bean class must be provided in another
way, e.g. as the {@code defaultClass}
+ * this attribute is not specified, the bean class must be provided in another
way, for example as the {@code defaultClass}
* passed to the {@code BeanHelper} class.</dd>
* <dt>{@code config-factory}</dt>
* <dd>This attribute can contain the name of the {@link BeanFactory} that
should be used for creating the bean. If it
diff --git
a/src/main/java/org/apache/commons/configuration2/builder/BasicBuilderParameters.java
b/src/main/java/org/apache/commons/configuration2/builder/BasicBuilderParameters.java
index fdd0cba8..10e03f89 100644
---
a/src/main/java/org/apache/commons/configuration2/builder/BasicBuilderParameters.java
+++
b/src/main/java/org/apache/commons/configuration2/builder/BasicBuilderParameters.java
@@ -293,7 +293,7 @@ public class BasicBuilderParameters implements Cloneable,
BuilderParameters, Bas
/**
* {@inheritDoc} This implementation returns a copy of the internal
parameters map with the values set so far.
- * Collection structures (e.g. for lookup objects) are stored as defensive
copies, so the original data cannot be
+ * Collection structures (for example for lookup objects) are stored as
defensive copies, so the original data cannot be
* modified.
*/
@Override
@@ -316,7 +316,7 @@ public class BasicBuilderParameters implements Cloneable,
BuilderParameters, Bas
* this method is to let a concrete implementation decide which properties
can be inherited. Because parameters are
* basically organized as a map it would be possible to simply copy over
all properties from the source object. However,
* this is not appropriate in all cases. For instance, some properties -
like a {@code ConfigurationInterpolator} - are
- * tightly connected to a configuration and cannot be reused in a
different context. For other properties, e.g. a file
+ * tightly connected to a configuration and cannot be reused in a
different context. For other properties, for example a file
* name, it does not make sense to copy it. Therefore, an implementation
has to be explicit in the properties it wants
* to take over.
*
diff --git
a/src/main/java/org/apache/commons/configuration2/builder/BasicConfigurationBuilder.java
b/src/main/java/org/apache/commons/configuration2/builder/BasicConfigurationBuilder.java
index d629a7d1..29364453 100644
---
a/src/main/java/org/apache/commons/configuration2/builder/BasicConfigurationBuilder.java
+++
b/src/main/java/org/apache/commons/configuration2/builder/BasicConfigurationBuilder.java
@@ -62,7 +62,7 @@ import
org.apache.commons.configuration2.reloading.ReloadingController;
* <li>All initialization properties can be set in one or multiple calls of
the {@code configure()} method. In each call
* an arbitrary number of {@link BuilderParameters} objects can be passed. The
API allows method chaining and is
* intended to be used from Java code.</li>
- * <li>If builder instances are created by other means - e.g. using a
dependency injection framework -, the fluent API
+ * <li>If builder instances are created by other means - for example using a
dependency injection framework -, the fluent API
* approach may not be suitable. For those use cases it is also possible to
pass in all initialization parameters as a
* map. The keys of the map have to match initialization properties of the
{@code ImmutableConfiguration} object to be
* created, the values are the corresponding property values. For instance,
the key <em>throwExceptionOnMissing</em> in
diff --git
a/src/main/java/org/apache/commons/configuration2/builder/ConfigurationBuilderEvent.java
b/src/main/java/org/apache/commons/configuration2/builder/ConfigurationBuilderEvent.java
index f3a2db68..9bf1a22e 100644
---
a/src/main/java/org/apache/commons/configuration2/builder/ConfigurationBuilderEvent.java
+++
b/src/main/java/org/apache/commons/configuration2/builder/ConfigurationBuilderEvent.java
@@ -47,7 +47,7 @@ public class ConfigurationBuilderEvent extends Event {
/**
* The specific event type for configuration request events. Events of
this type are generated each time the builder's
* {@code getConfiguration()} method is called (before the managed
configuration is actually accessed and the lock is
- * acquired). This gives listeners the opportunity to perform some checks
which may invalidate the configuration, e.g.
+ * acquired). This gives listeners the opportunity to perform some checks
which may invalidate the configuration, for example
* trigger a reload check. <strong>Note:</strong> A listener must not call
the builder's {@code getConfiguration()}
* method - this will cause an infinite loop!
*
diff --git
a/src/main/java/org/apache/commons/configuration2/builder/DefaultParametersManager.java
b/src/main/java/org/apache/commons/configuration2/builder/DefaultParametersManager.java
index ea123a7a..07dea91b 100644
---
a/src/main/java/org/apache/commons/configuration2/builder/DefaultParametersManager.java
+++
b/src/main/java/org/apache/commons/configuration2/builder/DefaultParametersManager.java
@@ -149,7 +149,7 @@ public class DefaultParametersManager {
* PropertiesBuilderParameters} (although, for technical reasons, this
relation is not reflected in the Java classes). A
* {@link DefaultParametersHandler} object defined for a base interface
can also deal with parameter objects "derived"
* from this base interface (i.e. supporting a super set of the methods
defined by the base interface). Now there may be
- * the use case that there is an implementation of {@code
DefaultParametersHandler} for a base interface (e.g.
+ * the use case that there is an implementation of {@code
DefaultParametersHandler} for a base interface (for example
* {@code FileBasedBuilderParameters}), but it should only process
specific derived interfaces (say
* {@code PropertiesBuilderParameters}, but not
* {@link
org.apache.commons.configuration2.builder.fluent.XMLBuilderParameters
XMLBuilderParameters}). This can be
diff --git
a/src/main/java/org/apache/commons/configuration2/builder/PropertiesBuilderParametersImpl.java
b/src/main/java/org/apache/commons/configuration2/builder/PropertiesBuilderParametersImpl.java
index e34df5de..438545cd 100644
---
a/src/main/java/org/apache/commons/configuration2/builder/PropertiesBuilderParametersImpl.java
+++
b/src/main/java/org/apache/commons/configuration2/builder/PropertiesBuilderParametersImpl.java
@@ -28,7 +28,7 @@ import
org.apache.commons.configuration2.ex.ConfigurationException;
* A specialized parameter class for configuring {@code
PropertiesConfiguration} instances.
* </p>
* <p>
- * This class allows setting of some properties specific to properties
configuration, e.g. the layout object. By
+ * This class allows setting of some properties specific to properties
configuration, for example the layout object. By
* inheriting from {@link FileBasedBuilderParametersImpl}, basic properties
and properties related to file-based
* configurations are available, too.
* </p>
diff --git
a/src/main/java/org/apache/commons/configuration2/builder/ReloadingDetectorFactory.java
b/src/main/java/org/apache/commons/configuration2/builder/ReloadingDetectorFactory.java
index c6b066c1..c016f5d4 100644
---
a/src/main/java/org/apache/commons/configuration2/builder/ReloadingDetectorFactory.java
+++
b/src/main/java/org/apache/commons/configuration2/builder/ReloadingDetectorFactory.java
@@ -35,7 +35,7 @@ public interface ReloadingDetectorFactory {
/**
* Creates a new {@code ReloadingDetector} object based on the passed in
parameters. The {@code FileHandler} points to
* the file to be monitored. (It may be different from the {@code
FileHandler} managed by the parameters object.) The
- * {@code FileBasedBuilderParametersImpl} object may contain additional
information for configuring the detector, e.g. a
+ * {@code FileBasedBuilderParametersImpl} object may contain additional
information for configuring the detector, for example a
* refresh delay.
*
* @param handler the handler of the file to be monitored
diff --git
a/src/main/java/org/apache/commons/configuration2/builder/ReloadingFileBasedConfigurationBuilder.java
b/src/main/java/org/apache/commons/configuration2/builder/ReloadingFileBasedConfigurationBuilder.java
index 9dc70f4b..3768fc1d 100644
---
a/src/main/java/org/apache/commons/configuration2/builder/ReloadingFileBasedConfigurationBuilder.java
+++
b/src/main/java/org/apache/commons/configuration2/builder/ReloadingFileBasedConfigurationBuilder.java
@@ -45,7 +45,7 @@ import
org.apache.commons.configuration2.reloading.ReloadingDetector;
* </p>
* <p>
* This builder does not actively trigger the {@code ReloadingController} to
perform a reload check. This has to be done
- * by an external component, e.g. a timer.
+ * by an external component, for example a timer.
* </p>
*
* @since 2.0
diff --git
a/src/main/java/org/apache/commons/configuration2/builder/combined/CombinedConfigurationBuilder.java
b/src/main/java/org/apache/commons/configuration2/builder/combined/CombinedConfigurationBuilder.java
index 33dba55f..54d95ed9 100644
---
a/src/main/java/org/apache/commons/configuration2/builder/combined/CombinedConfigurationBuilder.java
+++
b/src/main/java/org/apache/commons/configuration2/builder/combined/CombinedConfigurationBuilder.java
@@ -152,7 +152,7 @@ import org.xml.sax.EntityResolver;
* </p>
* <p>
* The default configuration object returned by this builder is an instance of
the {@link CombinedConfiguration} class.
- * This allows for convenient access to the configuration objects maintained
by the combined configuration (e.g. for
+ * This allows for convenient access to the configuration objects maintained
by the combined configuration (for example for
* updates of single configuration objects). It has also the advantage that
the properties stored in all declared
* configuration objects are collected and transformed into a single
hierarchical structure, which can be accessed using
* different expression engines. The actual {@code CombinedConfiguration}
implementation can be overridden by specifying
@@ -847,7 +847,7 @@ public class CombinedConfigurationBuilder extends
BasicConfigurationBuilder<Comb
/**
* Gets the configuration object that is currently constructed. This
method can be called during construction of the
- * result configuration. It is intended for internal usage, e.g. some
specialized builder providers need access to this
+ * result configuration. It is intended for internal usage, for example
some specialized builder providers need access to this
* configuration to perform advanced initialization.
*
* @return the configuration that us currently under construction
@@ -959,7 +959,7 @@ public class CombinedConfigurationBuilder extends
BasicConfigurationBuilder<Comb
/**
* Initializes a parameters object for a child builder. This combined
configuration builder has a bunch of properties
- * which may be inherited by child configurations, e.g. the base path, the
file system, etc. While processing the
+ * which may be inherited by child configurations, for example the base
path, the file system, etc. While processing the
* builders for child configurations, this method is called for each
parameters object for a child builder. It
* initializes some properties of the passed in parameters objects which
are derived from this parent builder.
*
diff --git
a/src/main/java/org/apache/commons/configuration2/builder/combined/ConfigurationDeclaration.java
b/src/main/java/org/apache/commons/configuration2/builder/combined/ConfigurationDeclaration.java
index b5dadd33..b5116a26 100644
---
a/src/main/java/org/apache/commons/configuration2/builder/combined/ConfigurationDeclaration.java
+++
b/src/main/java/org/apache/commons/configuration2/builder/combined/ConfigurationDeclaration.java
@@ -28,7 +28,7 @@ import
org.apache.commons.configuration2.beanutils.XMLBeanDeclaration;
* <p>
* Instances of this class are able to extract all information about a
configuration source from the configuration
* definition file. The declaration of a configuration source is very similar
to a bean declaration processed by
- * {@code XMLBeanDeclaration}. There are very few differences, e.g. some
reserved attributes like {@code optional} and
+ * {@code XMLBeanDeclaration}. There are very few differences, for example
some reserved attributes like {@code optional} and
* {@code at}, and the fact that a bean factory is never needed.
* </p>
*
diff --git
a/src/main/java/org/apache/commons/configuration2/builder/combined/MultiFileConfigurationBuilder.java
b/src/main/java/org/apache/commons/configuration2/builder/combined/MultiFileConfigurationBuilder.java
index 10331f68..905fec04 100644
---
a/src/main/java/org/apache/commons/configuration2/builder/combined/MultiFileConfigurationBuilder.java
+++
b/src/main/java/org/apache/commons/configuration2/builder/combined/MultiFileConfigurationBuilder.java
@@ -330,7 +330,7 @@ public class MultiFileConfigurationBuilder<T extends
FileBasedConfiguration> ext
*
* @return the configuration builder for the configuration corresponding
to the current evaluation of the file name
* pattern
- * @throws ConfigurationException if the builder cannot be determined
(e.g. due to missing initialization parameters)
+ * @throws ConfigurationException if the builder cannot be determined (for
example due to missing initialization parameters)
*/
public FileBasedConfigurationBuilder<T> getManagedBuilder() throws
ConfigurationException {
final Map<String, Object> params = getParameters();
diff --git
a/src/main/java/org/apache/commons/configuration2/convert/AbstractListDelimiterHandler.java
b/src/main/java/org/apache/commons/configuration2/convert/AbstractListDelimiterHandler.java
index 619a2646..6af2e8de 100644
---
a/src/main/java/org/apache/commons/configuration2/convert/AbstractListDelimiterHandler.java
+++
b/src/main/java/org/apache/commons/configuration2/convert/AbstractListDelimiterHandler.java
@@ -125,7 +125,7 @@ public abstract class AbstractListDelimiterHandler
implements ListDelimiterHandl
* contained elements are added to the resulting iteration.</li>
* <li>Arrays are treated as {@code Iterable} objects.</li>
* <li>All other types are directly inserted.</li>
- * <li>Recursive combinations are supported, e.g. a collection containing
an array that contains strings: The resulting
+ * <li>Recursive combinations are supported, for example a collection
containing an array that contains strings: The resulting
* collection will only contain primitive objects.</li>
* </ul>
*/
diff --git
a/src/main/java/org/apache/commons/configuration2/convert/ConversionHandler.java
b/src/main/java/org/apache/commons/configuration2/convert/ConversionHandler.java
index 3c9cd0a3..239003c6 100644
---
a/src/main/java/org/apache/commons/configuration2/convert/ConversionHandler.java
+++
b/src/main/java/org/apache/commons/configuration2/convert/ConversionHandler.java
@@ -63,7 +63,7 @@ public interface ConversionHandler {
<T> T to(Object src, Class<T> targetCls, ConfigurationInterpolator ci);
/**
- * Converts the given object to an array of the specified element type.
The object can be a single value (e.g. a String,
+ * Converts the given object to an array of the specified element type.
The object can be a single value (for example a String,
* a primitive, etc.) or a complex object containing multiple values (like
a collection or another array). In the latter
* case all elements contained in the complex object are converted to the
target type. If the value(s) cannot be
* converted to the desired target class, a {@link ConversionException} is
thrown. Note that the result type of this
diff --git
a/src/main/java/org/apache/commons/configuration2/convert/DefaultConversionHandler.java
b/src/main/java/org/apache/commons/configuration2/convert/DefaultConversionHandler.java
index ef04235c..de1a5bee 100644
---
a/src/main/java/org/apache/commons/configuration2/convert/DefaultConversionHandler.java
+++
b/src/main/java/org/apache/commons/configuration2/convert/DefaultConversionHandler.java
@@ -90,7 +90,7 @@ public class DefaultConversionHandler implements
ConversionHandler {
* each conversion to be done. The source object has already been passed
to the {@link ConfigurationInterpolator}, so
* interpolation does not have to be done again. (The passed in {@code
ConfigurationInterpolator} may still be necessary
* for extracting values from complex objects; it is guaranteed to be non
<strong>null</strong>.) The source object may be a
- * complex object, e.g. a collection or an array. This base implementation
checks whether the source object is complex.
+ * complex object, for example a collection or an array. This base
implementation checks whether the source object is complex.
* If so, it delegates to {@link #extractConversionValue(Object, Class,
ConfigurationInterpolator)} to obtain a single
* value. Eventually, {@link #convertValue(Object, Class,
ConfigurationInterpolator)} is called with the single value to
* be converted.
@@ -171,7 +171,7 @@ public class DefaultConversionHandler implements
ConversionHandler {
/**
* Extracts a maximum number of values contained in the given source
object and returns them as flat collection. This
- * method is useful if the caller only needs a subset of values, e.g. only
the first one.
+ * method is useful if the caller only needs a subset of values, for
example only the first one.
*
* @param source the source object (may be a single value or a complex
object)
* @param limit the number of elements to extract
diff --git
a/src/main/java/org/apache/commons/configuration2/convert/ListDelimiterHandler.java
b/src/main/java/org/apache/commons/configuration2/convert/ListDelimiterHandler.java
index dae120b8..0ac73772 100644
---
a/src/main/java/org/apache/commons/configuration2/convert/ListDelimiterHandler.java
+++
b/src/main/java/org/apache/commons/configuration2/convert/ListDelimiterHandler.java
@@ -82,7 +82,7 @@ public interface ListDelimiterHandler {
/**
* Extracts all values contained in the specified object up to the given
limit. The passed in object is evaluated (if
- * necessary in a recursive way). If it is a complex object (e.g. a
collection or an array), all its elements are
+ * necessary in a recursive way). If it is a complex object (for example a
collection or an array), all its elements are
* processed recursively and added to a target collection. The process
stops if the limit is reached, but depending on
* the input object, it might be exceeded. (The limit is just an indicator
to stop the process to avoid unnecessary work
* if the caller is only interested in a few values.)
@@ -98,7 +98,7 @@ public interface ListDelimiterHandler {
/**
* Parses the specified value for list delimiters and splits it if
necessary. The passed in object can be either a
- * single value or a complex one, e.g. a collection, an array, or an
{@code Iterable}. It is the responsibility of this
+ * single value or a complex one, for example a collection, an array, or
an {@code Iterable}. It is the responsibility of this
* method to return an {@code Iterable} which contains all extracted
values.
*
* @param value the value to be parsed
diff --git
a/src/main/java/org/apache/commons/configuration2/convert/PropertyConverter.java
b/src/main/java/org/apache/commons/configuration2/convert/PropertyConverter.java
index a9482ad8..aa99230f 100644
---
a/src/main/java/org/apache/commons/configuration2/convert/PropertyConverter.java
+++
b/src/main/java/org/apache/commons/configuration2/convert/PropertyConverter.java
@@ -207,7 +207,7 @@ public final class PropertyConverter {
/**
* Converts the specified object into a Boolean. Internally the {@code
org.apache.commons.lang.BooleanUtils} class from
* the <a href="https://commons.apache.org/lang/";>Commons Lang</a> project
is used to perform this conversion. This
- * class accepts some more tokens for the boolean value of
<strong>true</strong>, e.g. {@code yes} and {@code on}. Please refer to
+ * class accepts some more tokens for the boolean value of
<strong>true</strong>, for example {@code yes} and {@code on}. Please refer to
* the documentation of this class for more details.
*
* @param value the value to convert
@@ -514,7 +514,7 @@ public final class PropertyConverter {
* Converts the specified value into an email address with the given class
name.
*
* @param value the value to convert
- * @param targetClassName the fully qualified name of the {@code
InternetAddress} class to convert to, e.g.,
+ * @param targetClassName the fully qualified name of the {@code
InternetAddress} class to convert to, for example,
* {@value #INTERNET_ADDRESS_CLASSNAME_JAVAX} or {@value
#INTERNET_ADDRESS_CLASSNAME_JAKARTA}
* @return the converted value
* @throws ConversionException thrown if the value cannot be converted to
an email address
diff --git
a/src/main/java/org/apache/commons/configuration2/convert/ValueTransformer.java
b/src/main/java/org/apache/commons/configuration2/convert/ValueTransformer.java
index ef9e351e..de3d9678 100644
---
a/src/main/java/org/apache/commons/configuration2/convert/ValueTransformer.java
+++
b/src/main/java/org/apache/commons/configuration2/convert/ValueTransformer.java
@@ -23,7 +23,7 @@ package org.apache.commons.configuration2.convert;
* </p>
* <p>
* Some {@code Configuration} implementations require a special encoding of
their property values before they get
- * written on disk. In some constellations, e.g. when a property with multiple
values is to be forced on a single line,
+ * written on disk. In some constellations, for example when a property with
multiple values is to be forced on a single line,
* this encoding has to be done together with the escaping of list delimiter
characters - which is in the responsibility
* of {@link ListDelimiterHandler}.
* </p>
diff --git
a/src/main/java/org/apache/commons/configuration2/event/ConfigurationErrorEvent.java
b/src/main/java/org/apache/commons/configuration2/event/ConfigurationErrorEvent.java
index 6b3aaa61..ec02d9d6 100644
---
a/src/main/java/org/apache/commons/configuration2/event/ConfigurationErrorEvent.java
+++
b/src/main/java/org/apache/commons/configuration2/event/ConfigurationErrorEvent.java
@@ -21,7 +21,7 @@ package org.apache.commons.configuration2.event;
* An event class that is used for reporting errors that occurred while
processing configuration properties.
* </p>
* <p>
- * Some configuration implementations (e.g. {@link
org.apache.commons.configuration2.DatabaseConfiguration} or
+ * Some configuration implementations (for example {@link
org.apache.commons.configuration2.DatabaseConfiguration} or
* {@link org.apache.commons.configuration2.JNDIConfiguration} use an
underlying storage that can throw an exception on
* each property access. In earlier versions of this library such exceptions
were logged and then silently ignored. This
* makes it impossible for a client to find out that something went wrong.
@@ -35,7 +35,7 @@ package org.apache.commons.configuration2.event;
* This class defines similar properties to the {@link ConfigurationEvent}
class. This makes it possible to find out
* which operation was performed on a configuration causing this error event.
In addition, a {@code Throwable} object is
* available representing the occurred error. Note that depending on the event
type and the occurred exception not all
- * of the other properties (e.g. name of the affected property or its value)
may be available.
+ * of the other properties (for example name of the affected property or its
value) may be available.
* </p>
*
* @since 1.4
diff --git
a/src/main/java/org/apache/commons/configuration2/event/ConfigurationEvent.java
b/src/main/java/org/apache/commons/configuration2/event/ConfigurationEvent.java
index dd208b09..d3e34025 100644
---
a/src/main/java/org/apache/commons/configuration2/event/ConfigurationEvent.java
+++
b/src/main/java/org/apache/commons/configuration2/event/ConfigurationEvent.java
@@ -22,7 +22,7 @@ package org.apache.commons.configuration2.event;
* </p>
* <p>
* Event objects of this type are used for "raw" events, i.e.
unfiltered modifications of any kind. A level
- * with semantically higher events (e.g. for property changes) may be built on
top of this fundamental event mechanism.
+ * with semantically higher events (for example for property changes) may be
built on top of this fundamental event mechanism.
* </p>
* <p>
* Each event can contain the following data:
diff --git
a/src/main/java/org/apache/commons/configuration2/interpol/ConfigurationInterpolator.java
b/src/main/java/org/apache/commons/configuration2/interpol/ConfigurationInterpolator.java
index bd1252a0..1cfec976 100644
---
a/src/main/java/org/apache/commons/configuration2/interpol/ConfigurationInterpolator.java
+++
b/src/main/java/org/apache/commons/configuration2/interpol/ConfigurationInterpolator.java
@@ -196,7 +196,7 @@ public class ConfigurationInterpolator {
}
/** Attempt to extract a simple value from {@code obj} for use in
string conversion.
- * If the input represents a collection of some sort (e.g., an
iterable or array),
+ * If the input represents a collection of some sort (for example, an
iterable or array),
* the first item from the collection is returned.
* @param obj input object
* @return extracted simple object
@@ -304,8 +304,8 @@ public class ConfigurationInterpolator {
*
* <p>
* All of the lookups present in the returned map are from {@link
DefaultLookups}. However, not all of the
- * available lookups are included by default. Specifically, lookups that
can execute code (e.g.,
- * {@link DefaultLookups#SCRIPT SCRIPT}) and those that can result in
contact with remote servers (e.g.,
+ * available lookups are included by default. Specifically, lookups that
can execute code (for example,
+ * {@link DefaultLookups#SCRIPT SCRIPT}) and those that can result in
contact with remote servers (for example,
* {@link DefaultLookups#URL URL} and {@link DefaultLookups#DNS DNS}) are
not included. If this behavior
* must be modified, users can define the {@value
#DEFAULT_PREFIX_LOOKUPS_PROPERTY} system property
* with a comma-separated list of {@link DefaultLookups} enum names to be
included in the set of defaults.
@@ -600,7 +600,7 @@ public class ConfigurationInterpolator {
}
/**
- * Checks whether a value to be interpolated consists of single, simple
variable reference, e.g.,
+ * Checks whether a value to be interpolated consists of single, simple
variable reference, for example,
* <code>${myvar}</code>. In this case, the variable is resolved directly
without using the
* {@code StringSubstitutor}.
*
diff --git
a/src/main/java/org/apache/commons/configuration2/interpol/Lookup.java
b/src/main/java/org/apache/commons/configuration2/interpol/Lookup.java
index 1ca938d7..9ce83f9f 100644
--- a/src/main/java/org/apache/commons/configuration2/interpol/Lookup.java
+++ b/src/main/java/org/apache/commons/configuration2/interpol/Lookup.java
@@ -23,7 +23,7 @@ package org.apache.commons.configuration2.interpol;
* <p>
* Objects implementing this interface can be assigned a variable prefix and
added to a
* {@link ConfigurationInterpolator} object. Whenever the {@code
ConfigurationInterpolator} encounters a property value
- * referencing a variable, e.g. {@code ${prefix:variableName}}, it extracts
the prefix and finds the matching
+ * referencing a variable, for example {@code ${prefix:variableName}}, it
extracts the prefix and finds the matching
* {@code Lookup} object. Then this object is asked to resolve the variable
name and provide the corresponding value.
* </p>
* <p>
diff --git a/src/main/java/org/apache/commons/configuration2/io/FileBased.java
b/src/main/java/org/apache/commons/configuration2/io/FileBased.java
index 65c3da68..a95fca74 100644
--- a/src/main/java/org/apache/commons/configuration2/io/FileBased.java
+++ b/src/main/java/org/apache/commons/configuration2/io/FileBased.java
@@ -35,7 +35,7 @@ import
org.apache.commons.configuration2.ex.ConfigurationException;
* <p>
* <strong>Note that the methods defined by this interface are not intended to
be called directly by client
* code!</strong> Rather, they are used internally when doing I/O operations
with a {@link FileHandler}. A
- * {@code FileHandler} supports additional functionality (e.g. it evaluates
some additional interfaces the
+ * {@code FileHandler} supports additional functionality (for example it
evaluates some additional interfaces the
* {@code FileBased} object may implement); this functionality is not
available on a direct method invocation, so this
* may lead to unpredictable results.
* </p>
@@ -47,7 +47,7 @@ public interface FileBased {
*
* @param in the reader
* @throws IOException if an I/O error occurs.
- * @throws ConfigurationException if a non-I/O related problem occurs,
e.g. the data read does not have the expected
+ * @throws ConfigurationException if a non-I/O related problem occurs, for
example the data read does not have the expected
* format
*/
void read(Reader in) throws ConfigurationException, IOException;
@@ -58,7 +58,7 @@ public interface FileBased {
*
* @param out the writer
* @throws IOException if an I/O error occurs.
- * @throws ConfigurationException if a non-I/O related problem occurs,
e.g. the data read does not have the expected
+ * @throws ConfigurationException if a non-I/O related problem occurs, for
example the data read does not have the expected
* format
*/
void write(Writer out) throws ConfigurationException, IOException;
diff --git
a/src/main/java/org/apache/commons/configuration2/io/FileHandler.java
b/src/main/java/org/apache/commons/configuration2/io/FileHandler.java
index 72256ea7..52fc0225 100644
--- a/src/main/java/org/apache/commons/configuration2/io/FileHandler.java
+++ b/src/main/java/org/apache/commons/configuration2/io/FileHandler.java
@@ -88,7 +88,7 @@ import org.apache.commons.logging.LogFactory;
* </p>
* <ul>
* <li>{@code FileLocatorAware}: In this case an object with the current file
location is injected before the load or
- * save operation is executed. This is useful for {@code FileBased} objects
that depend on their current location, e.g.
+ * save operation is executed. This is useful for {@code FileBased} objects
that depend on their current location, for example
* to resolve relative path names.</li>
* <li>{@code SynchronizerSupport}: If this interface is implemented, load and
save operations obtain a write lock on
* the {@code FileBased} object before they access it. (In case of a save
operation, a read lock would probably be
@@ -544,7 +544,7 @@ public class FileHandler {
/**
* Checks whether the associated {@code FileBased} object implements the
{@code FileLocatorAware} interface. If this is
* the case, a {@code FileLocator} instance is injected which returns only
<strong>null</strong> values. This method is called if
- * no file location is available (e.g. if data is to be loaded from a
stream). The encoding of the injected locator is
+ * no file location is available (for example if data is to be loaded from
a stream). The encoding of the injected locator is
* derived from this object.
*/
private void injectNullFileLocator() {
@@ -646,7 +646,7 @@ public class FileHandler {
/**
* Loads the associated file from the given file name. The file name is
interpreted in the context of the already set
- * location (e.g. if it is a relative file name, a base path is applied if
available). The underlying location is not
+ * location (for example if it is a relative file name, a base path is
applied if available). The underlying location is not
* changed.
*
* @param fileName the name of the file to be loaded
@@ -788,7 +788,7 @@ public class FileHandler {
/**
* Locates the referenced file if necessary and ensures that the
associated {@link FileLocator} is fully initialized.
* When accessing the referenced file the information stored in the
associated {@code FileLocator} is used. If this
- * information is incomplete (e.g. only the file name is set), an attempt
to locate the file may have to be performed on
+ * information is incomplete (for example only the file name is set), an
attempt to locate the file may have to be performed on
* each access. By calling this method such an attempt is performed once,
and the results of a successful localization
* are stored. Hence, later access to the referenced file can be more
efficient. Also, all properties pointing to the
* referenced file in this object's {@code FileLocator} are set (i.e. the
URL, the base path, and the file name). If the
@@ -818,7 +818,7 @@ public class FileHandler {
}
/**
- * Prepares a builder for a {@code FileLocator} which does not have a
defined file location. Other properties (e.g.
+ * Prepares a builder for a {@code FileLocator} which does not have a
defined file location. Other properties (for example
* encoding or file system) are initialized from the {@code FileLocator}
associated with this object.
*
* @return the initialized builder for a {@code FileLocator}
@@ -1071,7 +1071,7 @@ public class FileHandler {
* for locating the file are quite tolerant. For instance if the file name
is already an absolute path or a fully
* defined URL, the base path will be ignored. The base path can also be a
URL, in which case the file name is
* interpreted in this URL's context. If other methods are used for
determining the location of the associated file
- * (e.g. {@code setFile()} or {@code setURL()}), the base path is
automatically set. Setting the base path using this
+ * (for example {@code setFile()} or {@code setURL()}), the base path is
automatically set. Setting the base path using this
* method automatically sets the URL to <strong>null</strong> because it
has to be determined anew based on the file name and the
* base path.
*
diff --git
a/src/main/java/org/apache/commons/configuration2/io/FileHandlerListener.java
b/src/main/java/org/apache/commons/configuration2/io/FileHandlerListener.java
index 91ee3ab0..1d483bf5 100644
---
a/src/main/java/org/apache/commons/configuration2/io/FileHandlerListener.java
+++
b/src/main/java/org/apache/commons/configuration2/io/FileHandlerListener.java
@@ -22,7 +22,7 @@ package org.apache.commons.configuration2.io;
* </p>
* <p>
* Objects implementing this interface are notified when properties of a
{@code FileHandler} change or when a load or
- * save operation is performed. This can be useful for various use cases, e.g.
when monitoring file-based
+ * save operation is performed. This can be useful for various use cases, for
example when monitoring file-based
* configurations.
* </p>
*
diff --git
a/src/main/java/org/apache/commons/configuration2/io/FileLocatorUtils.java
b/src/main/java/org/apache/commons/configuration2/io/FileLocatorUtils.java
index 870b41e5..4f7f2fa9 100644
--- a/src/main/java/org/apache/commons/configuration2/io/FileLocatorUtils.java
+++ b/src/main/java/org/apache/commons/configuration2/io/FileLocatorUtils.java
@@ -35,7 +35,7 @@ import org.apache.commons.logging.LogFactory;
* </p>
* <p>
* The methods of this class are used behind the scenes when retrieving
configuration files based on different criteria,
- * e.g. URLs, files, or more complex search strategies. They also implement
functionality required by the default
+ * for example URLs, files, or more complex search strategies. They also
implement functionality required by the default
* {@link FileSystem} implementations. Most methods are intended to be used
internally only by other classes in the
* {@code io} package.
* </p>
@@ -222,7 +222,7 @@ public final class FileLocatorUtils {
/**
* Returns a {@code FileLocatorBuilder} which is already initialized with
the properties of the passed in
* {@code FileLocator}. This builder can be used to create a {@code
FileLocator} object which shares properties of the
- * original locator (e.g. the {@code FileSystem} or the encoding), but
points to a different file. An example use case
+ * original locator (for example the {@code FileSystem} or the encoding),
but points to a different file. An example use case
* is as follows:
*
* <pre>
@@ -337,7 +337,7 @@ public final class FileLocatorUtils {
}
/**
- * Tries to convert the specified base path and file name into a file
object. This method is called e.g. by the save()
+ * Tries to convert the specified base path and file name into a file
object. This method is called for example by the save()
* methods of file based configurations. The parameter strings can be
relative files, absolute files and URLs as well.
* This implementation checks first whether the passed in file name is
absolute. If this is the case, it is returned.
* Otherwise further checks are performed whether the base path and file
name can be combined to a valid URL or a valid
diff --git
a/src/main/java/org/apache/commons/configuration2/io/InputStreamSupport.java
b/src/main/java/org/apache/commons/configuration2/io/InputStreamSupport.java
index ffcac4ea..bb6ff870 100644
--- a/src/main/java/org/apache/commons/configuration2/io/InputStreamSupport.java
+++ b/src/main/java/org/apache/commons/configuration2/io/InputStreamSupport.java
@@ -41,7 +41,7 @@ public interface InputStreamSupport {
* Reads the content of this object from the specified {@code InputStream}.
*
* @param in the input stream
- * @throws ConfigurationException if a non-I/O related problem occurs,
e.g. the data read does not have the expected
+ * @throws ConfigurationException if a non-I/O related problem occurs, for
example the data read does not have the expected
* format
* @throws IOException if an I/O error occurs.
*/
diff --git
a/src/main/java/org/apache/commons/configuration2/reloading/CombinedReloadingController.java
b/src/main/java/org/apache/commons/configuration2/reloading/CombinedReloadingController.java
index 88480add..cd0a9a31 100644
---
a/src/main/java/org/apache/commons/configuration2/reloading/CombinedReloadingController.java
+++
b/src/main/java/org/apache/commons/configuration2/reloading/CombinedReloadingController.java
@@ -41,7 +41,7 @@ import java.util.Objects;
* <p>
* This class expects the managed controller objects to be passed to the
constructor. From this list a defensive copy is
* created so that it cannot be changed later on. Derived classes can override
the {@link #getSubControllers()} method
- * if they need another way to handle child controllers (e.g. a more dynamic
way). However, they are then responsible to
+ * if they need another way to handle child controllers (for example a more
dynamic way). However, they are then responsible to
* ensure a safe access to this list in a multi-threaded environment.
* </p>
*
diff --git
a/src/main/java/org/apache/commons/configuration2/sync/Synchronizer.java
b/src/main/java/org/apache/commons/configuration2/sync/Synchronizer.java
index dad7cb1d..52c9a9ee 100644
--- a/src/main/java/org/apache/commons/configuration2/sync/Synchronizer.java
+++ b/src/main/java/org/apache/commons/configuration2/sync/Synchronizer.java
@@ -23,7 +23,7 @@ package org.apache.commons.configuration2.sync;
* <p>
* Each {@code Configuration} object derived from {@link
org.apache.commons.configuration2.AbstractConfiguration
* AbstractConfiguration} has an associated {@code Synchronizer} object.
Before an operation on the configuration is
- * performed (e.g. a property read or an update), the {@code Synchronizer} is
invoked. Depending on the concrete
+ * performed (for example a property read or an update), the {@code
Synchronizer} is invoked. Depending on the concrete
* implementation of the {@code Synchronizer} used, the configuration can be
made thread-safe.
* </p>
* <p>
diff --git
a/src/main/java/org/apache/commons/configuration2/tree/AbstractImmutableNodeHandler.java
b/src/main/java/org/apache/commons/configuration2/tree/AbstractImmutableNodeHandler.java
index a2c8b384..740ff714 100644
---
a/src/main/java/org/apache/commons/configuration2/tree/AbstractImmutableNodeHandler.java
+++
b/src/main/java/org/apache/commons/configuration2/tree/AbstractImmutableNodeHandler.java
@@ -27,7 +27,7 @@ import java.util.stream.Collectors;
* </p>
* <p>
* This class already implements all methods which need no other information
than the passed in node object.
- * Functionality which requires additional state (e.g. querying the root node
or a parent node) has to be added by
+ * Functionality which requires additional state (for example querying the
root node or a parent node) has to be added by
* concrete sub classes.
* </p>
*
diff --git
a/src/main/java/org/apache/commons/configuration2/tree/ConfigurationNodeVisitor.java
b/src/main/java/org/apache/commons/configuration2/tree/ConfigurationNodeVisitor.java
index 32d0008e..caedc83e 100644
---
a/src/main/java/org/apache/commons/configuration2/tree/ConfigurationNodeVisitor.java
+++
b/src/main/java/org/apache/commons/configuration2/tree/ConfigurationNodeVisitor.java
@@ -36,7 +36,7 @@ package org.apache.commons.configuration2.tree;
public interface ConfigurationNodeVisitor<T> {
/**
* Returns a flag whether the current visit process should be aborted.
This method allows a visitor implementation to
- * state that it does not need any further data. It may be used e.g. by
visitors that search for a certain node in the
+ * state that it does not need any further data. It may be used for
example by visitors that search for a certain node in the
* hierarchy. After that node was found, there is no need to process the
remaining nodes, too. This method is called
* after each visited node. A result of <strong>true</strong> indicates
that the current iteration is to be aborted.
*
diff --git
a/src/main/java/org/apache/commons/configuration2/tree/DefaultConfigurationKey.java
b/src/main/java/org/apache/commons/configuration2/tree/DefaultConfigurationKey.java
index 858e0ee2..7b4d6e9d 100644
---
a/src/main/java/org/apache/commons/configuration2/tree/DefaultConfigurationKey.java
+++
b/src/main/java/org/apache/commons/configuration2/tree/DefaultConfigurationKey.java
@@ -700,7 +700,7 @@ public class DefaultConfigurationKey {
}
/**
- * Sets the new length of this configuration key. With this method it is
possible to truncate the key, e.g. to return to
+ * Sets the new length of this configuration key. With this method it is
possible to truncate the key, for example to return to
* a state prior calling some {@code append()} methods. The semantic is
the same as the {@code setLength()} method of
* {@code StringBuilder}.
*
diff --git
a/src/main/java/org/apache/commons/configuration2/tree/DefaultExpressionEngine.java
b/src/main/java/org/apache/commons/configuration2/tree/DefaultExpressionEngine.java
index d93295ea..ea1b1b3d 100644
---
a/src/main/java/org/apache/commons/configuration2/tree/DefaultExpressionEngine.java
+++
b/src/main/java/org/apache/commons/configuration2/tree/DefaultExpressionEngine.java
@@ -296,7 +296,7 @@ public class DefaultExpressionEngine implements
ExpressionEngine {
* ...
* </pre>
* <p>
- * In this example a database structure is defined, e.g. all fields of the
first table could be accessed using the key
+ * In this example a database structure is defined, for example all fields
of the first table could be accessed using the key
* {@code tables.table(0).fields.field.name}. If now properties are to be
added, it must be exactly specified at which
* position in the hierarchy the new property is to be inserted. So to add
a new field name to a table it is not enough
* to say just
diff --git
a/src/main/java/org/apache/commons/configuration2/tree/ExpressionEngine.java
b/src/main/java/org/apache/commons/configuration2/tree/ExpressionEngine.java
index b0d16a96..ee4721b3 100644
--- a/src/main/java/org/apache/commons/configuration2/tree/ExpressionEngine.java
+++ b/src/main/java/org/apache/commons/configuration2/tree/ExpressionEngine.java
@@ -25,7 +25,7 @@ import java.util.List;
* <p>
* An <em>expression engine</em> knows how to map a key for a configuration's
property to a single or a set of
* configuration nodes. Thus it defines the way how properties are addressed
in this configuration. Methods of a
- * configuration that have to handle property keys (e.g. {@code getProperty()}
or {@code addProperty()} do not interpret
+ * configuration that have to handle property keys (for example {@code
getProperty()} or {@code addProperty()} do not interpret
* the passed in keys on their own, but delegate this task to an associated
expression engine. This expression engine
* will then find out, which configuration nodes are addressed by the key.
* </p>
@@ -69,7 +69,7 @@ public interface ExpressionEngine {
/**
* Returns the key for the specified node in the expression language
supported by an implementation. This method is
- * called whenever a property key for a node has to be constructed, e.g.
by the
+ * called whenever a property key for a node has to be constructed, for
example by the
* {@link org.apache.commons.configuration2.Configuration#getKeys()
getKeys()} method.
*
* @param <T> the type of the node to be processed
diff --git
a/src/main/java/org/apache/commons/configuration2/tree/InMemoryNodeModel.java
b/src/main/java/org/apache/commons/configuration2/tree/InMemoryNodeModel.java
index 51b392d0..f1f43778 100644
---
a/src/main/java/org/apache/commons/configuration2/tree/InMemoryNodeModel.java
+++
b/src/main/java/org/apache/commons/configuration2/tree/InMemoryNodeModel.java
@@ -628,7 +628,7 @@ public class InMemoryNodeModel implements
NodeModel<ImmutableNode> {
/**
* Gets the root node of this mode. Note: This method should be used with
care. The model may be updated concurrently
- * which causes the root node to be replaced. If the root node is to be
processed further (e.g. by executing queries on
+ * which causes the root node to be replaced. If the root node is to be
processed further (for example by executing queries on
* it), the model should be asked for its {@code NodeHandler}, and the
root node should be obtained from there. The
* connection between a node handler and its root node remain constant
because an update of the model causes the whole
* node handler to be replaced.
diff --git
a/src/main/java/org/apache/commons/configuration2/tree/NodeCombiner.java
b/src/main/java/org/apache/commons/configuration2/tree/NodeCombiner.java
index def670dc..2df02c46 100644
--- a/src/main/java/org/apache/commons/configuration2/tree/NodeCombiner.java
+++ b/src/main/java/org/apache/commons/configuration2/tree/NodeCombiner.java
@@ -26,7 +26,7 @@ import java.util.Set;
* </p>
* <p>
* A <em>node combiner</em> is an object that knows how two hierarchical node
structures can be combined into a single
- * one. Of course, there are many possible ways of implementing such a
combination, e.g. constructing a union, an
+ * one. Of course, there are many possible ways of implementing such a
combination, for example constructing a union, an
* intersection, or an "override" structure (were nodes in the first hierarchy
take precedence over nodes in the second
* hierarchy). This abstract base class only provides some helper methods and
defines the common interface for node
* combiners. Concrete sub classes will implement the diverse combination
algorithms.
diff --git
a/src/main/java/org/apache/commons/configuration2/tree/NodeHandler.java
b/src/main/java/org/apache/commons/configuration2/tree/NodeHandler.java
index 18ec5a2a..15b1b213 100644
--- a/src/main/java/org/apache/commons/configuration2/tree/NodeHandler.java
+++ b/src/main/java/org/apache/commons/configuration2/tree/NodeHandler.java
@@ -158,7 +158,7 @@ public interface NodeHandler<T> {
int indexOfChild(T parent, T child);
/**
- * Checks whether the specified node is defined. Nodes are
"defined" if they contain any data, e.g. a value,
+ * Checks whether the specified node is defined. Nodes are
"defined" if they contain any data, for example a value,
* or attributes, or defined children.
*
* @param node the node to test
diff --git
a/src/main/java/org/apache/commons/configuration2/tree/NodeKeyResolver.java
b/src/main/java/org/apache/commons/configuration2/tree/NodeKeyResolver.java
index acab1895..a0462e4d 100644
--- a/src/main/java/org/apache/commons/configuration2/tree/NodeKeyResolver.java
+++ b/src/main/java/org/apache/commons/configuration2/tree/NodeKeyResolver.java
@@ -71,7 +71,7 @@ public interface NodeKeyResolver<T> {
/**
* Performs a query for the specified key on the given root node returning
only node results. Some operations require
- * results of type node and do not support attributes (e.g. for tracking
nodes). This operation can be used in such
+ * results of type node and do not support attributes (for example for
tracking nodes). This operation can be used in such
* cases. It works like {@code resolveKey()}, but filters only for results
of type node.
*
* @param root the root node
diff --git
a/src/main/java/org/apache/commons/configuration2/tree/NodeModel.java
b/src/main/java/org/apache/commons/configuration2/tree/NodeModel.java
index 29de96ad..857707b2 100644
--- a/src/main/java/org/apache/commons/configuration2/tree/NodeModel.java
+++ b/src/main/java/org/apache/commons/configuration2/tree/NodeModel.java
@@ -28,7 +28,7 @@ import java.util.Collection;
* </p>
* <p>
* The idea behind this interface is that concrete implementations can be used
by hierarchical configurations. This
- * makes it possible to integrate various hierarchical structures with the API
of a hierarchical configuration, e.g.
+ * makes it possible to integrate various hierarchical structures with the API
of a hierarchical configuration, for example
* configuration nodes stored in memory, JNDI contexts, or other structures.
The configuration object interacts with the
* underlying data structure via this interface. For more complex operations
access to an {@link ExpressionEngine} may
* be required in order to interpret the passed in keys. For these purposes a
{@link NodeKeyResolver} has to be provided
@@ -93,7 +93,7 @@ public interface NodeModel<T> {
/**
* Gets a representation of the data stored in this model in form of a
nodes hierarchy of {@code ImmutableNode}
* objects. A concrete model implementation can use an arbitrary means to
store its data. When a model's data is to be
- * used together with other functionality of the <em>Configuration</em>
library (e.g. when combining multiple
+ * used together with other functionality of the <em>Configuration</em>
library (for example when combining multiple
* configuration sources) it has to be transformed into a common format.
This is done by this method.
* {@code ImmutableNode} is a generic representation of a hierarchical
structure. Thus, it should be possible to
* generate a corresponding structure from arbitrary model data.
diff --git
a/src/main/java/org/apache/commons/configuration2/tree/NodeSelector.java
b/src/main/java/org/apache/commons/configuration2/tree/NodeSelector.java
index 2283148f..a1d3fc0e 100644
--- a/src/main/java/org/apache/commons/configuration2/tree/NodeSelector.java
+++ b/src/main/java/org/apache/commons/configuration2/tree/NodeSelector.java
@@ -30,7 +30,7 @@ import org.apache.commons.lang3.builder.ToStringBuilder;
* </p>
* <p>
* An instance of this class is initialized with the key of a node. It is also
possible to concatenate multiple keys -
- * e.g. if a sub key is to be constructed from another sub key. {@code
NodeSelector} provides the {@code select()}
+ * for example if a sub key is to be constructed from another sub key. {@code
NodeSelector} provides the {@code select()}
* method which evaluates the wrapped keys on a specified root node and
returns the resulting unique target node. The
* class expects that the key(s) stored in an instance select exactly one
target node. If this is not the case, result
* is <strong>null</strong> indicating that the selection criteria are not
sufficient.
diff --git
a/src/main/java/org/apache/commons/configuration2/tree/NodeTracker.java
b/src/main/java/org/apache/commons/configuration2/tree/NodeTracker.java
index db52ffd1..eab159fb 100644
--- a/src/main/java/org/apache/commons/configuration2/tree/NodeTracker.java
+++ b/src/main/java/org/apache/commons/configuration2/tree/NodeTracker.java
@@ -265,7 +265,7 @@ final class NodeTracker {
/**
* Marks all tracked nodes as detached. This method is called if there are
some drastic changes on the underlying node
- * structure, e.g. if the root node was replaced.
+ * structure, for example if the root node was replaced.
*
* @return the updated instance
*/
diff --git
a/src/main/java/org/apache/commons/configuration2/tree/NodeTreeWalker.java
b/src/main/java/org/apache/commons/configuration2/tree/NodeTreeWalker.java
index e518ada8..db6d44c8 100644
--- a/src/main/java/org/apache/commons/configuration2/tree/NodeTreeWalker.java
+++ b/src/main/java/org/apache/commons/configuration2/tree/NodeTreeWalker.java
@@ -31,7 +31,7 @@ import java.util.List;
* </p>
* <p>
* An instance of this class does not define any state; therefore, it can be
shared and used concurrently. The
- * {@code INSTANCE} member field can be used for accessing a default instance.
If desired (e.g. for testing purposes),
+ * {@code INSTANCE} member field can be used for accessing a default instance.
If desired (for example for testing purposes),
* new instances can be created.
* </p>
*
diff --git
a/src/main/java/org/apache/commons/configuration2/tree/TrackedNodeModel.java
b/src/main/java/org/apache/commons/configuration2/tree/TrackedNodeModel.java
index 2367dce7..a6faa559 100644
--- a/src/main/java/org/apache/commons/configuration2/tree/TrackedNodeModel.java
+++ b/src/main/java/org/apache/commons/configuration2/tree/TrackedNodeModel.java
@@ -38,7 +38,7 @@ import java.util.concurrent.atomic.AtomicBoolean;
* {@code InMemoryNodeModel}. The reason for using an {@code
InMemoryNodeModelSupport} object rather than an
* {@code InMemoryNodeModel} directly is that this additional layer of
indirection can be used for performing special
* initializations on the model before it is returned to the {@code
TrackedNodeModel} object. This is needed by some
- * dynamic configuration implementations, e.g. by {@code
CombinedConfiguration}.
+ * dynamic configuration implementations, for example by {@code
CombinedConfiguration}.
* </p>
* <p>
* If the tracked node acting as root node is exclusively used by this model,
it should be released when this model is
diff --git
a/src/test/java/org/apache/commons/configuration2/TestSubnodeConfiguration.java
b/src/test/java/org/apache/commons/configuration2/TestSubnodeConfiguration.java
index 8eec56bd..d3a26e60 100644
---
a/src/test/java/org/apache/commons/configuration2/TestSubnodeConfiguration.java
+++
b/src/test/java/org/apache/commons/configuration2/TestSubnodeConfiguration.java
@@ -363,7 +363,7 @@ public class TestSubnodeConfiguration {
}
/**
- * Tests detaching a subnode configuration if an exception is thrown
during reconstruction. This can happen e.g. if the
+ * Tests detaching a subnode configuration if an exception is thrown
during reconstruction. This can happen for example if the
* expression engine is changed for the parent.
*/
@Test
diff --git
a/src/test/java/org/apache/commons/configuration2/tree/TestDefaultExpressionEngine.java
b/src/test/java/org/apache/commons/configuration2/tree/TestDefaultExpressionEngine.java
index f39b2049..aeb2e5e0 100644
---
a/src/test/java/org/apache/commons/configuration2/tree/TestDefaultExpressionEngine.java
+++
b/src/test/java/org/apache/commons/configuration2/tree/TestDefaultExpressionEngine.java
@@ -447,7 +447,7 @@ public class TestDefaultExpressionEngine {
}
/**
- * Tests using invalid keys, e.g. if something should be added to
attributes.
+ * Tests using invalid keys, for example if something should be added to
attributes.
*/
@Test
public void testPrepareAddInvalidKey() {
