16:52:51.496 INFO  jd.cli.Main - Decompiling slf4j-api-1.5.2.jar
package org.slf4j.helpers;

import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
import org.slf4j.Marker;

public class BasicMarker
  implements Marker
{
  private static final long serialVersionUID = 1803952589649545191L;
  private final String name;
  private List children;
  
  BasicMarker(String name)
  {
    if (name == null) {
      throw new IllegalArgumentException("A merker name cannot be null");
    }
    this.name = name;
  }
  
  public String getName()
  {
    return name;
  }
  
  public synchronized void add(Marker markerToAddAsChild)
  {
    if (markerToAddAsChild == null) {
      throw new IllegalArgumentException("A null value cannot be added to a Marker as child.");
    }
    if (contains(markerToAddAsChild)) {
      return;
    }
    if (markerToAddAsChild.contains(this)) {
      return;
    }
    if (children == null) {
      children = new Vector();
    }
    children.add(markerToAddAsChild);
  }
  
  public synchronized boolean hasChildren()
  {
    return (children != null) && (children.size() > 0);
  }
  
  public synchronized Iterator iterator()
  {
    if (children != null) {
      return children.iterator();
    }
    return Collections.EMPTY_LIST.iterator();
  }
  
  public synchronized boolean remove(Marker markerToRemove)
  {
    if (children == null) {
      return false;
    }
    int size = children.size();
    for (int i = 0; i < size; i++)
    {
      Marker m = (Marker)children.get(i);
      if (m == markerToRemove)
      {
        children.remove(i);
        return true;
      }
    }
    return false;
  }
  
  public boolean contains(Marker other)
  {
    if (other == null) {
      throw new IllegalArgumentException("Other cannot be null");
    }
    if (this == other) {
      return true;
    }
    if (hasChildren()) {
      for (int i = 0; i < children.size(); i++)
      {
        Marker child = (Marker)children.get(i);
        if (child.contains(other)) {
          return true;
        }
      }
    }
    return false;
  }
  
  public boolean contains(String name)
  {
    if (name == null) {
      throw new IllegalArgumentException("Other cannot be null");
    }
    if (this.name.equals(name)) {
      return true;
    }
    if (hasChildren()) {
      for (int i = 0; i < children.size(); i++)
      {
        Marker child = (Marker)children.get(i);
        if (child.contains(name)) {
          return true;
        }
      }
    }
    return false;
  }
  
  private static String OPEN = "[ ";
  private static String CLOSE = " ]";
  private static String SEP = ", ";
  
  public boolean equals(Object obj)
  {
    if (this == obj) {
      return true;
    }
    if (obj == null) {
      return false;
    }
    if (!(obj instanceof Marker)) {
      return false;
    }
    Marker other = (Marker)obj;
    return name.equals(other.getName());
  }
  
  public int hashCode()
  {
    return name.hashCode();
  }
  
  public String toString()
  {
    if (!hasChildren()) {
      return getName();
    }
    Iterator it = iterator();
    
    StringBuffer sb = new StringBuffer(getName());
    sb.append(' ').append(OPEN);
    while (it.hasNext())
    {
      Marker child = (Marker)it.next();
      sb.append(child.getName());
      if (it.hasNext()) {
        sb.append(SEP);
      }
    }
    sb.append(CLOSE);
    
    return sb.toString();
  }
}

/* Location:
 * Qualified Name:     org.slf4j.helpers.BasicMarker
 * Java Class Version: 1.3 (47.0)
 * JD-Core Version:    0.7.1
 */
package org.slf4j.helpers;

import java.util.HashMap;
import java.util.Map;
import org.slf4j.IMarkerFactory;
import org.slf4j.Marker;

public class BasicMarkerFactory
  implements IMarkerFactory
{
  Map markerMap = new HashMap();
  
  public synchronized Marker getMarker(String name)
  {
    if (name == null) {
      throw new IllegalArgumentException("Marker name cannot be null");
    }
    Marker marker = (Marker)markerMap.get(name);
    if (marker == null)
    {
      marker = new BasicMarker(name);
      markerMap.put(name, marker);
    }
    return marker;
  }
  
  public synchronized boolean exists(String name)
  {
    if (name == null) {
      return false;
    }
    return markerMap.containsKey(name);
  }
  
  public boolean detachMarker(String name)
  {
    if (name == null) {
      return false;
    }
    return markerMap.remove(name) != null;
  }
  
  public Marker getDetachedMarker(String name)
  {
    return new BasicMarker(name);
  }
}

