From a5e8042b68ecaa9db65ae70001ea3f3874ba08f7 Mon Sep 17 00:00:00 2001 From: Jun Luo <4catcode@gmail.com> Date: Mon, 7 Aug 2023 20:53:22 +0800 Subject: [PATCH] fix(java): Fix the representation of UnsignedInteger and UnsignedHyperInteger. (#163) --- lib/xdrgen/generators/java.rb | 26 ++++--- .../java/XdrUnsignedHyperInteger.erb | 77 +++++++++++++++++++ .../generators/java/XdrUnsignedInteger.erb | 65 ++++++++++++++++ .../XdrUnsignedHyperInteger.java | 77 +++++++++++++++++++ .../block_comments.x/XdrUnsignedInteger.java | 65 ++++++++++++++++ .../const.x/XdrUnsignedHyperInteger.java | 77 +++++++++++++++++++ .../const.x/XdrUnsignedInteger.java | 65 ++++++++++++++++ .../enum.x/XdrUnsignedHyperInteger.java | 77 +++++++++++++++++++ .../enum.x/XdrUnsignedInteger.java | 65 ++++++++++++++++ .../nesting.x/XdrUnsignedHyperInteger.java | 77 +++++++++++++++++++ .../nesting.x/XdrUnsignedInteger.java | 65 ++++++++++++++++ .../optional.x/XdrUnsignedHyperInteger.java | 77 +++++++++++++++++++ .../optional.x/XdrUnsignedInteger.java | 65 ++++++++++++++++ .../struct.x/XdrUnsignedHyperInteger.java | 77 +++++++++++++++++++ .../struct.x/XdrUnsignedInteger.java | 65 ++++++++++++++++ .../generator_spec_java/test.x/Int3.java | 12 +-- .../generator_spec_java/test.x/Int4.java | 12 +-- .../generator_spec_java/test.x/MyStruct.java | 14 ++-- .../test.x/XdrUnsignedHyperInteger.java | 77 +++++++++++++++++++ .../test.x/XdrUnsignedInteger.java | 65 ++++++++++++++++ .../union.x/XdrUnsignedHyperInteger.java | 77 +++++++++++++++++++ .../union.x/XdrUnsignedInteger.java | 65 ++++++++++++++++ 22 files changed, 1314 insertions(+), 28 deletions(-) create mode 100644 lib/xdrgen/generators/java/XdrUnsignedHyperInteger.erb create mode 100644 lib/xdrgen/generators/java/XdrUnsignedInteger.erb create mode 100644 spec/output/generator_spec_java/block_comments.x/XdrUnsignedHyperInteger.java create mode 100644 spec/output/generator_spec_java/block_comments.x/XdrUnsignedInteger.java create mode 100644 spec/output/generator_spec_java/const.x/XdrUnsignedHyperInteger.java create mode 100644 spec/output/generator_spec_java/const.x/XdrUnsignedInteger.java create mode 100644 spec/output/generator_spec_java/enum.x/XdrUnsignedHyperInteger.java create mode 100644 spec/output/generator_spec_java/enum.x/XdrUnsignedInteger.java create mode 100644 spec/output/generator_spec_java/nesting.x/XdrUnsignedHyperInteger.java create mode 100644 spec/output/generator_spec_java/nesting.x/XdrUnsignedInteger.java create mode 100644 spec/output/generator_spec_java/optional.x/XdrUnsignedHyperInteger.java create mode 100644 spec/output/generator_spec_java/optional.x/XdrUnsignedInteger.java create mode 100644 spec/output/generator_spec_java/struct.x/XdrUnsignedHyperInteger.java create mode 100644 spec/output/generator_spec_java/struct.x/XdrUnsignedInteger.java create mode 100644 spec/output/generator_spec_java/test.x/XdrUnsignedHyperInteger.java create mode 100644 spec/output/generator_spec_java/test.x/XdrUnsignedInteger.java create mode 100644 spec/output/generator_spec_java/union.x/XdrUnsignedHyperInteger.java create mode 100644 spec/output/generator_spec_java/union.x/XdrUnsignedInteger.java 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() + ")"; + } +}