Clean up streams and write README.

Author: Moderocky

README.md

@@ -0,0 +1,38 @@
+Jupiter
+=====
+
+### Opus #15
+
+A library for working with common Input/Output routes and providing better utilities for Java's I/O streams.
+
+## Maven Information
+```xml
+<repository>
+ <id>kenzie</id>
+ <name>Kenzie's Repository</name>
+ <url>https://repo.kenzie.mx/releases</url>
+</repository>
+``` 
+
+```xml
+<dependency>
+ <groupId>mx.kenzie</groupId>
+ <artifactId>jupiter</artifactId>
+ <version>1.0.0</version>
+</dependency>
+```
+
+## Description
+
+Jupiter provides a set of utilities for working with streams and channels, to make integrating them easier and to reduce the amount of necessary boilerplate for common tasks.
+
+These utilities include:
+1. Synchronization locks for streams (where multithreaded access would normally be dangerous)
+2. Stream controllers that can perform simple conversion tasks
+3. Forking, locking and wrapping streams with automatic resource disposal
+
+There are also more advanced utilities for handling complex socket connections.
+
+The `SocketPair` provides a smart two-way socket channel between two known addresses with automatic host/guest deference.
+
+The `SocketHub` provides a fluid-size socket network connection for organising channels between an unknown set of guests.

src/main/java/mx/kenzie/jupiter/socket/SocketHub.java

@@ -10,12 +10,9 @@
 import java.util.Collections;
 import java.util.List;
 
+@SuppressWarnings("unused")
 public class SocketHub extends Thread implements AutoCloseable {
 
- public static final byte
- JOIN = 1,
- FAIL = 2,
- LEAVE = 3;
  private static final ByteBuffer BUFFER = ByteBuffer.allocate(4);
  protected final ServerSocket central;
  protected final List<Socket> list = Collections.synchronizedList(new ArrayList<>());

src/main/java/mx/kenzie/jupiter/socket/SocketPair.java

@@ -6,6 +6,7 @@
 import java.net.ServerSocket;
 import java.net.Socket;
 
+@SuppressWarnings("unused")
 public class SocketPair extends Thread implements AutoCloseable {
 
  protected final Object lock = new Object();
@@ -14,7 +15,6 @@ public class SocketPair extends Thread implements AutoCloseable {
  protected SocketOpeningProcess process;
 
  protected SocketPair() {
- 
  }
 
  public static Builder host(int port) {

src/main/java/mx/kenzie/jupiter/stream/InputStreamController.java

@@ -5,6 +5,7 @@
 import java.io.OutputStream;
 import java.nio.ByteBuffer;
 
+@SuppressWarnings("unused")
 public class InputStreamController extends InputStream implements StreamController {
 
  protected final InputStream stream;

src/main/java/mx/kenzie/jupiter/stream/OutputStreamController.java

@@ -5,6 +5,7 @@
 import java.io.OutputStream;
 import java.nio.ByteBuffer;
 
+@SuppressWarnings("unused")
 public class OutputStreamController extends OutputStream implements StreamController {
 
  protected final OutputStream stream;

src/main/java/mx/kenzie/jupiter/stream/SplitStream.java

@@ -4,6 +4,7 @@
 import java.io.OutputStream;
 import java.util.Arrays;
 
+@SuppressWarnings("unused")
 public class SplitStream extends OutputStream implements Stream {
 
  protected static final byte GROW_SIZE = 8;

src/main/java/mx/kenzie/jupiter/stream/Stream.java

@@ -17,4 +17,12 @@ static SplitStream split(OutputStream... streams) {
  return new SplitStream(streams);
  }
 
+ static InputStream synchronize(InputStream stream) {
+ return new SynchronizedInputStream(stream);
+ }
+ 
+ static OutputStream synchronize(OutputStream stream) {
+ return new SynchronizedOutputStream(stream);
+ }
+ 
 }

src/main/java/mx/kenzie/jupiter/stream/StreamController.java

@@ -2,5 +2,4 @@
 
 public interface StreamController extends Stream {
 
-
 }

src/main/java/mx/kenzie/jupiter/stream/SynchronizedInputStream.java

@@ -0,0 +1,83 @@
+package mx.kenzie.jupiter.stream;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+class SynchronizedInputStream extends InputStream {
+ 
+ protected final InputStream stream;
+ 
+ SynchronizedInputStream(InputStream stream) {
+ this.stream = stream;
+ }
+ 
+ @Override
+ public int read() throws IOException {
+ synchronized (stream) {
+ return stream.read();
+ }
+ }
+ 
+ @Override
+ public int read(byte @NotNull [] bytes) throws IOException {
+ synchronized (stream) {
+ return stream.read(bytes);
+ }
+ }
+ 
+ @Override
+ public int read(byte @NotNull [] b, int offset, int length) throws IOException {
+ synchronized (stream) {
+ return stream.read(b, offset, length);
+ }
+ }
+ 
+ @Override
+ public byte[] readAllBytes() throws IOException {
+ synchronized (stream) {
+ return stream.readAllBytes();
+ }
+ }
+ 
+ @Override
+ public byte[] readNBytes(int len) throws IOException {
+ synchronized (stream) {
+ return stream.readNBytes(len);
+ }
+ }
+ 
+ @Override
+ public int readNBytes(byte[] b, int off, int len) throws IOException {
+ synchronized (stream) {
+ return super.readNBytes(b, off, len);
+ }
+ }
+ 
+ @Override
+ public long skip(long n) throws IOException {
+ synchronized (stream) {
+ return super.skip(n);
+ }
+ }
+ 
+ @Override
+ public void skipNBytes(long n) throws IOException {
+ synchronized (stream) {
+ super.skipNBytes(n);
+ }
+ }
+ 
+ @Override
+ public int available() throws IOException {
+ synchronized (stream) {
+ return super.available();
+ }
+ }
+ 
+ @Override
+ public void close() throws IOException {
+ this.stream.close();
+ }
+}

src/main/java/mx/kenzie/jupiter/stream/SynchronizedOutputStream.java

@@ -0,0 +1,48 @@
+package mx.kenzie.jupiter.stream;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+class SynchronizedOutputStream extends OutputStream {
+ 
+ protected final OutputStream stream;
+ 
+ SynchronizedOutputStream(OutputStream stream) {
+ this.stream = stream;
+ }
+ 
+ @Override
+ public void write(byte @NotNull [] bytes) throws IOException {
+ synchronized (stream) {
+ super.write(bytes);
+ }
+ }
+ 
+ @Override
+ public void write(byte @NotNull [] bytes, int offset, int length) throws IOException {
+ synchronized (stream) {
+ super.write(bytes, offset, length);
+ }
+ }
+ 
+ @Override
+ public void flush() throws IOException {
+ synchronized (stream) {
+ stream.flush();
+ }
+ }
+ 
+ @Override
+ public void write(int b) throws IOException {
+ synchronized (stream) {
+ stream.write(b);
+ }
+ }
+ 
+ @Override
+ public void close() throws IOException {
+ this.stream.close();
+ }
+}