@Override
public void run() {
try {
// Open socket
socket = new Socket("127.0.0.1", 5432);
// Get input streams
DataOutputStream writer =
new DataOutputStream(new BufferedOutputStream(socket.getOutputStream()));
DataInputStream scanner = new DataInputStream(socket.getInputStream());
// Send calculation data
writer.writeDouble(zoom);
writer.writeDouble(zoomTranslateX);
writer.writeDouble(zoomTranslateY);
writer.writeInt(level);
writer.writeInt(mode);
writer.flush();
System.out.println("Sent data");
// Wait for server to do calculations
while (scanner.available() == 0) {
Thread.sleep(level);
}
System.out.println("Start drawing");
// Start reading and drawing
application.clearKochPanel();
int counter = 0;
while (true) {
if (scanner.available() > 0) {
application.drawEdge(
new Edge(
scanner.readDouble(),
scanner.readDouble(),
scanner.readDouble(),
scanner.readDouble(),
Color.hsb(scanner.readDouble(), 1, 1)));
counter = 0;
} else {
Thread.sleep(10);
counter++;
if (counter > 10) {
break;
}
}
}
System.out.println("Finished drawing!");
writer.writeChar('H');
writer.flush();
writer.close();
scanner.close();
socket.close();
} catch (Exception e) {
System.out.println("Receiving edges failed!");
System.out.println(e.getMessage());
Thread.currentThread().interrupt();
}
}
public double saveBinaryFileWithBuffer() {
double time = System.nanoTime();
File file = new File("C:\\Users\\rvanduijnhoven\\Documents\\jsfoutput\\binFileWithBuffer.bin");
DataOutputStream outPut = null;
DataInputStream inPut = null;
FileOutputStream fileOut = null;
FileInputStream fileIn = null;
BufferedInputStream buffInput = null;
BufferedOutputStream buffOut = null;
try {
fileOut = new FileOutputStream(file);
buffOut = new BufferedOutputStream(fileOut);
outPut = new DataOutputStream(buffOut);
for (Edge e : edges) {
outPut.writeDouble(e.X1);
outPut.writeDouble(e.Y1);
outPut.writeDouble(e.X2);
outPut.writeDouble(e.Y2);
outPut.writeDouble(e.color.getRed());
outPut.writeDouble(e.color.getGreen());
outPut.writeDouble(e.color.getBlue());
outPut.flush();
}
outPut.close();
} catch (Exception ex) {
ex.printStackTrace();
}
edges.clear();
// Now read every edge from the file and draw it.
try {
fileIn = new FileInputStream(file);
buffInput = new BufferedInputStream(fileIn);
inPut = new DataInputStream(buffInput);
if (inPut.available() > 0) {
while (inPut.available() > 0) {
double X1 = inPut.readDouble();
double Y1 = inPut.readDouble();
double X2 = inPut.readDouble();
double Y2 = inPut.readDouble();
double red = inPut.readDouble();
double green = inPut.readDouble();
double blue = inPut.readDouble();
Edge e = new Edge(X1, Y1, X2, Y2, new Color(red, green, blue, 1));
drawEdge(e);
}
}
} catch (Exception ex) {
ex.printStackTrace();
}
return System.nanoTime() - time;
}
/**
* Reads the payload of a tag, given the name and type.
*
* @param type The type.
* @param name The name.
* @param depth The depth.
* @return The tag.
* @throws IOException if an I/O error occurs.
*/
private Tag readTagPayload(int type, String name, int depth) throws IOException {
switch (type) {
case NBTConstants.TYPE_END:
if (depth == 0) {
throw new IOException("TAG_End found without a TAG_Compound/TAG_List tag preceding it.");
} else {
return new EndTag();
}
case NBTConstants.TYPE_BYTE:
return new ByteTag(name, is.readByte());
case NBTConstants.TYPE_SHORT:
return new ShortTag(name, is.readShort());
case NBTConstants.TYPE_INT:
return new IntTag(name, is.readInt());
case NBTConstants.TYPE_LONG:
return new LongTag(name, is.readLong());
case NBTConstants.TYPE_FLOAT:
return new FloatTag(name, is.readFloat());
case NBTConstants.TYPE_DOUBLE:
return new DoubleTag(name, is.readDouble());
case NBTConstants.TYPE_BYTE_ARRAY:
int length = is.readInt();
byte[] bytes = new byte[length];
is.readFully(bytes);
return new ByteArrayTag(name, bytes);
case NBTConstants.TYPE_STRING:
length = is.readShort();
bytes = new byte[length];
is.readFully(bytes);
return new StringTag(name, new String(bytes, NBTConstants.CHARSET));
case NBTConstants.TYPE_LIST:
int childType = is.readByte();
length = is.readInt();
List<Tag> tagList = new ArrayList<Tag>();
for (int i = 0; i < length; i++) {
Tag tag = readTagPayload(childType, "", depth + 1);
if (tag instanceof EndTag) {
throw new IOException("TAG_End not permitted in a list.");
}
tagList.add(tag);
}
return new ListTag(name, NBTUtils.getTypeClass(childType), tagList);
case NBTConstants.TYPE_COMPOUND:
Map<String, Tag> tagMap = new HashMap<String, Tag>();
while (true) {
Tag tag = readTag(depth + 1);
if (tag instanceof EndTag) {
break;
} else {
tagMap.put(tag.getName(), tag);
}
}
return new CompoundTag(name, tagMap);
default:
throw new IOException("Invalid tag type: " + type + ".");
}
}
public static void main(String[] args) {
String inputFileName =
"C:\\Users\\Ahmed\\Desktop\\RA\\2011-2012\\Term1\\KNN\\BerlinMod Data\\trips.1000.dat";
FileInputStream fin;
try {
fin = new FileInputStream(inputFileName);
DataInputStream din = new DataInputStream(fin);
while (true)
System.out.println(
din.readInt()
+ ", "
+ din.readLong()
+ ", "
+ din.readDouble()
+ ", "
+ din.readDouble());
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
System.out.println("End of file reached");
e.printStackTrace();
}
}
public RGAPlayer(int index, DataInputStream dis) throws IOException {
super(index, ChromoTypes.RGA);
jailLength = JAIL_LENGTH;
chrNoOwners = new double[lotLength];
chrPlayerOwns = new double[lotLength];
chrOpponentOwns = new double[lotLength];
chrTwoOpponentOwns = new double[lotLength];
chrJail = new double[jailLength][jailLength];
addToFitness(dis.readInt());
for (int i = 0; i < chrNoOwners.length; i++) {
chrNoOwners[i] = dis.readDouble();
}
for (int i = 0; i < chrPlayerOwns.length; i++) {
chrPlayerOwns[i] = dis.readDouble();
}
for (int i = 0; i < chrOpponentOwns.length; i++) {
chrOpponentOwns[i] = dis.readDouble();
}
for (int i = 0; i < chrTwoOpponentOwns.length; i++) {
chrTwoOpponentOwns[i] = dis.readDouble();
}
for (int i = 0; i < jailLength; i++) {
for (int j = 0; j < jailLength; j++) {
chrJail[i][j] = dis.readDouble();
}
}
}
public static void main(String[] args) throws IOException {
FileReader in = new FileReader("frog.txt");
FileWriter out = new FileWriter("prince.txt");
int c;
while ((c = in.read()) != -1) out.write(c);
in.close();
out.close();
// Read file name from stdin
BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Please enter a valid filename: ");
String fileName = stdin.readLine();
DataOutputStream outStream =
new DataOutputStream(new BufferedOutputStream(new FileOutputStream(fileName)));
outStream.writeDouble(3.14);
outStream.writeUTF("That is pi");
outStream.writeDouble(1.41413);
outStream.writeUTF("Square root of 2");
outStream.close();
DataInputStream inStream =
new DataInputStream(new BufferedInputStream(new FileInputStream(fileName)));
System.out.println(inStream.readDouble());
System.out.println(inStream.readUTF());
System.out.println(inStream.readDouble());
System.out.println(inStream.readUTF());
}
@Override
public void handle(SMPPlayer p, Server server, DataInputStream reader) {
try {
p.setOldLocation(p.getLocation());
double x = reader.readDouble();
double y = reader.readDouble();
double stance = reader.readDouble();
double z = reader.readDouble();
boolean onGround = reader.readBoolean();
if ((stance - y) < 0.1d || (stance - y) > 1.65d) {
p.kick("Illegal Stance");
}
if ((Math.abs(x) >= Math.abs(p.getLocation().getX()) + 100)
|| // TODO: possibly add customization for this number and an option for if it will be
// checked at all
(Math.abs(y) >= Math.abs(p.getLocation().getY()) + 100)
|| (Math.abs(z) >= Math.abs(p.getLocation().getZ()) + 100)) {
p.kick("You moved too quickly");
}
if (Math.abs(x) > 3.2E7d || Math.abs(y) > 3.2E7d) {
p.kick("Illegal Position");
}
p.getLocation().setX(x);
p.getLocation().setY(y);
p.getLocation().setZ(z);
p.setStance(stance);
p.setOnGround(onGround);
} catch (IOException e) {
e.printStackTrace();
}
}
public Response sendRequest(Request request) throws IOException {
byte[] requestData = request.getBytes();
dataOutputStream.writeInt(requestData.length);
dataOutputStream.write(requestData);
dataOutputStream.flush();
byte responseType = dataInputStream.readByte();
switch (responseType) {
case Response.TYPE_SENT_OK:
return new SendMessageResponse(dataInputStream.readDouble());
case Response.TYPE_SENT_NOT_OK:
return new SendMessageResponse(dataInputStream.readDouble());
case Response.TYPE_EMPTY:
return new EmptyResponse();
case Response.TYPE_MESSAGE:
return new MessageResponse(
dataInputStream.readInt(),
dataInputStream.readInt(),
dataInputStream.readUTF(),
dataInputStream.readDouble());
case Response.TYPE_QUEUE_CREATED:
return new CreateQueueResponse(dataInputStream.readInt());
case Response.TYPE_QUEUE_DELETED:
return new DeleteQueueResponse(dataInputStream.readBoolean());
case Response.TYPE_QUEUE_QUERY:
ArrayList<Integer> queues = new ArrayList<Integer>();
int size = dataInputStream.readInt();
for (int i = 0; i < size; ++i) {
queues.add(dataInputStream.readInt());
}
return new QueryQueuesResponse(queues);
default:
return new InvalidRequestResponse();
}
}
public void load(DataInputStream in, String name, World w) {
this.name = name;
try {
world = w;
try {
double x1 = in.readDouble();
double y1 = in.readDouble();
double z1 = in.readDouble();
catArena.setLocB(world, x1, y1, z1);
double x2 = in.readDouble();
double y2 = in.readDouble();
double z2 = in.readDouble();
catArena.setLocG(world, x2, y2, z2);
while (true) {
int d = in.readInt();
if (d == Material.CHEST.getId()) {
blocks.add(new BlocksChest(in, world));
} else if (d == Material.SIGN.getId() || d == Material.SIGN_POST.getId()) {
blocks.add(new BlocksSign(in, world));
} else {
blocks.add(new Blocks(in, world));
}
}
} catch (EOFException d) {
}
} catch (Exception e) {
e.printStackTrace();
}
}
protected void read(DataInputStream s) {
try {
ref = new WeakReference<DataBuffer>(this, Nd4j.bufferRefQueue());
referencing = Collections.synchronizedSet(new HashSet<String>());
dirty = new AtomicBoolean(false);
allocationMode = AllocationMode.valueOf(s.readUTF());
length = s.readInt();
Type t = Type.valueOf(s.readUTF());
if (t == Type.DOUBLE) {
if (allocationMode == AllocationMode.HEAP) {
if (this.dataType() == Type.FLOAT) { // DataBuffer type
// double -> float
floatData = new float[length()];
} else if (this.dataType() == Type.DOUBLE) {
// double -> double
doubleData = new double[length()];
} else {
// double -> int
intData = new int[length()];
}
for (int i = 0; i < length(); i++) {
put(i, s.readDouble());
}
} else {
wrappedBuffer = ByteBuffer.allocateDirect(length() * getElementSize());
wrappedBuffer.order(ByteOrder.nativeOrder());
for (int i = 0; i < length(); i++) {
put(i, s.readDouble());
}
}
} else {
if (allocationMode == AllocationMode.HEAP) {
if (this.dataType() == Type.FLOAT) { // DataBuffer type
// float -> float
floatData = new float[length()];
} else if (this.dataType() == Type.DOUBLE) {
// float -> double
doubleData = new double[length()];
} else {
// float-> int
intData = new int[length()];
}
for (int i = 0; i < length(); i++) {
put(i, s.readFloat());
}
} else {
wrappedBuffer = ByteBuffer.allocateDirect(length() * getElementSize());
wrappedBuffer.order(ByteOrder.nativeOrder());
for (int i = 0; i < length(); i++) {
put(i, s.readFloat());
}
}
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static Edge parse(DataInputStream dis) throws IOException {
double x1 = dis.readDouble();
double y1 = dis.readDouble();
double x2 = dis.readDouble();
double y2 = dis.readDouble();
double red = dis.readDouble();
double green = dis.readDouble();
double blue = dis.readDouble();
return new Edge(x1, y1, x2, y2, new Color(red, green, blue, 1));
}
private static Unit readUnitV3(DataInputStream dis) throws IOException {
int length = dis.readInt();
String name = "";
for (int i = length - 1; i >= 0; i--) {
name += dis.readChar();
}
String weapon = "";
length = dis.readInt();
for (int i = length - 1; i >= 0; i--) {
weapon += dis.readChar();
}
double life = dis.readDouble();
double movement = dis.readDouble();
double energyCost = dis.readDouble();
double metalCost = dis.readDouble();
double energyDrain = dis.readDouble();
double metalDrain = dis.readDouble();
double width = dis.readDouble();
double height = dis.readDouble();
double depth = dis.readDouble();
int buildTime = dis.readInt();
ArrayList<String> buildTree = new ArrayList<String>();
length = dis.readInt();
for (int i = 0; i < length; i++) {
int tempLength = dis.readInt();
String tempName = "";
for (int a = 0; a < tempLength; a++) {
tempName += dis.readChar();
}
buildTree.add(tempName);
}
Weapon w = EngineConstants.weaponFactory.makeWeapon(weapon);
Unit u =
new Unit(
name,
w,
life,
movement,
energyCost,
metalCost,
energyDrain,
metalDrain,
0,
0,
width,
height,
depth,
buildTime);
u.setBuildTree(buildTree);
// System.out.println(name+" build tree = "+buildTree);
return u;
}
@DeployableTestMethod
@Test(timeout = 300000)
public void testFileReadAndWriteBackWithDataOutputStreamAndDeferredBufferedReaderCreation()
throws IOException {
Random rng = new Random();
String testString = "This string tests readLine";
double testDouble = rng.nextDouble();
int testInteger = rng.nextInt();
File testFile = new File(TEST_DIRECTORY + "shortReadWriteTestFile.txt");
DataOutputStream outputStream = new DataOutputStream(new FileOutputStream(testFile));
outputStream.writeDouble(testDouble);
outputStream.writeInt(testInteger);
outputStream.writeBytes(testString + "\n");
outputStream.close();
DataInputStream inputStream = new DataInputStream(new FileInputStream(testFile));
double doubleReadBack = inputStream.readDouble();
int integerReadBack = inputStream.readInt();
BufferedReader bufferedReader =
new BufferedReader(new InputStreamReader(inputStream, "US-ASCII"));
String lineReadBack = bufferedReader.readLine();
inputStream.close();
bufferedReader.close();
System.out.println(lineReadBack);
System.out.println(testString);
assertTrue(testDouble == doubleReadBack);
assertTrue(testString.equals(lineReadBack));
assertTrue(testInteger == integerReadBack);
}
@SuppressWarnings("deprecation")
@DeployableTestMethod
@Test(timeout = 300000)
public void testFileReadAndWriteWithDataOutputStreamAndDataInputStream()
throws IOException, FileNotFoundException, NullPointerException {
Random rng = new Random();
String testString = "This string tests readLine";
double testDouble = rng.nextDouble();
int testInteger = rng.nextInt();
File testFile = new File(TEST_DIRECTORY + "shortReadWriteTestFile.txt");
DataOutputStream outputStream = new DataOutputStream(new FileOutputStream(testFile));
outputStream.writeDouble(testDouble);
outputStream.writeBytes(testString + "\n");
outputStream.writeInt(testInteger);
outputStream.close();
DataInputStream inputStream = new DataInputStream(new FileInputStream(testFile));
double doubleReadBack = inputStream.readDouble();
String lineReadBack = inputStream.readLine();
int integerReadBack = inputStream.readInt();
assertTrue(testDouble == doubleReadBack);
assertTrue(testString.equals(lineReadBack));
assertTrue(testInteger == integerReadBack);
}
/**
* Reads a double value from the file.
*
* @return
*/
public double readDouble() {
try {
return m_reader.readDouble();
} catch (IOException e) {
return 0;
}
}
/**
* Load ensemble from file_name
*
* @param file_name File name
*/
public void LoadEnsemble(String file_name) {
String name;
// Load networks
for (int i = 0; i < Nnetworks; i++) {
name = file_name + "_net_" + i;
nets[i].LoadNetwork(name);
}
// Load weigths
try {
FileInputStream file = new FileInputStream(file_name);
DataInputStream dataIn = new DataInputStream(file);
// Load weights
for (int i = 0; i < Noutputs; i++) {
for (int j = 0; j < Nnetworks; j++) {
weights[i][j] = dataIn.readDouble();
}
}
dataIn.close();
} catch (FileNotFoundException ex) {
System.err.println("Unable to open ensemble files");
System.exit(1);
} catch (IOException ex) {
System.err.println("IO exception");
System.exit(1);
}
}
private static double[] byteToDouble(byte[] data) throws IOException {
int len = data.length;
if (len % WORDSIZE != 0) {
throw new IOException("Array length is not divisible by wordsize");
}
int size = len / WORDSIZE;
double[] result = new double[size];
DataInputStream inputStream = new DataInputStream(new ByteArrayInputStream(data));
try {
int ii = 0;
while (inputStream.available() > 0) {
result[ii] = inputStream.readDouble();
ii++;
}
} catch (EOFException e) {
throw new IOException("Unable to read from dataInputStream, found EOF");
} catch (IOException e) {
throw new IOException("Unable to read from dataInputStream, IO error");
}
return result;
}
private static void dataStreams() throws IOException {
DataOutputStream out =
new DataOutputStream(new BufferedOutputStream(new FileOutputStream(dataFile)));
for (int i = 0; i < prices.length; i++) {
out.writeDouble(prices[i]);
out.writeInt(units[i]);
out.writeUTF(descs[i]);
}
DataInputStream in =
new DataInputStream(new BufferedInputStream(new FileInputStream(dataFile)));
double price;
int unit;
String desc;
double total = 0.0;
try {
while (true) {
price = in.readDouble();
unit = in.readInt();
desc = in.readUTF();
System.out.format("You ordered %d" + " units of %s at $%.2f%n", unit, desc, price);
total += unit * price;
}
} catch (EOFException e) {
}
}
public static void main(String[] args) throws IOException {
// Create a FileOutputStream.
FileOutputStream outputFile = new FileOutputStream("primitives.data");
// Create a DataOutputStream which is chained to the FileOutputStream.
DataOutputStream outputStream = new DataOutputStream(outputFile);
// Write Java primitive values in binary representation:
outputStream.writeBoolean(true);
outputStream.writeChar('A'); // int written as Unicode char
outputStream.writeByte(Byte.MAX_VALUE); // int written as 8-bits byte
outputStream.writeShort(Short.MIN_VALUE); // int written as 16-bits short
outputStream.writeInt(Integer.MAX_VALUE);
outputStream.writeLong(Long.MIN_VALUE);
outputStream.writeFloat(Float.MAX_VALUE);
outputStream.writeDouble(Math.PI);
// Close the output stream, which also closes the underlying stream.
outputStream.flush();
outputStream.close();
// Create a FileInputStream.
FileInputStream inputFile = new FileInputStream("primitives.data");
// Create a DataInputStream which is chained to the FileInputStream.
DataInputStream inputStream = new DataInputStream(inputFile);
// Read the binary representation of Java primitive values
// in the same order they were written out:
boolean v = inputStream.readBoolean();
char c = inputStream.readChar();
byte b = inputStream.readByte();
short s = inputStream.readShort();
int i = inputStream.readInt();
long l = inputStream.readLong();
float f = inputStream.readFloat();
double d = inputStream.readDouble();
// Check for end of stream:
try {
int value = inputStream.readByte();
System.out.println("More input: " + value);
} catch (EOFException eofe) {
System.out.println("End of stream");
} finally {
// Close the input stream, which also closes the underlying stream.
inputStream.close();
}
// Write the values read to the standard input stream:
System.out.println("Values read:");
System.out.println(v);
System.out.println(c);
System.out.println(b);
System.out.println(s);
System.out.println(i);
System.out.println(l);
System.out.println(f);
System.out.println(d);
}
public static void main(String[] args) throws IOException {
DataInputStream in = null;
DataOutputStream out = null;
try {
out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(dataFile)));
for (int i = 0; i < prices.length; i++) {
out.writeDouble(prices[i]);
out.writeInt(units[i]);
out.writeUTF(desks[i]);
}
out.close();
in = new DataInputStream(new BufferedInputStream(new FileInputStream(dataFile)));
while (true) {
double price = in.readDouble();
int unit = in.readInt();
String desc = in.readUTF();
System.out.format("You ordered %d units of %s $%.2f%n", unit, desc, price);
double total = unit * price;
}
} catch (EOFException e) {
System.out.println("Reached end of file");
} catch (IOException e) {
e.printStackTrace();
} finally {
if (in != null) {
in.close();
}
}
}
public static void main(String[] args) throws IOException {
try (DataOutputStream dout = new DataOutputStream(new FileOutputStream("Test.dat"))) {
dout.writeDouble(98.6);
dout.writeInt(123);
dout.writeBoolean(true);
} catch (FileNotFoundException e) {
System.out.println("Cannot Open Output");
return;
} catch (IOException e) {
System.out.println("I/O Ero " + e);
}
try (DataInputStream din = new DataInputStream(new FileInputStream("Test.dat"))) {
double d = din.readDouble();
int i = din.readInt();
boolean b = din.readBoolean();
System.out.println("Gere are the values " + b + " " + i + " " + d);
} catch (FileNotFoundException e) {
System.out.println("Cannot Open Output");
return;
} catch (IOException e) {
System.out.println("I/O Ero " + e);
}
}
private static void getMedicineList(Socket socket) {
int medicineID;
String medicineName;
String medicineUnit;
double price;
try {
OutputStream output = socket.getOutputStream();
DataOutputStream dos = new DataOutputStream(output);
InputStream input = socket.getInputStream();
DataInputStream dis = new DataInputStream(input);
dos.writeInt(8);
int numberOfMedicine = dis.readInt();
for (int i = 0; i < numberOfMedicine; i++) {
medicineID = dis.readInt();
medicineName = dis.readUTF();
medicineUnit = dis.readUTF();
price = dis.readDouble();
medicineList.add(new Medicine(medicineID, medicineName, medicineUnit, price));
}
} catch (IOException e) {
System.out.println("Cannot get IO streams.");
}
}
@Override
public void run() {
while (true)
try {
switch (inputStream.readUTF()) {
case "GetAllEdges":
level = inputStream.readInt();
GetAllEdges();
break;
case "GetEdges":
level = inputStream.readInt();
GetEdges();
break;
case "ChangeZoomLevel":
zoom = inputStream.readDouble();
offset = (kpSize - zoom) / 2;
GetEdges();
break;
}
} catch (IOException e) {
e.printStackTrace();
break;
}
}
/**
* See if there are array elements.
*
* @param dbl0 Value of the first (maybe only) array element
* @param result ResultSet for the sample table with blob
* @return Array with given element and maybe more.
* @throws Exception on error, including 'cancel'
*/
private double[] readBlobArrayElements(final double dbl0, final ResultSet result)
throws Exception {
final String datatype;
if (reader.isOracle()) datatype = result.getString(7);
else datatype = result.getString(8);
// ' ' or NULL indicate: Scalar, not an array
if (datatype == null || " ".equals(datatype) || result.wasNull()) return new double[] {dbl0};
// Decode BLOB
final byte[] bytes = result.getBytes(reader.isOracle() ? 8 : 9);
final ByteArrayInputStream stream = new ByteArrayInputStream(bytes);
final DataInputStream data = new DataInputStream(stream);
if ("d".equals(datatype)) { // Read Double typed array elements
final int nelm = data.readInt();
final double[] array = new double[nelm];
for (int i = 0; i < nelm; i++) array[i] = data.readDouble();
data.close();
return array;
}
// TODO Decode 'l' Long and 'i' Integer?
else {
throw new Exception("Sample BLOBs of type '" + datatype + "' are not decoded");
}
}
public static void main(String[] args) throws IOException {
// open file output stream
File outFile = new File("data");
FileOutputStream outStream = new FileOutputStream(outFile);
DataOutputStream outDataStream = new DataOutputStream(outStream);
// write an int, boolean, double
outDataStream.writeInt(44);
outDataStream.writeBoolean(true);
outDataStream.writeDouble(7.2);
outDataStream.close();
// open file input stream
File inFile = new File("data");
FileInputStream inStream = new FileInputStream(inFile);
DataInputStream inDataStream = new DataInputStream(inStream);
// read an int, boolean, double
int n = inDataStream.readInt();
boolean b = inDataStream.readBoolean();
double d = inDataStream.readDouble();
inDataStream.close();
// what did we get?
System.out.println("n = " + n);
System.out.println("b = " + b);
System.out.println("d = " + d);
// can we add n to d?
System.out.println("n + d = " + (n + d));
}
private double readDouble() {
try {
return inStream.readDouble();
} catch (IOException e) {
IOError();
}
return 0;
}
public Object read(DataInputStream in) throws IOException {
nRows = in.readInt();
nCols = in.readInt();
items = new double[nRows][nCols];
for (int i = 0; i < items.length; i++)
for (int j = 0; j < items[i].length; j++) items[i][j] = in.readDouble();
return this;
}
@Override
public double readDouble() throws IOException {
if (bigEndian()) {
return dataInput.readDouble();
} else {
return Double.longBitsToDouble(readLong());
}
}
public static final BinaryIOClass readFromFile(String filename) throws IOException {
DataInputStream dis = new DataInputStream(new FileInputStream(filename));
int integer = dis.readInt();
double decimal = dis.readDouble();
char character = dis.readChar();
return new BinaryIOClass(integer, decimal, character);
}
@Override
public MeanInts.CountSum decode(InputStream inStream, Context context)
throws CoderException, IOException {
DataInputStream dataStream = new DataInputStream(inStream);
long count = dataStream.readLong();
double sum = dataStream.readDouble();
return (new MeanInts()).new CountSum(count, sum);
}
