first commit

rus/WEB-INF/lib/slf4j-api-1.7.5_src/META-INF/MANIFEST.MF

@@ -0,0 +1,18 @@
+Manifest-Version: 1.0
+Archiver-Version: Plexus Archiver
+Created-By: Apache Maven
+Built-By: ceki
+Build-Jdk: 1.6.0_23
+Bundle-Description: The slf4j API
+Bundle-Version: 1.7.5
+Implementation-Version: 1.7.5
+Implementation-Title: slf4j-api
+Bundle-ManifestVersion: 2
+Bundle-SymbolicName: slf4j.api
+Bundle-Name: slf4j-api
+Bundle-Vendor: SLF4J.ORG
+Bundle-RequiredExecutionEnvironment: J2SE-1.3
+Export-Package: org.slf4j;version=1.7.5, org.slf4j.spi;version=1.7.5, 
+ org.slf4j.helpers;version=1.7.5
+Import-Package: org.slf4j.impl;version=1.6.0
+

rus/WEB-INF/lib/slf4j-api-1.7.5_src/META-INF/maven/org.slf4j/slf4j-api/pom.properties

@@ -0,0 +1,5 @@
+#Generated by Maven
+#Mon Mar 25 21:49:23 CET 2013
+version=1.7.5
+groupId=org.slf4j
+artifactId=slf4j-api

rus/WEB-INF/lib/slf4j-api-1.7.5_src/META-INF/maven/org.slf4j/slf4j-api/pom.xml

@@ -0,0 +1,89 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+  <parent>
+    <groupId>org.slf4j</groupId>
+    <artifactId>slf4j-parent</artifactId>
+    <version>1.7.5</version>
+  </parent>
+
+  <modelVersion>4.0.0</modelVersion>
+
+  <groupId>org.slf4j</groupId>
+  <artifactId>slf4j-api</artifactId>
+  <packaging>jar</packaging>
+  <name>SLF4J API Module</name>
+  <description>The slf4j API</description>
+
+  <url>http://www.slf4j.org</url>
+
+  <dependencies>
+
+  </dependencies> 
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-surefire-plugin</artifactId>
+        <configuration>
+          <forkMode>once</forkMode>
+          <reportFormat>plain</reportFormat>
+          <trimStackTrace>false</trimStackTrace>
+          <excludes>
+            <exclude>**/AllTest.java</exclude>
+            <exclude>**/PackageTest.java</exclude>
+          </excludes>
+        </configuration>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jar-plugin</artifactId>
+        <configuration>
+          <archive>
+            <manifestEntries>
+              <Bundle-Version>${parsedVersion.osgiVersion}</Bundle-Version>
+              <Bundle-Description>${project.description}</Bundle-Description>
+              <Implementation-Version>${project.version}</Implementation-Version>
+            </manifestEntries>
+            <manifestFile>${project.build.outputDirectory}/META-INF/MANIFEST.MF</manifestFile>
+          </archive>
+        </configuration>
+        <executions>
+          <execution>
+            <id>bundle-test-jar</id>
+            <phase>package</phase>
+            <goals>
+              <goal>jar</goal>
+              <goal>test-jar</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-antrun-plugin</artifactId>
+        <executions>
+          <execution>
+            <phase>process-classes</phase>
+            <goals>
+             <goal>run</goal>
+            </goals>
+          </execution>
+        </executions>
+        <configuration>
+          <tasks>
+            <echo>Removing slf4j-api's dummy StaticLoggerBinder and StaticMarkerBinder</echo>
+            <delete dir="target/classes/org/slf4j/impl"/>
+          </tasks>
+        </configuration>
+      </plugin>
+
+    </plugins>
+
+  </build>
+
+</project>

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/ILoggerFactory.java

@@ -0,0 +1,5 @@
+package org.slf4j;
+
+public interface ILoggerFactory {
+  Logger getLogger(String paramString);
+}

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/IMarkerFactory.java

@@ -0,0 +1,11 @@
+package org.slf4j;
+
+public interface IMarkerFactory {
+  Marker getMarker(String paramString);
+  
+  boolean exists(String paramString);
+  
+  boolean detachMarker(String paramString);
+  
+  Marker getDetachedMarker(String paramString);
+}

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/Logger.java

