\paragraph{}
\label{JSS:*CL-USER-COMPATIBILITY*}
\index{*CL-USER-COMPATIBILITY*}
--- Variable: \textbf{*cl-user-compatibility*} [\textbf{jss}] \textit{}

\begin{adjustwidth}{5em}{5em}
Whether backwards compatibility with JSS's use of CL-USER has been enabled.
\end{adjustwidth}

\paragraph{}
\label{JSS:*DO-AUTO-IMPORTS*}
\index{*DO-AUTO-IMPORTS*}
--- Variable: \textbf{*do-auto-imports*} [\textbf{jss}] \textit{}

\begin{adjustwidth}{5em}{5em}
Whether to automatically introspect all Java classes on the classpath when JSS is loaded.
\end{adjustwidth}

\paragraph{}
\label{JSS:*MUFFLE-WARNINGS*}
\index{*MUFFLE-WARNINGS*}
--- Variable: \textbf{*muffle-warnings*} [\textbf{jss}] \textit{}

\begin{adjustwidth}{5em}{5em}
Attempt to make JSS less chatting about how things are going.
\end{adjustwidth}

\paragraph{}
\label{JSS:CLASSFILES-IMPORT}
\index{CLASSFILES-IMPORT}
--- Function: \textbf{classfiles-import} [\textbf{jss}] \textit{directory}

\begin{adjustwidth}{5em}{5em}
Load all Java classes recursively contained under DIRECTORY in the current process.
\end{adjustwidth}

\paragraph{}
\label{JSS:ENSURE-COMPATIBILITY}
\index{ENSURE-COMPATIBILITY}
--- Function: \textbf{ensure-compatibility} [\textbf{jss}] \textit{}

\begin{adjustwidth}{5em}{5em}
Ensure backwards compatibility with JSS's use of CL-USER.
\end{adjustwidth}

\paragraph{}
\label{JSS:FIND-JAVA-CLASS}
\index{FIND-JAVA-CLASS}
--- Function: \textbf{find-java-class} [\textbf{jss}] \textit{name}

\begin{adjustwidth}{5em}{5em}
not-documented
\end{adjustwidth}

\paragraph{}
\label{JSS:GET-JAVA-FIELD}
\index{GET-JAVA-FIELD}
--- Function: \textbf{get-java-field} [\textbf{jss}] \textit{object field \&optional (try-harder *running-in-osgi*)}

\begin{adjustwidth}{5em}{5em}
Get the value of the FIELD contained in OBJECT.
If OBJECT is a symbol it names a dot qualified static FIELD.
\end{adjustwidth}

\paragraph{}
\label{JSS:HASHMAP-TO-HASHTABLE}
\index{HASHMAP-TO-HASHTABLE}
--- Function: \textbf{hashmap-to-hashtable} [\textbf{jss}] \textit{hashmap \&rest rest \&key (keyfun (function identity)) (valfun (function identity)) (invert? NIL) table \&allow-other-keys}

\begin{adjustwidth}{5em}{5em}
Converts the a HASHMAP reference to a java.util.HashMap object to a Lisp hashtable.

The REST paramter specifies arguments to the underlying MAKE-HASH-TABLE call.

KEYFUN and VALFUN specifies functions to be run on the keys and values
of the HASHMAP right before they are placed in the hashtable.

If INVERT? is non-nil than reverse the keys and values in the resulting hashtable.
\end{adjustwidth}

\paragraph{}
\label{JSS:INVOKE-ADD-IMPORTS}
\index{INVOKE-ADD-IMPORTS}
--- Macro: \textbf{invoke-add-imports} [\textbf{jss}] \textit{}

\begin{adjustwidth}{5em}{5em}
Push these imports onto the search path. If multiple, earlier in list take precedence
\end{adjustwidth}

\paragraph{}
\label{JSS:INVOKE-RESTARGS}
\index{INVOKE-RESTARGS}
--- Function: \textbf{invoke-restargs} [\textbf{jss}] \textit{method object args \&optional (raw? NIL)}

