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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.searchlib.expression;
import com.yahoo.searchlib.aggregation.RawData;
import com.yahoo.vespa.objects.Deserializer;
import com.yahoo.vespa.objects.ObjectVisitor;
import com.yahoo.vespa.objects.Serializer;
import java.util.Arrays;
/**
* This result holds a byte array value.
*
* @author baldersheim
* @author Simon Thoresen Hult
*/
public class RawResultNode extends SingleResultNode {
// The global class identifier shared with C++.
public static final int classId = registerClass(0x4000 + 54, RawResultNode.class);
private static final RawResultNode negativeInfinity = new RawResultNode();
private static final PositiveInfinityResultNode positiveInfinity = new PositiveInfinityResultNode();
// The raw value of this node.
private RawData value = null;
/**
* Constructs an empty result node. <b>NOTE:</b> This instance is broken until non-optional member data is set.
*/
public RawResultNode() {
super();
value = new RawData();
}
/**
* Constructs an instance of this class with given byte buffer.
*
* @param value The value to assign to this.
*/
public RawResultNode(byte[] value) {
super();
setValue(value);
}
/**
* Sets the value of this result.
*
* @param value The value to set.
* @return This, to allow chaining.
*/
public RawResultNode setValue(byte[] value) {
this.value = new RawData(value);
return this;
}
@Override
protected int onGetClassId() {
return classId;
}
@Override
protected void onSerialize(Serializer buf) {
value.serialize(buf);
}
@Override
protected void onDeserialize(Deserializer buf) {
value = new RawData();
value.deserialize(buf);
}
@Override
public long getInteger() {
return 0;
}
@Override
public double getFloat() {
return 0;
}
@Override
public String getString() {
return new String(value.getData());
}
@Override
public byte[] getRaw() {
return value.getData();
}
@Override
public String toString() {
if (value != null) {
return Arrays.toString(value.getData());
}
return "[]";
}
@Override
protected int onCmp(ResultNode rhs) {
return (rhs instanceof PositiveInfinityResultNode)
? -1
: RawData.compare(value.getData(), rhs.getRaw());
}
@Override
public int hashCode() {
return super.hashCode() + value.hashCode();
}
@Override
public RawResultNode clone() {
RawResultNode obj = (RawResultNode)super.clone();
if (value != null) {
obj.value = (RawData)value.clone();
}
return obj;
}
@Override
public void visitMembers(ObjectVisitor visitor) {
super.visitMembers(visitor);
visitor.visit("value", value);
}
public void add(ResultNode rhs) {
byte[] nb = new byte[value.getData().length + rhs.getRaw().length];
System.arraycopy(value.getData(), 0, nb, 0, value.getData().length);
System.arraycopy(rhs.getRaw(), 0, nb, value.getData().length, rhs.getRaw().length);
value = new RawData(nb);
}
public void min(ResultNode rhs) {
RawData b = new RawData(rhs.getRaw());
if (value.compareTo(b) > 0) {
value = b;
}
}
public void max(ResultNode rhs) {
RawData b = new RawData(rhs.getRaw());
if (value.compareTo(b) < 0) {
value = b;
}
}
@Override
public Object getValue() {
return value;
}
@Override
public void set(ResultNode rhs) {
value = new RawData(rhs.getRaw());
}
@Override
public void negate() {
byte[] data = value.getData();
for (int i = 0; i < data.length; i++) {
data[i] = (byte)-data[i];
}
}
/**
* Will provide the smallest possible value
*
* @return the smallest possible IntegerResultNode
*/
public static RawResultNode getNegativeInfinity() {
return negativeInfinity;
}
/**
* Will provide the largest possible value
*
* @return the smallest largest IntegerResultNode
*/
public static PositiveInfinityResultNode getPositiveInfinity() {
return positiveInfinity;
}
}
|
