searchlib/src/main/java/com/yahoo/searchlib/rankingexpression/evaluation/LongValue.java


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.searchlib.rankingexpression.evaluation;

import com.yahoo.searchlib.rankingexpression.rule.Function;

/**
 * A representation for integer numbers
 *
 * @author balder
 */
public class LongValue extends DoubleCompatibleValue {
    private final long value;

    public LongValue(long value) {
        this.value = value;
    }
    @Override
    public double asDouble() {
        return value;
    }
    @Override
    public boolean asBoolean() {
        return value != 0;
    }

    @Override
    public Value asMutable() {
        return new LongValue(value);
    }

    @Override
    public String toString() {
        return String.valueOf(value);
    }

    @Override
    public boolean equals(Object other) {
        if (this==other) return true;
        if ( ! (other instanceof Value)) return false;
        if ( ! ((Value) other).hasDouble()) return false;
        return new DoubleValue(value).equals(other);
    }

    @Override
    public int hashCode() {
        return Long.hashCode(value);
    }

    @Override
    public DoubleValue negate() {
        return new DoubleValue(-value);
    }

    private UnsupportedOperationException unsupported(String operation, Value value) {
        return new UnsupportedOperationException("Cannot perform " + operation + " on " + value + " and " + this);
    }

    /** Returns this or a mutable copy assigned the given value */
    private DoubleValue mutable(double value) {
        return new DoubleValue(value);
    }

    @Override
    public Value add(Value value) {
        if (value instanceof TensorValue)
            return value.add(this);

        try {
            return mutable(this.value + value.asDouble());
        }
        catch (UnsupportedOperationException e) {
            throw unsupported("add",value);
        }
    }

    @Override
    public Value subtract(Value value) {
        if (value instanceof TensorValue)
            return value.negate().add(this);

        try {
            return mutable(this.value - value.asDouble());
        }
        catch (UnsupportedOperationException e) {
            throw unsupported("subtract",value);
        }
    }

    @Override
    public Value multiply(Value value) {
        if (value instanceof TensorValue)
            return value.multiply(this);

        try {
            return mutable(this.value * value.asDouble());
        }
        catch (UnsupportedOperationException e) {
            throw unsupported("multiply", value);
        }
    }

    @Override
    public Value divide(Value value) {
        try {
            return mutable(this.value / value.asDouble());
        }
        catch (UnsupportedOperationException e) {
            throw unsupported("divide",value);
        }
    }

    @Override
    public Value modulo(Value value) {
        try {
            return mutable(this.value % value.asDouble());
        }
        catch (UnsupportedOperationException e) {
            throw unsupported("modulo",value);
        }
    }

    @Override
    public Value function(Function function, Value value) {
        // use the tensor implementation of max and min if the argument is a tensor
        if ( (function.equals(Function.min) || function.equals(Function.max)) && value instanceof TensorValue)
            return value.function(function, this);

        try {
            return mutable(function.evaluate(this.value, value.asDouble()));
        }
        catch (UnsupportedOperationException e) {
            throw unsupported("function " + function, value);
        }
    }

}