@@ -0,0 +1,127 @@
+package org.slf4j;
+
+public interface Logger {
+  public static final String ROOT_LOGGER_NAME = "ROOT";
+  
+  String getName();
+  
+  boolean isTraceEnabled();
+  
+  void trace(String paramString);
+  
+  void trace(String paramString, Object paramObject);
+  
+  void trace(String paramString, Object paramObject1, Object paramObject2);
+  
+  void trace(String paramString, Object... paramVarArgs);
+  
+  void trace(String paramString, Throwable paramThrowable);
+  
+  boolean isTraceEnabled(Marker paramMarker);
+  
+  void trace(Marker paramMarker, String paramString);
+  
+  void trace(Marker paramMarker, String paramString, Object paramObject);
+  
+  void trace(Marker paramMarker, String paramString, Object paramObject1, Object paramObject2);
+  
+  void trace(Marker paramMarker, String paramString, Object... paramVarArgs);
+  
+  void trace(Marker paramMarker, String paramString, Throwable paramThrowable);
+  
+  boolean isDebugEnabled();
+  
+  void debug(String paramString);
+  
+  void debug(String paramString, Object paramObject);
+  
+  void debug(String paramString, Object paramObject1, Object paramObject2);
+  
+  void debug(String paramString, Object... paramVarArgs);
+  
+  void debug(String paramString, Throwable paramThrowable);
+  
+  boolean isDebugEnabled(Marker paramMarker);
+  
+  void debug(Marker paramMarker, String paramString);
+  
+  void debug(Marker paramMarker, String paramString, Object paramObject);
+  
+  void debug(Marker paramMarker, String paramString, Object paramObject1, Object paramObject2);
+  
+  void debug(Marker paramMarker, String paramString, Object... paramVarArgs);
+  
+  void debug(Marker paramMarker, String paramString, Throwable paramThrowable);
+  
+  boolean isInfoEnabled();
+  
+  void info(String paramString);
+  
+  void info(String paramString, Object paramObject);
+  
+  void info(String paramString, Object paramObject1, Object paramObject2);
+  
+  void info(String paramString, Object... paramVarArgs);
+  
+  void info(String paramString, Throwable paramThrowable);
+  
+  boolean isInfoEnabled(Marker paramMarker);
+  
+  void info(Marker paramMarker, String paramString);
+  
+  void info(Marker paramMarker, String paramString, Object paramObject);
+  
+  void info(Marker paramMarker, String paramString, Object paramObject1, Object paramObject2);
+  
+  void info(Marker paramMarker, String paramString, Object... paramVarArgs);
+  
+  void info(Marker paramMarker, String paramString, Throwable paramThrowable);
+  
+  boolean isWarnEnabled();
+  
+  void warn(String paramString);
+  
+  void warn(String paramString, Object paramObject);
+  
+  void warn(String paramString, Object... paramVarArgs);
+  
+  void warn(String paramString, Object paramObject1, Object paramObject2);
+  
+  void warn(String paramString, Throwable paramThrowable);
+  
+  boolean isWarnEnabled(Marker paramMarker);
+  
+  void warn(Marker paramMarker, String paramString);
+  
+  void warn(Marker paramMarker, String paramString, Object paramObject);
+  
+  void warn(Marker paramMarker, String paramString, Object paramObject1, Object paramObject2);
+  
+  void warn(Marker paramMarker, String paramString, Object... paramVarArgs);
+  
+  void warn(Marker paramMarker, String paramString, Throwable paramThrowable);
+  
+  boolean isErrorEnabled();
+  
+  void error(String paramString);
+  
+  void error(String paramString, Object paramObject);
+  
+  void error(String paramString, Object paramObject1, Object paramObject2);
+  
+  void error(String paramString, Object... paramVarArgs);
+  
+  void error(String paramString, Throwable paramThrowable);
+  
+  boolean isErrorEnabled(Marker paramMarker);
+  
+  void error(Marker paramMarker, String paramString);
+  
+  void error(Marker paramMarker, String paramString, Object paramObject);
+  
+  void error(Marker paramMarker, String paramString, Object paramObject1, Object paramObject2);
+  
+  void error(Marker paramMarker, String paramString, Object... paramVarArgs);
+  
+  void error(Marker paramMarker, String paramString, Throwable paramThrowable);
+}

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/LoggerFactory.java