/* Location:
 * Qualified Name:     org.slf4j.helpers.BasicMarkerFactory
 * Java Class Version: 1.3 (47.0)
 * JD-Core Version:    0.7.1
 */
package org.slf4j.helpers;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import org.slf4j.spi.MDCAdapter;

public class BasicMDCAdapter
  implements MDCAdapter
{
  private InheritableThreadLocal inheritableThreadLocal = new InheritableThreadLocal();
  
  public void put(String key, String val)
  {
    if (key == null) {
      throw new IllegalArgumentException("key cannot be null");
    }
    HashMap map = (HashMap)inheritableThreadLocal.get();
    if (map == null)
    {
      map = new HashMap();
      inheritableThreadLocal.set(map);
    }
    map.put(key, val);
  }
  
  public String get(String key)
  {
    HashMap hashMap = (HashMap)inheritableThreadLocal.get();
    if ((hashMap != null) && (key != null)) {
      return (String)hashMap.get(key);
    }
    return null;
  }
  
  public void remove(String key)
  {
    HashMap map = (HashMap)inheritableThreadLocal.get();
    if (map != null) {
      map.remove(key);
    }
  }
  
  public void clear()
  {
    HashMap hashMap = (HashMap)inheritableThreadLocal.get();
    if (hashMap != null)
    {
      hashMap.clear();
      inheritableThreadLocal.remove();
    }
  }
  
  public Set getKeys()
  {
    HashMap hashMap = (HashMap)inheritableThreadLocal.get();
    if (hashMap != null) {
      return hashMap.keySet();
    }
    return null;
  }
  
  public Map getCopyOfContextMap()
  {
    HashMap hashMap = (HashMap)inheritableThreadLocal.get();
    if (hashMap != null) {
      return new HashMap(hashMap);
    }
    return null;
  }
  
  public void setContextMap(Map contextMap)
  {
    HashMap hashMap = (HashMap)inheritableThreadLocal.get();
    if (hashMap != null)
    {
      hashMap.clear();
      hashMap.putAll(contextMap);
    }
    else
    {
      hashMap = new HashMap(contextMap);
      inheritableThreadLocal.set(hashMap);
    }
  }
}

/* Location:
 * Qualified Name:     org.slf4j.helpers.BasicMDCAdapter
 * Java Class Version: 1.3 (47.0)
 * JD-Core Version:    0.7.1
 */
package org.slf4j.helpers;

import org.slf4j.Logger;
import org.slf4j.Marker;

