/**
 * Used internally to parse an {@link ErrorHandler} element.
 */
private void parseErrorHandler(Element element, Appender appender) {
    ErrorHandler eh = (ErrorHandler) OptionConverter.instantiateByClassName(
            subst(element.getAttribute(CLASS_ATTR)),
            ErrorHandler.class,
            null);

    if (eh != null) {
        eh.setAppender(appender);

        PropertySetter propSetter = new PropertySetter(eh);
        forEachElement(element.getChildNodes(), (currentElement) -> {
            String tagName = currentElement.getTagName();
            if (tagName.equals(PARAM_TAG)) {
                setParameter(currentElement, propSetter);
            }
        });
        propSetter.activate();
        appender.setErrorHandler(eh);
    }
}
 

/**
 * Used internally to parse an {@link ErrorHandler} element.
 */
private void parseErrorHandler(Element element, Appender appender) {
    ErrorHandler eh = (ErrorHandler) OptionConverter.instantiateByClassName(
            subst(element.getAttribute(CLASS_ATTR)),
            ErrorHandler.class,
            null);

    if (eh != null) {
        eh.setAppender(appender);

        PropertySetter propSetter = new PropertySetter(eh);
        forEachElement(element.getChildNodes(), (currentElement) -> {
            String tagName = currentElement.getTagName();
            if (tagName.equals(PARAM_TAG)) {
                setParameter(currentElement, propSetter);
            }
        });
        propSetter.activate();
        appender.setErrorHandler(eh);
    }
}
 

/**
 * Constructor
 */
public FallbackAppender() {
    ErrorHandler fb = new FallbackErrorHandler();
    this.setErrorHandler(fb);
    fb.setAppender(this);
    Appender rootAppen = Logger.getRootLogger().getAppender("RootAppender");

    if (rootAppen != null) {
        fb.setBackupAppender(rootAppen);
    }

    Logger logger = Logger.getLogger(LoggingInvocationProcessor.class);
    fb.setLogger(logger);
}
 

/**
 * Constructor
 */
public FailbackAppender() {
    ErrorHandler fb = new FallbackErrorHandler();
    this.setErrorHandler(fb);
    fb.setAppender(this);
    Appender rootAppen = Logger.getRootLogger().getAppender("RootAppender");

    if (rootAppen != null) {
        fb.setBackupAppender(rootAppen);
    }

    Logger logger = Logger.getLogger(LoggingInvocationProcessor.class);
    fb.setLogger(logger);
}
 

public
void setErrorHandler(ErrorHandler eh) {
  if(eh == null) {
    // This is a programming error on the part of the enclosing appender.
    throw new IllegalArgumentException("Attempted to set null ErrorHandler.");
  } else { 
    this.errorHandler = eh;
  }
}
 

/** 
    Set the {@link ErrorHandler} for this Appender.
    @since 0.9.0
*/
public
synchronized
void setErrorHandler(ErrorHandler eh) {
  if(eh == null) {
    // We do not throw exception here since the cause is probably a
    // bad config file.
    LogLog.warn("You have tried to set a null error-handler.");
  } else {
    this.errorHandler = eh;
  }
}
 

/**
    Set the {@link ErrorHandler} for this WriterAppender and also the
    underlying {@link QuietWriter} if any. */
 public synchronized void setErrorHandler(ErrorHandler eh) {
   if(eh == null) {
     LogLog.warn("You have tried to set a null error-handler.");
   } else {
     this.errorHandler = eh;
     if(this.qw != null) {
this.qw.setErrorHandler(eh);
     }
   }
 }
 

/**
 * Constructor
 */
public FallbackAppender() {
    ErrorHandler fb = new FallbackErrorHandler();
    this.setErrorHandler(fb);
    fb.setAppender(this);
    Appender rootAppen = Logger.getRootLogger().getAppender("RootAppender");

    if (rootAppen != null) {
        fb.setBackupAppender(rootAppen);
    }

    Logger logger = Logger.getLogger(LoggingInvocationProcessor.class);
    fb.setLogger(logger);
}
 

/**
 * Constructor
 */
public FailbackAppender() {
    ErrorHandler fb = new FallbackErrorHandler();
    this.setErrorHandler(fb);
    fb.setAppender(this);
    Appender rootAppen = Logger.getRootLogger().getAppender("RootAppender");

    if (rootAppen != null) {
        fb.setBackupAppender(rootAppen);
    }

    Logger logger = Logger.getLogger(LoggingInvocationProcessor.class);
    fb.setLogger(logger);
}
 

