aboutsummaryrefslogtreecommitdiffstats
path: root/lib/jinterface/java_src/com/ericsson/otp/erlang/OtpErlangDouble.java
blob: e92ce11431c566860380f8298de82fb72b01b4c4 (plain) (blame)
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
/*
 * %CopyrightBegin%
 * 
 * Copyright Ericsson AB 2000-2009. All Rights Reserved.
 * 
 * The contents of this file are subject to the Erlang Public License,
 * Version 1.1, (the "License"); you may not use this file except in
 * compliance with the License. You should have received a copy of the
 * Erlang Public License along with this software. If not, it can be
 * retrieved online at http://www.erlang.org/.
 * 
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 * 
 * %CopyrightEnd%
 */
package com.ericsson.otp.erlang;


/**
 * Provides a Java representation of Erlang floats and doubles. Erlang defines
 * only one floating point numeric type, however this class and its subclass
 * {@link OtpErlangFloat} are used to provide representations corresponding to
 * the Java types Double and Float.
 */
public class OtpErlangDouble extends OtpErlangObject {
    // don't change this!
    private static final long serialVersionUID = 132947104811974021L;

    private final double d;

    /**
     * Create an Erlang float from the given double value.
     */
    public OtpErlangDouble(final double d) {
	this.d = d;
    }

    /**
     * Create an Erlang float from a stream containing a double encoded in
     * Erlang external format.
     * 
     * @param buf
     *                the stream containing the encoded value.
     * 
     * @exception OtpErlangDecodeException
     *                    if the buffer does not contain a valid external
     *                    representation of an Erlang float.
     */
    public OtpErlangDouble(final OtpInputStream buf)
	    throws OtpErlangDecodeException {
	d = buf.read_double();
    }

    /**
     * Get the value, as a double.
     * 
     * @return the value of this object, as a double.
     */
    public double doubleValue() {
	return d;
    }

    /**
     * Get the value, as a float.
     * 
     * @return the value of this object, as a float.
     * 
     * @exception OtpErlangRangeException
     *                    if the value cannot be represented as a float.
     */
    public float floatValue() throws OtpErlangRangeException {
	final float f = (float) d;

	if (f != d) {
	    throw new OtpErlangRangeException("Value too large for float: " + d);
	}

	return f;
    }

    /**
     * Get the string representation of this double.
     * 
     * @return the string representation of this double.
     */
    @Override
    public String toString() {
	return "" + d;
    }

    /**
     * Convert this double to the equivalent Erlang external representation.
     * 
     * @param buf
     *                an output stream to which the encoded value should be
     *                written.
     */
    @Override
    public void encode(final OtpOutputStream buf) {
	buf.write_double(d);
    }

    /**
     * Determine if two floats are equal. Floats are equal if they contain the
     * same value.
     * 
     * @param o
     *                the float to compare to.
     * 
     * @return true if the floats have the same value.
     */
    @Override
    public boolean equals(final Object o) {
	if (!(o instanceof OtpErlangDouble)) {
	    return false;
	}

	final OtpErlangDouble other = (OtpErlangDouble) o;
	return this.d == other.d;
    }
    
    @Override
    protected int doHashCode() {
	Double v = new Double(d);
	return v.hashCode();
    }
}