public abstract class MarkerIgnoringBase
  implements Logger
{
  public boolean isTraceEnabled(Marker marker)
  {
    return isTraceEnabled();
  }
  
  public void trace(Marker marker, String msg)
  {
    trace(msg);
  }
  
  public void trace(Marker marker, String format, Object arg)
  {
    trace(format, arg);
  }
  
  public void trace(Marker marker, String format, Object arg1, Object arg2)
  {
    trace(format, arg1, arg2);
  }
  
  public void trace(Marker marker, String format, Object[] argArray)
  {
    trace(format, argArray);
  }
  
  public void trace(Marker marker, String msg, Throwable t)
  {
    trace(msg, t);
  }
  
  public boolean isDebugEnabled(Marker marker)
  {
    return isDebugEnabled();
  }
  
  public void debug(Marker marker, String msg)
  {
    debug(msg);
  }
  
  public void debug(Marker marker, String format, Object arg)
  {
    debug(format, arg);
  }
  
  public void debug(Marker marker, String format, Object arg1, Object arg2)
  {
    debug(format, arg1, arg2);
  }
  
  public void debug(Marker marker, String format, Object[] argArray)
  {
    debug(format, argArray);
  }
  
  public void debug(Marker marker, String msg, Throwable t)
  {
    debug(msg, t);
  }
  
  public boolean isInfoEnabled(Marker marker)
  {
    return isInfoEnabled();
  }
  
  public void info(Marker marker, String msg)
  {
    info(msg);
  }
  
  public void info(Marker marker, String format, Object arg)
  {
    info(format, arg);
  }
  
  public void info(Marker marker, String format, Object arg1, Object arg2)
  {
    info(format, arg1, arg2);
  }
  
  public void info(Marker marker, String format, Object[] argArray)
  {
    info(format, argArray);
  }
  
  public void info(Marker marker, String msg, Throwable t)
  {
    info(msg, t);
  }
  
  public boolean isWarnEnabled(Marker marker)
  {
    return isWarnEnabled();
  }
  
  public void warn(Marker marker, String msg)
  {
    warn(msg);
  }
  
  public void warn(Marker marker, String format, Object arg)
  {
    warn(format, arg);
  }
  
  public void warn(Marker marker, String format, Object arg1, Object arg2)
  {
    warn(format, arg1, arg2);
  }
  
  public void warn(Marker marker, String format, Object[] argArray)
  {
    warn(format, argArray);
  }
  
  public void warn(Marker marker, String msg, Throwable t)
  {
    warn(msg, t);
  }
  
  public boolean isErrorEnabled(Marker marker)
  {
    return isErrorEnabled();
  }
  
  public void error(Marker marker, String msg)
  {
    error(msg);
  }
  
  public void error(Marker marker, String format, Object arg)
  {
    error(format, arg);
  }
  
  public void error(Marker marker, String format, Object arg1, Object arg2)
  {
    error(format, arg1, arg2);
  }
  
  public void error(Marker marker, String format, Object[] argArray)
  {
    error(format, argArray);
  }
  
  public void error(Marker marker, String msg, Throwable t)
  {
    error(msg, t);
  }
  
  public String toString()
  {
    return getClass().getName() + "(" + getName() + ")";
  }
}

/* Location:
 * Qualified Name:     org.slf4j.helpers.MarkerIgnoringBase
 * Java Class Version: 1.3 (47.0)
 * JD-Core Version:    0.7.1
 */
package org.slf4j.helpers;

public class MessageFormatter
{
  static final char DELIM_START = '{';
  static final char DELIM_STOP = '}';
  private static final char ESCAPE_CHAR = '\\';
  
  public static String format(String messagePattern, Object arg)
  {
    return arrayFormat(messagePattern, new Object[] { arg });
  }
  
  public static String format(String messagePattern, Object arg1, Object arg2)
  {
    return arrayFormat(messagePattern, new Object[] { arg1, arg2 });
  }
  
  public static String arrayFormat(String messagePattern, Object[] argArray)
  {
    if (messagePattern == null) {
      return null;
    }
    int i = 0;
    int len = messagePattern.length();
    int j = messagePattern.indexOf('{');
    if (argArray == null) {
      return messagePattern;
    }
    StringBuffer sbuf = new StringBuffer(messagePattern.length() + 50);
    for (int L = 0; L < argArray.length; L++)
    {
      j = messagePattern.indexOf('{', i);
      if ((j == -1) || (j + 1 == len))
      {
        if (i == 0) {
          return messagePattern;
        }
        sbuf.append(messagePattern.substring(i, messagePattern.length()));
        return sbuf.toString();
      }
      char delimStop = messagePattern.charAt(j + 1);
      if (isEscapedDelimeter(messagePattern, j))
      {
        if (!isDoubleEscaped(messagePattern, j))
        {
          L--;
          sbuf.append(messagePattern.substring(i, j - 1));
          sbuf.append('{');
          i = j + 1;
        }
        else
        {
          sbuf.append(messagePattern.substring(i, j - 1));
          sbuf.append(argArray[L]);
          i = j + 2;
        }
      }
      else
      {
        if (delimStop != '}')
        {
          sbuf.append(messagePattern.substring(i, messagePattern.length()));
          return sbuf.toString();
        }
        sbuf.append(messagePattern.substring(i, j));
        sbuf.append(argArray[L]);
        i = j + 2;
      }
    }
    sbuf.append(messagePattern.substring(i, messagePattern.length()));
    return sbuf.toString();
  }
  
  static boolean isEscapedDelimeter(String messagePattern, int delimeterStartIndex)
  {
    if (delimeterStartIndex == 0) {
      return false;
    }
    char potentialEscape = messagePattern.charAt(delimeterStartIndex - 1);
    if (potentialEscape == '\\') {
      return true;
    }
    return false;
  }
  