@@ -0,0 +1,212 @@
+package org.slf4j;
+
+import java.io.IOException;
+import java.net.URL;
+import java.util.Arrays;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import org.slf4j.helpers.NOPLoggerFactory;
+import org.slf4j.helpers.SubstituteLoggerFactory;
+import org.slf4j.helpers.Util;
+import org.slf4j.impl.StaticLoggerBinder;
+
+public final class LoggerFactory {
+  static final String CODES_PREFIX = "http://www.slf4j.org/codes.html";
+  
+  static final String NO_STATICLOGGERBINDER_URL = "http://www.slf4j.org/codes.html#StaticLoggerBinder";
+  
+  static final String MULTIPLE_BINDINGS_URL = "http://www.slf4j.org/codes.html#multiple_bindings";
+  
+  static final String NULL_LF_URL = "http://www.slf4j.org/codes.html#null_LF";
+  
+  static final String VERSION_MISMATCH = "http://www.slf4j.org/codes.html#version_mismatch";
+  
+  static final String SUBSTITUTE_LOGGER_URL = "http://www.slf4j.org/codes.html#substituteLogger";
+  
+  static final String UNSUCCESSFUL_INIT_URL = "http://www.slf4j.org/codes.html#unsuccessfulInit";
+  
+  static final String UNSUCCESSFUL_INIT_MSG = "org.slf4j.LoggerFactory could not be successfully initialized. See also http://www.slf4j.org/codes.html#unsuccessfulInit";
+  
+  static final int UNINITIALIZED = 0;
+  
+  static final int ONGOING_INITIALIZATION = 1;
+  
+  static final int FAILED_INITIALIZATION = 2;
+  
+  static final int SUCCESSFUL_INITIALIZATION = 3;
+  
+  static final int NOP_FALLBACK_INITIALIZATION = 4;
+  
+  static int INITIALIZATION_STATE = 0;
+  
+  static SubstituteLoggerFactory TEMP_FACTORY = new SubstituteLoggerFactory();
+  
+  static NOPLoggerFactory NOP_FALLBACK_FACTORY = new NOPLoggerFactory();
+  
+  private static final String[] API_COMPATIBILITY_LIST = new String[] { "1.6", "1.7" };
+  
+  static void reset() {
+    INITIALIZATION_STATE = 0;
+    TEMP_FACTORY = new SubstituteLoggerFactory();
+  }
+  
+  private static final void performInitialization() {
+    bind();
+    if (INITIALIZATION_STATE == 3)
+      versionSanityCheck(); 
+  }
+  
+  private static boolean messageContainsOrgSlf4jImplStaticLoggerBinder(String msg) {
+    if (msg == null)
+      return false; 
+    if (msg.indexOf("org/slf4j/impl/StaticLoggerBinder") != -1)
+      return true; 
+    if (msg.indexOf("org.slf4j.impl.StaticLoggerBinder") != -1)
+      return true; 
+    return false;
+  }
+  
+  private static final void bind() {
+    try {
+      Set staticLoggerBinderPathSet = findPossibleStaticLoggerBinderPathSet();
+      reportMultipleBindingAmbiguity(staticLoggerBinderPathSet);
+      StaticLoggerBinder.getSingleton();
+      INITIALIZATION_STATE = 3;
+      reportActualBinding(staticLoggerBinderPathSet);
+      emitSubstituteLoggerWarning();
+    } catch (NoClassDefFoundError ncde) {
+      String msg = ncde.getMessage();
+      if (messageContainsOrgSlf4jImplStaticLoggerBinder(msg)) {
+        INITIALIZATION_STATE = 4;
+        Util.report("Failed to load class \"org.slf4j.impl.StaticLoggerBinder\".");
+        Util.report("Defaulting to no-operation (NOP) logger implementation");
+        Util.report("See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.");
+      } else {
+        failedBinding(ncde);
+        throw ncde;
+      } 
+    } catch (NoSuchMethodError nsme) {
+      String msg = nsme.getMessage();
+      if (msg != null && msg.indexOf("org.slf4j.impl.StaticLoggerBinder.getSingleton()") != -1) {
+        INITIALIZATION_STATE = 2;
+        Util.report("slf4j-api 1.6.x (or later) is incompatible with this binding.");
+        Util.report("Your binding is version 1.5.5 or earlier.");
+        Util.report("Upgrade your binding to version 1.6.x.");
+      } 
+      throw nsme;
+    } catch (Exception e) {
+      failedBinding(e);
+      throw new IllegalStateException("Unexpected initialization failure", e);
+    } 
+  }
+  
+  static void failedBinding(Throwable t) {
+    INITIALIZATION_STATE = 2;
+    Util.report("Failed to instantiate SLF4J LoggerFactory", t);
+  }
+  
+  private static final void emitSubstituteLoggerWarning() {
+    List<String> loggerNameList = TEMP_FACTORY.getLoggerNameList();
+    if (loggerNameList.size() == 0)
+      return; 
+    Util.report("The following loggers will not work because they were created");
+    Util.report("during the default configuration phase of the underlying logging system.");
+    Util.report("See also http://www.slf4j.org/codes.html#substituteLogger");
+    for (int i = 0; i < loggerNameList.size(); i++) {
+      String loggerName = loggerNameList.get(i);
+      Util.report(loggerName);
+    } 
+  }
+  
+  private static final void versionSanityCheck() {
+    try {
+      String requested = StaticLoggerBinder.REQUESTED_API_VERSION;
+      boolean match = false;
+      for (int i = 0; i < API_COMPATIBILITY_LIST.length; i++) {
+        if (requested.startsWith(API_COMPATIBILITY_LIST[i]))
+          match = true; 
+      } 
+      if (!match) {
+        Util.report("The requested version " + requested + " by your slf4j binding is not compatible with " + Arrays.<String>asList(API_COMPATIBILITY_LIST).toString());
+        Util.report("See http://www.slf4j.org/codes.html#version_mismatch for further details.");
+      } 
+    } catch (NoSuchFieldError nsfe) {
+    
+    } catch (Throwable e) {
+      Util.report("Unexpected problem occured during version sanity check", e);
+    } 
+  }
+  
+  private static String STATIC_LOGGER_BINDER_PATH = "org/slf4j/impl/StaticLoggerBinder.class";
+  
+  private static Set findPossibleStaticLoggerBinderPathSet() {
+    Set<URL> staticLoggerBinderPathSet = new LinkedHashSet();
+    try {
+      Enumeration<URL> paths;
+      ClassLoader loggerFactoryClassLoader = LoggerFactory.class.getClassLoader();
+      if (loggerFactoryClassLoader == null) {
+        paths = ClassLoader.getSystemResources(STATIC_LOGGER_BINDER_PATH);
+      } else {
+        paths = loggerFactoryClassLoader.getResources(STATIC_LOGGER_BINDER_PATH);
+      } 
+      while (paths.hasMoreElements()) {
+        URL path = paths.nextElement();
+        staticLoggerBinderPathSet.add(path);
+      } 
+    } catch (IOException ioe) {
+      Util.report("Error getting resources from path", ioe);
+    } 
+    return staticLoggerBinderPathSet;
+  }
+  
+  private static boolean isAmbiguousStaticLoggerBinderPathSet(Set staticLoggerBinderPathSet) {
+    return (staticLoggerBinderPathSet.size() > 1);
+  }
+  
+  private static void reportMultipleBindingAmbiguity(Set staticLoggerBinderPathSet) {
+    if (isAmbiguousStaticLoggerBinderPathSet(staticLoggerBinderPathSet)) {
+      Util.report("Class path contains multiple SLF4J bindings.");
+      Iterator<URL> iterator = staticLoggerBinderPathSet.iterator();
+      while (iterator.hasNext()) {
+        URL path = iterator.next();
+        Util.report("Found binding in [" + path + "]");
+      } 
+      Util.report("See http://www.slf4j.org/codes.html#multiple_bindings for an explanation.");
+    } 
+  }
+  
+  private static void reportActualBinding(Set staticLoggerBinderPathSet) {
+    if (isAmbiguousStaticLoggerBinderPathSet(staticLoggerBinderPathSet))
+      Util.report("Actual binding is of type [" + StaticLoggerBinder.getSingleton().getLoggerFactoryClassStr() + "]"); 
+  }
+  
+  public static Logger getLogger(String name) {
+    ILoggerFactory iLoggerFactory = getILoggerFactory();
+    return iLoggerFactory.getLogger(name);
+  }
+  
+  public static Logger getLogger(Class clazz) {
+    return getLogger(clazz.getName());
+  }
+  
+  public static ILoggerFactory getILoggerFactory() {
+    if (INITIALIZATION_STATE == 0) {
+      INITIALIZATION_STATE = 1;
+      performInitialization();
+    } 
+    switch (INITIALIZATION_STATE) {
+      case 3:
+        return StaticLoggerBinder.getSingleton().getLoggerFactory();
+      case 4:
+        return NOP_FALLBACK_FACTORY;
+      case 2:
+        throw new IllegalStateException("org.slf4j.LoggerFactory could not be successfully initialized. See also http://www.slf4j.org/codes.html#unsuccessfulInit");
+      case 1:
+        return TEMP_FACTORY;
+    } 
+    throw new IllegalStateException("Unreachable code");
+  }
+}

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/MDC.java

