calabash-android 0.4.7.pre4 → 0.4.7.pre6

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

@@ -1,58 +0,0 @@
-package sh.calaba.org.codehaus.jackson.node;
-
-import java.io.IOException;
-
-import sh.calaba.org.codehaus.jackson.JsonGenerator;
-import sh.calaba.org.codehaus.jackson.JsonNode;
-import sh.calaba.org.codehaus.jackson.JsonProcessingException;
-import sh.calaba.org.codehaus.jackson.JsonToken;
-import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
-import sh.calaba.org.codehaus.jackson.map.TypeSerializer;
-
-/**
- * This intermediate base class is used for all leaf nodes, that is,
- * all non-container (array or object) nodes, except for the
- * "missing node".
- */
-public abstract class ValueNode
-    extends BaseJsonNode
-{
-    protected ValueNode() { }
-
-    @Override
-    public boolean isValueNode() { return true; }
-
-    @Override
-    public abstract JsonToken asToken();
-
-    @Override
-    public void serializeWithType(JsonGenerator jg, SerializerProvider provider,
-            TypeSerializer typeSer)
-        throws IOException, JsonProcessingException
-    {
-        typeSer.writeTypePrefixForScalar(this, jg);
-        serialize(jg, provider);
-        typeSer.writeTypeSuffixForScalar(this, jg);
-    }
-    
-    /*
-    /**********************************************************************
-    /* Public API, path handling
-    /**********************************************************************
-     */
-
-    @Override
-    public JsonNode path(String fieldName) { return MissingNode.getInstance(); }
-
-    @Override
-    public JsonNode path(int index) { return MissingNode.getInstance(); }
-
-    /*
-    /**********************************************************************
-    /* Base impls for standard methods
-    /**********************************************************************
-     */
-
-    @Override
-    public String toString() { return asText(); }
-}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/node/package-info.java

@@ -1,8 +0,0 @@
-/**
- * Contains concrete {@link sh.calaba.org.codehaus.jackson.JsonNode} implementations
- * Jackson uses for the Tree model.
- * These classes are public since concrete type will be needed
- * for most operations that modify node trees. For read-only access concrete
- * types are usually not needed.
- */
-package sh.calaba.org.codehaus.jackson.node;

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

@@ -1,30 +0,0 @@
-/**
- * Main public API classes of the core streaming JSON
- * processor: most importantly {@link sh.calaba.org.codehaus.jackson.JsonFactory}
- * used for constructing
- * JSON parser ({@link sh.calaba.org.codehaus.jackson.JsonParser})
- * and generator
- * ({@link sh.calaba.org.codehaus.jackson.JsonParser})
- * instances.
- * <p>
- * Public API of the higher-level mapping interfaces ("Mapping API")
- * is found from
- * under {@link sh.calaba.org.codehaus.jackson.map} and not included here,
- * except for following base interfaces:
- * <ul>
- *<li>{@link sh.calaba.org.codehaus.jackson.JsonNode} 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 sh.calaba.org.codehaus.jackson.ObjectCodec} is included so that
- *  reference to the object capable of serializing/deserializing
- *  Objects to/from JSON (usually, {@link sh.calaba.org.codehaus.jackson.map.ObjectMapper})
- *  can be exposed, without adding direct dependency to implementation.
- *  </li>
- *</ul>
- * </ul>
- */
-
-package sh.calaba.org.codehaus.jackson;

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

@@ -1,82 +0,0 @@
-package sh.calaba.org.codehaus.jackson.schema;
-
-import sh.calaba.org.codehaus.jackson.JsonNode;
-import sh.calaba.org.codehaus.jackson.annotate.JsonCreator;
-import sh.calaba.org.codehaus.jackson.annotate.JsonValue;
-import sh.calaba.org.codehaus.jackson.node.JsonNodeFactory;
-import sh.calaba.org.codehaus.jackson.node.ObjectNode;
-
-/**
- * A {@link sh.calaba.org.codehaus.jackson.JsonNode} that represents a JSON-Schema instance.
- *
- * @author Ryan Heaton
- * @see <a href="http://json-schema.org/">JSON Schema</a>
- */
-public class JsonSchema
-{
-    private final ObjectNode schema;
-
-    /**
-     * Main constructor for schema instances.
-     *<p>
-     * This is the creator constructor used by Jackson itself when
-     * deserializing instances. It is so-called delegating creator, 
-     * meaning that its argument will be bound by Jackson before
-     * constructor gets called.
-     */
-    @JsonCreator
-    public JsonSchema(ObjectNode schema)
-    {
-        this.schema = schema;
-    }
-
-    /**
-     * Method for accessing root JSON object of the contained schema.
-     *<p>
-     * Note: this method is specified with {@link JsonValue} annotation
-     * to represent serialization to use; same as if explicitly
-     * serializing returned object.
-     *
-     * @return Root node of the schema tree
-     */
-    @JsonValue
-    public ObjectNode getSchemaNode()
-    {
-        return schema;
-    }
-
-    @Override
-    public String toString()
-    {
-        return this.schema.toString();
-    }
-
-    @Override
-    public boolean equals(Object o)
-    {
-        if (o == this) return true;
-        if (o == null) return false;
-        if (!(o instanceof JsonSchema)) return false;
-
-        JsonSchema other = (JsonSchema) o;
-        if (schema == null) {
-            return other.schema == null;
-        }
-        return schema.equals(other.schema);
-    }
-
-    /**
-     * Get the default schema node.
-     *
-     * @return The default schema node.
-     */
-    public static JsonNode getDefaultSchemaNode()
-    {
-        ObjectNode objectNode = JsonNodeFactory.instance.objectNode();
-        objectNode.put("type", "any");
-        // "required" is false by default, no need to include
-        //objectNode.put("required", false);
-        return objectNode;
-    }
-
-}

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

