diff --git a/lib/xdrgen/generators/java.rb b/lib/xdrgen/generators/java.rb
index 476c1d754..20880628f 100644
--- a/lib/xdrgen/generators/java.rb
+++ b/lib/xdrgen/generators/java.rb
@@ -26,6 +26,14 @@ def render_lib
template = IO.read(__dir__ + "/java/XdrString.erb")
result = ERB.new(template).result binding
@output.write "XdrString.java", result
+
+ template = IO.read(__dir__ + "/java/XdrUnsignedHyperInteger.erb")
+ result = ERB.new(template).result binding
+ @output.write "XdrUnsignedHyperInteger.java", result
+
+ template = IO.read(__dir__ + "/java/XdrUnsignedInteger.erb")
+ result = ERB.new(template).result binding
+ @output.write "XdrUnsignedInteger.java", result
end
def render_definitions(node)
@@ -506,13 +514,13 @@ def render_union(union, out)
out.puts "stream.writeInt(encoded#{name union}.getDiscriminant().intValue());"
elsif type_string(union.discriminant.type) == "Uint32"
# ugly workaround for compile error after generating source for AuthenticatedMessage in stellar-core
- out.puts "stream.writeInt(encoded#{name union}.getDiscriminant().getUint32());"
+ out.puts "stream.writeInt(encoded#{name union}.getDiscriminant().getUint32().getNumber().intValue());"
else
out.puts "stream.writeInt(encoded#{name union}.getDiscriminant().getValue());"
end
if type_string(union.discriminant.type) == "Uint32"
# ugly workaround for compile error after generating source for AuthenticatedMessage in stellar-core
- out.puts "switch (encoded#{name union}.getDiscriminant().getUint32()) {"
+ out.puts "switch (encoded#{name union}.getDiscriminant().getUint32().getNumber().intValue()) {"
else
out.puts "switch (encoded#{name union}.getDiscriminant()) {"
end
@@ -555,7 +563,7 @@ def render_union(union, out)
if type_string(union.discriminant.type) == "Uint32"
# ugly workaround for compile error after generating source for AuthenticatedMessage in stellar-core
- out.puts "switch (decoded#{name union}.getDiscriminant().getUint32()) {"
+ out.puts "switch (decoded#{name union}.getDiscriminant().getUint32().getNumber().intValue()) {"
else
out.puts "switch (decoded#{name union}.getDiscriminant()) {"
end
@@ -722,11 +730,11 @@ def encode_type(type, value)
when AST::Typespecs::Int ;
"stream.writeInt(#{value})"
when AST::Typespecs::UnsignedInt ;
- "stream.writeInt(#{value})"
+ "#{value}.encode(stream)"
when AST::Typespecs::Hyper ;
"stream.writeLong(#{value})"
when AST::Typespecs::UnsignedHyper ;
- "stream.writeLong(#{value})"
+ "#{value}.encode(stream)"
when AST::Typespecs::Float ;
"stream.writeFloat(#{value})"
when AST::Typespecs::Double ;
@@ -793,11 +801,11 @@ def decode_type(decl)
when AST::Typespecs::Int ;
"stream.readInt()"
when AST::Typespecs::UnsignedInt ;
- "stream.readInt()"
+ "XdrUnsignedInteger.decode(stream)"
when AST::Typespecs::Hyper ;
"stream.readLong()"
when AST::Typespecs::UnsignedHyper ;
- "stream.readLong()"
+ "XdrUnsignedHyperInteger.decode(stream)"
when AST::Typespecs::Float ;
"stream.readFloat()"
when AST::Typespecs::Double ;
@@ -863,11 +871,11 @@ def type_string(type)
when AST::Typespecs::Int ;
"Integer"
when AST::Typespecs::UnsignedInt ;
- "Integer"
+ "XdrUnsignedInteger"
when AST::Typespecs::Hyper ;
"Long"
when AST::Typespecs::UnsignedHyper ;
- "Long"
+ "XdrUnsignedHyperInteger"
when AST::Typespecs::Float ;
"Float"
when AST::Typespecs::Double ;
diff --git a/lib/xdrgen/generators/java/XdrUnsignedHyperInteger.erb b/lib/xdrgen/generators/java/XdrUnsignedHyperInteger.erb
new file mode 100644
index 000000000..083227def
--- /dev/null
+++ b/lib/xdrgen/generators/java/XdrUnsignedHyperInteger.erb
@@ -0,0 +1,77 @@
+package <%= @namespace %>;
+
+import com.google.common.base.Objects;
+import java.io.IOException;
+import java.math.BigInteger;
+
+/**
+ * Represents XDR Unsigned Hyper Integer.
+ *
+ * @see XDR: External Data
+ * Representation Standard
+ */
+public class XdrUnsignedHyperInteger implements XdrElement {
+ public static final BigInteger MAX_VALUE = new BigInteger("18446744073709551615");
+ public static final BigInteger MIN_VALUE = BigInteger.ZERO;
+ private final BigInteger number;
+
+ public XdrUnsignedHyperInteger(BigInteger number) {
+ if (number.compareTo(MIN_VALUE) < 0 || number.compareTo(MAX_VALUE) > 0) {
+ throw new IllegalArgumentException("number must be between 0 and 2^64 - 1 inclusive");
+ }
+ this.number = number;
+ }
+
+ public XdrUnsignedHyperInteger(Long number) {
+ if (number < 0) {
+ throw new IllegalArgumentException(
+ "number must be greater than or equal to 0 if you want to construct it from Long");
+ }
+ this.number = BigInteger.valueOf(number);
+ }
+
+ @Override
+ public void encode(XdrDataOutputStream stream) throws IOException {
+ stream.write(getBytes());
+ }
+
+ public static XdrUnsignedHyperInteger decode(XdrDataInputStream stream) throws IOException {
+ byte[] bytes = new byte[8];
+ stream.readFully(bytes);
+ BigInteger uint64 = new BigInteger(1, bytes);
+ return new XdrUnsignedHyperInteger(uint64);
+ }
+
+ private byte[] getBytes() {
+ byte[] bytes = number.toByteArray();
+ byte[] paddedBytes = new byte[8];
+
+ int numBytesToCopy = Math.min(bytes.length, 8);
+ int copyStartIndex = bytes.length - numBytesToCopy;
+ System.arraycopy(bytes, copyStartIndex, paddedBytes, 8 - numBytesToCopy, numBytesToCopy);
+ return paddedBytes;
+ }
+
+ public BigInteger getNumber() {
+ return number;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(this.number);
+ }
+
+ @Override
+ public boolean equals(Object object) {
+ if (!(object instanceof XdrUnsignedHyperInteger)) {
+ return false;
+ }
+
+ XdrUnsignedHyperInteger other = (XdrUnsignedHyperInteger) object;
+ return Objects.equal(this.number, other.number);
+ }
+
+ public String toString() {
+ return "XdrUnsignedInteger(number=" + this.getNumber() + ")";
+ }
+}
diff --git a/lib/xdrgen/generators/java/XdrUnsignedInteger.erb b/lib/xdrgen/generators/java/XdrUnsignedInteger.erb
new file mode 100644
index 000000000..a30fcd8f8
--- /dev/null
+++ b/lib/xdrgen/generators/java/XdrUnsignedInteger.erb
@@ -0,0 +1,65 @@
+package <%= @namespace %>;
+
+import com.google.common.base.Objects;
+import java.io.IOException;
+
+/**
+ * Represents XDR Unsigned Integer.
+ *
+ * @see XDR: External Data
+ * Representation Standard
+ */
+public class XdrUnsignedInteger implements XdrElement {
+ public static final long MAX_VALUE = (1L << 32) - 1;
+ public static final long MIN_VALUE = 0;
+ private final Long number;
+
+ public XdrUnsignedInteger(Long number) {
+ if (number < MIN_VALUE || number > MAX_VALUE) {
+ throw new IllegalArgumentException("number must be between 0 and 2^32 - 1 inclusive");
+ }
+ this.number = number;
+ }
+
+ public XdrUnsignedInteger(Integer number) {
+ if (number < 0) {
+ throw new IllegalArgumentException(
+ "number must be greater than or equal to 0 if you want to construct it from Integer");
+ }
+ this.number = number.longValue();
+ }
+
+ public Long getNumber() {
+ return number;
+ }
+
+ public static XdrUnsignedInteger decode(XdrDataInputStream stream) throws IOException {
+ int intValue = stream.readInt();
+ long uint32Value = Integer.toUnsignedLong(intValue);
+ return new XdrUnsignedInteger(uint32Value);
+ }
+
+ @Override
+ public void encode(XdrDataOutputStream stream) throws IOException {
+ stream.writeInt(number.intValue());
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(this.number);
+ }
+
+ @Override
+ public boolean equals(Object object) {
+ if (!(object instanceof XdrUnsignedInteger)) {
+ return false;
+ }
+
+ XdrUnsignedInteger other = (XdrUnsignedInteger) object;
+ return Objects.equal(this.number, other.number);
+ }
+
+ public String toString() {
+ return "XdrUnsignedInteger(number=" + this.getNumber() + ")";
+ }
+}
diff --git a/spec/output/generator_spec_java/block_comments.x/XdrUnsignedHyperInteger.java b/spec/output/generator_spec_java/block_comments.x/XdrUnsignedHyperInteger.java
new file mode 100644
index 000000000..f419e92e6
--- /dev/null
+++ b/spec/output/generator_spec_java/block_comments.x/XdrUnsignedHyperInteger.java
@@ -0,0 +1,77 @@
+package MyXDR;
+
+import com.google.common.base.Objects;
+import java.io.IOException;
+import java.math.BigInteger;
+
+/**
+ * Represents XDR Unsigned Hyper Integer.
+ *
+ * @see XDR: External Data
+ * Representation Standard
+ */
+public class XdrUnsignedHyperInteger implements XdrElement {
+ public static final BigInteger MAX_VALUE = new BigInteger("18446744073709551615");
+ public static final BigInteger MIN_VALUE = BigInteger.ZERO;
+ private final BigInteger number;
+
+ public XdrUnsignedHyperInteger(BigInteger number) {
+ if (number.compareTo(MIN_VALUE) < 0 || number.compareTo(MAX_VALUE) > 0) {
+ throw new IllegalArgumentException("number must be between 0 and 2^64 - 1 inclusive");
+ }
+ this.number = number;
+ }
+
+ public XdrUnsignedHyperInteger(Long number) {
+ if (number < 0) {
+ throw new IllegalArgumentException(
+ "number must be greater than or equal to 0 if you want to construct it from Long");
+ }
+ this.number = BigInteger.valueOf(number);
+ }
+
+ @Override
+ public void encode(XdrDataOutputStream stream) throws IOException {
+ stream.write(getBytes());
+ }
+
+ public static XdrUnsignedHyperInteger decode(XdrDataInputStream stream) throws IOException {
+ byte[] bytes = new byte[8];
+ stream.readFully(bytes);
+ BigInteger uint64 = new BigInteger(1, bytes);
+ return new XdrUnsignedHyperInteger(uint64);
+ }
+
+ private byte[] getBytes() {
+ byte[] bytes = number.toByteArray();
+ byte[] paddedBytes = new byte[8];
+
+ int numBytesToCopy = Math.min(bytes.length, 8);
+ int copyStartIndex = bytes.length - numBytesToCopy;
+ System.arraycopy(bytes, copyStartIndex, paddedBytes, 8 - numBytesToCopy, numBytesToCopy);
+ return paddedBytes;
+ }
+
+ public BigInteger getNumber() {
+ return number;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(this.number);
+ }
+
+ @Override
+ public boolean equals(Object object) {
+ if (!(object instanceof XdrUnsignedHyperInteger)) {
+ return false;
+ }
+
+ XdrUnsignedHyperInteger other = (XdrUnsignedHyperInteger) object;
+ return Objects.equal(this.number, other.number);
+ }
+
+ public String toString() {
+ return "XdrUnsignedInteger(number=" + this.getNumber() + ")";
+ }
+}
diff --git a/spec/output/generator_spec_java/block_comments.x/XdrUnsignedInteger.java b/spec/output/generator_spec_java/block_comments.x/XdrUnsignedInteger.java
new file mode 100644
index 000000000..aae47a25f
--- /dev/null
+++ b/spec/output/generator_spec_java/block_comments.x/XdrUnsignedInteger.java
@@ -0,0 +1,65 @@
+package MyXDR;
+
+import com.google.common.base.Objects;
+import java.io.IOException;
+
+/**
+ * Represents XDR Unsigned Integer.
+ *
+ * @see XDR: External Data
+ * Representation Standard
+ */
+public class XdrUnsignedInteger implements XdrElement {
+ public static final long MAX_VALUE = (1L << 32) - 1;
+ public static final long MIN_VALUE = 0;
+ private final Long number;
+
+ public XdrUnsignedInteger(Long number) {
+ if (number < MIN_VALUE || number > MAX_VALUE) {
+ throw new IllegalArgumentException("number must be between 0 and 2^32 - 1 inclusive");
+ }
+ this.number = number;
+ }
+
+ public XdrUnsignedInteger(Integer number) {
+ if (number < 0) {
+ throw new IllegalArgumentException(
+ "number must be greater than or equal to 0 if you want to construct it from Integer");
+ }
+ this.number = number.longValue();
+ }
+
+ public Long getNumber() {
+ return number;
+ }
+
+ public static XdrUnsignedInteger decode(XdrDataInputStream stream) throws IOException {
+ int intValue = stream.readInt();
+ long uint32Value = Integer.toUnsignedLong(intValue);
+ return new XdrUnsignedInteger(uint32Value);
+ }
+
+ @Override
+ public void encode(XdrDataOutputStream stream) throws IOException {
+ stream.writeInt(number.intValue());
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(this.number);
+ }
+
+ @Override
+ public boolean equals(Object object) {
+ if (!(object instanceof XdrUnsignedInteger)) {
+ return false;
+ }
+
+ XdrUnsignedInteger other = (XdrUnsignedInteger) object;
+ return Objects.equal(this.number, other.number);
+ }
+
+ public String toString() {
+ return "XdrUnsignedInteger(number=" + this.getNumber() + ")";
+ }
+}
diff --git a/spec/output/generator_spec_java/const.x/XdrUnsignedHyperInteger.java b/spec/output/generator_spec_java/const.x/XdrUnsignedHyperInteger.java
new file mode 100644
index 000000000..f419e92e6
--- /dev/null
+++ b/spec/output/generator_spec_java/const.x/XdrUnsignedHyperInteger.java
@@ -0,0 +1,77 @@
+package MyXDR;
+
+import com.google.common.base.Objects;
+import java.io.IOException;
+import java.math.BigInteger;
+
+/**
+ * Represents XDR Unsigned Hyper Integer.
+ *
+ * @see XDR: External Data
+ * Representation Standard
+ */
+public class XdrUnsignedHyperInteger implements XdrElement {
+ public static final BigInteger MAX_VALUE = new BigInteger("18446744073709551615");
+ public static final BigInteger MIN_VALUE = BigInteger.ZERO;
+ private final BigInteger number;
+
+ public XdrUnsignedHyperInteger(BigInteger number) {
+ if (number.compareTo(MIN_VALUE) < 0 || number.compareTo(MAX_VALUE) > 0) {
+ throw new IllegalArgumentException("number must be between 0 and 2^64 - 1 inclusive");
+ }
+ this.number = number;
+ }
+
+ public XdrUnsignedHyperInteger(Long number) {
+ if (number < 0) {
+ throw new IllegalArgumentException(
+ "number must be greater than or equal to 0 if you want to construct it from Long");
+ }
+ this.number = BigInteger.valueOf(number);
+ }
+
+ @Override
+ public void encode(XdrDataOutputStream stream) throws IOException {
+ stream.write(getBytes());
+ }
+
+ public static XdrUnsignedHyperInteger decode(XdrDataInputStream stream) throws IOException {
+ byte[] bytes = new byte[8];
+ stream.readFully(bytes);
+ BigInteger uint64 = new BigInteger(1, bytes);
+ return new XdrUnsignedHyperInteger(uint64);
+ }
+
+ private byte[] getBytes() {
+ byte[] bytes = number.toByteArray();
+ byte[] paddedBytes = new byte[8];
+
+ int numBytesToCopy = Math.min(bytes.length, 8);
+ int copyStartIndex = bytes.length - numBytesToCopy;
+ System.arraycopy(bytes, copyStartIndex, paddedBytes, 8 - numBytesToCopy, numBytesToCopy);
+ return paddedBytes;
+ }
+
+ public BigInteger getNumber() {
+ return number;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(this.number);
+ }
+
+ @Override
+ public boolean equals(Object object) {
+ if (!(object instanceof XdrUnsignedHyperInteger)) {
+ return false;
+ }
+
+ XdrUnsignedHyperInteger other = (XdrUnsignedHyperInteger) object;
+ return Objects.equal(this.number, other.number);
+ }
+
+ public String toString() {
+ return "XdrUnsignedInteger(number=" + this.getNumber() + ")";
+ }
+}
diff --git a/spec/output/generator_spec_java/const.x/XdrUnsignedInteger.java b/spec/output/generator_spec_java/const.x/XdrUnsignedInteger.java
new file mode 100644
index 000000000..aae47a25f
--- /dev/null
+++ b/spec/output/generator_spec_java/const.x/XdrUnsignedInteger.java
@@ -0,0 +1,65 @@
+package MyXDR;
+
+import com.google.common.base.Objects;
+import java.io.IOException;
+
+/**
+ * Represents XDR Unsigned Integer.
+ *
+ * @see XDR: External Data
+ * Representation Standard
+ */
+public class XdrUnsignedInteger implements XdrElement {
+ public static final long MAX_VALUE = (1L << 32) - 1;
+ public static final long MIN_VALUE = 0;
+ private final Long number;
+
+ public XdrUnsignedInteger(Long number) {
+ if (number < MIN_VALUE || number > MAX_VALUE) {
+ throw new IllegalArgumentException("number must be between 0 and 2^32 - 1 inclusive");
+ }
+ this.number = number;
+ }
+
+ public XdrUnsignedInteger(Integer number) {
+ if (number < 0) {
+ throw new IllegalArgumentException(
+ "number must be greater than or equal to 0 if you want to construct it from Integer");
+ }
+ this.number = number.longValue();
+ }
+
+ public Long getNumber() {
+ return number;
+ }
+
+ public static XdrUnsignedInteger decode(XdrDataInputStream stream) throws IOException {
+ int intValue = stream.readInt();
+ long uint32Value = Integer.toUnsignedLong(intValue);
+ return new XdrUnsignedInteger(uint32Value);
+ }
+
+ @Override
+ public void encode(XdrDataOutputStream stream) throws IOException {
+ stream.writeInt(number.intValue());
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(this.number);
+ }
+
+ @Override
+ public boolean equals(Object object) {
+ if (!(object instanceof XdrUnsignedInteger)) {
+ return false;
+ }
+
+ XdrUnsignedInteger other = (XdrUnsignedInteger) object;
+ return Objects.equal(this.number, other.number);
+ }
+
+ public String toString() {
+ return "XdrUnsignedInteger(number=" + this.getNumber() + ")";
+ }
+}
diff --git a/spec/output/generator_spec_java/enum.x/XdrUnsignedHyperInteger.java b/spec/output/generator_spec_java/enum.x/XdrUnsignedHyperInteger.java
new file mode 100644
index 000000000..f419e92e6
--- /dev/null
+++ b/spec/output/generator_spec_java/enum.x/XdrUnsignedHyperInteger.java
@@ -0,0 +1,77 @@
+package MyXDR;
+
+import com.google.common.base.Objects;
+import java.io.IOException;
+import java.math.BigInteger;
+
+/**
+ * Represents XDR Unsigned Hyper Integer.
+ *
+ * @see XDR: External Data
+ * Representation Standard
+ */
+public class XdrUnsignedHyperInteger implements XdrElement {
+ public static final BigInteger MAX_VALUE = new BigInteger("18446744073709551615");
+ public static final BigInteger MIN_VALUE = BigInteger.ZERO;
+ private final BigInteger number;
+
+ public XdrUnsignedHyperInteger(BigInteger number) {
+ if (number.compareTo(MIN_VALUE) < 0 || number.compareTo(MAX_VALUE) > 0) {
+ throw new IllegalArgumentException("number must be between 0 and 2^64 - 1 inclusive");
+ }
+ this.number = number;
+ }
+
+ public XdrUnsignedHyperInteger(Long number) {
+ if (number < 0) {
+ throw new IllegalArgumentException(
+ "number must be greater than or equal to 0 if you want to construct it from Long");
+ }
+ this.number = BigInteger.valueOf(number);
+ }
+
+ @Override
+ public void encode(XdrDataOutputStream stream) throws IOException {
+ stream.write(getBytes());
+ }
+
+ public static XdrUnsignedHyperInteger decode(XdrDataInputStream stream) throws IOException {
+ byte[] bytes = new byte[8];
+ stream.readFully(bytes);
+ BigInteger uint64 = new BigInteger(1, bytes);
+ return new XdrUnsignedHyperInteger(uint64);
+ }
+
+ private byte[] getBytes() {
+ byte[] bytes = number.toByteArray();
+ byte[] paddedBytes = new byte[8];
+
+ int numBytesToCopy = Math.min(bytes.length, 8);
+ int copyStartIndex = bytes.length - numBytesToCopy;
+ System.arraycopy(bytes, copyStartIndex, paddedBytes, 8 - numBytesToCopy, numBytesToCopy);
+ return paddedBytes;
+ }
+
+ public BigInteger getNumber() {
+ return number;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(this.number);
+ }
+
+ @Override
+ public boolean equals(Object object) {
+ if (!(object instanceof XdrUnsignedHyperInteger)) {
+ return false;
+ }
+
+ XdrUnsignedHyperInteger other = (XdrUnsignedHyperInteger) object;
+ return Objects.equal(this.number, other.number);
+ }
+
+ public String toString() {
+ return "XdrUnsignedInteger(number=" + this.getNumber() + ")";
+ }
+}
diff --git a/spec/output/generator_spec_java/enum.x/XdrUnsignedInteger.java b/spec/output/generator_spec_java/enum.x/XdrUnsignedInteger.java
new file mode 100644
index 000000000..aae47a25f
--- /dev/null
+++ b/spec/output/generator_spec_java/enum.x/XdrUnsignedInteger.java
@@ -0,0 +1,65 @@
+package MyXDR;
+
+import com.google.common.base.Objects;
+import java.io.IOException;
+
+/**
+ * Represents XDR Unsigned Integer.
+ *
+ * @see XDR: External Data
+ * Representation Standard
+ */
+public class XdrUnsignedInteger implements XdrElement {
+ public static final long MAX_VALUE = (1L << 32) - 1;
+ public static final long MIN_VALUE = 0;
+ private final Long number;
+
+ public XdrUnsignedInteger(Long number) {
+ if (number < MIN_VALUE || number > MAX_VALUE) {
+ throw new IllegalArgumentException("number must be between 0 and 2^32 - 1 inclusive");
+ }
+ this.number = number;
+ }
+
+ public XdrUnsignedInteger(Integer number) {
+ if (number < 0) {
+ throw new IllegalArgumentException(
+ "number must be greater than or equal to 0 if you want to construct it from Integer");
+ }
+ this.number = number.longValue();
+ }
+
+ public Long getNumber() {
+ return number;
+ }
+
+ public static XdrUnsignedInteger decode(XdrDataInputStream stream) throws IOException {
+ int intValue = stream.readInt();
+ long uint32Value = Integer.toUnsignedLong(intValue);
+ return new XdrUnsignedInteger(uint32Value);
+ }
+
+ @Override
+ public void encode(XdrDataOutputStream stream) throws IOException {
+ stream.writeInt(number.intValue());
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(this.number);
+ }
+
+ @Override
+ public boolean equals(Object object) {
+ if (!(object instanceof XdrUnsignedInteger)) {
+ return false;
+ }
+
+ XdrUnsignedInteger other = (XdrUnsignedInteger) object;
+ return Objects.equal(this.number, other.number);
+ }
+
+ public String toString() {
+ return "XdrUnsignedInteger(number=" + this.getNumber() + ")";
+ }
+}
diff --git a/spec/output/generator_spec_java/nesting.x/XdrUnsignedHyperInteger.java b/spec/output/generator_spec_java/nesting.x/XdrUnsignedHyperInteger.java
new file mode 100644
index 000000000..f419e92e6
--- /dev/null
+++ b/spec/output/generator_spec_java/nesting.x/XdrUnsignedHyperInteger.java
@@ -0,0 +1,77 @@
+package MyXDR;
+
+import com.google.common.base.Objects;
+import java.io.IOException;
+import java.math.BigInteger;
+
+/**
+ * Represents XDR Unsigned Hyper Integer.
+ *
+ * @see XDR: External Data
+ * Representation Standard
+ */
+public class XdrUnsignedHyperInteger implements XdrElement {
+ public static final BigInteger MAX_VALUE = new BigInteger("18446744073709551615");
+ public static final BigInteger MIN_VALUE = BigInteger.ZERO;
+ private final BigInteger number;
+
+ public XdrUnsignedHyperInteger(BigInteger number) {
+ if (number.compareTo(MIN_VALUE) < 0 || number.compareTo(MAX_VALUE) > 0) {
+ throw new IllegalArgumentException("number must be between 0 and 2^64 - 1 inclusive");
+ }
+ this.number = number;
+ }
+
+ public XdrUnsignedHyperInteger(Long number) {
+ if (number < 0) {
+ throw new IllegalArgumentException(
+ "number must be greater than or equal to 0 if you want to construct it from Long");
+ }
+ this.number = BigInteger.valueOf(number);
+ }
+
+ @Override
+ public void encode(XdrDataOutputStream stream) throws IOException {
+ stream.write(getBytes());
+ }
+
+ public static XdrUnsignedHyperInteger decode(XdrDataInputStream stream) throws IOException {
+ byte[] bytes = new byte[8];
+ stream.readFully(bytes);
+ BigInteger uint64 = new BigInteger(1, bytes);
+ return new XdrUnsignedHyperInteger(uint64);
+ }
+
+ private byte[] getBytes() {
+ byte[] bytes = number.toByteArray();
+ byte[] paddedBytes = new byte[8];
+
+ int numBytesToCopy = Math.min(bytes.length, 8);
+ int copyStartIndex = bytes.length - numBytesToCopy;
+ System.arraycopy(bytes, copyStartIndex, paddedBytes, 8 - numBytesToCopy, numBytesToCopy);
+ return paddedBytes;
+ }
+
+ public BigInteger getNumber() {
+ return number;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(this.number);
+ }
+
+ @Override
+ public boolean equals(Object object) {
+ if (!(object instanceof XdrUnsignedHyperInteger)) {
+ return false;
+ }
+
+ XdrUnsignedHyperInteger other = (XdrUnsignedHyperInteger) object;
+ return Objects.equal(this.number, other.number);
+ }
+
+ public String toString() {
+ return "XdrUnsignedInteger(number=" + this.getNumber() + ")";
+ }
+}
diff --git a/spec/output/generator_spec_java/nesting.x/XdrUnsignedInteger.java b/spec/output/generator_spec_java/nesting.x/XdrUnsignedInteger.java
new file mode 100644
index 000000000..aae47a25f
--- /dev/null
+++ b/spec/output/generator_spec_java/nesting.x/XdrUnsignedInteger.java
@@ -0,0 +1,65 @@
+package MyXDR;
+
+import com.google.common.base.Objects;
+import java.io.IOException;
+
+/**
+ * Represents XDR Unsigned Integer.
+ *
+ * @see XDR: External Data
+ * Representation Standard
+ */
+public class XdrUnsignedInteger implements XdrElement {
+ public static final long MAX_VALUE = (1L << 32) - 1;
+ public static final long MIN_VALUE = 0;
+ private final Long number;
+
+ public XdrUnsignedInteger(Long number) {
+ if (number < MIN_VALUE || number > MAX_VALUE) {
+ throw new IllegalArgumentException("number must be between 0 and 2^32 - 1 inclusive");
+ }
+ this.number = number;
+ }
+
+ public XdrUnsignedInteger(Integer number) {
+ if (number < 0) {
+ throw new IllegalArgumentException(
+ "number must be greater than or equal to 0 if you want to construct it from Integer");
+ }
+ this.number = number.longValue();
+ }
+
+ public Long getNumber() {
+ return number;
+ }
+
+ public static XdrUnsignedInteger decode(XdrDataInputStream stream) throws IOException {
+ int intValue = stream.readInt();
+ long uint32Value = Integer.toUnsignedLong(intValue);
+ return new XdrUnsignedInteger(uint32Value);
+ }
+
+ @Override
+ public void encode(XdrDataOutputStream stream) throws IOException {
+ stream.writeInt(number.intValue());
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(this.number);
+ }
+
+ @Override
+ public boolean equals(Object object) {
+ if (!(object instanceof XdrUnsignedInteger)) {
+ return false;
+ }
+
+ XdrUnsignedInteger other = (XdrUnsignedInteger) object;
+ return Objects.equal(this.number, other.number);
+ }
+
+ public String toString() {
+ return "XdrUnsignedInteger(number=" + this.getNumber() + ")";
+ }
+}
diff --git a/spec/output/generator_spec_java/optional.x/XdrUnsignedHyperInteger.java b/spec/output/generator_spec_java/optional.x/XdrUnsignedHyperInteger.java
new file mode 100644
index 000000000..f419e92e6
--- /dev/null
+++ b/spec/output/generator_spec_java/optional.x/XdrUnsignedHyperInteger.java
@@ -0,0 +1,77 @@
+package MyXDR;
+
+import com.google.common.base.Objects;
+import java.io.IOException;
+import java.math.BigInteger;
+
+/**
+ * Represents XDR Unsigned Hyper Integer.
+ *
+ * @see XDR: External Data
+ * Representation Standard
+ */
+public class XdrUnsignedHyperInteger implements XdrElement {
+ public static final BigInteger MAX_VALUE = new BigInteger("18446744073709551615");
+ public static final BigInteger MIN_VALUE = BigInteger.ZERO;
+ private final BigInteger number;
+
+ public XdrUnsignedHyperInteger(BigInteger number) {
+ if (number.compareTo(MIN_VALUE) < 0 || number.compareTo(MAX_VALUE) > 0) {
+ throw new IllegalArgumentException("number must be between 0 and 2^64 - 1 inclusive");
+ }
+ this.number = number;
+ }
+
+ public XdrUnsignedHyperInteger(Long number) {
+ if (number < 0) {
+ throw new IllegalArgumentException(
+ "number must be greater than or equal to 0 if you want to construct it from Long");
+ }
+ this.number = BigInteger.valueOf(number);
+ }
+
+ @Override
+ public void encode(XdrDataOutputStream stream) throws IOException {
+ stream.write(getBytes());
+ }
+
+ public static XdrUnsignedHyperInteger decode(XdrDataInputStream stream) throws IOException {
+ byte[] bytes = new byte[8];
+ stream.readFully(bytes);
+ BigInteger uint64 = new BigInteger(1, bytes);
+ return new XdrUnsignedHyperInteger(uint64);
+ }
+
+ private byte[] getBytes() {
+ byte[] bytes = number.toByteArray();
+ byte[] paddedBytes = new byte[8];
+
+ int numBytesToCopy = Math.min(bytes.length, 8);
+ int copyStartIndex = bytes.length - numBytesToCopy;
+ System.arraycopy(bytes, copyStartIndex, paddedBytes, 8 - numBytesToCopy, numBytesToCopy);
+ return paddedBytes;
+ }
+
+ public BigInteger getNumber() {
+ return number;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(this.number);
+ }
+
+ @Override
+ public boolean equals(Object object) {
+ if (!(object instanceof XdrUnsignedHyperInteger)) {
+ return false;
+ }
+
+ XdrUnsignedHyperInteger other = (XdrUnsignedHyperInteger) object;
+ return Objects.equal(this.number, other.number);
+ }
+
+ public String toString() {
+ return "XdrUnsignedInteger(number=" + this.getNumber() + ")";
+ }
+}
diff --git a/spec/output/generator_spec_java/optional.x/XdrUnsignedInteger.java b/spec/output/generator_spec_java/optional.x/XdrUnsignedInteger.java
new file mode 100644
index 000000000..aae47a25f
--- /dev/null
+++ b/spec/output/generator_spec_java/optional.x/XdrUnsignedInteger.java
@@ -0,0 +1,65 @@
+package MyXDR;
+
+import com.google.common.base.Objects;
+import java.io.IOException;
+
+/**
+ * Represents XDR Unsigned Integer.
+ *
+ * @see XDR: External Data
+ * Representation Standard
+ */
+public class XdrUnsignedInteger implements XdrElement {
+ public static final long MAX_VALUE = (1L << 32) - 1;
+ public static final long MIN_VALUE = 0;
+ private final Long number;
+
+ public XdrUnsignedInteger(Long number) {
+ if (number < MIN_VALUE || number > MAX_VALUE) {
+ throw new IllegalArgumentException("number must be between 0 and 2^32 - 1 inclusive");
+ }
+ this.number = number;
+ }
+
+ public XdrUnsignedInteger(Integer number) {
+ if (number < 0) {
+ throw new IllegalArgumentException(
+ "number must be greater than or equal to 0 if you want to construct it from Integer");
+ }
+ this.number = number.longValue();
+ }
+
+ public Long getNumber() {
+ return number;
+ }
+
+ public static XdrUnsignedInteger decode(XdrDataInputStream stream) throws IOException {
+ int intValue = stream.readInt();
+ long uint32Value = Integer.toUnsignedLong(intValue);
+ return new XdrUnsignedInteger(uint32Value);
+ }
+
+ @Override
+ public void encode(XdrDataOutputStream stream) throws IOException {
+ stream.writeInt(number.intValue());
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(this.number);
+ }
+
+ @Override
+ public boolean equals(Object object) {
+ if (!(object instanceof XdrUnsignedInteger)) {
+ return false;
+ }
+
+ XdrUnsignedInteger other = (XdrUnsignedInteger) object;
+ return Objects.equal(this.number, other.number);
+ }
+
+ public String toString() {
+ return "XdrUnsignedInteger(number=" + this.getNumber() + ")";
+ }
+}
diff --git a/spec/output/generator_spec_java/struct.x/XdrUnsignedHyperInteger.java b/spec/output/generator_spec_java/struct.x/XdrUnsignedHyperInteger.java
new file mode 100644
index 000000000..f419e92e6
--- /dev/null
+++ b/spec/output/generator_spec_java/struct.x/XdrUnsignedHyperInteger.java
@@ -0,0 +1,77 @@
+package MyXDR;
+
+import com.google.common.base.Objects;
+import java.io.IOException;
+import java.math.BigInteger;
+
+/**
+ * Represents XDR Unsigned Hyper Integer.
+ *
+ * @see XDR: External Data
+ * Representation Standard
+ */
+public class XdrUnsignedHyperInteger implements XdrElement {
+ public static final BigInteger MAX_VALUE = new BigInteger("18446744073709551615");
+ public static final BigInteger MIN_VALUE = BigInteger.ZERO;
+ private final BigInteger number;
+
+ public XdrUnsignedHyperInteger(BigInteger number) {
+ if (number.compareTo(MIN_VALUE) < 0 || number.compareTo(MAX_VALUE) > 0) {
+ throw new IllegalArgumentException("number must be between 0 and 2^64 - 1 inclusive");
+ }
+ this.number = number;
+ }
+
+ public XdrUnsignedHyperInteger(Long number) {
+ if (number < 0) {
+ throw new IllegalArgumentException(
+ "number must be greater than or equal to 0 if you want to construct it from Long");
+ }
+ this.number = BigInteger.valueOf(number);
+ }
+
+ @Override
+ public void encode(XdrDataOutputStream stream) throws IOException {
+ stream.write(getBytes());
+ }
+
+ public static XdrUnsignedHyperInteger decode(XdrDataInputStream stream) throws IOException {
+ byte[] bytes = new byte[8];
+ stream.readFully(bytes);
+ BigInteger uint64 = new BigInteger(1, bytes);
+ return new XdrUnsignedHyperInteger(uint64);
+ }
+
+ private byte[] getBytes() {
+ byte[] bytes = number.toByteArray();
+ byte[] paddedBytes = new byte[8];
+
+ int numBytesToCopy = Math.min(bytes.length, 8);
+ int copyStartIndex = bytes.length - numBytesToCopy;
+ System.arraycopy(bytes, copyStartIndex, paddedBytes, 8 - numBytesToCopy, numBytesToCopy);
+ return paddedBytes;
+ }
+
+ public BigInteger getNumber() {
+ return number;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(this.number);
+ }
+
+ @Override
+ public boolean equals(Object object) {
+ if (!(object instanceof XdrUnsignedHyperInteger)) {
+ return false;
+ }
+
+ XdrUnsignedHyperInteger other = (XdrUnsignedHyperInteger) object;
+ return Objects.equal(this.number, other.number);
+ }
+
+ public String toString() {
+ return "XdrUnsignedInteger(number=" + this.getNumber() + ")";
+ }
+}
diff --git a/spec/output/generator_spec_java/struct.x/XdrUnsignedInteger.java b/spec/output/generator_spec_java/struct.x/XdrUnsignedInteger.java
new file mode 100644
index 000000000..aae47a25f
--- /dev/null
+++ b/spec/output/generator_spec_java/struct.x/XdrUnsignedInteger.java
@@ -0,0 +1,65 @@
+package MyXDR;
+
+import com.google.common.base.Objects;
+import java.io.IOException;
+
+/**
+ * Represents XDR Unsigned Integer.
+ *
+ * @see XDR: External Data
+ * Representation Standard
+ */
+public class XdrUnsignedInteger implements XdrElement {
+ public static final long MAX_VALUE = (1L << 32) - 1;
+ public static final long MIN_VALUE = 0;
+ private final Long number;
+
+ public XdrUnsignedInteger(Long number) {
+ if (number < MIN_VALUE || number > MAX_VALUE) {
+ throw new IllegalArgumentException("number must be between 0 and 2^32 - 1 inclusive");
+ }
+ this.number = number;
+ }
+
+ public XdrUnsignedInteger(Integer number) {
+ if (number < 0) {
+ throw new IllegalArgumentException(
+ "number must be greater than or equal to 0 if you want to construct it from Integer");
+ }
+ this.number = number.longValue();
+ }
+
+ public Long getNumber() {
+ return number;
+ }
+
+ public static XdrUnsignedInteger decode(XdrDataInputStream stream) throws IOException {
+ int intValue = stream.readInt();
+ long uint32Value = Integer.toUnsignedLong(intValue);
+ return new XdrUnsignedInteger(uint32Value);
+ }
+
+ @Override
+ public void encode(XdrDataOutputStream stream) throws IOException {
+ stream.writeInt(number.intValue());
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(this.number);
+ }
+
+ @Override
+ public boolean equals(Object object) {
+ if (!(object instanceof XdrUnsignedInteger)) {
+ return false;
+ }
+
+ XdrUnsignedInteger other = (XdrUnsignedInteger) object;
+ return Objects.equal(this.number, other.number);
+ }
+
+ public String toString() {
+ return "XdrUnsignedInteger(number=" + this.getNumber() + ")";
+ }
+}
diff --git a/spec/output/generator_spec_java/test.x/Int3.java b/spec/output/generator_spec_java/test.x/Int3.java
index 22f040b10..57d8278b0 100644
--- a/spec/output/generator_spec_java/test.x/Int3.java
+++ b/spec/output/generator_spec_java/test.x/Int3.java
@@ -14,24 +14,24 @@
// ===========================================================================
public class Int3 implements XdrElement {
- private Integer int3;
+ private XdrUnsignedInteger int3;
public Int3() {}
- public Int3(Integer int3) {
+ public Int3(XdrUnsignedInteger int3) {
this.int3 = int3;
}
- public Integer getInt3() {
+ public XdrUnsignedInteger getInt3() {
return this.int3;
}
- public void setInt3(Integer value) {
+ public void setInt3(XdrUnsignedInteger value) {
this.int3 = value;
}
public static void encode(XdrDataOutputStream stream, Int3 encodedInt3) throws IOException {
- stream.writeInt(encodedInt3.int3);
+ encodedInt3.int3.encode(stream);
}
public void encode(XdrDataOutputStream stream) throws IOException {
@@ -39,7 +39,7 @@ public void encode(XdrDataOutputStream stream) throws IOException {
}
public static Int3 decode(XdrDataInputStream stream) throws IOException {
Int3 decodedInt3 = new Int3();
- decodedInt3.int3 = stream.readInt();
+ decodedInt3.int3 = XdrUnsignedInteger.decode(stream);
return decodedInt3;
}
diff --git a/spec/output/generator_spec_java/test.x/Int4.java b/spec/output/generator_spec_java/test.x/Int4.java
index 6199f5af6..9217be5d9 100644
--- a/spec/output/generator_spec_java/test.x/Int4.java
+++ b/spec/output/generator_spec_java/test.x/Int4.java
@@ -14,24 +14,24 @@
// ===========================================================================
public class Int4 implements XdrElement {
- private Long int4;
+ private XdrUnsignedHyperInteger int4;
public Int4() {}
- public Int4(Long int4) {
+ public Int4(XdrUnsignedHyperInteger int4) {
this.int4 = int4;
}
- public Long getInt4() {
+ public XdrUnsignedHyperInteger getInt4() {
return this.int4;
}
- public void setInt4(Long value) {
+ public void setInt4(XdrUnsignedHyperInteger value) {
this.int4 = value;
}
public static void encode(XdrDataOutputStream stream, Int4 encodedInt4) throws IOException {
- stream.writeLong(encodedInt4.int4);
+ encodedInt4.int4.encode(stream);
}
public void encode(XdrDataOutputStream stream) throws IOException {
@@ -39,7 +39,7 @@ public void encode(XdrDataOutputStream stream) throws IOException {
}
public static Int4 decode(XdrDataInputStream stream) throws IOException {
Int4 decodedInt4 = new Int4();
- decodedInt4.int4 = stream.readLong();
+ decodedInt4.int4 = XdrUnsignedHyperInteger.decode(stream);
return decodedInt4;
}
diff --git a/spec/output/generator_spec_java/test.x/MyStruct.java b/spec/output/generator_spec_java/test.x/MyStruct.java
index 02417b319..c3f48bf4f 100644
--- a/spec/output/generator_spec_java/test.x/MyStruct.java
+++ b/spec/output/generator_spec_java/test.x/MyStruct.java
@@ -45,11 +45,11 @@ public Int1 getField3() {
public void setField3(Int1 value) {
this.field3 = value;
}
- private Integer field4;
- public Integer getField4() {
+ private XdrUnsignedInteger field4;
+ public XdrUnsignedInteger getField4() {
return this.field4;
}
- public void setField4(Integer value) {
+ public void setField4(XdrUnsignedInteger value) {
this.field4 = value;
}
private Float field5;
@@ -77,7 +77,7 @@ public static void encode(XdrDataOutputStream stream, MyStruct encodedMyStruct)
Uint512.encode(stream, encodedMyStruct.field1);
OptHash1.encode(stream, encodedMyStruct.field2);
Int1.encode(stream, encodedMyStruct.field3);
- stream.writeInt(encodedMyStruct.field4);
+ encodedMyStruct.field4.encode(stream);
stream.writeFloat(encodedMyStruct.field5);
stream.writeDouble(encodedMyStruct.field6);
stream.writeInt(encodedMyStruct.field7 ? 1 : 0);
@@ -90,7 +90,7 @@ public static MyStruct decode(XdrDataInputStream stream) throws IOException {
decodedMyStruct.field1 = Uint512.decode(stream);
decodedMyStruct.field2 = OptHash1.decode(stream);
decodedMyStruct.field3 = Int1.decode(stream);
- decodedMyStruct.field4 = stream.readInt();
+ decodedMyStruct.field4 = XdrUnsignedInteger.decode(stream);
decodedMyStruct.field5 = stream.readFloat();
decodedMyStruct.field6 = stream.readDouble();
decodedMyStruct.field7 = stream.readInt() == 1 ? true : false;
@@ -114,7 +114,7 @@ public static final class Builder {
private Uint512 field1;
private OptHash1 field2;
private Int1 field3;
- private Integer field4;
+ private XdrUnsignedInteger field4;
private Float field5;
private Double field6;
private Boolean field7;
@@ -134,7 +134,7 @@ public Builder field3(Int1 field3) {
return this;
}
- public Builder field4(Integer field4) {
+ public Builder field4(XdrUnsignedInteger field4) {
this.field4 = field4;
return this;
}
diff --git a/spec/output/generator_spec_java/test.x/XdrUnsignedHyperInteger.java b/spec/output/generator_spec_java/test.x/XdrUnsignedHyperInteger.java
new file mode 100644
index 000000000..f419e92e6
--- /dev/null
+++ b/spec/output/generator_spec_java/test.x/XdrUnsignedHyperInteger.java
@@ -0,0 +1,77 @@
+package MyXDR;
+
+import com.google.common.base.Objects;
+import java.io.IOException;
+import java.math.BigInteger;
+
+/**
+ * Represents XDR Unsigned Hyper Integer.
+ *
+ * @see XDR: External Data
+ * Representation Standard
+ */
+public class XdrUnsignedHyperInteger implements XdrElement {
+ public static final BigInteger MAX_VALUE = new BigInteger("18446744073709551615");
+ public static final BigInteger MIN_VALUE = BigInteger.ZERO;
+ private final BigInteger number;
+
+ public XdrUnsignedHyperInteger(BigInteger number) {
+ if (number.compareTo(MIN_VALUE) < 0 || number.compareTo(MAX_VALUE) > 0) {
+ throw new IllegalArgumentException("number must be between 0 and 2^64 - 1 inclusive");
+ }
+ this.number = number;
+ }
+
+ public XdrUnsignedHyperInteger(Long number) {
+ if (number < 0) {
+ throw new IllegalArgumentException(
+ "number must be greater than or equal to 0 if you want to construct it from Long");
+ }
+ this.number = BigInteger.valueOf(number);
+ }
+
+ @Override
+ public void encode(XdrDataOutputStream stream) throws IOException {
+ stream.write(getBytes());
+ }
+
+ public static XdrUnsignedHyperInteger decode(XdrDataInputStream stream) throws IOException {
+ byte[] bytes = new byte[8];
+ stream.readFully(bytes);
+ BigInteger uint64 = new BigInteger(1, bytes);
+ return new XdrUnsignedHyperInteger(uint64);
+ }
+
+ private byte[] getBytes() {
+ byte[] bytes = number.toByteArray();
+ byte[] paddedBytes = new byte[8];
+
+ int numBytesToCopy = Math.min(bytes.length, 8);
+ int copyStartIndex = bytes.length - numBytesToCopy;
+ System.arraycopy(bytes, copyStartIndex, paddedBytes, 8 - numBytesToCopy, numBytesToCopy);
+ return paddedBytes;
+ }
+
+ public BigInteger getNumber() {
+ return number;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(this.number);
+ }
+
+ @Override
+ public boolean equals(Object object) {
+ if (!(object instanceof XdrUnsignedHyperInteger)) {
+ return false;
+ }
+
+ XdrUnsignedHyperInteger other = (XdrUnsignedHyperInteger) object;
+ return Objects.equal(this.number, other.number);
+ }
+
+ public String toString() {
+ return "XdrUnsignedInteger(number=" + this.getNumber() + ")";
+ }
+}
diff --git a/spec/output/generator_spec_java/test.x/XdrUnsignedInteger.java b/spec/output/generator_spec_java/test.x/XdrUnsignedInteger.java
new file mode 100644
index 000000000..aae47a25f
--- /dev/null
+++ b/spec/output/generator_spec_java/test.x/XdrUnsignedInteger.java
@@ -0,0 +1,65 @@
+package MyXDR;
+
+import com.google.common.base.Objects;
+import java.io.IOException;
+
+/**
+ * Represents XDR Unsigned Integer.
+ *
+ * @see XDR: External Data
+ * Representation Standard
+ */
+public class XdrUnsignedInteger implements XdrElement {
+ public static final long MAX_VALUE = (1L << 32) - 1;
+ public static final long MIN_VALUE = 0;
+ private final Long number;
+
+ public XdrUnsignedInteger(Long number) {
+ if (number < MIN_VALUE || number > MAX_VALUE) {
+ throw new IllegalArgumentException("number must be between 0 and 2^32 - 1 inclusive");
+ }
+ this.number = number;
+ }
+
+ public XdrUnsignedInteger(Integer number) {
+ if (number < 0) {
+ throw new IllegalArgumentException(
+ "number must be greater than or equal to 0 if you want to construct it from Integer");
+ }
+ this.number = number.longValue();
+ }
+
+ public Long getNumber() {
+ return number;
+ }
+
+ public static XdrUnsignedInteger decode(XdrDataInputStream stream) throws IOException {
+ int intValue = stream.readInt();
+ long uint32Value = Integer.toUnsignedLong(intValue);
+ return new XdrUnsignedInteger(uint32Value);
+ }
+
+ @Override
+ public void encode(XdrDataOutputStream stream) throws IOException {
+ stream.writeInt(number.intValue());
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(this.number);
+ }
+
+ @Override
+ public boolean equals(Object object) {
+ if (!(object instanceof XdrUnsignedInteger)) {
+ return false;
+ }
+
+ XdrUnsignedInteger other = (XdrUnsignedInteger) object;
+ return Objects.equal(this.number, other.number);
+ }
+
+ public String toString() {
+ return "XdrUnsignedInteger(number=" + this.getNumber() + ")";
+ }
+}
diff --git a/spec/output/generator_spec_java/union.x/XdrUnsignedHyperInteger.java b/spec/output/generator_spec_java/union.x/XdrUnsignedHyperInteger.java
new file mode 100644
index 000000000..f419e92e6
--- /dev/null
+++ b/spec/output/generator_spec_java/union.x/XdrUnsignedHyperInteger.java
@@ -0,0 +1,77 @@
+package MyXDR;
+
+import com.google.common.base.Objects;
+import java.io.IOException;
+import java.math.BigInteger;
+
+/**
+ * Represents XDR Unsigned Hyper Integer.
+ *
+ * @see XDR: External Data
+ * Representation Standard
+ */
+public class XdrUnsignedHyperInteger implements XdrElement {
+ public static final BigInteger MAX_VALUE = new BigInteger("18446744073709551615");
+ public static final BigInteger MIN_VALUE = BigInteger.ZERO;
+ private final BigInteger number;
+
+ public XdrUnsignedHyperInteger(BigInteger number) {
+ if (number.compareTo(MIN_VALUE) < 0 || number.compareTo(MAX_VALUE) > 0) {
+ throw new IllegalArgumentException("number must be between 0 and 2^64 - 1 inclusive");
+ }
+ this.number = number;
+ }
+
+ public XdrUnsignedHyperInteger(Long number) {
+ if (number < 0) {
+ throw new IllegalArgumentException(
+ "number must be greater than or equal to 0 if you want to construct it from Long");
+ }
+ this.number = BigInteger.valueOf(number);
+ }
+
+ @Override
+ public void encode(XdrDataOutputStream stream) throws IOException {
+ stream.write(getBytes());
+ }
+
+ public static XdrUnsignedHyperInteger decode(XdrDataInputStream stream) throws IOException {
+ byte[] bytes = new byte[8];
+ stream.readFully(bytes);
+ BigInteger uint64 = new BigInteger(1, bytes);
+ return new XdrUnsignedHyperInteger(uint64);
+ }
+
+ private byte[] getBytes() {
+ byte[] bytes = number.toByteArray();
+ byte[] paddedBytes = new byte[8];
+
+ int numBytesToCopy = Math.min(bytes.length, 8);
+ int copyStartIndex = bytes.length - numBytesToCopy;
+ System.arraycopy(bytes, copyStartIndex, paddedBytes, 8 - numBytesToCopy, numBytesToCopy);
+ return paddedBytes;
+ }
+
+ public BigInteger getNumber() {
+ return number;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(this.number);
+ }
+
+ @Override
+ public boolean equals(Object object) {
+ if (!(object instanceof XdrUnsignedHyperInteger)) {
+ return false;
+ }
+
+ XdrUnsignedHyperInteger other = (XdrUnsignedHyperInteger) object;
+ return Objects.equal(this.number, other.number);
+ }
+
+ public String toString() {
+ return "XdrUnsignedInteger(number=" + this.getNumber() + ")";
+ }
+}
diff --git a/spec/output/generator_spec_java/union.x/XdrUnsignedInteger.java b/spec/output/generator_spec_java/union.x/XdrUnsignedInteger.java
new file mode 100644
index 000000000..aae47a25f
--- /dev/null
+++ b/spec/output/generator_spec_java/union.x/XdrUnsignedInteger.java
@@ -0,0 +1,65 @@
+package MyXDR;
+
+import com.google.common.base.Objects;
+import java.io.IOException;
+
+/**
+ * Represents XDR Unsigned Integer.
+ *
+ * @see XDR: External Data
+ * Representation Standard
+ */
+public class XdrUnsignedInteger implements XdrElement {
+ public static final long MAX_VALUE = (1L << 32) - 1;
+ public static final long MIN_VALUE = 0;
+ private final Long number;
+
+ public XdrUnsignedInteger(Long number) {
+ if (number < MIN_VALUE || number > MAX_VALUE) {
+ throw new IllegalArgumentException("number must be between 0 and 2^32 - 1 inclusive");
+ }
+ this.number = number;
+ }
+
+ public XdrUnsignedInteger(Integer number) {
+ if (number < 0) {
+ throw new IllegalArgumentException(
+ "number must be greater than or equal to 0 if you want to construct it from Integer");
+ }
+ this.number = number.longValue();
+ }
+
+ public Long getNumber() {
+ return number;
+ }
+
+ public static XdrUnsignedInteger decode(XdrDataInputStream stream) throws IOException {
+ int intValue = stream.readInt();
+ long uint32Value = Integer.toUnsignedLong(intValue);
+ return new XdrUnsignedInteger(uint32Value);
+ }
+
+ @Override
+ public void encode(XdrDataOutputStream stream) throws IOException {
+ stream.writeInt(number.intValue());
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(this.number);
+ }
+
+ @Override
+ public boolean equals(Object object) {
+ if (!(object instanceof XdrUnsignedInteger)) {
+ return false;
+ }
+
+ XdrUnsignedInteger other = (XdrUnsignedInteger) object;
+ return Objects.equal(this.number, other.number);
+ }
+
+ public String toString() {
+ return "XdrUnsignedInteger(number=" + this.getNumber() + ")";
+ }
+}