@@ -0,0 +1,79 @@
+package org.slf4j;
+
+import java.util.Map;
+import org.slf4j.helpers.NOPMDCAdapter;
+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) {
+      mdcAdapter = new NOPMDCAdapter();
+      String msg = ncde.getMessage();
+      if (msg != null && msg.indexOf("StaticMDCBinder") != -1) {
+        Util.report("Failed to load class \"org.slf4j.impl.StaticMDCBinder\".");
+        Util.report("Defaulting to no-operation MDCAdapter implementation.");
+        Util.report("See http://www.slf4j.org/codes.html#no_static_mdc_binder for further details.");
+      } else {
+        throw ncde;
+      } 
+    } catch (Exception e) {
+      Util.report("MDC binding unsuccessful.", 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;
+  }
+}

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/Marker.java

@@ -0,0 +1,30 @@
+package org.slf4j;
+
+import java.io.Serializable;
+import java.util.Iterator;
+
+public interface Marker extends Serializable {
+  public static final String ANY_MARKER = "*";
+  
+  public static final String ANY_NON_NULL_MARKER = "+";
+  
+  String getName();
+  
+  void add(Marker paramMarker);
+  
+  boolean remove(Marker paramMarker);
+  
+  boolean hasChildren();
+  
+  boolean hasReferences();
+  
+  Iterator iterator();
+  
+  boolean contains(Marker paramMarker);
+  
+  boolean contains(String paramString);
+  
+  boolean equals(Object paramObject);
+  
+  int hashCode();
+}

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/MarkerFactory.java

