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-logging.git
The following commit(s) were added to refs/heads/master by this push:
new 32c8bd6 Javadoc: Better wording
32c8bd6 is described below
commit 32c8bd625728624ca58e0470ad49e108033c99bb
Author: Gary Gregory <garydgreg...@gmail.com>
AuthorDate: Thu Oct 19 10:50:29 2023 -0400
Javadoc: Better wording
---
.../java/org/apache/commons/logging/LogFactory.java | 18 ++++++++++--------
.../org/apache/commons/logging/impl/SimpleLog.java | 3 ++-
.../apache/commons/logging/PathableClassLoader.java | 2 +-
.../commons/logging/security/MockSecurityManager.java | 2 +-
4 files changed, 14 insertions(+), 11 deletions(-)
diff --git a/src/main/java/org/apache/commons/logging/LogFactory.java
b/src/main/java/org/apache/commons/logging/LogFactory.java
index 0172741..84e68ab 100644
--- a/src/main/java/org/apache/commons/logging/LogFactory.java
+++ b/src/main/java/org/apache/commons/logging/LogFactory.java
@@ -407,7 +407,7 @@ public abstract class LogFactory {
* classLoader was unable to load factoryClass.
*
* In either case, we call Class.forName, which is equivalent
- * to LogFactory.class.getClassLoader().load(name), ie we ignore
+ * to LogFactory.class.getClassLoader().load(name), that is, we
ignore
* the classloader parameter the caller passed, and fall back
* to trying the classloader associated with this class. See the
* javadoc for the newFactory method for more info on the
@@ -576,7 +576,7 @@ public abstract class LogFactory {
* <p>
* Even when using an AccessController, however, this method can still
* throw SecurityException. Commons-logging basically relies on the
- * ability to access classloaders, ie a policy that forbids all
+ * ability to access classloaders. A policy that forbids all
* classloader access will also prevent commons-logging from working:
* currently this method will throw an exception preventing the entire app
* from starting up. Maybe it would be good to detect this situation and
@@ -1411,9 +1411,11 @@ public abstract class LogFactory {
/**
* Return a new instance of the specified {@code LogFactory}
implementation class, loaded by the specified class loader. If that fails, try
the class loader
* used to load this (abstract) LogFactory.
- * <p><b>ClassLoader conflicts</b></p>
* <p>
- * Note that there can be problems if the specified ClassLoader is not the
same as the classloader that loaded this class, ie when loading a concrete
+ * <b>ClassLoader conflicts</b>
+ * </p>
+ * <p>
+ * Note that there can be problems if the specified ClassLoader is not the
same as the classloader that loaded this class, that is, when loading a concrete
* LogFactory subclass via a context classloader.
* </p>
* <p>
@@ -1423,9 +1425,9 @@ public abstract class LogFactory {
* The problem occurs when code running in the context classloader calls
class X which was loaded via a parent classloader, and class X then calls
* LogFactory.getFactory (either directly or via LogFactory.getLog).
Because class X was loaded via the parent, it binds to LogFactory loaded via the
* parent. When the code in this method finds some LogFactoryYYYY class in
the child (context) classloader, and there also happens to be a LogFactory class
- * defined in the child classloader, then LogFactoryYYYY will be bound to
LogFactory@childloader. It cannot be cast to LogFactory@parentloader, ie this
- * method cannot return the object as the desired type. Note that it
doesn't matter if the LogFactory class in the child classloader is identical to
the
- * LogFactory class in the parent classloader, they are not compatible.
+ * defined in the child classloader, then LogFactoryYYYY will be bound to
LogFactory@childloader. It cannot be cast to LogFactory@parentloader, that is,
+ * this method cannot return the object as the desired type. Note that it
doesn't matter if the LogFactory class in the child classloader is identical to
+ * the LogFactory class in the parent classloader, they are not compatible.
* </p>
* <p>
* The solution taken here is to simply print out an error message when
this occurs then throw an exception. The deployer of the application must ensure
@@ -1468,7 +1470,7 @@ public abstract class LogFactory {
* Returns a string that uniquely identifies the specified object,
including
* its class.
* <p>
- * The returned string is of form "className@hashCode", ie is the same as
+ * The returned string is of form "className@hashCode", that is, is the
same as
* the return value of the Object.toString() method, but works even when
* the specified object's class has overridden the toString method.
* </p>
diff --git a/src/main/java/org/apache/commons/logging/impl/SimpleLog.java
b/src/main/java/org/apache/commons/logging/impl/SimpleLog.java
index d23d276..399ce5d 100644
--- a/src/main/java/org/apache/commons/logging/impl/SimpleLog.java
+++ b/src/main/java/org/apache/commons/logging/impl/SimpleLog.java
@@ -104,9 +104,10 @@ public class SimpleLog implements Log, Serializable {
* Used to format times.
* <p>
* Any code that accesses this object should first obtain a lock on it,
- * ie use synchronized(dateFormatter); this requirement was introduced
+ * that is, use synchronized(dateFormatter); this requirement was
introduced
* in 1.1.1 to fix an existing thread safety bug (SimpleDateFormat.format
* is not thread-safe).
+ * </p>
*/
static protected DateFormat dateFormatter;
diff --git a/src/test/java/org/apache/commons/logging/PathableClassLoader.java
b/src/test/java/org/apache/commons/logging/PathableClassLoader.java
index b145ec1..8356a08 100644
--- a/src/test/java/org/apache/commons/logging/PathableClassLoader.java
+++ b/src/test/java/org/apache/commons/logging/PathableClassLoader.java
@@ -74,7 +74,7 @@ public class PathableClassLoader extends URLClassLoader {
/**
* Constructor.
* <p>
- * Often, null is passed as the parent, ie the parent of the new
+ * Often, null is passed as the parent, that is, the parent of the new
* instance is the bootloader. This ensures that the classpath is
* totally clean; nothing but the standard java library will be
* present.
diff --git
a/src/test/java/org/apache/commons/logging/security/MockSecurityManager.java
b/src/test/java/org/apache/commons/logging/security/MockSecurityManager.java
index b68b08a..ad9a0e1 100644
--- a/src/test/java/org/apache/commons/logging/security/MockSecurityManager.java
+++ b/src/test/java/org/apache/commons/logging/security/MockSecurityManager.java
@@ -139,7 +139,7 @@ public class MockSecurityManager extends SecurityManager {
/**
* This returns the number of times that a check of a permission failed
* due to stack-walking tracing up into untrusted code. Any non-zero
- * value indicates a bug in JCL, ie a situation where code was not
+ * value indicates a bug in JCL, that is, a situation where code was not
* correctly wrapped in an AccessController block. The result of such a
* bug is that signing JCL is not sufficient to allow JCL to perform
* the operation; the caller would need to be signed too.
