rename minecraft folder to `targets

targets/java/include/java/InputOutputStream/BufferedOutputStream.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <stdint.h>
+#include <vector>
+#include <cstdint>
+#include <vector>
+
+#include "OutputStream.h"
+
+class BufferedOutputStream : public OutputStream {
+private:
+    OutputStream* stream;
+
+protected:
+    std::vector<uint8_t> buf;       // The internal buffer where data is stored.
+    unsigned int count;  // The number of valid bytes in the buffer.
+
+public:
+    BufferedOutputStream(OutputStream* out, int size);
+    ~BufferedOutputStream();
+
+    virtual void flush();
+    virtual void close();
+    virtual void write(const std::vector<uint8_t>& b, unsigned int offset, unsigned int length);
+    virtual void write(const std::vector<uint8_t>& b);
+    virtual void write(unsigned int b);
+};

targets/java/include/java/InputOutputStream/BufferedReader.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "Reader.h"
+
+#include <string>
+
+class BufferedReader : public Reader {
+private:
+    Reader* reader;
+    wchar_t* buffer;
+
+    unsigned int readMark;
+    unsigned int bufferedMark;
+    unsigned int bufferSize;
+    bool eofReached;
+
+    static const unsigned int BUFFER_MORE_AMOUNT = 64;
+    void bufferMore();
+
+public:
+    BufferedReader(Reader* in);
+    virtual ~BufferedReader();
+
+    virtual void close();
+    virtual int read();
+    virtual int read(wchar_t cbuf[], unsigned int off, unsigned int len);
+    std::wstring readLine();
+};

targets/java/include/java/InputOutputStream/ByteArrayInputStream.h

@@ -0,0 +1,38 @@
+#pragma once
+// 4J Stu - Represents Java standard library class
+
+#include <vector>
+#include <cstdint>
+
+#include "InputStream.h"
+
+class ByteArrayInputStream : public InputStream {
+protected:
+    std::vector<uint8_t> buf;  // An array of bytes that was provided by the creator of the
+                    // stream.
+    unsigned int count;  // The index one greater than the last valid character
+                         // in the input stream buffer.
+    unsigned int mark;   // The currently marked position in the stream.
+    unsigned int pos;  // The index of the next character to read from the input
+                       // stream buffer.
+
+public:
+    ByteArrayInputStream(std::vector<uint8_t>& buf, unsigned int offset,
+                         unsigned int length);
+    ByteArrayInputStream(std::vector<uint8_t>& buf);
+    virtual ~ByteArrayInputStream();
+    virtual int read();
+    virtual int read(std::vector<uint8_t>& b);
+    virtual int read(std::vector<uint8_t>& b, unsigned int offset, unsigned int length);
+    virtual void close();
+    virtual int64_t skip(int64_t n);
+
+    // 4J Stu Added - Sometimes we don't want to delete the data on destroying
+    // this
+    void reset() {
+        buf = std::vector<uint8_t>();
+        count = 0;
+        mark = 0;
+        pos = 0;
+    }
+};

targets/java/include/java/InputOutputStream/ByteArrayOutputStream.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "OutputStream.h"
+
+#include <vector>
+#include <cstdint>
+
+class ByteArrayOutputStream : public OutputStream {
+    // Note - when actually implementing, std::vector<uint8_t> will need to grow as data is
+    // written
+public:
+    std::vector<uint8_t> buf;  // The buffer where data is stored.
+
+protected:
+    unsigned int count;  // The number of valid bytes in the buffer.
+
+public:
+    ByteArrayOutputStream();
+    ByteArrayOutputStream(unsigned int size);
+    virtual ~ByteArrayOutputStream();
+
+    virtual void flush() {}
+    virtual void write(unsigned int b);
+    virtual void write(const std::vector<uint8_t>& b);
+    virtual void write(const std::vector<uint8_t>& b, unsigned int offset, unsigned int length);
+    virtual void close();
+    virtual std::vector<uint8_t> toByteArray();
+
+    void reset() { count = 0; }
+    unsigned int size() { return count; }
+};

targets/java/include/java/InputOutputStream/DataInput.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <vector>
+#include <string>
+#include <cstdint>
+
+class DataInput {
+public:
+    virtual int read() = 0;
+    virtual int read(std::vector<uint8_t>& b) = 0;
+    virtual int read(std::vector<uint8_t>& b, unsigned int offset, unsigned int length) = 0;
+    virtual bool readBoolean() = 0;
+    virtual uint8_t readByte() = 0;
+    virtual unsigned char readUnsignedByte() = 0;
+    virtual bool readFully(std::vector<uint8_t>& a) = 0;
+    virtual double readDouble() = 0;
+    virtual float readFloat() = 0;
+    virtual int readInt() = 0;
+    virtual int64_t readLong() = 0;
+    virtual short readShort() = 0;
+    virtual wchar_t readChar() = 0;
+    virtual std::wstring readUTF() = 0;
+    virtual unsigned long long readPlayerUID() = 0;  // 4J Added
+    virtual int skipBytes(int n) = 0;
+};

targets/java/include/java/InputOutputStream/DataInputStream.h

@@ -0,0 +1,39 @@
+#pragma once
+// 4J Stu - Represents Java standard library class (although we miss out an
+// intermediate inheritance class that we don't care about)
+
+#include <string>
+#include <cstdint>
+
+#include "InputStream.h"
+#include "DataInput.h"
+
+class DataInputStream : public InputStream, public DataInput {
+private:
+    InputStream* stream;
+
+public:
+    DataInputStream(InputStream* in);
+    virtual int read();
+    virtual int read(std::vector<uint8_t>& b);
+    virtual int read(std::vector<uint8_t>& b, unsigned int offset, unsigned int length);
+    virtual void close();
+    virtual bool readBoolean();
+    virtual uint8_t readByte();
+    virtual unsigned char readUnsignedByte();
+    virtual wchar_t readChar();
+    virtual bool readFully(std::vector<uint8_t>& b);
+    virtual bool readFully(std::vector<char>& b);
+    virtual double readDouble();
+    virtual float readFloat();
+    virtual int readInt();
+    virtual int64_t readLong();
+    virtual short readShort();
+    virtual unsigned short readUnsignedShort();
+    virtual std::wstring readUTF();
+    void deleteChildStream();
+    virtual int readUTFChar();
+    virtual unsigned long long readPlayerUID();  // 4J Added
+    virtual int64_t skip(int64_t n);
+    virtual int skipBytes(int n);
+};

targets/java/include/java/InputOutputStream/DataOutput.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <vector>
+#include <string>
+#include <cstdint>
+
+class DataOutput {
+public:
+    virtual void write(unsigned int b) = 0;
+    virtual void write(const std::vector<uint8_t>& b) = 0;
+    virtual void write(const std::vector<uint8_t>& b, unsigned int offset,
+                       unsigned int length) = 0;
+    virtual void writeByte(uint8_t a) = 0;
+    virtual void writeDouble(double a) = 0;
+    virtual void writeFloat(float a) = 0;
+    virtual void writeInt(int a) = 0;
+    virtual void writeLong(int64_t a) = 0;
+    virtual void writeShort(short a) = 0;
+    virtual void writeBoolean(bool v) = 0;
+    virtual void writeChar(wchar_t v) = 0;
+    virtual void writeChars(const std::wstring& s) = 0;
+    virtual void writeUTF(const std::wstring& a) = 0;
+    virtual void writePlayerUID(unsigned long long player) = 0;  // 4J Added
+};

targets/java/include/java/InputOutputStream/DataOutputStream.h

@@ -0,0 +1,41 @@
+#pragma once
+// 4J Stu - Represents Java standard library class (although we miss out an
+// intermediate inheritance class that we don't care about)
+
+#include <string>
+
+#include "OutputStream.h"
+#include "DataOutput.h"
+
+class DataOutputStream : public OutputStream, public DataOutput {
+private:
+    OutputStream* stream;
+
+protected:
+    int written;  // The number of bytes written to the data output stream so
+                  // far.
+
+public:
+    DataOutputStream(OutputStream* out);
+
+    // 4J Stu Added
+    void deleteChildStream();
+
+    virtual void write(unsigned int b);
+    virtual void write(const std::vector<uint8_t>& b);
+    virtual void write(const std::vector<uint8_t>& b, unsigned int offset, unsigned int length);
+    virtual void close();
+    virtual void writeByte(uint8_t a);
+    virtual void writeDouble(double a);
+    virtual void writeFloat(float a);
+    virtual void writeInt(int a);
+    virtual void writeLong(int64_t a);
+    virtual void writeShort(short a);
+    virtual void writeUnsignedShort(unsigned short a);
+    virtual void writeChar(wchar_t a);
+    virtual void writeChars(const std::wstring& a);
+    virtual void writeBoolean(bool b);
+    virtual void writeUTF(const std::wstring& a);
+    virtual void writePlayerUID(unsigned long long player);
+    virtual void flush();
+};

targets/java/include/java/InputOutputStream/FileInputStream.h

@@ -0,0 +1,23 @@
+#pragma once
+// 4J Stu - Represents Java standard library class
+
+#include <cstdio>
+#include <cstdint>
+
+#include "InputStream.h"
+
+class File;
+
+class FileInputStream : public InputStream {
+public:
+    FileInputStream(const File& file);
+    virtual ~FileInputStream();
+    virtual int read();
+    virtual int read(std::vector<uint8_t>& b);
+    virtual int read(std::vector<uint8_t>& b, unsigned int offset, unsigned int length);
+    virtual void close();
+    virtual int64_t skip(int64_t n);
+
+private:
+    std::FILE* m_fileHandle;
+};

targets/java/include/java/InputOutputStream/FileOutputStream.h

@@ -0,0 +1,22 @@
+#pragma once
+// 4J Stu - Represents Java standard lib abstract
+
+#include <cstdio>
+
+#include "OutputStream.h"
+
+class File;
+
+class FileOutputStream : public OutputStream {
+public:
+    FileOutputStream(const File& file);
+    virtual ~FileOutputStream();
+    virtual void write(unsigned int b);
+    virtual void write(const std::vector<uint8_t>& b);
+    virtual void write(const std::vector<uint8_t>& b, unsigned int offset, unsigned int length);
+    virtual void close();
+    virtual void flush();
+
+private:
+    std::FILE* m_fileHandle;
+};

targets/java/include/java/InputOutputStream/GZIPInputStream.h

@@ -0,0 +1,22 @@
+#pragma once
+// 4J Stu - We are not using GZIP compression, so this is just a pass through
+// class
+
+#include <cstdint>
+
+#include "InputStream.h"
+
+class GZIPInputStream : public InputStream {
+private:
+    InputStream* stream;
+
+public:
+    GZIPInputStream(InputStream* out) : stream(out) {};
+    virtual int read() { return stream->read(); };
+    virtual int read(std::vector<uint8_t>& b) { return stream->read(b); };
+    virtual int read(std::vector<uint8_t>& b, unsigned int offset, unsigned int length) {
+        return stream->read(b, offset, length);
+    };
+    virtual void close() { return stream->close(); };
+    virtual int64_t skip(int64_t n) { return 0; };
+};

targets/java/include/java/InputOutputStream/GZIPOutputStream.h

@@ -0,0 +1,20 @@
+#pragma once
+// 4J Stu - We are not using GZIP compression, so this is just a pass through
+// class
+
+#include "OutputStream.h"
+
+class GZIPOutputStream : public OutputStream {
+private:
+    OutputStream* stream;
+
+public:
+    GZIPOutputStream(OutputStream* out) : stream(out) {};
+    virtual void write(unsigned int b) { stream->write(b); };
+    virtual void write(const std::vector<uint8_t>& b) { stream->write(b); };
+    virtual void write(const std::vector<uint8_t>& b, unsigned int offset, unsigned int length) {
+        stream->write(b, offset, length);
+    };
+    virtual void close() { stream->close(); };
+    virtual void flush() {}
+};

targets/java/include/java/InputOutputStream/InputOutputStream.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "InputStream.h"
+#include "ByteArrayInputStream.h"
+#include "DataInput.h"
+#include "DataInputStream.h"
+#include "FileInputStream.h"
+#include "GZIPInputStream.h"
+
+#include "OutputStream.h"
+#include "ByteArrayOutputStream.h"
+#include "DataOutput.h"
+#include "BufferedOutputStream.h"
+#include "DataOutputStream.h"
+#include "FileOutputStream.h"
+#include "GZIPOutputStream.h"
+
+#include "Reader.h"
+#include "BufferedReader.h"
+#include "InputStreamReader.h"

targets/java/include/java/InputOutputStream/InputStream.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <vector>
+#include <cstdint>
+#include <string>
+
+// 4J Stu - Represents Java standard lib abstract
+
+class InputStream {
+public:
+    virtual ~InputStream() {}
+
+    virtual int read() = 0;
+    virtual int read(std::vector<uint8_t>& b) = 0;
+    virtual int read(std::vector<uint8_t>& b, unsigned int offset, unsigned int length) = 0;
+    virtual void close() = 0;
+    virtual int64_t skip(int64_t n) = 0;
+
+    static InputStream* getResourceAsStream(const std::wstring& fileName);
+};

targets/java/include/java/InputOutputStream/InputStreamReader.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "Reader.h"
+#include "DataInputStream.h"
+
+class InputStream;
+
+class InputStreamReader : public Reader {
+private:
+    DataInputStream* stream;
+
+public:
+    InputStreamReader(InputStream* in);
+
+    virtual void close();
+    virtual int read();
+    virtual int read(wchar_t cbuf[], unsigned int offset, unsigned int length);
+};

targets/java/include/java/InputOutputStream/OutputStream.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <vector>
+#include <cstdint>
+
+// 4J Stu - Represents Java standard lib abstract
+
+class OutputStream {
+public:
+    virtual ~OutputStream() {}
+
+    virtual void write(unsigned int b) = 0;
+    virtual void write(const std::vector<uint8_t>& b) = 0;
+    virtual void write(const std::vector<uint8_t>& b, unsigned int offset,
+                       unsigned int length) = 0;
+    virtual void close() = 0;
+    virtual void flush() = 0;
+};

targets/java/include/java/InputOutputStream/Reader.h

@@ -0,0 +1,13 @@
+#pragma once
+
+class Reader {
+public:
+    virtual ~Reader() {}
+
+    virtual void close() = 0;  // Closes the stream and releases any system
+                               // resources associated with it.
+    virtual int read() = 0;    // Reads a single character.
+    virtual int read(
+        wchar_t cbuf[], unsigned int off,
+        unsigned int len) = 0;  // Reads characters into a portion of an array.
+};