DWord64Data.java
// <editor-fold defaultstate="collapsed" desc="license">
/*
* Copyright (c) 2014, Karl H. Beckers
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the <ORGANIZATION> nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
**/
// </editor-fold>
package net.jarre_de_the.griffin.types.data;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import net.jarre_de_the.griffin.Util;
import net.jarre_de_the.griffin.exception.ValueTooLargeException;
import net.jarre_de_the.griffin.exception.ValueTooSmallException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Implementation of the DWORD64. The GFF DWORD64 is an 8 byte unsigned integer
* with possible values from 0 to 18446744073709551615.
* <p>
* @author charly4711
*/
public class DWord64Data extends AbstractFixedLengthData<Long, DWord64Data>
implements NumberData<BigInteger>, Cloneable {
/**
* The length of a DWORD64 in bytes.
*/
public static final int LENGTH = 8;
private static final Logger LOGGER = LoggerFactory.getLogger(DWord64Data.class);
private long value = 0L;
/*
*
* constructors
*
*/
protected DWord64Data() {
}
/**
* Creates a new instance of{@code DWord64Data} and sets a defined value.
* <p>
* @param l The value to set. The Java primitive long is signed where the
* DWORD64 is not. Treat this as a bit-field.
* @see #setValue(long l)
*/
public DWord64Data(long l) {
setValue(l);
}
/**
* Creates a new instance of{@code DWord64Data} and sets a defined value.
* <p>
* @param bi the numeric representation of the DWord64Data. If you pass a
* value < 0 or > 0xFFFFFFFFFFFFFFFF, you will get a ValueTooSmallException
* or ValueTooLargeException runtime exception.
* @see #setValue(BigInteger bi)
*/
public DWord64Data(BigInteger bi) {
setValue(bi);
}
/*
*
* read from file
*
*/
/**
* Creates a new instance of {@code DWord64Data} based on the data read from
* the file passed. Note that the contents are read from whatever position
* the file pointer is at.
* <p>
* @param in An open {@code RandomAccessFile}.
* @return
* @throws java.io.IOException If there are any I/O related problems with
* file access to in.
*/
public static DWord64Data read(RandomAccessFile in)
throws IOException {
return new DWord64Data((long) read(in, Long.class));
}
/*
*
* setter
*
*/
/**
* Sets this instance's value.
* <p>
* @param l The value to set. The Java primitive long is signed where the
* DWORD64 is not. Treat this as a bit-field.
*/
private void setValue(long l) {
this.value = l;
}
private void setValue(BigInteger bi) {
BigInteger max = BigInteger.ONE;
max = max.shiftLeft(64);
BigInteger minusOne = new BigInteger("-1", 10);
max = max.add(minusOne);
if (max.compareTo(bi) < 0) {
throw new ValueTooLargeException(max, bi);
} else if (bi.compareTo(BigInteger.ZERO) < 0) {
throw new ValueTooSmallException(BigInteger.ZERO, bi);
}
this.value = bi.longValue();
}
/*
*
* getter
*
*/
/**
* Returns this instance's value as a long. A DWORD64 is 8 bytes as is the
* Java long primitive type. However, a DWORD64 is always unsigned and there
* is no unsigned long in Java. Therefore, the returned value must only be
* regarded as a bit field.
* <p>
* @return The value of this instance as a bit field.
*/
@Override
public Long getValue() {
LOGGER.debug("Retrieving unsigned long to long from: " + value);
return value;
}
@Override
public BigInteger getValueAsNumber() {
byte[] buf = new byte[Long.BYTES + 1];
ByteBuffer bb = ByteBuffer.wrap(buf);
// this is set to BIG_ENDIAN because that's what the BigInteger
// constructor expects. It is completely unrelated to the LITTLE_ENDIAN
// we use elsewhere to get there right format for persisting to GFF.
bb.order(ByteOrder.BIG_ENDIAN);
bb.putLong(1, value);
return new BigInteger(buf);
}
/**
* Returns this instance's value as a byte array in the same order it would
* be stored in a GFF file.
* <p>
* @return This instance's value as a bit field split into 8 bytes.
*/
@Override
public byte[] getValueAsByteArray() {
byte[] buf = new byte[LENGTH];
ByteBuffer bb = ByteBuffer.wrap(buf);
bb.order(ByteOrder.LITTLE_ENDIAN);
bb.putLong(value);
LOGGER.debug("Retrieving byte array for (" + Long.toHexString(value)
+ ") to: " + new String(buf, Util.CHARSET_US_ASCII));
return buf;
}
/*
*
* utility
*
*/
@Override
public int length() {
return LENGTH;
}
/**
* Overrides the {@code java.lang.Object} method to ensure we always get
* back an instance of {@code DWord64Data} rather than just {@code Object}.
* <p>
* @return A deep copy of this object.
* @throws java.lang.CloneNotSupportedException
*/
@Override
public DWord64Data clone() throws CloneNotSupportedException {
LOGGER.debug("Cloning object");
DWord64Data clone = (DWord64Data) super.clone();
clone.setValue(value);
return clone;
}
/**
* Overrides the {@code java.lang.Object} method to make test for equality
* possible for this class.
* <p>
* @param compare The Object to compare this object with.
* @return True if the objects have the same value, false if not.
*/
@Override
public boolean equals(Object compare) {
if (compare == this) {
return true;
}
if (!(compare instanceof DWord64Data)) {
return false;
}
DWord64Data dw = (DWord64Data) compare;
if (dw.getValue().equals(this.getValue())) {
return true;
}
return false;
}
/**
* Overrides the {@code java.lang.Object} method to ensure we have a hash
* code consistent with the test for equality. Because we have a full 8 byte
* long value but can only return a 4 byte int, we need to lose some date.
* We do the same as the {@code java.lang.Long}, i. e. return an exclusive
* OR of the two halves of the long value.
* <p>
* <blockquote>
* {@code (int)(this.getLongValue()^(this.getLongValue()>>>32))}
* </blockquote>
* <p>
* @return The hash returned is based on the value.
*/
@Override
public int hashCode() {
LOGGER.debug("Creating int hashCode from long value");
long l = getValue();
return (int) (l ^ (l >>> 32));
}
@Override
public String toString() {
String iS = Long.toHexString(value);
if (iS.length() < LENGTH * 2) {
StringBuilder sb = new StringBuilder();
sb.append(iS);
for (int i = 0; i < (LENGTH * 2) - iS.length(); i++) {
sb.append("0");
}
iS = sb.toString();
}
return iS;
}
}