@@ -1,46 +0,0 @@
-package sh.calaba.org.codehaus.jackson.schema;
-
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Retention;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Target;
-
-import sh.calaba.org.codehaus.jackson.annotate.JacksonAnnotation;
-
-/**
- * Annotation that can be used to define JSON Schema definition for
- * the annotated class.
- *<p>
- * Note that annotation is often not needed: for example, regular
- * Jackson beans that Jackson can introspect can be used without
- * annotations, to produce JSON schema definition.
- * 
- * @author Ryan Heaton
- */
-@Target(ElementType.TYPE)
-@Retention(RetentionPolicy.RUNTIME)
-@JacksonAnnotation
-public @interface JsonSerializableSchema
-{
-    /**
-     * The schema type for this JsonSerializable instance.
-     * Possible values: "string", "number", "boolean", "object", "array", "null", "any"
-     *
-     * @return The schema type for this JsonSerializable instance.
-     */
-    String schemaType() default "any";
-
-    /**
-     * If the schema type is "object", the node that defines the properties of the object.
-     *
-     * @return The node representing the schema properties, or "##irrelevant" if irrelevant.
-     */
-    String schemaObjectPropertiesDefinition() default "##irrelevant";
-
-    /**
-     * If the schema type if "array", the node that defines the schema for the items in the array.
-     *
-     * @return The schema for the items in the array, or "##irrelevant" if irrelevant.
-     */
-    String schemaItemDefinition() default "##irrelevant";
-}

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

@@ -1,25 +0,0 @@
-package sh.calaba.org.codehaus.jackson.schema;
-
-import sh.calaba.org.codehaus.jackson.JsonNode;
-import sh.calaba.org.codehaus.jackson.map.JsonMappingException;
-import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
-
-import java.lang.reflect.Type;
-
-/**
- * Marker interface for schema-aware serializers.
- *
- * @author Ryan Heaton
- */
-public interface SchemaAware
-{
-    /**
-     * Get the representation of the schema to which this serializer will conform.
-     *
-     * @param provider The serializer provider.
-     * @param typeHint A hint about the type.
-     * @return <a href="http://json-schema.org/">Json-schema</a> for this serializer.
-     */
-    JsonNode getSchema(SerializerProvider provider, Type typeHint)
-            throws JsonMappingException;
-}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/schema/package-info.java

@@ -1,5 +0,0 @@
-/**
- * Classes needed for JSON schema support (currently just ability
- * to generate schemas using serialization part of data mapping)
- */
-package sh.calaba.org.codehaus.jackson.schema;

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