\begin{adjustwidth}{5em}{5em}
not-documented
\end{adjustwidth}

\paragraph{}
\label{JSS:ITERABLE-TO-LIST}
\index{ITERABLE-TO-LIST}
--- Function: \textbf{iterable-to-list} [\textbf{jss}] \textit{iterable}

\begin{adjustwidth}{5em}{5em}
Return the items contained the java.lang.Iterable ITERABLE as a list.
\end{adjustwidth}

\paragraph{}
\label{JSS:J2LIST}
\index{J2LIST}
--- Function: \textbf{j2list} [\textbf{jss}] \textit{thing}

\begin{adjustwidth}{5em}{5em}
Attempt to construct a Lisp list out of a Java THING.

THING may be a wide range of Java collection types, their common
iterators or a Java array.
\end{adjustwidth}

\paragraph{}
\label{JSS:JAPROPOS}
\index{JAPROPOS}
--- Function: \textbf{japropos} [\textbf{jss}] \textit{string}

\begin{adjustwidth}{5em}{5em}
Output the names of all Java class names loaded in the current process which match STRING..
\end{adjustwidth}

\paragraph{}
\label{JSS:JAR-IMPORT}
\index{JAR-IMPORT}
--- Function: \textbf{jar-import} [\textbf{jss}] \textit{file}

\begin{adjustwidth}{5em}{5em}
Import all the Java classes contained in the pathname FILE into the JSS dynamic lookup cache.
\end{adjustwidth}

\paragraph{}
\label{JSS:JARRAY-TO-LIST}
\index{JARRAY-TO-LIST}
--- Function: \textbf{jarray-to-list} [\textbf{jss}] \textit{jarray}

\begin{adjustwidth}{5em}{5em}
Convert the Java array named by JARRARY into a Lisp list.
\end{adjustwidth}

\paragraph{}
\label{JSS:JAVA-CLASS-METHOD-NAMES}
\index{JAVA-CLASS-METHOD-NAMES}
--- Function: \textbf{java-class-method-names} [\textbf{jss}] \textit{class \&optional stream}

\begin{adjustwidth}{5em}{5em}
Return a list of the public methods encapsulated by the JVM CLASS.

If STREAM non-nil, output a verbose description to the named output stream.

CLASS may either be a string naming a fully qualified JVM class in dot
notation, or a symbol resolved against all class entries in the
current classpath.
\end{adjustwidth}

\paragraph{}
\label{JSS:JCLASS-ALL-INTERFACES}
\index{JCLASS-ALL-INTERFACES}
--- Function: \textbf{jclass-all-interfaces} [\textbf{jss}] \textit{class}

\begin{adjustwidth}{5em}{5em}
Return a list of interfaces the class implements
\end{adjustwidth}

\paragraph{}
\label{JSS:JCMN}
\index{JCMN}
--- Function: \textbf{jcmn} [\textbf{jss}] \textit{class \&optional stream}

\begin{adjustwidth}{5em}{5em}
Return a list of the public methods encapsulated by the JVM CLASS.

If STREAM non-nil, output a verbose description to the named output stream.

CLASS may either be a string naming a fully qualified JVM class in dot
notation, or a symbol resolved against all class entries in the
current classpath.
\end{adjustwidth}

\paragraph{}
\label{JSS:JLIST-TO-LIST}
\index{JLIST-TO-LIST}
--- Function: \textbf{jlist-to-list} [\textbf{jss}] \textit{list}

\begin{adjustwidth}{5em}{5em}
Convert a LIST implementing java.util.List to a Lisp list.
\end{adjustwidth}

\paragraph{}
\label{JSS:JMAP}
\index{JMAP}
--- Function: \textbf{jmap} [\textbf{jss}] \textit{function thing}

\begin{adjustwidth}{5em}{5em}
Call FUNCTION for every element in the THING.  Returns NIL.

