o parameter. This is accomplished by calling the
+ {@link #get(Class)} method. Once a renderer is found, it is
+ applied on the object o and the result is returned
+ as a {@link String}. */
+ public
+ String findAndRender(Object o) {
+ if(o == null) {
+ return null;
+ } else {
+ return get(o.getClass()).doRender(o);
+ }
+ }
+
+
+ /**
+ Syntactic sugar method that calls {@link #get(Class)} with the
+ class of the object parameter. */
+ public
+ ObjectRenderer get(Object o) {
+ if(o == null) {
+ return null;
+ } else {
+ return get(o.getClass());
+ }
+ }
+
+
+ /**
+ Search the parents of clazz for a renderer. The
+ renderer closest in the hierarchy will be returned. If no
+ renderers could be found, then the default renderer is returned.
+
+ The search first looks for a renderer configured for
+ clazz. If a renderer could not be found, then the
+ search continues by looking at all the interfaces implemented by
+ clazz including the super-interfaces of each
+ interface. If a renderer cannot be found, then the search looks
+ for a renderer defined for the parent (superclass) of
+ clazz. If that fails, then all the interfaces
+ implemented by the parent of clazz are searched and
+ so on.
+
+
For example, if A0, A1, A2 are classes and X0, X1, X2, Y0, Y1 + are interfaces where A2 extends A1 which in turn extends A0 and + similarly X2 extends X1 which extends X0 and Y1 extends Y0. Let + us also assume that A1 implements the Y0 interface and that A2 + implements the X2 interface. + +
The table below shows the results returned by the
+ get(A2.class) method depending on the renderers
+ added to the map.
+
+
| Added renderers | Value returned by get(A2.class) |
+
+
|---|---|
A0Renderer
+ | A0Renderer
+
+ |
A0Renderer, A1Renderer
+ | A1Renderer
+
+ |
X0Renderer
+ | X0Renderer
+
+ |
A1Renderer, X0Renderer
+ | X0Renderer
+
+ |
This search algorithm is not the most natural, although it is
+ particularly easy to implement. Future log4j versions
+ may implement a more intuitive search
+ algorithm. However, the present algorithm should be acceptable in
+ the vast majority of circumstances.
+
+ */
+ public
+ ObjectRenderer get(Class clazz) {
+ //System.out.println("\nget: "+clazz);
+ ObjectRenderer r = null;
+ for(Class c = clazz; c != null; c = c.getSuperclass()) {
+ //System.out.println("Searching for class: "+c);
+ r = (ObjectRenderer) map.get(c);
+ if(r != null) {
+ return r;
+ }
+ r = searchInterfaces(c);
+ if(r != null) {
+ return r;
+ }
+ }
+ return defaultRenderer;
+ }
+
+ ObjectRenderer searchInterfaces(Class c) {
+ //System.out.println("Searching interfaces of class: "+c);
+
+ ObjectRenderer r = (ObjectRenderer) map.get(c);
+ if(r != null) {
+ return r;
+ } else {
+ Class[] ia = c.getInterfaces();
+ for(int i = 0; i < ia.length; i++) {
+ r = searchInterfaces(ia[i]);
+ if(r != null) {
+ return r;
+ }
+ }
+ }
+ return null;
+ }
+
+
+ public
+ ObjectRenderer getDefaultRenderer() {
+ return defaultRenderer;
+ }
+
+
+ public
+ void clear() {
+ map.clear();
+ }
+
+ /**
+ Register an {@link ObjectRenderer} for clazz.
+ */
+ public
+ void put(Class clazz, ObjectRenderer or) {
+ map.put(clazz, or);
+ }
+}