Export from java-mammoth 5f538798b147f0e76

36 files changed, 619 insertions, 0 deletions

diff --git a/Mammoth/Couscous/java/io/Closeable.cs b/Mammoth/Couscous/java/io/Closeable.cs
new file mode 100644
index 0000000..9dc10c5
--- /dev/null
+++ b/Mammoth/Couscous/java/io/Closeable.cs
@@ -0,0 +1,8 @@
+using System;
+
+namespace Mammoth.Couscous.java.io {
+	internal interface Closeable {
+		void close();
+	}
+}
+
diff --git a/Mammoth/Couscous/java/io/File.cs b/Mammoth/Couscous/java/io/File.cs
new file mode 100644
index 0000000..abff40a
--- /dev/null
+++ b/Mammoth/Couscous/java/io/File.cs
@@ -0,0 +1,15 @@
+using Mammoth.Couscous.java.nio.file;
+
+namespace Mammoth.Couscous.java.io {
+    internal class File {
+        internal string Path { get; }
+        
+        internal File(string path) {
+            Path = path;
+        }
+        
+        internal Path toPath() {
+            return new Path(Path);
+        }
+    }
+}
diff --git a/Mammoth/Couscous/java/io/IOException.cs b/Mammoth/Couscous/java/io/IOException.cs
new file mode 100644
index 0000000..f7b708e
--- /dev/null
+++ b/Mammoth/Couscous/java/io/IOException.cs
@@ -0,0 +1,17 @@
+using System;
+
+namespace Mammoth.Couscous.java.io
+{
+	internal class IOException : Exception {
+		internal IOException() : base() {
+		}
+		
+		internal IOException(string message) : base(message) {
+		}
+		
+		internal string getMessage() {
+			return Message;
+		}
+	}
+}
+
diff --git a/Mammoth/Couscous/java/io/InputStream.cs b/Mammoth/Couscous/java/io/InputStream.cs
new file mode 100644
index 0000000..b474bb8
--- /dev/null
+++ b/Mammoth/Couscous/java/io/InputStream.cs
@@ -0,0 +1,5 @@
+namespace Mammoth.Couscous.java.io {
+    internal interface InputStream {
+        System.IO.Stream Stream { get; }
+    }
+}
diff --git a/Mammoth/Couscous/java/lang/IllegalArgumentException.cs b/Mammoth/Couscous/java/lang/IllegalArgumentException.cs
new file mode 100644
index 0000000..57ef62b
--- /dev/null
+++ b/Mammoth/Couscous/java/lang/IllegalArgumentException.cs
@@ -0,0 +1,8 @@
+using System;
+
+namespace Mammoth.Couscous.java.lang {
+	internal class IllegalArgumentException : RuntimeException {
+        internal IllegalArgumentException(string message) : base(message) {
+        }
+	}
+}
diff --git a/Mammoth/Couscous/java/lang/IndexOutOfBoundsException.cs b/Mammoth/Couscous/java/lang/IndexOutOfBoundsException.cs
new file mode 100644
index 0000000..c56c7c1
--- /dev/null
+++ b/Mammoth/Couscous/java/lang/IndexOutOfBoundsException.cs
@@ -0,0 +1,7 @@
+using System;
+
+namespace Mammoth.Couscous.java.lang {
+	internal class IndexOutOfBoundsException : RuntimeException {
+	}
+}
+
diff --git a/Mammoth/Couscous/java/lang/Iterable.cs b/Mammoth/Couscous/java/lang/Iterable.cs
new file mode 100644
index 0000000..d050b06
--- /dev/null
+++ b/Mammoth/Couscous/java/lang/Iterable.cs
@@ -0,0 +1,5 @@
+namespace Mammoth.Couscous.java.lang {
+    internal interface Iterable<out T> {
+        java.util.Iterator<T> iterator();
+    }
+}
diff --git a/Mammoth/Couscous/java/lang/RuntimeException.cs b/Mammoth/Couscous/java/lang/RuntimeException.cs
new file mode 100644
index 0000000..cf882aa
--- /dev/null
+++ b/Mammoth/Couscous/java/lang/RuntimeException.cs
@@ -0,0 +1,13 @@
+using System;
+
+namespace Mammoth.Couscous.java.lang
+{
+	internal class RuntimeException : Exception {
+		internal RuntimeException() : base() {
+		}
+		
+		internal RuntimeException(string message) : base(message) {
+		}
+	}
+}
+
diff --git a/Mammoth/Couscous/java/lang/String.cs b/Mammoth/Couscous/java/lang/String.cs
new file mode 100644
index 0000000..bd0838d
--- /dev/null
+++ b/Mammoth/Couscous/java/lang/String.cs
@@ -0,0 +1,7 @@
+namespace Mammoth.Couscous.java.lang {
+    internal partial class String {
+        internal static string join(string separator, Iterable<string> values) {
+            return string.Join(separator, FromJava.IterableToEnumerable(values));
+        }
+    }
+}
diff --git a/Mammoth/Couscous/java/lang/StringBuilder.cs b/Mammoth/Couscous/java/lang/StringBuilder.cs
new file mode 100644
index 0000000..c894936
--- /dev/null
+++ b/Mammoth/Couscous/java/lang/StringBuilder.cs
@@ -0,0 +1,14 @@
+namespace Mammoth.Couscous.java.lang {
+    internal class StringBuilder {
+        private readonly System.Text.StringBuilder _builder = new System.Text.StringBuilder();
+        
+        internal StringBuilder append(string value) {
+            _builder.Append(value);
+            return this;
+        }
+        
+        internal string toString() {
+            return _builder.ToString();
+        }
+    }
+}
diff --git a/Mammoth/Couscous/java/lang/UnsupportedOperationException.cs b/Mammoth/Couscous/java/lang/UnsupportedOperationException.cs
new file mode 100644
index 0000000..da86874
--- /dev/null
+++ b/Mammoth/Couscous/java/lang/UnsupportedOperationException.cs
@@ -0,0 +1,7 @@
+using System;
+
+namespace Mammoth.Couscous.java.lang {
+	internal class UnsupportedOperationException : RuntimeException {
+	}
+}
+
diff --git a/Mammoth/Couscous/java/math/BigInteger.cs b/Mammoth/Couscous/java/math/BigInteger.cs
new file mode 100644
index 0000000..40ac3d3
--- /dev/null
+++ b/Mammoth/Couscous/java/math/BigInteger.cs
@@ -0,0 +1,24 @@
+namespace Mammoth.Couscous.java.math {
+    internal class BigInteger {
+        internal static readonly BigInteger _ONE = new BigInteger(1);
+        
+        // TOOD: use proper BigInteger
+        private readonly long _value;
+        
+        internal BigInteger(string value) {
+            _value = long.Parse(value);
+        }
+        
+        internal BigInteger(long value) {
+            _value = value;
+        }
+        
+        internal BigInteger subtract(BigInteger other) {
+            return new BigInteger(_value - other._value);
+        }
+        
+        internal string toString() {
+            return _value.ToString();
+        }
+    }
+}
diff --git a/Mammoth/Couscous/java/net/URI.cs b/Mammoth/Couscous/java/net/URI.cs
new file mode 100644
index 0000000..818d694
--- /dev/null
+++ b/Mammoth/Couscous/java/net/URI.cs
@@ -0,0 +1,42 @@
+using System;
+
+namespace Mammoth.Couscous.java.net {
+    internal class URI {
+        private readonly Uri _uri;
+        
+        internal URI(string uri) {
+            try {
+                _uri = new Uri(uri, UriKind.RelativeOrAbsolute);
+            } catch (UriFormatException exception) {
+                throw new URISyntaxException(exception.Message);
+            }
+        }
+        
+        internal URI(Uri uri) {
+            _uri = uri;
+        }
+        
+        internal bool isAbsolute() {
+            return _uri.IsAbsoluteUri;
+        }
+        
+        internal URL toURL() {
+            return new URL(_uri.ToString());
+        }
+        
+        internal URI resolve(string relativeUri) {
+            if (new URI(relativeUri).isAbsolute()) {
+                return new URI(relativeUri);
+            } else if (_uri.IsAbsoluteUri) {
+                return new URI(new Uri(_uri, relativeUri));
+            } else {
+                var path = _uri.ToString();
+                var lastSlashIndex = path.LastIndexOf("/");
+                var basePath = lastSlashIndex == -1
+                    ?  "."
+                    : path.Substring(0, lastSlashIndex + 1);
+                return new URI(basePath + relativeUri);
+            }
+        }
+    }
+}
diff --git a/Mammoth/Couscous/java/net/URISyntaxException.cs b/Mammoth/Couscous/java/net/URISyntaxException.cs
new file mode 100644
index 0000000..7380ff6
--- /dev/null
+++ b/Mammoth/Couscous/java/net/URISyntaxException.cs
@@ -0,0 +1,6 @@
+namespace Mammoth.Couscous.java.net {
+    internal class URISyntaxException : System.Exception {
+        internal URISyntaxException(string message) : base(message) {
+        }
+    }
+}
diff --git a/Mammoth/Couscous/java/net/URL.cs b/Mammoth/Couscous/java/net/URL.cs
new file mode 100644
index 0000000..88479e8
--- /dev/null
+++ b/Mammoth/Couscous/java/net/URL.cs
@@ -0,0 +1,28 @@
+using System.Net;
+using Mammoth.Couscous.java.io;
+
+namespace Mammoth.Couscous.java.net {
+    internal class URL {
+        private readonly string _url;
+        
+        internal URL(string url) {
+            _url = url;
+        }
+        
+        internal InputStream openStream() {
+            try {
+                var response = WebRequest.Create(_url).GetResponse();
+                try {
+                    return ToJava.StreamToInputStream(response.GetResponseStream());
+                } catch {
+                    response.Close();
+                    throw;
+                }
+            } catch (System.UriFormatException) {
+                return ToJava.StreamToInputStream(System.IO.File.OpenRead(_url));
+            } catch (System.Net.WebException exception) {
+                throw new java.io.IOException(exception.Message);
+            }
+        }
+    }
+}
diff --git a/Mammoth/Couscous/java/nio/file/Path.cs b/Mammoth/Couscous/java/nio/file/Path.cs
new file mode 100644
index 0000000..030f757
--- /dev/null
+++ b/Mammoth/Couscous/java/nio/file/Path.cs
@@ -0,0 +1,16 @@
+using Mammoth.Couscous.java.net;
+
+namespace Mammoth.Couscous.java.nio.file {
+	internal class Path {
+		private readonly string _path;
+		
+		internal Path(string path) {
+			_path = path;
+		}
+
+        internal URI toUri() {
+            return new URI(_path);
+        }
+	}
+}
+
diff --git a/Mammoth/Couscous/java/util/ArrayDeque.cs b/Mammoth/Couscous/java/util/ArrayDeque.cs
new file mode 100644
index 0000000..df5447d
--- /dev/null
+++ b/Mammoth/Couscous/java/util/ArrayDeque.cs
@@ -0,0 +1,35 @@
+namespace Mammoth.Couscous.java.util {
+    internal class ArrayDeque<T> : Deque<T> {
+        private readonly System.Collections.Generic.IList<T> _list = new System.Collections.Generic.List<T>();
+        
+        public int size() {
+            return _list.Count;
+        }
+        
+        public T getFirst() {
+            if (_list.Count > 0) {
+                return _list[0];
+            } else {
+                throw new NoSuchElementException();
+            }
+        }
+        
+        public T getLast() {
+            if (_list.Count > 0) {
+                return _list[_list.Count - 1];
+            } else {
+                throw new NoSuchElementException();
+            }
+        }
+        
+        public void add(T value) {
+            _list.Add(value);
+        }
+        
+        public T removeLast() {
+            T value = getLast();
+            _list.RemoveAt(_list.Count - 1);
+            return value;
+        }
+    }
+}
diff --git a/Mammoth/Couscous/java/util/ArrayList.cs b/Mammoth/Couscous/java/util/ArrayList.cs
new file mode 100644
index 0000000..4414123
--- /dev/null
+++ b/Mammoth/Couscous/java/util/ArrayList.cs
@@ -0,0 +1,49 @@
+using Mammoth.Couscous.java.lang;
+using Mammoth.Couscous.java.util;
+
+namespace Mammoth.Couscous.java.util {
+    internal class ArrayList<T> : List<T> {
+        private readonly System.Collections.Generic.IList<T> _list;
+        
+        internal ArrayList() : this(new System.Collections.Generic.List<T>()) {
+        }
+        
+        internal ArrayList(System.Collections.Generic.IList<T> list) {
+            _list = list;
+        }
+        
+        public Iterator<T> iterator() {
+            return ToJava.EnumeratorToIterator(_list.GetEnumerator());
+        }
+        
+        public bool isEmpty() {
+            return _list.Count == 0;
+        }
+        
+        public int size() {
+            return _list.Count;
+        }
+        
+        public bool contains(object value) {
+            return value is T && _list.Contains((T) value);
+        }
+        
+        public T get(int index) {
+            if (index < 0 || index >= _list.Count) {
+                throw new IndexOutOfBoundsException();
+            } else {
+                return _list[index];
+            }
+        }
+        
+        public void add(T value) {
+            _list.Add(value);
+        }
+        
+        public T remove(int index) {
+            T value = _list[index];
+            _list.RemoveAt(index);
+            return value;
+        }
+    }
+}
diff --git a/Mammoth/Couscous/java/util/Arrays.cs b/Mammoth/Couscous/java/util/Arrays.cs
new file mode 100644
index 0000000..093db83
--- /dev/null
+++ b/Mammoth/Couscous/java/util/Arrays.cs
@@ -0,0 +1,7 @@
+namespace Mammoth.Couscous.java.util {
+    internal static class Arrays {
+        internal static List<T> asList<T>(T[] elements) {
+            return ToJava.ListToList(elements);
+        }
+    }
+}
diff --git a/Mammoth/Couscous/java/util/Collection.cs b/Mammoth/Couscous/java/util/Collection.cs
new file mode 100644
index 0000000..a0cae74
--- /dev/null
+++ b/Mammoth/Couscous/java/util/Collection.cs
@@ -0,0 +1,11 @@
+using Mammoth.Couscous.java.lang;
+
+namespace Mammoth.Couscous.java.util {
+    interface Collection<T> : Iterable<T> {
+        bool isEmpty();
+        int size();
+        bool contains(object value);
+        
+        void add(T value);
+    }
+}
diff --git a/Mammoth/Couscous/java/util/Deque.cs b/Mammoth/Couscous/java/util/Deque.cs
new file mode 100644
index 0000000..c954fce
--- /dev/null
+++ b/Mammoth/Couscous/java/util/Deque.cs
@@ -0,0 +1,10 @@
+namespace Mammoth.Couscous.java.util {
+    internal interface Deque<T> {
+        int size();
+        T getFirst();
+        T getLast();
+        
+        void add(T value);
+        T removeLast();
+    }
+}
diff --git a/Mammoth/Couscous/java/util/HashMap.cs b/Mammoth/Couscous/java/util/HashMap.cs
new file mode 100644
index 0000000..38e516e
--- /dev/null
+++ b/Mammoth/Couscous/java/util/HashMap.cs
@@ -0,0 +1,69 @@
+using System.Collections.Generic;
+using System.Linq;
+using Mammoth.Couscous.org.zwobble.mammoth.@internal.util;
+using Mammoth.Couscous.java.lang;
+
+namespace Mammoth.Couscous.java.util {
+    internal class HashMap<TKey, TValue> : Map<TKey, TValue> {
+        private readonly IDictionary<TKey, TValue> _dictionary;
+        
+        internal HashMap() : this(new Dictionary<TKey, TValue>()) {
+        }
+        
+        internal HashMap(IDictionary<TKey, TValue> dictionary) {
+            _dictionary = dictionary;
+        }
+        
+        public void put(TKey key, TValue value) {
+            _dictionary[key] = value;
+        }
+        
+        public bool containsKey(TKey key) {
+            return _dictionary.ContainsKey(key);
+        }
+        
+        public Set<Map__Entry<TKey, TValue>> entrySet() {
+            return new EntrySet(_dictionary);
+        }
+        
+        public Optional<TValue> _lookup(TKey key) {
+            if (_dictionary.ContainsKey(key)) {
+                return new Some<TValue>(_dictionary[key]);
+            } else {
+                return new None<TValue>();
+            }
+        }
+        
+        public IDictionary<TKey, TValue> AsDictionary() {
+            return _dictionary;
+        }
+        
+        internal class EntrySet : Set<Map__Entry<TKey, TValue>> {
+            private readonly IDictionary<TKey, TValue> _dictionary;
+            
+            internal EntrySet(IDictionary<TKey, TValue> dictionary) {
+                _dictionary = dictionary;
+            }
+            
+            public Iterator<Map__Entry<TKey, TValue>> iterator() {
+                return ToJava.EnumeratorToIterator(_dictionary.Select(entry => Maps.entry(entry.Key, entry.Value)).GetEnumerator());
+            }
+            
+            public bool isEmpty() {
+                return _dictionary.Count == 0;
+            }
+            
+            public int size() {
+                return _dictionary.Count;
+            }
+            
+            public bool contains(object value) {
+                return value is TKey && _dictionary.ContainsKey((TKey) value);
+            }
+            
+            public void add(Map__Entry<TKey, TValue> value) {
+                throw new UnsupportedOperationException();
+            }
+        }
+    }
+}
diff --git a/Mammoth/Couscous/java/util/HashSet.cs b/Mammoth/Couscous/java/util/HashSet.cs
new file mode 100644
index 0000000..ac10075
--- /dev/null
+++ b/Mammoth/Couscous/java/util/HashSet.cs
@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+
+namespace Mammoth.Couscous.java.util {
+    internal class HashSet<T> : Set<T> {
+        private readonly ISet<T> _set;
+
+        internal HashSet() : this(new System.Collections.Generic.HashSet<T>()) {
+        }
+        
+        internal HashSet(ISet<T> set) {
+            _set = set;
+        }
+        
+        public Iterator<T> iterator() {
+            return ToJava.EnumeratorToIterator(_set.GetEnumerator());
+        }
+        
+        public bool isEmpty() {
+            return _set.Count == 0;
+        }
+        
+        public int size() {
+            return _set.Count;
+        }
+
+        public bool contains(object value) {
+            return value is T && _set.Contains((T)value);
+        }
+        
+        public void add(T value) {
+            _set.Add(value);
+        }
+    }
+}
diff --git a/Mammoth/Couscous/java/util/Iterator.cs b/Mammoth/Couscous/java/util/Iterator.cs
new file mode 100644
index 0000000..0ae48b2
--- /dev/null
+++ b/Mammoth/Couscous/java/util/Iterator.cs
@@ -0,0 +1,6 @@
+namespace Mammoth.Couscous.java.util {
+    internal interface Iterator<out T> {
+        bool hasNext();
+        T next();
+    }
+}
diff --git a/Mammoth/Couscous/java/util/List.cs b/Mammoth/Couscous/java/util/List.cs
new file mode 100644
index 0000000..45a9299
--- /dev/null
+++ b/Mammoth/Couscous/java/util/List.cs
@@ -0,0 +1,8 @@
+using Mammoth.Couscous.java.lang;
+
+namespace Mammoth.Couscous.java.util {
+    interface List<T> : Collection<T> {
+        T get(int index);
+        T remove(int index);
+    }
+}
diff --git a/Mammoth/Couscous/java/util/Map.cs b/Mammoth/Couscous/java/util/Map.cs
new file mode 100644
index 0000000..5405c77
--- /dev/null
+++ b/Mammoth/Couscous/java/util/Map.cs
@@ -0,0 +1,15 @@
+namespace Mammoth.Couscous.java.util {
+    internal interface Map<K, V> {
+	void put(K key, V value);
+	bool containsKey(K key);
+	Set<Map__Entry<K, V>> entrySet();
+	
+        Optional<V> _lookup(K key);
+	System.Collections.Generic.IDictionary<K, V> AsDictionary();
+    }
+    
+    internal interface Map__Entry<K, V> {
+	K getKey();
+	V getValue();
+    }
+}
diff --git a/Mammoth/Couscous/java/util/NoSuchElementException.cs b/Mammoth/Couscous/java/util/NoSuchElementException.cs
new file mode 100644
index 0000000..4a1ee9c
--- /dev/null
+++ b/Mammoth/Couscous/java/util/NoSuchElementException.cs
@@ -0,0 +1,6 @@
+using Mammoth.Couscous.java.lang;
+
+namespace Mammoth.Couscous.java.util {
+    internal class NoSuchElementException : RuntimeException {
+    }
+}
diff --git a/Mammoth/Couscous/java/util/Optional.cs b/Mammoth/Couscous/java/util/Optional.cs
new file mode 100644
index 0000000..f295688
--- /dev/null
+++ b/Mammoth/Couscous/java/util/Optional.cs
@@ -0,0 +1,103 @@
+using System;
+using Mammoth.Couscous.java.util.function;
+
+namespace Mammoth.Couscous.java.util
+{
+    internal interface Optional<T>
+	{
+		bool isPresent();
+		Optional<U> map<U>(Function<T, U> function);
+		Optional<U> flatMap<U>(Function<T, Optional<U>> function);
+		T orElse(T value);
+		T orElseGet(Supplier<T> supplier);
+		T orElseThrow<TException>(Supplier<TException> exceptionSupplier) where TException : Exception;
+		T get();
+		void ifPresent(Consumer<T> consumer);
+    }
+
+	internal class None<T> : Optional<T> {
+		public bool isPresent() {
+			return false;
+		}
+
+		public Optional<U> map<U>(Function<T, U> function) {
+			return new None<U>();
+		}
+
+		public Optional<U> flatMap<U>(Function<T, Optional<U>> function) {
+			return new None<U>();
+		}
+
+		public T orElse(T value) {
+			return value;
+		}
+		
+		public T orElseGet(Supplier<T> supplier) {
+			return supplier.get();
+		}
+		
+		public T orElseThrow<TException>(Supplier<TException> exceptionSupplier) where TException : Exception {
+			throw exceptionSupplier.get();
+		}
+
+		public T get() {
+			throw new NoSuchElementException();
+		}
+		
+		public void ifPresent(Consumer<T> consumer) {
+		}
+	}
+
+	internal class Some<T> : Optional<T> {
+		private readonly T _value;
+
+		internal Some(T value) {
+			_value = value;
+		}
+
+		public bool isPresent() {
+			return true;
+		}
+
+		public Optional<U> map<U>(Function<T, U> function) {
+			return new Some<U>(function.apply(_value));
+		}
+
+		public Optional<U> flatMap<U>(Function<T, Optional<U>> function) {
+			return function.apply(_value);
+		}
+
+		public T orElse(T value) {
+			return _value;
+		}
+		
+		public T orElseGet(Supplier<T> supplier) {
+			return _value;
+		}
+		
+		public T orElseThrow<TException>(Supplier<TException> exceptionSupplier) where TException : Exception {
+			return _value;
+		}
+
+		public T get() {
+			return _value;
+		}
+		
+		public void ifPresent(Consumer<T> consumer) {
+			consumer.accept(_value);
+		}
+	}
+
+    internal static class Optional
+    {
+		internal static Optional<T> empty<T>()
+        {
+			return new None<T>();
+        }
+        
+        internal static Optional<T> of<T>(T value)
+        {
+			return new Some<T> (value);
+        }
+    }
+}
diff --git a/Mammoth/Couscous/java/util/Set.cs b/Mammoth/Couscous/java/util/Set.cs
new file mode 100644
index 0000000..34a23ac
--- /dev/null
+++ b/Mammoth/Couscous/java/util/Set.cs
@@ -0,0 +1,6 @@
+using Mammoth.Couscous.java.lang;
+
+namespace Mammoth.Couscous.java.util {
+    internal interface Set<T> : Collection<T> {
+    }
+}
diff --git a/Mammoth/Couscous/java/util/function/BiConsumer.cs b/Mammoth/Couscous/java/util/function/BiConsumer.cs
new file mode 100644
index 0000000..9479a78
--- /dev/null
+++ b/Mammoth/Couscous/java/util/function/BiConsumer.cs
@@ -0,0 +1,5 @@
+namespace Mammoth.Couscous.java.util.function {
+    internal interface BiConsumer<T1, T2> {
+        void accept(T1 first, T2 second);
+    }
+}
diff --git a/Mammoth/Couscous/java/util/function/BiFunction.cs b/Mammoth/Couscous/java/util/function/BiFunction.cs
new file mode 100644
index 0000000..050f85f
--- /dev/null
+++ b/Mammoth/Couscous/java/util/function/BiFunction.cs
@@ -0,0 +1,6 @@
+namespace Mammoth.Couscous.java.util.function
+{
+    internal interface BiFunction<T1, T2, U> {
+        U apply(T1 first, T2 second);
+    }
+}
\ No newline at end of file
diff --git a/Mammoth/Couscous/java/util/function/BiPredicate.cs b/Mammoth/Couscous/java/util/function/BiPredicate.cs
new file mode 100644
index 0000000..0419a6e
--- /dev/null
+++ b/Mammoth/Couscous/java/util/function/BiPredicate.cs
@@ -0,0 +1,6 @@
+namespace Mammoth.Couscous.java.util.function
+{
+    internal interface BiPredicate<T, U> {
+		bool test(T first, U second);
+    }
+}
\ No newline at end of file
diff --git a/Mammoth/Couscous/java/util/function/Consumer.cs b/Mammoth/Couscous/java/util/function/Consumer.cs
new file mode 100644
index 0000000..f80d426
--- /dev/null
+++ b/Mammoth/Couscous/java/util/function/Consumer.cs
@@ -0,0 +1,5 @@
+namespace Mammoth.Couscous.java.util.function {
+    internal interface Consumer<T> {
+        void accept(T value);
+    }
+}
\ No newline at end of file
diff --git a/Mammoth/Couscous/java/util/function/Function.cs b/Mammoth/Couscous/java/util/function/Function.cs
new file mode 100644
index 0000000..2b4d3ae
--- /dev/null
+++ b/Mammoth/Couscous/java/util/function/Function.cs
@@ -0,0 +1,6 @@
+namespace Mammoth.Couscous.java.util.function
+{
+    internal interface Function<T, U> {
+        U apply(T arg);
+    }
+}
\ No newline at end of file
diff --git a/Mammoth/Couscous/java/util/function/Predicate.cs b/Mammoth/Couscous/java/util/function/Predicate.cs
new file mode 100644
index 0000000..2023309
--- /dev/null
+++ b/Mammoth/Couscous/java/util/function/Predicate.cs
@@ -0,0 +1,5 @@
+namespace Mammoth.Couscous.java.util.function {
+    internal interface Predicate<T> {
+		bool test(T value);
+    }
+}
\ No newline at end of file
diff --git a/Mammoth/Couscous/java/util/function/Supplier.cs b/Mammoth/Couscous/java/util/function/Supplier.cs
new file mode 100644
index 0000000..eab3ffb
--- /dev/null
+++ b/Mammoth/Couscous/java/util/function/Supplier.cs
@@ -0,0 +1,5 @@
+namespace Mammoth.Couscous.java.util.function {
+    internal interface Supplier<T> {
+        T get();
+    }
+}
\ No newline at end of file