  static boolean isDoubleEscaped(String messagePattern, int delimeterStartIndex)
  {
    if ((delimeterStartIndex >= 2) && (messagePattern.charAt(delimeterStartIndex - 2) == '\\')) {
      return true;
    }
    return false;
  }
}

/* Location:
 * Qualified Name:     org.slf4j.helpers.MessageFormatter
 * Java Class Version: 1.3 (47.0)
 * JD-Core Version:    0.7.1
 */
package org.slf4j.helpers;

import java.util.Map;
import org.slf4j.spi.MDCAdapter;

public class NOPMakerAdapter
  implements MDCAdapter
{
  public void clear() {}
  
  public String get(String key)
  {
    return null;
  }
  
  public void put(String key, String val) {}
  
  public void remove(String key) {}
  
  public Map getCopyOfContextMap()
  {
    return null;
  }
  
  public void setContextMap(Map contextMap) {}
}

/* Location:
 * Qualified Name:     org.slf4j.helpers.NOPMakerAdapter
 * Java Class Version: 1.3 (47.0)
 * JD-Core Version:    0.7.1
 */
package org.slf4j.helpers;

import java.io.PrintStream;

public class Util
{
  public static final void reportFailure(String msg, Throwable t)
  {
    System.err.println(msg);
    System.err.println("Reported exception:");
    t.printStackTrace();
  }
  
  public static final void reportFailure(String msg)
  {
    System.err.println("SLF4J: " + msg);
  }
}

/* Location:
 * Qualified Name:     org.slf4j.helpers.Util
 * Java Class Version: 1.3 (47.0)
 * JD-Core Version:    0.7.1
 */
package org.slf4j;

public abstract interface ILoggerFactory
{
  public abstract Logger getLogger(String paramString);
}

/* Location:
 * Qualified Name:     org.slf4j.ILoggerFactory
 * Java Class Version: 1.3 (47.0)
 * JD-Core Version:    0.7.1
 */
package org.slf4j;

public abstract interface IMarkerFactory
{
  public abstract Marker getMarker(String paramString);
  
  public abstract boolean exists(String paramString);
  
  public abstract boolean detachMarker(String paramString);
  
  public abstract Marker getDetachedMarker(String paramString);
}

/* Location:
 * Qualified Name:     org.slf4j.IMarkerFactory
 * Java Class Version: 1.3 (47.0)
 * JD-Core Version:    0.7.1
 */
package org.slf4j;

public abstract interface Logger
{
  public static final String ROOT_LOGGER_NAME = "ROOT";
  
  public abstract String getName();
  
  public abstract boolean isTraceEnabled();
  
  public abstract void trace(String paramString);
  
  public abstract void trace(String paramString, Object paramObject);
  
  public abstract void trace(String paramString, Object paramObject1, Object paramObject2);
  
  public abstract void trace(String paramString, Object[] paramArrayOfObject);
  
  public abstract void trace(String paramString, Throwable paramThrowable);
  
  public abstract boolean isTraceEnabled(Marker paramMarker);
  
  public abstract void trace(Marker paramMarker, String paramString);
  
  public abstract void trace(Marker paramMarker, String paramString, Object paramObject);
  
  public abstract void trace(Marker paramMarker, String paramString, Object paramObject1, Object paramObject2);
  
  public abstract void trace(Marker paramMarker, String paramString, Object[] paramArrayOfObject);
  
  public abstract void trace(Marker paramMarker, String paramString, Throwable paramThrowable);
  
  public abstract boolean isDebugEnabled();
  
  public abstract void debug(String paramString);
  
  public abstract void debug(String paramString, Object paramObject);
  
  public abstract void debug(String paramString, Object paramObject1, Object paramObject2);
  
  public abstract void debug(String paramString, Object[] paramArrayOfObject);
  
  public abstract void debug(String paramString, Throwable paramThrowable);
  
  public abstract boolean isDebugEnabled(Marker paramMarker);
  
  public abstract void debug(Marker paramMarker, String paramString);
  
  public abstract void debug(Marker paramMarker, String paramString, Object paramObject);
  
