* Optional<Number>} (where {@code Number} is the desired output type) solves the problem:
   *
   * {@snippet :
   * Optional<Number> optionalInt = (Optional) getSomeOptionalInt();
   * Number value = optionalInt.or(0.5); // fine
   *
   * FluentIterable<? extends Number> numbers = getSomeNumbers();
   * Optional<Number> first = (Optional) numbers.first();
   * Number value = first.or(0.5); // fine
   * }

                        },
                        "price": {
                            "anyOf": [{"type": "number"}, {"type": "null"}],
                            "title": "Price",
                        },
                        "tax": {"title": "Tax", "type": "number", "default": 10.5},
                        "tags": {
                            "title": "Tags",
                            "type": "array",

     */
    @Override
    public byte getFileInformationLevel() {
        return FILE_INTERNAL_INFO;
    }

    /**
     * Gets the file index number.
     *
     * @return the index number assigned by the file system
     */
    public long getIndexNumber() {
        return this.indexNumber;
    }

    /**
     * {@inheritDoc}
     *

     */
    public void setLength(final int length) {
        this.deferred.length = length;
    }

    /**
     * Advances the buffer index by the specified number of bytes.
     *
     * @param n the number of bytes to advance
     */
    public void advance(final int n) {
        this.index += n;
        if (this.index - this.start > this.deferred.length) {

     * @param fid the file identifier
     * @param offset the file offset at which to write
     * @param remaining the number of bytes remaining to be written
     * @param b the data buffer containing bytes to write
     * @param off the offset in the buffer where data starts
     * @param len the number of bytes to write
     * @param andx the next command in the AndX chain, or null
     */

    Ordering<Number> numbers = Ordering.explicit((Number) 1);
    Ordering<Integer> integers = Ordering.explicit(1);

    // Like by like equals like
    Ordering<Number> unusedA = numbers.compound(numbers);

    // The compound takes the more specific type of the two, regardless of order

    Ordering<Number> unusedB = numbers.compound(objects);
    Ordering<Number> unusedC = objects.compound(numbers);

    Ordering<Number> numbers = Ordering.explicit((Number) 1);
    Ordering<Integer> integers = Ordering.explicit(1);

    // Like by like equals like
    Ordering<Number> unusedA = numbers.compound(numbers);

    // The compound takes the more specific type of the two, regardless of order

    Ordering<Number> unusedB = numbers.compound(objects);
    Ordering<Number> unusedC = objects.compound(numbers);

            // It could be either "Unexpected number of update indices" or "Unexpected number of search indices"
            // depending on which check fails first
            assertTrue("Exception message should mention unexpected indices: " + exceptionMessage,
                    exceptionMessage.contains("Unexpected number of update indices")
                            || exceptionMessage.contains("Unexpected number of search indices"));
        } finally {

     * @param off the offset in the buffer
     * @param length the length of data to send
     * @param inB the buffer to receive the response
     * @param maxRecvCnt the maximum number of bytes to receive
     * @return len the number of bytes received
     * @throws IOException if an I/O error occurs
     */
    int sendrecv(byte[] buf, int off, int length, byte[] inB, int maxRecvCnt) throws IOException;

        if (field == null) {
            return null;
        }
        if (clazz.equals(Integer.class)) {
            final Number value = (Number) field;
            return (T) Integer.valueOf(value.intValue());
        }
        if (clazz.equals(Long.class)) {
            final Number value = (Number) field;
            return (T) Long.valueOf(value.longValue());
        }
        return (T) field;
    }

    /**