hugegraph-sync/src/main/java/com/baidu/hugegraph/util/NumericUtil.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements. See the NOTICE file distributed with this
 * work for additional information regarding copyright ownership. The ASF
 * licenses this file to You under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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 com.baidu.hugegraph.util;

import java.math.BigDecimal;
import java.nio.ByteBuffer;
import java.util.Date;

/**
 * This file is copied verbatim from Apache Lucene NumericUtils.java Only the
 * double/float to sortable long/int conversions are retained.
 */
public final class NumericUtil {

    private NumericUtil() {
    } // no instance!

    /**
     * Converts a <code>double</code> value to a sortable signed
     * <code>long</code>. The value is converted by getting their IEEE 754
     * floating-point &quot;double format&quot; bit layout and then some bits
     * are swapped, to be able to compare the result as long. By this the
     * precision is not reduced, but the value can easily used as a long. The
     * sort order (including {@link Double#NaN}) is defined by
     * {@link Double#compareTo}; {@code NaN} is greater than positive infinity.
     *
     * @see #sortableLongToDouble
     */
    public static long doubleToSortableLong(double val) {
        return sortableDoubleBits(Double.doubleToLongBits(val));
    }

    /**
     * Converts a sortable <code>long</code> back to a <code>double</code>.
     *
     * @see #doubleToSortableLong
     */
    public static double sortableLongToDouble(long val) {
        return Double.longBitsToDouble(sortableDoubleBits(val));
    }

    /**
     * Converts a <code>float</code> value to a sortable signed
     * <code>int</code>. The value is converted by getting their IEEE 754
     * floating-point &quot;float format&quot; bit layout and then some bits are
     * swapped, to be able to compare the result as int. By this the precision
     * is not reduced, but the value can easily used as an int. The sort order
     * (including {@link Float#NaN}) is defined by {@link Float#compareTo};
     * {@code NaN} is greater than positive infinity.
     *
     * @see #sortableIntToFloat
     */
    public static int floatToSortableInt(float val) {
        return sortableFloatBits(Float.floatToIntBits(val));
    }

    /**
     * Converts a sortable <code>int</code> back to a <code>float</code>.
     *
     * @see #floatToSortableInt
     */
    public static float sortableIntToFloat(int val) {
        return Float.intBitsToFloat(sortableFloatBits(val));
    }

    /**
     * Converts IEEE 754 representation of a double to sortable order (or back
     * to the original)
     */
    public static long sortableDoubleBits(long bits) {
        return bits ^ (bits >> 63) & 0x7fffffffffffffffL;
    }

    /**
     * Converts IEEE 754 representation of a float to sortable order (or back to
     * the original)
     */
    public static int sortableFloatBits(int bits) {
        return bits ^ (bits >> 31) & 0x7fffffff;
    }

    /*************************************************************************/

    public static byte[] longToBytes(long value) {
        ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
        buffer.putLong(value);
        return buffer.array();
    }

    public static long bytesToLong(byte[] bytes) {
        ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
        buffer.put(bytes);
        buffer.flip();
        return buffer.getLong();
    }

    /*************************************************************************/

    public static boolean isNumber(Object value) {
        if (value == null) {
            return false;
        }
        return isNumber(value.getClass());
    }

    public static boolean isNumber(Class<?> type) {
        if (type.getSuperclass() != null
                && type.getSuperclass().equals(Number.class)) {
            return true;
        }
        return false;
    }

    /*************************************************************************/

    public static Object convert2Number(Object value) {
        if (!isNumber(value) && value != null) {
            if (value instanceof Date) {
                value = ((Date) value).getTime();
            }
            // TODO: add some more types to convert

            value = new BigDecimal(value.toString());
        }
        return value;
    }

}