Statistics
| Revision:

svn-gvsig-desktop / tags / v1_1_Build_1015 / libraries / libGDBMS / src / main / java / com / hardcode / gdbms / engine / values / NumericValue.java @ 13679

History | View | Annotate | Download (4.84 KB)

1
package com.hardcode.gdbms.engine.values;
2

    
3
import java.io.Serializable;
4

    
5
import com.hardcode.gdbms.engine.instruction.IncompatibleTypesException;
6

    
7

    
8
/**
9
 * DOCUMENT ME!
10
 *
11
 * @author Fernando Gonz?lez Cort?s
12
 */
13
public abstract class NumericValue extends AbstractValue implements Serializable {
14
        /**
15
         * DOCUMENT ME!
16
         *
17
         * @return DOCUMENT ME!
18
         */
19
        public abstract byte byteValue();
20

    
21
        /**
22
         * DOCUMENT ME!
23
         *
24
         * @return DOCUMENT ME!
25
         */
26
        public abstract short shortValue();
27

    
28
        /**
29
         * DOCUMENT ME!
30
         *
31
         * @return DOCUMENT ME!
32
         */
33
        public abstract int intValue();
34

    
35
        /**
36
         * DOCUMENT ME!
37
         *
38
         * @return DOCUMENT ME!
39
         */
40
        public abstract long longValue();
41

    
42
        /**
43
         * DOCUMENT ME!
44
         *
45
         * @return DOCUMENT ME!
46
         */
47
        public abstract float floatValue();
48

    
49
        /**
50
         * DOCUMENT ME!
51
         *
52
         * @return DOCUMENT ME!
53
         */
54
        public abstract double doubleValue();
55

    
56
        /**
57
         * DOCUMENT ME!
58
         *
59
         * @return DOCUMENT ME!
60
         */
61
        public abstract int getType();
62

    
63
        /**
64
         * DOCUMENT ME!
65
         *
66
         * @param value DOCUMENT ME!
67
         *
68
         * @return DOCUMENT ME!
69
         *
70
         * @throws IncompatibleTypesException DOCUMENT ME!
71
         */
72
        public Value producto(Value value) throws IncompatibleTypesException {
73
                if (!(value instanceof NumericValue)) {
74
                        throw new IncompatibleTypesException();
75
                }
76

    
77
                return ValueFactory.producto(this, (NumericValue) value);
78
        }
79

    
80
        /**
81
         * DOCUMENT ME!
82
         *
83
         * @param value DOCUMENT ME!
84
         *
85
         * @return DOCUMENT ME!
86
         *
87
         * @throws IncompatibleTypesException DOCUMENT ME!
88
         */
89
        public Value suma(Value value) throws IncompatibleTypesException {
90
                if (!(value instanceof NumericValue)) {
91
                        throw new IncompatibleTypesException();
92
                }
93

    
94
                return ValueFactory.suma(this, (NumericValue) value);
95
        }
96

    
97
        /**
98
         * DOCUMENT ME!
99
         *
100
         * @return DOCUMENT ME!
101
         *
102
         * @throws IncompatibleTypesException DOCUMENT ME!
103
         */
104
        public Value inversa() throws IncompatibleTypesException {
105
                return ValueFactory.inversa(this);
106
        }
107

    
108
        /**
109
         * DOCUMENT ME!
110
         *
111
         * @param value DOCUMENT ME!
112
         *
113
         * @return DOCUMENT ME!
114
         *
115
         * @throws IncompatibleTypesException DOCUMENT ME!
116
         */
117
        public Value equals(Value value) throws IncompatibleTypesException {
118
                if (value instanceof NullValue) {
119
                        return ValueFactory.createValue(false);
120
                }
121

    
122
                if (!(value instanceof NumericValue)) {
123
                        throw new IncompatibleTypesException();
124
                }
125

    
126
                return ValueFactory.createValue(this.doubleValue() == ((NumericValue) value).doubleValue());
127
        }
128

    
129
        /**
130
         * DOCUMENT ME!
131
         *
132
         * @param value DOCUMENT ME!
133
         *
134
         * @return DOCUMENT ME!
135
         *
136
         * @throws IncompatibleTypesException DOCUMENT ME!
137
         */
138
        public Value greater(Value value) throws IncompatibleTypesException {
139
                if (value instanceof NullValue) {
140
                        return ValueFactory.createValue(false);
141
                }
142

    
143
                if (!(value instanceof NumericValue)) {
144
                        throw new IncompatibleTypesException();
145
                }
146

    
147
                return ValueFactory.createValue(this.doubleValue() > ((NumericValue) value).doubleValue());
148
        }
149

    
150
        /**
151
         * DOCUMENT ME!
152
         *
153
         * @param value DOCUMENT ME!
154
         *
155
         * @return DOCUMENT ME!
156
         *
157
         * @throws IncompatibleTypesException DOCUMENT ME!
158
         */
159
        public Value greaterEqual(Value value) throws IncompatibleTypesException {
160
                if (value instanceof NullValue) {
161
                        return ValueFactory.createValue(false);
162
                }
163

    
164
                if (!(value instanceof NumericValue)) {
165
                        throw new IncompatibleTypesException();
166
                }
167

    
168
                return ValueFactory.createValue(this.doubleValue() >= ((NumericValue) value).doubleValue());
169
        }
170

    
171
        /**
172
         * DOCUMENT ME!
173
         *
174
         * @param value DOCUMENT ME!
175
         *
176
         * @return DOCUMENT ME!
177
         *
178
         * @throws IncompatibleTypesException DOCUMENT ME!
179
         */
180
        public Value less(Value value) throws IncompatibleTypesException {
181
                if (value instanceof NullValue) {
182
                        return ValueFactory.createValue(false);
183
                }
184

    
185
                if (!(value instanceof NumericValue)) {
186
                        throw new IncompatibleTypesException();
187
                }
188

    
189
                return ValueFactory.createValue(this.doubleValue() < ((NumericValue) value).doubleValue());
190
        }
191

    
192
        /**
193
         * DOCUMENT ME!
194
         *
195
         * @param value DOCUMENT ME!
196
         *
197
         * @return DOCUMENT ME!
198
         *
199
         * @throws IncompatibleTypesException DOCUMENT ME!
200
         */
201
        public Value lessEqual(Value value) throws IncompatibleTypesException {
202
                if (value instanceof NullValue) {
203
                        return ValueFactory.createValue(false);
204
                }
205

    
206
                if (!(value instanceof NumericValue)) {
207
                        throw new IncompatibleTypesException();
208
                }
209

    
210
                return ValueFactory.createValue(this.doubleValue() <= ((NumericValue) value).doubleValue());
211
        }
212

    
213
        /**
214
         * DOCUMENT ME!
215
         *
216
         * @param value DOCUMENT ME!
217
         *
218
         * @return DOCUMENT ME!
219
         *
220
         * @throws IncompatibleTypesException DOCUMENT ME!
221
         */
222
        public Value notEquals(Value value) throws IncompatibleTypesException {
223
                if (value instanceof NullValue) {
224
                        return ValueFactory.createValue(false);
225
                }
226

    
227
                if (!(value instanceof NumericValue)) {
228
                        throw new IncompatibleTypesException();
229
                }
230

    
231
                return ValueFactory.createValue(this.doubleValue() != ((NumericValue) value).doubleValue());
232
        }
233

    
234
        /**
235
         * @see com.hardcode.gdbms.engine.values.Value#doHashCode()
236
         */
237
        public int doHashCode() {
238
                return intValue();
239
        }
240
}