public void setErrorHandler(ErrorHandler eh) {
    if (eh == null) {
        // This is a programming error on the part of the enclosing appender.
        throw new IllegalArgumentException("Attempted to set null ErrorHandler.");
    } else {
        this.errorHandler = eh;
    }
}
 

/**
 * Set the {@link ErrorHandler} for this Appender.
 *
 * @since 0.9.0
 */
@Override
public synchronized void setErrorHandler(final ErrorHandler eh) {
    if (eh != null) {
        this.errorHandler = eh;
    }
}
 

/**
 * Set the {@link ErrorHandler} for this WriterAppender and also the
 * underlying {@link QuietWriter} if any.
 */
public synchronized void setErrorHandler(ErrorHandler eh) {
    if (eh == null) {
        LOGGER.warn("You have tried to set a null error-handler.");
    } else {
        this.errorHandler = eh;
        if (this.qw != null) {
            this.qw.setErrorHandler(eh);
        }
    }
}
 

private Appender buildAppender(final String appenderName, final String className, final String prefix,
        final String layoutPrefix, final String filterPrefix, final Properties props) {
    Appender appender = newInstanceOf(className, "Appender");
    if (appender == null) {
        return null;
    }
    appender.setName(appenderName);
    appender.setLayout(parseLayout(layoutPrefix, appenderName, props));
    final String errorHandlerPrefix = prefix + ".errorhandler";
    String errorHandlerClass = OptionConverter.findAndSubst(errorHandlerPrefix, props);
    if (errorHandlerClass != null) {
        ErrorHandler eh = parseErrorHandler(props, errorHandlerPrefix, errorHandlerClass, appender);
        if (eh != null) {
            appender.setErrorHandler(eh);
        }
    }
    parseAppenderFilters(props, filterPrefix, appenderName);
    String[] keys = new String[] {
            layoutPrefix,
    };
    addProperties(appender, keys, props, prefix);
    if (appender instanceof AppenderWrapper) {
        addAppender(((AppenderWrapper) appender).getAppender());
    } else {
        addAppender(new AppenderAdapter(appender).getAdapter());
    }
    registry.put(appenderName, appender);
    return appender;
}
 

public ErrorHandler parseErrorHandler(final Properties props, final String errorHandlerPrefix,
        final String errorHandlerClass, final Appender appender) {
    ErrorHandler eh = newInstanceOf(errorHandlerClass, "ErrorHandler");
    final String[] keys = new String[] {
            errorHandlerPrefix + "." + ROOT_REF,
            errorHandlerPrefix + "." + LOGGER_REF,
            errorHandlerPrefix + "." + APPENDER_REF_TAG
    };
    addProperties(eh, keys, props, errorHandlerPrefix);
    return eh;
}
 

/**
 * Convert <code>val</code> a String parameter to an object of a
 * given type.
 * @param val The value to convert.
 * @param type The type of the value to convert to.
 * @return The result of the conversion.
 */
protected Object convertArg(String val, Class<?> type) {
    if (val == null) {
        return null;
    }

    String v = val.trim();
    if (String.class.isAssignableFrom(type)) {
        return val;
    } else if (Integer.TYPE.isAssignableFrom(type)) {
        return Integer.parseInt(v);
    } else if (Long.TYPE.isAssignableFrom(type)) {
        return Long.parseLong(v);
    } else if (Boolean.TYPE.isAssignableFrom(type)) {
        if ("true".equalsIgnoreCase(v)) {
            return Boolean.TRUE;
        } else if ("false".equalsIgnoreCase(v)) {
            return Boolean.FALSE;
        }
    } else if (Priority.class.isAssignableFrom(type)) {
        return org.apache.log4j.helpers.OptionConverter.toLevel(v, Level.DEBUG);
    } else if (ErrorHandler.class.isAssignableFrom(type)) {
        return OptionConverter.instantiateByClassName(v,
                ErrorHandler.class, null);
    }
    return null;
}
 

public void setErrorHandler(ErrorHandler eh) {
    if (eh == null) {
        // This is a programming error on the part of the enclosing appender.
        throw new IllegalArgumentException("Attempted to set null ErrorHandler.");
    } else {
        this.errorHandler = eh;
    }
}
 

/**
 * Set the {@link ErrorHandler} for this Appender.
 *
 * @since 0.9.0
 */