  public abstract void debug(Marker paramMarker, String paramString, Object paramObject1, Object paramObject2);
  
  public abstract void debug(Marker paramMarker, String paramString, Object[] paramArrayOfObject);
  
  public abstract void debug(Marker paramMarker, String paramString, Throwable paramThrowable);
  
  public abstract boolean isInfoEnabled();
  
  public abstract void info(String paramString);
  
  public abstract void info(String paramString, Object paramObject);
  
  public abstract void info(String paramString, Object paramObject1, Object paramObject2);
  
  public abstract void info(String paramString, Object[] paramArrayOfObject);
  
  public abstract void info(String paramString, Throwable paramThrowable);
  
  public abstract boolean isInfoEnabled(Marker paramMarker);
  
  public abstract void info(Marker paramMarker, String paramString);
  
  public abstract void info(Marker paramMarker, String paramString, Object paramObject);
  
  public abstract void info(Marker paramMarker, String paramString, Object paramObject1, Object paramObject2);
  
  public abstract void info(Marker paramMarker, String paramString, Object[] paramArrayOfObject);
  
  public abstract void info(Marker paramMarker, String paramString, Throwable paramThrowable);
  
  public abstract boolean isWarnEnabled();
  
  public abstract void warn(String paramString);
  
  public abstract void warn(String paramString, Object paramObject);
  
  public abstract void warn(String paramString, Object[] paramArrayOfObject);
  
  public abstract void warn(String paramString, Object paramObject1, Object paramObject2);
  
  public abstract void warn(String paramString, Throwable paramThrowable);
  
  public abstract boolean isWarnEnabled(Marker paramMarker);
  
  public abstract void warn(Marker paramMarker, String paramString);
  
  public abstract void warn(Marker paramMarker, String paramString, Object paramObject);
  
  public abstract void warn(Marker paramMarker, String paramString, Object paramObject1, Object paramObject2);
  
  public abstract void warn(Marker paramMarker, String paramString, Object[] paramArrayOfObject);
  
  public abstract void warn(Marker paramMarker, String paramString, Throwable paramThrowable);
  
  public abstract boolean isErrorEnabled();
  
  public abstract void error(String paramString);
  
  public abstract void error(String paramString, Object paramObject);
  
  public abstract void error(String paramString, Object paramObject1, Object paramObject2);
  
  public abstract void error(String paramString, Object[] paramArrayOfObject);
  
  public abstract void error(String paramString, Throwable paramThrowable);
  
  public abstract boolean isErrorEnabled(Marker paramMarker);
  
  public abstract void error(Marker paramMarker, String paramString);
  
  public abstract void error(Marker paramMarker, String paramString, Object paramObject);
  
  public abstract void error(Marker paramMarker, String paramString, Object paramObject1, Object paramObject2);
  
  public abstract void error(Marker paramMarker, String paramString, Object[] paramArrayOfObject);
  
  public abstract void error(Marker paramMarker, String paramString, Throwable paramThrowable);
}

/* Location:
 * Qualified Name:     org.slf4j.Logger
 * Java Class Version: 1.3 (47.0)
 * JD-Core Version:    0.7.1
 */
package org.slf4j;

import org.slf4j.helpers.Util;
import org.slf4j.impl.StaticLoggerBinder;

public final class LoggerFactory
{
  static ILoggerFactory loggerFactory;
  static final String NO_STATICLOGGERBINDER_URL = "http://www.slf4j.org/codes.html#StaticLoggerBinder";
  static final String NULL_LF_URL = "http://www.slf4j.org/codes.html#null_LF";
  
  static
  {
    try
    {
      loggerFactory = StaticLoggerBinder.SINGLETON.getLoggerFactory();
    }
    catch (NoClassDefFoundError ncde)
    {
      String msg = ncde.getMessage();
      if ((msg != null) && (msg.indexOf("org/slf4j/impl/StaticLoggerBinder") != -1))
      {
        Util.reportFailure("Failed to load class \"org.slf4j.impl.StaticLoggerBinder\".");
        Util.reportFailure("See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.");
      }
      throw ncde;
    }
    catch (Exception e)
    {
      Util.reportFailure("Failed to instantiate logger [" + StaticLoggerBinder.SINGLETON.getLoggerFactoryClassStr() + "]", e);
    }
  }
  