@@ -0,0 +1,31 @@
+package org.slf4j;
+
+import org.slf4j.helpers.BasicMarkerFactory;
+import org.slf4j.helpers.Util;
+import org.slf4j.impl.StaticMarkerBinder;
+
+public class MarkerFactory {
+  static IMarkerFactory markerFactory;
+  
+  static {
+    try {
+      markerFactory = StaticMarkerBinder.SINGLETON.getMarkerFactory();
+    } catch (NoClassDefFoundError e) {
+      markerFactory = new BasicMarkerFactory();
+    } catch (Exception e) {
+      Util.report("Unexpected failure while binding MarkerFactory", 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;
+  }
+}

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/helpers/BasicMDCAdapter.java

@@ -0,0 +1,82 @@
+package org.slf4j.helpers;
+
+import java.util.Collections;
+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();
+  
+  static boolean isJDK14() {
+    try {
+      String javaVersion = System.getProperty("java.version");
+      return javaVersion.startsWith("1.4");
+    } catch (SecurityException se) {
+      return false;
+    } 
+  }
+  
+  static boolean IS_JDK14 = isJDK14();
+  
+  public void put(String key, String val) {
+    if (key == null)
+      throw new IllegalArgumentException("key cannot be null"); 
+    Map<?, ?> map = this.inheritableThreadLocal.get();
+    if (map == null) {
+      map = Collections.synchronizedMap(new HashMap());
+      this.inheritableThreadLocal.set(map);
+    } 
+    map.put(key, val);
+  }
+  
+  public String get(String key) {
+    Map Map = this.inheritableThreadLocal.get();
+    if (Map != null && key != null)
+      return (String)Map.get(key); 
+    return null;
+  }
+  
+  public void remove(String key) {
+    Map map = this.inheritableThreadLocal.get();
+    if (map != null)
+      map.remove(key); 
+  }
+  
+  public void clear() {
+    Map map = this.inheritableThreadLocal.get();
+    if (map != null) {
+      map.clear();
+      if (isJDK14()) {
+        this.inheritableThreadLocal.set(null);
+      } else {
+        this.inheritableThreadLocal.remove();
+      } 
+    } 
+  }
+  
+  public Set getKeys() {
+    Map map = this.inheritableThreadLocal.get();
+    if (map != null)
+      return map.keySet(); 
+    return null;
+  }
+  
+  public Map getCopyOfContextMap() {
+    Map<?, ?> oldMap = this.inheritableThreadLocal.get();
+    if (oldMap != null) {
+      Map<?, ?> newMap = Collections.synchronizedMap(new HashMap());
+      synchronized (oldMap) {
+        newMap.putAll(oldMap);
+      } 
+      return newMap;
+    } 
+    return null;
+  }
+  
+  public void setContextMap(Map contextMap) {
+    Map<?, ?> map = Collections.synchronizedMap(new HashMap(contextMap));
+    this.inheritableThreadLocal.set(map);
+  }
+}

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/helpers/BasicMarker.java

@@ -0,0 +1,130 @@
+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 refereceList;
+  
+  BasicMarker(String name) {
+    if (name == null)
+      throw new IllegalArgumentException("A marker name cannot be null"); 
+    this.name = name;
+  }
+  
+  public String getName() {
+    return this.name;
+  }
+  
+  public synchronized void add(Marker reference) {
+    if (reference == null)
+      throw new IllegalArgumentException("A null value cannot be added to a Marker as reference."); 
+    if (contains(reference))
+      return; 
+    if (reference.contains(this))
+      return; 
+    if (this.refereceList == null)
+      this.refereceList = new Vector(); 
+    this.refereceList.add(reference);
+  }
+  
+  public synchronized boolean hasReferences() {
+    return (this.refereceList != null && this.refereceList.size() > 0);
+  }
+  
+  public boolean hasChildren() {
+    return hasReferences();
+  }
+  
+  public synchronized Iterator iterator() {
+    if (this.refereceList != null)
+      return this.refereceList.iterator(); 
+    return Collections.EMPTY_LIST.iterator();
+  }
+  
+  public synchronized boolean remove(Marker referenceToRemove) {
+    if (this.refereceList == null)
+      return false; 
+    int size = this.refereceList.size();
+    for (int i = 0; i < size; i++) {
+      Marker m = this.refereceList.get(i);
+      if (referenceToRemove.equals(m)) {
+        this.refereceList.remove(i);
+        return true;
+      } 
+    } 
+    return false;
+  }
+  
+  public boolean contains(Marker other) {
+    if (other == null)
+      throw new IllegalArgumentException("Other cannot be null"); 
+    if (equals(other))
+      return true; 
+    if (hasReferences())
+      for (int i = 0; i < this.refereceList.size(); i++) {
+        Marker ref = this.refereceList.get(i);
+        if (ref.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 (hasReferences())
+      for (int i = 0; i < this.refereceList.size(); i++) {
+        Marker ref = this.refereceList.get(i);
+        if (ref.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 this.name.equals(other.getName());
+  }
+  
+  public int hashCode() {
+    return this.name.hashCode();
+  }
+  
+  public String toString() {
+    if (!hasReferences())
+      return getName(); 
+    Iterator<Marker> it = iterator();
+    StringBuffer sb = new StringBuffer(getName());
+    sb.append(' ').append(OPEN);
+    while (it.hasNext()) {
+      Marker reference = it.next();
+      sb.append(reference.getName());
+      if (it.hasNext())
+        sb.append(SEP); 
+    } 
+    sb.append(CLOSE);
+    return sb.toString();
+  }
+}

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/helpers/BasicMarkerFactory.java

@@ -0,0 +1,37 @@
+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)this.markerMap.get(name);
+    if (marker == null) {
+      marker = new BasicMarker(name);
+      this.markerMap.put(name, marker);
+    } 
+    return marker;
+  }
+  
+  public synchronized boolean exists(String name) {
+    if (name == null)
+      return false; 
+    return this.markerMap.containsKey(name);
+  }
+  
+  public boolean detachMarker(String name) {
+    if (name == null)
+      return false; 
+    return (this.markerMap.remove(name) != null);
+  }
+  
+  public Marker getDetachedMarker(String name) {
+    return new BasicMarker(name);
+  }
+}

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/helpers/FormattingTuple.java

@@ -0,0 +1,46 @@
+package org.slf4j.helpers;
+
+public class FormattingTuple {
+  public static FormattingTuple NULL = new FormattingTuple(null);
+  
+  private String message;
+  
+  private Throwable throwable;
+  
+  private Object[] argArray;
+  
+  public FormattingTuple(String message) {
+    this(message, null, null);
+  }
+  
+  public FormattingTuple(String message, Object[] argArray, Throwable throwable) {
+    this.message = message;
+    this.throwable = throwable;
+    if (throwable == null) {
+      this.argArray = argArray;
+    } else {
+      this.argArray = trimmedCopy(argArray);
+    } 
+  }
+  
+  static Object[] trimmedCopy(Object[] argArray) {
+    if (argArray == null || argArray.length == 0)
+      throw new IllegalStateException("non-sensical empty or null argument array"); 
+    int trimemdLen = argArray.length - 1;
+    Object[] trimmed = new Object[trimemdLen];
+    System.arraycopy(argArray, 0, trimmed, 0, trimemdLen);
+    return trimmed;
+  }
+  
+  public String getMessage() {
+    return this.message;
+  }
+  
+  public Object[] getArgArray() {
+    return this.argArray;
+  }
+  
+  public Throwable getThrowable() {
+    return this.throwable;
+  }
+}

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/helpers/MarkerIgnoringBase.java

@@ -0,0 +1,132 @@
+package org.slf4j.helpers;
+
+import org.slf4j.Logger;
+import org.slf4j.Marker;
+
+public abstract class MarkerIgnoringBase extends NamedLoggerBase implements Logger {
+  private static final long serialVersionUID = 9044267456635152283L;
+  
+  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... arguments) {
+    trace(format, arguments);
+  }
+  
+  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... arguments) {
+    debug(format, arguments);
+  }
+  
+  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... arguments) {
+    info(format, arguments);
+  }
+  
+  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... arguments) {
+    warn(format, arguments);
+  }
+  
+  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... arguments) {
+    error(format, arguments);
+  }
+  
+  public void error(Marker marker, String msg, Throwable t) {
+    error(msg, t);
+  }
+  
+  public String toString() {
+    return getClass().getName() + "(" + getName() + ")";
+  }
+}

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/helpers/MessageFormatter.java