@Override
public synchronized void setErrorHandler(final ErrorHandler eh) {
    if (eh != null) {
        this.errorHandler = eh;
    }
}
 

/**
 * Set the {@link ErrorHandler} for this WriterAppender and also the
 * underlying {@link QuietWriter} if any.
 */
public synchronized void setErrorHandler(ErrorHandler eh) {
    if (eh == null) {
        LOGGER.warn("You have tried to set a null error-handler.");
    } else {
        this.errorHandler = eh;
        if (this.qw != null) {
            this.qw.setErrorHandler(eh);
        }
    }
}
 

/**
 * Convert <code>val</code> a String parameter to an object of a
 * given type.
 */
protected Object convertArg(String val, Class type) {
    if (val == null) {
        return null;
    }

    String v = val.trim();
    if (String.class.isAssignableFrom(type)) {
        return val;
    } else if (Integer.TYPE.isAssignableFrom(type)) {
        return Integer.parseInt(v);
    } else if (Long.TYPE.isAssignableFrom(type)) {
        return Long.parseLong(v);
    } else if (Boolean.TYPE.isAssignableFrom(type)) {
        if ("true".equalsIgnoreCase(v)) {
            return Boolean.TRUE;
        } else if ("false".equalsIgnoreCase(v)) {
            return Boolean.FALSE;
        }
    } else if (Priority.class.isAssignableFrom(type)) {
        return org.apache.log4j.helpers.OptionConverter.toLevel(v, Level.DEBUG);
    } else if (ErrorHandler.class.isAssignableFrom(type)) {
        return OptionConverter.instantiateByClassName(v,
                ErrorHandler.class, null);
    }
    return null;
}
 

public ErrorHandler getErrorHandler()
{
    return null;
}
 

public void setErrorHandler(ErrorHandler errorHandler)
{
}
 

@Override
public ErrorHandler getErrorHandler() {
    return null;
}
 

public
QuietWriter(Writer writer, ErrorHandler errorHandler) {
  super(writer);
  setErrorHandler(errorHandler);
}
 

public
SyslogQuietWriter(Writer writer, int syslogFacility, ErrorHandler eh) {
  super(writer, eh);
  this.syslogFacility = syslogFacility;
}
 

public
CountingQuietWriter(Writer writer, ErrorHandler eh) {
  super(writer, eh);
}
 

/**
    Used internally to parse an {@link ErrorHandler} element.
  */
 protected
 void parseErrorHandler(Element element, Appender appender) {
   ErrorHandler eh = (ErrorHandler) OptionConverter.instantiateByClassName(
                                      subst(element.getAttribute(CLASS_ATTR)),
                                      org.apache.log4j.spi.ErrorHandler.class, 
				       null);
   
   if(eh != null) {
     eh.setAppender(appender);

     PropertySetter propSetter = new PropertySetter(eh);
     NodeList children = element.getChildNodes();
     final int length 	= children.getLength();

     for (int loop = 0; loop < length; loop++) {
Node currentNode = children.item(loop);
if (currentNode.getNodeType() == Node.ELEMENT_NODE) {
  Element currentElement = (Element) currentNode;
  String tagName = currentElement.getTagName();
  if(tagName.equals(PARAM_TAG)) {
           setParameter(currentElement, propSetter);
  } else if(tagName.equals(APPENDER_REF_TAG)) {
    eh.setBackupAppender(findAppenderByReference(currentElement));
  } else if(tagName.equals(LOGGER_REF)) {
    String loggerName = currentElement.getAttribute(REF_ATTR);	    
    Logger logger = (catFactory == null) ? repository.getLogger(loggerName)
               : repository.getLogger(loggerName, catFactory);
    eh.setLogger(logger);
  } else if(tagName.equals(ROOT_REF)) {
    Logger root = repository.getRootLogger();
    eh.setLogger(root);
  } else {
         quietParseUnrecognizedElement(eh, currentElement, props);
     }
}
     }
     propSetter.activate();
     appender.setErrorHandler(eh);
   }
 }
 

public ErrorHandler getErrorHandler() {
  return null;
}
 

public ErrorHandler getErrorHandler()
{
	return m_other.getErrorHandler();
}
 

public void setErrorHandler(ErrorHandler arg0)
{
	m_other.setErrorHandler(arg0);
}
 

@Override
public ErrorHandler getErrorHandler() {
   return null;
}