THING may be a wide range of Java collection types, their common iterators or
a Java array.

In case the THING is a map-like object, FUNCTION will be called with two
arguments, key and value.
\end{adjustwidth}

\paragraph{}
\label{JSS:JTYPECASE}
\index{JTYPECASE}
--- Macro: \textbf{jtypecase} [\textbf{jss}] \textit{}

\begin{adjustwidth}{5em}{5em}
JTYPECASE Keyform {(Type Form*)}*
  Evaluates the Forms in the first clause for which Type names a class that Keyform isInstance of
  is true.
\end{adjustwidth}

\paragraph{}
\label{JSS:JTYPEP}
\index{JTYPEP}
--- Function: \textbf{jtypep} [\textbf{jss}] \textit{object type}

\begin{adjustwidth}{5em}{5em}
not-documented
\end{adjustwidth}

\paragraph{}
\label{JSS:LIST-TO-LIST}
\index{LIST-TO-LIST}
--- Function: \textbf{list-to-list} [\textbf{jss}] \textit{list}

\begin{adjustwidth}{5em}{5em}
not-documented
\end{adjustwidth}

\paragraph{}
\label{JSS:NEW}
\index{NEW}
--- Function: \textbf{new} [\textbf{jss}] \textit{class-name \&rest args}

\begin{adjustwidth}{5em}{5em}
Invoke the Java constructor for CLASS-NAME with ARGS.

CLASS-NAME may either be a symbol or a string according to the usual JSS conventions.
\end{adjustwidth}

\paragraph{}
\label{JSS:SET-JAVA-FIELD}
\index{SET-JAVA-FIELD}
--- Function: \textbf{set-java-field} [\textbf{jss}] \textit{object field value \&optional (try-harder *running-in-osgi*)}

\begin{adjustwidth}{5em}{5em}
Set the FIELD of OBJECT to VALUE.
If OBJECT is a symbol, it names a dot qualified Java class to look for
a static FIELD.  If OBJECT is an instance of java:java-object, the
associated is used to look up the static FIELD.
\end{adjustwidth}

\paragraph{}
\label{JSS:SET-TO-LIST}
\index{SET-TO-LIST}
--- Function: \textbf{set-to-list} [\textbf{jss}] \textit{set}

\begin{adjustwidth}{5em}{5em}
Convert the java.util.Set named in SET to a Lisp list.
\end{adjustwidth}

\paragraph{}
\label{JSS:TO-HASHSET}
\index{TO-HASHSET}
--- Function: \textbf{to-hashset} [\textbf{jss}] \textit{list}

\begin{adjustwidth}{5em}{5em}
Convert LIST to the java.util.HashSet contract
\end{adjustwidth}

\paragraph{}
\label{JSS:VECTOR-TO-LIST}
\index{VECTOR-TO-LIST}
--- Function: \textbf{vector-to-list} [\textbf{jss}] \textit{vector}

\begin{adjustwidth}{5em}{5em}
Return the elements of java.lang.Vector VECTOR as a list.
\end{adjustwidth}

\paragraph{}
\label{JSS:WITH-CONSTANT-SIGNATURE}
\index{WITH-CONSTANT-SIGNATURE}
--- Macro: \textbf{with-constant-signature} [\textbf{jss}] \textit{}

\begin{adjustwidth}{5em}{5em}
Expand all references to FNAME-JNAME-PAIRS in BODY into static function calls promising that the same function bound in the FNAME-JNAME-PAIRS will be invoked with the same argument signature.

FNAME-JNAME-PAIRS is a list of (symbol function \&optional raw)
elements where symbol will be the symbol bound to the method named by
the string function.  If the optional parameter raw is non-nil, the
result will be the raw JVM object, uncoerced by the usual conventions.

Use this macro if you are making a lot of calls and 
want to avoid the overhead of the dynamic dispatch.
\end{adjustwidth}