  public static Logger getLogger(String name)
  {
    if (loggerFactory == null) {
      throw new IllegalStateException("Logging factory implementation cannot be null. See also http://www.slf4j.org/codes.html#null_LF");
    }
    return loggerFactory.getLogger(name);
  }
  
  public static Logger getLogger(Class clazz)
  {
    if (loggerFactory == null) {
      throw new IllegalStateException("Logging factory implementation cannot be null. See also http://www.slf4j.org/codes.html#null_LF");
    }
    return loggerFactory.getLogger(clazz.getName());
  }
  
  public static ILoggerFactory getILoggerFactory()
  {
    return loggerFactory;
  }
}

/* Location:
 * Qualified Name:     org.slf4j.LoggerFactory
 * Java Class Version: 1.3 (47.0)
 * JD-Core Version:    0.7.1
 */
package org.slf4j;

import java.io.Serializable;
import java.util.Iterator;

public abstract interface Marker
  extends Serializable
{
  public static final String ANY_MARKER = "*";
  public static final String ANY_NON_NULL_MARKER = "+";
  
  public abstract String getName();
  
  public abstract void add(Marker paramMarker);
  
  public abstract boolean remove(Marker paramMarker);
  
  public abstract boolean hasChildren();
  
  public abstract Iterator iterator();
  
  public abstract boolean contains(Marker paramMarker);
  
  public abstract boolean contains(String paramString);
  
  public abstract boolean equals(Object paramObject);
  
  public abstract int hashCode();
}

/* Location:
 * Qualified Name:     org.slf4j.Marker
 * Java Class Version: 1.3 (47.0)
 * JD-Core Version:    0.7.1
 */
package org.slf4j;

import org.slf4j.helpers.Util;
import org.slf4j.impl.StaticMarkerBinder;

public class MarkerFactory
{
  static IMarkerFactory markerFactory;
  
  static
  {
    try
    {
      markerFactory = StaticMarkerBinder.SINGLETON.getMarkerFactory();
    }
    catch (Exception e)
    {
      Util.reportFailure("Could not instantiate instance of class [" + StaticMarkerBinder.SINGLETON.getMarkerFactoryClassStr() + "]", e);
    }
  }
  
  public static Marker getMarker(String name)
  {
    return markerFactory.getMarker(name);
  }
  
  public static Marker getDetachedMarker(String name)
  {
    return markerFactory.getDetachedMarker(name);
  }
  
  public static IMarkerFactory getIMarkerFactory()
  {
    return markerFactory;
  }
}

/* Location:
 * Qualified Name:     org.slf4j.MarkerFactory
 * Java Class Version: 1.3 (47.0)
 * JD-Core Version:    0.7.1
 */
package org.slf4j;

import java.util.Map;
import org.slf4j.helpers.Util;
import org.slf4j.impl.StaticMDCBinder;
import org.slf4j.spi.MDCAdapter;

public class MDC
{
  static final String NULL_MDCA_URL = "http://www.slf4j.org/codes.html#null_MDCA";
  static final String NO_STATIC_MDC_BINDER_URL = "http://www.slf4j.org/codes.html#no_static_mdc_binder";
  static MDCAdapter mdcAdapter;
  
  static
  {
    try
    {
      mdcAdapter = StaticMDCBinder.SINGLETON.getMDCA();
    }
    catch (NoClassDefFoundError ncde)
    {
      String msg = ncde.getMessage();
      if ((msg != null) && (msg.indexOf("org/slf4j/impl/StaticMDCBinder") != -1))
      {
        Util.reportFailure("Failed to load class \"org.slf4j.impl.StaticMDCBinder\".");
        
        Util.reportFailure("See http://www.slf4j.org/codes.html#no_static_mdc_binder for further details.");
      }
      throw ncde;
    }
    catch (Exception e)
    {
      Util.reportFailure("Could not bind with an instance of class [" + StaticMDCBinder.SINGLETON.getMDCAdapterClassStr() + "]", e);
    }
  }
  