@@ -0,0 +1,230 @@
+package org.slf4j.helpers;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public final class MessageFormatter {
+  static final char DELIM_START = '{';
+  
+  static final char DELIM_STOP = '}';
+  
+  static final String DELIM_STR = "{}";
+  
+  private static final char ESCAPE_CHAR = '\\';
+  
+  public static final FormattingTuple format(String messagePattern, Object arg) {
+    return arrayFormat(messagePattern, new Object[] { arg });
+  }
+  
+  public static final FormattingTuple format(String messagePattern, Object arg1, Object arg2) {
+    return arrayFormat(messagePattern, new Object[] { arg1, arg2 });
+  }
+  
+  static final Throwable getThrowableCandidate(Object[] argArray) {
+    if (argArray == null || argArray.length == 0)
+      return null; 
+    Object lastEntry = argArray[argArray.length - 1];
+    if (lastEntry instanceof Throwable)
+      return (Throwable)lastEntry; 
+    return null;
+  }
+  
+  public static final FormattingTuple arrayFormat(String messagePattern, Object[] argArray) {
+    Throwable throwableCandidate = getThrowableCandidate(argArray);
+    if (messagePattern == null)
+      return new FormattingTuple(null, argArray, throwableCandidate); 
+    if (argArray == null)
+      return new FormattingTuple(messagePattern); 
+    int i = 0;
+    StringBuffer sbuf = new StringBuffer(messagePattern.length() + 50);
+    int L;
+    for (L = 0; L < argArray.length; L++) {
+      int j = messagePattern.indexOf("{}", i);
+      if (j == -1) {
+        if (i == 0)
+          return new FormattingTuple(messagePattern, argArray, throwableCandidate); 
+        sbuf.append(messagePattern.substring(i, messagePattern.length()));
+        return new FormattingTuple(sbuf.toString(), argArray, throwableCandidate);
+      } 
+      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));
+          deeplyAppendParameter(sbuf, argArray[L], new HashMap());
+          i = j + 2;
+        } 
+      } else {
+        sbuf.append(messagePattern.substring(i, j));
+        deeplyAppendParameter(sbuf, argArray[L], new HashMap());
+        i = j + 2;
+      } 
+    } 
+    sbuf.append(messagePattern.substring(i, messagePattern.length()));
+    if (L < argArray.length - 1)
+      return new FormattingTuple(sbuf.toString(), argArray, throwableCandidate); 
+    return new FormattingTuple(sbuf.toString(), argArray, null);
+  }
+  
+  static final boolean isEscapedDelimeter(String messagePattern, int delimeterStartIndex) {
+    if (delimeterStartIndex == 0)
+      return false; 
+    char potentialEscape = messagePattern.charAt(delimeterStartIndex - 1);
+    if (potentialEscape == '\\')
+      return true; 
+    return false;
+  }
+  
+  static final boolean isDoubleEscaped(String messagePattern, int delimeterStartIndex) {
+    if (delimeterStartIndex >= 2 && messagePattern.charAt(delimeterStartIndex - 2) == '\\')
+      return true; 
+    return false;
+  }
+  
+  private static void deeplyAppendParameter(StringBuffer sbuf, Object o, Map seenMap) {
+    if (o == null) {
+      sbuf.append("null");
+      return;
+    } 
+    if (!o.getClass().isArray()) {
+      safeObjectAppend(sbuf, o);
+    } else if (o instanceof boolean[]) {
+      booleanArrayAppend(sbuf, (boolean[])o);
+    } else if (o instanceof byte[]) {
+      byteArrayAppend(sbuf, (byte[])o);
+    } else if (o instanceof char[]) {
+      charArrayAppend(sbuf, (char[])o);
+    } else if (o instanceof short[]) {
+      shortArrayAppend(sbuf, (short[])o);
+    } else if (o instanceof int[]) {
+      intArrayAppend(sbuf, (int[])o);
+    } else if (o instanceof long[]) {
+      longArrayAppend(sbuf, (long[])o);
+    } else if (o instanceof float[]) {
+      floatArrayAppend(sbuf, (float[])o);
+    } else if (o instanceof double[]) {
+      doubleArrayAppend(sbuf, (double[])o);
+    } else {
+      objectArrayAppend(sbuf, (Object[])o, seenMap);
+    } 
+  }
+  
+  private static void safeObjectAppend(StringBuffer sbuf, Object o) {
+    try {
+      String oAsString = o.toString();
+      sbuf.append(oAsString);
+    } catch (Throwable t) {
+      System.err.println("SLF4J: Failed toString() invocation on an object of type [" + o.getClass().getName() + "]");
+      t.printStackTrace();
+      sbuf.append("[FAILED toString()]");
+    } 
+  }
+  
+  private static void objectArrayAppend(StringBuffer sbuf, Object[] a, Map seenMap) {
+    sbuf.append('[');
+    if (!seenMap.containsKey(a)) {
+      seenMap.put(a, null);
+      int len = a.length;
+      for (int i = 0; i < len; i++) {
+        deeplyAppendParameter(sbuf, a[i], seenMap);
+        if (i != len - 1)
+          sbuf.append(", "); 
+      } 
+      seenMap.remove(a);
+    } else {
+      sbuf.append("...");
+    } 
+    sbuf.append(']');
+  }
+  
+  private static void booleanArrayAppend(StringBuffer sbuf, boolean[] a) {
+    sbuf.append('[');
+    int len = a.length;
+    for (int i = 0; i < len; i++) {
+      sbuf.append(a[i]);
+      if (i != len - 1)
+        sbuf.append(", "); 
+    } 
+    sbuf.append(']');
+  }
+  
+  private static void byteArrayAppend(StringBuffer sbuf, byte[] a) {
+    sbuf.append('[');
+    int len = a.length;
+    for (int i = 0; i < len; i++) {
+      sbuf.append(a[i]);
+      if (i != len - 1)
+        sbuf.append(", "); 
+    } 
+    sbuf.append(']');
+  }
+  
+  private static void charArrayAppend(StringBuffer sbuf, char[] a) {
+    sbuf.append('[');
+    int len = a.length;
+    for (int i = 0; i < len; i++) {
+      sbuf.append(a[i]);
+      if (i != len - 1)
+        sbuf.append(", "); 
+    } 
+    sbuf.append(']');
+  }
+  
+  private static void shortArrayAppend(StringBuffer sbuf, short[] a) {
+    sbuf.append('[');
+    int len = a.length;
+    for (int i = 0; i < len; i++) {
+      sbuf.append(a[i]);
+      if (i != len - 1)
+        sbuf.append(", "); 
+    } 
+    sbuf.append(']');
+  }
+  
+  private static void intArrayAppend(StringBuffer sbuf, int[] a) {
+    sbuf.append('[');
+    int len = a.length;
+    for (int i = 0; i < len; i++) {
+      sbuf.append(a[i]);
+      if (i != len - 1)
+        sbuf.append(", "); 
+    } 
+    sbuf.append(']');
+  }
+  
+  private static void longArrayAppend(StringBuffer sbuf, long[] a) {
+    sbuf.append('[');
+    int len = a.length;
+    for (int i = 0; i < len; i++) {
+      sbuf.append(a[i]);
+      if (i != len - 1)
+        sbuf.append(", "); 
+    } 
+    sbuf.append(']');
+  }
+  
+  private static void floatArrayAppend(StringBuffer sbuf, float[] a) {
+    sbuf.append('[');
+    int len = a.length;
+    for (int i = 0; i < len; i++) {
+      sbuf.append(a[i]);
+      if (i != len - 1)
+        sbuf.append(", "); 
+    } 
+    sbuf.append(']');
+  }
+  
+  private static void doubleArrayAppend(StringBuffer sbuf, double[] a) {
+    sbuf.append('[');
+    int len = a.length;
+    for (int i = 0; i < len; i++) {
+      sbuf.append(a[i]);
+      if (i != len - 1)
+        sbuf.append(", "); 
+    } 
+    sbuf.append(']');
+  }
+}

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/helpers/NOPLogger.java

