calabash-android 0.0.1

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

@@ -0,0 +1,90 @@
+/* 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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,937 @@
+/* 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();
+    }
+}