[java] Implemented haxe.io.Input/Output. Needs testing

std/haxe/io/Input.hx

@@ -33,6 +33,8 @@ class Input {
 	public var bigEndian(default,setEndian) : Bool;
 	#if cs
 	private var helper:BytesData;
+	#elseif java
+	private var helper:java.nio.ByteBuffer;
 	#end
 
 	public function readByte() : Int {
@@ -208,6 +210,24 @@ class Input {
 			}
 			
 			return system.BitConverter.ToSingle(helper, 0);
+		#elseif java
+			if (helper == null) helper = java.nio.ByteBuffer.allocateDirect(8);
+			var helper = helper;
+			
+			if ( (helper.order() == java.nio.ByteOrder.BIG_ENDIAN) == bigEndian )
+			{
+				helper.putChar(0, readByte());
+				helper.putChar(1, readByte());
+				helper.putChar(2, readByte());
+				helper.putChar(3, readByte());
+			} else {
+				helper.putChar(3, readByte());
+				helper.putChar(2, readByte());
+				helper.putChar(1, readByte());
+				helper.putChar(0, readByte());
+			}
+			
+			return helper.getFloat();
 		#else
 			var bytes = [];
 			bytes.push(readByte());
@@ -278,6 +298,32 @@ class Input {
 		}
 		
 		return system.BitConverter.ToDouble(helper, 0);
+		#elseif java
+		if (helper == null) helper = java.nio.ByteBuffer.allocateDirect(8);
+		var helper = helper;
+		
+		if ( (helper.order() == java.nio.ByteOrder.BIG_ENDIAN) == bigEndian )
+		{
+			helper.putChar(0, readByte());
+			helper.putChar(1, readByte());
+			helper.putChar(2, readByte());
+			helper.putChar(3, readByte());
+			helper.putChar(4, readByte());
+			helper.putChar(5, readByte());
+			helper.putChar(6, readByte());
+			helper.putChar(7, readByte());
+		} else {
+			helper.putChar(7, readByte());
+			helper.putChar(6, readByte());
+			helper.putChar(5, readByte());
+			helper.putChar(4, readByte());
+			helper.putChar(3, readByte());
+			helper.putChar(2, readByte());
+			helper.putChar(1, readByte());
+			helper.putChar(0, readByte());
+		}
+		
+		return helper.getDouble();
 		#else
 		return throw "not implemented";
 		#end

std/haxe/io/Output.hx

@@ -32,7 +32,11 @@ package haxe.io;
 **/
 class Output {
 	private static var LN2 = Math.log(2);
-	public var bigEndian(default,setEndian) : Bool;
+	public var bigEndian(default, setEndian) : Bool;
+	
+	#if java
+	private var helper:java.nio.ByteBuffer;
+	#end
 
 	public function writeByte( c : Int ) : Void {
 		throw "Not implemented";
@@ -114,6 +118,23 @@ class Output {
 			writeByte(bytes[2]);
 			writeByte(bytes[3]);
 		}
+		#elseif java
+		if (helper == null) helper = java.nio.ByteBuffer.allocateDirect(8);
+		var helper = helper;
+		
+		helper.putFloat(0, x);
+		if ( (helper.order() == java.nio.ByteOrder.BIG_ENDIAN) == bigEndian )
+		{
+			writeByte(helper.get(0));
+			writeByte(helper.get(1));
+			writeByte(helper.get(2));
+			writeByte(helper.get(3));
+		} else {
+			writeByte(helper.get(3));
+			writeByte(helper.get(2));
+			writeByte(helper.get(1));
+			writeByte(helper.get(0));
+		}
 		#else
 		if (x == 0.0)
 		{
@@ -166,6 +187,31 @@ class Output {
 			writeByte(bytes[6]);
 			writeByte(bytes[7]);
 		}
+		#elseif java
+		if (helper == null) helper = java.nio.ByteBuffer.allocateDirect(8);
+		var helper = helper;
+		
+		helper.putDouble(0, x);
+		if ( (helper.order() == java.nio.ByteOrder.BIG_ENDIAN) == bigEndian )
+		{
+			writeByte(helper.get(0));
+			writeByte(helper.get(1));
+			writeByte(helper.get(2));
+			writeByte(helper.get(3));
+			writeByte(helper.get(4));
+			writeByte(helper.get(5));
+			writeByte(helper.get(6));
+			writeByte(helper.get(7));
+		} else {
+			writeByte(helper.get(7));
+			writeByte(helper.get(6));
+			writeByte(helper.get(5));
+			writeByte(helper.get(4));
+			writeByte(helper.get(3));
+			writeByte(helper.get(2));
+			writeByte(helper.get(1));
+			writeByte(helper.get(0));
+		}
 		#else
 		if (x == 0.0) 
 		{

std/java/nio/Buffer.hx

@@ -0,0 +1,18 @@
+package java.nio;
+
+extern class Buffer 
+{
+	function capacity():Int;
+	function clear():Buffer;
+	function flip():Buffer;
+	function hasRemaining():Bool;
+	function isReadOnly():Bool;
+	@:overload(function(newLimit:Int):Buffer {})
+	function limit():Int;
+	function mark():Buffer;
+	@:overload(function(newPosition:Int):Buffer { })
+	function position():Int;
+	function remaining():Int;
+	function reset():Buffer;
+	function rewind():Buffer;
+}

std/java/nio/ByteBuffer.hx

@@ -0,0 +1,73 @@
+package java.nio;
+import haxe.Int64;
+import haxe.io.BytesData;
+import java.StdTypes;
+
+extern class ByteBuffer extends Buffer
+{
+	static function allocate(capacity:Int):ByteBuffer;
+	static function allocateDirect(capacity:Int):ByteBuffer;
+	@:overload(function(arr:BytesData, offset:Int, length:Int):ByteBuffer {})
+	static function wrap(arr:BytesData):ByteBuffer;
+	
+	function array():BytesData;
+	function arrayOffset():Int;
+	
+	function compact():ByteBuffer;
+	function compareTo(obj:Dynamic):Int;
+	
+	function duplicate():ByteBuffer;
+	
+	@:overload(function (dst:BytesData, offset:Int, length:Int):ByteBuffer {})
+	@:overload(function (dst:BytesData):ByteBuffer {})
+	@:overload(function (idx:Int):Int8 {})
+	function get():Int8;
+	
+	@:overload(function (index:Int):Char16 {})
+	function getChar():Char16;
+	
+	@:overload(function (index:Int):Float {})
+	function getDouble():Float;
+	
+	@:overload(function (index:Int):Single {})
+	function getFloat():Single;
+	
+	@:overload(function (index:Int):Int {})
+	function getInt():Int;
+	
+	@:overload(function (index:Int):Int64 {})
+	function getLong():Int64;
+	
+	@:overload(function (index:Int):Int16 {})
+	function getShort():Int16;
+	
+	function hasArray():Bool;
+	function isDirect():Bool;
+	
+	@:overload(function (index:ByteOrder):ByteBuffer {})
+	function order():ByteOrder;
+	
+	@:overload(function (index:Int, b:Int8):ByteBuffer {})
+	@:overload(function (src:ByteBuffer):ByteBuffer {})
+	@:overload(function (src:BytesData, offset:Int, length:Int):ByteBuffer {})
+	@:overload(function (src:BytesData):ByteBuffer {})
+	function put(b:Int8):ByteBuffer;
+	
+	@:overload(function (index:Int, value:Char16):ByteBuffer {})
+	function putChar(value:Char16):ByteBuffer;
+	
+	@:overload(function (index:Int, value:Float):ByteBuffer {})
+	function putDouble(value:Float):ByteBuffer;
+	
+	@:overload(function (index:Int, value:Single):ByteBuffer {})
+	function putFloat(value:Single):ByteBuffer;
+	
+	@:overload(function (index:Int, value:Int):ByteBuffer {})
+	function putInt(value:Int):ByteBuffer;
+	
+	@:overload(function (index:Int, value:Int64):ByteBuffer {})
+	function putLong(value:Int64):ByteBuffer;
+	
+	@:overload(function (index:Int, value:Int16):ByteBuffer {})
+	function putShort(value:Int16):ByteBuffer;
+}

std/java/nio/ByteOrder.hx

@@ -0,0 +1,7 @@
+package java.nio;
+
+extern enum ByteOrder 
+{
+	BIG_ENDIAN;
+	LITTLE_ENDIAN;
+}