@@ -0,0 +1,81 @@
+package org.slf4j.helpers;
+
+public class NOPLogger extends MarkerIgnoringBase {
+  private static final long serialVersionUID = -517220405410904473L;
+  
+  public static final NOPLogger NOP_LOGGER = new NOPLogger();
+  
+  public String getName() {
+    return "NOP";
+  }
+  
+  public final boolean isTraceEnabled() {
+    return false;
+  }
+  
+  public final void trace(String msg) {}
+  
+  public final void trace(String format, Object arg) {}
+  
+  public final void trace(String format, Object arg1, Object arg2) {}
+  
+  public final void trace(String format, Object... argArray) {}
+  
+  public final void trace(String msg, Throwable t) {}
+  
+  public final boolean isDebugEnabled() {
+    return false;
+  }
+  
+  public final void debug(String msg) {}
+  
+  public final void debug(String format, Object arg) {}
+  
+  public final void debug(String format, Object arg1, Object arg2) {}
+  
+  public final void debug(String format, Object... argArray) {}
+  
+  public final void debug(String msg, Throwable t) {}
+  
+  public final boolean isInfoEnabled() {
+    return false;
+  }
+  
+  public final void info(String msg) {}
+  
+  public final void info(String format, Object arg1) {}
+  
+  public final void info(String format, Object arg1, Object arg2) {}
+  
+  public final void info(String format, Object... argArray) {}
+  
+  public final void info(String msg, Throwable t) {}
+  
+  public final boolean isWarnEnabled() {
+    return false;
+  }
+  
+  public final void warn(String msg) {}
+  
+  public final void warn(String format, Object arg1) {}
+  
+  public final void warn(String format, Object arg1, Object arg2) {}
+  
+  public final void warn(String format, Object... argArray) {}
+  
+  public final void warn(String msg, Throwable t) {}
+  
+  public final boolean isErrorEnabled() {
+    return false;
+  }
+  
+  public final void error(String msg) {}
+  
+  public final void error(String format, Object arg1) {}
+  
+  public final void error(String format, Object arg1, Object arg2) {}
+  
+  public final void error(String format, Object... argArray) {}
+  
+  public final void error(String msg, Throwable t) {}
+}

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/helpers/NOPLoggerFactory.java

