calabash-android 0.5.2 → 0.5.3

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/Base64Variants.java

@@ -1,90 +0,0 @@
-/* Jackson JSON-processor.
- *
- * Copyright (c) 2007- Tatu Saloranta, tatu.saloranta@iki.fi
- *
- * Licensed under the License specified in file LICENSE, included with
- * the source code and binary code bundles.
- * You may not use this file except in compliance with the License.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package sh.calaba.org.codehaus.jackson;
-
-/**
- * Container for commonly used Base64 variants.
- * 
- * @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;
-    }
-}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/FormatSchema.java

@@ -1,29 +0,0 @@
-package sh.calaba.org.codehaus.jackson;
-
-/**
- * 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.
- * 
- * @since 1.8
- */
-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.
-     */
-    public String getSchemaType();
-}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/JsonEncoding.java

@@ -1,47 +0,0 @@
-package sh.calaba.org.codehaus.jackson;
-
-/**
- * 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), // N/A for big-endian, really
-        UTF16_BE("UTF-16BE", true),
-        UTF16_LE("UTF-16LE", false),
-        UTF32_BE("UTF-32BE", true),
-        UTF32_LE("UTF-32LE", false)
-        ;
-    
-    protected final String _javaName;
-
-    protected final boolean _bigEndian;
-    
-    JsonEncoding(String javaName, boolean bigEndian)
-    {
-        _javaName = javaName;
-        _bigEndian = bigEndian;
-    }
-
-    /**
-     * 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; }
-}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/JsonFactory.java

@@ -1,937 +0,0 @@
-/* Jackson JSON-processor.
- *
- * Copyright (c) 2007- Tatu Saloranta, tatu.saloranta@iki.fi
- *
- * Licensed under the License specified in file LICENSE, included with
- * the source code and binary code bundles.
- * You may not use this file except in compliance with the License.
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package sh.calaba.org.codehaus.jackson;
-
-import java.io.*;
-import java.lang.ref.SoftReference;
-import java.net.URL;
-
-import sh.calaba.org.codehaus.jackson.format.InputAccessor;
-import sh.calaba.org.codehaus.jackson.format.MatchStrength;
-import sh.calaba.org.codehaus.jackson.impl.ByteSourceBootstrapper;
-import sh.calaba.org.codehaus.jackson.impl.ReaderBasedParser;
-import sh.calaba.org.codehaus.jackson.impl.Utf8Generator;
-import sh.calaba.org.codehaus.jackson.impl.WriterBasedGenerator;
-import sh.calaba.org.codehaus.jackson.io.*;
-import sh.calaba.org.codehaus.jackson.sym.BytesToNameCanonicalizer;
-import sh.calaba.org.codehaus.jackson.sym.CharsToNameCanonicalizer;
-import sh.calaba.org.codehaus.jackson.util.BufferRecycler;
-import sh.calaba.org.codehaus.jackson.util.VersionUtil;
-
-/**
- * The main factory class of Jackson package, used to configure and
- * construct reader (aka parser, {@link JsonParser})
- * and writer (aka generator, {@link JsonGenerator})
- * instances.
- *<p>
- * Factory instances are thread-safe and reusable after configuration
- * (if any). Typically applications and services use only a single
- * globally shared factory instance, unless they need differently
- * configured factories. Factory reuse is important if efficiency matters;
- * most recycling of expensive construct is done on per-factory basis.
- *<p>
- * Creation of a factory instance is a light-weight operation,
- * and since there is no need for pluggable alternative implementations
- * (as there is no "standard" JSON processor API to implement),
- * the default constructor is used for constructing factory
- * instances.
- *
- * @author Tatu Saloranta
- */
-public class JsonFactory implements Versioned
-{
-    /**
-     * Name used to identify JSON format
-     * (and returned by {@link #getFormatName()}
-     */
-    public final static String FORMAT_NAME_JSON = "JSON";
-    
-    /**
-     * Bitfield (set of flags) of all parser features that are enabled
-     * by default.
-     */
-    final static int DEFAULT_PARSER_FEATURE_FLAGS = JsonParser.Feature.collectDefaults();
-
-    /**
-     * Bitfield (set of flags) of all generator features that are enabled
-     * by default.
-     */
-    final static int DEFAULT_GENERATOR_FEATURE_FLAGS = JsonGenerator.Feature.collectDefaults();
-
-    /*
-    /**********************************************************
-    /* Buffer, symbol table management
-    /**********************************************************
-     */
-
-    /**
-     * This <code>ThreadLocal</code> contains a {@link java.lang.ref.SoftRerefence}
-     * to a {@link BufferRecycler} used to provide a low-cost
-     * buffer recycling between reader and writer instances.
-     */
-    final protected static ThreadLocal<SoftReference<BufferRecycler>> _recyclerRef
-        = new ThreadLocal<SoftReference<BufferRecycler>>();
-
-    /**
-     * Each factory comes equipped with a shared root symbol table.
-     * It should not be linked back to the original blueprint, to
-     * avoid contents from leaking between factories.
-     */
-    protected CharsToNameCanonicalizer _rootCharSymbols = CharsToNameCanonicalizer.createRoot();
-
-    /**
-     * Alternative to the basic symbol table, some stream-based
-     * parsers use different name canonicalization method.
-     *<p>
-     * TODO: should clean up this; looks messy having 2 alternatives
-     * with not very clear differences.
-     */
-    protected BytesToNameCanonicalizer _rootByteSymbols = BytesToNameCanonicalizer.createRoot();
-
-    /*
-    /**********************************************************
-    /* Configuration
-    /**********************************************************
-     */
-
-    /**
-     * Object that implements conversion functionality between
-     * Java objects and JSON content. For base JsonFactory implementation
-     * usually not set by default, but can be explicitly set.
-     * Sub-classes (like @link sh.calaba.org.codehaus.jackson.map.MappingJsonFactory}
-     * usually provide an implementation.
-     */
-    protected ObjectCodec _objectCodec;
-
-    /**
-     * Currently enabled parser features.
-     */
-    protected int _parserFeatures = DEFAULT_PARSER_FEATURE_FLAGS;
-
-    /**
-     * Currently enabled generator features.
-     */
-    protected int _generatorFeatures = DEFAULT_GENERATOR_FEATURE_FLAGS;
-
-    /**
-     * Definition of custom character escapes to use for generators created
-     * by this factory, if any. If null, standard data format specific
-     * escapes are used.
-     * 
-     * @since 1.8
-     */
-    protected CharacterEscapes _characterEscapes;
-
-    /**
-     * Optional helper object that may decorate input sources, to do
-     * additional processing on input during parsing.
-     * 
-     * @since 1.8
-     */
-    protected InputDecorator _inputDecorator;
-
-    /**
-     * Optional helper object that may decorate output object, to do
-     * additional processing on output during content generation.
-     * 
-     * @since 1.8
-     */
-    protected OutputDecorator _outputDecorator;
-    
-    /*
-    /**********************************************************
-    /* Construction
-    /**********************************************************
-     */
-    
-    /**
-     * Default constructor used to create factory instances.
-     * Creation of a factory instance is a light-weight operation,
-     * but it is still a good idea to reuse limited number of
-     * factory instances (and quite often just a single instance):
-     * factories are used as context for storing some reused
-     * processing objects (such as symbol tables parsers use)
-     * and this reuse only works within context of a single
-     * factory instance.
-     */
-    public JsonFactory() { this(null); }
-
-    public JsonFactory(ObjectCodec oc) { _objectCodec = oc; }
-
-    /*
-    /**********************************************************
-    /* Format detection functionality (since 1.8)
-    /**********************************************************
-     */
-
-    /**
-     * Method that returns short textual id identifying format
-     * this factory supports.
-     *<p>
-     * Note: sub-classes should override this method; default
-     * implementation will return null for all sub-classes
-     * 
-     * @since 1.8
-     */
-    public String getFormatName()
-    {
-        /* Somewhat nasty check: since we can't make this abstract
-         * (due to backwards compatibility concerns), need to prevent
-         * format name "leakage"
-         */
-        if (getClass() == JsonFactory.class) {
-            return FORMAT_NAME_JSON;
-        }
-        return null;
-    }
-
-    public MatchStrength hasFormat(InputAccessor acc) throws IOException
-    {
-        // since we can't keep this abstract, only implement for "vanilla" instance
-        if (getClass() == JsonFactory.class) {
-            return hasJSONFormat(acc);
-        }
-        return null;
-    }
-
-    protected MatchStrength hasJSONFormat(InputAccessor acc) throws IOException
-    {
-        return ByteSourceBootstrapper.hasJSONFormat(acc);
-    }    
-    
-    /*
-    /**********************************************************
-    /* Versioned
-    /**********************************************************
-     */
-
-    @Override
-    public Version version() {
-        // VERSION is included under impl, so can't pass this class:
-        return VersionUtil.versionFor(Utf8Generator.class);
-    }
-
-    /*
-    /**********************************************************
-    /* Configuration, parser settings
-    /**********************************************************
-     */
-
-    /**
-     * Method for enabling or disabling specified parser feature
-     * (check {@link JsonParser.Feature} for list of features)
-     *
-     * @since 1.2
-     */
-    public final JsonFactory configure(JsonParser.Feature f, boolean state)
-    {
-        if (state) {
-            enable(f);
-        } else {
-            disable(f);
-        }
-        return this;
-    }
-
-    /**
-     * Method for enabling specified parser feature
-     * (check {@link JsonParser.Feature} for list of features)
-     *
-     * @since 1.2
-     */
-    public JsonFactory enable(JsonParser.Feature f) {
-        _parserFeatures |= f.getMask();
-        return this;
-    }
-
-    /**
-     * Method for disabling specified parser features
-     * (check {@link JsonParser.Feature} for list of features)
-     *
-     * @since 1.2
-     */
-    public JsonFactory disable(JsonParser.Feature f) {
-        _parserFeatures &= ~f.getMask();
-        return this;
-    }
-
-    /**
-     * Checked whether specified parser feature is enabled.
-     *
-     * @since 1.2
-     */
-    public final boolean isEnabled(JsonParser.Feature f) {
-        return (_parserFeatures & f.getMask()) != 0;
-    }
-
-    // // // Older deprecated (as of 1.2) methods
-
-    /**
-     * @deprecated Use {@link #enable(JsonParser.Feature)} instead
-     */
-    @SuppressWarnings("dep-ann")
-    public final void enableParserFeature(JsonParser.Feature f) {
-        enable(f);
-    }
-
-    /**
-     * @deprecated Use {@link #disable(JsonParser.Feature)} instead
-     */
-    @SuppressWarnings("dep-ann")
-    public final void disableParserFeature(JsonParser.Feature f) {
-        disable(f);
-    }
-
-    /**
-     * @deprecated Use {@link #configure(JsonParser.Feature, boolean)} instead
-     */
-    @SuppressWarnings("dep-ann")
-    public final void setParserFeature(JsonParser.Feature f, boolean state) {
-        configure(f, state);
-    }
-
-    /**
-     * @deprecated Use {@link #isEnabled(JsonParser.Feature)} instead
-     */
-    @SuppressWarnings("dep-ann")
-    public final boolean isParserFeatureEnabled(JsonParser.Feature f) {
-        return (_parserFeatures & f.getMask()) != 0;
-    }
-
-    /**
-     * Method for getting currently configured input decorator (if any;
-     * there is no default decorator).
-     * 
-     * @since 1.8
-     */
-    public InputDecorator getInputDecorator() {
-        return _inputDecorator;
-    }
-
-    /**
-     * Method for overriding currently configured input decorator
-     * 
-     * @since 1.8
-     */
-    public JsonFactory setInputDecorator(InputDecorator d) {
-        _inputDecorator = d;
-        return this;
-    }
-    
-    /*
-    /**********************************************************
-    /* Configuration, generator settings
-    /**********************************************************
-     */
-
-    /**
-     * Method for enabling or disabling specified generator feature
-     * (check {@link JsonGenerator.Feature} for list of features)
-     *
-     * @since 1.2
-     */
-    public final JsonFactory configure(JsonGenerator.Feature f, boolean state) {
-        if (state) {
-            enable(f);
-        } else {
-            disable(f);
-        }
-        return this;
-    }
-
-
-    /**
-     * Method for enabling specified generator features
-     * (check {@link JsonGenerator.Feature} for list of features)
-     *
-     * @since 1.2
-     */
-    public JsonFactory enable(JsonGenerator.Feature f) {
-        _generatorFeatures |= f.getMask();
-        return this;
-    }
-
-    /**
-     * Method for disabling specified generator feature
-     * (check {@link JsonGenerator.Feature} for list of features)
-     *
-     * @since 1.2
-     */
-    public JsonFactory disable(JsonGenerator.Feature f) {
-        _generatorFeatures &= ~f.getMask();
-        return this;
-    }
-
-    /**
-     * Check whether specified generator feature is enabled.
-     *
-     * @since 1.2
-     */
-    public final boolean isEnabled(JsonGenerator.Feature f) {
-        return (_generatorFeatures & f.getMask()) != 0;
-    }
-
-    // // // Older deprecated (as of 1.2) methods
-
-    /**
-     * @deprecated Use {@link #enable(JsonGenerator.Feature)} instead
-     */
-    @Deprecated
-    public final void enableGeneratorFeature(JsonGenerator.Feature f) {
-        enable(f);
-    }
-
-    /**
-     * @deprecated Use {@link #disable(JsonGenerator.Feature)} instead
-     */
-    @Deprecated
-    public final void disableGeneratorFeature(JsonGenerator.Feature f) {
-        disable(f);
-    }
-
-    /**
-     * @deprecated Use {@link #configure(JsonGenerator.Feature, boolean)} instead
-     */
-    @Deprecated
-    public final void setGeneratorFeature(JsonGenerator.Feature f, boolean state) {
-        configure(f, state);
-    }
-
-    /**
-     * @deprecated Use {@link #isEnabled(JsonGenerator.Feature)} instead
-     */
-    @Deprecated
-    public final boolean isGeneratorFeatureEnabled(JsonGenerator.Feature f) {
-        return isEnabled(f);
-    }
-
-    /**
-     * Method for accessing custom escapes factory uses for {@link JsonGenerator}s
-     * it creates.
-     * 
-     * @since 1.8
-     */
-    public CharacterEscapes getCharacterEscapes() {
-        return _characterEscapes;
-    }
-
-    /**
-     * Method for defining custom escapes factory uses for {@link JsonGenerator}s
-     * it creates.
-     * 
-     * @since 1.8
-     */
-    public JsonFactory setCharacterEscapes(CharacterEscapes esc) {
-        _characterEscapes = esc;
-        return this;
-    }
-
-    /**
-     * Method for getting currently configured output decorator (if any;
-     * there is no default decorator).
-     * 
-     * @since 1.8
-     */
-    public OutputDecorator getOutputDecorator() {
-        return _outputDecorator;
-    }
-
-    /**
-     * Method for overriding currently configured output decorator
-     * 
-     * @since 1.8
-     */
-    public JsonFactory setOutputDecorator(OutputDecorator d) {
-        _outputDecorator = d;
-        return this;
-    }
-    
-    /*
-    /**********************************************************
-    /* Configuration, other
-    /**********************************************************
-     */
-
-    /**
-     * Method for associating a {@link ObjectCodec} (typically
-     * a {@link sh.calaba.org.codehaus.jackson.map.ObjectMapper}) with
-     * this factory (and more importantly, parsers and generators
-     * it constructs). This is needed to use data-binding methods
-     * of {@link JsonParser} and {@link JsonGenerator} instances.
-     */
-    public JsonFactory setCodec(ObjectCodec oc) {
-        _objectCodec = oc;
-        return this;
-    }
-
-    public ObjectCodec getCodec() { return _objectCodec; }
-
-    /*
-    /**********************************************************
-    /* Reader factories
-    /**********************************************************
-     */
-
-    /**
-     * Method for constructing JSON parser instance to parse
-     * contents of specified file. Encoding is auto-detected
-     * from contents according to JSON specification recommended
-     * mechanism.
-     *<p>
-     * Underlying input stream (needed for reading contents)
-     * will be <b>owned</b> (and managed, i.e. closed as need be) by
-     * the parser, since caller has no access to it.
-     *
-     * @param f File that contains JSON content to parse
-     */
-    public JsonParser createJsonParser(File f)
-        throws IOException, JsonParseException
-    {
-        // true, since we create InputStream from File
-        IOContext ctxt = _createContext(f, true);
-        InputStream in = new FileInputStream(f);
-        // [JACKSON-512]: allow wrapping with InputDecorator
-        if (_inputDecorator != null) {
-            in = _inputDecorator.decorate(ctxt, in);
-        }
-        return _createJsonParser(in, ctxt);
-    }
-
-    /**
-     * Method for constructing JSON parser instance to parse
-     * contents of resource reference by given URL.
-     * Encoding is auto-detected
-     * from contents according to JSON specification recommended
-     * mechanism.
-     *<p>
-     * Underlying input stream (needed for reading contents)
-     * will be <b>owned</b> (and managed, i.e. closed as need be) by
-     * the parser, since caller has no access to it.
-     *
-     * @param url URL pointing to resource that contains JSON content to parse
-     */
-    public JsonParser createJsonParser(URL url)
-        throws IOException, JsonParseException
-    {
-        // true, since we create InputStream from URL
-        IOContext ctxt = _createContext(url, true);
-        InputStream in = _optimizedStreamFromURL(url);
-        // [JACKSON-512]: allow wrapping with InputDecorator
-        if (_inputDecorator != null) {
-            in = _inputDecorator.decorate(ctxt, in);
-        }
-        return _createJsonParser(in, ctxt);
-    }
-
-    /**
-     * Method for constructing JSON parser instance to parse
-     * the contents accessed via specified input stream.
-     *<p>
-     * The input stream will <b>not be owned</b> by
-     * the parser, it will still be managed (i.e. closed if
-     * end-of-stream is reacher, or parser close method called)
-     * if (and only if) {@link sh.calaba.org.codehaus.jackson.JsonParser.Feature#AUTO_CLOSE_SOURCE}
-     * is enabled.
-     *<p>
-     * Note: no encoding argument is taken since it can always be
-     * auto-detected as suggested by Json RFC.
-     *
-     * @param in InputStream to use for reading JSON content to parse
-     */
-    public JsonParser createJsonParser(InputStream in)
-        throws IOException, JsonParseException
-    {
-        IOContext ctxt = _createContext(in, false);
-        // [JACKSON-512]: allow wrapping with InputDecorator
-        if (_inputDecorator != null) {
-            in = _inputDecorator.decorate(ctxt, in);
-        }
-        return _createJsonParser(in, ctxt);
-    }
-
-    /**
-     * Method for constructing parser for parsing
-     * the contents accessed via specified Reader.
-     <p>
-     * The read stream will <b>not be owned</b> by
-     * the parser, it will still be managed (i.e. closed if
-     * end-of-stream is reacher, or parser close method called)
-     * if (and only if) {@link sh.calaba.org.codehaus.jackson.JsonParser.Feature#AUTO_CLOSE_SOURCE}
-     * is enabled.
-     *<p>
-     *
-     * @param r Reader to use for reading JSON content to parse
-     */
-    public JsonParser createJsonParser(Reader r)
-        throws IOException, JsonParseException
-    {
-        // false -> we do NOT own Reader (did not create it)
-        IOContext ctxt = _createContext(r, false);
-        // [JACKSON-512]: allow wrapping with InputDecorator
-        if (_inputDecorator != null) {
-            r = _inputDecorator.decorate(ctxt, r);
-        }
-	return _createJsonParser(r, ctxt);
-    }
-
-    /**
-     * Method for constructing parser for parsing
-     * the contents of given byte array.
-     */
-    public JsonParser createJsonParser(byte[] data)
-        throws IOException, JsonParseException
-    {
-        IOContext ctxt = _createContext(data, true);
-        // [JACKSON-512]: allow wrapping with InputDecorator
-        if (_inputDecorator != null) {
-            InputStream in = _inputDecorator.decorate(ctxt, data, 0, data.length);
-            if (in != null) {
-                return _createJsonParser(in, ctxt);
-            }
-        }
-        return _createJsonParser(data, 0, data.length, ctxt);
-    }
-
-    /**
-     * Method for constructing parser for parsing
-     * the contents of given byte array.
-     * 
-     * @param data Buffer that contains data to parse
-     * @param offset Offset of the first data byte within buffer
-     * @param len Length of contents to parse within buffer
-     */
-    public JsonParser createJsonParser(byte[] data, int offset, int len)
-        throws IOException, JsonParseException
-    {
-        IOContext ctxt = _createContext(data, true);
-        // [JACKSON-512]: allow wrapping with InputDecorator
-        if (_inputDecorator != null) {
-            InputStream in = _inputDecorator.decorate(ctxt, data, offset, len);
-            if (in != null) {
-                return _createJsonParser(in, ctxt);
-            }
-        }
-	return _createJsonParser(data, offset, len, ctxt);
-    }
-
-    /**
-     * Method for constructing parser for parsing
-     * contens of given String.
-     */
-    public JsonParser createJsonParser(String content)
-        throws IOException, JsonParseException
-    {
-	Reader r = new StringReader(content);
-        // true -> we own the Reader (and must close); not a big deal
-        IOContext ctxt = _createContext(r, true);
-        // [JACKSON-512]: allow wrapping with InputDecorator
-        if (_inputDecorator != null) {
-            r = _inputDecorator.decorate(ctxt, r);
-        }
-	return _createJsonParser(r, ctxt);
-    }
-
-    /*
-    /**********************************************************
-    /* Generator factories
-    /**********************************************************
-     */
-
-    /**
-     * Method for constructing JSON generator for writing JSON content
-     * using specified output stream.
-     * Encoding to use must be specified, and needs to be one of available
-     * types (as per JSON specification).
-     *<p>
-     * Underlying stream <b>is NOT owned</b> by the generator constructed,
-     * so that generator will NOT close the output stream when
-     * {@link JsonGenerator#close} is called (unless auto-closing
-     * feature,
-     * {@link sh.calaba.org.codehaus.jackson.JsonGenerator.Feature#AUTO_CLOSE_TARGET}
-     * is enabled).
-     * Using application needs to close it explicitly if this is the case.
-     *<p>
-     * Note: there are formats that use fixed encoding (like most binary data formats)
-     * and that ignore passed in encoding.
-     *
-     * @param out OutputStream to use for writing JSON content 
-     * @param enc Character encoding to use
-     */
-    public JsonGenerator createJsonGenerator(OutputStream out, JsonEncoding enc)
-        throws IOException
-    {
-	// false -> we won't manage the stream unless explicitly directed to
-        IOContext ctxt = _createContext(out, false);
-        ctxt.setEncoding(enc);
-        if (enc == JsonEncoding.UTF8) {
-            // [JACKSON-512]: allow wrapping with _outputDecorator
-            if (_outputDecorator != null) {
-                out = _outputDecorator.decorate(ctxt, out);
-            }
-            return _createUTF8JsonGenerator(out, ctxt);
-        }
-        Writer w = _createWriter(out, enc, ctxt);
-        // [JACKSON-512]: allow wrapping with _outputDecorator
-        if (_outputDecorator != null) {
-            w = _outputDecorator.decorate(ctxt, w);
-        }
-	return _createJsonGenerator(w, ctxt);
-    }
-
-    /**
-     * Method for constructing JSON generator for writing JSON content
-     * using specified Writer.
-     *<p>
-     * Underlying stream <b>is NOT owned</b> by the generator constructed,
-     * so that generator will NOT close the Reader when
-     * {@link JsonGenerator#close} is called (unless auto-closing
-     * feature,
-     * {@link sh.calaba.org.codehaus.jackson.JsonGenerator.Feature#AUTO_CLOSE_TARGET} is enabled).
-     * Using application needs to close it explicitly.
-     *
-     * @param out Writer to use for writing JSON content 
-     */
-    public JsonGenerator createJsonGenerator(Writer out)
-        throws IOException
-    {
-        IOContext ctxt = _createContext(out, false);
-        // [JACKSON-512]: allow wrapping with _outputDecorator
-        if (_outputDecorator != null) {
-            out = _outputDecorator.decorate(ctxt, out);
-        }
-	return _createJsonGenerator(out, ctxt);
-    }
-
-    /**
-     * Convenience method for constructing generator that uses default
-     * encoding of the format (UTF-8 for JSON and most other data formats).
-     *<p>
-     * Note: there are formats that use fixed encoding (like most binary data formats).
-     * 
-     * @since 1.8
-     */
-    public JsonGenerator createJsonGenerator(OutputStream out) throws IOException {
-        return createJsonGenerator(out, JsonEncoding.UTF8);
-    }
-    
-    /**
-     * Method for constructing JSON generator for writing JSON content
-     * to specified file, overwriting contents it might have (or creating
-     * it if such file does not yet exist).
-     * Encoding to use must be specified, and needs to be one of available
-     * types (as per JSON specification).
-     *<p>
-     * Underlying stream <b>is owned</b> by the generator constructed,
-     * i.e. generator will handle closing of file when
-     * {@link JsonGenerator#close} is called.
-     *
-     * @param f File to write contents to
-     * @param enc Character encoding to use
-     */
-    public JsonGenerator createJsonGenerator(File f, JsonEncoding enc)
-        throws IOException
-    {
-	OutputStream out = new FileOutputStream(f);
-	// true -> yes, we have to manage the stream since we created it
-        IOContext ctxt = _createContext(out, true);
-        ctxt.setEncoding(enc);
-        if (enc == JsonEncoding.UTF8) {
-            // [JACKSON-512]: allow wrapping with _outputDecorator
-            if (_outputDecorator != null) {
-                out = _outputDecorator.decorate(ctxt, out);
-            }
-            return _createUTF8JsonGenerator(out, ctxt);
-        }
-        Writer w = _createWriter(out, enc, ctxt);
-        // [JACKSON-512]: allow wrapping with _outputDecorator
-        if (_outputDecorator != null) {
-            w = _outputDecorator.decorate(ctxt, w);
-        }
-	return _createJsonGenerator(w, ctxt);
-    }
-
-    /*
-    /**********************************************************
-    /* Factory methods used by factory for creating parser instances,
-    /* overridable by sub-classes
-    /**********************************************************
-     */
-
-    /**
-     * Overridable factory method that actually instantiates desired parser
-     * given {@link InputStream} and context object.
-     *<p>
-     * This method is specifically designed to remain
-     * compatible between minor versions so that sub-classes can count
-     * on it being called as expected. That is, it is part of official
-     * interface from sub-class perspective, although not a public
-     * method available to users of factory implementations.
-     */
-    protected JsonParser _createJsonParser(InputStream in, IOContext ctxt)
-        throws IOException, JsonParseException
-    {
-        return new ByteSourceBootstrapper(ctxt, in).constructParser(_parserFeatures,
-                _objectCodec, _rootByteSymbols, _rootCharSymbols);
-    }
-
-    /**
-     * Overridable factory method that actually instantiates parser
-     * using given {@link Reader} object for reading content.
-     *<p>
-     * This method is specifically designed to remain
-     * compatible between minor versions so that sub-classes can count
-     * on it being called as expected. That is, it is part of official
-     * interface from sub-class perspective, although not a public
-     * method available to users of factory implementations.
-     */
-    protected JsonParser _createJsonParser(Reader r, IOContext ctxt)
-	throws IOException, JsonParseException
-    {
-        return new ReaderBasedParser(ctxt, _parserFeatures, r, _objectCodec,
-                _rootCharSymbols.makeChild(isEnabled(JsonParser.Feature.CANONICALIZE_FIELD_NAMES),
-                    isEnabled(JsonParser.Feature.INTERN_FIELD_NAMES)));
-    }
-
-    /**
-     * Overridable factory method that actually instantiates parser
-     * using given {@link Reader} object for reading content
-     * passed as raw byte array.
-     *<p>
-     * This method is specifically designed to remain
-     * compatible between minor versions so that sub-classes can count
-     * on it being called as expected. That is, it is part of official
-     * interface from sub-class perspective, although not a public
-     * method available to users of factory implementations.
-     */
-    protected JsonParser _createJsonParser(byte[] data, int offset, int len, IOContext ctxt)
-        throws IOException, JsonParseException
-    {
-        return new ByteSourceBootstrapper(ctxt, data, offset, len).constructParser(_parserFeatures,
-                _objectCodec, _rootByteSymbols, _rootCharSymbols);
-    }
-
-    /*
-    /**********************************************************
-    /* Factory methods used by factory for creating generator instances,
-    /* overridable by sub-classes
-    /**********************************************************
-     */
-    
-    /**
-     * Overridable factory method that actually instantiates generator for
-     * given {@link Writer} and context object.
-     *<p>
-     * This method is specifically designed to remain
-     * compatible between minor versions so that sub-classes can count
-     * on it being called as expected. That is, it is part of official
-     * interface from sub-class perspective, although not a public
-     * method available to users of factory implementations.
-     */
-    protected JsonGenerator _createJsonGenerator(Writer out, IOContext ctxt)
-        throws IOException
-    {
-        WriterBasedGenerator gen = new WriterBasedGenerator(ctxt, _generatorFeatures, _objectCodec, out);
-        if (_characterEscapes != null) {
-            gen.setCharacterEscapes(_characterEscapes);
-        }
-        return gen;
-    }
-
-    /**
-     * Overridable factory method that actually instantiates generator for
-     * given {@link OutputStream} and context object, using UTF-8 encoding.
-     *<p>
-     * This method is specifically designed to remain
-     * compatible between minor versions so that sub-classes can count
-     * on it being called as expected. That is, it is part of official
-     * interface from sub-class perspective, although not a public
-     * method available to users of factory implementations.
-     */
-    protected JsonGenerator _createUTF8JsonGenerator(OutputStream out, IOContext ctxt)
-        throws IOException
-    {
-        Utf8Generator gen = new Utf8Generator(ctxt, _generatorFeatures, _objectCodec, out);
-        if (_characterEscapes != null) {
-            gen.setCharacterEscapes(_characterEscapes);
-        }
-        return gen;
-    }
-
-    protected Writer _createWriter(OutputStream out, JsonEncoding enc, IOContext ctxt) throws IOException
-    {
-        // note: this should not get called any more (caller checks, dispatches)
-        if (enc == JsonEncoding.UTF8) { // We have optimized writer for UTF-8
-            return new UTF8Writer(ctxt, out);
-        }
-        // not optimal, but should do unless we really care about UTF-16/32 encoding speed
-        return new OutputStreamWriter(out, enc.getJavaName());
-    }
-    
-    /*
-    /**********************************************************
-    /* Internal factory methods, other
-    /**********************************************************
-     */
-
-    /**
-     * Overridable factory method that actually instantiates desired
-     * context object.
-     */
-    protected IOContext _createContext(Object srcRef, boolean resourceManaged)
-    {
-        return new IOContext(_getBufferRecycler(), srcRef, resourceManaged);
-    }
-
-    /**
-     * Method used by factory to create buffer recycler instances
-     * for parsers and generators.
-     *<p>
-     * Note: only public to give access for <code>ObjectMapper</code>
-     */
-    public BufferRecycler _getBufferRecycler()
-    {
-        SoftReference<BufferRecycler> ref = _recyclerRef.get();
-        BufferRecycler br = (ref == null) ? null : ref.get();
-
-        if (br == null) {
-            br = new BufferRecycler();
-            _recyclerRef.set(new SoftReference<BufferRecycler>(br));
-        }
-        return br;
-    }
-    
-    /**
-     * Helper methods used for constructing an optimal stream for
-     * parsers to use, when input is to be read from an URL.
-     * This helps when reading file content via URL.
-     */
-    protected InputStream _optimizedStreamFromURL(URL url)
-        throws IOException
-    {
-        if ("file".equals(url.getProtocol())) {
-            /* Can not do this if the path refers
-             * to a network drive on windows. This fixes the problem;
-             * might not be needed on all platforms (NFS?), but should not
-             * matter a lot: performance penalty of extra wrapping is more
-             * relevant when accessing local file system.
-             */
-            String host = url.getHost();
-            if (host == null || host.length() == 0) {
-                return new FileInputStream(url.getPath());
-            }
-        }
-        return url.openStream();
-    }
-}