  public static void put(String key, String val)
    throws IllegalArgumentException
  {
    if (key == null) {
      throw new IllegalArgumentException("key parameter cannot be null");
    }
    if (mdcAdapter == null) {
      throw new IllegalStateException("MDCAdapter cannot be null. See also http://www.slf4j.org/codes.html#null_MDCA");
    }
    mdcAdapter.put(key, val);
  }
  
  public static String get(String key)
    throws IllegalArgumentException
  {
    if (key == null) {
      throw new IllegalArgumentException("key parameter cannot be null");
    }
    if (mdcAdapter == null) {
      throw new IllegalStateException("MDCAdapter cannot be null. See also http://www.slf4j.org/codes.html#null_MDCA");
    }
    return mdcAdapter.get(key);
  }
  
  public static void remove(String key)
    throws IllegalArgumentException
  {
    if (key == null) {
      throw new IllegalArgumentException("key parameter cannot be null");
    }
    if (mdcAdapter == null) {
      throw new IllegalStateException("MDCAdapter cannot be null. See also http://www.slf4j.org/codes.html#null_MDCA");
    }
    mdcAdapter.remove(key);
  }
  
  public static void clear()
  {
    if (mdcAdapter == null) {
      throw new IllegalStateException("MDCAdapter cannot be null. See also http://www.slf4j.org/codes.html#null_MDCA");
    }
    mdcAdapter.clear();
  }
  
  public static Map getCopyOfContextMap()
  {
    if (mdcAdapter == null) {
      throw new IllegalStateException("MDCAdapter cannot be null. See also http://www.slf4j.org/codes.html#null_MDCA");
    }
    return mdcAdapter.getCopyOfContextMap();
  }
  
  public static void setContextMap(Map contextMap)
  {
    if (mdcAdapter == null) {
      throw new IllegalStateException("MDCAdapter cannot be null. See also http://www.slf4j.org/codes.html#null_MDCA");
    }
    mdcAdapter.setContextMap(contextMap);
  }
  
  public static MDCAdapter getMDCAdapter()
  {
    return mdcAdapter;
  }
}

/* Location:
 * Qualified Name:     org.slf4j.MDC
 * Java Class Version: 1.3 (47.0)
 * JD-Core Version:    0.7.1
 */
package org.slf4j.spi;

import org.slf4j.Logger;
import org.slf4j.Marker;

public abstract interface LocationAwareLogger
  extends Logger
{
  public static final int TRACE_INT = 0;
  public static final int DEBUG_INT = 10;
  public static final int INFO_INT = 20;
  public static final int WARN_INT = 30;
  public static final int ERROR_INT = 40;
  
  public abstract void log(Marker paramMarker, String paramString1, int paramInt, String paramString2, Throwable paramThrowable);
}

/* Location:
 * Qualified Name:     org.slf4j.spi.LocationAwareLogger
 * Java Class Version: 1.3 (47.0)
 * JD-Core Version:    0.7.1
 */
package org.slf4j.spi;

import org.slf4j.ILoggerFactory;

public abstract interface LoggerFactoryBinder
{
  public abstract ILoggerFactory getLoggerFactory();
  
  public abstract String getLoggerFactoryClassStr();
}

/* Location:
 * Qualified Name:     org.slf4j.spi.LoggerFactoryBinder
 * Java Class Version: 1.3 (47.0)
 * JD-Core Version:    0.7.1
 */
package org.slf4j.spi;

import org.slf4j.IMarkerFactory;

public abstract interface MarkerFactoryBinder
{
  public abstract IMarkerFactory getMarkerFactory();
  
  public abstract String getMarkerFactoryClassStr();
}

/* Location:
 * Qualified Name:     org.slf4j.spi.MarkerFactoryBinder
 * Java Class Version: 1.3 (47.0)
 * JD-Core Version:    0.7.1
 */
package org.slf4j.spi;

import java.util.Map;

public abstract interface MDCAdapter
{
  public abstract void put(String paramString1, String paramString2);
  
  public abstract String get(String paramString);
  
  public abstract void remove(String paramString);
  
  public abstract void clear();
  
  public abstract Map getCopyOfContextMap();
  
  public abstract void setContextMap(Map paramMap);
}

/* Location:
 * Qualified Name:     org.slf4j.spi.MDCAdapter
 * Java Class Version: 1.3 (47.0)
 * JD-Core Version:    0.7.1
 */