Added cubby-holes for new projects.
diff --git a/of-save/lib/src/main/java/org/projectfloodlight/openflow/types/U128.java b/of-save/lib/src/main/java/org/projectfloodlight/openflow/types/U128.java
new file mode 100644
index 0000000..ddf4faa
--- /dev/null
+++ b/of-save/lib/src/main/java/org/projectfloodlight/openflow/types/U128.java
@@ -0,0 +1,222 @@
+package org.projectfloodlight.openflow.types;
+
+import javax.annotation.Nonnull;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+
+import com.google.common.hash.PrimitiveSink;
+import com.google.common.primitives.UnsignedLongs;
+
+public class U128 implements OFValueType<U128>, HashValue<U128> {
+
+ static final int LENGTH = 16;
+
+ private final long raw1; // MSBs
+ private final long raw2; // LSBs
+
+ public static final U128 ZERO = new U128(0, 0);
+
+ private U128(long raw1, long raw2) {
+ this.raw1 = raw1;
+ this.raw2 = raw2;
+ }
+
+ public static U128 of(long raw1, long raw2) {
+ if (raw1 == 0 && raw2 == 0)
+ return ZERO;
+ return new U128(raw1, raw2);
+ }
+
+ @Override
+ public int getLength() {
+ return LENGTH;
+ }
+
+
+ public long getMsb() {
+ return raw1;
+ }
+
+ public long getLsb() {
+ return raw2;
+ }
+
+ @Override
+ public U128 applyMask(U128 mask) {
+ return and(mask);
+ }
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result + (int) (raw1 ^ (raw1 >>> 32));
+ result = prime * result + (int) (raw2 ^ (raw2 >>> 32));
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null)
+ return false;
+ if (getClass() != obj.getClass())
+ return false;
+ U128 other = (U128) obj;
+ if (raw1 != other.raw1)
+ return false;
+ if (raw2 != other.raw2)
+ return false;
+ return true;
+ }
+
+ public void write16Bytes(ChannelBuffer cb) {
+ cb.writeLong(raw1);
+ cb.writeLong(raw2);
+ }
+
+ public static U128 read16Bytes(ChannelBuffer cb) {
+ long raw1 = cb.readLong();
+ long raw2 = cb.readLong();
+ return of(raw1, raw2);
+ }
+
+ @Override
+ public String toString() {
+ return String.format("0x%016x%016x", raw1, raw2);
+ }
+
+ @Override
+ public int compareTo(@Nonnull U128 o) {
+ int msb = UnsignedLongs.compare(this.raw1, o.raw1);
+ if(msb != 0)
+ return msb;
+ else
+ return UnsignedLongs.compare(this.raw2, o.raw2);
+ }
+
+ @Override
+ public void putTo(PrimitiveSink sink) {
+ sink.putLong(raw1);
+ sink.putLong(raw2);
+ }
+
+ @Override
+ public U128 inverse() {
+ return U128.of(~raw1, ~raw2);
+ }
+
+ @Override
+ public U128 or(U128 other) {
+ return U128.of(raw1 | other.raw1, raw2 | other.raw2);
+ }
+
+ @Override
+ public U128 and(U128 other) {
+ return U128.of(raw1 & other.raw1, raw2 & other.raw2);
+ }
+
+ @Override
+ public U128 xor(U128 other) {
+ return U128.of(raw1 ^ other.raw1, raw2 ^ other.raw2);
+ }
+
+ @Override
+ public U128 add(U128 other) {
+ long newRaw2 = this.raw2 + other.raw2;
+ long newRaw1 = this.raw1 + other.raw1;
+ if(UnsignedLongs.compare(newRaw2, this.raw2) < 0) {
+ // raw2 overflow
+ newRaw1+=1;
+ }
+ return U128.of(newRaw1, newRaw2);
+ }
+
+ @Override
+ public U128 subtract(U128 other) {
+ long newRaw2 = this.raw2 - other.raw2;
+ long newRaw1 = this.raw1 - other.raw1;
+ if(UnsignedLongs.compare(this.raw2, other.raw2) < 0) {
+ newRaw1 -= 1;
+ }
+ return U128.of(newRaw1, newRaw2);
+ }
+ @Override
+ public int prefixBits(int numBits) {
+ return HashValueUtils.prefixBits(this.raw1, numBits);
+ }
+
+ @Override
+ public HashValue.Builder<U128> builder() {
+ return new U128Builder(raw1, raw2);
+ }
+
+ static class U128Builder implements HashValue.Builder<U128> {
+ private long raw1, raw2;
+
+ public U128Builder(long raw1, long raw2) {
+ this.raw1 = raw1;
+ this.raw2 = raw2;
+ }
+
+ @Override
+ public Builder<U128> add(U128 other) {
+ raw2 += other.raw2;
+ raw1 += other.raw1;
+ if(UnsignedLongs.compare(raw2, other.raw2) < 0) {
+ // raw2 overflow
+ raw1+=1;
+ }
+ return this;
+ }
+
+ @Override
+ public Builder<U128> subtract(
+ U128 other) {
+ if(UnsignedLongs.compare(this.raw2, other.raw2) >= 0) {
+ raw2 -= other.raw2;
+ raw1 -= other.raw1;
+ } else {
+ // raw2 overflow
+ raw2 -= other.raw2;
+ raw1 = this.raw1 - other.raw1 - 1;
+ }
+ return this;
+ }
+
+ @Override
+ public Builder<U128> invert() {
+ raw1 = ~raw1;
+ raw2 = ~raw2;
+ return this;
+ }
+
+ @Override
+ public Builder<U128> or(U128 other) {
+ raw1 |= other.raw1;
+ raw2 |= other.raw2;
+ return this;
+ }
+
+ @Override
+ public Builder<U128> and(U128 other) {
+ raw1 &= other.raw1;
+ raw2 &= other.raw2;
+ return this;
+ }
+
+ @Override
+ public Builder<U128> xor(U128 other) {
+ raw1 ^= other.raw1;
+ raw2 ^= other.raw2;
+ return this;
+ }
+
+ @Override
+ public U128 build() {
+ return U128.of(raw1, raw2);
+ }
+ }
+
+}