build

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JacksonAnnotation.java

@@ -1,20 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Meta-annotation (annotations used on other annotations)
- * used for marking all annotations that are
- * part of Jackson package. Can be used for recognizing all
- * Jackson annotations generically, and in future also for
- * passing other generic annotation configuration.
- */
-@Target({ElementType.ANNOTATION_TYPE})
-@Retention(RetentionPolicy.RUNTIME)
-public @interface JacksonAnnotation
-{
-    // for now, a pure tag annotation, no parameters
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JacksonAnnotationsInside.java

@@ -1,25 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Meta-annotation (annotations used on other annotations)
- * used for indicating that instead of using target annotation
- * (annotation annotated with this annotation),
- * Jackson should use meta-annotations it has.
- * This can be useful in creating "combo-annotations" by having
- * a container annotation, which needs to be annotated with this
- * annotation as well as all annotations it 'contains'.
- * 
- * @since 2.0
- */
-@Target({ElementType.ANNOTATION_TYPE})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JacksonAnnotationsInside
-{
-
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JacksonInject.java

@@ -1,28 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import com.fr.third.fasterxml.jackson.annotation.JacksonAnnotation;
-
-/**
- * Jackson-specific annotation used for indicating that value of
- * annotated property will be "injected", i.e. set based on value
- * configured by <code>ObjectMapper</code> (usually on per-call basis).
- * Usually property is not deserialized from JSON, although it possible
- * to have injected value as default and still allow optional override
- * from JSON.
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JacksonInject
-{
-    /**
-     * Logical id of the value to inject; if not specified (or specified
-     * as empty String), will use id based on declared type of property.
-     */
-    public String value() default "";
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonAnyGetter.java

@@ -1,23 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Marker annotation that can be used to define a non-static,
- * no-argument method or member field as something of a reverse of
- * {@link JsonAnySetter} method; basically being used like a
- * getter but such that contents of the returned Map (type <b>must</b> be
- * {@link java.util.Map}) are serialized as if they were actual properties
- * of the bean that contains method/field with this annotations.
- * As with {@link JsonAnySetter}, only one property should be annotated
- * with this annotation.
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonAnyGetter
-{
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonAnySetter.java

@@ -1,25 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Marker annotation that can be used to define a non-static,
- * two-argument method (first argument name of property, second value
- * to set), to be used as a "fallback" handler
- * for all otherwise unrecognized properties found from JSON content.
- * It is similar to {@link javax.xml.bind.annotation.XmlAnyElement}
- * in behavior; and can only be used to denote a single property
- * per type.
- *<p>
- * If used, all otherwise unmapped key-value pairs from JSON Object values
- * are added to the property (of type Map or bean).
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonAnySetter
-{
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonAutoDetect.java

@@ -1,126 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-import java.lang.reflect.Member;
-import java.lang.reflect.Modifier;
-
-/**
- * Class annotation that can be used to define which kinds of Methods
- * are to be detected by auto-detection.
- * Auto-detection means using name conventions
- * and/or signature templates to find methods to use for data binding.
- * For example, so-called "getters" can be auto-detected by looking for
- * public member methods that return a value, do not take argument,
- * and have prefix "get" in their name.
- *<p>
- * Pseudo-value <code>NONE</code> means that all auto-detection is disabled
- * for the <b>specific</b> class that annotation is applied to (including
- * its super-types, but only when resolving that class).
- * Pseudo-value <code>ALWAYS</code> means that auto-detection is enabled
- * for all method types for the class in similar way.
- *<p>
- * The default value is <code>ALWAYS</code>: that is, by default, auto-detection
- * is enabled for all classes unless instructed otherwise.
- *<p>
- * Starting with version 1.5, it is also possible to use more fine-grained
- * definitions, to basically define minimum visibility level needed. Defaults
- * are different for different types (getters need to be public; setters can
- * have any access modifier, for example).
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonAutoDetect
-{
-    /**
-     * Enumeration for possible visibility thresholds (minimum visibility)
-     * that can be used to limit which methods (and fields) are
-     * auto-detected.
-     */
-    public enum Visibility {
-        /**
-         * Value that means that all kinds of access modifiers are acceptable,
-         * from private to public.
-         */
-        ANY,
-        /**
-         * Value that means that any other access modifier other than 'private'
-         * is considered auto-detectable.
-         */
-        NON_PRIVATE,
-        /**
-         * Value that means access modifiers 'protected' and 'public' are
-         * auto-detectable (and 'private' and "package access" == no modifiers
-         * are not)
-         */
-        PROTECTED_AND_PUBLIC,
-        /**
-         * Value to indicate that only 'public' access modifier is considered
-         * auto-detectable.
-         */
-        PUBLIC_ONLY,
-        /**
-         * Value that indicates that no access modifiers are auto-detectable:
-         * this can be used to explicitly disable auto-detection for specified
-         * types.
-         */
-        NONE,
-        
-        /**
-         * Value that indicates that default visibility level (whatever it is,
-         * depends on context) is to be used. This usually means that inherited
-         * value (from parent visibility settings) is to be used.
-         */
-        DEFAULT;
-
-        public boolean isVisible(Member m) {
-            switch (this) {
-            case ANY:
-                return true;
-            case NONE:
-                return false;
-            case NON_PRIVATE:
-                return !Modifier.isPrivate(m.getModifiers());
-            case PROTECTED_AND_PUBLIC:
-                if (Modifier.isProtected(m.getModifiers())) {
-                    return true;
-                }
-                // fall through to public case:
-            case PUBLIC_ONLY:
-                return Modifier.isPublic(m.getModifiers());
-            default:
-                return false;
-            }
-        }
-    }
-    
-    /**
-     * Minimum visibility required for auto-detecting regular getter methods.
-     */
-    Visibility getterVisibility() default Visibility.DEFAULT;
-
-    /**
-     * Minimum visibility required for auto-detecting is-getter methods.
-     */
-    Visibility isGetterVisibility() default Visibility.DEFAULT;
-    
-    /**
-     * Minimum visibility required for auto-detecting setter methods.
-     */    
-    Visibility setterVisibility() default Visibility.DEFAULT;
-
-    /**
-     * Minimum visibility required for auto-detecting Creator methods,
-     * except for no-argument constructors (which are always detected
-     * no matter what).
-     */
-    Visibility creatorVisibility() default Visibility.DEFAULT;
-
-    /**
-     * Minimum visibility required for auto-detecting member fields.
-     */ 
-    Visibility fieldVisibility() default Visibility.DEFAULT;
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonBackReference.java

@@ -1,39 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Annotation used to indicate that associated property is part of
- * two-way linkage between fields; and that its role is "child" (or "back") link.
- * Value type of the property must be a bean: it can not be a Collection, Map,
- * Array or enumeration.
- * Linkage is handled such that the property
- * annotated with this annotation is not serialized; and during deserialization,
- * its value is set to instance that has the "managed" (forward) link.
- *<p>
- * All references have logical name to allow handling multiple linkages; typical case
- * would be that where nodes have both parent/child and sibling linkages. If so,
- * pairs of references should be named differently.
- * It is an error for a class to have multiple back references with same name,
- * even if types pointed are different.
- *<p>
- * Note: only methods and fields can be annotated with this annotation: constructor
- * arguments should NOT be annotated, as they can not be either managed or back
- * references.
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.FIELD, ElementType.METHOD})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonBackReference
-{
-    /**
-     * Logical have for the reference property pair; used to link managed and
-     * back references. Default name can be used if there is just single
-     * reference pair (for example, node class that just has parent/child linkage,
-     * consisting of one managed reference and matching back reference)
-     */
-    public String value() default "defaultReference";
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonCreator.java

@@ -1,36 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Marker annotation that can be used to define constructors and factory
- * methods as one to use for instantiating new instances of the associated
- * class.
- *<p>
- * NOTE: when annotating creator methods (constructors, factory methods),
- * method must either be:
- *<ul>
- * <li>Single-argument constructor/factory method without {@link JsonProperty}
- *    annotation for the argument: if so, this is so-called "delegate creator",
- *    in which case Jackson first binds JSON into type of the argument, and
- *    then calls creator
- *   </li>
- * <li>Constructor/factory method where <b>every argument</b> is annotated with
- *   either {@link JsonProperty} or {@link JacksonInject}, to indicate name
- *   of property to bind to
- *  </li>
- * </ul>
- * Also note that all {@link JsonProperty} annotations MUST use actual name
- * (NOT empty String for "default"): this because Java bytecode does not
- * retain names of method or constructor arguments.
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonCreator
-{
-    // no values, since there's no property
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonFilter.java

@@ -1,33 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Annotation used to indicate which logical filter is to be used
- * for filtering out properties of type (class) annotated;
- * association made by this annotation declaring ids of filters,
- * and  <code>com.fr.third.fasterxml.jackson.databind.ObjectMapper</code> (or objects
- * it delegates to) providing matching filters by id.
- *<p>
- * Filters to use are usually of type
- * <code>com.fr.third.fasterxml.jackson.databind.ser.BeanPropertyFilter</code> and
- * are registered through <code>com.fr.third.fasterxml.jackson.databind.ObjectMapper</code>
- *<p>
- * Since 2.3, this annotation can also be used on properties (fields, methods,
- * constructor parameters).
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE,
-    ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER // new in 2.3
-})
-@Retention(RetentionPolicy.RUNTIME)
-@com.fr.third.fasterxml.jackson.annotation.JacksonAnnotation
-public @interface JsonFilter
-{
-    /**
-     * Id of filter to use; if empty String (""), no filter is to be used.
-     */
-    public String value();
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonFormat.java

@@ -1,252 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-import java.util.Locale;
-import java.util.TimeZone;
-
-/**
- * General-purpose annotation used for configuring details of how
- * values of properties are to be serialized.
- * Unlike most other Jackson annotations, annotation does not
- * have specific universal interpretation: instead, effect depends on datatype
- * of property being annotated (or more specifically, deserializer
- * and serializer being used).
- *<p>
- * Common uses include choosing between alternate representations -- for example,
- * whether {@link java.util.Date} is to be serialized as number (Java timestamp)
- * or String (such as ISO-8601 compatible time value) -- as well as configuring
- * exact details with {@link #pattern} property.
- *<p>
- * As of Jackson 2.1, known special handling include:
- *<ul>
- * <li>{@link java.util.Date}: Shape can  be {@link Shape#STRING} or {@link Shape#NUMBER};
- *    pattern may contain {@link java.text.SimpleDateFormat}-compatible pattern definition.
- *   </li>
- *</ul>
- * Jackson 2.1 added following new features:
- *<ul>
- * <li>Can now be used on Classes (types) as well, for modified default behavior, possibly
- *   overridden by per-property annotation
- *   </li>
- * <li>{@link java.lang.Enum}s: Shapes {@link Shape#STRING} and {@link Shape#NUMBER} can be
- *    used to change between numeric (index) and textual (name or <code>toString()</code>);
- *    but it is also possible to use {@link Shape#OBJECT} to serialize (but not deserialize)
- *    {@link java.lang.Enum}s as JSON Objects (as if they were POJOs). NOTE: serialization
- *     as JSON Object only works with class annotation; 
- *    will not work as per-property annotation.
- *   </li>
- * <li>{@link java.util.Collection}s can be serialized as (and deserialized from) JSON Objects,
- *    if {@link Shape#OBJECT} is used. NOTE: can ONLY be used as class annotation;
- *    will not work as per-property annotation.
- *   </li>
- *</ul>
- * 
- * @since 2.0
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER,
-    ElementType.TYPE})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonFormat
-{
-    /**
-     * Value that indicates that default {@link java.util.Locale}
-     * (from deserialization or serialization context) should be used:
-     * annotation does not define value to use.
-     */
-    public final static String DEFAULT_LOCALE = "##default";
-
-    /**
-     * Value that indicates that default {@link java.util.TimeZone}
-     * (from deserialization or serialization context) should be used:
-     * annotation does not define value to use.
-     */
-    public final static String DEFAULT_TIMEZONE = "##default";
-    
-    /**
-     * Datatype-specific additional piece of configuration that may be used
-     * to further refine formatting aspects. This may, for example, determine
-     * low-level format String used for {@link java.util.Date} serialization;
-     * however, exact use is determined by specific <code>JsonSerializer</code>
-     */
-    public String pattern() default "";
-
-    /**
-     * Structure to use for serialization: definition of mapping depends on datatype,
-     * but usually has straight-forward counterpart in data format (JSON).
-     * Note that commonly only a subset of shapes is available; and if 'invalid' value
-     * is chosen, defaults are usually used.
-     */
-    public Shape shape() default Shape.ANY;
-
-    /**
-     * {@link java.util.Locale} to use for serialization (if needed).
-     * Special value of {@link #DEFAULT_LOCALE}
-     * can be used to mean "just use the default", where default is specified
-     * by the serialization context, which in turn defaults to system
-     * defaults ({@link java.util.Locale#getDefault()}) unless explicitly
-     * set to another locale.
-     */
-    public String locale() default DEFAULT_LOCALE;
-    
-    /**
-     * {@link java.util.TimeZone} to use for serialization (if needed).
-     * Special value of {@link #DEFAULT_TIMEZONE}
-     * can be used to mean "just use the default", where default is specified
-     * by the serialization context, which in turn defaults to system
-     * defaults ({@link java.util.TimeZone#getDefault()}) unless explicitly
-     * set to another locale.
-     */
-    public String timezone() default DEFAULT_TIMEZONE;
-    
-    /*
-    /**********************************************************
-    /* Value enumeration(s), value class(es)
-    /**********************************************************
-     */
-
-    /**
-     * Value enumeration used for indicating preferred Shape; translates
-     * loosely to JSON types, with some extra values to indicate less precise
-     * choices (i.e. allowing one of multiple actual shapes)
-     */
-    public enum Shape
-    {
-        /**
-         * Marker enum value that indicates "default" (or "whatever") choice; needed
-         * since Annotations can not have null values for enums.
-         */
-        ANY,
-
-        /**
-         * Value that indicates shape should not be structural (that is, not
-         * {@link #ARRAY} or {@link #OBJECT}, but can be any other shape.
-         */
-        SCALAR,
-
-        /**
-         * Value that indicates that (JSON) Array type should be used.
-         */
-        ARRAY,
-        
-        /**
-         * Value that indicates that (JSON) Object type should be used.
-         */
-        OBJECT,
-
-        /**
-         * Value that indicates that a numeric (JSON) type should be used
-         * (but does not specify whether integer or floating-point representation
-         * should be used)
-         */
-        NUMBER,
-
-        /**
-         * Value that indicates that floating-point numeric type should be used
-         */
-        NUMBER_FLOAT,
-
-        /**
-         * Value that indicates that integer number type should be used
-         * (and not {@link #NUMBER_FLOAT}).
-         */
-        NUMBER_INT,
-
-        /**
-         * Value that indicates that (JSON) String type should be used.
-         */
-        STRING,
-        
-        /**
-         * Value that indicates that (JSON) boolean type
-         * (true, false) should be used.
-         */
-        BOOLEAN
-        ;
-
-        public boolean isNumeric() {
-            return (this == NUMBER) || (this == NUMBER_INT) || (this == NUMBER_FLOAT);
-        }
-
-        public boolean isStructured() {
-            return (this == OBJECT) || (this == ARRAY);
-        }
-    }
-
-    /**
-     * Helper class used to contain information from a single {@link JsonFormat}
-     * annotation.
-     */
-    public static class Value
-    {
-        private final String pattern;
-        private final Shape shape;
-        private final Locale locale;
-        private final TimeZone timezone;
-
-        public Value() {
-            this("", Shape.ANY, "", "");
-        }
-        
-        public Value(JsonFormat ann) {
-            this(ann.pattern(), ann.shape(), ann.locale(), ann.timezone());
-        }
-
-        public Value(String p, Shape sh, String localeStr, String tzStr)
-        {
-            this(p, sh
-                    ,(localeStr == null || localeStr.length() == 0 || DEFAULT_LOCALE.equals(localeStr)) ?
-                            null : new Locale(localeStr)
-                    ,(tzStr == null || tzStr.length() == 0 || DEFAULT_TIMEZONE.equals(tzStr)) ?
-                            null : TimeZone.getTimeZone(tzStr)
-            );
-        }
-
-        /**
-         * @since 2.1
-         */
-        public Value(String p, Shape sh, Locale l, TimeZone tz)
-        {
-            pattern = p;
-            shape = sh;
-            locale = l;
-            timezone = tz;
-        }
-
-        /**
-         * @since 2.1
-         */
-        public Value withPattern(String p) {
-            return new Value(p, shape, locale, timezone);
-        }
-
-        /**
-         * @since 2.1
-         */
-        public Value withShape(Shape s) {
-            return new Value(pattern, s, locale, timezone);
-        }
-
-        /**
-         * @since 2.1
-         */
-        public Value withLocale(Locale l) {
-            return new Value(pattern, shape, l, timezone);
-        }
-
-        /**
-         * @since 2.1
-         */
-        public Value withTimeZone(TimeZone tz) {
-            return new Value(pattern, shape, locale, tz);
-        }
-        
-        public String getPattern() { return pattern; }
-        public Shape getShape() { return shape; }
-        public Locale getLocale() { return locale; }
-        public TimeZone getTimeZone() { return timezone; }
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonGetter.java

@@ -1,33 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Marker annotation that can be used to define a non-static,
- * no-argument value-returning (non-void) method to be used as a "getter"
- * for a logical property.
- * It can be used as an alternative to more general
- * {@link JsonProperty} annotation (which is the recommended choice in
- * general case).
- *<p>
- * Getter means that when serializing Object instance of class that has
- * this method (possibly inherited from a super class), a call is made
- * through the method, and return value will be serialized as value of
- * the property.
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonGetter
-{
-    /**
-     * Defines name of the logical property this
-     * method is used to access ("get"); empty String means that
-     * name should be derived from the underlying method (using
-     * standard Bean name detection rules)
-     */
-    String value() default "";
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonIdentityInfo.java

@@ -1,75 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Annotation used for indicating that values of annotated type
- * or property should be serializing so that instances either
- * contain additional object identifier (in addition actual object
- * properties), or as a reference that consists of an object id
- * that refers to a full serialization. In practice this is done
- * by serializing the first instance as full object and object
- * identity, and other references to the object as reference values.
- *<p>
- * There are two main approaches to generating object identifier:
- * either using a generator (either one of standard ones, or a custom
- * generator), or using a value of a property. The latter case is
- * indicated by using a placeholder generator marker
- * {@link ObjectIdGenerators.PropertyGenerator}; former by using explicit generator.
- * Object id has to be serialized as a property in case of POJOs;
- * object identity is currently NOT support for JSON Array types
- * (Java arrays or Lists) or Java Map types.
- *<p>
- * Finally, note that generator type of {@link ObjectIdGenerators.None}
- * indicates that no Object Id should be included or used: it is included
- * to allow suppressing Object Ids using mix-in annotations.
- * 
- * @since 2.0
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE,
-    ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonIdentityInfo
-{
-    /**
-     * Name of JSON property in which Object Id will reside: also,
-     * if "from property" marker generator is used, identifies
-     * property that will be accessed to get type id.
-     * If a property is used, name must match its external
-     * name (one defined by annotation, or derived from accessor
-     * name as per Java Bean Introspection rules).
-     *<p>
-     * Default value is <code>@id</code>.
-     */
-    public String property() default "@id";
-
-    /**
-     * Generator to use for producing Object Identifier for objects:
-     * either one of pre-defined generators from
-     * {@link ObjectIdGenerator}, or a custom generator.
-     * Defined as class to instantiate.
-     *<p>
-     * Note that special type
-     * {@link ObjectIdGenerators.None}
-     * can be used to disable inclusion of Object Ids.
-     */
-    public Class<? extends ObjectIdGenerator<?>> generator();
-
-    /**
-     * Scope is used to define applicability of an Object Id: all ids
-     * must be unique within their scope; where scope is defined
-     * as combination of this value and generator type.
-     * Comparison is simple equivalence, meaning that both type
-     * generator type and scope class must be the same.
-     *<p>
-     * Scope is used for determining how many generators are needed;
-     * more than one scope is typically only needed if external Object Ids
-     * have overlapping value domains (i.e. are only unique within some
-     * limited scope)
-     */
-    public Class<?> scope() default Object.class;
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonIdentityReference.java

@@ -1,35 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Optional annotation that can be used for customizing details of a reference
- * to Objects for which "Object Identity" is enabled (see {@link JsonIdentityInfo}).
- * The main use case is that of enforcing use of Object Id even for the first
- * time an Object is referenced, instead of first instance being serialized
- * as full POJO.
- * 
- * @since 2.1
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE,
-    ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonIdentityReference
-{
-    /**
-     * Marker to indicate whether all referenced values are to
-     * be serialized as ids (true); or by serializing the
-     * first encountered reference as POJO and only then as id (false).
-     *<p>
-     * Note that if value of 'true' is used, deserialization may require
-     * additional contextual information, and possibly using a custom
-     * id resolver -- the default handling may not be sufficient.
-     * 
-     * @since 2.1
-     */
-    public boolean alwaysAsId() default false;
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonIgnore.java

@@ -1,58 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Marker annotation that indicates that the annotated method or field is to be
- * ignored by introspection-based
- * serialization and deserialization functionality. That is, it should
- * not be consider a "getter", "setter" or "creator".
- *<p>
- * In addition, starting with Jackson 1.9, if this is the only annotation
- * associated with a property, it will also cause cause the whole
- * property to be ignored: that is, if setter has this annotation and
- * getter has no annotations, getter is also effectively ignored.
- * It is still possible for different accessors to use different
- * annotations; so if only "getter" is to be ignored, other accessors
- * (setter or field) would need explicit annotation to prevent
- * ignoral (usually {@link JsonProperty}).
- * <p>
- * For example, a "getter" method that would otherwise denote
- * a property (like, say, "getValue" to suggest property "value")
- * to serialize, would be ignored and no such property would
- * be output unless another annotation defines alternative method to use.
- *<p>
- * Before version 1.9, this annotation worked purely on method-by-method (or field-by-field)
- * basis; annotation on one method or field did not imply ignoring other methods
- * or fields. However, with version 1.9 and above, annotations associated
- * with various accessors (getter, setter, field, constructor parameter) of
- * a logical property are combined; meaning that annotations in one (say, setter)
- * can have effects on all of them (if getter or field has nothing indicating
- * otherwise).
- *<p>
- * Annotation is usually used just a like a marker annotation, that
- * is, without explicitly defining 'value' argument (which defaults
- * to <code>true</code>): but argument can be explicitly defined.
- * This can be done to override an existing JsonIgnore by explicitly
- * defining one with 'false' argument.
- *<p>
- * Annotation is similar to {@link javax.xml.bind.annotation.XmlTransient} 
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.FIELD})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonIgnore
-{
-    /**
-     * Optional argument that defines whether this annotation is active
-     * or not. The only use for value 'false' if for overriding purposes
-     * (which is not needed often); most likely it is needed for use
-     * with "mix-in annotations" (aka "annotation overrides").
-     * For most cases, however, default value of "true" is just fine
-     * and should be omitted.
-     */
-    boolean value() default true;
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonIgnoreProperties.java

@@ -1,51 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Annotation that can be used to either suppress serialization of
- * properties (during serialization), or ignore processing of
- * JSON properties read (during deserialization).
- *<p>
- * Example:
- *<pre>
- * // to prevent specified fields from being serialized or deserialized
- * // (i.e. not include in JSON output; or being set even if they were included)
- * &#064;JsonIgnoreProperties({ "internalId", "secretKey" })
- * // To ignore any unknown properties in JSON input without exception:
- * &#064;JsonIgnoreProperties(ignoreUnknown=true)
- *</pre>
- *<p>
- * Starting with 2.0, this annotation can be applied both to classes and
- * to properties. If used for both, actual set will be union of all
- * ignorals: that is, you can only add properties to ignore, not remove
- * or override. So you can not remove properties to ignore using
- * per-property annotation.
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE,
-    ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.FIELD})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonIgnoreProperties
-{
-    /**
-     * Names of properties to ignore.
-     */
-    public String[] value() default { };
-
-    /**
-     * Property that defines whether it is ok to just ignore any
-     * unrecognized properties during deserialization.
-     * If true, all properties that are unrecognized -- that is,
-     * there are no setters or creators that accept them -- are
-     * ignored without warnings (although handlers for unknown
-     * properties, if any, will still be called) without
-     * exception.
-     *<p>
-     * Does not have any effect on serialization.
-     */
-    public boolean ignoreUnknown() default false;
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonIgnoreType.java

@@ -1,31 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Marker annotation that indicates that all properties of annotated
- * type are to be ignored during serialization and deserialization.
- *<p>
- * Note: annotation does have boolean 'value' property (which defaults
- * to 'true'), so that it is actually possible to override value
- * using mix-in annotations.
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonIgnoreType
-{
-    /**
-     * Optional argument that defines whether this annotation is active
-     * or not. The only use for value 'false' if for overriding purposes
-     * (which is not needed often); most likely it is needed for use
-     * with "mix-in annotations" ("annotation overrides").
-     * For most cases, however, default value of "true" is just fine
-     * and should be omitted.
-     */
-    boolean value() default true;
-
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonInclude.java

@@ -1,96 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Annotation used to indicate when value of the annotated property (when
- * used for a field, method or constructor parameter), or all 
- * properties of the annotated class, is to be serialized.
- * Without annotation property values are always included, but by using
- * this annotation one can specify simple exclusion rules to reduce
- * amount of properties to write out.
- * 
- * @since 2.0
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.FIELD,
-    ElementType.TYPE, ElementType.PARAMETER})
-@Retention(RetentionPolicy.RUNTIME)
-@com.fr.third.fasterxml.jackson.annotation.JacksonAnnotation
-public @interface JsonInclude
-{
-    /**
-     * Inclusion rule to use.
-     */
-    public Include value() default Include.ALWAYS;
-    
-    /*
-    /**********************************************************
-    /* Value enumerations needed
-    /**********************************************************
-     */
-
-    /**
-     * Enumeration used with {@link JsonInclude}
-     * to define which properties
-     * of Java Beans are to be included in serialization.
-     *<p>
-     * Note: Jackson 1.x had similarly named ("Inclusion") enumeration included
-     * in <code>JsonSerialize</code> annotation: it is not deprecated
-     * and this value used instead.
-     */
-    public enum Include
-    {
-        /**
-         * Value that indicates that property is to be always included,
-         * independent of value of the property.
-         */
-        ALWAYS,
-
-        /**
-         * Value that indicates that only properties with non-null
-         * values are to be included.
-         */
-        NON_NULL,
-
-        /**
-         * Value that indicates that only properties that have values
-         * that differ from default settings (meaning values they have
-         * when Bean is constructed with its no-arguments constructor)
-         * are to be included. Value is generally not useful with
-         * {@link java.util.Map}s, since they have no default values;
-         * and if used, works same as {@link #ALWAYS}.
-         */
-        NON_DEFAULT,
-
-        /**
-         * Value that indicates that only properties that have values
-         * that values that are null or what is considered empty are
-         * not to be included.
-         *<p>
-         * Default emptiness is defined for following type:
-         *<ul>
-         * <li>For {@link java.util.Collection}s and {@link java.util.Map}s,
-         *    method <code>isEmpty()</code> is called;
-         *   </li>
-         * <li>For Java arrays, empty arrays are ones with length of 0
-         *   </li>
-         * <li>For Java {@link java.lang.String}s, <code>length()</code> is called,
-         *   and return value of 0 indicates empty String (note that <code>String.isEmpty()</code>
-         *   was added in Java 1.6 and as such can not be used by Jackson
-         *   </li>
-         * <ul>
-         *  and for other types, non-null values are to be included.
-         *<p>
-         * Note that this default handling can be overridden by custom
-         * <code>JsonSerializer</code> implementation: if method <code>isEmpty()</code>
-         * is overridden, it will be called to see if non-null values are
-         * considered empty (null is always considered empty).
-         */
-        NON_EMPTY
-        ;
-    }
-
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonManagedReference.java

@@ -1,41 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Annotation used to indicate that annotated property is part of
- * two-way linkage between fields; and that its role is "parent" (or "forward") link.
- * Value type (class) of property must have a single compatible property annotated with
- * {@link JsonBackReference}. Linkage is handled such that the property
- * annotated with this annotation is handled normally (serialized normally, no
- * special handling for deserialization); it is the matching back reference
- * that requires special handling
- *<p>
- * All references have logical name to allow handling multiple linkages; typical case
- * would be that where nodes have both parent/child and sibling linkages. If so,
- * pairs of references should be named differently.
- * It is an error for a class too have multiple managed references with same name,
- * even if types pointed are different.
- *<p>
- * Note: only methods and fields can be annotated with this annotation: constructor
- * arguments should NOT be annotated, as they can not be either managed or back
- * references.
- * 
- * @author tatu
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.FIELD, ElementType.METHOD})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonManagedReference
-{
-    /**
-     * Logical have for the reference property pair; used to link managed and
-     * back references. Default name can be used if there is just single
-     * reference pair (for example, node class that just has parent/child linkage,
-     * consisting of one managed reference and matching back reference)
-     */
-    public String value() default "defaultReference";
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonProperty.java

@@ -1,67 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Marker annotation that can be used to define a non-static
- * method as a "setter" or "getter" for a logical property
- * (depending on its signature),
- * or non-static object field to be used (serialized, deserialized) as
- * a logical property.
- *<p>
- * Default value ("") indicates that the field name is used
- * as the property name without any modifications, but it
- * can be specified to non-empty value to specify different
- * name. Property name refers to name used externally, as
- * the field name in JSON objects.
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonProperty
-{
-    /**
-     * Special value that indicates that handlers should use the default
-     * name (derived from method or field name) for property.
-     * 
-     * @since 2.1
-     */
-    public final static String USE_DEFAULT_NAME = "";
-
-    /**
-     * Defines name of the logical property, i.e. JSON object field
-     * name to use for the property. If value is empty String (which is the
-     * default), will try to use name of the field that is annotated.
-     * Note that there is
-     * <b>no default name available for constructor arguments</b>,
-     * meaning that
-     * <b>Empty String is not a valid value for constructor arguments</b>.
-     */
-    String value() default USE_DEFAULT_NAME;
-
-    /**
-     * Property that indicates whether a value (which may be explicit
-     * null) is expected for property during deserialization or not.
-     * If expected, <code>BeanDeserialized</code> should indicate
-     * this as a validity problem (usually by throwing an exception,
-     * but this may be sent via problem handlers that can try to
-     * rectify the problem, for example, by supplying a default
-     * value).
-     *<p>
-     * Note that as of 2.0, this property is NOT used by
-     * <code>BeanDeserializer</code>: support is expected to be
-     * added for a later minor version.
-     * 
-     * @since 2.0
-     */
-    boolean required() default false;
-
-    /* NOTE: considering of adding ability to specify default
-     * String value -- would work well for scalar types, most of
-     * which can coerce from Strings. But won't add for 2.0 yet.
-     */
-    //String defaultValue() default "";
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonPropertyDescription.java

@@ -1,25 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Annotaion used to define a human readable description for a logical
- * property.
- * Currently used to populate the description field in generated JSON
- * Schemas.
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonPropertyDescription
-{
-    /**
-     * Defines a human readable description of the logical property.
-     * Currently used to populate the description field in generated JSON
-     * Schemas.
-     */
-    String value() default "";
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonPropertyOrder.java

@@ -1,46 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Annotation that can be used to define ordering (possibly partial) to use
- * when serializing object properties. Properties included in annotation
- * declaration will be serialized first (in defined order), followed by
- * any properties not included in the definition.
- * Annotation definition will override any implicit orderings (such as
- * guarantee that Creator-properties are serialized before non-creator
- * properties)
- *<p>
- * Examples:
- *<pre>
- *  // ensure that "id" and "name" are output before other properties
- *  <div>@</div>JsonPropertyOrder({ "id", "name" })
- *  // order any properties that don't have explicit setting using alphabetic order
- *  <div>@</div>JsonPropertyOrder(alphabetic=true)
- *</pre>
- *<p>
- * This annotation may or may not have effect on deserialization: for basic JSON
- * handling there is no effect, but for other supported data types (or structural
- * conventions) there may be.
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonPropertyOrder
-{
-    /**
-     * Order in which properties of annotated object are to be serialized in.
-     */
-    public String[] value() default { };
-
-    /**
-     * Property that defines what to do regarding ordering of properties
-     * not explicitly included in annotation instance. If set to true,
-     * they will be alphabetically ordered; if false, order is
-     * undefined (default setting)
-     */
-    public boolean alphabetic() default false;
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonRawValue.java

@@ -1,31 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Marker annotation that indicates that the annotated method
- * or field should be serialized by including literal String value
- * of the property as is, without quoting of characters.
- * This can be useful for injecting values already serialized in JSON or 
- * passing javascript function definitions from server to a javascript client.
- *<p>
- * Warning: the resulting JSON stream may be invalid depending on your input value.
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.FIELD })
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonRawValue
-{
-    /**
-     * Optional argument that defines whether this annotation is active
-     * or not. The only use for value 'false' if for overriding purposes
-     * (which is not needed often); most likely it is needed for use
-     * with "mix-in annotations" (aka "annotation overrides").
-     * For most cases, however, default value of "true" is just fine
-     * and should be omitted.
-     */
-    boolean value() default true;
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonRootName.java

@@ -1,25 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Annotation similar to {@link javax.xml.bind.annotation.XmlRootElement},
- * used to indicate name to use for root-level wrapping, if wrapping is
- * enabled. Annotation itself does not indicate that wrapping should
- * be used; but if it is, name used for serialization should be name
- * specified here, and deserializer will expect the name as well.
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE})
-@Retention(RetentionPolicy.RUNTIME)
-@com.fr.third.fasterxml.jackson.annotation.JacksonAnnotation
-public @interface JsonRootName
-{
-    /**
-     * Root name to use if root-level wrapping is enabled.
-     */
-    public String value();
-
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonSetter.java

@@ -1,33 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Marker annotation that can be used to define a non-static,
- * single-argument method to be used as a "setter" for a logical property
- * as an alternative to recommended
- * {@link JsonProperty} annotation (which was introduced in version 1.1).
- *<p>
- * Setter means that when a property with matching name is encountered in
- * JSON content, this method will be used to set value of the property.
- *<p>
- * NOTE: this annotation was briefly deprecated for version 1.5; but has
- * since been un-deprecated to both allow for asymmetric naming (possibly
- * different name when reading and writing JSON), and more importantly to
- * allow multi-argument setter method in future.
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonSetter
-{
-    /**
-     * Optional default argument that defines logical property this
-     * method is used to modify ("set"); this is the property
-     * name used in JSON content.
-     */
-    String value() default "";
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonSubTypes.java

@@ -1,43 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Annotation used with {@link JsonTypeInfo} to indicate sub types of serializable
- * polymorphic types, and to associate logical names used within JSON content
- * (which is more portable than using physical Java class names).
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE, ElementType.FIELD,
-    ElementType.METHOD, ElementType.PARAMETER})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonSubTypes {
-    /**
-     * Subtypes of the annotated type (annotated class, or property value type
-     * associated with the annotated method). These will be checked recursively
-     * so that types can be defined by only including direct subtypes.
-     */
-    public Type[] value();
-
-    /**
-     * Definition of a subtype, along with optional name. If name is missing, class
-     * of the type will be checked for {@link JsonTypeName} annotation; and if that
-     * is also missing or empty, a default
-     * name will be constructed by type id mechanism.
-     * Default name is usually based on class name.
-     */
-    public @interface Type {
-        /**
-         * Class of the subtype
-         */
-        public Class<?> value();
-
-        /**
-         * Logical type name used as the type identifier for the class
-         */
-        public String name() default "";
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonTypeId.java

@@ -1,37 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Marker annotation that can be used on a property accessor
- * (field, getter or setter, constructor parameter) to indicate that
- * the property is to contain type id to use when including
- * polymorphic type information.
- * Annotation should <b>only be used</b> if the intent is to override
- * generation of standard type id: if so, value of the property will be
- * accessed during serialization and used as the type id.
- *<p>
- * On deserialization annotation has no effect, as visibility of type id
- * is governed by value of {@link JsonTypeInfo#visible}; properties with
- * this annotation get no special handling.
- *<p>
- * On serialization, this annotation will exclude property from being
- * serialized along other properties; instead, its value is serialized
- * as the type identifier. Since type identifier may be included in
- * various places, it may still appear like 'normal' property (when using
- * {@link JsonTypeInfo.As#PROPERTY}), but is more commonly embedded
- * in a different place, as per inclusion rules (see {@link JsonTypeInfo}
- * for details).
- * 
- * @since 2.0
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonTypeId
-{
-
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonTypeInfo.java

@@ -1,277 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.*;
-
-/**
- * Annotation used for configuring details of if and how type information is
- * used with JSON serialization and deserialization, to preserve information
- * about actual class of Object instances. This is necessarily for polymorphic
- * types, and may also be needed to link abstract declared types and matching
- * concrete implementation.
- *<p>
- * Some examples of typical annotations:
- *<pre>
- *  // Include Java class name ("com.myempl.ImplClass") as JSON property "class"
- *  &#064;JsonTypeInfo(use=Id.CLASS, include=As.PROPERTY, property="class")
- *  
- *  // Include logical type name (defined in impl classes) as wrapper; 2 annotations
- *  &#064;JsonTypeInfo(use=Id.NAME, include=As.WRAPPER_OBJECT)
- *  &#064;JsonSubTypes({com.myemp.Impl1.class, com.myempl.Impl2.class})
- *</pre>
- * Alternatively you can also define fully customized type handling by using
- * <code>&#064;JsonTypeResolver</code> annotation (from databind package).
- *<p>
- * This annotation can be used both for types (classes) and properties.
- * If both exist, annotation on property has precedence, as it is
- * considered more specific.
- *<p>
- * When used for properties (fields, methods), this annotation applies
- * to <b>values</b>: so when applied to structure types
- * (like {@link java.util.Collection}, {@link java.util.Map}, arrays),
- * will apply to contained values, not the container;
- * for non-structured types there is no difference.
- * This is identical to how JAXB handles type information
- * annotations; and is chosen since it is the dominant use case.
- * There is no per-property way to force type information to be included
- * for type of container (structured type); for container types one has
- * to use annotation for type declaration.
- *<p>
- * Note on visibility of type identifier: by default, deserialization
- * (use during reading of JSON) of type identifier
- * is completely handled by Jackson, and is <b>not passed to</b>
- * deserializers. However, if so desired,
- * it is possible to define property <code>visible = true</code>
- * in which case property will be passed as-is to deserializers
- * (and set via setter or field) on deserialization.
- *<p>
- * On serialization side, Jackson will generate type id by itself,
- * except if there is a property with name that matches
- * {@link #property()}, in which case value of that property is
- * used instead.
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE,
-    ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonTypeInfo
-{    
-    /*
-    /**********************************************************
-    /* Value enumerations used for properties
-    /**********************************************************
-     */
-    
-    /**
-     * Definition of different type identifiers that can be included in JSON
-     * during serialization, and used for deserialization.
-     */
-    public enum Id {
-        /**
-         * This means that no explicit type metadata is included, and typing is
-         * purely done using contextual information possibly augmented with other
-         * annotations.
-         */
-        NONE(null),
-
-        /**
-         * Means that fully-qualified Java class name is used as the type identifier.
-         */
-        CLASS("@class"),
-
-        /**
-         * Means that Java class name with minimal path is used as the type identifier.
-         * Minimal means that only the class name, and that part of preceding Java
-         * package name is included that is needed to construct fully-qualified name
-         * given fully-qualified name of the declared supertype; additionally a single
-         * leading dot ('.') must be used to indicate that partial class name is used.
-         * For example, for supertype "com.foobar.Base", and concrete type
-         * "com.foo.Impl", only ".Impl" would be included; and for "com.foo.impl.Impl2"
-         * only ".impl.Impl2" would be included.<br />
-         * <b>NOTE</b>: leading dot ('.') MUST be used to denote partial (minimal) name;
-         * if it is missing, value is assumed to be fully-qualified name. Fully-qualified
-         * name is used in cases where subtypes are not in same package (or sub-package
-         * thereof) as base class.
-         *<p>
-         * If all related classes are in the same Java package, this option can reduce
-         * amount of type information overhead, especially for small types.
-         * However, please note that using this alternative is inherently risky since it
-         * assumes that the
-         * supertype can be reliably detected. Given that it is based on declared type
-         * (since ultimate supertype, <code>java.lang.Object</code> would not be very
-         * useful reference point), this may not always work as expected.
-         */
-        MINIMAL_CLASS("@c"),
-
-        /**
-         * Means that logical type name is used as type information; name will then need
-         * to be separately resolved to actual concrete type (Class).
-         */
-        NAME("@type"),
-
-        /**
-         * Means that typing mechanism uses customized handling, with possibly
-         * custom configuration. This means that semantics of other properties is
-         * not defined by Jackson package, but by the custom implementation.
-         */
-        CUSTOM(null)
-        ;
-
-        private final String _defaultPropertyName;
-
-        private Id(String defProp) {
-            _defaultPropertyName = defProp;
-        }
-
-        public String getDefaultPropertyName() { return _defaultPropertyName; }
-    }
-
-    /**
-     * Definition of standard type inclusion mechanisms for type metadata.
-     * Used for standard metadata types, except for {@link Id#NONE}.
-     * May or may not be used for custom types ({@link Id#CUSTOM}).
-     */
-    public enum As {
-        /**
-         * Inclusion mechanism that uses a single configurable property, included
-         * along with actual data (POJO properties) as a separate meta-property.
-         * <p>
-         * Default choice for inclusion.
-         */
-        PROPERTY,
-
-        /**
-         * Inclusion mechanism that wraps typed JSON value (POJO
-         * serialized as JSON) in
-         * a JSON Object that has a single entry,
-         * where field name is serialized type identifier,
-         * and value is the actual JSON value.
-         *<p>
-         * Note: can only be used if type information can be serialized as
-         * String. This is true for standard type metadata types, but not
-         * necessarily for custom types.
-         */
-        WRAPPER_OBJECT,
-
-        /**
-         * Inclusion mechanism that wraps typed JSON value (POJO
-         * serialized as JSON) in
-         * a 2-element JSON array: first element is the serialized
-         * type identifier, and second element the serialized POJO
-         * as JSON Object.
-         */
-        WRAPPER_ARRAY,
-
-        /**
-         * Inclusion mechanism similar to <code>PROPERTY</code>, except that
-         * property is included one-level higher in hierarchy, i.e. as sibling
-         * property at same level as JSON Object to type.
-         * Note that this choice <b>can only be used for properties</b>, not
-         * for types (classes). Trying to use it for classes will result in
-         * inclusion strategy of basic <code>PROPERTY</code> instead.
-         */
-        EXTERNAL_PROPERTY,
-
-        /**
-         * Inclusion mechanism similar to <code>PROPERTY</code> with respect
-         * to deserialization; but one that is produced by a "regular" accessible
-         * property during serialization. This means that <code>TypeSerializer</code>
-         * will do nothing, and expect a property with defined name to be output
-         * using some other mechanism (like default POJO property serialization, or
-         * custom serializer).
-         *<p>
-         * Note that this behavior is quite similar to that of using {@link JsonTypeId};
-         * except that here <code>TypeSerializer</code> is basically suppressed;
-         * whereas with {@link JsonTypeId}, output of regular property is suppressed.
-         * This mostly matters with respect to output order; this choice is the only
-         * way to ensure specific placement of type id during serialization.
-         * 
-         * @since 2.3.0
-         */
-        EXISTING_PROPERTY
-        ;
-    }
-    
-    /*
-    /**********************************************************
-    /* Annotation properties
-    /**********************************************************
-     */
-    
-    /**
-     * What kind of type metadata is to be used for serializing and deserializing
-     * type information for instances of annotated type (and its subtypes
-     * unless overridden)
-     */
-    public Id use();    
-    
-    /**
-     * What mechanism is used for including type metadata (if any; for
-     * {@link Id#NONE} nothing is included). Default
-     *<p>
-     * Note that for type metadata type of {@link Id#CUSTOM},
-     * this setting may or may not have any effect.
-     */
-    public As include() default As.PROPERTY;
-
-    /**
-     * Property names used when type inclusion method ({@link As#PROPERTY}) is used
-     * (or possibly when using type metadata of type {@link Id#CUSTOM}).
-     * If POJO itself has a property with same name, value of property
-     * will be set with type id metadata: if no such property exists, type id
-     * is only used for determining actual type.
-     *<p>
-     * Default property name used if this property is not explicitly defined
-     * (or is set to empty String) is based on
-     * type metadata type ({@link #use}) used.
-     */
-    public String property() default "";
-
-    /**
-     * Optional property that can be used to specify default implementation
-     * class to use if type identifier is either not present, or can not
-     * be mapped to a registered type (which can occur for ids, but not when
-     * specifying explicit class to use).
-     *<p>
-     * Note that while this property allows specification of the default
-     * implementation to use, it does not help with structural issues that
-     * may arise if type information is missing. This means that most often
-     * this is used with type-name -based resolution, to cover cases
-     * where new sub-types are added, but base type is not changed to
-     * reference new sub-types.
-     *<p>
-     * There are certain special values that indicate alternate behavior:
-     *<ul>
-     * <li>{@link None} means "there is no default implementation" (in which
-     *   case an error results from unmappable type)
-     * <li><code>com.fr.third.fasterxml.jackson.databind.annotation.NoClass</code> means that
-     *   objects with unmappable (or missing) type are to be mapped to null references.
-     * </ul>
-     */
-    public Class<?> defaultImpl() default None.class;
-
-    /**
-     * Property that defines whether type identifier value will be passed
-     * as part of JSON stream to deserializer (true), or handled and
-     * removed by <code>TypeDeserializer</code> (false).
-     *<p>
-     * Default value is false, meaning that Jackson handles and removes
-     * the type identifier from JSON content that is passed to
-     * <code>JsonDeserializer</code>.
-     * 
-     * @since 2.0
-     */
-    public boolean visible() default false;
-    
-    /*
-    /**********************************************************
-    /* Helper classes
-    /**********************************************************
-     */
-
-    /**
-     * This marker class that is only to be used with <code>defaultImpl</code>
-     * annotation property, to indicate that there is no default implementation
-     * specified.
-     */
-    public abstract static class None { }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonTypeName.java

@@ -1,26 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-
-/**
- * Annotation used for binding logical name that the annotated class
- * has. Used with {@link JsonTypeInfo} (and specifically its
- * {@link JsonTypeInfo#use} property) to establish relationship
- * between type names and types.
- * 
- * @author tatu
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonTypeName {
-    /**
-     * Logical type name for annotated type. If missing (or defined as Empty String),
-     * defaults to using non-qualified class name as the type.
-     */
-    public String value() default "";
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonUnwrapped.java

@@ -1,89 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Annotation used to indicate that a property should be serialized
- * "unwrapped"; that is, if it would be serialized as JSON Object, its
- * properties are instead included as properties of its containing
- * Object. For example, consider case of POJO like:
- * 
- *<pre>
- *  public class Parent {
- *    public int age;
- *    public Name name;
- *  }
- *  public class Name {
- *    public String first, last;
- *  }
- *</pre>  
- * which would normally be serialized as follows (assuming @JsonUnwrapped
- * had no effect):
- *<pre>
- *  {
- *    "age" : 18,
- *    "name" : {
- *      "first" : "Joey",
- *      "last" : "Sixpack"
- *    }
- *  }
- *</pre>
- * can be changed to this:
- *<pre>
- *  {
- *    "age" : 18,
- *    "first" : "Joey",
- *    "last" : "Sixpack"
- *  }
- *</pre>
- * by changing Parent class to:
- *<pre>
- *  public class Parent {
- *    public int age;
- *    &#064;JsonUnwrapped
- *    public Name name;
- *  }
- *</pre>
- * Annotation can only be added to properties, and not classes, as it is contextual.
- *<p>
- * Also note that annotation only applies if
- *<ul>
- * <li>Value is serialized as JSON Object (can not unwrap JSON arrays using this
- *   mechanism)
- *   </li>
- * <li>Serialization is done using <code>BeanSerializer</code>, not a custom serializer
- *   </li>
- * <li>No type information is added; if type information needs to be added, structure can
- *   not be altered regardless of inclusion strategy; so annotation is basically ignored.
- *   </li>
- * </ul>
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonUnwrapped
-{
-    /**
-     * Property that is usually only used when overriding (masking) annotations,
-     * using mix-in annotations. Otherwise default value of 'true' is fine, and
-     * value need not be explicitly included.
-     */
-    boolean enabled() default true;
-
-    /**
-     * Optional property that can be used to add prefix String to use in front
-     * of names of properties that are unwrapped: this can be done for example to prevent
-     * name collisions.
-     */
-    String prefix() default "";
-
-    /**
-     * Optional property that can be used to add suffix String to append at the end
-     * of names of properties that are unwrapped: this can be done for example to prevent
-     * name collisions.
-     */
-    String suffix() default "";
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonValue.java

@@ -1,54 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Marker annotation similar to
- * {@link javax.xml.bind.annotation.XmlValue} 
- * that indicates that results of the annotated "getter" method
- * (which means signature must be that of getters; non-void return
- * type, no args) is to be used as the single value to serialize
- * for the instance. Usually value will be of a simple scalar type
- * (String or Number), but it can be any serializable type (Collection,
- * Map or Bean).
- *<p>
- * At most one method of a <code>Class</code> can be annotated with this annotation;
- * if more than one is found, an exception may be thrown.
- * Also, if method signature is not compatible with Getters, an exception
- * may be thrown (whether exception is thrown or not is an implementation detail (due
- * to filtering during introspection, some annotations may be skipped)
- * and applications should not rely on specific behavior).
- *<p>
- * A typical usage is that of annotating <code>toString()</code>
- * method so that returned String value is used as the JSON serialization;
- * and if deserialization is needed, there is matching constructor
- * or factory method annotated with {@link JsonCreator} annotation.
- *<p>
- * Boolean argument is only used so that sub-classes can "disable"
- * annotation if necessary.
- *<p>
- * NOTE: when use for Java <code>enum</code>s, one additional feature is
- * that value returned by annotated method is also considered to be the
- * value to deserialize from, not just JSON String to serialize as.
- * This is possible since set of Enum values is constant and it is possible
- * to define mapping, but can not be done in general for POJO types; as such,
- * this is not used for POJO deserialization.
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonValue
-{
-    /**
-     * Optional argument that defines whether this annotation is active
-     * or not. The only use for value 'false' if for overriding purposes.
-     * Overriding may be necessary when used
-     * with "mix-in annotations" (aka "annotation overrides").
-     * For most cases, however, default value of "true" is just fine
-     * and should be omitted.
-     */
-    boolean value() default true;
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/JsonView.java

@@ -1,34 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import com.fr.third.fasterxml.jackson.annotation.JacksonAnnotation;
-
-/**
- * Annotation used for indicating view(s) that the property
- * that is defined by method or field annotated is part of.
- *<p>
- * An example annotation would be:
- *<pre>
- *  &#064;JsonView(BasicView.class)
- *</pre>
- * which would specify that property annotated would be included
- * when processing (serializing, deserializing) View identified
- * by <code>BasicView.class</code> (or its sub-class).
- * If multiple View class identifiers are included, property will
- * be part of all of them.
- */
-@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.FIELD})
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonView {
-    /**
-     * View or views that annotated element is part of. Views are identified
-     * by classes, and use expected class inheritance relationship: child
-     * views contain all elements parent views have, for example.
-     */
-    public Class<?>[] value() default { };
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/ObjectIdGenerator.java

@@ -1,145 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-/**
- * Definition of API used for constructing Object Identifiers
- * (as annotated using {@link JsonIdentityInfo}).
- * Also defines factory methods used for creating instances
- * for serialization, deserialization.
- *
- * @param <T> Type of Object Identifiers produced.
- */
-@SuppressWarnings("serial")
-public abstract class ObjectIdGenerator<T>
-    implements java.io.Serializable
-{
-    /*
-    /**********************************************************
-    /* Accessors
-    /**********************************************************
-     */
-
-    public abstract Class<?> getScope();
-
-    /**
-     * Method called to check whether this generator instance can
-     * be used for Object Ids of specific generator type and
-     * scope; determination is based by passing a configured
-     * "blueprint" (prototype) instance; from which the actual
-     * instances are created (using {@link #newForSerialization}).
-     * 
-     * @return True if this instance can be used as-is; false if not
-     */
-    public abstract boolean canUseFor(ObjectIdGenerator<?> gen);
-    
-    /*
-    /**********************************************************
-    /* Factory methods
-    /**********************************************************
-     */
-    
-    /**
-     * Factory method to create a blueprint instance for specified
-     * scope. Generators that do not use scope may return 'this'.
-     */
-    public abstract ObjectIdGenerator<T> forScope(Class<?> scope);
-    
-    /**
-     * Factory method called to create a new instance to use for
-     * serialization: needed since generators may have state
-     * (next id to produce).
-     *<p>
-     * Note that actual type of 'context' is
-     * <code>com.fr.third.fasterxml.jackson.databind.SerializerProvider</code>,
-     * but can not be declared here as type itself (as well as call
-     * to this object) comes from databind package.
-     * 
-     * @param context Serialization context object used (of type
-     *    <code>com.fr.third.fasterxml.jackson.databind.SerializerProvider</code>;
-     *    may be needed by more complex generators to access contextual
-     *    information such as configuration.
-     */
-    public abstract ObjectIdGenerator<T> newForSerialization(Object context);
-
-    /**
-     * Method for constructing key to use for ObjectId-to-POJO maps.
-     */
-    public abstract IdKey key(Object key);
-    
-    /*
-    /**********************************************************
-    /* Methods for serialization
-    /**********************************************************
-     */
-    
-    /**
-     * Method used for generating a new Object Identifier to serialize
-     * for given POJO.
-     * 
-     * @param forPojo POJO for which identifier is needed
-     * 
-     * @return Object Identifier to use.
-     */
-    public abstract T generateId(Object forPojo);
-
-    /*
-    /**********************************************************
-    /* Helper classes
-    /**********************************************************
-     */
-
-    /**
-     * Simple key class that can be used as a key for
-     * ObjectId-to-POJO mappings, when multiple ObjectId types
-     * and scopes are used.
-     */
-    public final static class IdKey
-        implements java.io.Serializable
-    {
-        private static final long serialVersionUID = 1L;
-
-        /**
-         * Type of {@link ObjectIdGenerator} used for generating Object Id
-         */
-        private final Class<?> type;
-
-        /**
-         * Scope of the Object Id (may be null, to denote global)
-         */
-        private final Class<?> scope;
-
-        /**
-         * Object for which Object Id was generated: can NOT be null.
-         */
-        private final Object key;
-
-        /**
-         * Hash code
-         */
-        private final int hashCode;
-        
-        public IdKey(Class<?> type, Class<?> scope, Object key) {
-            this.type = type;
-            this.scope = scope;
-            this.key = key;
-            
-            int h = key.hashCode() + type.getName().hashCode();
-            if (scope != null) {
-                h ^= scope.getName().hashCode();
-            }
-            hashCode = h;
-        }
-
-        @Override
-        public int hashCode() { return hashCode; }
-
-        @Override
-        public boolean equals(Object o)
-        {
-            if (o == this) return true;
-            if (o == null) return false;
-            if (o.getClass() != getClass()) return false;
-            IdKey other = (IdKey) o;
-            return (other.key.equals(key)) && (other.type == type) && (other.scope == scope);
-        }
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/ObjectIdGenerators.java

@@ -1,164 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-import java.util.UUID;
-
-/**
- * Container class for standard {@link ObjectIdGenerator} implementations.
- */
-public class ObjectIdGenerators
-{
-    /*
-    /**********************************************************
-    /* Shared base class for concrete implementations
-    /**********************************************************
-     */
-
-    /**
-     * Helper class for implementations contained.
-     */
-    @SuppressWarnings("serial")
-    private abstract static class Base<T> extends ObjectIdGenerator<T>
-    {
-        protected final Class<?> _scope;
-
-        protected Base(Class<?> scope) {
-            _scope = scope;
-        }
-
-        @Override
-        public final Class<?> getScope() {
-            return _scope;
-        }
-        
-        @Override
-        public boolean canUseFor(ObjectIdGenerator<?> gen) {
-            return (gen.getClass() == getClass()) && (gen.getScope() == _scope);
-        }
-        
-        @Override
-        public abstract T generateId(Object forPojo);
-    }
-
-    /*
-    /**********************************************************
-    /* Implementation classes
-    /**********************************************************
-     */
-    
-    /**
-     * Abstract marker class used to allow explicitly specifying
-     * that no generator is used; which also implies that no
-     * Object Id is to be included or used.
-     */
-    @SuppressWarnings("serial")
-    public abstract static class None extends ObjectIdGenerator<Object> { }
-    
-    /**
-     * Abstract place-holder class which is used to denote case
-     * where Object Identifier to use comes from a POJO property
-     * (getter method or field). If so, value is written directly
-     * during serialization, and used as-is during deserialization.
-     *<p>
-     * Actual implementation class is part of <code>databind</code>
-     * package.
-     */
-    public abstract static class PropertyGenerator extends Base<Object> {
-        private static final long serialVersionUID = 1L;
-
-        protected PropertyGenerator(Class<?> scope) { super(scope); }
-    }
-    
-    /**
-     * Simple sequence-number based generator, which uses basic Java
-     * <code>int</code>s (starting with value 1) as Object Identifiers.
-     */
-    public final static class IntSequenceGenerator extends Base<Integer>
-    {
-        private static final long serialVersionUID = 1L;
-
-        protected transient int _nextValue;
-
-        public IntSequenceGenerator() { this(Object.class, -1); }
-        public IntSequenceGenerator(Class<?> scope, int fv) {
-            super(scope);
-            _nextValue = fv;
-        }
-
-        protected int initialValue() { return 1; }
-        
-        @Override
-        public ObjectIdGenerator<Integer> forScope(Class<?> scope) {
-            return (_scope == scope) ? this : new IntSequenceGenerator(scope, _nextValue);
-        }
-        
-        @Override
-        public ObjectIdGenerator<Integer> newForSerialization(Object context) {
-            return new IntSequenceGenerator(_scope, initialValue());
-        }
-
-        @Override
-        public IdKey key(Object key) {
-            return new IdKey(getClass(), _scope, key);
-        }
-        
-        @Override
-        public Integer generateId(Object forPojo) {
-            int id = _nextValue;
-            ++_nextValue;
-            return id;
-        }
-    }
-
-    /**
-     * Implementation that just uses {@link java.util.UUID}s as reliably
-     * unique identifiers: downside is that resulting String is
-     * 36 characters long.
-     *<p>
-     * One difference to other generators is that scope is always
-     * set as <code>Object.class</code> (regardless of arguments): this
-     * because UUIDs are globally unique, and scope has no meaning.
-     */
-    public final static class UUIDGenerator extends Base<UUID>
-    {
-        private static final long serialVersionUID = 1L;
-
-        public UUIDGenerator() { this(Object.class); }
-        private UUIDGenerator(Class<?> scope) {
-            super(Object.class);
-        }
-
-        /**
-         * Can just return base instance since this is essentially scopeless
-         */
-        @Override
-        public ObjectIdGenerator<UUID> forScope(Class<?> scope) {
-            return this;
-        }
-        
-        /**
-         * Can just return base instance since this is essentially scopeless
-         */
-        @Override
-        public ObjectIdGenerator<UUID> newForSerialization(Object context) {
-            return this;
-        }
-
-        @Override
-        public UUID generateId(Object forPojo) {
-            return UUID.randomUUID();
-        }
-
-        @Override
-        public IdKey key(Object key) {
-            return new IdKey(getClass(), null, key);
-        }
-
-        /**
-         * Since UUIDs are always unique, let's fully ignore scope definition
-         */
-        @Override
-        public boolean canUseFor(ObjectIdGenerator<?> gen) {
-            return (gen.getClass() == getClass());
-        }
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/PropertyAccessor.java

@@ -1,87 +0,0 @@
-package com.fr.third.fasterxml.jackson.annotation;
-
-/**
- * Enumeration used to define kinds of elements (called "property accessors")
- * that annotations like {@link JsonAutoDetect} apply to.
- *<p>
- * In addition to method types (GETTER/IS_GETTER, SETTER, CREATOR) and the
- * field type (FIELD), 2 pseudo-types
- * are defined for convenience: <code>ALWAYS</code> and <code>NONE</code>. These
- * can be used to indicate, all or none of available method types (respectively),
- * for use by annotations that takes <code>JsonMethod</code> argument.
- */
-public enum PropertyAccessor
-{
-    /**
-     * Getters are methods used to get a POJO field value for serialization,
-     * or, under certain conditions also for de-serialization. Latter
-     * can be used for effectively setting Collection or Map values
-     * in absence of setters, iff returned value is not a copy but
-     * actual value of the logical property.
-     *<p>
-     * Since version 1.3, this does <b>NOT</b> include "is getters" (methods
-     * that return boolean and named 'isXxx' for property 'xxx'); instead,
-     * {@link #IS_GETTER} is used}.
-     */
-    GETTER,
-
-    /**
-     * Setters are methods used to set a POJO value for deserialization.
-     */
-    SETTER,
-
-    /**
-     * Creators are constructors and (static) factory methods used to
-     * construct POJO instances for deserialization
-     */
-    CREATOR,
-
-    /**
-     * Field refers to fields of regular Java objects. Although
-     * they are not really methods, addition of optional field-discovery
-     * in version 1.1 meant that there was need to enable/disable
-     * their auto-detection, and this is the place to add it in.
-     */
-    FIELD,
-
-    /**
-     * "Is getters" are getter-like methods that are named "isXxx"
-     * (instead of "getXxx" for getters) and return boolean value
-     * (either primitive, or {@link java.lang.Boolean}).
-     *
-     */
-    IS_GETTER,
-
-    /**
-     * This pseudo-type indicates that none of accessors if affected.
-     */
-    NONE,
-
-    /**
-     * This pseudo-type indicates that all accessors are affected.
-     */
-    ALL
-    ;
-
-    private PropertyAccessor() { }
-
-    public boolean creatorEnabled() {
-        return (this == CREATOR) || (this == ALL);
-    }
-
-    public boolean getterEnabled() {
-        return (this == GETTER) || (this == ALL);
-    }
-
-    public boolean isGetterEnabled() {
-        return (this == IS_GETTER) || (this == ALL);
-    }
-
-    public boolean setterEnabled() {
-        return (this == SETTER) || (this == ALL);
-    }
-
-    public boolean fieldEnabled() {
-        return (this == FIELD) || (this == ALL);
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/annotation/package-info.java

@@ -1,12 +0,0 @@
-/**
- * Public core annotations, most of which are used to configure how
- * Data Mapping/Binding works. Annotations in this package can only
- * have dependencies to non-annotation classes in Core package;
- * annotations that have dependencies to Mapper classes are included
- * in Mapper module (under <code>org.codehaus.jackson.map.annotate</code>).
- * Also contains parameter types (mostly enums) needed by annotations.
- *<p>
- * Note that prior versions (1.x) contained these annotations within
- * 'core' jar, as part of Streaming API.
- */
-package com.fr.third.fasterxml.jackson.annotation;

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/Base64Variant.java

@@ -1,593 +0,0 @@
-/* Jackson JSON-processor.
- *
- * Copyright (c) 2007- Tatu Saloranta, tatu.saloranta@iki.fi
- */
-package com.fr.third.fasterxml.jackson.core;
-
-import java.util.Arrays;
-
-import com.fr.third.fasterxml.jackson.core.util.ByteArrayBuilder;
-
-/**
- * Abstract base class used to define specific details of which
- * variant of Base64 encoding/decoding is to be used. Although there is
- * somewhat standard basic version (so-called "MIME Base64"), other variants
- * exists, see <a href="http://en.wikipedia.org/wiki/Base64">Base64 Wikipedia entry</a> for details.
- * 
- * @author Tatu Saloranta
- */
-public final class Base64Variant
-    implements java.io.Serializable
-{
-    private final static int INT_SPACE = 0x20;
-    
-    // We'll only serialize name
-    private static final long serialVersionUID = 1L;
-
-    /**
-     * Placeholder used by "no padding" variant, to be used when a character
-     * value is needed.
-     */
-    final static char PADDING_CHAR_NONE = '\0';
-
-    /**
-     * Marker used to denote ascii characters that do not correspond
-     * to a 6-bit value (in this variant), and is not used as a padding
-     * character.
-     */
-    public final static int BASE64_VALUE_INVALID = -1;
-
-    /**
-     * Marker used to denote ascii character (in decoding table) that
-     * is the padding character using this variant (if any).
-     */
-    public final static int BASE64_VALUE_PADDING = -2;
-
-    /*
-    /**********************************************************
-    /* Encoding/decoding tables
-    /**********************************************************
-     */
-
-    /**
-     * Decoding table used for base 64 decoding.
-     */
-    private final transient int[] _asciiToBase64 = new int[128];
-
-    /**
-     * Encoding table used for base 64 decoding when output is done
-     * as characters.
-     */
-    private final transient char[] _base64ToAsciiC = new char[64];
-
-    /**
-     * Alternative encoding table used for base 64 decoding when output is done
-     * as ascii bytes.
-     */
-    private final transient byte[] _base64ToAsciiB = new byte[64];
-
-    /*
-    /**********************************************************
-    /* Other configuration
-    /**********************************************************
-     */
-
-    /**
-     * Symbolic name of variant; used for diagnostics/debugging.
-     *<p>
-     * Note that this is the only non-transient field; used when reading
-     * back from serialized state
-     */
-    protected final String _name;
-
-    /**
-     * Whether this variant uses padding or not.
-     */
-    protected final transient boolean _usesPadding;
-
-    /**
-     * Characted used for padding, if any ({@link #PADDING_CHAR_NONE} if not).
-     */
-    protected final transient char _paddingChar;
-    
-    /**
-     * Maximum number of encoded base64 characters to output during encoding
-     * before adding a linefeed, if line length is to be limited
-     * ({@link java.lang.Integer#MAX_VALUE} if not limited).
-     *<p>
-     * Note: for some output modes (when writing attributes) linefeeds may
-     * need to be avoided, and this value ignored.
-     */
-    protected final transient int _maxLineLength;
-
-    /*
-    /**********************************************************
-    /* Life-cycle
-    /**********************************************************
-     */
-
-    public Base64Variant(String name, String base64Alphabet, boolean usesPadding, char paddingChar, int maxLineLength)
-    {
-        _name = name;
-        _usesPadding = usesPadding;
-        _paddingChar = paddingChar;
-        _maxLineLength = maxLineLength;
-
-        // Ok and then we need to create codec tables.
-
-        // First the main encoding table:
-        int alphaLen = base64Alphabet.length();
-        if (alphaLen != 64) {
-            throw new IllegalArgumentException("Base64Alphabet length must be exactly 64 (was "+alphaLen+")");
-        }
-
-        // And then secondary encoding table and decoding table:
-        base64Alphabet.getChars(0, alphaLen, _base64ToAsciiC, 0);
-        Arrays.fill(_asciiToBase64, BASE64_VALUE_INVALID);
-        for (int i = 0; i < alphaLen; ++i) {
-            char alpha = _base64ToAsciiC[i];
-            _base64ToAsciiB[i] = (byte) alpha;
-            _asciiToBase64[alpha] = i;
-        }
-
-        // Plus if we use padding, add that in too
-        if (usesPadding) {
-            _asciiToBase64[(int) paddingChar] = BASE64_VALUE_PADDING;
-        }
-    }
-
-    /**
-     * "Copy constructor" that can be used when the base alphabet is identical
-     * to one used by another variant except for the maximum line length
-     * (and obviously, name).
-     */
-    public Base64Variant(Base64Variant base, String name, int maxLineLength)
-    {
-        this(base, name, base._usesPadding, base._paddingChar, maxLineLength);
-    }
-
-    /**
-     * "Copy constructor" that can be used when the base alphabet is identical
-     * to one used by another variant, but other details (padding, maximum
-     * line length) differ
-     */
-    public Base64Variant(Base64Variant base, String name, boolean usesPadding, char paddingChar, int maxLineLength)
-    {
-        _name = name;
-        byte[] srcB = base._base64ToAsciiB;
-        System.arraycopy(srcB, 0, this._base64ToAsciiB, 0, srcB.length);
-        char[] srcC = base._base64ToAsciiC;
-        System.arraycopy(srcC, 0, this._base64ToAsciiC, 0, srcC.length);
-        int[] srcV = base._asciiToBase64;
-        System.arraycopy(srcV, 0, this._asciiToBase64, 0, srcV.length);
-
-        _usesPadding = usesPadding;
-        _paddingChar = paddingChar;
-        _maxLineLength = maxLineLength;
-    }
-
-    /*
-    /**********************************************************
-    /* Serializable overrides
-    /**********************************************************
-     */
-
-    /**
-     * Method used to "demote" deserialized instances back to 
-     * canonical ones
-     */
-    protected Object readResolve() {
-        return Base64Variants.valueOf(_name);
-    }
-    
-    /*
-    /**********************************************************
-    /* Public accessors
-    /**********************************************************
-     */
-
-    public String getName() { return _name; }
-
-    public boolean usesPadding() { return _usesPadding; }
-    public boolean usesPaddingChar(char c) { return c == _paddingChar; }
-    public boolean usesPaddingChar(int ch) { return ch == (int) _paddingChar; }
-    public char getPaddingChar() { return _paddingChar; }
-    public byte getPaddingByte() { return (byte)_paddingChar; }
-
-    public int getMaxLineLength() { return _maxLineLength; }
-
-    /*
-    /**********************************************************
-    /* Decoding support
-    /**********************************************************
-     */
-
-    /**
-     * @return 6-bit decoded value, if valid character; 
-     */
-    public int decodeBase64Char(char c)
-    {
-        int ch = (int) c;
-        return (ch <= 127) ? _asciiToBase64[ch] : BASE64_VALUE_INVALID;
-    }
-
-    public int decodeBase64Char(int ch)
-    {
-        return (ch <= 127) ? _asciiToBase64[ch] : BASE64_VALUE_INVALID;
-    }
-
-    public int decodeBase64Byte(byte b)
-    {
-        int ch = (int) b;
-        return (ch <= 127) ? _asciiToBase64[ch] : BASE64_VALUE_INVALID;
-    }
-
-    /*
-    /**********************************************************
-    /* Encoding support
-    /**********************************************************
-     */
-
-    public char encodeBase64BitsAsChar(int value)
-    {
-        /* Let's assume caller has done necessary checks; this
-         * method must be fast and inlinable
-         */
-        return _base64ToAsciiC[value];
-    }
-
-    /**
-     * Method that encodes given right-aligned (LSB) 24-bit value
-     * into 4 base64 characters, stored in given result buffer.
-     */
-    public int encodeBase64Chunk(int b24, char[] buffer, int ptr)
-    {
-        buffer[ptr++] = _base64ToAsciiC[(b24 >> 18) & 0x3F];
-        buffer[ptr++] = _base64ToAsciiC[(b24 >> 12) & 0x3F];
-        buffer[ptr++] = _base64ToAsciiC[(b24 >> 6) & 0x3F];
-        buffer[ptr++] = _base64ToAsciiC[b24 & 0x3F];
-        return ptr;
-    }
-
-    public void encodeBase64Chunk(StringBuilder sb, int b24)
-    {
-        sb.append(_base64ToAsciiC[(b24 >> 18) & 0x3F]);
-        sb.append(_base64ToAsciiC[(b24 >> 12) & 0x3F]);
-        sb.append(_base64ToAsciiC[(b24 >> 6) & 0x3F]);
-        sb.append(_base64ToAsciiC[b24 & 0x3F]);
-    }
-
-    /**
-     * Method that outputs partial chunk (which only encodes one
-     * or two bytes of data). Data given is still aligned same as if
-     * it as full data; that is, missing data is at the "right end"
-     * (LSB) of int.
-     *
-     * @param outputBytes Number of encoded bytes included (either 1 or 2)
-     */
-    public int encodeBase64Partial(int bits, int outputBytes, char[] buffer, int outPtr)
-    {
-        buffer[outPtr++] = _base64ToAsciiC[(bits >> 18) & 0x3F];
-        buffer[outPtr++] = _base64ToAsciiC[(bits >> 12) & 0x3F];
-        if (_usesPadding) {
-            buffer[outPtr++] = (outputBytes == 2) ?
-                _base64ToAsciiC[(bits >> 6) & 0x3F] : _paddingChar;
-            buffer[outPtr++] = _paddingChar;
-        } else {
-            if (outputBytes == 2) {
-                buffer[outPtr++] = _base64ToAsciiC[(bits >> 6) & 0x3F];
-            }
-        }
-        return outPtr;
-    }
-
-    public void encodeBase64Partial(StringBuilder sb, int bits, int outputBytes)
-    {
-        sb.append(_base64ToAsciiC[(bits >> 18) & 0x3F]);
-        sb.append(_base64ToAsciiC[(bits >> 12) & 0x3F]);
-        if (_usesPadding) {
-            sb.append((outputBytes == 2) ?
-                      _base64ToAsciiC[(bits >> 6) & 0x3F] : _paddingChar);
-            sb.append(_paddingChar);
-        } else {
-            if (outputBytes == 2) {
-                sb.append(_base64ToAsciiC[(bits >> 6) & 0x3F]);
-            }
-        }
-    }
-
-    public byte encodeBase64BitsAsByte(int value)
-    {
-        // As with above, assuming it is 6-bit value
-        return _base64ToAsciiB[value];
-    }
-
-    /**
-     * Method that encodes given right-aligned (LSB) 24-bit value
-     * into 4 base64 bytes (ascii), stored in given result buffer.
-     */
-    public int encodeBase64Chunk(int b24, byte[] buffer, int ptr)
-    {
-        buffer[ptr++] = _base64ToAsciiB[(b24 >> 18) & 0x3F];
-        buffer[ptr++] = _base64ToAsciiB[(b24 >> 12) & 0x3F];
-        buffer[ptr++] = _base64ToAsciiB[(b24 >> 6) & 0x3F];
-        buffer[ptr++] = _base64ToAsciiB[b24 & 0x3F];
-        return ptr;
-    }
-
-    /**
-     * Method that outputs partial chunk (which only encodes one
-     * or two bytes of data). Data given is still aligned same as if
-     * it as full data; that is, missing data is at the "right end"
-     * (LSB) of int.
-     *
-     * @param outputBytes Number of encoded bytes included (either 1 or 2)
-     */
-    public int encodeBase64Partial(int bits, int outputBytes, byte[] buffer, int outPtr)
-    {
-        buffer[outPtr++] = _base64ToAsciiB[(bits >> 18) & 0x3F];
-        buffer[outPtr++] = _base64ToAsciiB[(bits >> 12) & 0x3F];
-        if (_usesPadding) {
-            byte pb = (byte) _paddingChar;
-            buffer[outPtr++] = (outputBytes == 2) ?
-                _base64ToAsciiB[(bits >> 6) & 0x3F] : pb;
-            buffer[outPtr++] = pb;
-        } else {
-            if (outputBytes == 2) {
-                buffer[outPtr++] = _base64ToAsciiB[(bits >> 6) & 0x3F];
-            }
-        }
-        return outPtr;
-    }
-
-    /*
-    /**********************************************************
-    /* Convenience conversion methods for String to/from bytes
-    /* use case.
-    /**********************************************************
-     */
-    
-    /**
-     * Convenience method for converting given byte array as base64 encoded
-     * String using this variant's settings.
-     * Resulting value is "raw", that is, not enclosed in double-quotes.
-     * 
-     * @param input Byte array to encode
-     */
-    public String encode(byte[] input)
-    {
-        return encode(input, false);
-    }
-
-    /**
-     * Convenience method for converting given byte array as base64 encoded String
-     * using this variant's settings,
-     * optionally enclosed in double-quotes.
-     * 
-     * @param input Byte array to encode
-     * @param addQuotes Whether to surround resulting value in double quotes or not
-     */
-    public String encode(byte[] input, boolean addQuotes)
-    {
-        int inputEnd = input.length;
-        StringBuilder sb;
-        {
-            // let's approximate... 33% overhead, ~= 3/8 (0.375)
-            int outputLen = inputEnd + (inputEnd >> 2) + (inputEnd >> 3);
-            sb = new StringBuilder(outputLen);
-        }
-        if (addQuotes) {
-            sb.append('"');
-        }
-
-        int chunksBeforeLF = getMaxLineLength() >> 2;
-
-        // Ok, first we loop through all full triplets of data:
-        int inputPtr = 0;
-        int safeInputEnd = inputEnd-3; // to get only full triplets
-
-        while (inputPtr <= safeInputEnd) {
-            // First, mash 3 bytes into lsb of 32-bit int
-            int b24 = ((int) input[inputPtr++]) << 8;
-            b24 |= ((int) input[inputPtr++]) & 0xFF;
-            b24 = (b24 << 8) | (((int) input[inputPtr++]) & 0xFF);
-            encodeBase64Chunk(sb, b24);
-            if (--chunksBeforeLF <= 0) {
-                // note: must quote in JSON value, so not really useful...
-                sb.append('\\');
-                sb.append('n');
-                chunksBeforeLF = getMaxLineLength() >> 2;
-            }
-        }
-
-        // And then we may have 1 or 2 leftover bytes to encode
-        int inputLeft = inputEnd - inputPtr; // 0, 1 or 2
-        if (inputLeft > 0) { // yes, but do we have room for output?
-            int b24 = ((int) input[inputPtr++]) << 16;
-            if (inputLeft == 2) {
-                b24 |= (((int) input[inputPtr++]) & 0xFF) << 8;
-            }
-            encodeBase64Partial(sb, b24, inputLeft);
-        }
-
-        if (addQuotes) {
-            sb.append('"');
-        }
-        return sb.toString();
-    }
-
-    /**
-     * Convenience method for decoding contents of a Base64-encoded String,
-     * using this variant's settings.
-     * 
-     * @param input
-     * 
-     * @since 2.2.3
-     *
-     * @throws IllegalArgumentException if input is not valid base64 encoded data
-     */
-    @SuppressWarnings("resource")
-    public byte[] decode(String input) throws IllegalArgumentException
-    {
-        ByteArrayBuilder b = new ByteArrayBuilder();
-        decode(input, b);
-        return b.toByteArray();
-    }
-
-    /**
-     * Convenience method for decoding contents of a Base64-encoded String,
-     * using this variant's settings
-     * and appending decoded binary data using provided {@link ByteArrayBuilder}.
-     *<p>
-     * NOTE: builder will NOT be reset before decoding (nor cleared afterwards);
-     * assumption is that caller will ensure it is given in proper state, and
-     * used as appropriate afterwards.
-     * 
-     * @since 2.2.3
-     *
-     * @throws IllegalArgumentException if input is not valid base64 encoded data
-     */
-    public void decode(String str, ByteArrayBuilder builder) throws IllegalArgumentException
-    {
-        int ptr = 0;
-        int len = str.length();
-        
-        main_loop:
-        while (ptr < len) {
-            // first, we'll skip preceding white space, if any
-            char ch;
-            do {
-                ch = str.charAt(ptr++);
-                if (ptr >= len) {
-                    break main_loop;
-                }
-            } while (ch <= INT_SPACE);
-            int bits = decodeBase64Char(ch);
-            if (bits < 0) {
-                _reportInvalidBase64(ch, 0, null);
-            }
-            int decodedData = bits;
-            // then second base64 char; can't get padding yet, nor ws
-            if (ptr >= len) {
-                _reportBase64EOF();
-            }
-            ch = str.charAt(ptr++);
-            bits = decodeBase64Char(ch);
-            if (bits < 0) {
-                _reportInvalidBase64(ch, 1, null);
-            }
-            decodedData = (decodedData << 6) | bits;
-            // third base64 char; can be padding, but not ws
-            if (ptr >= len) {
-                // but as per [JACKSON-631] can be end-of-input, iff not using padding
-                if (!usesPadding()) {
-                    decodedData >>= 4;
-                    builder.append(decodedData);
-                    break;
-                }
-                _reportBase64EOF();
-            }
-            ch = str.charAt(ptr++);
-            bits = decodeBase64Char(ch);
-            
-            // First branch: can get padding (-> 1 byte)
-            if (bits < 0) {
-                if (bits != Base64Variant.BASE64_VALUE_PADDING) {
-                    _reportInvalidBase64(ch, 2, null);
-                }
-                // Ok, must get padding
-                if (ptr >= len) {
-                    _reportBase64EOF();
-                }
-                ch = str.charAt(ptr++);
-                if (!usesPaddingChar(ch)) {
-                    _reportInvalidBase64(ch, 3, "expected padding character '"+getPaddingChar()+"'");
-                }
-                // Got 12 bits, only need 8, need to shift
-                decodedData >>= 4;
-                builder.append(decodedData);
-                continue;
-            }
-            // Nope, 2 or 3 bytes
-            decodedData = (decodedData << 6) | bits;
-            // fourth and last base64 char; can be padding, but not ws
-            if (ptr >= len) {
-                // but as per [JACKSON-631] can be end-of-input, iff not using padding
-                if (!usesPadding()) {
-                    decodedData >>= 2;
-                    builder.appendTwoBytes(decodedData);
-                    break;
-                }
-                _reportBase64EOF();
-            }
-            ch = str.charAt(ptr++);
-            bits = decodeBase64Char(ch);
-            if (bits < 0) {
-                if (bits != Base64Variant.BASE64_VALUE_PADDING) {
-                    _reportInvalidBase64(ch, 3, null);
-                }
-                decodedData >>= 2;
-                builder.appendTwoBytes(decodedData);
-            } else {
-                // otherwise, our triple is now complete
-                decodedData = (decodedData << 6) | bits;
-                builder.appendThreeBytes(decodedData);
-            }
-        }
-    }
-
-    /*
-    /**********************************************************
-    /* Overridden standard methods
-    /**********************************************************
-     */
-
-    @Override
-    public String toString() { return _name; }
-    
-    @Override
-    public boolean equals(Object o) {
-        // identity comparison should be dine
-        return (o == this);
-    }
-
-    @Override
-    public int hashCode() {
-        return _name.hashCode();
-    }
-    
-    /*
-    /**********************************************************
-    /* Internal helper methods
-    /**********************************************************
-     */
-    
-    /**
-     * @param bindex Relative index within base64 character unit; between 0
-     *   and 3 (as unit has exactly 4 characters)
-     */
-    protected void _reportInvalidBase64(char ch, int bindex, String msg)
-        throws IllegalArgumentException
-    {
-        String base;
-        if (ch <= INT_SPACE) {
-            base = "Illegal white space character (code 0x"+Integer.toHexString(ch)+") as character #"+(bindex+1)+" of 4-char base64 unit: can only used between units";
-        } else if (usesPaddingChar(ch)) {
-            base = "Unexpected padding character ('"+getPaddingChar()+"') as character #"+(bindex+1)+" of 4-char base64 unit: padding only legal as 3rd or 4th character";
-        } else if (!Character.isDefined(ch) || Character.isISOControl(ch)) {
-            // Not sure if we can really get here... ? (most illegal xml chars are caught at lower level)
-            base = "Illegal character (code 0x"+Integer.toHexString(ch)+") in base64 content";
-        } else {
-            base = "Illegal character '"+ch+"' (code 0x"+Integer.toHexString(ch)+") in base64 content";
-        }
-        if (msg != null) {
-            base = base + ": " + msg;
-        }
-        throw new IllegalArgumentException(base);
-    }
-
-    protected void _reportBase64EOF() throws IllegalArgumentException {
-        throw new IllegalArgumentException("Unexpected end-of-String in base64 content");
-    }
-}
-

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/Base64Variants.java

@@ -1,111 +0,0 @@
-/* Jackson JSON-processor.
- *
- * Copyright (c) 2007- Tatu Saloranta, tatu.saloranta@iki.fi
- */
-package com.fr.third.fasterxml.jackson.core;
-
-/**
- * Container for commonly used Base64 variants:
- *<ul>
- * <li> {@link #MIME}
- * <li> {@link #MIME_NO_LINEFEEDS}
- * <li> {@link #PEM}
- * <li> {@link #MODIFIED_FOR_URL}
- * </ul>
- * 
- * @author Tatu Saloranta
- */
-public final class Base64Variants
-{
-    final static String STD_BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-    /**
-     * This variant is what most people would think of "the standard"
-     * Base64 encoding.
-     *<p>
-     * See <a href="">wikipedia Base64 entry</a> for details.
-     *<p>
-     * Note that although this can be thought of as the standard variant,
-     * it is <b>not</b> the default for Jackson: no-linefeeds alternative
-     * is because of JSON requirement of escaping all linefeeds.
-     */
-    public final static Base64Variant MIME;
-    static {
-        MIME = new Base64Variant("MIME", STD_BASE64_ALPHABET, true, '=', 76);
-    }
-
-    /**
-     * Slightly non-standard modification of {@link #MIME} which does not
-     * use linefeeds (max line length set to infinite). Useful when linefeeds
-     * wouldn't work well (possibly in attributes), or for minor space savings
-     * (save 1 linefeed per 76 data chars, ie. ~1.4% savings).
-     */
-    public final static Base64Variant MIME_NO_LINEFEEDS;
-    static {
-        MIME_NO_LINEFEEDS = new Base64Variant(MIME, "MIME-NO-LINEFEEDS", Integer.MAX_VALUE);
-    }
-
-    /**
-     * This variant is the one that predates {@link #MIME}: it is otherwise
-     * identical, except that it mandates shorter line length.
-     */
-    public final static Base64Variant PEM = new Base64Variant(MIME, "PEM", true, '=', 64);
-
-    /**
-     * This non-standard variant is usually used when encoded data needs to be
-     * passed via URLs (such as part of GET request). It differs from the
-     * base {@link #MIME} variant in multiple ways.
-     * First, no padding is used: this also means that it generally can not
-     * be written in multiple separate but adjacent chunks (which would not
-     * be the usual use case in any case). Also, no linefeeds are used (max
-     * line length set to infinite). And finally, two characters (plus and
-     * slash) that would need quoting in URLs are replaced with more
-     * optimal alternatives (hyphen and underscore, respectively).
-     */
-    public final static Base64Variant MODIFIED_FOR_URL;
-    static {
-        StringBuffer sb = new StringBuffer(STD_BASE64_ALPHABET);
-        // Replace plus with hyphen, slash with underscore (and no padding)
-        sb.setCharAt(sb.indexOf("+"), '-');
-        sb.setCharAt(sb.indexOf("/"), '_');
-        /* And finally, let's not split lines either, wouldn't work too
-         * well with URLs
-         */
-        MODIFIED_FOR_URL = new Base64Variant("MODIFIED-FOR-URL", sb.toString(), false, Base64Variant.PADDING_CHAR_NONE, Integer.MAX_VALUE);
-    }
-
-    /**
-     * Method used to get the default variant ("MIME_NO_LINEFEEDS") for cases
-     * where caller does not explicitly specify the variant.
-     * We will prefer no-linefeed version because linefeeds in JSON values
-     * must be escaped, making linefeed-containing variants sub-optimal.
-     */
-    public static Base64Variant getDefaultVariant() {
-        return MIME_NO_LINEFEEDS;
-    }
-
-    /**
-     * @since 2.1
-     */
-    public static Base64Variant valueOf(String name) throws IllegalArgumentException
-    {
-        if (MIME._name.equals(name)) {
-            return MIME;
-        }
-        if (MIME_NO_LINEFEEDS._name.equals(name)) {
-            return MIME_NO_LINEFEEDS;
-        }
-        if (PEM._name.equals(name)) {
-            return PEM;
-        }
-        if (MODIFIED_FOR_URL._name.equals(name)) {
-            return MODIFIED_FOR_URL;
-        }
-        if (name == null) {
-            name = "<null>";
-        } else {
-            name = "'"+name+"'";
-        }
-        throw new IllegalArgumentException("No Base64Variant with name "+name);
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/FormatSchema.java

@@ -1,32 +0,0 @@
-/* Jackson JSON-processor.
- *
- * Copyright (c) 2007- Tatu Saloranta, tatu.saloranta@iki.fi
- */
-
-package com.fr.third.fasterxml.jackson.core;
-
-/**
- * Simple tag interface used to mark schema objects that are used by some
- * {@link JsonParser} and {@link JsonGenerator} implementations to further
- * specify structure of expected format.
- * Basic JSON-based parsers and generators do not use schemas, but some data
- * formats (like many binary data formats like Thrift, protobuf) mandate
- * use of schemas.
- *<p>
- * Since there is little commonality between schemas for different data formats,
- * this interface does not define much meaningful functionality for accessing
- * schema details; rather, specific parser and generator implementations need
- * to cast to schema implementations they use. This marker interface is mostly
- * used for tagging "some kind of schema" -- instead of passing opaque
- * {@link java.lang.Object} -- for documentation purposes.
- */
-public interface FormatSchema
-{
-    /**
-     * Method that can be used to get an identifier that can be used for diagnostics
-     * purposes, to indicate what kind of data format this schema is used for: typically
-     * it is a short name of format itself, but it can also contain additional information
-     * in cases where data format supports multiple types of schemas.
-     */
-    String getSchemaType();
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/JsonEncoding.java

@@ -1,57 +0,0 @@
-/* Jackson JSON-processor.
- *
- * Copyright (c) 2007- Tatu Saloranta, tatu.saloranta@iki.fi
- */
-
-package com.fr.third.fasterxml.jackson.core;
-
-/**
- * Enumeration that defines legal encodings that can be used
- * for JSON content, based on list of allowed encodings from
- * <a href="http://www.ietf.org/rfc/rfc4627.txt">JSON specification</a>.
- *<p>
- * Note: if application want to explicitly disregard Encoding
- * limitations (to read in JSON encoded using an encoding not
- * listed as allowed), they can use {@link java.io.Reader} /
- * {@link java.io.Writer} instances as input
- */
-public enum JsonEncoding {
-    UTF8("UTF-8", false, 8), // N/A for big-endian, really
-        UTF16_BE("UTF-16BE", true, 16),
-        UTF16_LE("UTF-16LE", false, 16),
-        UTF32_BE("UTF-32BE", true, 32),
-        UTF32_LE("UTF-32LE", false, 32)
-        ;
-    
-    protected final String _javaName;
-
-    protected final boolean _bigEndian;
-
-    protected final int _bits;
-    
-    JsonEncoding(String javaName, boolean bigEndian, int bits)
-    {
-        _javaName = javaName;
-        _bigEndian = bigEndian;
-        _bits = bits;
-    }
-
-    /**
-     * Method for accessing encoding name that JDK will support.
-     *
-     * @return Matching encoding name that JDK will support.
-     */
-    public String getJavaName() { return _javaName; }
-
-    /**
-     * Whether encoding is big-endian (if encoding supports such
-     * notion). If no such distinction is made (as is the case for
-     * {@link #UTF8}), return value is undefined.
-     *
-     * @return True for big-endian encodings; false for little-endian
-     *   (or if not applicable)
-     */
-    public boolean isBigEndian() { return _bigEndian; }
-
-    public int bits() { return _bits; }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/JsonGenerationException.java

@@ -1,32 +0,0 @@
-/* Jackson JSON-processor.
- *
- * Copyright (c) 2007- Tatu Saloranta, tatu.saloranta@iki.fi
- */
-
-package com.fr.third.fasterxml.jackson.core;
-
-/**
- * Exception type for exceptions during JSON writing, such as trying
- * to output  content in wrong context (non-matching end-array or end-object,
- * for example).
- */
-public class JsonGenerationException
-    extends JsonProcessingException
-{
-    private final static long serialVersionUID = 123; // Stupid eclipse...
-    
-    public JsonGenerationException(Throwable rootCause)
-    {
-        super(rootCause);
-    }
-
-    public JsonGenerationException(String msg)
-    {
-        super(msg, (JsonLocation)null);
-    }
-
-    public JsonGenerationException(String msg, Throwable rootCause)
-    {
-        super(msg, (JsonLocation)null, rootCause);
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/JsonLocation.java

@@ -1,139 +0,0 @@
-/* Jackson JSON-processor.
- *
- * Copyright (c) 2007- Tatu Saloranta, tatu.saloranta@iki.fi
- */
-
-package com.fr.third.fasterxml.jackson.core;
-
-/**
- * Object that encapsulates Location information used for reporting
- * parsing (or potentially generation) errors, as well as current location
- * within input streams.
- */
-public class JsonLocation
-    implements java.io.Serializable // as per [JACKSON-168]
-{
-    private static final long serialVersionUID = 1L;
-
-    /**
-     * Shared immutable "N/A location" that can be returned to indicate
-     * that no location information is available
-     */
-    public final static JsonLocation NA = new JsonLocation("N/A", -1L, -1L, -1, -1);
-
-    final long _totalBytes;
-    final long _totalChars;
-
-    final int _lineNr;
-    final int _columnNr;
-
-    /**
-     * Displayable description for input source: file path, URL.
-     *<p>
-     * NOTE: <code>transient</code> since 2.2 so that Location itself is Serializable.
-     */
-    final transient Object _sourceRef;
-
-    public JsonLocation(Object srcRef, long totalChars, int lineNr, int colNr)
-    {
-        /* Unfortunately, none of legal encodings are straight single-byte
-         * encodings. Could determine offset for UTF-16/UTF-32, but the
-         * most important one is UTF-8...
-         * so for now, we'll just not report any real byte count
-         */
-        this(srcRef, -1L, totalChars, lineNr, colNr);
-    }
-
-    public JsonLocation(Object sourceRef, long totalBytes, long totalChars,
-            int lineNr, int columnNr)
-    {
-        _sourceRef = sourceRef;
-        _totalBytes = totalBytes;
-        _totalChars = totalChars;
-        _lineNr = lineNr;
-        _columnNr = columnNr;
-    }
-
-    /**
-     * Reference to the original resource being read, if one available.
-     * For example, when a parser has been constructed by passing
-     * a {@link java.io.File} instance, this method would return
-     * that File. Will return null if no such reference is available,
-     * for example when {@link java.io.InputStream} was used to
-     * construct the parser instance.
-     */
-    public Object getSourceRef() { return _sourceRef; }
-
-    /**
-     * @return Line number of the location (1-based)
-     */
-    public int getLineNr() { return _lineNr; }
-
-    /**
-     * @return Column number of the location (1-based)
-     */
-    public int getColumnNr() { return _columnNr; }
-
-    /**
-     * @return Character offset within underlying stream, reader or writer,
-     *   if available; -1 if not.
-     */
-    public long getCharOffset() { return _totalChars; }
-
-    /**
-     * @return Byte offset within underlying stream, reader or writer,
-     *   if available; -1 if not.
-     */
-    public long getByteOffset()
-    {
-        return _totalBytes;
-    }
-
-    @Override
-    public String toString()
-    {
-        StringBuilder sb = new StringBuilder(80);
-        sb.append("[Source: ");
-        if (_sourceRef == null) {
-            sb.append("UNKNOWN");
-        } else {
-            sb.append(_sourceRef.toString());
-        }
-        sb.append("; line: ");
-        sb.append(_lineNr);
-        sb.append(", column: ");
-        sb.append(_columnNr);
-        sb.append(']');
-        return sb.toString();
-    }
-
-    @Override
-    public int hashCode()
-    {
-        int hash = (_sourceRef == null) ? 1 : _sourceRef.hashCode();
-        hash ^= _lineNr;
-        hash += _columnNr;
-        hash ^= (int) _totalChars;
-        hash += (int) _totalBytes;
-        return hash;
-    }
-
-    @Override
-    public boolean equals(Object other)
-    {
-        if (other == this) return true;
-        if (other == null) return false;
-        if (!(other instanceof JsonLocation)) return false;
-        JsonLocation otherLoc = (JsonLocation) other;
-
-        if (_sourceRef == null) {
-            if (otherLoc._sourceRef != null) return false;
-        } else if (!_sourceRef.equals(otherLoc._sourceRef)) return false;
-
-        return (_lineNr == otherLoc._lineNr)
-            && (_columnNr == otherLoc._columnNr)
-            && (_totalChars == otherLoc._totalChars)
-            && (getByteOffset() == otherLoc.getByteOffset())
-            ;
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/JsonParseException.java

@@ -1,27 +0,0 @@
-/* Jackson JSON-processor.
- *
- * Copyright (c) 2007- Tatu Saloranta, tatu.saloranta@iki.fi
- */
-
-package com.fr.third.fasterxml.jackson.core;
-
-/**
- * Exception type for parsing problems, used when non-well-formed content
- * (content that does not conform to JSON syntax as per specification)
- * is encountered.
- */
-public class JsonParseException
-    extends JsonProcessingException
-{
-    private static final long serialVersionUID = 1L;
-    
-    public JsonParseException(String msg, JsonLocation loc)
-    {
-        super(msg, loc);
-    }
-
-    public JsonParseException(String msg, JsonLocation loc, Throwable root)
-    {
-        super(msg, loc, root);
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/JsonPointer.java

@@ -1,269 +0,0 @@
-package com.fr.third.fasterxml.jackson.core;
-
-import com.fr.third.fasterxml.jackson.core.io.NumberInput;
-
-/**
- * Implementation of
- * <a href="http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-03">JSON Pointer</a>
- * specification.
- * Pointer instances can be used to locate logical JSON nodes for things like
- * tree traversal (see {@link TreeNode#at}).
- * It may be used in future for filtering of streaming JSON content
- * as well (not implemented yet for 2.3).
- *<p>
- * Instances are fully immutable and can be shared, cached.
- * 
- * @author Tatu Saloranta
- * 
- * @since 2.3
- */
-public class JsonPointer
-{
-    /**
-     * Marker instance used to represent segment that matches current
-     * node or position.
-     */
-    protected final static JsonPointer EMPTY = new JsonPointer();
-    
-    /**
-     * Reference to rest of the pointer beyond currently matching
-     * segment (if any); null if this pointer refers to a matching
-     * segment.
-     */
-    protected final JsonPointer _nextSegment;
-    
-    /**
-     * We will retain representation of the pointer, as a String,
-     * so that {@link #toString} should be as efficient as possible.
-     */
-    protected final String _asString;
-    
-    protected final String _matchingPropertyName;
-
-    protected final int _matchingElementIndex;
-
-    /*
-    /**********************************************************
-    /* Cosntruction
-    /**********************************************************
-     */
-    
-    /**
-     * Constructor used for creating "empty" instance, used to represent
-     * state that matches current node.
-     */
-    protected JsonPointer() {
-        _nextSegment = null;
-        _matchingPropertyName = "";
-        _matchingElementIndex = -1;
-        _asString = "";
-    }
-
-    /**
-     * Constructor used for creating non-empty Segments
-     */
-    protected JsonPointer(String fullString, String segment, JsonPointer next) {
-        _asString = fullString;
-        _nextSegment = next;
-        // Ok; may always be a property
-        _matchingPropertyName = segment;
-        _matchingElementIndex = _parseIndex(segment);
-    }
-    
-    /*
-    /**********************************************************
-    /* Factory methods
-    /**********************************************************
-     */
-    
-    /**
-     * Factory method that parses given input and construct matching pointer
-     * instance, if it represents a valid JSON Pointer: if not, a
-     * {@link IllegalArgumentException} is thrown.
-     * 
-     * @throws IllegalArgumentException Thrown if the input does not present a valid JSON Pointer
-     *   expression: currently the only such expression is one that does NOT start with
-     *   a slash ('/').
-     */
-    public static JsonPointer compile(String input) throws IllegalArgumentException
-    {
-        // First quick checks for well-known 'empty' pointer
-        if ((input == null) || input.length() == 0) {
-            return EMPTY;
-        }
-        // And then quick validity check:
-        if (input.charAt(0) != '/') {
-            throw new IllegalArgumentException("Invalid input: JSON Pointer expression must start with '/': "+"\""+input+"\"");
-        }
-        return _parseTail(input);
-    }
-
-    /**
-     * Alias for {@link #compile}; added to make instances automatically
-     * deserializable by Jackson databind.
-     */
-    public static JsonPointer valueOf(String input) { return compile(input); }
-
-    /* Factory method that composes a pointer instance, given a set
-     * of 'raw' segments: raw meaning that no processing will be done,
-     * no escaping may is present.
-     * 
-     * @param segments
-     * 
-     * @return Constructed path instance
-     */
-    /* TODO!
-    public static JsonPointer fromSegment(String... segments)
-    {
-        if (segments.length == 0) {
-            return EMPTY;
-        }
-        JsonPointer prev = null;
-                
-        for (String segment : segments) {
-            JsonPointer next = new JsonPointer()
-        }
-    }
-    */
-    
-    /*
-    /**********************************************************
-    /* Public API
-    /**********************************************************
-     */
-
-    public boolean matches() { return _nextSegment == null; }
-    public String getMatchingProperty() { return _matchingPropertyName; }
-    public int getMatchingIndex() { return _matchingElementIndex; }
-    public boolean mayMatchProperty() { return _matchingPropertyName != null; }
-    public boolean mayMatchElement() { return _matchingElementIndex >= 0; }
-
-    public JsonPointer matchProperty(String name) {
-        if (_nextSegment == null || !_matchingPropertyName.equals(name)) {
-            return null;
-        }
-        return _nextSegment;
-    }
-
-    public JsonPointer matchElement (int index) {
-        if ((index != _matchingElementIndex) || (index < 0)) {
-            return null;
-        }
-        return _nextSegment;
-    }
-
-    /**
-     * Accessor for getting a "sub-pointer", instance where current segment
-     * has been removed and pointer includes rest of segments;
-     */
-    public JsonPointer tail() {
-        return _nextSegment;
-    }
-    
-    /*
-    /**********************************************************
-    /* Standard method overrides
-    /**********************************************************
-     */
-
-    @Override public String toString() { return _asString; }
-    @Override public int hashCode() { return _asString.hashCode(); }
-
-    @Override public boolean equals(Object o) {
-        if (o == this) return true;
-        if (o == null) return false;
-        if (!(o instanceof JsonPointer)) return false;
-        return _asString.equals(((JsonPointer) o)._asString);
-    }
-    
-    /*
-    /**********************************************************
-    /* Internal methods
-    /**********************************************************
-     */
-
-    private final static int _parseIndex(String str) {
-        final int len = str.length();
-        // [Issue#133]: beware of super long indexes; assume we never
-        // have arrays over 2 billion entries so ints are fine.
-        if (len == 0 || len > 10) {
-            return -1;
-        }
-        for (int i = 0; i < len; ++i) {
-            char c = str.charAt(i++);
-            if (c > '9' || c < '0') {
-                return -1;
-            }
-        }
-        if (len == 10) {
-            long l = NumberInput.parseLong(str);
-            if (l > Integer.MAX_VALUE) {
-                return -1;
-            }
-        }
-        return NumberInput.parseInt(str);
-    }
-    
-    protected static JsonPointer _parseTail(String input) {
-        final int end = input.length();
-
-        // first char is the contextual slash, skip
-        for (int i = 1; i < end; ) {
-            char c = input.charAt(i);
-            if (c == '/') { // common case, got a segment
-                return new JsonPointer(input, input.substring(1, i),
-                        _parseTail(input.substring(i)));
-            }
-            ++i;
-            // quoting is different; offline this case
-            if (c == '~' && i < end) { // possibly, quote
-                return _parseQuotedTail(input, i);
-            }
-            // otherwise, loop on
-        }
-        // end of the road, no escapes
-        return new JsonPointer(input, input.substring(1), EMPTY);
-    }
-
-    /**
-     * Method called to parse tail of pointer path, when a potentially
-     * escaped character has been seen.
-     * 
-     * @param input Full input for the tail being parsed
-     * @param i Offset to character after tilde
-     */
-    protected static JsonPointer _parseQuotedTail(String input, int i) {
-        final int end = input.length();
-        StringBuilder sb = new StringBuilder(Math.max(16, end));
-        if (i > 2) {
-            sb.append(input, 1, i-1);
-        }
-        _appendEscape(sb, input.charAt(i++));
-        while (i < end) {
-            char c = input.charAt(i);
-            if (c == '/') { // end is nigh!
-                return new JsonPointer(input, sb.toString(),
-                        _parseTail(input.substring(i))); // need to push back slash
-            }
-            ++i;
-            if (c == '~' && i < end) {
-                _appendEscape(sb, input.charAt(i++));
-                continue;
-            }
-            sb.append(c);
-        }
-        // end of the road, last segment
-        return new JsonPointer(input, sb.toString(), EMPTY);
-    }
-    
-    private static void _appendEscape(StringBuilder sb, char c) {
-        if (c == '0') {
-            c = '~';
-        } else if (c == '1') {
-            c = '/';
-        } else {
-            sb.append('~');
-        }
-        sb.append(c);
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/JsonProcessingException.java

@@ -1,130 +0,0 @@
-/* Jackson JSON-processor.
- *
- * Copyright (c) 2007- Tatu Saloranta, tatu.saloranta@iki.fi
- */
-
-package com.fr.third.fasterxml.jackson.core;
-
-/**
- * Intermediate base class for all problems encountered when
- * processing (parsing, generating) JSON content
- * that are not pure I/O problems.
- * Regular {@link java.io.IOException}s will be passed through as is.
- * Sub-class of {@link java.io.IOException} for convenience.
- */
-public class JsonProcessingException
-    extends java.io.IOException
-{
-    final static long serialVersionUID = 123; // Stupid eclipse...
-	
-    protected JsonLocation _location;
-
-    protected JsonProcessingException(String msg, JsonLocation loc, Throwable rootCause)
-    {
-        /* Argh. IOException(Throwable,String) is only available starting
-         * with JDK 1.6...
-         */
-        super(msg);
-        if (rootCause != null) {
-            initCause(rootCause);
-        }
-        _location = loc;
-    }
-
-    protected JsonProcessingException(String msg)
-    {
-        super(msg);
-    }
-
-    protected JsonProcessingException(String msg, JsonLocation loc)
-    {
-        this(msg, loc, null);
-    }
-
-    protected JsonProcessingException(String msg, Throwable rootCause)
-    {
-        this(msg, null, rootCause);
-    }
-
-    protected JsonProcessingException(Throwable rootCause)
-    {
-        this(null, null, rootCause);
-    }
-
-    public JsonLocation getLocation() {
-        return _location;
-    }
-
-    /*
-    /**********************************************************
-    /* Extended API
-    /**********************************************************
-     */
-
-    /**
-     * Method that allows accessing the original "message" argument,
-     * without additional decorations (like location information)
-     * that overridden {@link #getMessage} adds.
-     * 
-     * @since 2.1
-     */
-    public String getOriginalMessage()
-    {
-        return super.getMessage();
-    }
-
-    /*
-    /**********************************************************
-    /* Methods for sub-classes to use, override
-    /**********************************************************
-     */
-    
-    /**
-     * Accessor that sub-classes can override to append additional
-     * information right after the main message, but before
-     * source location information.
-     */
-    protected String getMessageSuffix() {
-        return null;
-    }
-
-    /*
-    /**********************************************************
-    /* Overrides of standard methods
-    /**********************************************************
-     */
-    
-    /**
-     * Default method overridden so that we can add location information
-     */
-    @Override
-    public String getMessage()
-    {
-        String msg = super.getMessage();
-        if (msg == null) {
-            msg = "N/A";
-        }
-        JsonLocation loc = getLocation();
-        String suffix = getMessageSuffix();
-        // mild optimization, if nothing extra is needed:
-        if (loc != null || suffix != null) {
-            StringBuilder sb = new StringBuilder(100);
-            sb.append(msg);
-            if (suffix != null) {
-                sb.append(suffix);
-            }
-            if (loc != null) {
-                sb.append('\n');
-                sb.append(" at ");
-                sb.append(loc.toString());
-            }
-            msg = sb.toString();
-        }
-        return msg;
-    }
-
-    @Override
-    public String toString() {
-        return getClass().getName()+": "+getMessage();
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/JsonStreamContext.java

@@ -1,112 +0,0 @@
-/* Jackson JSON-processor.
- *
- * Copyright (c) 2007- Tatu Saloranta, tatu.saloranta@iki.fi
- */
-
-package com.fr.third.fasterxml.jackson.core;
-
-/**
- * Shared base class for streaming processing contexts used during
- * reading and writing of Json content using Streaming API.
- * This context is also exposed to applications:
- * context object can be used by applications to get an idea of
- * relative position of the parser/generator within json content
- * being processed. This allows for some contextual processing: for
- * example, output within Array context can differ from that of
- * Object context.
- */
-public abstract class JsonStreamContext
-{
-    // // // Type constants used internally
-
-    protected final static int TYPE_ROOT = 0;
-    protected final static int TYPE_ARRAY = 1;
-    protected final static int TYPE_OBJECT = 2;
-
-    protected int _type;
-
-    /**
-     * Index of the currently processed entry. Starts with -1 to signal
-     * that no entries have been started, and gets advanced each
-     * time a new entry is started, either by encountering an expected
-     * separator, or with new values if no separators are expected
-     * (the case for root context).
-     */
-    protected int _index;
-
-    /*
-    /**********************************************************
-    /* Life-cycle
-    /**********************************************************
-     */
-
-    protected JsonStreamContext() { }
-
-    /*
-    /**********************************************************
-    /* Public API, accessors
-    /**********************************************************
-     */
-
-    /**
-     * Accessor for finding parent context of this context; will
-     * return null for root context.
-     */
-    public abstract JsonStreamContext getParent();
-
-    /**
-     * Method that returns true if this context is an Array context;
-     * that is, content is being read from or written to a Json Array.
-     */
-    public final boolean inArray() { return _type == TYPE_ARRAY; }
-
-    /**
-     * Method that returns true if this context is a Root context;
-     * that is, content is being read from or written to without
-     * enclosing array or object structure.
-     */
-    public final boolean inRoot() { return _type == TYPE_ROOT; }
-
-    /**
-     * Method that returns true if this context is an Object context;
-     * that is, content is being read from or written to a Json Object.
-     */
-    public final boolean inObject() { return _type == TYPE_OBJECT; }
-
-    /**
-     * Method for accessing simple type description of current context;
-     * either ROOT (for root-level values), OBJECT (for field names and
-     * values of JSON Objects) or ARRAY (for values of JSON Arrays)
-     */
-    public final String getTypeDesc() {
-        switch (_type) {
-        case TYPE_ROOT: return "ROOT";
-        case TYPE_ARRAY: return "ARRAY";
-        case TYPE_OBJECT: return "OBJECT";
-        }
-        return "?";
-    }
-
-    /**
-     * @return Number of entries that are complete and started.
-     */
-    public final int getEntryCount()
-    {
-        return _index + 1;
-    }
-
-    /**
-     * @return Index of the currently processed entry, if any
-     */
-    public final int getCurrentIndex()
-    {
-        return (_index < 0) ? 0 : _index;
-    }
-
-    /**
-     * Method for accessing name associated with the current location.
-     * Non-null for <code>FIELD_NAME</code> and value events that directly
-     * follow field names; null for root level and array values.
-     */
-    public abstract String getCurrentName();
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/JsonToken.java

@@ -1,212 +0,0 @@
-/* Jackson JSON-processor.
- *
- * Copyright (c) 2007- Tatu Saloranta, tatu.saloranta@iki.fi
- */
-
-package com.fr.third.fasterxml.jackson.core;
-
-/**
- * Enumeration for basic token types used for returning results
- * of parsing JSON content.
- */
-public enum JsonToken
-{
-    /* Some notes on implementation:
-     *
-     * - Entries are to be ordered such that start/end array/object
-     *   markers come first, then field name marker (if any), and
-     *   finally scalar value tokens. This is assumed by some
-     *   typing checks.
-     */
-
-    /**
-     * NOT_AVAILABLE can be returned if {@link JsonParser}
-     * implementation can not currently return the requested
-     * token (usually next one), or even if any will be
-     * available, but that may be able to determine this in
-     * future. This is the case with non-blocking parsers --
-     * they can not block to wait for more data to parse and
-     * must return something.
-     */
-    NOT_AVAILABLE(null, JsonTokenId.ID_NOT_AVAILABLE),
-
-    /**
-     * START_OBJECT is returned when encountering '{'
-     * which signals starting of an Object value.
-     */
-    START_OBJECT("{", JsonTokenId.ID_START_OBJECT),
-        
-    /**
-     * END_OBJECT is returned when encountering '}'
-     * which signals ending of an Object value
-     */
-    END_OBJECT("}", JsonTokenId.ID_END_OBJECT),
-
-    /**
-     * START_ARRAY is returned when encountering '['
-     * which signals starting of an Array value
-     */
-    START_ARRAY("[", JsonTokenId.ID_START_ARRAY),
-
-    /**
-     * END_ARRAY is returned when encountering ']'
-     * which signals ending of an Array value
-     */
-    END_ARRAY("]", JsonTokenId.ID_END_ARRAY),
-        
-    /**
-     * FIELD_NAME is returned when a String token is encountered
-     * as a field name (same lexical value, different function)
-     */
-    FIELD_NAME(null, JsonTokenId.ID_FIELD_NAME),
-    
-    /**
-     * Placeholder token returned when the input source has a concept
-     * of embedded Object that are not accessible as usual structure
-     * (of starting with {@link #START_OBJECT}, having values, ending with
-     * {@link #END_OBJECT}), but as "raw" objects.
-     *<p>
-     * Note: this token is never returned by regular JSON readers, but
-     * only by readers that expose other kinds of source (like
-     * <code>JsonNode</code>-based JSON trees, Maps, Lists and such).
-     */
-    VALUE_EMBEDDED_OBJECT(null, JsonTokenId.ID_EMBEDDED_OBJECT),
-
-    /**
-     * VALUE_STRING is returned when a String token is encountered
-     * in value context (array element, field value, or root-level
-     * stand-alone value)
-     */
-    VALUE_STRING(null, JsonTokenId.ID_STRING),
-
-    /**
-     * VALUE_NUMBER_INT is returned when an integer numeric token is
-     * encountered in value context: that is, a number that does
-     * not have floating point or exponent marker in it (consists
-     * only of an optional sign, followed by one or more digits)
-     */
-    VALUE_NUMBER_INT(null, JsonTokenId.ID_NUMBER_INT),
-
-    /**
-     * VALUE_NUMBER_INT is returned when a numeric token other
-     * that is not an integer is encountered: that is, a number that does
-     * have floating point or exponent marker in it, in addition
-     * to one or more digits.
-     */
-    VALUE_NUMBER_FLOAT(null, JsonTokenId.ID_NUMBER_FLOAT),
-    
-    /**
-     * VALUE_TRUE is returned when encountering literal "true" in
-     * value context
-     */
-    VALUE_TRUE("true", JsonTokenId.ID_TRUE),
-
-    /**
-     * VALUE_FALSE is returned when encountering literal "false" in
-     * value context
-     */
-    VALUE_FALSE("false", JsonTokenId.ID_FALSE),
-
-    /**
-     * VALUE_NULL is returned when encountering literal "null" in
-     * value context
-     */
-    VALUE_NULL("null", JsonTokenId.ID_NULL),
-        ;
-    
-    final String _serialized;
-
-    final char[] _serializedChars;
-
-    final byte[] _serializedBytes;
-
-    final int _id;
-    
-    final boolean _isStructStart, _isStructEnd;
-
-    final boolean _isNumber;
-
-    final boolean _isBoolean;
-
-    final boolean _isScalar;
-
-    /**
-     * @param token representation for this token, if there is a
-     *   single static representation; null otherwise
-     */
-    JsonToken(String token, int id)
-    {
-        if (token == null) {
-            _serialized = null;
-            _serializedChars = null;
-            _serializedBytes = null;
-        } else {
-            _serialized = token;
-            _serializedChars = token.toCharArray();
-            // It's all in ascii, can just case...
-            int len = _serializedChars.length;
-            _serializedBytes = new byte[len];
-            for (int i = 0; i < len; ++i) {
-                _serializedBytes[i] = (byte) _serializedChars[i];
-            }
-        }
-        _id = id;
-        
-        _isBoolean = (id == JsonTokenId.ID_FALSE || id == JsonTokenId.ID_TRUE);
-        _isNumber = (id == JsonTokenId.ID_NUMBER_INT || id == JsonTokenId.ID_NUMBER_FLOAT);
-
-        _isStructStart = (id == JsonTokenId.ID_START_OBJECT || id == JsonTokenId.ID_START_ARRAY);
-        _isStructEnd = (id == JsonTokenId.ID_END_OBJECT || id == JsonTokenId.ID_END_ARRAY);
-
-        _isScalar = !_isStructStart && !_isStructEnd
-                && (id != JsonTokenId.ID_FIELD_NAME)
-                && (id != JsonTokenId.ID_NOT_AVAILABLE);
-    }
-
-    public final int id() { return _id; }
-    
-    public final String asString() { return _serialized; }
-    public final char[] asCharArray() { return _serializedChars; }
-    public final byte[] asByteArray() { return _serializedBytes; }
-
-    public final boolean isNumeric() {
-        return _isNumber;
-    }
-
-    /**
-     * Accessor that is functionally equivalent to:
-     * <code>
-     *    this == JsonToken.START_OBJECT || this == JsonToken.START_ARRAY
-     * </code>
-     * 
-     * @since 2.3
-     */
-    public final boolean isStructStart() {
-        return _isStructStart;
-    }
-
-    /**
-     * Accessor that is functionally equivalent to:
-     * <code>
-     *    this == JsonToken.END_OBJECT || this == JsonToken.END_ARRAY
-     * </code>
-     * 
-     * @since 2.3
-     */
-    public final boolean isStructEnd() {
-        return _isStructEnd;
-    }
-
-    /**
-     * Method that can be used to check whether this token represents
-     * a valid non-structured value. This means all tokens other than
-     * Object/Array start/end markers all field names.
-     */
-    public final boolean isScalarValue() {
-        return _isScalar;
-    }
-
-    public final boolean isBoolean() {
-        return _isBoolean;
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/JsonTokenId.java

@@ -1,87 +0,0 @@
-package com.fr.third.fasterxml.jackson.core;
-
-/**
- * Interface defined to contain ids accessible with {@link JsonToken#id()}.
- * Needed because it is impossible to define these constants in
- * {@link JsonToken} itself, as static constants (oddity of how Enums
- * are implemented by JVM).
- * 
- * @since 2.3
- */
-public interface JsonTokenId
-{
-    /**
-     * Id used to represent {@link JsonToken#NOT_AVAILABLE}, used in
-     * cases where a token may become available when more input
-     * is available: this occurs in non-blocking use cases.
-     */
-    public final static int ID_NOT_AVAILABLE = -1;
-
-    /**
-     * Id used to represent the case where no {@link JsonToken}
-     * is available: either because {@link JsonParser} has not been
-     * advanced to first token, or because no more tokens will be
-     * available (end-of-input or explicit closing of parser}.
-     */
-    public final static int ID_NO_TOKEN = 0;
-
-    /**
-     * Id used to represent {@link JsonToken#START_OBJECT}
-     */
-    public final static int ID_START_OBJECT = 1;
-
-    /**
-     * Id used to represent {@link JsonToken#END_OBJECT}
-     */
-    public final static int ID_END_OBJECT = 2;
-
-    /**
-     * Id used to represent {@link JsonToken#START_ARRAY}
-     */
-    public final static int ID_START_ARRAY = 3;
-
-    /**
-     * Id used to represent {@link JsonToken#END_ARRAY}
-     */
-    public final static int ID_END_ARRAY = 4;
-
-    /**
-     * Id used to represent {@link JsonToken#FIELD_NAME}
-     */
-    public final static int ID_FIELD_NAME = 5;
-
-    /**
-     * Id used to represent {@link JsonToken#VALUE_STRING}
-     */
-    public final static int ID_STRING = 6;
-
-    /**
-     * Id used to represent {@link JsonToken#VALUE_NUMBER_INT}
-     */
-    public final static int ID_NUMBER_INT = 7;
-
-    /**
-     * Id used to represent {@link JsonToken#VALUE_NUMBER_FLOAT}
-     */
-    public final static int ID_NUMBER_FLOAT = 8;
-
-    /**
-     * Id used to represent {@link JsonToken#VALUE_TRUE}
-     */
-    public final static int ID_TRUE = 9;
-
-    /**
-     * Id used to represent {@link JsonToken#VALUE_FALSE}
-     */
-    public final static int ID_FALSE = 10;
-    /**
-     * Id used to represent {@link JsonToken#VALUE_NULL}
-     */
-
-    public final static int ID_NULL = 11;
-
-    /**
-     * Id used to represent {@link JsonToken#VALUE_EMBEDDED_OBJECT}
-     */
-    public final static int ID_EMBEDDED_OBJECT = 12;
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/ObjectCodec.java

@@ -1,185 +0,0 @@
-/* Jackson JSON-processor.
- *
- * Copyright (c) 2007- Tatu Saloranta, tatu.saloranta@iki.fi
- */
-
-package com.fr.third.fasterxml.jackson.core;
-
-import java.io.IOException;
-import java.util.Iterator;
-
-import com.fr.third.fasterxml.jackson.core.type.ResolvedType;
-import com.fr.third.fasterxml.jackson.core.type.TypeReference;
-
-/**
- * Abstract class that defines the interface that {@link JsonParser} and
- * {@link JsonGenerator} use to serialize and deserialize regular
- * Java objects (POJOs aka Beans).
- *<p>
- * The standard implementation of this class is
- * <code>com.fr.third.fasterxml.jackson.databind.ObjectMapper</code>,
- * defined in the "jackson-databind".
- */
-public abstract class ObjectCodec
-    extends TreeCodec // since 2.3
-    implements Versioned // since 2.3
-{
-    protected ObjectCodec() { }
-
-    // Since 2.3: need baseline implementation to avoid backwards compatibility
-    @Override
-    public Version version() {
-        return Version.unknownVersion();
-    }
-    
-    /*
-    /**********************************************************
-    /* API for de-serialization (JSON-to-Object)
-    /**********************************************************
-     */
-
-    /**
-     * Method to deserialize JSON content into a non-container
-     * type (it can be an array type, however): typically a bean, array
-     * or a wrapper type (like {@link java.lang.Boolean}).
-     *<p>
-     * Note: this method should NOT be used if the result type is a
-     * container ({@link java.util.Collection} or {@link java.util.Map}.
-     * The reason is that due to type erasure, key and value types
-     * can not be introspected when using this method.
-     */
-    public abstract <T> T readValue(JsonParser jp, Class<T> valueType)
-        throws IOException, JsonProcessingException;
-
-    /**
-     * Method to deserialize JSON content into a Java type, reference
-     * to which is passed as argument. Type is passed using so-called
-     * "super type token" 
-     * and specifically needs to be used if the root type is a 
-     * parameterized (generic) container type.
-     */
-    public abstract <T> T readValue(JsonParser jp, TypeReference<?> valueTypeRef)
-        throws IOException, JsonProcessingException;
-
-    /**
-     * Method to deserialize JSON content into a POJO, type specified
-     * with fully resolved type object (so it can be a generic type,
-     * including containers like {@link java.util.Collection} and
-     * {@link java.util.Map}).
-     */
-    public abstract <T> T readValue(JsonParser jp, ResolvedType valueType)
-        throws IOException, JsonProcessingException;
-
-    /**
-     * Method for reading sequence of Objects from parser stream,
-     * all with same specified value type.
-     */
-    public abstract <T> Iterator<T> readValues(JsonParser jp, Class<T> valueType)
-        throws IOException, JsonProcessingException;
-
-    /**
-     * Method for reading sequence of Objects from parser stream,
-     * all with same specified value type.
-     */
-    public abstract <T> Iterator<T> readValues(JsonParser jp, TypeReference<?> valueTypeRef)
-        throws IOException, JsonProcessingException;
-    
-    /**
-     * Method for reading sequence of Objects from parser stream,
-     * all with same specified value type.
-     */
-    public abstract <T> Iterator<T> readValues(JsonParser jp, ResolvedType valueType)
-        throws IOException, JsonProcessingException;
-    
-    /*
-    /**********************************************************
-    /* API for serialization (Object-to-JSON)
-    /**********************************************************
-     */
-
-    /**
-     * Method to serialize given Java Object, using generator
-     * provided.
-     */
-    public abstract void writeValue(JsonGenerator jgen, Object value)
-        throws IOException, JsonProcessingException;
-
-    /*
-    /**********************************************************
-    /* TreeCodec pass-through methods
-    /**********************************************************
-     */
-
-    /**
-     * Method to deserialize JSON content as tree expressed
-     * using set of {@link TreeNode} instances. Returns
-     * root of the resulting tree (where root can consist
-     * of just a single node if the current event is a
-     * value event, not container).
-     */
-    @Override
-    public abstract <T extends TreeNode> T readTree(JsonParser jp)
-        throws IOException, JsonProcessingException;
-    
-    @Override
-    public abstract void writeTree(JsonGenerator jg, TreeNode tree)
-        throws IOException, JsonProcessingException;
-    
-    /**
-     * Method for construct root level Object nodes
-     * for Tree Model instances.
-     */
-    @Override
-    public abstract TreeNode createObjectNode();
-
-    /**
-     * Method for construct root level Array nodes
-     * for Tree Model instances.
-     */
-    @Override
-    public abstract TreeNode createArrayNode();
-
-    /**
-     * Method for constructing a {@link JsonParser} for reading
-     * contents of a JSON tree, as if it was external serialized
-     * JSON content.
-     */
-    @Override
-    public abstract JsonParser treeAsTokens(TreeNode n);
-
-    /*
-    /**********************************************************
-    /* Extended tree conversions beyond TreeCodec
-    /**********************************************************
-     */
-    
-    /**
-     * Convenience method for converting given JSON tree into instance of specified
-     * value type. This is equivalent to first constructing a {@link JsonParser} to
-     * iterate over contents of the tree, and using that parser for data binding.
-     */
-    public abstract <T> T treeToValue(TreeNode n, Class<T> valueType)
-        throws JsonProcessingException;
-
-    /*
-    /**********************************************************
-    /* Basic accessors
-    /**********************************************************
-     */
-
-    /**
-     * @deprecated Since 2.1: Use {@link #getFactory} instead.
-     */
-    @Deprecated
-    public abstract JsonFactory getJsonFactory();
-
-    /**
-     * Accessor for finding underlying data format factory
-     * ({@link JsonFactory}) codec will use for data binding.
-     * 
-     * @since 2.1
-     */
-    public JsonFactory getFactory() {
-        return getJsonFactory();
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/PrettyPrinter.java

@@ -1,177 +0,0 @@
-/* Jackson JSON-processor.
- *
- * Copyright (c) 2007- Tatu Saloranta, tatu.saloranta@iki.fi
- */
-
-package com.fr.third.fasterxml.jackson.core;
-
-import java.io.IOException;
-
-/**
- * Interface for objects that implement pretty printer functionality, such
- * as indentation.
- * Pretty printers are used to add white space in output JSON content,
- * to make results more human readable. Usually this means things like adding
- * linefeeds and indentation.
- *<p>
- * Note: since Jackson 2.1, stateful implementations MUST implement
- * {@link com.fr.third.fasterxml.jackson.core.util.Instantiatable} interface,
- * to allow for constructing  per-generation instances and avoid
- * state corruption (see [JACKSON-851] for details).
- * Stateless implementations need not do this; but those are less common.
- */
-public interface PrettyPrinter
-{
-    /*
-    /**********************************************************
-    /* First methods that act both as events, and expect
-    /* output for correct functioning (i.e something gets
-    /* output even when not pretty-printing)
-    /**********************************************************
-     */
-
-    // // // Root-level handling:
-
-    /**
-     * Method called after a root-level value has been completely
-     * output, and before another value is to be output.
-     *<p>
-     * Default
-     * handling (without pretty-printing) will output a space, to
-     * allow values to be parsed correctly. Pretty-printer is
-     * to output some other suitable and nice-looking separator
-     * (tab(s), space(s), linefeed(s) or any combination thereof).
-     */
-    void writeRootValueSeparator(JsonGenerator jg)
-        throws IOException, JsonGenerationException;
-
-    // // Object handling
-
-    /**
-     * Method called when an Object value is to be output, before
-     * any fields are output.
-     *<p>
-     * Default handling (without pretty-printing) will output
-     * the opening curly bracket.
-     * Pretty-printer is
-     * to output a curly bracket as well, but can surround that
-     * with other (white-space) decoration.
-     */
-    void writeStartObject(JsonGenerator jg)
-        throws IOException, JsonGenerationException;
-
-    /**
-     * Method called after an Object value has been completely output
-     * (minus closing curly bracket).
-     *<p>
-     * Default handling (without pretty-printing) will output
-     * the closing curly bracket.
-     * Pretty-printer is
-     * to output a curly bracket as well, but can surround that
-     * with other (white-space) decoration.
-     *
-     * @param nrOfEntries Number of direct members of the array that
-     *   have been output
-     */
-    void writeEndObject(JsonGenerator jg, int nrOfEntries)
-        throws IOException, JsonGenerationException;
-
-    /**
-     * Method called after an object entry (field:value) has been completely
-     * output, and before another value is to be output.
-     *<p>
-     * Default handling (without pretty-printing) will output a single
-     * comma to separate the two. Pretty-printer is
-     * to output a comma as well, but can surround that with other
-     * (white-space) decoration.
-     */
-    void writeObjectEntrySeparator(JsonGenerator jg)
-        throws IOException, JsonGenerationException;
-
-    /**
-     * Method called after an object field has been output, but
-     * before the value is output.
-     *<p>
-     * Default handling (without pretty-printing) will output a single
-     * colon to separate the two. Pretty-printer is
-     * to output a colon as well, but can surround that with other
-     * (white-space) decoration.
-     */
-    void writeObjectFieldValueSeparator(JsonGenerator jg)
-        throws IOException, JsonGenerationException;
-
-    // // // Array handling
-
-    /**
-     * Method called when an Array value is to be output, before
-     * any member/child values are output.
-     *<p>
-     * Default handling (without pretty-printing) will output
-     * the opening bracket.
-     * Pretty-printer is
-     * to output a bracket as well, but can surround that
-     * with other (white-space) decoration.
-     */
-    void writeStartArray(JsonGenerator jg)
-        throws IOException, JsonGenerationException;
-
-    /**
-     * Method called after an Array value has been completely output
-     * (minus closing bracket).
-     *<p>
-     * Default handling (without pretty-printing) will output
-     * the closing bracket.
-     * Pretty-printer is
-     * to output a bracket as well, but can surround that
-     * with other (white-space) decoration.
-     *
-     * @param nrOfValues Number of direct members of the array that
-     *   have been output
-     */
-    void writeEndArray(JsonGenerator jg, int nrOfValues)
-        throws IOException, JsonGenerationException;
-
-    /**
-     * Method called after an array value has been completely
-     * output, and before another value is to be output.
-     *<p>
-     * Default handling (without pretty-printing) will output a single
-     * comma to separate the two. Pretty-printer is
-     * to output a comma as well, but can surround that with other
-     * (white-space) decoration.
-     */
-    void writeArrayValueSeparator(JsonGenerator jg)
-        throws IOException, JsonGenerationException;
-
-    /*
-    /**********************************************************
-    /* Then events that by default do not produce any output
-    /* but that are often overridden to add white space
-    /* in pretty-printing mode
-    /**********************************************************
-     */
-
-    /**
-     * Method called after array start marker has been output,
-     * and right before the first value is to be output.
-     * It is <b>not</b> called for arrays with no values.
-     *<p>
-     * Default handling does not output anything, but pretty-printer
-     * is free to add any white space decoration.
-     */
-    void beforeArrayValues(JsonGenerator jg)
-        throws IOException, JsonGenerationException;
-
-    /**
-     * Method called after object start marker has been output,
-     * and right before the field name of the first entry is
-     * to be output.
-     * It is <b>not</b> called for objects without entries.
-     *<p>
-     * Default handling does not output anything, but pretty-printer
-     * is free to add any white space decoration.
-     */
-    void beforeObjectEntries(JsonGenerator jg)
-        throws IOException, JsonGenerationException;
-}
-

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/SerializableString.java

@@ -1,156 +0,0 @@
-/* Jackson JSON-processor.
- *
- * Copyright (c) 2007- Tatu Saloranta, tatu.saloranta@iki.fi
- */
-
-package com.fr.third.fasterxml.jackson.core;
-
-import java.io.IOException;
-import java.io.OutputStream;
-import java.nio.ByteBuffer;
-
-/**
- * Interface that defines how Jackson package can interact with efficient
- * pre-serialized or lazily-serialized and reused String representations.
- * Typically implementations store possible serialized version(s) so that
- * serialization of String can be done more efficiently, especially when
- * used multiple times.
- *<p>
- * Note that "quoted" in methods means quoting of 'special' characters using
- * JSON backlash notation (and not use of actual double quotes).
- * 
- * @see com.fr.third.fasterxml.jackson.core.io.SerializedString
- */
-public interface SerializableString
-{
-    /**
-     * Returns unquoted String that this object represents (and offers
-     * serialized forms for)
-     */
-    String getValue();
-    
-    /**
-     * Returns length of the (unquoted) String as characters.
-     * Functionally equvalent to:
-     *<pre>
-     *   getValue().length();
-     *</pre>
-     */
-    int charLength();
-
-    /*
-    /**********************************************************
-    /* Accessors for byte sequences
-    /**********************************************************
-     */
-    
-    /**
-     * Returns JSON quoted form of the String, as character array.
-     * Result can be embedded as-is in textual JSON as property name or JSON String.
-     */
-    char[] asQuotedChars();
-
-    /**
-     * Returns UTF-8 encoded version of unquoted String.
-     * Functionally equivalent to (but more efficient than):
-     *<pre>
-     * getValue().getBytes("UTF-8");
-     *</pre>
-     */
-    byte[] asUnquotedUTF8();
-
-    /**
-     * Returns UTF-8 encoded version of JSON-quoted String.
-     * Functionally equivalent to (but more efficient than):
-     *<pre>
-     * new String(asQuotedChars()).getBytes("UTF-8");
-     *</pre>
-     */
-    byte[] asQuotedUTF8();
-
-    /*
-    /**********************************************************
-    /* Helper methods for appending byte/char sequences
-    /**********************************************************
-     */
-
-    /**
-     * Method that will append quoted UTF-8 bytes of this String into given
-     * buffer, if there is enough room; if not, returns -1.
-     * Functionally equivalent to:
-     *<pre>
-     *  byte[] bytes = str.asQuotedUTF8();
-     *  System.arraycopy(bytes, 0, buffer, offset, bytes.length);
-     *  return bytes.length;
-     *</pre>
-     * 
-     * @return Number of bytes appended, if successful, otherwise -1
-     */
-    int appendQuotedUTF8(byte[] buffer, int offset);
-
-    /**
-     * Method that will append quoted characters of this String into given
-     * buffer. Functionally equivalent to:
-     *<pre>
-     *  char[] ch = str.asQuotedChars();
-     *  System.arraycopy(ch, 0, buffer, offset, ch.length);
-     *  return ch.length;
-     *</pre>
-     * 
-     * @return Number of characters appended, if successful, otherwise -1
-     */
-    int appendQuoted(char[] buffer, int offset);
-    
-    /**
-     * Method that will append unquoted ('raw') UTF-8 bytes of this String into given
-     * buffer. Functionally equivalent to:
-     *<pre>
-     *  byte[] bytes = str.asUnquotedUTF8();
-     *  System.arraycopy(bytes, 0, buffer, offset, bytes.length);
-     *  return bytes.length;
-     *</pre>
-     * 
-     * @return Number of bytes appended, if successful, otherwise -1
-     */
-    int appendUnquotedUTF8(byte[] buffer, int offset);
-
-    
-    /**
-     * Method that will append unquoted characters of this String into given
-     * buffer. Functionally equivalent to:
-     *<pre>
-     *  char[] ch = str.getValue().toCharArray();
-     *  System.arraycopy(bytes, 0, buffer, offset, ch.length);
-     *  return ch.length;
-     *</pre>
-     * 
-     * @return Number of characters appended, if successful, otherwise -1
-     */
-    int appendUnquoted(char[] buffer, int offset);
-
-    /*
-    /**********************************************************
-    /* Helper methods for writing out byte sequences
-    /**********************************************************
-     */
-
-    /**
-     * @return Number of bytes written
-     */
-    int writeQuotedUTF8(OutputStream out) throws IOException;
-
-    /**
-     * @return Number of bytes written
-     */
-    int writeUnquotedUTF8(OutputStream out) throws IOException;
-
-    /**
-     * @return Number of bytes put, if successful, otherwise -1
-     */
-    int putQuotedUTF8(ByteBuffer buffer) throws IOException;
-
-    /**
-     * @return Number of bytes put, if successful, otherwise -1
-     */
-    int putUnquotedUTF8(ByteBuffer out) throws IOException;
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/TreeCodec.java

@@ -1,23 +0,0 @@
-package com.fr.third.fasterxml.jackson.core;
-
-import java.io.IOException;
-
-/**
- * Interface that defines objects that can read and write
- * {@link TreeNode} instances using Streaming API.
- * 
- * @since 2.3
- */
-public abstract class TreeCodec
-{
-    public abstract <T extends TreeNode> T readTree(JsonParser jp)
-        throws IOException, JsonProcessingException;
-
-    public abstract void writeTree(JsonGenerator jg, TreeNode tree)
-        throws IOException, JsonProcessingException;
-
-    public abstract TreeNode createArrayNode();
-    public abstract TreeNode createObjectNode();
-
-    public abstract JsonParser treeAsTokens(TreeNode node);
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/TreeNode.java

@@ -1,276 +0,0 @@
-/* Jackson JSON-processor.
- *
- * Copyright (c) 2007- Tatu Saloranta, tatu.saloranta@iki.fi
- */
-
-package com.fr.third.fasterxml.jackson.core;
-
-import java.util.Iterator;
-
-/**
- * Marker interface used to denote JSON Tree nodes, as far as
- * the core package knows them (which is very little): mostly
- * needed to allow {@link ObjectCodec} to have some level
- * of interoperability.
- * Most functionality is within <code>JsonNode</code>
- * base class in <code>mapper</code> package.
- *<p>
- * Note that in Jackson 1.x <code>JsonNode</code> itself
- * was part of core package: Jackson 2.x refactored this
- * since conceptually Tree Model is part of mapper package,
- * and so part visible to <code>core</code> package should
- * be minimized.
- *<p>
- * NOTE: starting with Jackson 2.2, there is more functionality
- * available via this class, and the intent is that this should
- * form actual base for multiple alternative tree representations;
- * for example, immutable trees could use different implementation
- * than mutable trees. It should also be possible to move actual
- * Tree Model implementation out of databind package eventually
- * (Jackson 3?).
- * 
- * @since 2.2
- */
-public interface TreeNode
-{
-    /*
-    /**********************************************************
-    /* Minimal introspection methods
-    /**********************************************************
-     */
-    
-    /**
-     * Method that can be used for efficient type detection
-     * when using stream abstraction for traversing nodes.
-     * Will return the first {@link JsonToken} that equivalent
-     * stream event would produce (for most nodes there is just
-     * one token but for structured/container types multiple)
-     */
-    JsonToken asToken();
-
-    /**
-     * If this node is a numeric type (as per {@link JsonToken#isNumeric}),
-     * returns native type that node uses to store the numeric value;
-     * otherwise returns null.
-     * 
-     * @return Type of number contained, if any; or null if node does not
-     *  contain numeric value.
-     */
-    JsonParser.NumberType numberType();
-
-    /**
-     * Method that returns number of child nodes this node contains:
-     * for Array nodes, number of child elements, for Object nodes,
-     * number of fields, and for all other nodes 0.
-     *
-     * @return For non-container nodes returns 0; for arrays number of
-     *   contained elements, and for objects number of fields.
-     * 
-     * @since 2.2
-     */
-    int size();
-
-    /**
-     * Method that returns true for all value nodes: ones that 
-     * are not containers, and that do not represent "missing" nodes
-     * in the path. Such value nodes represent String, Number, Boolean
-     * and null values from JSON.
-     *<p>
-     * Note: one and only one of methods {@link #isValueNode},
-     * {@link #isContainerNode} and {@link #isMissingNode} ever
-     * returns true for any given node.
-     * 
-     * @since 2.2
-     */
-    boolean isValueNode();
-
-    /**
-     * Method that returns true for container nodes: Arrays and Objects.
-     *<p>
-     * Note: one and only one of methods {@link #isValueNode},
-     * {@link #isContainerNode} and {@link #isMissingNode} ever
-     * returns true for any given node.
-     * 
-     * @since 2.2
-     */
-    boolean isContainerNode();
-    
-    /**
-     * Method that returns true for "virtual" nodes which represent
-     * missing entries constructed by path accessor methods when
-     * there is no actual node matching given criteria.
-     *<p>
-     * Note: one and only one of methods {@link #isValueNode},
-     * {@link #isContainerNode} and {@link #isMissingNode} ever
-     * returns true for any given node.
-     * 
-     * @since 2.2
-     */
-    boolean isMissingNode();
-    
-    /**
-     * Method that returns true if this node is an Array node, false
-     * otherwise.
-     * Note that if true is returned, {@link #isContainerNode}
-     * must also return true.
-     * 
-     * @since 2.2
-     */
-    boolean isArray();
-
-    /**
-     * Method that returns true if this node is an Object node, false
-     * otherwise.
-     * Note that if true is returned, {@link #isContainerNode}
-     * must also return true.
-     * 
-     * @since 2.2
-     */
-    boolean isObject();
-
-    /*
-    /**********************************************************
-    /* Basic traversal through structured entries (Arrays, Objects)
-    /**********************************************************
-     */
-
-    /**
-     * Method for accessing value of the specified field of
-     * an object node. If this node is not an object (or it
-     * does not have a value for specified field name), or
-     * if there is no field with such name, null is returned.
-     *<p>
-     * NOTE: handling of explicit null values may vary between
-     * implementations; some trees may retain explicit nulls, others
-     * not.
-     * 
-     * @return Node that represent value of the specified field,
-     *   if this node is an object and has value for the specified
-     *   field. Null otherwise.
-     * 
-     * @since 2.2
-     */
-    TreeNode get(String fieldName);
-
-    /**
-     * Method for accessing value of the specified element of
-     * an array node. For other nodes, null is returned.
-     *<p>
-     * For array nodes, index specifies
-     * exact location within array and allows for efficient iteration
-     * over child elements (underlying storage is guaranteed to
-     * be efficiently indexable, i.e. has random-access to elements).
-     * If index is less than 0, or equal-or-greater than
-     * <code>node.size()</code>, null is returned; no exception is
-     * thrown for any index.
-     *
-     * @return Node that represent value of the specified element,
-     *   if this node is an array and has specified element.
-     *   Null otherwise.
-     * 
-     * @since 2.2
-     */
-    TreeNode get(int index);
-
-    /**
-     * Method for accessing value of the specified field of
-     * an object node.
-     * For other nodes, a "missing node" (virtual node
-     * for which {@link #isMissingNode} returns true) is returned.
-     * 
-     * @return Node that represent value of the specified field,
-     *   if this node is an object and has value for the specified field;
-     *   otherwise "missing node" is returned.
-     * 
-     * @since 2.2
-     */
-    TreeNode path(String fieldName);
-
-    /**
-     * Method for accessing value of the specified element of
-     * an array node.
-     * For other nodes, a "missing node" (virtual node
-     * for which {@link #isMissingNode} returns true) is returned.
-     *<p>
-     * For array nodes, index specifies
-     * exact location within array and allows for efficient iteration
-     * over child elements (underlying storage is guaranteed to
-     * be efficiently indexable, i.e. has random-access to elements).
-     * If index is less than 0, or equal-or-greater than
-     * <code>node.size()</code>, "missing node" is returned; no exception is
-     * thrown for any index.
-     *
-     * @return Node that represent value of the specified element,
-     *   if this node is an array and has specified element;
-     *   otherwise "missing node" is returned.
-     * 
-     * @since 2.2
-     */
-    TreeNode path(int index);
-    
-    /**
-     * Method for accessing names of all fields for this node, iff
-     * this node is an Object node. Number of field names accessible
-     * will be {@link #size}.
-     * 
-     * @since 2.2
-     */
-    Iterator<String> fieldNames();
-
-    /**
-     * Method for locating node specified by given JSON pointer instances.
-     * Method will never return null; if no matching node exists, 
-     *   will return a node for which {@link TreeNode#isMissingNode()} returns true.
-     * 
-     * @return Node that matches given JSON Pointer: if no match exists,
-     *   will return a node for which {@link TreeNode#isMissingNode()} returns true.
-     * 
-     * @since 2.3
-     */
-    TreeNode at(JsonPointer ptr);
-
-    /**
-     * Convenience method that is functionally equivalent to:
-     *<pre>
-     *   return at(JsonPointer.valueOf(jsonPointerExpression));
-     *</pre>
-     *<p>
-     * Note that if the same expression is used often, it is preferable to construct
-     * {@link JsonPointer} instance once and reuse it: this method will not perform
-     * any caching of compiled expressions.
-     * 
-     * @param jsonPointerExpression Expression to compile as a {@link JsonPointer}
-     *   instance
-     * 
-     * @return Node that matches given JSON Pointer: if no match exists,
-     *   will return a node for which {@link TreeNode#isMissingNode()} returns true.
-     * 
-     * @since 2.3
-     */
-    TreeNode at(String jsonPointerExpression)
-        throws IllegalArgumentException;
-    
-    /*
-    /**********************************************************
-    /* Converting to/from Streaming API
-    /**********************************************************
-     */
-
-    /**
-     * Method for constructing a {@link JsonParser} instance for
-     * iterating over contents of the tree that this node is root of.
-     * Functionally equivalent to first serializing tree using
-     * {@link ObjectCodec} and then re-parsing but
-     * more efficient.
-     */
-    JsonParser traverse();
-
-    /**
-     * Same as {@link #traverse()}, but additionally passes {@link com.fr.third.fasterxml.jackson.core.ObjectCodec}
-     * to use if {@link JsonParser#readValueAs(Class)} is used (otherwise caller must call
-     * {@link JsonParser#setCodec} on response explicitly).
-     * 
-     * @since 2.1
-     */
-    JsonParser traverse(ObjectCodec codec);
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/Version.java

@@ -1,141 +0,0 @@
-/* Jackson JSON-processor.
- *
- * Copyright (c) 2007- Tatu Saloranta, tatu.saloranta@iki.fi
- */
-
-package com.fr.third.fasterxml.jackson.core;
-
-/**
- * Object that encapsulates versioning information of a component.
- * Version information includes not just version number but also
- * optionally group and artifact ids of the component being versioned.
- *<p>
- * Note that optional group and artifact id properties are new with Jackson 2.0:
- * if provided, they should align with Maven artifact information.
- */
-public class Version
-    implements Comparable<Version>,
-        java.io.Serializable
-{
-    private static final long serialVersionUID = 1L;
-
-    private final static Version UNKNOWN_VERSION = new Version(0, 0, 0, null, null, null);
-    
-    protected final int _majorVersion;
-
-    protected final int _minorVersion;
-
-    protected final int _patchLevel;
-
-    protected final String _groupId;
-    
-    protected final String _artifactId;
-    
-    /**
-     * Additional information for snapshot versions; null for non-snapshot
-     * (release) versions.
-     */
-    protected final String _snapshotInfo;
-
-    /**
-     * @deprecated Use variant that takes group and artifact ids
-     * 
-     * @since 2.1
-     */
-    @Deprecated
-    public Version(int major, int minor, int patchLevel, String snapshotInfo)
-    {
-        this(major, minor, patchLevel, snapshotInfo, null, null);
-    }
-    
-    public Version(int major, int minor, int patchLevel, String snapshotInfo,
-            String groupId, String artifactId)
-    {
-        _majorVersion = major;
-        _minorVersion = minor;
-        _patchLevel = patchLevel;
-        _snapshotInfo = snapshotInfo;
-        _groupId = (groupId == null) ? "" : groupId;
-        _artifactId = (artifactId == null) ? "" : artifactId;
-    }
-
-    /**
-     * Method returns canonical "not known" version, which is used as version
-     * in cases where actual version information is not known (instead of null).
-     */
-    public static Version unknownVersion() { return UNKNOWN_VERSION; }
-
-    public boolean isUknownVersion() { return (this == UNKNOWN_VERSION); }
-    public boolean isSnapshot() { return (_snapshotInfo != null && _snapshotInfo.length() > 0); }
-    
-    public int getMajorVersion() { return _majorVersion; }
-    public int getMinorVersion() { return _minorVersion; }
-    public int getPatchLevel() { return _patchLevel; }
-
-    public String getGroupId() { return _groupId; }
-    public String getArtifactId() { return _artifactId; }
-    
-    public String toFullString() {
-        return new StringBuilder()
-        	.append(_groupId)
-        	.append('/')
-        	.append(_artifactId)
-        	.append('/')
-        	.append(toString())
-        	.toString();
-    }
-    
-    @Override
-    public String toString()
-    {
-        StringBuilder sb = new StringBuilder();
-        sb.append(_majorVersion).append('.');
-        sb.append(_minorVersion).append('.');
-        sb.append(_patchLevel);
-        if (isSnapshot()) {
-            sb.append('-').append(_snapshotInfo);
-        }
-        return sb.toString();
-    }
-
-    @Override
-    public int hashCode() {
-        return _artifactId.hashCode() ^ _groupId.hashCode() + _majorVersion - _minorVersion + _patchLevel;
-    }
-
-    @Override
-    public boolean equals(Object o)
-    {
-        if (o == this) return true;
-        if (o == null) return false;
-        if (o.getClass() != getClass()) return false;
-        Version other = (Version) o;
-        return (other._majorVersion == _majorVersion)
-            && (other._minorVersion == _minorVersion)
-            && (other._patchLevel == _patchLevel)
-            && other._artifactId.equals(_artifactId)
-            && other._groupId.equals(_groupId)
-            ;
-    }
-
-    @Override
-    public int compareTo(Version other)
-    {
-        if (other == this) return 0;
-        
-        int diff = _groupId.compareTo(other._groupId);
-        if (diff == 0) {
-            diff = _artifactId.compareTo(other._artifactId);
-            if (diff == 0) {
-                diff = _majorVersion - other._majorVersion;
-                if (diff == 0) {
-                    diff = _minorVersion - other._minorVersion;
-                    if (diff == 0) {
-                        diff = _patchLevel - other._patchLevel;
-                    }
-                }
-            }
-        }
-        return diff;
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/Versioned.java

@@ -1,23 +0,0 @@
-/* Jackson JSON-processor.
- *
- * Copyright (c) 2007- Tatu Saloranta, tatu.saloranta@iki.fi
- */
-
-package com.fr.third.fasterxml.jackson.core;
-
-/**
- * Interface that those Jackson components that are explicitly versioned will implement.
- * Intention is to allow both plug-in components (custom extensions) and applications and
- * frameworks that use Jackson to detect exact version of Jackson in use.
- * This may be useful for example for ensuring that proper Jackson version is deployed
- * (beyond mechanisms that deployment system may have), as well as for possible
- * workarounds.
- */
-public interface Versioned {
-    /**
-     * Method called to detect version of the component that implements this interface;
-     * returned version should never be null, but may return specific "not available"
-     * instance (see {@link Version} for details).
-     */
-    Version version();
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/base/GeneratorBase.java

@@ -1,317 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.base;
-
-import java.io.*;
-
-import com.fr.third.fasterxml.jackson.core.*;
-import com.fr.third.fasterxml.jackson.core.json.DupDetector;
-import com.fr.third.fasterxml.jackson.core.json.JsonWriteContext;
-import com.fr.third.fasterxml.jackson.core.util.DefaultPrettyPrinter;
-import com.fr.third.fasterxml.jackson.core.util.VersionUtil;
-
-/**
- * This base class implements part of API that a JSON generator exposes
- * to applications, adds shared internal methods that sub-classes
- * can use and adds some abstract methods sub-classes must implement.
- */
-public abstract class GeneratorBase
-    extends JsonGenerator
-{
-    /*
-    /**********************************************************
-    /* Configuration
-    /**********************************************************
-     */
-
-    protected ObjectCodec _objectCodec;
-
-    /**
-     * Bit flag composed of bits that indicate which
-     * {@link com.fr.third.fasterxml.jackson.core.JsonGenerator.Feature}s
-     * are enabled.
-     */
-    protected int _features;
-
-    /**
-     * Flag set to indicate that implicit conversion from number
-     * to JSON String is needed (as per
-     * {@link com.fr.third.fasterxml.jackson.core.JsonGenerator.Feature#WRITE_NUMBERS_AS_STRINGS}).
-     */
-    protected boolean _cfgNumbersAsStrings;
-    
-    /*
-    /**********************************************************
-    /* State
-    /**********************************************************
-     */
-
-    /**
-     * Object that keeps track of the current contextual state
-     * of the generator.
-     */
-    protected JsonWriteContext _writeContext;
-
-    /**
-     * Flag that indicates whether generator is closed or not. Gets
-     * set when it is closed by an explicit call
-     * ({@link #close}).
-     */
-    protected boolean _closed;
-
-    /*
-    /**********************************************************
-    /* Life-cycle
-    /**********************************************************
-     */
-
-    protected GeneratorBase(int features, ObjectCodec codec)
-    {
-        super();
-        _features = features;
-        DupDetector dups = Feature.STRICT_DUPLICATE_DETECTION.enabledIn(features)
-                ? DupDetector.rootDetector(this) : null;
-        _writeContext = JsonWriteContext.createRootContext(dups);
-        _objectCodec = codec;
-        _cfgNumbersAsStrings = Feature.WRITE_NUMBERS_AS_STRINGS.enabledIn(features);
-    }
-
-    /**
-     * Implemented with detection that tries to find "VERSION.txt" in same
-     * package as the implementation class.
-     */
-    @Override
-    public Version version() {
-        return VersionUtil.versionFor(getClass());
-    }
-    
-    /*
-    /**********************************************************
-    /* Configuration
-    /**********************************************************
-     */
-
-    @Override
-    public JsonGenerator enable(Feature f) {
-        _features |= f.getMask();
-        if (f == Feature.WRITE_NUMBERS_AS_STRINGS) {
-            _cfgNumbersAsStrings = true;
-        } else if (f == Feature.ESCAPE_NON_ASCII) {
-            setHighestNonEscapedChar(127);
-        }
-        return this;
-    }
-
-    @Override
-    public JsonGenerator disable(Feature f) {
-        _features &= ~f.getMask();
-        if (f == Feature.WRITE_NUMBERS_AS_STRINGS) {
-            _cfgNumbersAsStrings = false;
-        } else if (f == Feature.ESCAPE_NON_ASCII) {
-            setHighestNonEscapedChar(0);
-        }
-        return this;
-    }
-
-    //public JsonGenerator configure(Feature f, boolean state) { }
-
-    @Override
-    public final boolean isEnabled(Feature f) {
-        return (_features & f.getMask()) != 0;
-    }
-
-    @Override
-    public int getFeatureMask() {
-        return _features;
-    }
-
-    @Override
-    public JsonGenerator setFeatureMask(int mask) {
-        _features = mask;
-        return this;
-    }
-    
-    @Override
-    public JsonGenerator useDefaultPrettyPrinter() {
-        /* 28-Sep-2012, tatu: As per [Issue#84], should not override a
-         *  pretty printer if one already assigned.
-         */
-        if (getPrettyPrinter() != null) {
-            return this;
-        }
-        return setPrettyPrinter(new DefaultPrettyPrinter());
-    }
-    
-    @Override
-    public JsonGenerator setCodec(ObjectCodec oc) {
-        _objectCodec = oc;
-        return this;
-    }
-
-    @Override
-    public final ObjectCodec getCodec() { return _objectCodec; }
-
-    /*
-    /**********************************************************
-    /* Public API, accessors
-    /**********************************************************
-     */
-
-    /**
-     * Note: co-variant return type.
-     */
-    @Override
-    public final JsonWriteContext getOutputContext() { return _writeContext; }
-
-    /*
-    /**********************************************************
-    /* Public API, write methods, structural
-    /**********************************************************
-     */
-
-    //public void writeStartArray() throws IOException
-    //public void writeEndArray() throws IOException
-    //public void writeStartObject() throws IOException
-    //public void writeEndObject() throws IOException
-
-    /*
-    /**********************************************************
-    /* Public API, write methods, textual
-    /**********************************************************
-     */
-
-    @Override
-    public void writeFieldName(SerializableString name) throws IOException {
-        writeFieldName(name.getValue());
-    }
-    
-    //public abstract void writeString(String text) throws IOException;
-
-    //public abstract void writeString(char[] text, int offset, int len) throws IOException;
-
-    //public abstract void writeRaw(String text) throws IOException;
-
-    //public abstract void writeRaw(char[] text, int offset, int len) throws IOException;
-
-    @Override
-    public void writeString(SerializableString text) throws IOException {
-        writeString(text.getValue());
-    }
-    
-    @Override
-    public void writeRawValue(String text) throws IOException {
-        _verifyValueWrite("write raw value");
-        writeRaw(text);
-    }
-
-    @Override
-    public void writeRawValue(String text, int offset, int len) throws IOException {
-        _verifyValueWrite("write raw value");
-        writeRaw(text, offset, len);
-    }
-
-    @Override
-    public void writeRawValue(char[] text, int offset, int len) throws IOException {
-        _verifyValueWrite("write raw value");
-        writeRaw(text, offset, len);
-    }
-
-    @Override
-    public int writeBinary(Base64Variant b64variant, InputStream data, int dataLength) throws IOException {
-        // Let's implement this as "unsupported" to make it easier to add new parser impls
-        _reportUnsupportedOperation();
-        return 0;
-    }
-
-    /*
-   /**********************************************************
-   /* Public API, write methods, primitive
-   /**********************************************************
-    */
-
-    // Not implemented at this level, added as placeholders
-
-     /*
-    public abstract void writeNumber(int i)
-    public abstract void writeNumber(long l)
-    public abstract void writeNumber(double d)
-    public abstract void writeNumber(float f)
-    public abstract void writeNumber(BigDecimal dec)
-    public abstract void writeBoolean(boolean state)
-    public abstract void writeNull()
-    */
-
-    /*
-    /**********************************************************
-    /* Public API, write methods, POJOs, trees
-    /**********************************************************
-     */
-
-    @Override
-    public void writeObject(Object value) throws IOException
-    {
-        if (value == null) {
-            // important: call method that does check value write:
-            writeNull();
-        } else {
-            /* 02-Mar-2009, tatu: we are NOT to call _verifyValueWrite here,
-             *   because that will be done when codec actually serializes
-             *   contained POJO. If we did call it it would advance state
-             *   causing exception later on
-             */
-            if (_objectCodec != null) {
-                _objectCodec.writeValue(this, value);
-                return;
-            }
-            _writeSimpleObject(value);
-        }
-    }
-
-    @Override
-    public void writeTree(TreeNode rootNode) throws IOException
-    {
-        // As with 'writeObject()', we are not check if write would work
-        if (rootNode == null) {
-            writeNull();
-        } else {
-            if (_objectCodec == null) {
-                throw new IllegalStateException("No ObjectCodec defined");
-            }
-            _objectCodec.writeValue(this, rootNode);
-        }
-    }
-
-    /*
-    /**********************************************************
-    /* Public API, low-level output handling
-    /**********************************************************
-     */
-
-    @Override public abstract void flush() throws IOException;
-    @Override public void close() throws IOException { _closed = true; }
-    @Override public boolean isClosed() { return _closed; }
-
-    /*
-    /**********************************************************
-    /* Package methods for this, sub-classes
-    /**********************************************************
-     */
-
-    /**
-     * Method called to release any buffers generator may be holding,
-     * once generator is being closed.
-     */
-    protected abstract void _releaseBuffers();
-
-    /**
-     * Method called before trying to write a value (scalar or structured),
-     * to verify that this is legal in current output state, as well as to
-     * output separators if and as necessary.
-     * 
-     * @param typeMsg Additional message used for generating exception message
-     *   if value output is NOT legal in current generator output state.
-     */
-    protected abstract void _verifyValueWrite(String typeMsg) throws IOException;
-
-    // @Deprecated in 2.3 -- now defined in super-class; remove in 2.4
-    @Override 
-    protected void _writeSimpleObject(Object value) throws IOException { super._writeSimpleObject(value); }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/base/ParserMinimalBase.java

@@ -1,574 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.base;
-
-import java.io.IOException;
-
-import com.fr.third.fasterxml.jackson.core.*;
-import com.fr.third.fasterxml.jackson.core.JsonParser.Feature;
-import com.fr.third.fasterxml.jackson.core.io.NumberInput;
-import com.fr.third.fasterxml.jackson.core.util.ByteArrayBuilder;
-import com.fr.third.fasterxml.jackson.core.util.VersionUtil;
-
-import static com.fr.third.fasterxml.jackson.core.JsonTokenId.*;
-
-/**
- * Intermediate base class used by all Jackson {@link JsonParser}
- * implementations, but does not add any additional fields that depend
- * on particular method of obtaining input.
- *<p>
- * Note that 'minimal' here mostly refers to minimal number of fields
- * (size) and functionality that is specific to certain types
- * of parser implementations; but not necessarily to number of methods.
- */
-public abstract class ParserMinimalBase
-    extends JsonParser
-{
-    // Control chars:
-    protected final static int INT_TAB = '\t';
-    protected final static int INT_LF = '\n';
-    protected final static int INT_CR = '\r';
-    protected final static int INT_SPACE = 0x0020;
-
-    // Markup
-    protected final static int INT_LBRACKET = '[';
-    protected final static int INT_RBRACKET = ']';
-    protected final static int INT_LCURLY = '{';
-    protected final static int INT_RCURLY = '}';
-    protected final static int INT_QUOTE = '"';
-    protected final static int INT_BACKSLASH = '\\';
-    protected final static int INT_SLASH = '/';
-    protected final static int INT_COLON = ':';
-    protected final static int INT_COMMA = ',';
-
-    /*
-    /**********************************************************
-    /* Minimal generally useful state
-    /**********************************************************
-     */
-    
-    /**
-     * Last token retrieved via {@link #nextToken}, if any.
-     * Null before the first call to <code>nextToken()</code>,
-     * as well as if token has been explicitly cleared
-     */
-    protected JsonToken _currToken;
-
-    /**
-     * Last cleared token, if any: that is, value that was in
-     * effect when {@link #clearCurrentToken} was called.
-     */
-    protected JsonToken _lastClearedToken;
-    
-    /*
-    /**********************************************************
-    /* Life-cycle
-    /**********************************************************
-     */
-
-    protected ParserMinimalBase() { }
-    protected ParserMinimalBase(int features) {
-        super(features);
-    }
-
-    @Override
-    public Version version() {
-        return VersionUtil.versionFor(getClass());
-    }
-    
-    /*
-    /**********************************************************
-    /* Configuration overrides if any
-    /**********************************************************
-     */
-
-    // from base class:
-
-    //public void enableFeature(Feature f)
-    //public void disableFeature(Feature f)
-    //public void setFeature(Feature f, boolean state)
-    //public boolean isFeatureEnabled(Feature f)
-
-    /*
-    /**********************************************************
-    /* JsonParser impl
-    /**********************************************************
-     */
-
-    @Override
-    public abstract JsonToken nextToken() throws IOException, JsonParseException;
-
-    @Override
-    public JsonToken getCurrentToken() {
-        return _currToken;
-    }
-
-    @Override
-    public final int getCurrentTokenId() {
-        final JsonToken t = _currToken;
-        return (t == null) ? JsonTokenId.ID_NO_TOKEN : t.id();
-    }
-    
-    @Override
-    public boolean hasCurrentToken() {
-        return _currToken != null;
-    }
-    
-    @Override
-    public JsonToken nextValue()
-        throws IOException, JsonParseException
-    {
-        /* Implementation should be as trivial as follows; only
-         * needs to change if we are to skip other tokens (for
-         * example, if comments were exposed as tokens)
-         */
-        JsonToken t = nextToken();
-        if (t == JsonToken.FIELD_NAME) {
-            t = nextToken();
-        }
-        return t;
-    }
-
-    @Override
-    public JsonParser skipChildren() throws IOException, JsonParseException
-    {
-        if (_currToken != JsonToken.START_OBJECT
-            && _currToken != JsonToken.START_ARRAY) {
-            return this;
-        }
-        int open = 1;
-
-        /* Since proper matching of start/end markers is handled
-         * by nextToken(), we'll just count nesting levels here
-         */
-        while (true) {
-            JsonToken t = nextToken();
-            if (t == null) {
-                _handleEOF();
-                /* given constraints, above should never return;
-                 * however, FindBugs doesn't know about it and
-                 * complains... so let's add dummy break here
-                 */
-                return this;
-            }
-            if (t.isStructStart()) {
-                ++open;
-            } else if (t.isStructEnd()) {
-                if (--open == 0) {
-                    return this;
-                }
-            }
-        }
-    }
-
-    /**
-     * Method sub-classes need to implement
-     */
-    protected abstract void _handleEOF() throws JsonParseException;
-
-    //public JsonToken getCurrentToken()
-
-    //public boolean hasCurrentToken()
-
-    @Override
-    public abstract String getCurrentName() throws IOException, JsonParseException;
-    
-    @Override
-    public abstract void close() throws IOException;
-
-    @Override
-    public abstract boolean isClosed();
-
-    @Override
-    public abstract JsonStreamContext getParsingContext();
-
-//    public abstract JsonLocation getTokenLocation();
-
-//   public abstract JsonLocation getCurrentLocation();
-
-    /*
-    /**********************************************************
-    /* Public API, token state overrides
-    /**********************************************************
-     */
-
-    @Override
-    public void clearCurrentToken() {
-        if (_currToken != null) {
-            _lastClearedToken = _currToken;
-            _currToken = null;
-        }
-    }
-
-    @Override
-    public JsonToken getLastClearedToken() {
-        return _lastClearedToken;
-    }
-
-    @Override
-    public abstract void overrideCurrentName(String name);
-    
-    /*
-    /**********************************************************
-    /* Public API, access to token information, text
-    /**********************************************************
-     */
-
-    @Override
-    public abstract String getText() throws IOException, JsonParseException;
-
-    @Override
-    public abstract char[] getTextCharacters() throws IOException, JsonParseException;
-
-    @Override
-    public abstract boolean hasTextCharacters();
-
-    @Override
-    public abstract int getTextLength() throws IOException, JsonParseException;
-
-    @Override
-    public abstract int getTextOffset() throws IOException, JsonParseException;  
-
-    /*
-    /**********************************************************
-    /* Public API, access to token information, binary
-    /**********************************************************
-     */
-
-    @Override
-    public abstract byte[] getBinaryValue(Base64Variant b64variant)
-        throws IOException, JsonParseException;
-
-    /*
-    /**********************************************************
-    /* Public API, access with conversion/coercion
-    /**********************************************************
-     */
-
-    @Override
-    public boolean getValueAsBoolean(boolean defaultValue) throws IOException, JsonParseException
-    {
-        JsonToken t = _currToken;
-        if (t != null) {
-            switch (t.id()) {
-            case ID_STRING:
-                String str = getText().trim();
-                if ("true".equals(str)) {
-                    return true;
-                }
-                if ("false".equals(str)) {
-                    return false;
-                }
-                if (_hasTextualNull(str)) {
-                    return false;
-                }
-                break;
-            case ID_NUMBER_INT:
-                return getIntValue() != 0;
-            case ID_TRUE:
-                return true;
-            case ID_FALSE:
-            case ID_NULL:
-                return false;
-            case ID_EMBEDDED_OBJECT:
-                Object value = this.getEmbeddedObject();
-                if (value instanceof Boolean) {
-                    return (Boolean) value;
-                }
-                break;
-            default:
-            }
-        }
-        return defaultValue;
-    }
-
-    @Override
-    public int getValueAsInt(int defaultValue) throws IOException, JsonParseException
-    {
-        JsonToken t = _currToken;
-        if (t != null) {
-            switch (t.id()) {
-            case ID_STRING:
-                String str = getText();
-                if (_hasTextualNull(str)) {
-                    return 0;
-                }
-                return NumberInput.parseAsInt(str, defaultValue);
-            case ID_NUMBER_INT:
-            case ID_NUMBER_FLOAT:
-                return getIntValue();
-            case ID_TRUE:
-                return 1;
-            case ID_FALSE:
-                return 0;
-            case ID_NULL:
-                return 0;
-            case ID_EMBEDDED_OBJECT:
-                Object value = this.getEmbeddedObject();
-                if (value instanceof Number) {
-                    return ((Number) value).intValue();
-                }
-            }
-        }
-        return defaultValue;
-    }
-    
-    @Override
-    public long getValueAsLong(long defaultValue) throws IOException, JsonParseException
-    {
-        JsonToken t = _currToken;
-        if (t != null) {
-            switch (t.id()) {
-            case ID_STRING:
-                String str = getText();
-                if (_hasTextualNull(str)) {
-                    return 0L;
-                }
-                return NumberInput.parseAsLong(str, defaultValue);
-            case ID_NUMBER_INT:
-            case ID_NUMBER_FLOAT:
-                return getLongValue();
-            case ID_TRUE:
-                return 1L;
-            case ID_FALSE:
-            case ID_NULL:
-                return 0L;
-            case ID_EMBEDDED_OBJECT:
-                Object value = this.getEmbeddedObject();
-                if (value instanceof Number) {
-                    return ((Number) value).longValue();
-                }
-            }
-        }
-        return defaultValue;
-    }
-
-    @Override
-    public double getValueAsDouble(double defaultValue) throws IOException, JsonParseException
-    {
-        JsonToken t = _currToken;
-        if (t != null) {
-            switch (t.id()) {
-            case ID_STRING:
-                String str = getText();
-                if (_hasTextualNull(str)) {
-                    return 0L;
-                }
-                return NumberInput.parseAsDouble(str, defaultValue);
-            case ID_NUMBER_INT:
-            case ID_NUMBER_FLOAT:
-                return getDoubleValue();
-            case ID_TRUE:
-                return 1.0;
-            case ID_FALSE:
-            case ID_NULL:
-                return 0.0;
-            case ID_EMBEDDED_OBJECT:
-                Object value = this.getEmbeddedObject();
-                if (value instanceof Number) {
-                    return ((Number) value).doubleValue();
-                }
-            }
-        }
-        return defaultValue;
-    }
-
-    @Override
-    public String getValueAsString(String defaultValue) throws IOException, JsonParseException
-    {
-        if (_currToken != JsonToken.VALUE_STRING) {
-            if (_currToken == null || _currToken == JsonToken.VALUE_NULL || !_currToken.isScalarValue()) {
-                return defaultValue;
-            }
-        }
-        return getText();
-    }
-    
-    /*
-    /**********************************************************
-    /* Base64 decoding
-    /**********************************************************
-     */
-
-    /**
-     * Helper method that can be used for base64 decoding in cases where
-     * encoded content has already been read as a String.
-     */
-    protected void _decodeBase64(String str, ByteArrayBuilder builder, Base64Variant b64variant)
-        throws IOException, JsonParseException
-    {
-        // just call helper method introduced in 2.2.3
-        try {
-            b64variant.decode(str, builder);
-        } catch (IllegalArgumentException e) {
-            _reportError(e.getMessage());
-        }
-    }
-
-    /**
-     * @param bindex Relative index within base64 character unit; between 0
-     *   and 3 (as unit has exactly 4 characters)
-     *   
-     * @deprecated in 2.2.3; should migrate away
-     */
-    @Deprecated
-    protected void _reportInvalidBase64(Base64Variant b64variant, char ch, int bindex, String msg)
-        throws JsonParseException
-    {
-        String base;
-        if (ch <= INT_SPACE) {
-            base = "Illegal white space character (code 0x"+Integer.toHexString(ch)+") as character #"+(bindex+1)+" of 4-char base64 unit: can only used between units";
-        } else if (b64variant.usesPaddingChar(ch)) {
-            base = "Unexpected padding character ('"+b64variant.getPaddingChar()+"') as character #"+(bindex+1)+" of 4-char base64 unit: padding only legal as 3rd or 4th character";
-        } else if (!Character.isDefined(ch) || Character.isISOControl(ch)) {
-            // Not sure if we can really get here... ? (most illegal xml chars are caught at lower level)
-            base = "Illegal character (code 0x"+Integer.toHexString(ch)+") in base64 content";
-        } else {
-            base = "Illegal character '"+ch+"' (code 0x"+Integer.toHexString(ch)+") in base64 content";
-        }
-        if (msg != null) {
-            base = base + ": " + msg;
-        }
-        throw _constructError(base);
-    }
-
-    /**
-     *   
-     * @deprecated in 2.2.3; should migrate away
-     */
-    @Deprecated
-    protected void _reportBase64EOF() throws JsonParseException {
-        throw _constructError("Unexpected end-of-String in base64 content");
-    }
-
-    /*
-    /**********************************************************
-    /* Coercion helper methods (overridable)
-    /**********************************************************
-     */
-    
-    /**
-     * Helper method used to determine whether we are currently pointing to
-     * a String value of "null" (NOT a null token); and, if so, that parser
-     * is to recognize and return it similar to if it was real null token.
-     * 
-     * @since 2.3
-     */
-    protected boolean _hasTextualNull(String value) {
-        return "null".equals(value);
-    }
-    
-    /*
-    /**********************************************************
-    /* Error reporting
-    /**********************************************************
-     */
-    
-    protected void _reportUnexpectedChar(int ch, String comment)
-        throws JsonParseException
-    {
-        if (ch < 0) { // sanity check
-            _reportInvalidEOF();
-        }
-        String msg = "Unexpected character ("+_getCharDesc(ch)+")";
-        if (comment != null) {
-            msg += ": "+comment;
-        }
-        _reportError(msg);
-    }
-
-    protected void _reportInvalidEOF()
-        throws JsonParseException
-    {
-        _reportInvalidEOF(" in "+_currToken);
-    }
-
-    protected void _reportInvalidEOF(String msg)
-        throws JsonParseException
-    {
-        _reportError("Unexpected end-of-input"+msg);
-    }
-
-    protected void _reportInvalidEOFInValue() throws JsonParseException {
-        _reportInvalidEOF(" in a value");
-    }
-
-    protected void _reportMissingRootWS(int ch) throws JsonParseException {
-        _reportUnexpectedChar(ch, "Expected space separating root-level values");
-    }
-    
-    protected void _throwInvalidSpace(int i)
-        throws JsonParseException
-    {
-        char c = (char) i;
-        String msg = "Illegal character ("+_getCharDesc(c)+"): only regular white space (\\r, \\n, \\t) is allowed between tokens";
-        _reportError(msg);
-    }
-
-    /**
-     * Method called to report a problem with unquoted control character.
-     * Note: starting with version 1.4, it is possible to suppress
-     * exception by enabling {@link Feature#ALLOW_UNQUOTED_CONTROL_CHARS}.
-     */
-    protected void _throwUnquotedSpace(int i, String ctxtDesc)
-        throws JsonParseException
-    {
-        // JACKSON-208; possible to allow unquoted control chars:
-        if (!isEnabled(Feature.ALLOW_UNQUOTED_CONTROL_CHARS) || i >= INT_SPACE) {
-            char c = (char) i;
-            String msg = "Illegal unquoted character ("+_getCharDesc(c)+"): has to be escaped using backslash to be included in "+ctxtDesc;
-            _reportError(msg);
-        }
-    }
-
-    protected char _handleUnrecognizedCharacterEscape(char ch) throws JsonProcessingException
-    {
-        // as per [JACKSON-300]
-        if (isEnabled(Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER)) {
-            return ch;
-        }
-        // and [JACKSON-548]
-        if (ch == '\'' && isEnabled(Feature.ALLOW_SINGLE_QUOTES)) {
-            return ch;
-        }
-        _reportError("Unrecognized character escape "+_getCharDesc(ch));
-        return ch;
-    }
-    
-    /*
-    /**********************************************************
-    /* Error reporting, generic
-    /**********************************************************
-     */
-
-    protected final static String _getCharDesc(int ch)
-    {
-        char c = (char) ch;
-        if (Character.isISOControl(c)) {
-            return "(CTRL-CHAR, code "+ch+")";
-        }
-        if (ch > 255) {
-            return "'"+c+"' (code "+ch+" / 0x"+Integer.toHexString(ch)+")";
-        }
-        return "'"+c+"' (code "+ch+")";
-    }
-
-    protected final void _reportError(String msg)
-        throws JsonParseException
-    {
-        throw _constructError(msg);
-    }
-
-    protected final void _wrapError(String msg, Throwable t)
-        throws JsonParseException
-    {
-        throw _constructError(msg, t);
-    }
-
-    protected final void _throwInternal() {
-        VersionUtil.throwInternal();
-    }
-
-    protected final JsonParseException _constructError(String msg, Throwable t)
-    {
-        return new JsonParseException(msg, getCurrentLocation(), t);
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/base/package-info.java

@@ -1,9 +0,0 @@
-/**
- * Base classes used by concrete Parser and Generator implementations;
- * contain functionality that is not specific to JSON or input
- * abstraction (byte vs char).
- * Most formats extend these types, although it is also possible to
- * directly extend {@link com.fr.third.fasterxml.jackson.core.JsonParser} or
- * {@link com.fr.third.fasterxml.jackson.core.JsonGenerator}.
- */
-package com.fr.third.fasterxml.jackson.core.base;

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/format/DataFormatDetector.java

@@ -1,211 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.format;
-
-import java.io.*;
-import java.util.*;
-
-import com.fr.third.fasterxml.jackson.core.*;
-
-/**
- * Simple helper class that allows data format (content type) auto-detection,
- * given an ordered set of {@link JsonFactory} instances to use for actual low-level
- * detection.
- */
-public class DataFormatDetector
-{
-    /**
-     * By default we will look ahead at most 64 bytes; in most cases,
-     * much less (4 bytes or so) is needed, but we will allow bit more
-     * leniency to support data formats that need more complex heuristics.
-     */
-    public final static int DEFAULT_MAX_INPUT_LOOKAHEAD = 64;
-    
-    /**
-     * Ordered list of factories which both represent data formats to
-     * detect (in precedence order, starting with highest) and are used
-     * for actual detection.
-     */
-    protected final JsonFactory[] _detectors;
-
-    /**
-     * Strength of match we consider to be good enough to be used
-     * without checking any other formats.
-     * Default value is {@link MatchStrength#SOLID_MATCH}, 
-     */
-    protected final MatchStrength _optimalMatch;
-
-    /**
-     * Strength of minimal match we accept as the answer, unless
-     * better matches are found. 
-     * Default value is {@link MatchStrength#WEAK_MATCH}, 
-     */
-    protected final MatchStrength _minimalMatch;
-
-    /**
-     * Maximum number of leading bytes of the input that we can read
-     * to determine data format.
-     *<p>
-     * Default value is {@link #DEFAULT_MAX_INPUT_LOOKAHEAD}.
-     */
-    protected final int _maxInputLookahead;
-    
-    /*
-    /**********************************************************
-    /* Construction
-    /**********************************************************
-     */
-    
-    public DataFormatDetector(JsonFactory... detectors) {
-        this(detectors, MatchStrength.SOLID_MATCH, MatchStrength.WEAK_MATCH,
-            DEFAULT_MAX_INPUT_LOOKAHEAD);
-    }
-
-    public DataFormatDetector(Collection<JsonFactory> detectors) {
-        this(detectors.toArray(new JsonFactory[detectors.size()]));
-    }
-
-    /**
-     * Method that will return a detector instance that uses given
-     * optimal match level (match that is considered sufficient to return, without
-     * trying to find stronger matches with other formats).
-     */
-    public DataFormatDetector withOptimalMatch(MatchStrength optMatch) {
-        if (optMatch == _optimalMatch) {
-            return this;
-        }
-        return new DataFormatDetector(_detectors, optMatch, _minimalMatch, _maxInputLookahead);
-    }
-    /**
-     * Method that will return a detector instance that uses given
-     * minimal match level; match that may be returned unless a stronger match
-     * is found with other format detectors.
-     */
-    public DataFormatDetector withMinimalMatch(MatchStrength minMatch) {
-        if (minMatch == _minimalMatch) {
-            return this;
-        }
-        return new DataFormatDetector(_detectors, _optimalMatch, minMatch, _maxInputLookahead);
-    }
-
-    /**
-     * Method that will return a detector instance that allows detectors to
-     * read up to specified number of bytes when determining format match strength.
-     */
-    public DataFormatDetector withMaxInputLookahead(int lookaheadBytes)
-    {
-        if (lookaheadBytes == _maxInputLookahead) {
-            return this;
-        }
-        return new DataFormatDetector(_detectors, _optimalMatch, _minimalMatch, lookaheadBytes);
-    }
-    
-    private DataFormatDetector(JsonFactory[] detectors,
-            MatchStrength optMatch, MatchStrength minMatch,
-            int maxInputLookahead)
-    {
-        _detectors = detectors;
-        _optimalMatch = optMatch;
-        _minimalMatch = minMatch;
-        _maxInputLookahead = maxInputLookahead;
-    }
-
-    /*
-    /**********************************************************
-    /* Public API
-    /**********************************************************
-     */
-
-    /**
-     * Method to call to find format that content (accessible via given
-     * {@link InputStream}) given has, as per configuration of this detector
-     * instance.
-     * 
-     * @return Matcher object which contains result; never null, even in cases
-     *    where no match (with specified minimal match strength) is found.
-     */
-    public DataFormatMatcher findFormat(InputStream in) throws IOException
-    {
-        return _findFormat(new InputAccessor.Std(in, new byte[_maxInputLookahead]));
-    }
-
-    /**
-     * Method to call to find format that given content (full document)
-     * has, as per configuration of this detector instance.
-     * 
-     * @return Matcher object which contains result; never null, even in cases
-     *    where no match (with specified minimal match strength) is found.
-     */
-    public DataFormatMatcher findFormat(byte[] fullInputData) throws IOException
-    {
-        return _findFormat(new InputAccessor.Std(fullInputData));
-    }
-
-    /**
-     * Method to call to find format that given content (full document)
-     * has, as per configuration of this detector instance.
-     * 
-     * @return Matcher object which contains result; never null, even in cases
-     *    where no match (with specified minimal match strength) is found.
-     * 
-     * @since 2.1
-     */
-    public DataFormatMatcher findFormat(byte[] fullInputData, int offset, int len) throws IOException
-    {
-        return _findFormat(new InputAccessor.Std(fullInputData, offset, len));
-    }
-    
-    /*
-    /**********************************************************
-    /* Overrides
-    /**********************************************************
-     */
-
-    @Override
-    public String toString()
-    {
-        StringBuilder sb = new StringBuilder();
-        sb.append('[');
-        final int len = _detectors.length;
-        if (len > 0) {
-            sb.append(_detectors[0].getFormatName());
-            for (int i = 1; i < len; ++i) {
-                sb.append(", ");
-                sb.append(_detectors[i].getFormatName());
-            }
-        }
-        sb.append(']');
-        return sb.toString();
-    }
-    
-    /*
-    /**********************************************************
-    /* Internal methods
-    /**********************************************************
-     */
-
-    private DataFormatMatcher _findFormat(InputAccessor.Std acc) throws IOException
-    {
-        JsonFactory bestMatch = null;
-        MatchStrength bestMatchStrength = null;
-        for (JsonFactory f : _detectors) {
-            acc.reset();
-            MatchStrength strength = f.hasFormat(acc);
-            // if not better than what we have so far (including minimal level limit), skip
-            if (strength == null || strength.ordinal() < _minimalMatch.ordinal()) {
-                continue;
-            }
-            // also, needs to better match than before
-            if (bestMatch != null) {
-                if (bestMatchStrength.ordinal() >= strength.ordinal()) {
-                    continue;
-                }
-            }
-            // finally: if it's good enough match, we are done
-            bestMatch = f;
-            bestMatchStrength = strength;
-            if (strength.ordinal() >= _optimalMatch.ordinal()) {
-                break;
-            }
-        }
-        return acc.createMatcher(bestMatch, bestMatchStrength);
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/format/DataFormatMatcher.java

@@ -1,124 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.format;
-
-import java.io.*;
-
-import com.fr.third.fasterxml.jackson.core.JsonFactory;
-import com.fr.third.fasterxml.jackson.core.JsonParser;
-import com.fr.third.fasterxml.jackson.core.io.MergedStream;
-
-/**
- * Result object constructed by {@link DataFormatDetector} when requested
- * to detect format of given input data.
- */
-public class DataFormatMatcher
-{
-    protected final InputStream _originalStream;
-
-    /**
-     * Content read during format matching process
-     */
-    protected final byte[] _bufferedData;
-
-    /**
-     * Pointer to the first byte in buffer available for reading
-     */
-    protected final int _bufferedStart;
-    
-    /**
-     * Number of bytes available in buffer.
-     */
-    protected final int _bufferedLength;
-
-    /**
-     * Factory that produced sufficient match (if any)
-     */
-    protected final JsonFactory _match;
-
-    /**
-     * Strength of match with {@link #_match}
-     */
-    protected final MatchStrength _matchStrength;
-    
-    protected DataFormatMatcher(InputStream in, byte[] buffered,
-            int bufferedStart, int bufferedLength,
-            JsonFactory match, MatchStrength strength)
-    {
-        _originalStream = in;
-        _bufferedData = buffered;
-        _bufferedStart = bufferedStart;
-        _bufferedLength = bufferedLength;
-        _match = match;
-        _matchStrength = strength;
-    }
-
-    /*
-    /**********************************************************
-    /* Public API, simple accessors
-    /**********************************************************
-     */
-
-    /**
-     * Accessor to use to see if any formats matched well enough with
-     * the input data.
-     */
-    public boolean hasMatch() { return _match != null; }
-
-    /**
-     * Method for accessing strength of the match, if any; if no match,
-     * will return {@link MatchStrength#INCONCLUSIVE}.
-     */
-    public MatchStrength getMatchStrength() {
-        return (_matchStrength == null) ? MatchStrength.INCONCLUSIVE : _matchStrength;
-    }
-
-    /**
-     * Accessor for {@link JsonFactory} that represents format that data matched.
-     */
-    public JsonFactory getMatch() { return _match; }
-
-    /**
-     * Accessor for getting brief textual name of matched format if any (null
-     * if none). Equivalent to:
-     *<pre>
-     *   return hasMatch() ? getMatch().getFormatName() : null;
-     *</pre>
-     */
-    public String getMatchedFormatName() {
-        return _match.getFormatName();
-    }
-    
-    /*
-    /**********************************************************
-    /* Public API, factory methods
-    /**********************************************************
-     */
-    
-    /**
-     * Convenience method for trying to construct a {@link JsonParser} for
-     * parsing content which is assumed to be in detected data format.
-     * If no match was found, returns null.
-     */
-    public JsonParser createParserWithMatch() throws IOException {
-        if (_match == null) {
-            return null;
-        }
-        if (_originalStream == null) {
-            return _match.createParser(_bufferedData, _bufferedStart, _bufferedLength);
-        }
-        return _match.createParser(getDataStream());
-    }
-    
-    /**
-     * Method to use for accessing input for which format detection has been done.
-     * This <b>must</b> be used instead of using stream passed to detector
-     * unless given stream itself can do buffering.
-     * Stream will return all content that was read during matching process, as well
-     * as remaining contents of the underlying stream.
-     */
-    public InputStream getDataStream() {
-        if (_originalStream == null) {
-            return new ByteArrayInputStream(_bufferedData, _bufferedStart, _bufferedLength);
-        }
-        return new MergedStream(null, _originalStream, _bufferedData, _bufferedStart, _bufferedLength);
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/format/InputAccessor.java

@@ -1,151 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.format;
-
-import java.io.*;
-
-import com.fr.third.fasterxml.jackson.core.JsonFactory;
-
-/**
- * Interface used to expose beginning of a data file to data format
- * detection code.
- */
-public interface InputAccessor
-{
-    /**
-     * Method to call to check if more input is available.
-     * Since this may result in more content to be read (at least
-     * one more byte), a {@link IOException} may get thrown.
-     */
-    boolean hasMoreBytes() throws IOException;
-
-    /**
-     * Returns next byte available, if any; if no more bytes are
-     * available, will throw {@link java.io.EOFException}.
-     */
-    byte nextByte() throws IOException;
-
-    /**
-     * Method that can be called to reset accessor to read from beginning
-     * of input.
-     */
-    void reset();
-
-    /*
-    /**********************************************************
-    /* Standard implementation
-    /**********************************************************
-     */
-
-    /**
-     * Basic implementation that reads data from given
-     * {@link InputStream} and buffers it as necessary.
-     */
-    class Std implements InputAccessor
-    {
-        protected final InputStream _in;
-
-        protected final byte[] _buffer;
-
-        protected final int _bufferedStart;
-
-        /**
-         * End of valid bytes in the buffer (points to one past last valid)
-         */
-        protected int _bufferedEnd;
-        
-        /**
-         * Pointer to next available buffered byte in {@link #_buffer}.
-         */
-        protected int _ptr;
-        
-        /**
-         * Constructor used when content to check is available via
-         * input stream and must be read.
-         */
-        public Std(InputStream in, byte[] buffer)
-        {
-            _in = in;
-            _buffer = buffer;
-            _bufferedStart = 0;
-            _ptr = 0;
-            _bufferedEnd = 0;
-        }
-
-        /**
-         * Constructor used when the full input (or at least enough leading bytes
-         * of full input) is available.
-         */
-        public Std(byte[] inputDocument)
-        {
-            _in = null;
-            _buffer = inputDocument;
-            // we have it all:
-            _bufferedStart = 0;
-            _bufferedEnd = inputDocument.length;
-        }
-
-        /**
-         * Constructor used when the full input (or at least enough leading bytes
-         * of full input) is available.
-         * 
-         * @since 2.1
-         */
-        public Std(byte[] inputDocument, int start, int len)
-        {
-            _in = null;
-            _buffer = inputDocument;
-            _ptr = start;
-            _bufferedStart = start;
-            _bufferedEnd = start+len;
-        }
-        
-        @Override
-        public boolean hasMoreBytes() throws IOException
-        {
-            if (_ptr < _bufferedEnd) { // already got more
-                return true;
-            }
-            if (_in == null) { // nowhere to read from
-                return false;
-            }
-            int amount = _buffer.length - _ptr;
-            if (amount < 1) { // can not load any more
-                return false;
-            }
-            int count = _in.read(_buffer, _ptr, amount);
-            if (count <= 0) { // EOF
-                return false;
-            }
-            _bufferedEnd += count;
-            return true;
-        }
-
-       @Override
-        public byte nextByte() throws IOException
-        {
-            // should we just try loading more automatically?
-            if (_ptr >= _bufferedEnd) {
-                if (!hasMoreBytes()) {
-                    throw new EOFException("Failed auto-detect: could not read more than "+_ptr+" bytes (max buffer size: "+_buffer.length+")");
-                }
-            }
-            return _buffer[_ptr++];
-        }
-
-        @Override
-        public void reset() {
-            _ptr = _bufferedStart;
-        }
-
-        /*
-        /**********************************************************
-        /* Extended API for DataFormatDetector/Matcher
-        /**********************************************************
-         */
-
-        public DataFormatMatcher createMatcher(JsonFactory match, MatchStrength matchStrength)
-        {
-            return new DataFormatMatcher(_in, _buffer, _bufferedStart, (_bufferedEnd - _bufferedStart),
-                    match, matchStrength);
-        }
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/format/MatchStrength.java

@@ -1,62 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.format;
-
-/**
- * Enumeration used to indicate strength of match between data format
- * and piece of data (typically beginning of a data file).
- * Values are in increasing match strength; and detectors should return
- * "strongest" value: that is, it should start with strongest match
- * criteria, and downgrading if criteria is not fulfilled.
- */
-public enum MatchStrength
-{
-    /**
-     * Value that indicates that given data can not be in given format.
-     */
-    NO_MATCH,
-    
-    /**
-     * Value that indicates that detector can not find out whether could
-     * be a match or not.
-     * This can occur for example for textual data formats t
-     * when there are so many leading spaces that detector can not
-     * find the first data byte (because detectors typically limit lookahead
-     * to some smallish value).
-     */
-    INCONCLUSIVE,
-
-    /**
-     * Value that indicates that given data could be of specified format (i.e.
-     * it can not be ruled out). This can occur for example when seen data
-     * is both not in canonical formats (for example: JSON data should be a JSON Array or Object
-     * not a scalar value, as per JSON specification) and there are known use case
-     * where a format detected is actually used (plain JSON Strings are actually used, even
-     * though specification does not indicate that as valid usage: as such, seeing a leading
-     * double-quote could indicate a JSON String, which plausibly <b>could</b> indicate
-     * non-standard JSON usage).
-     */
-    WEAK_MATCH,
-    
-    /**
-     * Value that indicates that given data conforms to (one of) canonical form(s) of
-     * the data format.
-     *<p>
-     * For example, when testing for XML data format,
-     * seeing a less-than character ("&lt;") alone (with possible leading spaces)
-     * would be a strong indication that data could
-     * be in xml format (but see below for {@link #FULL_MATCH} description for more)
-     */
-    SOLID_MATCH,
-
-    /**
-     * Value that indicates that given data contains a signature that is deemed
-     * specific enough to uniquely indicate data format used.
-     *<p>
-     * For example, when testing for XML data format,
-     * seing "&lt;xml" as the first data bytes ("XML declaration", as per XML specification)
-     * could give full confidence that data is indeed in XML format.
-     * Not all data formats have unique leading identifiers to allow full matches; for example,
-     * JSON only has heuristic matches and can have at most {@link #SOLID_MATCH}) match.
-     */
-    FULL_MATCH
-    ;
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/format/package-info.java

@@ -1,6 +0,0 @@
-/**
- * Package that contains interfaces needed for dynamic, pluggable
- * format (auto)detection; as well as basic utility classes for
- * simple format detection functionality.
- */
-package com.fr.third.fasterxml.jackson.core.format;

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/io/BaseReader.java

@@ -1,116 +0,0 @@
-
-package com.fr.third.fasterxml.jackson.core.io;
-
-import java.io.*;
-
-/**
- * Simple basic class for optimized readers in this package; implements
- * "cookie-cutter" methods that are used by all actual implementations.
- */
-abstract class BaseReader
-    extends Reader
-{
-    /**
-     * JSON actually limits available Unicode range in the high end
-     * to the same as xml (to basically limit UTF-8 max byte sequence
-     * length to 4)
-     */
-    final protected static int LAST_VALID_UNICODE_CHAR = 0x10FFFF;
-
-    final protected static char NULL_CHAR = (char) 0;
-    final protected static char NULL_BYTE = (byte) 0;
-
-    final protected IOContext _context;
-
-    protected InputStream _in;
-
-    protected byte[] _buffer;
-
-    protected int _ptr;
-    protected int _length;
-
-    /*
-    /**********************************************************
-    /* Life-cycle
-    /**********************************************************
-     */
-
-    protected BaseReader(IOContext context,
-            InputStream in, byte[] buf, int ptr, int len)
-    {
-        _context = context;
-        _in = in;
-        _buffer = buf;
-        _ptr = ptr;
-        _length = len;
-    }
-
-    /*
-    /**********************************************************
-    /* Reader API
-    /**********************************************************
-     */
-
-    @Override
-    public void close() throws IOException
-    {
-        InputStream in = _in;
-
-        if (in != null) {
-            _in = null;
-            freeBuffers();
-            in.close();
-        }
-    }
-
-    protected char[] _tmpBuf = null;
-
-    /**
-     * Although this method is implemented by the base class, AND it should
-     * never be called by main code, let's still implement it bit more
-     * efficiently just in case
-     */
-    @Override
-    public int read() throws IOException
-    {
-        if (_tmpBuf == null) {
-            _tmpBuf = new char[1];
-        }
-        if (read(_tmpBuf, 0, 1) < 1) {
-            return -1;
-        }
-        return _tmpBuf[0];
-    }
-
-    /*
-    /**********************************************************
-    /* Internal/package methods:
-    /**********************************************************
-     */
-
-    /**
-     * This method should be called along with (or instead of) normal
-     * close. After calling this method, no further reads should be tried.
-     * Method will try to recycle read buffers (if any).
-     */
-    public final void freeBuffers()
-    {
-        byte[] buf = _buffer;
-        if (buf != null) {
-            _buffer = null;
-            _context.releaseReadIOBuffer(buf);
-        }
-    }
-
-    protected void reportBounds(char[] cbuf, int start, int len)
-        throws IOException
-    {
-        throw new ArrayIndexOutOfBoundsException("read(buf,"+start+","+len+"), cbuf["+cbuf.length+"]");
-    }
-
-    protected void reportStrangeStream()
-        throws IOException
-    {
-        throw new IOException("Strange I/O stream, returned 0 bytes on read");
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/io/CharTypes.java

@@ -1,261 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.io;
-
-import java.util.Arrays;
-
-public final class CharTypes
-{
-    private final static char[] HEX_CHARS = "0123456789ABCDEF".toCharArray();
-    private final static byte[] HEX_BYTES;
-    static {
-        int len = HEX_CHARS.length;
-        HEX_BYTES = new byte[len];
-        for (int i = 0; i < len; ++i) {
-            HEX_BYTES[i] = (byte) HEX_CHARS[i];
-        }
-    }
-
-
-    /**
-     * Lookup table used for determining which input characters
-     * need special handling when contained in text segment.
-     */
-    final static int[] sInputCodes;
-    static {
-        /* 96 would do for most cases (backslash is ascii 94)
-         * but if we want to do lookups by raw bytes it's better
-         * to have full table
-         */
-        final int[] table = new int[256];
-        // Control chars and non-space white space are not allowed unquoted
-        for (int i = 0; i < 32; ++i) {
-            table[i] = -1;
-        }
-        // And then string end and quote markers are special too
-        table['"'] = 1;
-        table['\\'] = 1;
-        sInputCodes = table;
-    }
-
-    /**
-     * Additionally we can combine UTF-8 decoding info into similar
-     * data table.
-     */
-    final static int[] sInputCodesUTF8;
-    static {
-        final int[] table = new int[sInputCodes.length];
-        System.arraycopy(sInputCodes, 0, table, 0, table.length);
-        for (int c = 128; c < 256; ++c) {
-            int code;
-
-            // We'll add number of bytes needed for decoding
-            if ((c & 0xE0) == 0xC0) { // 2 bytes (0x0080 - 0x07FF)
-                code = 2;
-            } else if ((c & 0xF0) == 0xE0) { // 3 bytes (0x0800 - 0xFFFF)
-                code = 3;
-            } else if ((c & 0xF8) == 0xF0) {
-                // 4 bytes; double-char with surrogates and all...
-                code = 4;
-            } else {
-                // And -1 seems like a good "universal" error marker...
-                code = -1;
-            }
-            table[c] = code;
-        }
-        sInputCodesUTF8 = table;
-    }
-
-    /**
-     * To support non-default (and -standard) unquoted field names mode,
-     * need to have alternate checking.
-     * Basically this is list of 8-bit ASCII characters that are legal
-     * as part of Javascript identifier
-     */
-    final static int[] sInputCodesJsNames;
-    static {
-        final int[] table = new int[256];
-        // Default is "not a name char", mark ones that are
-        Arrays.fill(table, -1);
-        // Assume rules with JS same as Java (change if/as needed)
-        for (int i = 33; i < 256; ++i) {
-            if (Character.isJavaIdentifierPart((char) i)) {
-                table[i] = 0;
-            }
-        }
-        /* As per [JACKSON-267], '@', '#' and '*' are also to be accepted as well.
-         * And '-' (for hyphenated names); and '+' for sake of symmetricity...
-         */
-        table['@'] = 0;
-        table['#'] = 0;
-        table['*'] = 0;
-        table['-'] = 0;
-        table['+'] = 0;
-        sInputCodesJsNames = table;
-    }
-
-    /**
-     * This table is similar to Latin-1, except that it marks all "high-bit"
-     * code as ok. They will be validated at a later point, when decoding
-     * name
-     */
-    final static int[] sInputCodesUtf8JsNames;
-    static {
-        final int[] table = new int[256];
-        // start with 8-bit JS names
-        System.arraycopy(sInputCodesJsNames, 0, table, 0, table.length);
-        Arrays.fill(table, 128, 128, 0);
-        sInputCodesUtf8JsNames = table;
-    }
-
-    /**
-     * Decoding table used to quickly determine characters that are
-     * relevant within comment content.
-     */
-    final static int[] sInputCodesComment;
-    static {
-        final int[] buf = new int[256];
-        // but first: let's start with UTF-8 multi-byte markers:
-        System.arraycopy(sInputCodesUTF8, 128, buf, 128, 128);
-
-        // default (0) means "ok" (skip); -1 invalid, others marked by char itself
-        Arrays.fill(buf, 0, 32, -1); // invalid white space
-        buf['\t'] = 0; // tab is still fine
-        buf['\n'] = '\n'; // lf/cr need to be observed, ends cpp comment
-        buf['\r'] = '\r';
-        buf['*'] = '*'; // end marker for c-style comments
-        sInputCodesComment = buf;
-    }
-
-    /**
-     * Decoding table used for skipping white space and comments.
-     * 
-     * @since 2.3
-     */
-    final static int[] sInputCodesWS;
-    static {
-        // but first: let's start with UTF-8 multi-byte markers:
-        final int[] buf = new int[256];
-        System.arraycopy(sInputCodesUTF8, 128, buf, 128, 128);
-
-        // default (0) means "not whitespace" (end); 1 "whitespace", -1 invalid,
-        // 2-4 UTF-8 multi-bytes, others marked by char itself
-        //
-        Arrays.fill(buf, 0, 32, -1); // invalid white space
-        buf[' '] = 1;
-        buf['\t'] = 1;
-        buf['\n'] = '\n'; // lf/cr need to be observed, ends cpp comment
-        buf['\r'] = '\r';
-        buf['/'] = '/'; // start marker for c/cpp comments
-        buf['#'] = '#'; // start marker for YAML comments
-        sInputCodesWS = buf;
-    }
-    
-    /**
-     * Lookup table used for determining which output characters in
-     * 7-bit ASCII range need to be quoted.
-     */
-    final static int[] sOutputEscapes128;
-    static {
-        int[] table = new int[128];
-        // Control chars need generic escape sequence
-        for (int i = 0; i < 32; ++i) {
-            // 04-Mar-2011, tatu: Used to use "-(i + 1)", replaced with constant
-            table[i] = CharacterEscapes.ESCAPE_STANDARD;
-        }
-        /* Others (and some within that range too) have explicit shorter
-         * sequences
-         */
-        table['"'] = '"';
-        table['\\'] = '\\';
-        // Escaping of slash is optional, so let's not add it
-        table[0x08] = 'b';
-        table[0x09] = 't';
-        table[0x0C] = 'f';
-        table[0x0A] = 'n';
-        table[0x0D] = 'r';
-        sOutputEscapes128 = table;
-    }
-
-    /**
-     * Lookup table for the first 128 Unicode characters (7-bit ASCII)
-     * range. For actual hex digits, contains corresponding value;
-     * for others -1.
-     */
-    final static int[] sHexValues = new int[128];
-    static {
-        Arrays.fill(sHexValues, -1);
-        for (int i = 0; i < 10; ++i) {
-            sHexValues['0' + i] = i;
-        }
-        for (int i = 0; i < 6; ++i) {
-            sHexValues['a' + i] = 10 + i;
-            sHexValues['A' + i] = 10 + i;
-        }
-    }
-
-    public static int[] getInputCodeLatin1() { return sInputCodes; }
-    public static int[] getInputCodeUtf8() { return sInputCodesUTF8; }
-
-    public static int[] getInputCodeLatin1JsNames() { return sInputCodesJsNames; }
-    public static int[] getInputCodeUtf8JsNames() { return sInputCodesUtf8JsNames; }
-
-    public static int[] getInputCodeComment() { return sInputCodesComment; }
-    public static int[] getInputCodeWS() { return sInputCodesWS; }
-
-    /**
-     * Accessor for getting a read-only encoding table for first 128 Unicode
-     * code points (single-byte UTF-8 characters).
-     * Value of 0 means "no escaping"; other positive values that value is character
-     * to use after backslash; and negative values that generic (backslash - u)
-     * escaping is to be used.
-     */
-    public static int[] get7BitOutputEscapes() { return sOutputEscapes128; }
-
-    public static int charToHex(int ch)
-    {
-        return (ch > 127) ? -1 : sHexValues[ch];
-    }
-
-    public static void appendQuoted(StringBuilder sb, String content)
-    {
-        final int[] escCodes = sOutputEscapes128;
-        int escLen = escCodes.length;
-        for (int i = 0, len = content.length(); i < len; ++i) {
-            char c = content.charAt(i);
-            if (c >= escLen || escCodes[c] == 0) {
-                sb.append(c);
-                continue;
-            }
-            sb.append('\\');
-            int escCode = escCodes[c];
-            if (escCode < 0) { // generic quoting (hex value)
-                // The only negative value sOutputEscapes128 returns
-                // is CharacterEscapes.ESCAPE_STANDARD, which mean
-                // appendQuotes should encode using the Unicode encoding;
-                // not sure if this is the right way to encode for
-                // CharacterEscapes.ESCAPE_CUSTOM or other (future)
-                // CharacterEscapes.ESCAPE_XXX values.
-
-                // We know that it has to fit in just 2 hex chars
-                sb.append('u');
-                sb.append('0');
-                sb.append('0');
-                int value = c;  // widening
-                sb.append(HEX_CHARS[value >> 4]);
-                sb.append(HEX_CHARS[value & 0xF]);
-            } else { // "named", i.e. prepend with slash
-                sb.append((char) escCode);
-            }
-        }
-    }
-
-    public static char[] copyHexChars()
-    {
-        return (char[]) HEX_CHARS.clone();
-    }
-
-    public static byte[] copyHexBytes()
-    {
-        return (byte[]) HEX_BYTES.clone();
-    }
-}
-

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/io/CharacterEscapes.java

@@ -1,70 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.io;
-
-import com.fr.third.fasterxml.jackson.core.SerializableString;
-import com.fr.third.fasterxml.jackson.core.util.ArraysCompat;
-
-/**
- * Abstract base class that defines interface for customizing character
- * escaping aspects for String values, for formats that use escaping.
- * For JSON this applies to both property names and String values.
- */
-public abstract class CharacterEscapes
-    implements java.io.Serializable // since 2.1
-{
-    private static final long serialVersionUID = 1L;
-
-    /**
-     * Value used for lookup tables to indicate that matching characters
-     * do not need to be escaped.
-     */
-    public final static int ESCAPE_NONE = 0;
-
-    /**
-     * Value used for lookup tables to indicate that matching characters
-     * are to be escaped using standard escaping; for JSON this means
-     * (for example) using "backslash - u" escape method.
-     */
-    public final static int ESCAPE_STANDARD = -1;
-
-    /**
-     * Value used for lookup tables to indicate that matching characters
-     * will need custom escapes; and that another call
-     * to {@link #getEscapeSequence} is needed to figure out exact escape
-     * sequence to output.
-     */
-    public final static int ESCAPE_CUSTOM = -2;
-    
-    /**
-     * Method generators can call to get lookup table for determining
-     * escape handling for first 128 characters of Unicode (ASCII
-     * characters. Caller is not to modify contents of this array, since
-     * this is expected to be a shared copy.
-     * 
-     * @return Array with size of at least 128, where first 128 entries
-     *    have either one of <code>ESCAPE_xxx</code> constants, or non-zero positive
-     *    integer (meaning of which is data format specific; for JSON it means
-     *    that combination of backslash and character with that value is to be used)
-     *    to indicate that specific escape sequence is to be used.
-     */
-    public abstract int[] getEscapeCodesForAscii();
-
-    /**
-     * Method generators can call to get lookup table for determining
-     * exact escape sequence to use for given character.
-     * It can be called for any character, but typically is called for
-     * either for ASCII characters for which custom escape
-     * sequence is needed; or for any non-ASCII character.
-     */
-    public abstract SerializableString getEscapeSequence(int ch);
-
-    /**
-     * Helper method that can be used to get a copy of standard JSON
-     * escape definitions; this is useful when just wanting to slightly
-     * customize definitions. Caller can modify this array as it sees
-     * fit and usually returns modified instance via {@link #getEscapeCodesForAscii}
-     */
-    public static int[] standardAsciiEscapesForJSON() {
-        int[] esc = CharTypes.get7BitOutputEscapes();
-        return ArraysCompat.copyOf(esc, esc.length);
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/io/IOContext.java

@@ -1,265 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.io;
-
-import com.fr.third.fasterxml.jackson.core.JsonEncoding;
-import com.fr.third.fasterxml.jackson.core.util.BufferRecycler;
-import com.fr.third.fasterxml.jackson.core.util.TextBuffer;
-
-/**
- * To limit number of configuration and state objects to pass, all
- * contextual objects that need to be passed by the factory to
- * readers and writers are combined under this object. One instance
- * is created for each reader and writer.
- *<p>
- * NOTE: non-final since 2.4, to allow sub-classing.
- */
-public class IOContext
-{
-    /*
-    /**********************************************************
-    /* Configuration
-    /**********************************************************
-     */
-
-    /**
-     * Reference to the source object, which can be used for displaying
-     * location information
-     */
-    protected final Object _sourceRef;
-
-    /**
-     * Encoding used by the underlying stream, if known.
-     */
-    protected JsonEncoding _encoding;
-
-    /**
-     * Flag that indicates whether underlying input/output source/target
-     * object is fully managed by the owner of this context (parser or
-     * generator). If true, it is, and is to be closed by parser/generator;
-     * if false, calling application has to do closing (unless auto-closing
-     * feature is enabled for the parser/generator in question; in which
-     * case it acts like the owner).
-     */
-    protected final boolean _managedResource;
-
-    /*
-    /**********************************************************
-    /* Buffer handling, recycling
-    /**********************************************************
-     */
-
-    /**
-     * Recycler used for actual allocation/deallocation/reuse
-     */
-    protected final BufferRecycler _bufferRecycler;
-
-    /**
-     * Reference to the allocated I/O buffer for low-level input reading,
-     * if any allocated.
-     */
-    protected byte[] _readIOBuffer = null;
-
-    /**
-     * Reference to the allocated I/O buffer used for low-level
-     * encoding-related buffering.
-     */
-    protected byte[] _writeEncodingBuffer = null;
-    
-    /**
-     * Reference to the buffer allocated for temporary use with
-     * base64 encoding or decoding.
-     */
-    protected byte[] _base64Buffer = null;
-
-    /**
-     * Reference to the buffer allocated for tokenization purposes,
-     * in which character input is read, and from which it can be
-     * further returned.
-     */
-    protected char[] _tokenCBuffer = null;
-
-    /**
-     * Reference to the buffer allocated for buffering it for
-     * output, before being encoded: generally this means concatenating
-     * output, then encoding when buffer fills up.
-     */
-    protected char[] _concatCBuffer = null;
-
-    /**
-     * Reference temporary buffer Parser instances need if calling
-     * app decides it wants to access name via 'getTextCharacters' method.
-     * Regular text buffer can not be used as it may contain textual
-     * representation of the value token.
-     */
-    protected char[] _nameCopyBuffer = null;
-
-    /*
-    /**********************************************************
-    /* Life-cycle
-    /**********************************************************
-     */
-
-    public IOContext(BufferRecycler br, Object sourceRef, boolean managedResource)
-    {
-        _bufferRecycler = br;
-        _sourceRef = sourceRef;
-        _managedResource = managedResource;
-    }
-
-    public void setEncoding(JsonEncoding enc) {
-        _encoding = enc;
-    }
-
-    /*
-    /**********************************************************
-    /* Public API, accessors
-    /**********************************************************
-     */
-
-    public Object getSourceReference() { return _sourceRef; }
-    public JsonEncoding getEncoding() { return _encoding; }
-    public boolean isResourceManaged() { return _managedResource; }
-
-    /*
-    /**********************************************************
-    /* Public API, buffer management
-    /**********************************************************
-     */
-
-    public TextBuffer constructTextBuffer() {
-        return new TextBuffer(_bufferRecycler);
-    }
-
-    /**
-     *<p>
-     * Note: the method can only be called once during its life cycle.
-     * This is to protect against accidental sharing.
-     */
-    public byte[] allocReadIOBuffer() {
-        _verifyAlloc(_readIOBuffer);
-        return (_readIOBuffer = _bufferRecycler.allocByteBuffer(BufferRecycler.ByteBufferType.READ_IO_BUFFER));
-    }
-
-    /**
-     * @since 2.3.2
-     */
-    public byte[] allocReadIOBuffer(int minSize) {
-        _verifyAlloc(_readIOBuffer);
-        return (_readIOBuffer = _bufferRecycler.allocByteBuffer(BufferRecycler.ByteBufferType.READ_IO_BUFFER, minSize));
-    }
-    
-    public byte[] allocWriteEncodingBuffer() {
-        _verifyAlloc(_writeEncodingBuffer);
-        return (_writeEncodingBuffer = _bufferRecycler.allocByteBuffer(BufferRecycler.ByteBufferType.WRITE_ENCODING_BUFFER));
-    }
-
-    /**
-     * @since 2.3.2
-     */
-    public byte[] allocWriteEncodingBuffer(int minSize) {
-        _verifyAlloc(_writeEncodingBuffer);
-        return (_writeEncodingBuffer = _bufferRecycler.allocByteBuffer(BufferRecycler.ByteBufferType.WRITE_ENCODING_BUFFER, minSize));
-    }
-    
-    /**
-     * @since 2.1
-     */
-    public byte[] allocBase64Buffer() {
-        _verifyAlloc(_base64Buffer);
-        return (_base64Buffer = _bufferRecycler.allocByteBuffer(BufferRecycler.ByteBufferType.BASE64_CODEC_BUFFER));
-    }
-    
-    public char[] allocTokenBuffer() {
-        _verifyAlloc(_tokenCBuffer);
-        return (_tokenCBuffer = _bufferRecycler.allocCharBuffer(BufferRecycler.CharBufferType.TOKEN_BUFFER));
-    }
-
-    public char[] allocConcatBuffer() {
-        _verifyAlloc(_concatCBuffer);
-        return (_concatCBuffer = _bufferRecycler.allocCharBuffer(BufferRecycler.CharBufferType.CONCAT_BUFFER));
-    }
-
-    public char[] allocNameCopyBuffer(int minSize) {
-        _verifyAlloc(_nameCopyBuffer);
-        return (_nameCopyBuffer = _bufferRecycler.allocCharBuffer(BufferRecycler.CharBufferType.NAME_COPY_BUFFER, minSize));
-    }
-
-    /**
-     * Method to call when all the processing buffers can be safely
-     * recycled.
-     */
-    public void releaseReadIOBuffer(byte[] buf) {
-        if (buf != null) {
-            /* Let's do sanity checks to ensure once-and-only-once release,
-             * as well as avoiding trying to release buffers not owned
-             */
-            _verifyRelease(buf, _readIOBuffer);
-            _readIOBuffer = null;
-            _bufferRecycler.releaseByteBuffer(BufferRecycler.ByteBufferType.READ_IO_BUFFER, buf);
-        }
-    }
-
-    public void releaseWriteEncodingBuffer(byte[] buf) {
-        if (buf != null) {
-            /* Let's do sanity checks to ensure once-and-only-once release,
-             * as well as avoiding trying to release buffers not owned
-             */
-            _verifyRelease(buf, _writeEncodingBuffer);
-            _writeEncodingBuffer = null;
-            _bufferRecycler.releaseByteBuffer(BufferRecycler.ByteBufferType.WRITE_ENCODING_BUFFER, buf);
-        }
-    }
-
-    public void releaseBase64Buffer(byte[] buf) {
-        if (buf != null) { // sanity checks, release once-and-only-once, must be one owned
-            _verifyRelease(buf, _base64Buffer);
-            _base64Buffer = null;
-            _bufferRecycler.releaseByteBuffer(BufferRecycler.ByteBufferType.BASE64_CODEC_BUFFER, buf);
-        }
-    }
-    
-    public void releaseTokenBuffer(char[] buf) {
-        if (buf != null) {
-            _verifyRelease(buf, _tokenCBuffer);
-            _tokenCBuffer = null;
-            _bufferRecycler.releaseCharBuffer(BufferRecycler.CharBufferType.TOKEN_BUFFER, buf);
-        }
-    }
-
-    public void releaseConcatBuffer(char[] buf) {
-        if (buf != null) {
-            // 14-Jan-2014, tatu: Let's actually allow upgrade of the original buffer.
-            _verifyRelease(buf, _concatCBuffer);
-            _concatCBuffer = null;
-            _bufferRecycler.releaseCharBuffer(BufferRecycler.CharBufferType.CONCAT_BUFFER, buf);
-        }
-    }
-
-    public void releaseNameCopyBuffer(char[] buf) {
-        if (buf != null) {
-            // 14-Jan-2014, tatu: Let's actually allow upgrade of the original buffer.
-            _verifyRelease(buf, _nameCopyBuffer);
-            _nameCopyBuffer = null;
-            _bufferRecycler.releaseCharBuffer(BufferRecycler.CharBufferType.NAME_COPY_BUFFER, buf);
-        }
-    }
-
-    /*
-    /**********************************************************
-    /* Internal helpers
-    /**********************************************************
-     */
-
-    protected void _verifyAlloc(Object buffer) {
-        if (buffer != null) { throw new IllegalStateException("Trying to call same allocXxx() method second time"); }
-    }
-
-    protected void _verifyRelease(byte[] toRelease, byte[] src) {
-        if ((toRelease != src) && (toRelease.length <= src.length)) { throw wrongBuf(); }
-    }
-
-    protected void _verifyRelease(char[] toRelease, char[] src) {
-        if ((toRelease != src) && (toRelease.length <= src.length)) { throw wrongBuf(); }
-    }
-
-    private IllegalArgumentException wrongBuf() { return new IllegalArgumentException("Trying to release buffer not owned by the context"); }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/io/InputDecorator.java

@@ -1,68 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.io;
-
-import java.io.*;
-
-/**
- * Handler class that can be used to decorate input sources.
- * Typical use is to use a filter abstraction (filtered stream,
- * reader) around original input source, and apply additional
- * processing during read operations.
- */
-public abstract class InputDecorator
-    implements java.io.Serializable // since 2.1
-{
-    private static final long serialVersionUID = 1L;
-    
-    /**
-     * Method called by {@link com.fr.third.fasterxml.jackson.core.JsonFactory} instance when
-     * creating parser given an {@link InputStream}, when this decorator
-     * has been registered.
-     * 
-     * @param ctxt IO context in use (provides access to declared encoding).
-     *   NOTE: at this point context may not have all information initialized;
-     *   specifically auto-detected encoding is only available once parsing starts,
-     *   which may occur only after this method is called.
-     * @param in Original input source
-     * 
-     * @return InputStream to use; either passed in argument, or something that
-     *   calls it
-     */
-    public abstract InputStream decorate(IOContext ctxt, InputStream in)
-        throws IOException;
-
-    /**
-     * Method called by {@link com.fr.third.fasterxml.jackson.core.JsonFactory} instance when
-     * creating parser on given "raw" byte source.
-     * Method can either construct a {@link InputStream} for reading; or return
-     * null to indicate that no wrapping should occur.
-     * 
-     * @param ctxt IO context in use (provides access to declared encoding)
-     *   NOTE: at this point context may not have all information initialized;
-     *   specifically auto-detected encoding is only available once parsing starts,
-     *   which may occur only after this method is called.
-     * @param src Input buffer that contains contents to parse
-     * @param offset Offset of the first available byte in the input buffer
-     * @param length Number of bytes available in the input buffer
-     * 
-     * @return Either {@link InputStream} to use as input source; or null to indicate
-     *   that contents are to be processed as-is by caller
-     */
-    public abstract InputStream decorate(IOContext ctxt, byte[] src, int offset, int length)
-        throws IOException;
-    
-    /**
-     * Method called by {@link com.fr.third.fasterxml.jackson.core.JsonFactory} instance when
-     * creating parser given an {@link Reader}, when this decorator
-     * has been registered.
-     * 
-     * @param ctxt IO context in use (provides access to declared encoding)
-     *   NOTE: at this point context may not have all information initialized;
-     *   specifically auto-detected encoding is only available once parsing starts,
-     *   which may occur only after this method is called.
-     * @param src Original input source
-     * 
-     * @return Reader to use; either passed in argument, or something that
-     *   calls it (for example, a {@link FilterReader})
-     */
-    public abstract Reader decorate(IOContext ctxt, Reader src) throws IOException;
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/io/JsonStringEncoder.java

@@ -1,396 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.io;
-
-import java.lang.ref.SoftReference;
-
-import com.fr.third.fasterxml.jackson.core.util.BufferRecycler;
-import com.fr.third.fasterxml.jackson.core.util.ByteArrayBuilder;
-import com.fr.third.fasterxml.jackson.core.util.TextBuffer;
-
-/**
- * Helper class used for efficient encoding of JSON String values (including
- * JSON field names) into Strings or UTF-8 byte arrays.
- *<p>
- * Note that methods in here are somewhat optimized, but not ridiculously so.
- * Reason is that conversion method results are expected to be cached so that
- * these methods will not be hot spots during normal operation.
- */
-public final class JsonStringEncoder
-{
-    private final static char[] HEX_CHARS = CharTypes.copyHexChars();
-
-    private final static byte[] HEX_BYTES = CharTypes.copyHexBytes();
-
-    private final static int SURR1_FIRST = 0xD800;
-    private final static int SURR1_LAST = 0xDBFF;
-    private final static int SURR2_FIRST = 0xDC00;
-    private final static int SURR2_LAST = 0xDFFF;
-
-    private final static int INT_BACKSLASH = '\\';
-    private final static int INT_U = 'u';
-    private final static int INT_0 = '0';
-    
-    /**
-     * This <code>ThreadLocal</code> contains a {@link java.lang.ref.SoftReference}
-     * to a {@link BufferRecycler} used to provide a low-cost
-     * buffer recycling between reader and writer instances.
-     */
-    final protected static ThreadLocal<SoftReference<JsonStringEncoder>> _threadEncoder
-        = new ThreadLocal<SoftReference<JsonStringEncoder>>();
-
-    /**
-     * Lazily constructed text buffer used to produce JSON encoded Strings
-     * as characters (without UTF-8 encoding)
-     */
-    protected TextBuffer _textBuffer;
-
-    /**
-     * Lazily-constructed builder used for UTF-8 encoding of text values
-     * (quoted and unquoted)
-     */
-    protected ByteArrayBuilder _byteBuilder;
-    
-    /**
-     * Temporary buffer used for composing quote/escape sequences
-     */
-    protected final char[] _quoteBuffer;
-    
-    /*
-    /**********************************************************
-    /* Construction, instance access
-    /**********************************************************
-     */
-    
-    public JsonStringEncoder()
-    {
-        _quoteBuffer = new char[6];
-        _quoteBuffer[0] = '\\';
-        _quoteBuffer[2] = '0';
-        _quoteBuffer[3] = '0';
-    }
-    
-    /**
-     * Factory method for getting an instance; this is either recycled per-thread instance,
-     * or a newly constructed one.
-     */
-    public static JsonStringEncoder getInstance()
-    {
-        SoftReference<JsonStringEncoder> ref = _threadEncoder.get();
-        JsonStringEncoder enc = (ref == null) ? null : ref.get();
-
-        if (enc == null) {
-            enc = new JsonStringEncoder();
-            _threadEncoder.set(new SoftReference<JsonStringEncoder>(enc));
-        }
-        return enc;
-    }
-
-    /*
-    /**********************************************************
-    /* Public API
-    /**********************************************************
-     */
-
-    /**
-     * Method that will quote text contents using JSON standard quoting,
-     * and return results as a character array
-     */
-    public char[] quoteAsString(String input)
-    {
-        TextBuffer textBuffer = _textBuffer;
-        if (textBuffer == null) {
-            // no allocator; can add if we must, shouldn't need to
-            _textBuffer = textBuffer = new TextBuffer(null);
-        }
-        char[] outputBuffer = textBuffer.emptyAndGetCurrentSegment();
-        final int[] escCodes = CharTypes.get7BitOutputEscapes();
-        final int escCodeCount = escCodes.length;
-        int inPtr = 0;
-        final int inputLen = input.length();
-        int outPtr = 0;
- 
-        outer_loop:
-        while (inPtr < inputLen) {
-            tight_loop:
-            while (true) {
-                char c = input.charAt(inPtr);
-                if (c < escCodeCount && escCodes[c] != 0) {
-                    break tight_loop;
-                }
-                if (outPtr >= outputBuffer.length) {
-                    outputBuffer = textBuffer.finishCurrentSegment();
-                    outPtr = 0;
-                }
-                outputBuffer[outPtr++] = c;
-                if (++inPtr >= inputLen) {
-                    break outer_loop;
-                }
-            }
-            // something to escape; 2 or 6-char variant? 
-            char d = input.charAt(inPtr++);
-            int escCode = escCodes[d];
-            int length = (escCode < 0)
-                    ? _appendNumericEscape(d, _quoteBuffer)
-                    : _appendNamedEscape(escCode, _quoteBuffer);
-                    ;
-            if ((outPtr + length) > outputBuffer.length) {
-                int first = outputBuffer.length - outPtr;
-                if (first > 0) {
-                    System.arraycopy(_quoteBuffer, 0, outputBuffer, outPtr, first);
-                }
-                outputBuffer = textBuffer.finishCurrentSegment();
-                int second = length - first;
-                System.arraycopy(_quoteBuffer, first, outputBuffer, 0, second);
-                outPtr = second;
-            } else {
-                System.arraycopy(_quoteBuffer, 0, outputBuffer, outPtr, length);
-                outPtr += length;
-            }
-        }
-        textBuffer.setCurrentLength(outPtr);
-        return textBuffer.contentsAsArray();
-    }
-
-    /**
-     * Will quote given JSON String value using standard quoting, encode
-     * results as UTF-8, and return result as a byte array.
-     */
-    @SuppressWarnings("resource")
-    public byte[] quoteAsUTF8(String text)
-    {
-        ByteArrayBuilder byteBuilder = _byteBuilder;
-        if (byteBuilder == null) {
-            // no allocator; can add if we must, shouldn't need to
-            _byteBuilder = byteBuilder = new ByteArrayBuilder(null);
-        }
-        int inputPtr = 0;
-        int inputEnd = text.length();
-        int outputPtr = 0;
-        byte[] outputBuffer = byteBuilder.resetAndGetFirstSegment();
-        
-        main_loop:
-        while (inputPtr < inputEnd) {
-            final int[] escCodes = CharTypes.get7BitOutputEscapes();
-
-            inner_loop: // ASCII and escapes
-            while (true) {
-                int ch = text.charAt(inputPtr);
-                if (ch > 0x7F || escCodes[ch] != 0) {
-                    break inner_loop;
-                }
-                if (outputPtr >= outputBuffer.length) {
-                    outputBuffer = byteBuilder.finishCurrentSegment();
-                    outputPtr = 0;
-                }
-                outputBuffer[outputPtr++] = (byte) ch;
-                if (++inputPtr >= inputEnd) {
-                    break main_loop;
-                }
-            }                
-            if (outputPtr >= outputBuffer.length) {
-                outputBuffer = byteBuilder.finishCurrentSegment();
-                outputPtr = 0;
-            }
-            // Ok, so what did we hit?
-            int ch = (int) text.charAt(inputPtr++);
-            if (ch <= 0x7F) { // needs quoting
-                int escape = escCodes[ch];
-                // ctrl-char, 6-byte escape...
-                outputPtr = _appendByteEscape(ch, escape, byteBuilder, outputPtr);
-                outputBuffer = byteBuilder.getCurrentSegment();
-                continue main_loop;
-            } else if (ch <= 0x7FF) { // fine, just needs 2 byte output
-                outputBuffer[outputPtr++] = (byte) (0xc0 | (ch >> 6));
-                ch = (0x80 | (ch & 0x3f));
-            } else { // 3 or 4 bytes
-                // Surrogates?
-                if (ch < SURR1_FIRST || ch > SURR2_LAST) { // nope
-                    outputBuffer[outputPtr++] = (byte) (0xe0 | (ch >> 12));
-                    if (outputPtr >= outputBuffer.length) {
-                        outputBuffer = byteBuilder.finishCurrentSegment();
-                        outputPtr = 0;
-                    }
-                    outputBuffer[outputPtr++] = (byte) (0x80 | ((ch >> 6) & 0x3f));
-                    ch = (0x80 | (ch & 0x3f));
-                } else { // yes, surrogate pair
-                    if (ch > SURR1_LAST) { // must be from first range
-                        _illegalSurrogate(ch);
-                    }
-                    // and if so, followed by another from next range
-                    if (inputPtr >= inputEnd) {
-                        _illegalSurrogate(ch);
-                    }
-                    ch = _convertSurrogate(ch, text.charAt(inputPtr++));
-                    if (ch > 0x10FFFF) { // illegal, as per RFC 4627
-                        _illegalSurrogate(ch);
-                    }
-                    outputBuffer[outputPtr++] = (byte) (0xf0 | (ch >> 18));
-                    if (outputPtr >= outputBuffer.length) {
-                        outputBuffer = byteBuilder.finishCurrentSegment();
-                        outputPtr = 0;
-                    }
-                    outputBuffer[outputPtr++] = (byte) (0x80 | ((ch >> 12) & 0x3f));
-                    if (outputPtr >= outputBuffer.length) {
-                        outputBuffer = byteBuilder.finishCurrentSegment();
-                        outputPtr = 0;
-                    }
-                    outputBuffer[outputPtr++] = (byte) (0x80 | ((ch >> 6) & 0x3f));
-                    ch = (0x80 | (ch & 0x3f));
-                }
-            }
-            if (outputPtr >= outputBuffer.length) {
-                outputBuffer = byteBuilder.finishCurrentSegment();
-                outputPtr = 0;
-            }
-            outputBuffer[outputPtr++] = (byte) ch;
-        }
-        return _byteBuilder.completeAndCoalesce(outputPtr);
-    }
-    
-    /**
-     * Will encode given String as UTF-8 (without any quoting), return
-     * resulting byte array.
-     */
-    @SuppressWarnings("resource")
-    public byte[] encodeAsUTF8(String text)
-    {
-        ByteArrayBuilder byteBuilder = _byteBuilder;
-        if (byteBuilder == null) {
-            // no allocator; can add if we must, shouldn't need to
-            _byteBuilder = byteBuilder = new ByteArrayBuilder(null);
-        }
-        int inputPtr = 0;
-        int inputEnd = text.length();
-        int outputPtr = 0;
-        byte[] outputBuffer = byteBuilder.resetAndGetFirstSegment();
-        int outputEnd = outputBuffer.length;
-        
-        main_loop:
-        while (inputPtr < inputEnd) {
-            int c = text.charAt(inputPtr++);
-
-            // first tight loop for ascii
-            while (c <= 0x7F) {
-                if (outputPtr >= outputEnd) {
-                    outputBuffer = byteBuilder.finishCurrentSegment();
-                    outputEnd = outputBuffer.length;
-                    outputPtr = 0;
-                }
-                outputBuffer[outputPtr++] = (byte) c;
-                if (inputPtr >= inputEnd) {
-                    break main_loop;
-                }
-                c = text.charAt(inputPtr++);
-            }
-
-            // then multi-byte...
-            if (outputPtr >= outputEnd) {
-                outputBuffer = byteBuilder.finishCurrentSegment();
-                outputEnd = outputBuffer.length;
-                outputPtr = 0;
-            }
-            if (c < 0x800) { // 2-byte
-                outputBuffer[outputPtr++] = (byte) (0xc0 | (c >> 6));
-            } else { // 3 or 4 bytes
-                // Surrogates?
-                if (c < SURR1_FIRST || c > SURR2_LAST) { // nope
-                    outputBuffer[outputPtr++] = (byte) (0xe0 | (c >> 12));
-                    if (outputPtr >= outputEnd) {
-                        outputBuffer = byteBuilder.finishCurrentSegment();
-                        outputEnd = outputBuffer.length;
-                        outputPtr = 0;
-                    }
-                    outputBuffer[outputPtr++] = (byte) (0x80 | ((c >> 6) & 0x3f));
-                } else { // yes, surrogate pair
-                    if (c > SURR1_LAST) { // must be from first range
-                        _illegalSurrogate(c);
-                    }
-                    // and if so, followed by another from next range
-                    if (inputPtr >= inputEnd) {
-                        _illegalSurrogate(c);
-                    }
-                    c = _convertSurrogate(c, text.charAt(inputPtr++));
-                    if (c > 0x10FFFF) { // illegal, as per RFC 4627
-                        _illegalSurrogate(c);
-                    }
-                    outputBuffer[outputPtr++] = (byte) (0xf0 | (c >> 18));
-                    if (outputPtr >= outputEnd) {
-                        outputBuffer = byteBuilder.finishCurrentSegment();
-                        outputEnd = outputBuffer.length;
-                        outputPtr = 0;
-                    }
-                    outputBuffer[outputPtr++] = (byte) (0x80 | ((c >> 12) & 0x3f));
-                    if (outputPtr >= outputEnd) {
-                        outputBuffer = byteBuilder.finishCurrentSegment();
-                        outputEnd = outputBuffer.length;
-                        outputPtr = 0;
-                    }
-                    outputBuffer[outputPtr++] = (byte) (0x80 | ((c >> 6) & 0x3f));
-                }
-            }
-            if (outputPtr >= outputEnd) {
-                outputBuffer = byteBuilder.finishCurrentSegment();
-                outputEnd = outputBuffer.length;
-                outputPtr = 0;
-            }
-            outputBuffer[outputPtr++] = (byte) (0x80 | (c & 0x3f));
-        }
-        return _byteBuilder.completeAndCoalesce(outputPtr);
-    }
-    
-    /*
-    /**********************************************************
-    /* Internal methods
-    /**********************************************************
-     */
-
-    private int _appendNumericEscape(int value, char[] quoteBuffer)
-    {
-        quoteBuffer[1] = 'u';
-        // We know it's a control char, so only the last 2 chars are non-0
-        quoteBuffer[4] = HEX_CHARS[value >> 4];
-        quoteBuffer[5] = HEX_CHARS[value & 0xF];
-        return 6;
-    }
-
-    private int _appendNamedEscape(int escCode, char[] quoteBuffer)
-    {
-        quoteBuffer[1] = (char) escCode;
-        return 2;
-    }
-
-    private int _appendByteEscape(int ch, int escCode, ByteArrayBuilder byteBuilder, int ptr)
-    {
-        byteBuilder.setCurrentSegmentLength(ptr);
-        byteBuilder.append(INT_BACKSLASH);
-        if (escCode < 0) { // standard escape
-            byteBuilder.append(INT_U);
-            if (ch > 0xFF) {
-                int hi = (ch >> 8);
-                byteBuilder.append(HEX_BYTES[hi >> 4]);
-                byteBuilder.append(HEX_BYTES[hi & 0xF]);
-                ch &= 0xFF;
-            } else {
-                byteBuilder.append(INT_0);
-                byteBuilder.append(INT_0);
-            }
-            byteBuilder.append(HEX_BYTES[ch >> 4]);
-            byteBuilder.append(HEX_BYTES[ch & 0xF]);
-        } else { // 2-char simple escape
-            byteBuilder.append((byte) escCode);
-        }
-        return byteBuilder.getCurrentSegmentLength();
-    }
-
-    protected static int _convertSurrogate(int firstPart, int secondPart)
-    {
-        // Ok, then, is the second part valid?
-        if (secondPart < SURR2_FIRST || secondPart > SURR2_LAST) {
-            throw new IllegalArgumentException("Broken surrogate pair: first char 0x"+Integer.toHexString(firstPart)+", second 0x"+Integer.toHexString(secondPart)+"; illegal combination");
-        }
-        return 0x10000 + ((firstPart - SURR1_FIRST) << 10) + (secondPart - SURR2_FIRST);
-    }
-
-    protected static void _illegalSurrogate(int code) {
-        throw new IllegalArgumentException(UTF8Writer.illegalSurrogateDesc(code));
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/io/MergedStream.java

@@ -1,145 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.io;
-
-import java.io.*;
-
-/**
- * Simple {@link InputStream} implementation that is used to "unwind" some
- * data previously read from an input stream; so that as long as some of
- * that data remains, it's returned; but as long as it's read, we'll
- * just use data from the underlying original stream. 
- * This is similar to {@link java.io.PushbackInputStream}, but here there's
- * only one implicit pushback, when instance is constructed.
- */
-public final class MergedStream
-    extends InputStream
-{
-    final protected IOContext _context;
-
-    final InputStream _in;
-
-    byte[] _buffer;
-
-    int _ptr;
-
-    final int _end;
-
-    public MergedStream(IOContext context,
-            InputStream in, byte[] buf, int start, int end)
-    {
-        _context = context;
-        _in = in;
-        _buffer = buf;
-        _ptr = start;
-        _end = end;
-    }
-
-    @Override
-    public int available() throws IOException
-    {
-        if (_buffer != null) {
-            return _end - _ptr;
-        }
-        return _in.available();
-    }
-
-    @Override
-    public void close() throws IOException
-    {
-        freeMergedBuffer();
-        _in.close();
-    }
-
-    @Override
-    public void mark(int readlimit)
-    {
-        if (_buffer == null) {
-            _in.mark(readlimit);
-        }
-    }
-    
-    @Override
-    public boolean markSupported()
-    {
-        // Only supports marks past the initial rewindable section...
-        return (_buffer == null) && _in.markSupported();
-    }
-    
-    @Override
-    public int read() throws IOException
-    {
-        if (_buffer != null) {
-            int c = _buffer[_ptr++] & 0xFF;
-            if (_ptr >= _end) {
-                freeMergedBuffer();
-            }
-            return c;
-        }
-        return _in.read();
-    }
-    
-    @Override
-    public int read(byte[] b) throws IOException
-    {
-        return read(b, 0, b.length);
-    }
-
-    @Override
-    public int 	read(byte[] b, int off, int len) throws IOException
-    {
-        if (_buffer != null) {
-            int avail = _end - _ptr;
-            if (len > avail) {
-                len = avail;
-            }
-            System.arraycopy(_buffer, _ptr, b, off, len);
-            _ptr += len;
-            if (_ptr >= _end) {
-                freeMergedBuffer();
-            }
-            return len;
-        }
-        return _in.read(b, off, len);
-    }
-
-    @Override
-    public void reset() throws IOException
-    {
-        if (_buffer == null) {
-            _in.reset();
-        }
-    }
-
-    @Override
-    public long skip(long n) throws IOException
-    {
-        long count = 0L;
-
-        if (_buffer != null) {
-            int amount = _end - _ptr;
-
-            if (amount > n) { // all in pushed back segment?
-                _ptr += (int) n;
-                return n;
-            }
-            freeMergedBuffer();
-            count += amount;
-            n -= amount;
-        }
-
-        if (n > 0) {
-            count += _in.skip(n);
-        }
-        return count;
-    }
-
-    private void freeMergedBuffer()
-    {
-        byte[] buf = _buffer;
-        if (buf != null) {
-            _buffer = null;
-            if (_context != null) {
-                _context.releaseReadIOBuffer(buf);
-            }
-        }
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/io/NumberInput.java

@@ -1,319 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.io;
-
-import java.math.BigDecimal;
-
-public final class NumberInput
-{
-    /**
-     * Textual representation of a double constant that can cause nasty problems
-     * with JDK (see http://www.exploringbinary.com/java-hangs-when-converting-2-2250738585072012e-308).
-     */
-    public final static String NASTY_SMALL_DOUBLE = "2.2250738585072012e-308";
-
-    /**
-     * Constants needed for parsing longs from basic int parsing methods
-     */
-    final static long L_BILLION = 1000000000;
-
-    final static String MIN_LONG_STR_NO_SIGN = String.valueOf(Long.MIN_VALUE).substring(1);
-    final static String MAX_LONG_STR = String.valueOf(Long.MAX_VALUE);
-    
-    /**
-     * Fast method for parsing integers that are known to fit into
-     * regular 32-bit signed int type. This means that length is
-     * between 1 and 9 digits (inclusive)
-     *<p>
-     * Note: public to let unit tests call it
-     */
-    public static int parseInt(char[] digitChars, int offset, int len)
-    {
-        int num = digitChars[offset] - '0';
-        len += offset;
-        // This looks ugly, but appears the fastest way (as per measurements)
-        if (++offset < len) {
-            num = (num * 10) + (digitChars[offset] - '0');
-            if (++offset < len) {
-                num = (num * 10) + (digitChars[offset] - '0');
-                if (++offset < len) {
-                    num = (num * 10) + (digitChars[offset] - '0');
-                    if (++offset < len) {
-                        num = (num * 10) + (digitChars[offset] - '0');
-                        if (++offset < len) {
-                            num = (num * 10) + (digitChars[offset] - '0');
-                            if (++offset < len) {
-                                num = (num * 10) + (digitChars[offset] - '0');
-                                if (++offset < len) {
-                                    num = (num * 10) + (digitChars[offset] - '0');
-                                    if (++offset < len) {
-                                        num = (num * 10) + (digitChars[offset] - '0');
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return num;
-    }
-
-    /**
-     * Helper method to (more) efficiently parse integer numbers from
-     * String values.
-     */
-    public static int parseInt(String str)
-    {
-        /* Ok: let's keep strategy simple: ignoring optional minus sign,
-         * we'll accept 1 - 9 digits and parse things efficiently;
-         * otherwise just defer to JDK parse functionality.
-         */
-        char c = str.charAt(0);
-        int length = str.length();
-        boolean negative = (c == '-');
-        int offset = 1;
-        // must have 1 - 9 digits after optional sign:
-        // negative?
-        if (negative) {
-            if (length == 1 || length > 10) {
-                return Integer.parseInt(str);
-            }
-            c = str.charAt(offset++);
-        } else {
-            if (length > 9) {
-                return Integer.parseInt(str);
-            }
-        }
-        if (c > '9' || c < '0') {
-            return Integer.parseInt(str);
-        }
-        int num = c - '0';
-        if (offset < length) {
-            c = str.charAt(offset++);
-            if (c > '9' || c < '0') {
-                return Integer.parseInt(str);
-            }
-            num = (num * 10) + (c - '0');
-            if (offset < length) {
-                c = str.charAt(offset++);
-                if (c > '9' || c < '0') {
-                    return Integer.parseInt(str);
-                }
-                num = (num * 10) + (c - '0');
-                // Let's just loop if we have more than 3 digits:
-                if (offset < length) {
-                    do {
-                        c = str.charAt(offset++);
-                        if (c > '9' || c < '0') {
-                            return Integer.parseInt(str);
-                        }
-                        num = (num * 10) + (c - '0');
-                    } while (offset < length);
-                }
-            }
-        }
-        return negative ? -num : num;
-    }
-    
-    public static long parseLong(char[] digitChars, int offset, int len)
-    {
-        // Note: caller must ensure length is [10, 18]
-        int len1 = len-9;
-        long val = parseInt(digitChars, offset, len1) * L_BILLION;
-        return val + (long) parseInt(digitChars, offset+len1, 9);
-    }
-
-    public static long parseLong(String str)
-    {
-        /* Ok, now; as the very first thing, let's just optimize case of "fake longs";
-         * that is, if we know they must be ints, call int parsing
-         */
-        int length = str.length();
-        if (length <= 9) {
-            return (long) parseInt(str);
-        }
-        // !!! TODO: implement efficient 2-int parsing...
-        return Long.parseLong(str);
-    }
-    
-    /**
-     * Helper method for determining if given String representation of
-     * an integral number would fit in 64-bit Java long or not.
-     * Note that input String must NOT contain leading minus sign (even
-     * if 'negative' is set to true).
-     *
-     * @param negative Whether original number had a minus sign (which is
-     *    NOT passed to this method) or not
-     */
-    public static boolean inLongRange(char[] digitChars, int offset, int len,
-            boolean negative)
-    {
-        String cmpStr = negative ? MIN_LONG_STR_NO_SIGN : MAX_LONG_STR;
-        int cmpLen = cmpStr.length();
-        if (len < cmpLen) return true;
-        if (len > cmpLen) return false;
-
-        for (int i = 0; i < cmpLen; ++i) {
-            int diff = digitChars[offset+i] - cmpStr.charAt(i);
-            if (diff != 0) {
-                return (diff < 0);
-            }
-        }
-        return true;
-    }
-
-    /**
-     * Similar to {@link #inLongRange(char[],int,int,boolean)}, but
-     * with String argument
-     *
-     * @param negative Whether original number had a minus sign (which is
-     *    NOT passed to this method) or not
-     */
-    public static boolean inLongRange(String numberStr, boolean negative)
-    {
-        String cmpStr = negative ? MIN_LONG_STR_NO_SIGN : MAX_LONG_STR;
-        int cmpLen = cmpStr.length();
-        int actualLen = numberStr.length();
-        if (actualLen < cmpLen) return true;
-        if (actualLen > cmpLen) return false;
-
-        // could perhaps just use String.compareTo()?
-        for (int i = 0; i < cmpLen; ++i) {
-            int diff = numberStr.charAt(i) - cmpStr.charAt(i);
-            if (diff != 0) {
-                return (diff < 0);
-            }
-        }
-        return true;
-    }
-
-    public static int parseAsInt(String input, int defaultValue)
-    {
-        if (input == null) {
-            return defaultValue;
-        }
-        input = input.trim();
-        int len = input.length();
-        if (len == 0) {
-            return defaultValue;
-        }
-        // One more thing: use integer parsing for 'simple'
-        int i = 0;
-        if (i < len) { // skip leading sign:
-            char c = input.charAt(0);
-            if (c == '+') { // for plus, actually physically remove
-                input = input.substring(1);
-                len = input.length();
-            } else if (c == '-') { // minus, just skip for checks, must retain
-                ++i;
-            }
-        }
-        for (; i < len; ++i) {
-            char c = input.charAt(i);
-            // if other symbols, parse as Double, coerce
-            if (c > '9' || c < '0') {
-                try {
-                    return (int) parseDouble(input);
-                } catch (NumberFormatException e) {
-                    return defaultValue;
-                }
-            }
-        }
-        try {
-            return Integer.parseInt(input);
-        } catch (NumberFormatException e) { }
-        return defaultValue;
-    }
-
-    public static long parseAsLong(String input, long defaultValue)
-    {
-        if (input == null) {
-            return defaultValue;
-        }
-        input = input.trim();
-        int len = input.length();
-        if (len == 0) {
-            return defaultValue;
-        }
-        // One more thing: use long parsing for 'simple'
-        int i = 0;
-        if (i < len) { // skip leading sign:
-            char c = input.charAt(0);
-            if (c == '+') { // for plus, actually physically remove
-                input = input.substring(1);
-                len = input.length();
-            } else if (c == '-') { // minus, just skip for checks, must retain
-                ++i;
-            }
-        }
-        for (; i < len; ++i) {
-            char c = input.charAt(i);
-            // if other symbols, parse as Double, coerce
-            if (c > '9' || c < '0') {
-                try {
-                    return (long) parseDouble(input);
-                } catch (NumberFormatException e) {
-                    return defaultValue;
-                }
-            }
-        }
-        try {
-            return Long.parseLong(input);
-        } catch (NumberFormatException e) { }
-        return defaultValue;
-    }
-    
-    public static double parseAsDouble(String input, double defaultValue)
-    {
-        if (input == null) {
-            return defaultValue;
-        }
-        input = input.trim();
-        int len = input.length();
-        if (len == 0) {
-            return defaultValue;
-        }
-        try {
-            return parseDouble(input);
-        } catch (NumberFormatException e) { }
-        return defaultValue;
-    }
-
-    public static double parseDouble(String numStr) throws NumberFormatException
-    {
-        // [JACKSON-486]: avoid some nasty float representations... but should it be MIN_NORMAL or MIN_VALUE?
-        /* as per [JACKSON-827], let's use MIN_VALUE as it is available on all JDKs; normalized
-         * only in JDK 1.6. In practice, should not really matter.
-         */
-        if (NASTY_SMALL_DOUBLE.equals(numStr)) {
-            return Double.MIN_VALUE;
-        }
-        return Double.parseDouble(numStr);
-    }
-
-    public static BigDecimal parseBigDecimal(String numStr) throws NumberFormatException
-    {
-        try {
-            return new BigDecimal(numStr);
-        } catch (NumberFormatException e) {
-            throw _badBigDecimal(numStr);
-        }
-    }
-
-    public static BigDecimal parseBigDecimal(char[] buffer) throws NumberFormatException {
-        return parseBigDecimal(buffer, 0, buffer.length);
-    }
-    
-    public static BigDecimal parseBigDecimal(char[] buffer, int offset, int len)
-            throws NumberFormatException
-    {
-        try {
-            return new BigDecimal(buffer, offset, len);
-        } catch (NumberFormatException e) {
-            throw _badBigDecimal(new String(buffer, offset, len));
-        }
-    }
-
-    private static NumberFormatException _badBigDecimal(String str) {
-        return new NumberFormatException("Value \""+str+"\" can not be represented as BigDecimal");
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/io/NumberOutput.java

@@ -1,398 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.io;
-
-public final class NumberOutput
-{
-    private final static char NULL_CHAR = (char) 0;
-
-    private static int MILLION = 1000000;
-    private static int BILLION = 1000000000;
-    private static long TEN_BILLION_L = 10000000000L;
-    private static long THOUSAND_L = 1000L;
-
-    private static long MIN_INT_AS_LONG = (long) Integer.MIN_VALUE;
-    private static long MAX_INT_AS_LONG = (long) Integer.MAX_VALUE;
-
-    final static String SMALLEST_LONG = String.valueOf(Long.MIN_VALUE);
-
-    final static char[] LEADING_TRIPLETS = new char[4000];
-    final static char[] FULL_TRIPLETS = new char[4000];
-    static {
-        /* Let's fill it with NULLs for ignorable leading digits,
-         * and digit chars for others
-         */
-        int ix = 0;
-        for (int i1 = 0; i1 < 10; ++i1) {
-            char f1 = (char) ('0' + i1);
-            char l1 = (i1 == 0) ? NULL_CHAR : f1;
-            for (int i2 = 0; i2 < 10; ++i2) {
-                char f2 = (char) ('0' + i2);
-                char l2 = (i1 == 0 && i2 == 0) ? NULL_CHAR : f2;
-                for (int i3 = 0; i3 < 10; ++i3) {
-                    // Last is never to be empty
-                    char f3 = (char) ('0' + i3);
-                    LEADING_TRIPLETS[ix] = l1;
-                    LEADING_TRIPLETS[ix+1] = l2;
-                    LEADING_TRIPLETS[ix+2] = f3;
-                    FULL_TRIPLETS[ix] = f1;
-                    FULL_TRIPLETS[ix+1] = f2;
-                    FULL_TRIPLETS[ix+2] = f3;
-                    ix += 4;
-                }
-            }
-        }
-    }
-
-    final static byte[] FULL_TRIPLETS_B = new byte[4000];
-    static {
-        for (int i = 0; i < 4000; ++i) {
-            FULL_TRIPLETS_B[i] = (byte) FULL_TRIPLETS[i];
-        }
-    }
-    
-    final static String[] sSmallIntStrs = new String[] {
-        "0","1","2","3","4","5","6","7","8","9","10"
-    };
-    final static String[] sSmallIntStrs2 = new String[] {
-        "-1","-2","-3","-4","-5","-6","-7","-8","-9","-10"
-    };
-
-    /*
-    /**********************************************************
-    /* Efficient serialization methods using raw buffers
-    /**********************************************************
-     */
-
-    /**
-     * @return Offset within buffer after outputting int
-     */
-    public static int outputInt(int value, char[] buffer, int offset)
-    {
-        if (value < 0) {
-            if (value == Integer.MIN_VALUE) {
-                /* Special case: no matching positive value within range;
-                 * let's then "upgrade" to long and output as such.
-                 */
-                return outputLong((long) value, buffer, offset);
-            }
-            buffer[offset++] = '-';
-            value = -value;
-        }
-
-        if (value < MILLION) { // at most 2 triplets...
-            if (value < 1000) {
-                if (value < 10) {
-                    buffer[offset++] = (char) ('0' + value);
-                } else {
-                    offset = outputLeadingTriplet(value, buffer, offset);
-                }
-            } else {
-                int thousands = value / 1000;
-                value -= (thousands * 1000); // == value % 1000
-                offset = outputLeadingTriplet(thousands, buffer, offset);
-                offset = outputFullTriplet(value, buffer, offset);
-            }
-            return offset;
-        }
-
-        // ok, all 3 triplets included
-        /* Let's first hand possible billions separately before
-         * handling 3 triplets. This is possible since we know we
-         * can have at most '2' as billion count.
-         */
-        boolean hasBillions = (value >= BILLION);
-        if (hasBillions) {
-            value -= BILLION;
-            if (value >= BILLION) {
-                value -= BILLION;
-                buffer[offset++] = '2';
-            } else {
-                buffer[offset++] = '1';
-            }
-        }
-        int newValue = value / 1000;
-        int ones = (value - (newValue * 1000)); // == value % 1000
-        value = newValue;
-        newValue /= 1000;
-        int thousands = (value - (newValue * 1000));
-        
-        // value now has millions, which have 1, 2 or 3 digits
-        if (hasBillions) {
-            offset = outputFullTriplet(newValue, buffer, offset);
-        } else {
-            offset = outputLeadingTriplet(newValue, buffer, offset);
-        }
-        offset = outputFullTriplet(thousands, buffer, offset);
-        offset = outputFullTriplet(ones, buffer, offset);
-        return offset;
-    }
-
-    public static int outputInt(int value, byte[] buffer, int offset)
-    {
-        if (value < 0) {
-            if (value == Integer.MIN_VALUE) {
-                return outputLong((long) value, buffer, offset);
-            }
-            buffer[offset++] = '-';
-            value = -value;
-        }
-
-        if (value < MILLION) { // at most 2 triplets...
-            if (value < 1000) {
-                if (value < 10) {
-                    buffer[offset++] = (byte) ('0' + value);
-                } else {
-                    offset = outputLeadingTriplet(value, buffer, offset);
-                }
-            } else {
-                int thousands = value / 1000;
-                value -= (thousands * 1000); // == value % 1000
-                offset = outputLeadingTriplet(thousands, buffer, offset);
-                offset = outputFullTriplet(value, buffer, offset);
-            }
-            return offset;
-        }
-        boolean hasBillions = (value >= BILLION);
-        if (hasBillions) {
-            value -= BILLION;
-            if (value >= BILLION) {
-                value -= BILLION;
-                buffer[offset++] = '2';
-            } else {
-                buffer[offset++] = '1';
-            }
-        }
-        int newValue = value / 1000;
-        int ones = (value - (newValue * 1000)); // == value % 1000
-        value = newValue;
-        newValue /= 1000;
-        int thousands = (value - (newValue * 1000));
-        
-        if (hasBillions) {
-            offset = outputFullTriplet(newValue, buffer, offset);
-        } else {
-            offset = outputLeadingTriplet(newValue, buffer, offset);
-        }
-        offset = outputFullTriplet(thousands, buffer, offset);
-        offset = outputFullTriplet(ones, buffer, offset);
-        return offset;
-    }
-    
-    /**
-     * @return Offset within buffer after outputting int
-     */
-    public static int outputLong(long value, char[] buffer, int offset)
-    {
-        // First: does it actually fit in an int?
-        if (value < 0L) {
-            /* MIN_INT is actually printed as long, just because its
-             * negation is not an int but long
-             */
-            if (value > MIN_INT_AS_LONG) {
-                return outputInt((int) value, buffer, offset);
-            }
-            if (value == Long.MIN_VALUE) {
-                // Special case: no matching positive value within range
-                int len = SMALLEST_LONG.length();
-                SMALLEST_LONG.getChars(0, len, buffer, offset);
-                return (offset + len);
-            }
-            buffer[offset++] = '-';
-            value = -value;
-        } else {
-            if (value <= MAX_INT_AS_LONG) {
-                return outputInt((int) value, buffer, offset);
-            }
-        }
-
-        /* Ok: real long print. Need to first figure out length
-         * in characters, and then print in from end to beginning
-         */
-        int origOffset = offset;
-        offset += calcLongStrLength(value);
-        int ptr = offset;
-
-        // First, with long arithmetics:
-        while (value > MAX_INT_AS_LONG) { // full triplet
-            ptr -= 3;
-            long newValue = value / THOUSAND_L;
-            int triplet = (int) (value - newValue * THOUSAND_L);
-            outputFullTriplet(triplet, buffer, ptr);
-            value = newValue;
-        }
-        // Then with int arithmetics:
-        int ivalue = (int) value;
-        while (ivalue >= 1000) { // still full triplet
-            ptr -= 3;
-            int newValue = ivalue / 1000;
-            int triplet = ivalue - (newValue * 1000);
-            outputFullTriplet(triplet, buffer, ptr);
-            ivalue = newValue;
-        }
-        // And finally, if anything remains, partial triplet
-        outputLeadingTriplet(ivalue, buffer, origOffset);
-
-        return offset;
-    }
-
-    public static int outputLong(long value, byte[] buffer, int offset)
-    {
-        if (value < 0L) {
-            if (value > MIN_INT_AS_LONG) {
-                return outputInt((int) value, buffer, offset);
-            }
-            if (value == Long.MIN_VALUE) {
-                // Special case: no matching positive value within range
-                int len = SMALLEST_LONG.length();
-                for (int i = 0; i < len; ++i) {
-                    buffer[offset++] = (byte) SMALLEST_LONG.charAt(i);
-                }
-                return offset;
-            }
-            buffer[offset++] = '-';
-            value = -value;
-        } else {
-            if (value <= MAX_INT_AS_LONG) {
-                return outputInt((int) value, buffer, offset);
-            }
-        }
-        int origOffset = offset;
-        offset += calcLongStrLength(value);
-        int ptr = offset;
-
-        // First, with long arithmetics:
-        while (value > MAX_INT_AS_LONG) { // full triplet
-            ptr -= 3;
-            long newValue = value / THOUSAND_L;
-            int triplet = (int) (value - newValue * THOUSAND_L);
-            outputFullTriplet(triplet, buffer, ptr);
-            value = newValue;
-        }
-        // Then with int arithmetics:
-        int ivalue = (int) value;
-        while (ivalue >= 1000) { // still full triplet
-            ptr -= 3;
-            int newValue = ivalue / 1000;
-            int triplet = ivalue - (newValue * 1000);
-            outputFullTriplet(triplet, buffer, ptr);
-            ivalue = newValue;
-        }
-        outputLeadingTriplet(ivalue, buffer, origOffset);
-        return offset;
-    }
-    
-    /*
-    /**********************************************************
-    /* Secondary convenience serialization methods
-    /**********************************************************
-     */
-
-    /* !!! 05-Aug-2008, tatus: Any ways to further optimize
-     *   these? (or need: only called by diagnostics methods?)
-     */
-
-    public static String toString(int value)
-    {
-        // Lookup table for small values
-        if (value < sSmallIntStrs.length) {
-            if (value >= 0) {
-                return sSmallIntStrs[value];
-            }
-            int v2 = -value - 1;
-            if (v2 < sSmallIntStrs2.length) {
-                return sSmallIntStrs2[v2];
-            }
-        }
-        return Integer.toString(value);
-    }
-
-    public static String toString(long value)
-    {
-        if (value <= Integer.MAX_VALUE &&
-            value >= Integer.MIN_VALUE) {
-            return toString((int) value);
-        }
-        return Long.toString(value);
-    }
-
-    public static String toString(double value)
-    {
-        return Double.toString(value);
-    }
-
-    /*
-    /**********************************************************
-    /* Internal methods
-    /**********************************************************
-     */
-
-    private static int outputLeadingTriplet(int triplet, char[] buffer, int offset)
-    {
-        int digitOffset = (triplet << 2);
-        char c = LEADING_TRIPLETS[digitOffset++];
-        if (c != NULL_CHAR) {
-            buffer[offset++] = c;
-        }
-        c = LEADING_TRIPLETS[digitOffset++];
-        if (c != NULL_CHAR) {
-            buffer[offset++] = c;
-        }
-        // Last is required to be non-empty
-        buffer[offset++] = LEADING_TRIPLETS[digitOffset];
-        return offset;
-    }
-
-    private static int outputLeadingTriplet(int triplet, byte[] buffer, int offset)
-    {
-        int digitOffset = (triplet << 2);
-        char c = LEADING_TRIPLETS[digitOffset++];
-        if (c != NULL_CHAR) {
-            buffer[offset++] = (byte) c;
-        }
-        c = LEADING_TRIPLETS[digitOffset++];
-        if (c != NULL_CHAR) {
-            buffer[offset++] = (byte) c;
-        }
-        // Last is required to be non-empty
-        buffer[offset++] = (byte) LEADING_TRIPLETS[digitOffset];
-        return offset;
-    }
-    
-    private static int outputFullTriplet(int triplet, char[] buffer, int offset)
-    {
-        int digitOffset = (triplet << 2);
-        buffer[offset++] = FULL_TRIPLETS[digitOffset++];
-        buffer[offset++] = FULL_TRIPLETS[digitOffset++];
-        buffer[offset++] = FULL_TRIPLETS[digitOffset];
-        return offset;
-    }
-
-    private static int outputFullTriplet(int triplet, byte[] buffer, int offset)
-    {
-        int digitOffset = (triplet << 2);
-        buffer[offset++] = FULL_TRIPLETS_B[digitOffset++];
-        buffer[offset++] = FULL_TRIPLETS_B[digitOffset++];
-        buffer[offset++] = FULL_TRIPLETS_B[digitOffset];
-        return offset;
-    }
-    
-    /**
-     *<p>
-     * Pre-conditions: posValue is positive, and larger than
-     * Integer.MAX_VALUE (about 2 billions).
-     */
-    private static int calcLongStrLength(long posValue)
-    {
-        int len = 10;
-        long comp = TEN_BILLION_L;
-
-        // 19 is longest, need to worry about overflow
-        while (posValue >= comp) {
-            if (len == 19) {
-                break;
-            }
-            ++len;
-            comp = (comp << 3) + (comp << 1); // 10x
-        }
-        return len;
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/io/OutputDecorator.java

@@ -1,41 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.io;
-
-import java.io.*;
-
-/**
- * Handler class that can be used to decorate output destinations.
- * Typical use is to use a filter abstraction (filtered output stream,
- * writer) around original output destination, and apply additional
- * processing during write operations.
- */
-public abstract class OutputDecorator
-    implements java.io.Serializable // since 2.1
-{
-    private static final long serialVersionUID = 1L;
-
-    /**
-     * Method called by {@link com.fr.third.fasterxml.jackson.core.JsonFactory} instance when
-     * creating generator for given {@link OutputStream}, when this decorator
-     * has been registered.
-     * 
-     * @param ctxt IO context in use (provides access to declared encoding)
-     * @param out Original output destination
-     * 
-     * @return OutputStream to use; either passed in argument, or something that
-     *   calls it
-     */
-    public abstract OutputStream decorate(IOContext ctxt, OutputStream out)
-        throws IOException;
-
-    /**
-     * Method called by {@link com.fr.third.fasterxml.jackson.core.JsonFactory} instance when
-     * creating generator for given {@link Writer}, when this decorator
-     * has been registered.
-     * 
-     * @param ctxt IO context in use (provides access to declared encoding)
-     * @param w Original output writer
-     * 
-     * @return Writer to use; either passed in argument, or something that calls it
-     */
-    public abstract Writer decorate(IOContext ctxt, Writer w) throws IOException;
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/io/SegmentedStringWriter.java

@@ -1,102 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.io;
-
-import java.io.*;
-
-import com.fr.third.fasterxml.jackson.core.util.BufferRecycler;
-import com.fr.third.fasterxml.jackson.core.util.TextBuffer;
-
-/**
- * Efficient alternative to {@link StringWriter}, based on using segmented
- * internal buffer. Initial input buffer is also recyclable.
- *<p>
- * This class is most useful when serializing JSON content as a String:
- * if so, instance of this class can be given as the writer to
- * <code>JsonGenerator</code>.
- */
-public final class SegmentedStringWriter
-    extends Writer
-{
-    final protected TextBuffer _buffer;
-
-    public SegmentedStringWriter(BufferRecycler br)
-    {
-        super();
-        _buffer = new TextBuffer(br);
-    }
-
-    /*
-    /**********************************************************
-    /* java.io.Writer implementation
-    /**********************************************************
-     */
-
-    @Override
-    public Writer append(char c)
-    {
-        write(c);
-        return this;
-    }
-
-    @Override
-    public Writer append(CharSequence csq)
-    {
-        String str = csq.toString();
-        _buffer.append(str, 0, str.length());
-        return this;
-    }
-
-    @Override
-    public Writer append(CharSequence csq, int start, int end)
-    {
-        String str = csq.subSequence(start, end).toString();
-        _buffer.append(str, 0, str.length());
-        return this;
-    }
-
-    @Override public void close() { } // NOP
-
-    @Override public void flush() { } // NOP
-
-    @Override
-    public void write(char[] cbuf) {
-        _buffer.append(cbuf, 0, cbuf.length);
-    }
-
-    @Override
-    public void write(char[] cbuf, int off, int len) {
-        _buffer.append(cbuf, off, len);
-    }
-
-    @Override
-    public void write(int c) {
-        _buffer.append((char) c);
-    }
-
-    @Override
-    public void write(String str) { _buffer.append(str, 0, str.length()); }
-
-    @Override
-    public void write(String str, int off, int len) {
-        _buffer.append(str, off, len);
-    }
-
-    /*
-    /**********************************************************
-    /* Extended API
-    /**********************************************************
-     */
-
-    /**
-     * Main access method that will construct a String that contains
-     * all the contents, release all internal buffers we may have,
-     * and return result String.
-     * Note that the method is not idempotent -- if called second time,
-     * will just return an empty String.
-     */
-    public String getAndClear()
-    {
-        String result = _buffer.contentsAsString();
-        _buffer.releaseBuffers();
-        return result;
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/io/SerializedString.java

@@ -1,280 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.io;
-
-import java.io.*;
-import java.nio.ByteBuffer;
-
-import com.fr.third.fasterxml.jackson.core.SerializableString;
-
-/**
- * String token that can lazily serialize String contained and then reuse that
- * serialization later on. This is similar to JDBC prepared statements, for example,
- * in that instances should only be created when they are used more than use;
- * prime candidates are various serializers.
- *<p>
- * Class is final for performance reasons and since this is not designed to
- * be extensible or customizable (customizations would occur in calling code)
- */
-public class SerializedString
-    implements SerializableString, java.io.Serializable
-{
-    protected final String _value;
-
-    /* 13-Dec-2010, tatu: Whether use volatile or not is actually an important
-     *   decision for multi-core use cases. Cost of volatility can be non-trivial
-     *   for heavy use cases, and serialized-string instances are accessed often.
-     *   Given that all code paths with common Jackson usage patterns go through
-     *   a few memory barriers (mostly with cache/reuse pool access) it seems safe
-     *   enough to omit volatiles here, given how simple lazy initialization is.
-     *   This can be compared to how {@link String#intern} works; lazily and
-     *   without synchronization or use of volatile keyword.
-     *   
-     *   Change to remove volatile was a request by implementors of a high-throughput
-     *   search framework; and they believed this is an important optimization for
-     *   heaviest, multi-core deployed use cases.
-     */
-    /*
-     * 22-Sep-2013, tatu: FWIW, there have been no reports of problems in this
-     *   area, or anything pointing to it. So I think we are safe up to JDK7
-     */
-    
-    protected /*volatile*/ byte[] _quotedUTF8Ref;
-
-    protected /*volatile*/ byte[] _unquotedUTF8Ref;
-
-    protected /*volatile*/ char[] _quotedChars;
-
-    public SerializedString(String v) {
-        if (v == null) {
-            throw new IllegalStateException("Null String illegal for SerializedString");
-        }
-        _value = v;
-    }
-    
-    /*
-    /**********************************************************
-    /* Serializable overrides
-    /**********************************************************
-     */
-
-    /**
-     * Ugly hack, to work through the requirement that _value is indeed final,
-     * and that JDK serialization won't call ctor(s).
-     * 
-     * @since 2.1
-     */
-    protected transient String _jdkSerializeValue;
-
-    private void readObject(ObjectInputStream in) throws IOException {
-        _jdkSerializeValue = in.readUTF();
-    }
-
-    private void writeObject(ObjectOutputStream out) throws IOException {
-        out.writeUTF(_value);
-    }
-
-    protected Object readResolve() {
-        return new SerializedString(_jdkSerializeValue);
-    }
-
-    /*
-    /**********************************************************
-    /* API
-    /**********************************************************
-     */
-
-    @Override
-    public final String getValue() { return _value; }
-    
-    /**
-     * Returns length of the String as characters
-     */
-    @Override
-    public final int charLength() { return _value.length(); }
-    
-    @Override
-    public final char[] asQuotedChars()
-    {
-        char[] result = _quotedChars;
-        if (result == null) {
-            result = JsonStringEncoder.getInstance().quoteAsString(_value);
-            _quotedChars = result;
-        }
-        return result;
-    }
-
-    /**
-     * Accessor for accessing value that has been quoted using JSON
-     * quoting rules, and encoded using UTF-8 encoding.
-     */
-    @Override
-    public final byte[] asUnquotedUTF8()
-    {
-        byte[] result = _unquotedUTF8Ref;
-        if (result == null) {
-            result = JsonStringEncoder.getInstance().encodeAsUTF8(_value);
-            _unquotedUTF8Ref  = result;
-        }
-        return result;
-    }
-
-    /**
-     * Accessor for accessing value as is (without JSON quoting)
-     * encoded using UTF-8 encoding.
-     */
-    @Override
-    public final byte[] asQuotedUTF8()
-    {
-        byte[] result = _quotedUTF8Ref;
-        if (result == null) {
-            result = JsonStringEncoder.getInstance().quoteAsUTF8(_value);
-            _quotedUTF8Ref = result;
-        }
-        return result;
-    }
-
-    /*
-    /**********************************************************
-    /* Additional 2.0 methods for appending/writing contents
-    /**********************************************************
-     */
-
-    @Override
-    public int appendQuotedUTF8(byte[] buffer, int offset)
-    {
-        byte[] result = _quotedUTF8Ref;
-        if (result == null) {
-            result = JsonStringEncoder.getInstance().quoteAsUTF8(_value);
-            _quotedUTF8Ref = result;
-        }
-        final int length = result.length;
-        if ((offset + length) > buffer.length) {
-            return -1;
-        }
-        System.arraycopy(result, 0, buffer, offset, length);
-        return length;
-    }
-
-    @Override
-    public int appendQuoted(char[] buffer, int offset)
-    {
-        char[] result = _quotedChars;
-        if (result == null) {
-            result = JsonStringEncoder.getInstance().quoteAsString(_value);
-            _quotedChars = result;
-        }
-        final int length = result.length;
-        if ((offset + length) > buffer.length) {
-            return -1;
-        }
-        System.arraycopy(result, 0, buffer, offset, length);
-        return length;
-    }
-
-    @Override
-    public int appendUnquotedUTF8(byte[] buffer, int offset)
-    {
-        byte[] result = _unquotedUTF8Ref;
-        if (result == null) {
-            result = JsonStringEncoder.getInstance().encodeAsUTF8(_value);
-            _unquotedUTF8Ref  = result;
-        }
-        final int length = result.length;
-        if ((offset + length) > buffer.length) {
-            return -1;
-        }
-        System.arraycopy(result, 0, buffer, offset, length);
-        return length;
-    }
-
-    @Override
-    public int appendUnquoted(char[] buffer, int offset)
-    {
-        String str = _value;
-        final int length = str.length();
-        if ((offset + length) > buffer.length) {
-            return -1;
-        }
-        str.getChars(0,  length, buffer, offset);
-        return length;
-    }
-
-    @Override
-    public int writeQuotedUTF8(OutputStream out) throws IOException
-    {
-        byte[] result = _quotedUTF8Ref;
-        if (result == null) {
-            result = JsonStringEncoder.getInstance().quoteAsUTF8(_value);
-            _quotedUTF8Ref = result;
-        }
-        final int length = result.length;
-        out.write(result, 0, length);
-        return length;
-    }
-
-    @Override
-    public int writeUnquotedUTF8(OutputStream out) throws IOException
-    {
-        byte[] result = _unquotedUTF8Ref;
-        if (result == null) {
-            result = JsonStringEncoder.getInstance().encodeAsUTF8(_value);
-            _unquotedUTF8Ref  = result;
-        }
-        final int length = result.length;
-        out.write(result, 0, length);
-        return length;
-    }
-
-    @Override
-    public int putQuotedUTF8(ByteBuffer buffer)
-    {
-        byte[] result = _quotedUTF8Ref;
-        if (result == null) {
-            result = JsonStringEncoder.getInstance().quoteAsUTF8(_value);
-            _quotedUTF8Ref = result;
-        }
-        final int length = result.length;
-        if (length > buffer.remaining()) {
-            return -1;
-        }
-        buffer.put(result, 0, length);
-        return length;
-    }
-
-    @Override
-    public int putUnquotedUTF8(ByteBuffer buffer)
-    {
-        byte[] result = _unquotedUTF8Ref;
-        if (result == null) {
-            result = JsonStringEncoder.getInstance().encodeAsUTF8(_value);
-            _unquotedUTF8Ref  = result;
-        }
-        final int length = result.length;
-        if (length > buffer.remaining()) {
-            return -1;
-        }
-        buffer.put(result, 0, length);
-        return length;
-    }
-
-    
-    /*
-    /**********************************************************
-    /* Standard method overrides
-    /**********************************************************
-     */
-
-    @Override
-    public final String toString() { return _value; }
-    
-    @Override
-    public final int hashCode() { return _value.hashCode(); }
-
-    @Override
-    public final boolean equals(Object o)
-    {
-        if (o == this) return true;
-        if (o == null || o.getClass() != getClass()) return false;
-        SerializedString other = (SerializedString) o;
-        return _value.equals(other._value);
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/io/UTF32Reader.java

@@ -1,218 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.io;
-
-import java.io.*;
-
-
-/**
- * Since JDK does not come with UTF-32/UCS-4, let's implement a simple
- * decoder to use.
- */
-public class UTF32Reader
-    extends BaseReader
-{
-    protected final boolean _bigEndian;
-
-    /**
-     * Although input is fine with full Unicode set, Java still uses
-     * 16-bit chars, so we may have to split high-order chars into
-     * surrogate pairs.
-     */
-    protected char _surrogate = NULL_CHAR;
-
-    /**
-     * Total read character count; used for error reporting purposes
-     */
-    protected int _charCount = 0;
-
-    /**
-     * Total read byte count; used for error reporting purposes
-     */
-    protected int _byteCount = 0;
-
-    protected final boolean _managedBuffers;
-    
-    /*
-    /**********************************************************
-    /* Life-cycle
-    /**********************************************************
-     */
-
-    public UTF32Reader(IOContext ctxt,
-            InputStream in, byte[] buf, int ptr, int len,
-            boolean isBigEndian)
-    {
-        super(ctxt, in, buf, ptr, len);
-        _bigEndian = isBigEndian;
-        _managedBuffers = (in != null);
-    }
-
-    /*
-    /**********************************************************
-    /* Public API
-    /**********************************************************
-     */
-
-    @Override
-	public int read(char[] cbuf, int start, int len)
-        throws IOException
-    {
-        // Already EOF?
-        if (_buffer == null) {
-            return -1;
-        }
-        if (len < 1) {
-            return len;
-        }
-        // Let's then ensure there's enough room...
-        if (start < 0 || (start+len) > cbuf.length) {
-            reportBounds(cbuf, start, len);
-        }
-
-        len += start;
-        int outPtr = start;
-
-        // Ok, first; do we have a surrogate from last round?
-        if (_surrogate != NULL_CHAR) {
-            cbuf[outPtr++] = _surrogate;
-            _surrogate = NULL_CHAR;
-            // No need to load more, already got one char
-        } else {
-            /* Note: we'll try to avoid blocking as much as possible. As a
-             * result, we only need to get 4 bytes for a full char.
-             */
-            int left = (_length - _ptr);
-            if (left < 4) {
-                if (!loadMore(left)) { // (legal) EOF?
-                    return -1;
-                }
-            }
-        }
-
-        main_loop:
-        while (outPtr < len) {
-            int ptr = _ptr;
-            int ch;
-
-            if (_bigEndian) {
-                ch = (_buffer[ptr] << 24) | ((_buffer[ptr+1] & 0xFF) << 16)
-                    | ((_buffer[ptr+2] & 0xFF) << 8) | (_buffer[ptr+3] & 0xFF);
-            } else {
-                ch = (_buffer[ptr] & 0xFF) | ((_buffer[ptr+1] & 0xFF) << 8)
-                    | ((_buffer[ptr+2] & 0xFF) << 16) | (_buffer[ptr+3] << 24);
-            }
-            _ptr += 4;
-
-            // Does it need to be split to surrogates?
-            // (also, we can and need to verify illegal chars)
-            if (ch > 0xFFFF) { // need to split into surrogates?
-                if (ch > LAST_VALID_UNICODE_CHAR) {
-                    reportInvalid(ch, outPtr-start,
-                                  "(above "+Integer.toHexString(LAST_VALID_UNICODE_CHAR)+") ");
-                }
-                ch -= 0x10000; // to normalize it starting with 0x0
-                cbuf[outPtr++] = (char) (0xD800 + (ch >> 10));
-                // hmmh. can this ever be 0? (not legal, at least?)
-                ch = (0xDC00 | (ch & 0x03FF));
-                // Room for second part?
-                if (outPtr >= len) { // nope
-                    _surrogate = (char) ch;
-                    break main_loop;
-                }
-            }
-            cbuf[outPtr++] = (char) ch;
-            if (_ptr >= _length) {
-                break main_loop;
-            }
-        }
-
-        len = outPtr - start;
-        _charCount += len;
-        return len;
-    }
-
-    /*
-    /**********************************************************
-    /* Internal methods
-    /**********************************************************
-     */
-
-    private void reportUnexpectedEOF(int gotBytes, int needed)
-        throws IOException
-    {
-        int bytePos = _byteCount + gotBytes;
-        int charPos = _charCount;
-
-        throw new CharConversionException("Unexpected EOF in the middle of a 4-byte UTF-32 char: got "
-                +gotBytes+", needed "+needed+", at char #"+charPos+", byte #"+bytePos+")");
-    }
-
-    private void reportInvalid(int value, int offset, String msg)
-        throws IOException
-    {
-        int bytePos = _byteCount + _ptr - 1;
-        int charPos = _charCount + offset;
-
-        throw new CharConversionException("Invalid UTF-32 character 0x"
-                +Integer.toHexString(value)+msg+" at char #"+charPos+", byte #"+bytePos+")");
-    }
-
-    /**
-     * @param available Number of "unused" bytes in the input buffer
-     *
-     * @return True, if enough bytes were read to allow decoding of at least
-     *   one full character; false if EOF was encountered instead.
-     */
-    private boolean loadMore(int available)
-        throws IOException
-    {
-        _byteCount += (_length - available);
-
-        // Bytes that need to be moved to the beginning of buffer?
-        if (available > 0) {
-            if (_ptr > 0) {
-                for (int i = 0; i < available; ++i) {
-                    _buffer[i] = _buffer[_ptr+i];
-                }
-                _ptr = 0;
-            }
-            _length = available;
-        } else {
-            /* Ok; here we can actually reasonably expect an EOF,
-             * so let's do a separate read right away:
-             */
-            _ptr = 0;
-            int count = (_in == null) ? -1 : _in.read(_buffer);
-            if (count < 1) {
-                _length = 0;
-                if (count < 0) { // -1
-                    if (_managedBuffers) {
-                        freeBuffers(); // to help GC?
-                    }
-                    return false;
-                }
-                // 0 count is no good; let's err out
-                reportStrangeStream();
-            }
-            _length = count;
-        }
-
-        /* Need at least 4 bytes; if we don't get that many, it's an
-         * error.
-         */
-        while (_length < 4) {
-            int count = (_in == null) ? -1 : _in.read(_buffer, _length, _buffer.length - _length);
-            if (count < 1) {
-                if (count < 0) { // -1, EOF... no good!
-                    if (_managedBuffers) {
-                        freeBuffers(); // to help GC?
-                    }
-                    reportUnexpectedEOF(_length, 4);
-                }
-                // 0 count is no good; let's err out
-                reportStrangeStream();
-            }
-            _length += count;
-        }
-        return true;
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/io/UTF8Writer.java

@@ -1,387 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.io;
-
-import java.io.*;
-
-public final class UTF8Writer extends Writer
-{
-    final static int SURR1_FIRST = 0xD800;
-    final static int SURR1_LAST = 0xDBFF;
-    final static int SURR2_FIRST = 0xDC00;
-    final static int SURR2_LAST = 0xDFFF;
-
-    final private IOContext _context;
-
-    private OutputStream _out;
-
-    private byte[] _outBuffer;
-
-    final private int _outBufferEnd;
-
-    private int _outPtr;
-
-    /**
-     * When outputting chars from BMP, surrogate pairs need to be coalesced.
-     * To do this, both pairs must be known first; and since it is possible
-     * pairs may be split, we need temporary storage for the first half
-     */
-    private int _surrogate = 0;
-
-    public UTF8Writer(IOContext ctxt, OutputStream out)
-    {
-        _context = ctxt;
-        _out = out;
-
-        _outBuffer = ctxt.allocWriteEncodingBuffer();
-        /* Max. expansion for a single char (in unmodified UTF-8) is
-         * 4 bytes (or 3 depending on how you view it -- 4 when recombining
-         * surrogate pairs)
-         */
-        _outBufferEnd = _outBuffer.length - 4;
-        _outPtr = 0;
-    }
-
-    @Override
-    public Writer append(char c)
-        throws IOException
-    {
-        write(c);
-        return this;
-    }
-
-    @Override
-    public void close()
-        throws IOException
-    {
-        if (_out != null) {
-            if (_outPtr > 0) {
-                _out.write(_outBuffer, 0, _outPtr);
-                _outPtr = 0;
-            }
-            OutputStream out = _out;
-            _out = null;
-
-            byte[] buf = _outBuffer;
-            if (buf != null) {
-                _outBuffer = null;
-                _context.releaseWriteEncodingBuffer(buf);
-            }
-
-            out.close();
-
-            /* Let's 'flush' orphan surrogate, no matter what; but only
-             * after cleanly closing everything else.
-             */
-            int code = _surrogate;
-            _surrogate = 0;
-            if (code > 0) {
-                illegalSurrogate(code);
-            }
-        }
-    }
-
-    @Override
-    public void flush()
-        throws IOException
-    {
-        if (_out != null) {
-            if (_outPtr > 0) {
-                _out.write(_outBuffer, 0, _outPtr);
-                _outPtr = 0;
-            }
-            _out.flush();
-        }
-    }
-
-    @Override
-    public void write(char[] cbuf)
-        throws IOException
-    {
-        write(cbuf, 0, cbuf.length);
-    }
-
-    @Override
-    public void write(char[] cbuf, int off, int len)
-        throws IOException
-    {
-        if (len < 2) {
-            if (len == 1) {
-                write(cbuf[off]);
-            }
-            return;
-        }
-
-        // First: do we have a leftover surrogate to deal with?
-        if (_surrogate > 0) {
-            char second = cbuf[off++];
-            --len;
-            write(convertSurrogate(second));
-            // will have at least one more char
-        }
-
-        int outPtr = _outPtr;
-        byte[] outBuf = _outBuffer;
-        int outBufLast = _outBufferEnd; // has 4 'spare' bytes
-
-        // All right; can just loop it nice and easy now:
-        len += off; // len will now be the end of input buffer
-
-        output_loop:
-        for (; off < len; ) {
-            /* First, let's ensure we can output at least 4 bytes
-             * (longest UTF-8 encoded codepoint):
-             */
-            if (outPtr >= outBufLast) {
-                _out.write(outBuf, 0, outPtr);
-                outPtr = 0;
-            }
-
-            int c = cbuf[off++];
-            // And then see if we have an Ascii char:
-            if (c < 0x80) { // If so, can do a tight inner loop:
-                outBuf[outPtr++] = (byte)c;
-                // Let's calc how many ascii chars we can copy at most:
-                int maxInCount = (len - off);
-                int maxOutCount = (outBufLast - outPtr);
-
-                if (maxInCount > maxOutCount) {
-                    maxInCount = maxOutCount;
-                }
-                maxInCount += off;
-                ascii_loop:
-                while (true) {
-                    if (off >= maxInCount) { // done with max. ascii seq
-                        continue output_loop;
-                    }
-                    c = cbuf[off++];
-                    if (c >= 0x80) {
-                        break ascii_loop;
-                    }
-                    outBuf[outPtr++] = (byte) c;
-                }
-            }
-
-            // Nope, multi-byte:
-            if (c < 0x800) { // 2-byte
-                outBuf[outPtr++] = (byte) (0xc0 | (c >> 6));
-                outBuf[outPtr++] = (byte) (0x80 | (c & 0x3f));
-            } else { // 3 or 4 bytes
-                // Surrogates?
-                if (c < SURR1_FIRST || c > SURR2_LAST) {
-                    outBuf[outPtr++] = (byte) (0xe0 | (c >> 12));
-                    outBuf[outPtr++] = (byte) (0x80 | ((c >> 6) & 0x3f));
-                    outBuf[outPtr++] = (byte) (0x80 | (c & 0x3f));
-                    continue;
-                }
-                // Yup, a surrogate:
-                if (c > SURR1_LAST) { // must be from first range
-                    _outPtr = outPtr;
-                    illegalSurrogate(c);
-                }
-                _surrogate = c;
-                // and if so, followed by another from next range
-                if (off >= len) { // unless we hit the end?
-                    break;
-                }
-                c = convertSurrogate(cbuf[off++]);
-                if (c > 0x10FFFF) { // illegal in JSON as well as in XML
-                    _outPtr = outPtr;
-                    illegalSurrogate(c);
-                }
-                outBuf[outPtr++] = (byte) (0xf0 | (c >> 18));
-                outBuf[outPtr++] = (byte) (0x80 | ((c >> 12) & 0x3f));
-                outBuf[outPtr++] = (byte) (0x80 | ((c >> 6) & 0x3f));
-                outBuf[outPtr++] = (byte) (0x80 | (c & 0x3f));
-            }
-        }
-        _outPtr = outPtr;
-    }
-    
-    @Override
-    public void write(int c) throws IOException
-    {
-        // First; do we have a left over surrogate?
-        if (_surrogate > 0) {
-            c = convertSurrogate(c);
-            // If not, do we start with a surrogate?
-        } else if (c >= SURR1_FIRST && c <= SURR2_LAST) {
-            // Illegal to get second part without first:
-            if (c > SURR1_LAST) {
-                illegalSurrogate(c);
-            }
-            // First part just needs to be held for now
-            _surrogate = c;
-            return;
-        }
-
-        if (_outPtr >= _outBufferEnd) { // let's require enough room, first
-            _out.write(_outBuffer, 0, _outPtr);
-            _outPtr = 0;
-        }
-
-        if (c < 0x80) { // ascii
-            _outBuffer[_outPtr++] = (byte) c;
-        } else {
-            int ptr = _outPtr;
-            if (c < 0x800) { // 2-byte
-                _outBuffer[ptr++] = (byte) (0xc0 | (c >> 6));
-                _outBuffer[ptr++] = (byte) (0x80 | (c & 0x3f));
-            } else if (c <= 0xFFFF) { // 3 bytes
-                _outBuffer[ptr++] = (byte) (0xe0 | (c >> 12));
-                _outBuffer[ptr++] = (byte) (0x80 | ((c >> 6) & 0x3f));
-                _outBuffer[ptr++] = (byte) (0x80 | (c & 0x3f));
-            } else { // 4 bytes
-                if (c > 0x10FFFF) { // illegal
-                    illegalSurrogate(c);
-                }
-                _outBuffer[ptr++] = (byte) (0xf0 | (c >> 18));
-                _outBuffer[ptr++] = (byte) (0x80 | ((c >> 12) & 0x3f));
-                _outBuffer[ptr++] = (byte) (0x80 | ((c >> 6) & 0x3f));
-                _outBuffer[ptr++] = (byte) (0x80 | (c & 0x3f));
-            }
-            _outPtr = ptr;
-        }
-    }
-
-    @Override
-    public void write(String str) throws IOException
-    {
-        write(str, 0, str.length());
-    }
-
-    @Override
-    public void write(String str, int off, int len)  throws IOException
-    {
-        if (len < 2) {
-            if (len == 1) {
-                write(str.charAt(off));
-            }
-            return;
-        }
-
-        // First: do we have a leftover surrogate to deal with?
-        if (_surrogate > 0) {
-            char second = str.charAt(off++);
-            --len;
-            write(convertSurrogate(second));
-            // will have at least one more char (case of 1 char was checked earlier on)
-        }
-
-        int outPtr = _outPtr;
-        byte[] outBuf = _outBuffer;
-        int outBufLast = _outBufferEnd; // has 4 'spare' bytes
-
-        // All right; can just loop it nice and easy now:
-        len += off; // len will now be the end of input buffer
-
-        output_loop:
-        for (; off < len; ) {
-            /* First, let's ensure we can output at least 4 bytes
-             * (longest UTF-8 encoded codepoint):
-             */
-            if (outPtr >= outBufLast) {
-                _out.write(outBuf, 0, outPtr);
-                outPtr = 0;
-            }
-
-            int c = str.charAt(off++);
-            // And then see if we have an Ascii char:
-            if (c < 0x80) { // If so, can do a tight inner loop:
-                outBuf[outPtr++] = (byte)c;
-                // Let's calc how many ascii chars we can copy at most:
-                int maxInCount = (len - off);
-                int maxOutCount = (outBufLast - outPtr);
-
-                if (maxInCount > maxOutCount) {
-                    maxInCount = maxOutCount;
-                }
-                maxInCount += off;
-                ascii_loop:
-                while (true) {
-                    if (off >= maxInCount) { // done with max. ascii seq
-                        continue output_loop;
-                    }
-                    c = str.charAt(off++);
-                    if (c >= 0x80) {
-                        break ascii_loop;
-                    }
-                    outBuf[outPtr++] = (byte) c;
-                }
-            }
-
-            // Nope, multi-byte:
-            if (c < 0x800) { // 2-byte
-                outBuf[outPtr++] = (byte) (0xc0 | (c >> 6));
-                outBuf[outPtr++] = (byte) (0x80 | (c & 0x3f));
-            } else { // 3 or 4 bytes
-                // Surrogates?
-                if (c < SURR1_FIRST || c > SURR2_LAST) {
-                    outBuf[outPtr++] = (byte) (0xe0 | (c >> 12));
-                    outBuf[outPtr++] = (byte) (0x80 | ((c >> 6) & 0x3f));
-                    outBuf[outPtr++] = (byte) (0x80 | (c & 0x3f));
-                    continue;
-                }
-                // Yup, a surrogate:
-                if (c > SURR1_LAST) { // must be from first range
-                    _outPtr = outPtr;
-                    illegalSurrogate(c);
-                }
-                _surrogate = c;
-                // and if so, followed by another from next range
-                if (off >= len) { // unless we hit the end?
-                    break;
-                }
-                c = convertSurrogate(str.charAt(off++));
-                if (c > 0x10FFFF) { // illegal, as per RFC 4627
-                    _outPtr = outPtr;
-                    illegalSurrogate(c);
-                }
-                outBuf[outPtr++] = (byte) (0xf0 | (c >> 18));
-                outBuf[outPtr++] = (byte) (0x80 | ((c >> 12) & 0x3f));
-                outBuf[outPtr++] = (byte) (0x80 | ((c >> 6) & 0x3f));
-                outBuf[outPtr++] = (byte) (0x80 | (c & 0x3f));
-            }
-        }
-        _outPtr = outPtr;
-    }
-
-    /*
-    /**********************************************************
-    /* Internal methods
-    /**********************************************************
-     */
-
-    /**
-     * Method called to calculate UTF codepoint, from a surrogate pair.
-     */
-    protected int convertSurrogate(int secondPart)
-        throws IOException
-    {
-        int firstPart = _surrogate;
-        _surrogate = 0;
-
-        // Ok, then, is the second part valid?
-        if (secondPart < SURR2_FIRST || secondPart > SURR2_LAST) {
-            throw new IOException("Broken surrogate pair: first char 0x"+Integer.toHexString(firstPart)+", second 0x"+Integer.toHexString(secondPart)+"; illegal combination");
-        }
-        return 0x10000 + ((firstPart - SURR1_FIRST) << 10) + (secondPart - SURR2_FIRST);
-    }
-    
-    protected static void illegalSurrogate(int code) throws IOException {
-        throw new IOException(illegalSurrogateDesc(code));
-    }
-    
-    protected static String illegalSurrogateDesc(int code)
-    {
-        if (code > 0x10FFFF) { // over max?
-            return "Illegal character point (0x"+Integer.toHexString(code)+") to output; max is 0x10FFFF as per RFC 4627";
-        }
-        if (code >= SURR1_FIRST) {
-            if (code <= SURR1_LAST) { // Unmatched first part (closing without second part?)
-                return "Unmatched first part of surrogate pair (0x"+Integer.toHexString(code)+")";
-            }
-            return "Unmatched second part of surrogate pair (0x"+Integer.toHexString(code)+")";
-        }
-        // should we ever get this?
-        return "Illegal character point (0x"+Integer.toHexString(code)+") to output";
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/json/ByteSourceJsonBootstrapper.java

@@ -1,513 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.json;
-
-import java.io.*;
-
-import com.fr.third.fasterxml.jackson.core.*;
-import com.fr.third.fasterxml.jackson.core.format.InputAccessor;
-import com.fr.third.fasterxml.jackson.core.format.MatchStrength;
-import com.fr.third.fasterxml.jackson.core.io.*;
-import com.fr.third.fasterxml.jackson.core.sym.BytesToNameCanonicalizer;
-import com.fr.third.fasterxml.jackson.core.sym.CharsToNameCanonicalizer;
-
-/**
- * This class is used to determine the encoding of byte stream
- * that is to contain JSON content. Rules are fairly simple, and
- * defined in JSON specification (RFC-4627 or newer), except
- * for BOM handling, which is a property of underlying
- * streams.
- */
-public final class ByteSourceJsonBootstrapper
-{
-    final static byte UTF8_BOM_1 = (byte) 0xEF;
-    final static byte UTF8_BOM_2 = (byte) 0xBB;
-    final static byte UTF8_BOM_3 = (byte) 0xBF;
-    
-    /*
-    /**********************************************************
-    /* Configuration
-    /**********************************************************
-     */
-
-    protected final IOContext _context;
-
-    protected final InputStream _in;
-
-    /*
-    /**********************************************************
-    /* Input buffering
-    /**********************************************************
-     */
-
-    protected final byte[] _inputBuffer;
-
-    private int _inputPtr;
-
-    private int _inputEnd;
-
-    /**
-     * Flag that indicates whether buffer above is to be recycled
-     * after being used or not.
-     */
-    private final boolean _bufferRecyclable;
-
-    /*
-    /**********************************************************
-    /* Input location
-    /**********************************************************
-     */
-
-    /**
-     * Current number of input units (bytes or chars) that were processed in
-     * previous blocks,
-     * before contents of current input buffer.
-     *<p>
-     * Note: includes possible BOMs, if those were part of the input.
-     */
-    protected int _inputProcessed;
-
-    /*
-    /**********************************************************
-    /* Data gathered
-    /**********************************************************
-     */
-
-    protected boolean _bigEndian = true;
-
-    protected int _bytesPerChar = 0; // 0 means "dunno yet"
-
-    /*
-    /**********************************************************
-    /* Life-cycle
-    /**********************************************************
-     */
-
-    public ByteSourceJsonBootstrapper(IOContext ctxt, InputStream in)
-    {
-        _context = ctxt;
-        _in = in;
-        _inputBuffer = ctxt.allocReadIOBuffer();
-        _inputEnd = _inputPtr = 0;
-        _inputProcessed = 0;
-        _bufferRecyclable = true;
-    }
-
-    public ByteSourceJsonBootstrapper(IOContext ctxt, byte[] inputBuffer, int inputStart, int inputLen)
-    {
-        _context = ctxt;
-        _in = null;
-        _inputBuffer = inputBuffer;
-        _inputPtr = inputStart;
-        _inputEnd = (inputStart + inputLen);
-        // Need to offset this for correct location info
-        _inputProcessed = -inputStart;
-        _bufferRecyclable = false;
-    }
-
-    /*
-    /**********************************************************
-    /*  Encoding detection during bootstrapping
-    /**********************************************************
-     */
-    
-    /**
-     * Method that should be called after constructing an instace.
-     * It will figure out encoding that content uses, to allow
-     * for instantiating a proper scanner object.
-     */
-    public JsonEncoding detectEncoding()
-        throws IOException, JsonParseException
-    {
-        boolean foundEncoding = false;
-
-        // First things first: BOM handling
-        /* Note: we can require 4 bytes to be read, since no
-         * combination of BOM + valid JSON content can have
-         * shorter length (shortest valid JSON content is single
-         * digit char, but BOMs are chosen such that combination
-         * is always at least 4 chars long)
-         */
-        if (ensureLoaded(4)) {
-            int quad =  (_inputBuffer[_inputPtr] << 24)
-                | ((_inputBuffer[_inputPtr+1] & 0xFF) << 16)
-                | ((_inputBuffer[_inputPtr+2] & 0xFF) << 8)
-                | (_inputBuffer[_inputPtr+3] & 0xFF);
-            
-            if (handleBOM(quad)) {
-                foundEncoding = true;
-            } else {
-                /* If no BOM, need to auto-detect based on first char;
-                 * this works since it must be 7-bit ascii (wrt. unicode
-                 * compatible encodings, only ones JSON can be transferred
-                 * over)
-                 */
-                // UTF-32?
-                if (checkUTF32(quad)) {
-                    foundEncoding = true;
-                } else if (checkUTF16(quad >>> 16)) {
-                    foundEncoding = true;
-                }
-            }
-        } else if (ensureLoaded(2)) {
-            int i16 = ((_inputBuffer[_inputPtr] & 0xFF) << 8)
-                | (_inputBuffer[_inputPtr+1] & 0xFF);
-            if (checkUTF16(i16)) {
-                foundEncoding = true;
-            }
-        }
-
-        JsonEncoding enc;
-
-        /* Not found yet? As per specs, this means it must be UTF-8. */
-        if (!foundEncoding) {
-            enc = JsonEncoding.UTF8;
-        } else {
-            switch (_bytesPerChar) {
-            case 1:
-                enc = JsonEncoding.UTF8;
-                break;
-            case 2:
-                enc = _bigEndian ? JsonEncoding.UTF16_BE : JsonEncoding.UTF16_LE;
-                break;
-            case 4:
-                enc = _bigEndian ? JsonEncoding.UTF32_BE : JsonEncoding.UTF32_LE;
-                break;
-            default:
-                throw new RuntimeException("Internal error"); // should never get here
-            }
-        }
-        _context.setEncoding(enc);
-        return enc;
-    }
-
-    /*
-    /**********************************************************
-    /* Constructing a Reader
-    /**********************************************************
-     */
-    
-    @SuppressWarnings("resource")
-    public Reader constructReader()
-        throws IOException
-    {
-        JsonEncoding enc = _context.getEncoding();
-        switch (enc.bits()) {
-        case 8: // only in non-common case where we don't want to do direct mapping
-        case 16:
-            {
-                // First: do we have a Stream? If not, need to create one:
-                InputStream in = _in;
-
-                if (in == null) {
-                    in = new ByteArrayInputStream(_inputBuffer, _inputPtr, _inputEnd);
-                } else {
-                    /* Also, if we have any read but unused input (usually true),
-                     * need to merge that input in:
-                     */
-                    if (_inputPtr < _inputEnd) {
-                        in = new MergedStream(_context, in, _inputBuffer, _inputPtr, _inputEnd);
-                    }
-                }
-                return new InputStreamReader(in, enc.getJavaName());
-            }
-        case 32:
-            return new UTF32Reader(_context, _in, _inputBuffer, _inputPtr, _inputEnd,
-                    _context.getEncoding().isBigEndian());
-        }
-        throw new RuntimeException("Internal error"); // should never get here
-    }
-
-    public JsonParser constructParser(int parserFeatures, ObjectCodec codec,
-            BytesToNameCanonicalizer rootByteSymbols, CharsToNameCanonicalizer rootCharSymbols,
-            boolean canonicalize, boolean intern)
-        throws IOException
-    {
-        JsonEncoding enc = detectEncoding();
-
-        if (enc == JsonEncoding.UTF8) {
-            /* and without canonicalization, byte-based approach is not performance; just use std UTF-8 reader
-             * (which is ok for larger input; not so hot for smaller; but this is not a common case)
-             */
-            if (canonicalize) {
-                BytesToNameCanonicalizer can = rootByteSymbols.makeChild(canonicalize, intern);
-                return new UTF8StreamJsonParser(_context, parserFeatures, _in, codec, can, _inputBuffer, _inputPtr, _inputEnd, _bufferRecyclable);
-            }
-        }
-        return new ReaderBasedJsonParser(_context, parserFeatures, constructReader(), codec,
-                rootCharSymbols.makeChild(canonicalize, intern));
-    }
-
-    /*
-    /**********************************************************
-    /*  Encoding detection for data format auto-detection
-    /**********************************************************
-     */
-
-    /**
-     * Current implementation is not as thorough as other functionality
-     * ({@link com.fr.third.fasterxml.jackson.core.json.ByteSourceJsonBootstrapper});
-     * supports UTF-8, for example. But it should work, for now, and can
-     * be improved as necessary.
-     */
-    public static MatchStrength hasJSONFormat(InputAccessor acc) throws IOException
-    {
-        // Ideally we should see "[" or "{"; but if not, we'll accept double-quote (String)
-        // in future could also consider accepting non-standard matches?
-        
-        if (!acc.hasMoreBytes()) {
-            return MatchStrength.INCONCLUSIVE;
-        }
-        byte b = acc.nextByte();
-        // Very first thing, a UTF-8 BOM?
-        if (b == UTF8_BOM_1) { // yes, looks like UTF-8 BOM
-            if (!acc.hasMoreBytes()) {
-                return MatchStrength.INCONCLUSIVE;
-            }
-            if (acc.nextByte() != UTF8_BOM_2) {
-                return MatchStrength.NO_MATCH;
-            }
-            if (!acc.hasMoreBytes()) {
-                return MatchStrength.INCONCLUSIVE;
-            }
-            if (acc.nextByte() != UTF8_BOM_3) {
-                return MatchStrength.NO_MATCH;
-            }
-            if (!acc.hasMoreBytes()) {
-                return MatchStrength.INCONCLUSIVE;
-            }
-            b = acc.nextByte();
-        }
-        // Then possible leading space
-        int ch = skipSpace(acc, b);
-        if (ch < 0) {
-            return MatchStrength.INCONCLUSIVE;
-        }
-        // First, let's see if it looks like a structured type:
-        if (ch == '{') { // JSON object?
-            // Ideally we need to find either double-quote or closing bracket
-            ch = skipSpace(acc);
-            if (ch < 0) {
-                return MatchStrength.INCONCLUSIVE;
-            }
-            if (ch == '"' || ch == '}') {
-                return MatchStrength.SOLID_MATCH;
-            }
-            // ... should we allow non-standard? Let's not yet... can add if need be
-            return MatchStrength.NO_MATCH;
-        }
-        MatchStrength strength;
-        
-        if (ch == '[') {
-            ch = skipSpace(acc);
-            if (ch < 0) {
-                return MatchStrength.INCONCLUSIVE;
-            }
-            // closing brackets is easy; but for now, let's also accept opening...
-            if (ch == ']' || ch == '[') {
-                return MatchStrength.SOLID_MATCH;
-            }
-            return MatchStrength.SOLID_MATCH;
-        } else {
-            // plain old value is not very convincing...
-            strength = MatchStrength.WEAK_MATCH;
-        }
-
-        if (ch == '"') { // string value
-            return strength;
-        }
-        if (ch <= '9' && ch >= '0') { // number
-            return strength;
-        }
-        if (ch == '-') { // negative number
-            ch = skipSpace(acc);
-            if (ch < 0) {
-                return MatchStrength.INCONCLUSIVE;
-            }
-            return (ch <= '9' && ch >= '0') ? strength : MatchStrength.NO_MATCH;
-        }
-        // or one of literals
-        if (ch == 'n') { // null
-            return tryMatch(acc, "ull", strength);
-        }
-        if (ch == 't') { // true
-            return tryMatch(acc, "rue", strength);
-        }
-        if (ch == 'f') { // false
-            return tryMatch(acc, "alse", strength);
-        }
-        return MatchStrength.NO_MATCH;
-    }
-
-    private static MatchStrength tryMatch(InputAccessor acc, String matchStr, MatchStrength fullMatchStrength)
-        throws IOException
-    {
-        for (int i = 0, len = matchStr.length(); i < len; ++i) {
-            if (!acc.hasMoreBytes()) {
-                return MatchStrength.INCONCLUSIVE;
-            }
-            if (acc.nextByte() != matchStr.charAt(i)) {
-                return MatchStrength.NO_MATCH;
-            }
-        }
-        return fullMatchStrength;
-    }
-    
-    private static int skipSpace(InputAccessor acc) throws IOException
-    {
-        if (!acc.hasMoreBytes()) {
-            return -1;
-        }
-        return skipSpace(acc, acc.nextByte());
-    }
-    
-    private static int skipSpace(InputAccessor acc, byte b) throws IOException
-    {
-        while (true) {
-            int ch = (int) b & 0xFF;
-            if (!(ch == ' ' || ch == '\r' || ch == '\n' || ch == '\t')) {
-                return ch;
-            }
-            if (!acc.hasMoreBytes()) {
-                return -1;
-            }
-            b = acc.nextByte();
-            ch = (int) b & 0xFF;
-        }
-    }
-    
-    /*
-    /**********************************************************
-    /* Internal methods, parsing
-    /**********************************************************
-     */
-
-    /**
-     * @return True if a BOM was succesfully found, and encoding
-     *   thereby recognized.
-     */
-    private boolean handleBOM(int quad)
-        throws IOException
-    {
-        /* Handling of (usually) optional BOM (required for
-         * multi-byte formats); first 32-bit charsets:
-         */
-        switch (quad) {
-        case 0x0000FEFF:
-            _bigEndian = true;
-            _inputPtr += 4;
-            _bytesPerChar = 4;
-            return true;
-        case 0xFFFE0000: // UCS-4, LE?
-            _inputPtr += 4;
-            _bytesPerChar = 4;
-            _bigEndian = false;
-            return true;
-        case 0x0000FFFE: // UCS-4, in-order...
-            reportWeirdUCS4("2143"); // throws exception
-        case 0xFEFF0000: // UCS-4, in-order...
-            reportWeirdUCS4("3412"); // throws exception
-        }
-        // Ok, if not, how about 16-bit encoding BOMs?
-        int msw = quad >>> 16;
-        if (msw == 0xFEFF) { // UTF-16, BE
-            _inputPtr += 2;
-            _bytesPerChar = 2;
-            _bigEndian = true;
-            return true;
-        }
-        if (msw == 0xFFFE) { // UTF-16, LE
-            _inputPtr += 2;
-            _bytesPerChar = 2;
-            _bigEndian = false;
-            return true;
-        }
-        // And if not, then UTF-8 BOM?
-        if ((quad >>> 8) == 0xEFBBBF) { // UTF-8
-            _inputPtr += 3;
-            _bytesPerChar = 1;
-            _bigEndian = true; // doesn't really matter
-            return true;
-        }
-        return false;
-    }
-
-    private boolean checkUTF32(int quad)
-        throws IOException
-    {
-        /* Handling of (usually) optional BOM (required for
-         * multi-byte formats); first 32-bit charsets:
-         */
-        if ((quad >> 8) == 0) { // 0x000000?? -> UTF32-BE
-            _bigEndian = true;
-        } else if ((quad & 0x00FFFFFF) == 0) { // 0x??000000 -> UTF32-LE
-            _bigEndian = false;
-        } else if ((quad & ~0x00FF0000) == 0) { // 0x00??0000 -> UTF32-in-order
-            reportWeirdUCS4("3412");
-        } else if ((quad & ~0x0000FF00) == 0) { // 0x0000??00 -> UTF32-in-order
-            reportWeirdUCS4("2143");
-        } else {
-            // Can not be valid UTF-32 encoded JSON...
-            return false;
-        }
-        // Not BOM (just regular content), nothing to skip past:
-        //_inputPtr += 4;
-        _bytesPerChar = 4;
-        return true;
-    }
-
-    private boolean checkUTF16(int i16)
-    {
-        if ((i16 & 0xFF00) == 0) { // UTF-16BE
-            _bigEndian = true;
-        } else if ((i16 & 0x00FF) == 0) { // UTF-16LE
-            _bigEndian = false;
-        } else { // nope, not  UTF-16
-            return false;
-        }
-        // Not BOM (just regular content), nothing to skip past:
-        //_inputPtr += 2;
-        _bytesPerChar = 2;
-        return true;
-    }
-
-    /*
-    /**********************************************************
-    /* Internal methods, problem reporting
-    /**********************************************************
-     */
-
-    private void reportWeirdUCS4(String type)
-        throws IOException
-    {
-        throw new CharConversionException("Unsupported UCS-4 endianness ("+type+") detected");
-    }
-
-    /*
-    /**********************************************************
-    /* Internal methods, raw input access
-    /**********************************************************
-     */
-
-    protected boolean ensureLoaded(int minimum)
-        throws IOException
-    {
-        /* Let's assume here buffer has enough room -- this will always
-         * be true for the limited used this method gets
-         */
-        int gotten = (_inputEnd - _inputPtr);
-        while (gotten < minimum) {
-            int count;
-
-            if (_in == null) { // block source
-                count = -1;
-            } else {
-                count = _in.read(_inputBuffer, _inputEnd, _inputBuffer.length - _inputEnd);
-            }
-            if (count < 1) {
-                return false;
-            }
-            _inputEnd += count;
-            gotten += count;
-        }
-        return true;
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/json/DupDetector.java

@@ -1,90 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.json;
-
-import java.util.*;
-
-import com.fr.third.fasterxml.jackson.core.*;
-
-/**
- * Helper class used if
- * {@link com.fr.third.fasterxml.jackson.core.JsonParser.Feature#STRICT_DUPLICATE_DETECTION}
- * is enabled.
- * Optimized to try to limit memory usage and processing overhead for smallest
- * entries, but without adding trashing (immutable objects would achieve optimal
- * memory usage but lead to significant number of discarded temp objects for
- * scopes with large number of entries). Another consideration is trying to limit
- * actual number of compiled classes as it contributes significantly to overall
- * jar size (due to linkage etc).
- * 
- * @since 2.3
- */
-public class DupDetector
-{
-    /**
-     * We need to store a back-reference here to parser/generator, unfortunately.
-     */
-    protected final Object _source;
-
-    protected String _firstName;
-
-    protected String _secondName;
-    
-    /**
-     * Lazily constructed set of names already seen within this context.
-     */
-    protected HashSet<String> _seen;
-
-    private DupDetector(Object src) {
-        _source = src;
-    }
-
-    public static DupDetector rootDetector(JsonParser p) {
-        return new DupDetector(p);
-    }
-
-    public static DupDetector rootDetector(JsonGenerator g) {
-        return new DupDetector(g);
-    }
-    
-    public DupDetector child() {
-        return new DupDetector(_source);
-    }
-
-    public void reset() {
-        _firstName = null;
-        _secondName = null;
-        _seen = null;
-    }
-
-    public JsonLocation findLocation() {
-        // ugly but:
-        if (_source instanceof JsonParser) {
-            return ((JsonParser)_source).getCurrentLocation();
-        }
-        // do generators have a way to provide Location? Apparently not...
-        return null;
-    }
-    
-    public boolean isDup(String name) throws JsonParseException
-    {
-        if (_firstName == null) {
-            _firstName = name;
-            return false;
-        }
-        if (name.equals(_firstName)) {
-            return true;
-        }
-        if (_secondName == null) {
-            _secondName = name;
-            return false;
-        }
-        if (name.equals(_secondName)) {
-            return true;
-        }
-        if (_seen == null) {
-            _seen = new HashSet<String>(16); // 16 is default, seems reasonable
-            _seen.add(_firstName);
-            _seen.add(_secondName);
-        }
-        return !_seen.add(name);
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/json/JsonGeneratorImpl.java

@@ -1,172 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.json;
-
-import java.io.IOException;
-
-import com.fr.third.fasterxml.jackson.core.*;
-import com.fr.third.fasterxml.jackson.core.base.GeneratorBase;
-import com.fr.third.fasterxml.jackson.core.io.CharTypes;
-import com.fr.third.fasterxml.jackson.core.io.CharacterEscapes;
-import com.fr.third.fasterxml.jackson.core.io.IOContext;
-import com.fr.third.fasterxml.jackson.core.util.DefaultPrettyPrinter;
-import com.fr.third.fasterxml.jackson.core.util.VersionUtil;
-
-/**
- * Intermediate base class shared by JSON-backed generators
- * like {@link UTF8JsonGenerator} and {@link WriterBasedJsonGenerator}.
- * 
- * @since 2.1
- */
-public abstract class JsonGeneratorImpl extends GeneratorBase
-{
-    /*
-    /**********************************************************
-    /* Constants
-    /**********************************************************
-     */
-
-    /**
-     * This is the default set of escape codes, over 7-bit ASCII range
-     * (first 128 character codes), used for single-byte UTF-8 characters.
-     */
-    protected final static int[] sOutputEscapes = CharTypes.get7BitOutputEscapes();
-    
-    /*
-    /**********************************************************
-    /* Configuration, basic I/O
-    /**********************************************************
-     */
-
-    final protected IOContext _ioContext;
-
-    /*
-    /**********************************************************
-    /* Configuration, output escaping
-    /**********************************************************
-     */
-
-    /**
-     * Currently active set of output escape code definitions (whether
-     * and how to escape or not) for 7-bit ASCII range (first 128
-     * character codes). Defined separately to make potentially
-     * customizable
-     */
-    protected int[] _outputEscapes = sOutputEscapes;
-
-    /**
-     * Value between 128 (0x80) and 65535 (0xFFFF) that indicates highest
-     * Unicode code point that will not need escaping; or 0 to indicate
-     * that all characters can be represented without escaping.
-     * Typically used to force escaping of some portion of character set;
-     * for example to always escape non-ASCII characters (if value was 127).
-     *<p>
-     * NOTE: not all sub-classes make use of this setting.
-     */
-    protected int _maximumNonEscapedChar;
-
-    /**
-     * Definition of custom character escapes to use for generators created
-     * by this factory, if any. If null, standard data format specific
-     * escapes are used.
-     */
-    protected CharacterEscapes _characterEscapes;
-    
-    /*
-    /**********************************************************
-    /* Configuration, other
-    /**********************************************************
-     */
-
-    /**
-     * Separator to use, if any, between root-level values.
-     * 
-     * @since 2.1
-     */
-    protected SerializableString _rootValueSeparator
-        = DefaultPrettyPrinter.DEFAULT_ROOT_VALUE_SEPARATOR;
-
-    /*
-    /**********************************************************
-    /* Life-cycle
-    /**********************************************************
-     */
-
-    public JsonGeneratorImpl(IOContext ctxt, int features, ObjectCodec codec)
-    {
-        super(features, codec);
-        _ioContext = ctxt;
-        if (isEnabled(Feature.ESCAPE_NON_ASCII)) {
-            setHighestNonEscapedChar(127);
-        }
-    }
-
-    /*
-    /**********************************************************
-    /* Overridden configuration methods
-    /**********************************************************
-     */
-
-    @Override
-    public JsonGenerator setHighestNonEscapedChar(int charCode) {
-        _maximumNonEscapedChar = (charCode < 0) ? 0 : charCode;
-        return this;
-    }
-
-    @Override
-    public int getHighestEscapedChar() {
-        return _maximumNonEscapedChar;
-    }
-
-    @Override
-    public JsonGenerator setCharacterEscapes(CharacterEscapes esc)
-    {
-        _characterEscapes = esc;
-        if (esc == null) { // revert to standard escapes
-            _outputEscapes = sOutputEscapes;
-        } else {
-            _outputEscapes = esc.getEscapeCodesForAscii();
-        }
-        return this;
-    }
-
-    /**
-     * Method for accessing custom escapes factory uses for {@link JsonGenerator}s
-     * it creates.
-     */
-    @Override
-    public CharacterEscapes getCharacterEscapes() {
-        return _characterEscapes;
-    }
-    
-    @Override
-    public JsonGenerator setRootValueSeparator(SerializableString sep) {
-        _rootValueSeparator = sep;
-        return this;
-    }
-    
-    /*
-    /**********************************************************
-    /* Versioned
-    /**********************************************************
-     */
-
-    @Override
-    public Version version() {
-        return VersionUtil.versionFor(getClass());
-    }
-
-    /*
-    /**********************************************************
-    /* Partial API
-    /**********************************************************
-     */
-
-    // // Overrides just to make things final, to possibly help with inlining
-    
-    @Override
-    public final void writeStringField(String fieldName, String value)
-        throws IOException, JsonGenerationException
-    {
-        writeFieldName(fieldName);
-        writeString(value);
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/json/JsonReadContext.java

@@ -1,227 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.json;
-
-import com.fr.third.fasterxml.jackson.core.*;
-import com.fr.third.fasterxml.jackson.core.io.CharTypes;
-
-/**
- * Extension of {@link JsonStreamContext}, which implements
- * core methods needed, and also exposes
- * more complete API to parser implementation classes.
- */
-public final class JsonReadContext
-    extends JsonStreamContext
-{
-    // // // Configuration
-
-    /**
-     * Parent context for this context; null for root context.
-     */
-    protected final JsonReadContext _parent;
-    
-    // // // Optional duplicate detection
-
-    protected final DupDetector _dups;
-    
-    // // // Location information (minus source reference)
-
-    protected int _lineNr;
-    protected int _columnNr;
-
-    protected String _currentName;
-    
-    /*
-    /**********************************************************
-    /* Simple instance reuse slots; speeds up things
-    /* a bit (10-15%) for docs with lots of small
-    /* arrays/objects (for which allocation was
-    /* visible in profile stack frames)
-    /**********************************************************
-     */
-
-    protected JsonReadContext _child = null;
-
-    /*
-    /**********************************************************
-    /* Instance construction, reuse
-    /**********************************************************
-     */
-
-    public JsonReadContext(JsonReadContext parent, DupDetector dups,
-            int type, int lineNr, int colNr)
-    {
-        super();
-        _parent = parent;
-        _dups = dups;
-        _type = type;
-        _lineNr = lineNr;
-        _columnNr = colNr;
-        _index = -1;
-    }
-
-    protected void reset(int type, int lineNr, int colNr)
-    {
-        _type = type;
-        _index = -1;
-        _lineNr = lineNr;
-        _columnNr = colNr;
-        _currentName = null;
-        if (_dups != null) {
-            _dups.reset();
-        }
-    }
-
-    /*
-    public void trackDups(JsonParser jp) {
-        _dups = DupDetector.rootDetector(jp);
-    }
-    */
-
-    // // // Factory methods
-
-    @Deprecated // since 2.3, use variant that takes dup detector
-    public static JsonReadContext createRootContext(int lineNr, int colNr) {
-        return createRootContext(lineNr, colNr, null);
-    }
-    
-    public static JsonReadContext createRootContext(int lineNr, int colNr,
-            DupDetector dups)
-    {
-        return new JsonReadContext(null, dups, TYPE_ROOT, lineNr, colNr);
-    }
-
-    @Deprecated // since 2.3, use variant that takes dup detector
-    public static JsonReadContext createRootContext() {
-        return createRootContext(null);
-    }
-
-    public static JsonReadContext createRootContext(DupDetector dups) {
-        return new JsonReadContext(null, dups, TYPE_ROOT, 1, 0);
-    }
-    
-    public JsonReadContext createChildArrayContext(int lineNr, int colNr)
-    {
-        JsonReadContext ctxt = _child;
-        if (ctxt == null) {
-            _child = ctxt = new JsonReadContext(this,
-                    (_dups == null) ? null : _dups.child(),
-                            TYPE_ARRAY, lineNr, colNr);
-        } else {
-            ctxt.reset(TYPE_ARRAY, lineNr, colNr);
-        }
-        return ctxt;
-    }
-
-    public JsonReadContext createChildObjectContext(int lineNr, int colNr)
-    {
-        JsonReadContext ctxt = _child;
-        if (ctxt == null) {
-            _child = ctxt = new JsonReadContext(this,
-                    (_dups == null) ? null : _dups.child(),
-                    TYPE_OBJECT, lineNr, colNr);
-            return ctxt;
-        }
-        ctxt.reset(TYPE_OBJECT, lineNr, colNr);
-        return ctxt;
-    }
-
-    /*
-    /**********************************************************
-    /* Abstract method implementation
-    /**********************************************************
-     */
-
-    @Override
-    public String getCurrentName() { return _currentName; }
-
-    @Override
-    public JsonReadContext getParent() { return _parent; }
-
-    /*
-    /**********************************************************
-    /* Extended API
-    /**********************************************************
-     */
-
-    /**
-     * @return Location pointing to the point where the context
-     *   start marker was found
-     */
-    public JsonLocation getStartLocation(Object srcRef)
-    {
-        /* We don't keep track of offsets at this level (only
-         * reader does)
-         */
-        long totalChars = -1L;
-
-        return new JsonLocation(srcRef, totalChars, _lineNr, _columnNr);
-    }
-
-    /*
-    /**********************************************************
-    /* State changes
-    /**********************************************************
-     */
-
-    public boolean expectComma()
-    {
-        /* Assumption here is that we will be getting a value (at least
-         * before calling this method again), and
-         * so will auto-increment index to avoid having to do another call
-         */
-        int ix = ++_index; // starts from -1
-        return (_type != TYPE_ROOT && ix > 0);
-    }
-
-    public void setCurrentName(String name) throws JsonProcessingException
-    {
-        _currentName = name;
-        if (_dups != null) {
-            _checkDup(_dups, name);
-        }
-    }
-
-    private void _checkDup(DupDetector dd, String name) throws JsonProcessingException
-    {
-        if (dd.isDup(name)) {
-            throw new JsonParseException("Duplicate field '"+name+"'", dd.findLocation());
-        }
-    }
-    
-    /*
-    /**********************************************************
-    /* Overridden standard methods
-    /**********************************************************
-     */
-
-    /**
-     * Overridden to provide developer readable "JsonPath" representation
-     * of the context.
-     */
-    @Override
-    public String toString()
-    {
-        StringBuilder sb = new StringBuilder(64);
-        switch (_type) {
-        case TYPE_ROOT:
-            sb.append("/");
-            break;
-        case TYPE_ARRAY:
-            sb.append('[');
-            sb.append(getCurrentIndex());
-            sb.append(']');
-            break;
-        case TYPE_OBJECT:
-            sb.append('{');
-            if (_currentName != null) {
-                sb.append('"');
-                CharTypes.appendQuoted(sb, _currentName);
-                sb.append('"');
-            } else {
-                sb.append('?');
-            }
-            sb.append('}');
-            break;
-        }
-        return sb.toString();
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/json/JsonWriteContext.java

@@ -1,208 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.json;
-
-import com.fr.third.fasterxml.jackson.core.*;
-
-/**
- * Extension of {@link JsonStreamContext}, which implements
- * core methods needed, and also exposes
- * more complete API to generator implementation classes.
- */
-public class JsonWriteContext
-    extends JsonStreamContext
-{
-    // // // Return values for writeValue()
-
-    public final static int STATUS_OK_AS_IS = 0;
-    public final static int STATUS_OK_AFTER_COMMA = 1;
-    public final static int STATUS_OK_AFTER_COLON = 2;
-    public final static int STATUS_OK_AFTER_SPACE = 3; // in root context
-    public final static int STATUS_EXPECT_VALUE = 4;
-    public final static int STATUS_EXPECT_NAME = 5;
-
-    /**
-     * Parent context for this context; null for root context.
-     */
-    protected final JsonWriteContext _parent;
-
-    // // // Optional duplicate detection
-
-    protected final DupDetector _dups;
-    
-    /*
-    /**********************************************************
-    /* Simple instance reuse slots; speed up things
-    /* a bit (10-15%) for docs with lots of small
-    /* arrays/objects
-    /**********************************************************
-     */
-
-    protected JsonWriteContext _child = null;
-
-    /**
-     * Name of the field of which value is to be parsed; only
-     * used for OBJECT contexts
-     */
-    protected String _currentName;
-
-    /**
-     * Marker used to indicate that we just received a name, and
-     * now expect a value
-     */
-    protected boolean _gotName;
-
-    /*
-    /**********************************************************
-    /* Life-cycle
-    /**********************************************************
-     */
-
-    protected JsonWriteContext(int type, JsonWriteContext parent,
-            DupDetector dups)
-    {
-        super();
-        _type = type;
-        _parent = parent;
-        _dups = dups;
-        _index = -1;
-    }
-
-    protected JsonWriteContext reset(int type) {
-        _type = type;
-        _index = -1;
-        _currentName = null;
-        _gotName = false;
-        if (_dups != null) {
-            _dups.reset();
-        }
-        return this;
-    }
-    
-    // // // Factory methods
-
-    /**
-     * @deprecated Since 2.3; use method that takes argument
-     */
-    @Deprecated
-    public static JsonWriteContext createRootContext() {
-        return createRootContext(null);
-    }
-
-    public static JsonWriteContext createRootContext(DupDetector dd) {
-        return new JsonWriteContext(TYPE_ROOT, null, dd);
-    }
-
-    public JsonWriteContext createChildArrayContext()
-    {
-        JsonWriteContext ctxt = _child;
-        if (ctxt == null) {
-            _child = ctxt = new JsonWriteContext(TYPE_ARRAY, this,
-                    (_dups == null) ? null : _dups.child());
-            return ctxt;
-        }
-        return ctxt.reset(TYPE_ARRAY);
-    }
-
-    public JsonWriteContext createChildObjectContext()
-    {
-        JsonWriteContext ctxt = _child;
-        if (ctxt == null) {
-            _child = ctxt = new JsonWriteContext(TYPE_OBJECT, this,
-                    (_dups == null) ? null : _dups.child());
-            return ctxt;
-        }
-        return ctxt.reset(TYPE_OBJECT);
-    }
-
-    // // // Shared API
-
-    @Override
-    public final JsonWriteContext getParent() { return _parent; }
-
-    @Override
-    public final String getCurrentName() { return _currentName; }
-    
-    // // // API sub-classes are to implement
-
-    /**
-     * Method that writer is to call before it writes a field name.
-     *
-     * @return Index of the field entry (0-based)
-     */
-    public final int writeFieldName(String name) throws JsonProcessingException
-    {
-        _gotName = true;
-        _currentName = name;
-        if (_dups != null) {
-            _checkDup(_dups, name);
-        }
-        return (_index < 0) ? STATUS_OK_AS_IS : STATUS_OK_AFTER_COMMA;
-    }
-
-    private void _checkDup(DupDetector dd, String name) throws JsonProcessingException
-    {
-        if (dd.isDup(name)) {
-            throw new JsonGenerationException("Duplicate field '"+name+"'");
-        }
-    }
-    
-    public final int writeValue()
-    {
-        // Most likely, object:
-        if (_type == TYPE_OBJECT) {
-            _gotName = false;
-            ++_index;
-            return STATUS_OK_AFTER_COLON;
-        }
-
-        // Ok, array?
-        if (_type == TYPE_ARRAY) {
-            int ix = _index;
-            ++_index;
-            return (ix < 0) ? STATUS_OK_AS_IS : STATUS_OK_AFTER_COMMA;
-        }
-        
-        // Nope, root context
-        // No commas within root context, but need space
-        ++_index;
-        return (_index == 0) ? STATUS_OK_AS_IS : STATUS_OK_AFTER_SPACE;
-    }
-
-    // // // Internally used abstract methods
-
-    protected final void appendDesc(StringBuilder sb)
-    {
-        if (_type == TYPE_OBJECT) {
-            sb.append('{');
-            if (_currentName != null) {
-                sb.append('"');
-                // !!! TODO: Name chars should be escaped?
-                sb.append(_currentName);
-                sb.append('"');
-            } else {
-                sb.append('?');
-            }
-            sb.append('}');
-        } else if (_type == TYPE_ARRAY) {
-            sb.append('[');
-            sb.append(getCurrentIndex());
-            sb.append(']');
-        } else {
-            // nah, ROOT:
-            sb.append("/");
-        }
-    }
-
-    // // // Overridden standard methods
-
-    /**
-     * Overridden to provide developer writeable "JsonPath" representation
-     * of the context.
-     */
-    @Override
-    public final String toString()
-    {
-        StringBuilder sb = new StringBuilder(64);
-        appendDesc(sb);
-        return sb.toString();
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/json/PackageVersion.java

@@ -1,20 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.json;
-
-import com.fr.third.fasterxml.jackson.core.Version;
-import com.fr.third.fasterxml.jackson.core.Versioned;
-import com.fr.third.fasterxml.jackson.core.util.VersionUtil;
-
-/**
- * Automatically generated from PackageVersion.java.in during
- * packageVersion-generate execution of maven-replacer-plugin in
- * pom.xml.
- */
-public final class PackageVersion implements Versioned {
-    public final static Version VERSION = VersionUtil.parseVersion(
-        "2.3.3", "com.fr.third.fasterxml.jackson.core", "jackson-core");
-
-    @Override
-    public Version version() {
-        return VERSION;
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/json/PackageVersion.java.in

@@ -1,20 +0,0 @@
-package @package@;
-
-import com.fr.third.fasterxml.jackson.core.Version;
-import com.fr.third.fasterxml.jackson.core.Versioned;
-import com.fr.third.fasterxml.jackson.core.util.VersionUtil;
-
-/**
- * Automatically generated from PackageVersion.java.in during
- * packageVersion-generate execution of maven-replacer-plugin in
- * pom.xml.
- */
-public final class PackageVersion implements Versioned {
-    public final static Version VERSION = VersionUtil.parseVersion(
-        "@projectversion@", "@projectgroupid@", "@projectartifactid@");
-
-    @Override
-    public Version version() {
-        return VERSION;
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/json/package-info.java

@@ -1,7 +0,0 @@
-/**
- * JSON-specific parser and generator implementation classes that
- * Jackson defines and uses.
- * Application code should not (need to) use contents of this package;
- * nor are these implementations likely to be of use for sub-classing.
- */
-package com.fr.third.fasterxml.jackson.core.json;

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/package-info.java

@@ -1,28 +0,0 @@
-/**
- * Main public API classes of the core streaming JSON
- * processor: most importantly {@link com.fr.third.fasterxml.jackson.core.JsonFactory}
- * used for constructing
- * JSON parser ({@link com.fr.third.fasterxml.jackson.core.JsonParser})
- * and generator
- * ({@link com.fr.third.fasterxml.jackson.core.JsonParser})
- * instances.
- * <p>
- * Public API of the higher-level mapping interfaces ("Mapping API")
- * is found from the "jackson-databind" bundle, except for following
- * base interfaces that are defined here:
- * <ul>
- *<li>{@link com.fr.third.fasterxml.jackson.core.TreeNode} is included
- *within Streaming API to support integration of the Tree Model
- *(which is based on <code>JsonNode</code>) with the basic
- *parsers and generators (iff using mapping-supporting factory: which
- *is part of Mapping API, not core)
- *  </li>
- *<li>{@link com.fr.third.fasterxml.jackson.core.ObjectCodec} is included so that
- *  reference to the object capable of serializing/deserializing
- *  Objects to/from JSON (usually, <code>com.fr.third.fasterxml.jackson.databind.ObjectMapper</code>)
- *  can be exposed, without adding direct dependency to implementation.
- *  </li>
- *</ul>
- */
-
-package com.fr.third.fasterxml.jackson.core;

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/sym/CharsToNameCanonicalizer.java

@@ -1,728 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.sym;
-
-import java.util.Arrays;
-
-import com.fr.third.fasterxml.jackson.core.util.ArraysCompat;
-import com.fr.third.fasterxml.jackson.core.util.InternCache;
-
-/**
- * This class is a kind of specialized type-safe Map, from char array to
- * String value. Specialization means that in addition to type-safety
- * and specific access patterns (key char array, Value optionally interned
- * String; values added on access if necessary), and that instances are
- * meant to be used concurrently, but by using well-defined mechanisms
- * to obtain such concurrently usable instances. Main use for the class
- * is to store symbol table information for things like compilers and
- * parsers; especially when number of symbols (keywords) is limited.
- *<p>
- * For optimal performance, usage pattern should be one where matches
- * should be very common (especially after "warm-up"), and as with most hash-based
- * maps/sets, that hash codes are uniformly distributed. Also, collisions
- * are slightly more expensive than with HashMap or HashSet, since hash codes
- * are not used in resolving collisions; that is, equals() comparison is
- * done with all symbols in same bucket index.<br />
- * Finally, rehashing is also more expensive, as hash codes are not
- * stored; rehashing requires all entries' hash codes to be recalculated.
- * Reason for not storing hash codes is reduced memory usage, hoping
- * for better memory locality.
- *<p>
- * Usual usage pattern is to create a single "master" instance, and either
- * use that instance in sequential fashion, or to create derived "child"
- * instances, which after use, are asked to return possible symbol additions
- * to master instance. In either case benefit is that symbol table gets
- * initialized so that further uses are more efficient, as eventually all
- * symbols needed will already be in symbol table. At that point no more
- * Symbol String allocations are needed, nor changes to symbol table itself.
- *<p>
- * Note that while individual SymbolTable instances are NOT thread-safe
- * (much like generic collection classes), concurrently used "child"
- * instances can be freely used without synchronization. However, using
- * master table concurrently with child instances can only be done if
- * access to master instance is read-only (i.e. no modifications done).
- */
-public final class CharsToNameCanonicalizer
-{
-    /* If we use "multiply-add" based hash algorithm, this is the multiplier
-     * we use.
-     */
-    public final static int HASH_MULT = 33;
-    
-    /**
-     * Default initial table size. Shouldn't be miniscule (as there's
-     * cost to both array realloc and rehashing), but let's keep
-     * it reasonably small nonetheless. For systems that properly 
-     * reuse factories it doesn't matter either way; but when
-     * recreating factories often, initial overhead may dominate.
-     */
-    protected static final int DEFAULT_TABLE_SIZE = 64;
-
-    /**
-     * Let's not expand symbol tables past some maximum size;
-     * this should protected against OOMEs caused by large documents
-     * with uniquer (~= random) names.
-     */
-    protected static final int MAX_TABLE_SIZE = 0x10000; // 64k entries == 256k mem
-
-    /**
-     * Let's only share reasonably sized symbol tables. Max size set to 3/4 of 16k;
-     * this corresponds to 64k main hash index. This should allow for enough distinct
-     * names for almost any case.
-     */
-    final static int MAX_ENTRIES_FOR_REUSE = 12000;
-
-    /**
-     * Also: to thwart attacks based on hash collisions (which may or may not
-     * be cheap to calculate), we will need to detect "too long"
-     * collision chains. Let's start with static value of 255 entries
-     * for the longest legal chain.
-     *<p>
-     * Note: longest chain we have been able to produce without malicious
-     * intent has been 38 (with "com.fr.third.fasterxml.jackson.core.main.TestWithTonsaSymbols");
-     * our setting should be reasonable here.
-     * 
-     * @since 2.1
-     */
-    final static int MAX_COLL_CHAIN_LENGTH = 255;
-
-    /**
-     * And to support reduce likelihood of accidental collisons causing
-     * exceptions, let's prevent reuse of tables with long collision
-     * overflow lists as well.
-     * 
-     * @since 2.1
-     */
-    final static int MAX_COLL_CHAIN_FOR_REUSE  = 63;
-    
-    final static CharsToNameCanonicalizer sBootstrapSymbolTable;
-    static {
-        sBootstrapSymbolTable = new CharsToNameCanonicalizer();
-    }
-
-    /*
-    /**********************************************************
-    /* Configuration
-    /**********************************************************
-     */
-
-    /**
-     * Sharing of learnt symbols is done by optional linking of symbol
-     * table instances with their parents. When parent linkage is
-     * defined, and child instance is released (call to <code>release</code>),
-     * parent's shared tables may be updated from the child instance.
-     */
-    protected CharsToNameCanonicalizer _parent;
-
-    /**
-     * Seed value we use as the base to make hash codes non-static between
-     * different runs, but still stable for lifetime of a single symbol table
-     * instance.
-     * This is done for security reasons, to avoid potential DoS attack via
-     * hash collisions.
-     * 
-     * @since 2.1
-     */
-    final private int _hashSeed;
-    
-    /**
-     * Whether canonical symbol Strings are to be intern()ed before added
-     * to the table or not
-     */
-    final protected boolean _intern;
-
-    /**
-     * Whether any canonicalization should be attempted (whether using
-     * intern or not)
-     */
-    final protected boolean _canonicalize;
-    
-    /*
-    /**********************************************************
-    /* Actual symbol table data
-    /**********************************************************
-     */
-
-    /**
-     * Primary matching symbols; it's expected most match occur from
-     * here.
-     */
-    protected String[] _symbols;
-
-    /**
-     * Overflow buckets; if primary doesn't match, lookup is done
-     * from here.
-     *<p>
-     * Note: Number of buckets is half of number of symbol entries, on
-     * assumption there's less need for buckets.
-     */
-    protected Bucket[] _buckets;
-
-    /**
-     * Current size (number of entries); needed to know if and when
-     * rehash.
-     */
-    protected int _size;
-
-    /**
-     * Limit that indicates maximum size this instance can hold before
-     * it needs to be expanded and rehashed. Calculated using fill
-     * factor passed in to constructor.
-     */
-    protected int _sizeThreshold;
-
-    /**
-     * Mask used to get index from hash values; equal to
-     * <code>_buckets.length - 1</code>, when _buckets.length is
-     * a power of two.
-     */
-    protected int _indexMask;
-
-    /**
-     * We need to keep track of the longest collision list; this is needed
-     * both to indicate problems with attacks and to allow flushing for
-     * other cases.
-     * 
-     * @since 2.1
-     */
-    protected int _longestCollisionList;
-    
-    /*
-    /**********************************************************
-    /* State regarding shared arrays
-    /**********************************************************
-     */
-
-    /**
-     * Flag that indicates if any changes have been made to the data;
-     * used to both determine if bucket array needs to be copied when
-     * (first) change is made, and potentially if updated bucket list
-     * is to be resync'ed back to master instance.
-     */
-    protected boolean _dirty;
-
-    /*
-    /**********************************************************
-    /* Life-cycle
-    /**********************************************************
-     */
-
-    /**
-     * Method called to create root canonicalizer for a {@link com.fr.third.fasterxml.jackson.core.JsonFactory}
-     * instance. Root instance is never used directly; its main use is for
-     * storing and sharing underlying symbol arrays as needed.
-     */
-    public static CharsToNameCanonicalizer createRoot()
-    {
-        /* [Issue-21]: Need to use a variable seed, to thwart hash-collision
-         * based attacks.
-         */
-        long now = System.currentTimeMillis();
-        // ensure it's not 0; and might as well require to be odd so:
-        int seed = (((int) now) + ((int) (now >>> 32))) | 1;
-        return createRoot(seed);
-    }
-    
-    protected static CharsToNameCanonicalizer createRoot(int hashSeed) {
-        return sBootstrapSymbolTable.makeOrphan(hashSeed);
-    }
-
-    /**
-     * Main method for constructing a master symbol table instance.
-     *
-     * @param initialSize Minimum initial size for bucket array; internally
-     *   will always use a power of two equal to or bigger than this value.
-     */
-    private CharsToNameCanonicalizer()
-    {
-        // these settings don't really matter for the bootstrap instance
-        _canonicalize = true;
-        _intern = true;
-        // And we'll also set flags so no copying of buckets is needed:
-        _dirty = true;
-        _hashSeed = 0;
-        _longestCollisionList = 0;
-        initTables(DEFAULT_TABLE_SIZE);
-    }
-
-    private void initTables(int initialSize)
-    {
-        _symbols = new String[initialSize];
-        _buckets = new Bucket[initialSize >> 1];
-        // Mask is easy to calc for powers of two.
-        _indexMask = initialSize - 1;
-        _size = 0;
-        _longestCollisionList = 0;
-        // Hard-coded fill factor is 75%
-        _sizeThreshold = _thresholdSize(initialSize);
-    }
-
-    private static int _thresholdSize(int hashAreaSize) {
-        return hashAreaSize - (hashAreaSize >> 2);
-    }
-    
-    /**
-     * Internal constructor used when creating child instances.
-     */
-    private CharsToNameCanonicalizer(CharsToNameCanonicalizer parent,
-            boolean canonicalize, boolean intern,
-            String[] symbols, Bucket[] buckets, int size,
-            int hashSeed, int longestColl)
-    {
-        _parent = parent;
-        _canonicalize = canonicalize;
-        _intern = intern;
-
-        _symbols = symbols;
-        _buckets = buckets;
-        _size = size;
-        _hashSeed = hashSeed;
-        // Hard-coded fill factor, 75%
-        int arrayLen = (symbols.length);
-        _sizeThreshold = _thresholdSize(arrayLen);
-        _indexMask =  (arrayLen - 1);
-        _longestCollisionList = longestColl;
-
-        // Need to make copies of arrays, if/when adding new entries
-        _dirty = false;
-    }
-
-    /**
-     * "Factory" method; will create a new child instance of this symbol
-     * table. It will be a copy-on-write instance, ie. it will only use
-     * read-only copy of parent's data, but when changes are needed, a
-     * copy will be created.
-     *<p>
-     * Note: while this method is synchronized, it is generally not
-     * safe to both use makeChild/mergeChild, AND to use instance
-     * actively. Instead, a separate 'root' instance should be used
-     * on which only makeChild/mergeChild are called, but instance itself
-     * is not used as a symbol table.
-     */
-    public CharsToNameCanonicalizer makeChild(final boolean canonicalize,
-            final boolean intern)
-    {
-        /* 24-Jul-2012, tatu: Trying to reduce scope of synchronization, assuming
-         *   that synchronizing construction is the (potentially) expensive part,
-         *   and not so much short copy-the-variables thing.
-         */
-        final String[] symbols;
-        final Bucket[] buckets;
-        final int size;
-        final int hashSeed;
-        final int longestCollisionList;
-        
-        synchronized (this) {
-            symbols = _symbols;
-            buckets = _buckets;
-            size = _size;
-            hashSeed = _hashSeed;
-            longestCollisionList = _longestCollisionList;
-        }
-        
-        return new CharsToNameCanonicalizer(this, canonicalize, intern,
-                symbols, buckets, size, hashSeed, longestCollisionList);
-    }
-
-    private CharsToNameCanonicalizer makeOrphan(int seed)
-    {
-        return new CharsToNameCanonicalizer(null, true, true,
-                _symbols, _buckets, _size, seed, _longestCollisionList);
-    }
-
-    /**
-     * Method that allows contents of child table to potentially be
-     * "merged in" with contents of this symbol table.
-     *<p>
-     * Note that caller has to make sure symbol table passed in is
-     * really a child or sibling of this symbol table.
-     */
-    private void mergeChild(CharsToNameCanonicalizer child)
-    {
-        /* One caveat: let's try to avoid problems with
-         * degenerate cases of documents with generated "random"
-         * names: for these, symbol tables would bloat indefinitely.
-         * One way to do this is to just purge tables if they grow
-         * too large, and that's what we'll do here.
-         */
-        if (child.size() > MAX_ENTRIES_FOR_REUSE
-                || child._longestCollisionList > MAX_COLL_CHAIN_FOR_REUSE) {
-            // Should there be a way to get notified about this event, to log it or such?
-            // (as it's somewhat abnormal thing to happen)
-            // At any rate, need to clean up the tables, then:
-            synchronized (this) {
-                initTables(DEFAULT_TABLE_SIZE);
-                // Dirty flag... well, let's just clear it. Shouldn't really matter for master tables
-                // (which this is, given something is merged to it)
-                _dirty = false;
-            }
-        } else {
-            // Otherwise, we'll merge changed stuff in, if there are  more entries (which
-            // may not be the case if one of siblings has added symbols first or such)
-            if (child.size() <= size()) { // nothing to add
-                return;
-            }
-            // Okie dokie, let's get the data in!
-            synchronized (this) {
-                _symbols = child._symbols;
-                _buckets = child._buckets;
-                _size = child._size;
-                _sizeThreshold = child._sizeThreshold;
-                _indexMask = child._indexMask;
-                _longestCollisionList = child._longestCollisionList;
-                // Dirty flag... well, let's just clear it. Shouldn't really matter for master tables
-                // (which this is, given something is merged to it)
-                _dirty = false;
-            }
-        }
-    }
-
-    public void release()
-    {
-        // If nothing has been added, nothing to do
-        if (!maybeDirty()) {
-            return;
-        }
-        if (_parent != null) {
-            _parent.mergeChild(this);
-            /* Let's also mark this instance as dirty, so that just in
-             * case release was too early, there's no corruption
-             * of possibly shared data.
-             */
-            _dirty = false;
-        }
-    }
-
-    /*
-    /**********************************************************
-    /* Public API, generic accessors:
-    /**********************************************************
-     */
-
-    public int size() { return _size; }
-
-    /**
-     * Method for checking number of primary hash buckets this symbol
-     * table uses.
-     * 
-     * @since 2.1
-     */
-    public int bucketCount() { 
-       return _symbols.length; }
-    
-    public boolean maybeDirty() { return _dirty; }
-
-    public int hashSeed() { return _hashSeed; }
-    
-    /**
-     * Method mostly needed by unit tests; calculates number of
-     * entries that are in collision list. Value can be at most
-     * ({@link #size} - 1), but should usually be much lower, ideally 0.
-     * 
-     * @since 2.1
-     */
-    public int collisionCount()
-    {
-        int count = 0;
-        
-        for (Bucket bucket : _buckets) {
-            if (bucket != null) {
-                count += bucket.length();
-            }
-        }
-        return count;
-    }
-
-    /**
-     * Method mostly needed by unit tests; calculates length of the
-     * longest collision chain. This should typically be a low number,
-     * but may be up to {@link #size} - 1 in the pathological case
-     * 
-     * @since 2.1
-     */
-    public int maxCollisionLength()
-    {
-        return _longestCollisionList;
-    }
-
-    /*
-    /**********************************************************
-    /* Public API, accessing symbols:
-    /**********************************************************
-     */
-
-    public String findSymbol(char[] buffer, int start, int len, int h)
-    {
-        if (len < 1) { // empty Strings are simplest to handle up front
-            return "";
-        }
-        if (!_canonicalize) { // [JACKSON-259]
-            return new String(buffer, start, len);
-        }
-
-        /* Related to problems with sub-standard hashing (somewhat
-         * relevant for collision attacks too), let's try little
-         * bit of shuffling to improve hash codes.
-         * (note, however, that this can't help with full collisions)
-         */
-        int index = _hashToIndex(h);
-        String sym = _symbols[index];
-
-        // Optimal case; checking existing primary symbol for hash index:
-        if (sym != null) {
-            // Let's inline primary String equality checking:
-            if (sym.length() == len) {
-                int i = 0;
-                do {
-                    if (sym.charAt(i) != buffer[start+i]) {
-                        break;
-                    }
-                } while (++i < len);
-                // Optimal case; primary match found
-                if (i == len) {
-                    return sym;
-                }
-            }
-            // How about collision bucket?
-            Bucket b = _buckets[index >> 1];
-            if (b != null) {
-                sym = b.find(buffer, start, len);
-                if (sym != null) {
-                    return sym;
-                }
-            }
-        }
-
-        if (!_dirty) { //need to do copy-on-write?
-            copyArrays();
-            _dirty = true;
-        } else if (_size >= _sizeThreshold) { // Need to expand?
-           rehash();
-           /* Need to recalc hash; rare occurence (index mask has been
-            * recalculated as part of rehash)
-            */
-           index = _hashToIndex(calcHash(buffer, start, len));
-        }
-
-        String newSymbol = new String(buffer, start, len);
-        if (_intern) {
-            newSymbol = InternCache.instance.intern(newSymbol);
-        }
-        ++_size;
-        // Ok; do we need to add primary entry, or a bucket?
-        if (_symbols[index] == null) {
-            _symbols[index] = newSymbol;
-        } else {
-            int bix = (index >> 1);
-            Bucket newB = new Bucket(newSymbol, _buckets[bix]);
-            _buckets[bix] = newB;
-            _longestCollisionList = Math.max(newB.length(), _longestCollisionList);
-            if (_longestCollisionList > MAX_COLL_CHAIN_LENGTH) {
-                reportTooManyCollisions(MAX_COLL_CHAIN_LENGTH);
-            }
-        }
-
-        return newSymbol;
-    }
-
-    /**
-     * Helper method that takes in a "raw" hash value, shuffles it as necessary,
-     * and truncates to be used as the index.
-     */
-    public int _hashToIndex(int rawHash)
-    {
-        rawHash += (rawHash >>> 15); // this seems to help quite a bit, at least for our tests
-        return (rawHash & _indexMask);
-    }
-    
-    /**
-     * Implementation of a hashing method for variable length
-     * Strings. Most of the time intention is that this calculation
-     * is done by caller during parsing, not here; however, sometimes
-     * it needs to be done for parsed "String" too.
-     *
-     * @param len Length of String; has to be at least 1 (caller guarantees
-     *   this pre-condition)
-     */
-    public int calcHash(char[] buffer, int start, int len)
-    {
-        int hash = _hashSeed;
-        for (int i = 0; i < len; ++i) {
-            hash = (hash * HASH_MULT) + (int) buffer[i];
-        }
-        // NOTE: shuffling, if any, is done in 'findSymbol()', not here:
-        return (hash == 0) ? 1 : hash;
-    }
-
-    public int calcHash(String key)
-    {
-        final int len = key.length();
-        
-        int hash = _hashSeed;
-        for (int i = 0; i < len; ++i) {
-            hash = (hash * HASH_MULT) + (int) key.charAt(i);
-        }
-        // NOTE: shuffling, if any, is done in 'findSymbol()', not here:
-        return (hash == 0) ? 1 : hash;
-    }
-
-    /*
-    /**********************************************************
-    /* Internal methods
-    /**********************************************************
-     */
-
-    /**
-     * Method called when copy-on-write is needed; generally when first
-     * change is made to a derived symbol table.
-     */
-    private void copyArrays()
-    {
-        final String[] oldSyms = _symbols;
-        _symbols = ArraysCompat.copyOf(oldSyms, oldSyms.length);
-        final Bucket[] oldBuckets = _buckets;
-        _buckets = ArraysCompat.copyOf(oldBuckets, oldBuckets.length);
-    }
-
-    /**
-     * Method called when size (number of entries) of symbol table grows
-     * so big that load factor is exceeded. Since size has to remain
-     * power of two, arrays will then always be doubled. Main work
-     * is really redistributing old entries into new String/Bucket
-     * entries.
-     */
-    private void rehash()
-    {
-        int size = _symbols.length;
-        int newSize = size + size;
-
-        /* 12-Mar-2010, tatu: Let's actually limit maximum size we are
-         *    prepared to use, to guard against OOME in case of unbounded
-         *    name sets (unique [non-repeating] names)
-         */
-        if (newSize > MAX_TABLE_SIZE) {
-            /* If this happens, there's no point in either growing or
-             * shrinking hash areas. Rather, it's better to just clean
-             * them up for reuse.
-             */
-            _size = 0;
-            Arrays.fill(_symbols, null);
-            Arrays.fill(_buckets, null);
-            _dirty = true;
-            return;
-        }
-        
-        String[] oldSyms = _symbols;
-        Bucket[] oldBuckets = _buckets;
-        _symbols = new String[newSize];
-        _buckets = new Bucket[newSize >> 1];
-        // Let's update index mask, threshold, now (needed for rehashing)
-        _indexMask = newSize - 1;
-        _sizeThreshold = _thresholdSize(newSize);
-        
-        int count = 0; // let's do sanity check
-
-        /* Need to do two loops, unfortunately, since spill-over area is
-         * only half the size:
-         */
-        int maxColl = 0;
-        for (int i = 0; i < size; ++i) {
-            String symbol = oldSyms[i];
-            if (symbol != null) {
-                ++count;
-                int index = _hashToIndex(calcHash(symbol));
-                if (_symbols[index] == null) {
-                    _symbols[index] = symbol;
-                } else {
-                    int bix = (index >> 1);
-                    Bucket newB = new Bucket(symbol, _buckets[bix]);
-                    _buckets[bix] = newB;
-                    maxColl = Math.max(maxColl, newB.length());
-                }
-            }
-        }
-
-        size >>= 1;
-        for (int i = 0; i < size; ++i) {
-            Bucket b = oldBuckets[i];
-            while (b != null) {
-                ++count;
-                String symbol = b.getSymbol();
-                int index = _hashToIndex(calcHash(symbol));
-                if (_symbols[index] == null) {
-                    _symbols[index] = symbol;
-                } else {
-                    int bix = (index >> 1);
-                    Bucket newB = new Bucket(symbol, _buckets[bix]);
-                    _buckets[bix] = newB;
-                    maxColl = Math.max(maxColl, newB.length());
-                }
-                b = b.getNext();
-            }
-        }
-        _longestCollisionList = maxColl;
-
-        if (count != _size) {
-            throw new Error("Internal error on SymbolTable.rehash(): had "+_size+" entries; now have "+count+".");
-        }
-    }
-
-    /**
-     * @since 2.1
-     */
-    protected void reportTooManyCollisions(int maxLen)
-    {
-        throw new IllegalStateException("Longest collision chain in symbol table (of size "+_size
-                +") now exceeds maximum, "+maxLen+" -- suspect a DoS attack based on hash collisions");
-    }
-    
-    /*
-    /**********************************************************
-    /* Bucket class
-    /**********************************************************
-     */
-
-    /**
-     * This class is a symbol table entry. Each entry acts as a node
-     * in a linked list.
-     */
-    static final class Bucket
-    {
-        private final String _symbol;
-        private final Bucket _next;
-        private final int _length;
-
-        public Bucket(String symbol, Bucket next) {
-            _symbol = symbol;
-            _next = next;
-            _length = (next == null) ? 1 : next._length+1;
-        }
-
-        public String getSymbol() { return _symbol; }
-        public Bucket getNext() { return _next; }
-        public int length() { return _length; }
-
-        public String find(char[] buf, int start, int len) {
-            String sym = _symbol;
-            Bucket b = _next;
-
-            while (true) { // Inlined equality comparison:
-                if (sym.length() == len) {
-                    int i = 0;
-                    do {
-                        if (sym.charAt(i) != buf[start+i]) {
-                            break;
-                        }
-                    } while (++i < len);
-                    if (i == len) {
-                        return sym;
-                    }
-                }
-                if (b == null) {
-                    break;
-                }
-                sym = b.getSymbol();
-                b = b.getNext();
-            }
-            return null;
-        }
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/sym/Name.java

@@ -1,50 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.sym;
-
-/**
- * Base class for tokenized names (key strings in objects) that have
- * been tokenized from byte-based input sources (like
- * {@link java.io.InputStream}.
- *
- * @author Tatu Saloranta
- */
-public abstract class Name
-{
-    protected final String _name;
-
-    protected final int _hashCode;
-
-    protected Name(String name, int hashCode) {
-        _name = name;
-        _hashCode = hashCode;
-    }
-
-    public String getName() { return _name; }
-
-    /*
-    /**********************************************************
-    /* Methods for package/core parser
-    /**********************************************************
-     */
-
-    public abstract boolean equals(int quad1);
-
-    public abstract boolean equals(int quad1, int quad2);
-
-    public abstract boolean equals(int[] quads, int qlen);
-
-    /*
-    /**********************************************************
-    /* Overridden standard methods
-    /**********************************************************
-     */
-
-    @Override public String toString() { return _name; }
-
-    @Override public final int hashCode() { return _hashCode; }
-
-    @Override public boolean equals(Object o)
-    {
-        // Canonical instances, can usually just do identity comparison
-        return (o == this);
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/sym/Name1.java

@@ -1,44 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.sym;
-
-/**
- * Specialized implementation of PName: can be used for short Strings
- * that consists of at most 4 bytes. Usually this means short
- * ascii-only names.
- *<p>
- * The reason for such specialized classes is mostly space efficiency;
- * and to a lesser degree performance. Both are achieved for short
- * Strings by avoiding another level of indirection (via quad arrays)
- */
-public final class Name1
-    extends Name
-{
-    final static Name1 sEmptyName = new Name1("", 0, 0);
-
-    final int mQuad;
-
-    Name1(String name, int hash, int quad)
-    {
-        super(name, hash);
-        mQuad = quad;
-    }
-
-    static Name1 getEmptyName() { return sEmptyName; }
-
-    @Override
-    public boolean equals(int quad)
-    {
-        return (quad == mQuad);
-    }
-
-    @Override
-    public boolean equals(int quad1, int quad2)
-    {
-        return (quad1 == mQuad) && (quad2 == 0);
-    }
-
-    @Override
-    public boolean equals(int[] quads, int qlen)
-    {
-        return (qlen == 1 && quads[0] == mQuad);
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/sym/Name2.java

@@ -1,40 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.sym;
-
-/**
- * Specialized implementation of PName: can be used for short Strings
- * that consists of 5 to 8 bytes. Usually this means relatively short
- * ascii-only names.
- *<p>
- * The reason for such specialized classes is mostly space efficiency;
- * and to a lesser degree performance. Both are achieved for short
- * Strings by avoiding another level of indirection (via quad arrays)
- */
-public final class Name2
-    extends Name
-{
-    final int mQuad1;
-
-    final int mQuad2;
-
-    Name2(String name, int hash, int quad1, int quad2)
-    {
-        super(name, hash);
-        mQuad1 = quad1;
-        mQuad2 = quad2;
-    }
-
-    @Override
-    public boolean equals(int quad) { return false; }
-
-    @Override
-    public boolean equals(int quad1, int quad2)
-    {
-        return (quad1 == mQuad1) && (quad2 == mQuad2);
-    }
-
-    @Override
-    public boolean equals(int[] quads, int qlen)
-    {
-        return (qlen == 2 && quads[0] == mQuad1 && quads[1] == mQuad2);
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/sym/Name3.java

@@ -1,39 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.sym;
-
-/**
- * Specialized implementation of PName: can be used for short Strings
- * that consists of 9 to 12 bytes. It's the longest special purpose
- * implementaion; longer ones are expressed using {@link NameN}.
- */
-public final class Name3
-    extends Name
-{
-    final int mQuad1;
-    final int mQuad2;
-    final int mQuad3;
-
-    Name3(String name, int hash, int q1, int q2, int q3)
-    {
-        super(name, hash);
-        mQuad1 = q1;
-        mQuad2 = q2;
-        mQuad3 = q3;
-    }
-
-    // Implies quad length == 1, never matches
-    @Override
-    public boolean equals(int quad) { return false; }
-
-    // Implies quad length == 2, never matches
-    @Override
-    public boolean equals(int quad1, int quad2) { return false; }
-
-    @Override
-    public boolean equals(int[] quads, int qlen)
-    {
-        return (qlen == 3)
-            && (quads[0] == mQuad1)
-            && (quads[1] == mQuad2)
-            && (quads[2] == mQuad3);
-    }
-}

fine-ehcache/src/com/fr/third/fasterxml/jackson/core/sym/NameN.java

@@ -1,68 +0,0 @@
-package com.fr.third.fasterxml.jackson.core.sym;
-
-/**
- * Generic implementation of PName used for "long" names, where long
- * means that its byte (UTF-8) representation is 13 bytes or more.
- */
-public final class NameN
-    extends Name
-{
-    final int[] mQuads;
-    final int mQuadLen;
-
-    NameN(String name, int hash, int[] quads, int quadLen)
-    {
-        super(name, hash);
-        /* We have specialized implementations for shorter
-         * names, so let's not allow runt instances here
-         */
-        if (quadLen < 3) {
-            throw new IllegalArgumentException("Qlen must >= 3");
-        }
-        mQuads = quads;
-        mQuadLen = quadLen;
-    }
-
-    // Implies quad length == 1, never matches
-    @Override
-	public boolean equals(int quad) { return false; }
-
-    // Implies quad length == 2, never matches
-    @Override
-	public boolean equals(int quad1, int quad2) { return false; }
-
-    @Override
-	public boolean equals(int[] quads, int qlen)
-    {
-        if (qlen != mQuadLen) {
-            return false;
-        }
-
-        /* 26-Nov-2008, tatus: Strange, but it does look like
-         *   unrolling here is counter-productive, reducing
-         *   speed. Perhaps it prevents inlining by HotSpot or
-         *   something...
-         */
-        // Will always have >= 3 quads, can unroll
-        /*
-        if (quads[0] == mQuads[0]
-            && quads[1] == mQuads[1]
-            && quads[2] == mQuads[2]) {
-            for (int i = 3; i < qlen; ++i) {
-                if (quads[i] != mQuads[i]) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        */
-
-        // or simpler way without unrolling:
-        for (int i = 0; i < qlen; ++i) {
-            if (quads[i] != mQuads[i]) {
-                return false;
-            }
-        }
-        return true;
-    }
-}