@@ -1,969 +0,0 @@
-package sh.calaba.org.codehaus.jackson.sym;
-
-import java.util.Arrays;
-
-import sh.calaba.org.codehaus.jackson.util.InternCache;
-
-/**
- * This class is basically a caching symbol table implementation used for
- * canonicalizing {@link Name}s, constructed directly from a byte-based
- * input source.
- *
- * @author Tatu Saloranta
- */
-public final class BytesToNameCanonicalizer
-{
-    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.
-     * 
-     * @since 1.5
-     */
-    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 = 6000;
-
-    final static int MIN_HASH_SIZE = 16;
-
-    final static int INITIAL_COLLISION_LEN = 32;
-
-    /**
-     * Bucket index is 8 bits, and value 0 is reserved to represent
-     * 'empty' status.
-     */
-    final static int LAST_VALID_BUCKET = 0xFE;
-    
-    /*
-    /**********************************************************
-    /* Linkage, needed for merging symbol tables
-    /**********************************************************
-     */
-
-    final BytesToNameCanonicalizer _parent;
-
-    /*
-    /**********************************************************
-    /* Main table state
-    /**********************************************************
-     */
-
-    /**
-     * Whether canonial symbol Strings are to be intern()ed before added
-     * to the table or not
-     */
-    final boolean _intern;
-    
-    // // // First, global information
-
-    /**
-     * Total number of Names in the symbol table
-     */
-    private int _count;
-
-    // // // Then information regarding primary hash array and its
-    // // // matching Name array
-
-    /**
-     * Mask used to truncate 32-bit hash value to current hash array
-     * size; essentially, hash array size - 1 (since hash array sizes
-     * are 2^N).
-     */
-    private int _mainHashMask;
-
-    /**
-     * Array of 2^N size, which contains combination
-     * of 24-bits of hash (0 to indicate 'empty' slot),
-     * and 8-bit collision bucket index (0 to indicate empty
-     * collision bucket chain; otherwise subtract one from index)
-     */
-    private int[] _mainHash;
-
-    /**
-     * Array that contains <code>Name</code> instances matching
-     * entries in <code>_mainHash</code>. Contains nulls for unused
-     * entries.
-     */
-    private Name[] _mainNames;
-
-    // // // Then the collision/spill-over area info
-
-    /**
-     * Array of heads of collision bucket chains; size dynamically
-     */
-    private Bucket[] _collList;
-
-    /**
-     * Total number of Names in collision buckets (included in
-     * <code>_count</code> along with primary entries)
-     */
-    private int _collCount;
-
-    /**
-     * Index of the first unused collision bucket entry (== size of
-     * the used portion of collision list): less than
-     * or equal to 0xFF (255), since max number of entries is 255
-     * (8-bit, minus 0 used as 'empty' marker)
-     */
-    private int _collEnd;
-
-    // // // Info regarding pending rehashing...
-
-    /**
-     * This flag is set if, after adding a new entry, it is deemed
-     * that a rehash is warranted if any more entries are to be added.
-     */
-    private transient boolean _needRehash;
-
-    /*
-    /**********************************************************
-    /* Sharing, versioning
-    /**********************************************************
-     */
-
-    // // // Which of the buffers may be shared (and are copy-on-write)?
-
-    /**
-     * Flag that indicates whether underlying data structures for
-     * the main hash area are shared or not. If they are, then they
-     * need to be handled in copy-on-write way, i.e. if they need
-     * to be modified, a copy needs to be made first; at this point
-     * it will not be shared any more, and can be modified.
-     *<p>
-     * This flag needs to be checked both when adding new main entries,
-     * and when adding new collision list queues (i.e. creating a new
-     * collision list head entry)
-     */
-    private boolean _mainHashShared;
-
-    private boolean _mainNamesShared;
-
-    /**
-     * Flag that indicates whether underlying data structures for
-     * the collision list are shared or not. If they are, then they
-     * need to be handled in copy-on-write way, i.e. if they need
-     * to be modified, a copy needs to be made first; at this point
-     * it will not be shared any more, and can be modified.
-     *<p>
-     * This flag needs to be checked when adding new collision entries.
-     */
-    private boolean _collListShared;
-
-    /*
-    /**********************************************************
-    /* Construction, merging
-    /**********************************************************
-     */
-
-    public static BytesToNameCanonicalizer createRoot()
-    {
-        return new BytesToNameCanonicalizer(DEFAULT_TABLE_SIZE, true);
-    }
-
-    /**
-     * @param intern Whether canonical symbol Strings should be interned
-     *   or not
-     */
-    public synchronized BytesToNameCanonicalizer makeChild(boolean canonicalize,
-        boolean intern)
-    {
-        return new BytesToNameCanonicalizer(this, intern);
-    }
-
-    /**
-     * Method called by the using code to indicate it is done
-     * with this instance. This lets instance merge accumulated
-     * changes into parent (if need be), safely and efficiently,
-     * and without calling code having to know about parent
-     * information
-     */
-    public void release()
-    {
-        if (maybeDirty() && _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.
-             */
-            markAsShared();
-        }
-    }
-
-    private BytesToNameCanonicalizer(int hashSize, boolean intern)
-    {
-        _parent = null;
-        _intern = intern;
-        /* Sanity check: let's now allow hash sizes below certain
-         * min. value
-         */
-        if (hashSize < MIN_HASH_SIZE) {
-            hashSize = MIN_HASH_SIZE;
-        } else {
-            /* Also; size must be 2^N; otherwise hash algorithm won't
-             * work... so let's just pad it up, if so
-             */
-            if ((hashSize & (hashSize - 1)) != 0) { // only true if it's 2^N
-                int curr = MIN_HASH_SIZE;
-                while (curr < hashSize) {
-                    curr += curr;
-                }
-                hashSize = curr;
-            }
-        }
-        initTables(hashSize);
-    }
-
-    /**
-     * Constructor used when creating a child instance
-     */
-    private BytesToNameCanonicalizer(BytesToNameCanonicalizer parent, boolean intern)
-    {
-        _parent = parent;
-        _intern = intern;
-
-        // First, let's copy the state as is:
-        _count = parent._count;
-        _mainHashMask = parent._mainHashMask;
-        _mainHash = parent._mainHash;
-        _mainNames = parent._mainNames;
-        _collList = parent._collList;
-        _collCount = parent._collCount;
-        _collEnd = parent._collEnd;
-        _needRehash = false;
-        // And consider all shared, so far:
-        _mainHashShared = true;
-        _mainNamesShared = true;
-        _collListShared = true;
-    }
-
-    private void initTables(int hashSize)
-    {
-        _count = 0;
-        _mainHash = new int[hashSize];
-        _mainNames = new Name[hashSize];
-        _mainHashShared = false;
-        _mainNamesShared = false;
-        _mainHashMask = hashSize - 1;
-
-        _collListShared = true; // just since it'll need to be allocated
-        _collList = null;
-        _collEnd = 0;
-
-        _needRehash = false;
-    }
-
-    private synchronized void mergeChild(BytesToNameCanonicalizer child)
-    {
-        // Only makes sense if child has more entries
-        int childCount = child._count;
-        if (childCount <= _count) {
-            return;
-        }
-
-        /* 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) {
-            /* 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:
-            initTables(DEFAULT_TABLE_SIZE);
-        } else {
-            _count = child._count;
-            _mainHash = child._mainHash;
-            _mainNames = child._mainNames;
-            _mainHashShared = true; // shouldn't matter for parent
-            _mainNamesShared = true; // - "" -
-            _mainHashMask = child._mainHashMask;
-            _collList = child._collList;
-            _collCount = child._collCount;
-            _collEnd = child._collEnd;
-        }
-    }
-
-    private void markAsShared()
-    {
-        _mainHashShared = true;
-        _mainNamesShared = true;
-        _collListShared = true;
-    }
-
-    /*
-    /**********************************************************
-    /* API, accessors
-    /**********************************************************
-     */
-
-    public int size() { return _count; }
-
-    /**
-     * Method called to check to quickly see if a child symbol table
-     * may have gotten additional entries. Used for checking to see
-     * if a child table should be merged into shared table.
-     */
-    public boolean maybeDirty()
-    {
-        return !_mainHashShared;
-    }
-
-    public static Name getEmptyName()
-    {
-        return Name1.getEmptyName();
-    }
-
-    /**
-     * Finds and returns name matching the specified symbol, if such
-     * name already exists in the table.
-     * If not, will return null.
-     *<p>
-     * Note: separate methods to optimize common case of
-     * short element/attribute names (4 or less ascii characters)
-     *
-     * @param firstQuad int32 containing first 4 bytes of the name;
-     *   if the whole name less than 4 bytes, padded with zero bytes
-     *   in front (zero MSBs, ie. right aligned)
-     *
-     * @return Name matching the symbol passed (or constructed for
-     *   it)
-     */
-    public Name findName(int firstQuad)
-    {
-        int hash = calcHash(firstQuad);
-        int ix = (hash & _mainHashMask);
-        int val = _mainHash[ix];
-        
-        /* High 24 bits of the value are low 24 bits of hash (low 8 bits
-         * are bucket index)... match?
-         */
-        if ((((val >> 8) ^ hash) << 8) == 0) { // match
-            // Ok, but do we have an actual match?
-            Name name = _mainNames[ix];
-            if (name == null) { // main slot empty; can't find
-                return null;
-            }
-            if (name.equals(firstQuad)) {
-                return name;
-            }
-        } else if (val == 0) { // empty slot? no match
-            return null;
-        }
-        // Maybe a spill-over?
-        val &= 0xFF;
-        if (val > 0) { // 0 means 'empty'
-            val -= 1; // to convert from 1-based to 0...
-            Bucket bucket = _collList[val];
-            if (bucket != null) {
-                return bucket.find(hash, firstQuad, 0);
-            }
-        }
-        // Nope, no match whatsoever
-        return null;
-    }
-
-    /**
-     * Finds and returns name matching the specified symbol, if such
-     * name already exists in the table.
-     * If not, will return null.
-     *<p>
-     * Note: separate methods to optimize common case of relatively
-     * short element/attribute names (8 or less ascii characters)
-     *
-     * @param firstQuad int32 containing first 4 bytes of the name.
-     * @param secondQuad int32 containing bytes 5 through 8 of the
-     *   name; if less than 8 bytes, padded with up to 3 zero bytes
-     *   in front (zero MSBs, ie. right aligned)
-     *
-     * @return Name matching the symbol passed (or constructed for
-     *   it)
-     */
-    public Name findName(int firstQuad, int secondQuad)
-    {
-        int hash = calcHash(firstQuad, secondQuad);
-        int ix = (hash & _mainHashMask);
-        int val = _mainHash[ix];
-        
-        /* High 24 bits of the value are low 24 bits of hash (low 8 bits
-         * are bucket index)... match?
-         */
-        if ((((val >> 8) ^ hash) << 8) == 0) { // match
-            // Ok, but do we have an actual match?
-            Name name = _mainNames[ix];
-            if (name == null) { // main slot empty; can't find
-                return null;
-            }
-            if (name.equals(firstQuad, secondQuad)) {
-                return name;
-            }
-        } else if (val == 0) { // empty slot? no match
-            return null;
-        }
-        // Maybe a spill-over?
-        val &= 0xFF;
-        if (val > 0) { // 0 means 'empty'
-            val -= 1; // to convert from 1-based to 0...
-            Bucket bucket = _collList[val];
-            if (bucket != null) {
-                return bucket.find(hash, firstQuad, secondQuad);
-            }
-        }
-        // Nope, no match whatsoever
-        return null;
-    }
-
-    /**
-     * Finds and returns name matching the specified symbol, if such
-     * name already exists in the table; or if not, creates name object,
-     * adds to the table, and returns it.
-     *<p>
-     * Note: this is the general purpose method that can be called for
-     * names of any length. However, if name is less than 9 bytes long,
-     * it is preferable to call the version optimized for short
-     * names.
-     *
-     * @param quads Array of int32s, each of which contain 4 bytes of
-     *   encoded name
-     * @param qlen Number of int32s, starting from index 0, in quads
-     *   parameter
-     *
-     * @return Name matching the symbol passed (or constructed for it)
-     */
-    public Name findName(int[] quads, int qlen)
-    {
-        /* // Not needed, never gets called
-        if (qlen < 3) { // another sanity check
-            return findName(quads[0], (qlen < 2) ? 0 : quads[1]);
-        }
-        */
-        int hash = calcHash(quads, qlen);
-        // (for rest of comments regarding logic, see method above)
-        int ix = (hash & _mainHashMask);
-        int val = _mainHash[ix];
-        if ((((val >> 8) ^ hash) << 8) == 0) {
-            Name name = _mainNames[ix];
-            if (name == null // main slot empty; no collision list then either
-                || name.equals(quads, qlen)) { // should be match, let's verify
-                return name;
-            }
-        } else if (val == 0) { // empty slot? no match
-            return null;
-        }
-        val &= 0xFF;
-        if (val > 0) { // 0 means 'empty'
-            val -= 1; // to convert from 1-based to 0...
-            Bucket bucket = _collList[val];
-            if (bucket != null) {
-                return bucket.find(hash, quads, qlen);
-            }
-        }
-        return null;
-    }
-
-    /*
-    /**********************************************************
-    /* API, mutators
-    /**********************************************************
-     */
-
-    /**
-     * @since 1.6.0
-     */
-    public Name addName(String symbolStr, int q1, int q2)
-    {
-        if (_intern) {
-            symbolStr = InternCache.instance.intern(symbolStr);
-        }
-        int hash = (q2 == 0) ? calcHash(q1) : calcHash(q1, q2);
-        Name symbol = constructName(hash, symbolStr, q1, q2);
-        _addSymbol(hash, symbol);
-        return symbol;
-    }
-    
-    public Name addName(String symbolStr, int[] quads, int qlen)
-    {
-        if (_intern) {
-            symbolStr = InternCache.instance.intern(symbolStr);
-        }
-        int hash = calcHash(quads, qlen);
-        Name symbol = constructName(hash, symbolStr, quads, qlen);
-        _addSymbol(hash, symbol);
-        return symbol;
-    }
-    
-    /*
-    /**********************************************************
-    /* Helper methods
-    /**********************************************************
-     */
-
-    public final static int calcHash(int firstQuad)
-    {
-        int hash = firstQuad;
-        hash ^= (hash >>> 16); // to xor hi- and low- 16-bits
-        hash ^= (hash >>> 8); // as well as lowest 2 bytes
-        return hash;
-    }
-
-    public final static int calcHash(int firstQuad, int secondQuad)
-    {
-        int hash = (firstQuad * 31) + secondQuad;
-
-        // If this was called for single-quad instance:
-        //int hash = (secondQuad == 0) ? firstQuad : ((firstQuad * 31) + secondQuad);
-
-        hash ^= (hash >>> 16); // to xor hi- and low- 16-bits
-        hash ^= (hash >>> 8); // as well as lowest 2 bytes
-        return hash;
-    }
-
-    public final static int calcHash(int[] quads, int qlen)
-    {
-        // Note: may be called for qlen < 3
-        int hash = quads[0];
-        for (int i = 1; i < qlen; ++i) {
-            hash = (hash * 31) + quads[i];
-        }
-
-        hash ^= (hash >>> 16); // to xor hi- and low- 16-bits
-        hash ^= (hash >>> 8); // as well as lowest 2 bytes
-
-        return hash;
-    }
-
-    /* 26-Nov-2008, tatu: not used currently; if not used in near future,
-     *   let's just delete it.
-     */
-    /*
-    public static int[] calcQuads(byte[] wordBytes)
-    {
-        int blen = wordBytes.length;
-        int[] result = new int[(blen + 3) / 4];
-        for (int i = 0; i < blen; ++i) {
-            int x = wordBytes[i] & 0xFF;
-
-            if (++i < blen) {
-                x = (x << 8) | (wordBytes[i] & 0xFF);
-                if (++i < blen) {
-                    x = (x << 8) | (wordBytes[i] & 0xFF);
-                    if (++i < blen) {
-                        x = (x << 8) | (wordBytes[i] & 0xFF);
-                    }
-                }
-            }
-            result[i >> 2] = x;
-        }
-        return result;
-    }
-    */
-
-    /*
-    /**********************************************************
-    /* Standard methods
-    /**********************************************************
-     */
-
-    /*
-    @Override
-    public String toString()
-    {
-        StringBuilder sb = new StringBuilder();
-        sb.append("[BytesToNameCanonicalizer, size: ");
-        sb.append(_count);
-        sb.append('/');
-        sb.append(_mainHash.length);
-        sb.append(", ");
-        sb.append(_collCount);
-        sb.append(" coll; avg length: ");
-
-        // Average length: minimum of 1 for all (1 == primary hit);
-        // and then 1 per each traversal for collisions/buckets
-        //int maxDist = 1;
-        int pathCount = _count;
-        for (int i = 0; i < _collEnd; ++i) {
-            int spillLen = _collList[i].length();
-            for (int j = 1; j <= spillLen; ++j) {
-                pathCount += j;
-            }
-        }
-        double avgLength;
-
-        if (_count == 0) {
-            avgLength = 0.0;
-        } else {
-            avgLength = (double) pathCount / (double) _count;
-        }
-        // let's round up a bit (two 2 decimal places)
-        //avgLength -= (avgLength % 0.01);
-
-        sb.append(avgLength);
-        sb.append(']');
-        return sb.toString();
-    }
-    */
-
-    /*
-    /**********************************************************
-    /* Internal methods
-    /**********************************************************
-     */
-
-    private void _addSymbol(int hash, Name symbol)
-    {
-        if (_mainHashShared) { // always have to modify main entry
-            unshareMain();
-        }
-        // First, do we need to rehash?
-        if (_needRehash) {
-            rehash();
-        }
-
-        ++_count;
-
-        /* Ok, enough about set up: now we need to find the slot to add
-         * symbol in:
-         */
-        int ix = (hash & _mainHashMask);
-        if (_mainNames[ix] == null) { // primary empty?
-            _mainHash[ix] = (hash << 8);
-            if (_mainNamesShared) {
-                unshareNames();
-            }
-            _mainNames[ix] = symbol;
-        } else { // nope, it's a collision, need to spill over
-            /* How about spill-over area... do we already know the bucket
-             * (is the case if it's not the first collision)
-             */
-            if (_collListShared) {
-                unshareCollision(); // also allocates if list was null
-            }
-
-            ++_collCount;
-            int entryValue = _mainHash[ix];
-            int bucket = entryValue & 0xFF;
-            if (bucket == 0) { // first spill over?
-                if (_collEnd <= LAST_VALID_BUCKET) { // yup, still unshared bucket
-                    bucket = _collEnd;
-                    ++_collEnd;
-                    // need to expand?
-                    if (bucket >= _collList.length) {
-                        expandCollision();
-                    }
-                } else { // nope, have to share... let's find shortest?
-                    bucket = findBestBucket();
-                }
-                // Need to mark the entry... and the spill index is 1-based
-                _mainHash[ix] = (entryValue & ~0xFF) | (bucket + 1);
-            } else {
-                --bucket; // 1-based index in value
-            }
-            
-            // And then just need to link the new bucket entry in
-            _collList[bucket] = new Bucket(symbol, _collList[bucket]);
-        }
-
-        /* Ok. Now, do we need a rehash next time? Need to have at least
-         * 50% fill rate no matter what:
-         */
-        {
-            int hashSize = _mainHash.length;
-            if (_count > (hashSize >> 1)) {
-                int hashQuarter = (hashSize >> 2);
-                /* And either strictly above 75% (the usual) or
-                 * just 50%, and collision count >= 25% of total hash size
-                 */
-                if (_count > (hashSize - hashQuarter)) {
-                    _needRehash = true;
-                } else if (_collCount >= hashQuarter) {
-                    _needRehash = true;
-                }
-            }
-        }
-    }
-
-    private void rehash()
-    {
-        _needRehash = false;        
-        // Note: since we'll make copies, no need to unshare, can just mark as such:
-        _mainNamesShared = false;
-
-        /* And then we can first deal with the main hash area. Since we
-         * are expanding linearly (double up), we know there'll be no
-         * collisions during this phase.
-         */
-        int[] oldMainHash = _mainHash;
-        int len = oldMainHash.length;
-        int newLen = len+len;
-
-        /* 13-Mar-2010, tatu: Let's guard against OOME that could be caused by
-         *    large documents with unique (or mostly so) names
-         */
-        if (newLen > MAX_TABLE_SIZE) {
-            nukeSymbols();
-            return;
-        }
-        
-        _mainHash = new int[newLen];
-        _mainHashMask = (newLen - 1);
-        Name[] oldNames = _mainNames;
-        _mainNames = new Name[newLen];
-        int symbolsSeen = 0; // let's do a sanity check
-        for (int i = 0; i < len; ++i) {
-            Name symbol = oldNames[i];
-            if (symbol != null) {
-                ++symbolsSeen;
-                int hash = symbol.hashCode();
-                int ix = (hash & _mainHashMask);
-                _mainNames[ix] = symbol;
-                _mainHash[ix] = hash << 8; // will clear spill index
-            }
-        }
-
-        /* And then the spill area. This may cause collisions, although
-         * not necessarily as many as there were earlier. Let's allocate
-         * same amount of space, however
-         */
-        int oldEnd = _collEnd;
-        if (oldEnd == 0) { // no prior collisions...
-            return;
-        }
-
-        _collCount = 0;
-        _collEnd = 0;
-        _collListShared = false;
-
-        Bucket[] oldBuckets = _collList;
-        _collList = new Bucket[oldBuckets.length];
-        for (int i = 0; i < oldEnd; ++i) {
-            for (Bucket curr = oldBuckets[i]; curr != null; curr = curr._next) {
-                ++symbolsSeen;
-                Name symbol = curr._name;
-                int hash = symbol.hashCode();
-                int ix = (hash & _mainHashMask);
-                int val = _mainHash[ix];
-                if (_mainNames[ix] == null) { // no primary entry?
-                    _mainHash[ix] = (hash << 8);
-                    _mainNames[ix] = symbol;
-                } else { // nope, it's a collision, need to spill over
-                    ++_collCount;
-                    int bucket = val & 0xFF;
-                    if (bucket == 0) { // first spill over?
-                        if (_collEnd <= LAST_VALID_BUCKET) { // yup, still unshared bucket
-                            bucket = _collEnd;
-                            ++_collEnd;
-                            // need to expand?
-                            if (bucket >= _collList.length) {
-                                expandCollision();
-                            }
-                        } else { // nope, have to share... let's find shortest?
-                            bucket = findBestBucket();
-                        }
-                        // Need to mark the entry... and the spill index is 1-based
-                        _mainHash[ix] = (val & ~0xFF) | (bucket + 1);
-                    } else {
-                        --bucket; // 1-based index in value
-                    }
-                    // And then just need to link the new bucket entry in
-                    _collList[bucket] = new Bucket(symbol, _collList[bucket]);
-                }
-            } // for (... buckets in the chain ...)
-        } // for (... list of bucket heads ... )
-
-        if (symbolsSeen != _count) { // sanity check
-            throw new RuntimeException("Internal error: count after rehash "+symbolsSeen+"; should be "+_count);
-        }
-    }
-
-    /**
-     * Helper method called to empty all shared symbols, but to leave
-     * arrays allocated
-     */
-    private void nukeSymbols()
-    {
-        _count = 0;
-        Arrays.fill(_mainHash, 0);
-        Arrays.fill(_mainNames, null);
-        Arrays.fill(_collList, null);
-        _collCount = 0;
-        _collEnd = 0;
-    }
-    
-    /**
-     * Method called to find the best bucket to spill a Name over to:
-     * usually the first bucket that has only one entry, but in general
-     * first one of the buckets with least number of entries
-     */
-    private int findBestBucket()
-    {
-        Bucket[] buckets = _collList;
-        int bestCount = Integer.MAX_VALUE;
-        int bestIx = -1;
-
-        for (int i = 0, len = _collEnd; i < len; ++i) {
-            int count = buckets[i].length();
-            if (count < bestCount) {
-                if (count == 1) { // best possible
-                    return i;
-                }
-                bestCount = count;
-                bestIx = i;
-            }
-        }
-        return bestIx;
-    }
-
-    /**
-     * Method that needs to be called, if the main hash structure
-     * is (may be) shared. This happens every time something is added,
-     * even if addition is to the collision list (since collision list
-     * index comes from lowest 8 bits of the primary hash entry)
-     */
-    private void unshareMain()
-    {
-        int[] old = _mainHash;
-        int len = _mainHash.length;
-
-        _mainHash = new int[len];
-        System.arraycopy(old, 0, _mainHash, 0, len);
-        _mainHashShared = false;
-    }
-
-    private void unshareCollision()
-    {
-        Bucket[] old = _collList;
-        if (old == null) {
-            _collList = new Bucket[INITIAL_COLLISION_LEN];
-        } else {
-            int len = old.length;
-            _collList = new Bucket[len];
-            System.arraycopy(old, 0, _collList, 0, len);
-        }
-        _collListShared = false;
-    }
-
-    private void unshareNames()
-    {
-        Name[] old = _mainNames;
-        int len = old.length;
-        _mainNames = new Name[len];
-        System.arraycopy(old, 0, _mainNames, 0, len);
-        _mainNamesShared = false;
-    }
-
-    private void expandCollision()
-    {
-        Bucket[] old = _collList;
-        int len = old.length;
-        _collList = new Bucket[len+len];
-        System.arraycopy(old, 0, _collList, 0, len);
-    }
-
-
-    /*
-    /**********************************************************
-    /* Constructing name objects
-    /**********************************************************
-     */
-
-    private static Name constructName(int hash, String name, int q1, int q2)
-    {     
-        if (q2 == 0) { // one quad only?
-            return new Name1(name, hash, q1);
-        }
-        return new Name2(name, hash, q1, q2);
-    }
-
-    private static Name constructName(int hash, String name, int[] quads, int qlen)
-    {
-        if (qlen < 4) { // Need to check for 3 quad one, can do others too
-            switch (qlen) {
-            case 1:
-                return new Name1(name, hash, quads[0]);
-            case 2:
-                return new Name2(name, hash, quads[0], quads[1]);
-            case 3:
-                return new Name3(name, hash, quads[0], quads[1], quads[2]);
-            default:
-            }
-        }
-        // Otherwise, need to copy the incoming buffer
-        int[] buf = new int[qlen];
-        for (int i = 0; i < qlen; ++i) {
-            buf[i] = quads[i];
-        }
-        return new NameN(name, hash, buf, qlen);
-    }
-
-    /*
-    /**********************************************************
-    /* Helper classes
-    /**********************************************************
-     */
-
-    final static class Bucket
-    {
-        protected final Name _name;
-        protected final Bucket _next;
-
-        Bucket(Name name, Bucket next)
-        {
-            _name = name;
-            _next = next;
-        }
-
-        public int length()
-        {
-            int len = 1;
-            for (Bucket curr = _next; curr != null; curr = curr._next) {
-                ++len;
-            }
-            return len;
-        }
-
-        public Name find(int hash, int firstQuad, int secondQuad)
-        {
-            if (_name.hashCode() == hash) {
-                if (_name.equals(firstQuad, secondQuad)) {
-                    return _name;
-                }
-            }
-            for (Bucket curr = _next; curr != null; curr = curr._next) {
-                Name currName = curr._name;
-                if (currName.hashCode() == hash) {
-                    if (currName.equals(firstQuad, secondQuad)) {
-                        return currName;
-                    }
-                }
-            }
-            return null;
-        }
-
-        public Name find(int hash, int[] quads, int qlen)
-        {
-            if (_name.hashCode() == hash) {
-                if (_name.equals(quads, qlen)) {
-                    return _name;
-                }
-            }
-            for (Bucket curr = _next; curr != null; curr = curr._next) {
-                Name currName = curr._name;
-                if (currName.hashCode() == hash) {
-                    if (currName.equals(quads, qlen)) {
-                        return currName;
-                    }
-                }
-            }
-            return null;
-        }
-    }
-}