Home | History | Annotate | Download | only in classfile 
      1 /*
      2  * Licensed to the Apache Software Foundation (ASF) under one or more
      3  * contributor license agreements.  See the NOTICE file distributed with
      4  * this work for additional information regarding copyright ownership.
      5  * The ASF licenses this file to You under the Apache License, Version 2.0
      6  * (the "License"); you may not use this file except in compliance with
      7  * the License.  You may obtain a copy of the License at
      8  *
      9  *      http://www.apache.org/licenses/LICENSE-2.0
     10  *
     11  *  Unless required by applicable law or agreed to in writing, software
     12  *  distributed under the License is distributed on an "AS IS" BASIS,
     13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14  *  See the License for the specific language governing permissions and
     15  *  limitations under the License.
     16  *
     17  */
     18 package org.apache.bcel.classfile;
     19 
     20 import java.io.DataInput;
     21 import java.io.DataOutputStream;
     22 import java.io.IOException;
     23 
     24 import org.apache.bcel.Const;
     25 
     26 /**
     27  * This class is derived from the abstract  {@link Constant}
     28  * and represents a reference to a Double object.
     29  *
     30  * @version $Id$
     31  * @see     Constant
     32  */
     33 public final class ConstantDouble extends Constant implements ConstantObject {
     34 
     35     private double bytes;
     36 
     37 
     38     /**
     39      * @param bytes Data
     40      */
     41     public ConstantDouble(final double bytes) {
     42         super(Const.CONSTANT_Double);
     43         this.bytes = bytes;
     44     }
     45 
     46 
     47     /**
     48      * Initialize from another object.
     49      */
     50     public ConstantDouble(final ConstantDouble c) {
     51         this(c.getBytes());
     52     }
     53 
     54 
     55     /**
     56      * Initialize instance from file data.
     57      *
     58      * @param file Input stream
     59      * @throws IOException
     60      */
     61     ConstantDouble(final DataInput file) throws IOException {
     62         this(file.readDouble());
     63     }
     64 
     65 
     66     /**
     67      * Called by objects that are traversing the nodes of the tree implicitely
     68      * defined by the contents of a Java class. I.e., the hierarchy of methods,
     69      * fields, attributes, etc. spawns a tree of objects.
     70      *
     71      * @param v Visitor object
     72      */
     73     @Override
     74     public void accept( final Visitor v ) {
     75         v.visitConstantDouble(this);
     76     }
     77 
     78 
     79     /**
     80      * Dump constant double to file stream in binary format.
     81      *
     82      * @param file Output file stream
     83      * @throws IOException
     84      */
     85     @Override
     86     public final void dump( final DataOutputStream file ) throws IOException {
     87         file.writeByte(super.getTag());
     88         file.writeDouble(bytes);
     89     }
     90 
     91 
     92     /**
     93      * @return data, i.e., 8 bytes.
     94      */
     95     public final double getBytes() {
     96         return bytes;
     97     }
     98 
     99 
    100     /**
    101      * @param bytes the raw bytes that represent the double value
    102      */
    103     public final void setBytes( final double bytes ) {
    104         this.bytes = bytes;
    105     }
    106 
    107 
    108     /**
    109      * @return String representation.
    110      */
    111     @Override
    112     public final String toString() {
    113         return super.toString() + "(bytes = " + bytes + ")";
    114     }
    115 
    116 
    117     /** @return Double object
    118      */
    119     @Override
    120     public Object getConstantValue( final ConstantPool cp ) {
    121         return new Double(bytes);
    122     }
    123 }
    124