@@ -0,0 +1,10 @@
+package org.slf4j.helpers;
+
+import org.slf4j.ILoggerFactory;
+import org.slf4j.Logger;
+
+public class NOPLoggerFactory implements ILoggerFactory {
+  public Logger getLogger(String name) {
+    return NOPLogger.NOP_LOGGER;
+  }
+}

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/helpers/NOPMDCAdapter.java

@@ -0,0 +1,22 @@
+package org.slf4j.helpers;
+
+import java.util.Map;
+import org.slf4j.spi.MDCAdapter;
+
+public class NOPMDCAdapter 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) {}
+}

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/helpers/NamedLoggerBase.java

@@ -0,0 +1,20 @@
+package org.slf4j.helpers;
+
+import java.io.ObjectStreamException;
+import java.io.Serializable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+abstract class NamedLoggerBase implements Logger, Serializable {
+  private static final long serialVersionUID = 7535258609338176893L;
+  
+  protected String name;
+  
+  public String getName() {
+    return this.name;
+  }
+  
+  protected Object readResolve() throws ObjectStreamException {
+    return LoggerFactory.getLogger(getName());
+  }
+}

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/helpers/SubstituteLoggerFactory.java

@@ -0,0 +1,25 @@
+package org.slf4j.helpers;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.slf4j.ILoggerFactory;
+import org.slf4j.Logger;
+
+public class SubstituteLoggerFactory implements ILoggerFactory {
+  final List loggerNameList = new ArrayList();
+  
+  public Logger getLogger(String name) {
+    synchronized (this.loggerNameList) {
+      this.loggerNameList.add(name);
+    } 
+    return NOPLogger.NOP_LOGGER;
+  }
+  
+  public List getLoggerNameList() {
+    List copy = new ArrayList();
+    synchronized (this.loggerNameList) {
+      copy.addAll(this.loggerNameList);
+    } 
+    return copy;
+  }
+}

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/helpers/Util.java

@@ -0,0 +1,13 @@
+package org.slf4j.helpers;
+
+public class Util {
+  public static final void report(String msg, Throwable t) {
+    System.err.println(msg);
+    System.err.println("Reported exception:");
+    t.printStackTrace();
+  }
+  
+  public static final void report(String msg) {
+    System.err.println("SLF4J: " + msg);
+  }
+}

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/spi/LocationAwareLogger.java

@@ -0,0 +1,18 @@
+package org.slf4j.spi;
+
+import org.slf4j.Logger;
+import org.slf4j.Marker;
+
+public 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;
+  
+  void log(Marker paramMarker, String paramString1, int paramInt, String paramString2, Object[] paramArrayOfObject, Throwable paramThrowable);
+}

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/spi/LoggerFactoryBinder.java

@@ -0,0 +1,9 @@
+package org.slf4j.spi;
+
+import org.slf4j.ILoggerFactory;
+
+public interface LoggerFactoryBinder {
+  ILoggerFactory getLoggerFactory();
+  
+  String getLoggerFactoryClassStr();
+}

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/spi/MDCAdapter.java

@@ -0,0 +1,17 @@
+package org.slf4j.spi;
+
+import java.util.Map;
+
+public interface MDCAdapter {
+  void put(String paramString1, String paramString2);
+  
+  String get(String paramString);
+  
+  void remove(String paramString);
+  
+  void clear();
+  
+  Map getCopyOfContextMap();
+  
+  void setContextMap(Map paramMap);
+}

rus/WEB-INF/lib/slf4j-api-1.7.5_src/org/slf4j/spi/MarkerFactoryBinder.java

@@ -0,0 +1,9 @@
+package org.slf4j.spi;
+
+import org.slf4j.IMarkerFactory;
+
+public interface MarkerFactoryBinder {
+  IMarkerFactory getMarkerFactory();
+  
+  String getMarkerFactoryClassStr();
+}