diff --git a/README.md b/README.md index edafc0047..d2c81d994 100644 --- a/README.md +++ b/README.md @@ -16,18 +16,16 @@ Xdrgen is a very early project. Aside from the test fixtures in are the .x files used for the [stellar-core project](https://github.com/stellar/stellar-core). -Xdrgen presently supports these output languages: ruby, javacript, java, -golang, and elixir: +Xdrgen presently supports these output languages: ruby, javacript, java, golang, and elixir: - ruby: complete support - javascript: complete support - java: complete support - golang: currently using a fork of go-xdr, but has complete support - rust: support is experimental. Default arms and floats are not supported. -- elixir: support is experimental as the SDK is in early development. Generated - code requires [:exdr](https://github.com/revelrylabs/exdr) in your deps +- elixir: complete support. Generated code requires [:elixir_xdr](https://github.com/kommitters/elixir_xdr) in your deps. - C#: complete support - + Testing is _very_ sparse, but will improve over time. ## Usage as a binary diff --git a/lib/xdrgen/generators/elixir.rb b/lib/xdrgen/generators/elixir.rb index b19d7cdfe..959acb22d 100644 --- a/lib/xdrgen/generators/elixir.rb +++ b/lib/xdrgen/generators/elixir.rb @@ -2,83 +2,72 @@ module Xdrgen module Generators class Elixir < Xdrgen::Generators::Base MAX_INT = (2**31) - 1 + def generate - path = "#{@namespace}_generated.ex" - out = @output.open(path) + @constants = Hash.new - render_define_block(out) do - out.indent() do - render_definitions(out, @top) - end - end + render_consts_definitions(@top) + render_definitions(@top) + render_base_classes end private - def render_definitions(out, node) - node.definitions.each{|n| render_definition out, n } - node.namespaces.each{|n| render_definitions out, n } + def render_definitions(node) + node.definitions.each{|n| render_definition n } + node.namespaces.each{|n| render_definitions n } end - def render_nested_definitions(out, defn) + def render_consts_definitions(node) + node.definitions.each{|n| render_consts n } + node.namespaces.each{|n| render_consts_definitions n } + end + + def render_nested_definitions(defn) return unless defn.respond_to? :nested_definitions - defn.nested_definitions.each{|ndefn| render_definition out, ndefn} + defn.nested_definitions.each{|ndefn| render_definition ndefn} end - def render_definition(out, defn) - render_nested_definitions(out, defn) - render_source_comment(out, defn) + def render_definition(defn) + render_nested_definitions(defn) case defn when AST::Definitions::Struct ; - render_struct out, defn + render_struct defn when AST::Definitions::Enum ; - render_enum out, defn + render_enum defn when AST::Definitions::Union ; - render_union out, defn + render_union defn when AST::Definitions::Typedef ; - render_typedef out, defn - when AST::Definitions::Const ; - render_const out, defn + render_typedef(defn, false) end - - out.break end - def render_source_comment(out, defn) - return if defn.is_a?(AST::Definitions::Namespace) - - out.puts <<-EOS.strip_heredoc - comment ~S""" - === xdr source ============================================================ - - EOS - - out.puts " " + defn.text_value.split("\n").join("\n ") - - out.puts <<-EOS.strip_heredoc - - =========================================================================== - """ - EOS + def render_consts(defn) + case defn + when AST::Definitions::Const; + render_const defn + end end - def render_moduledoc(out) + def render_moduledoc(out, type) out.puts <<-EOS.strip_heredoc @moduledoc """ Automatically generated by xdrgen DO NOT EDIT or your changes may be overwritten - Target implementation: exdr at https://hex.pm/packages/exdr + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `#{type.upcase_first}` type. """ EOS out.break + out.puts "@behaviour XDR.Declaration\n\n" end - def render_define_block(out) - out.puts "defmodule #{@namespace} do" + def render_define_block(out, module_name) + out.puts "defmodule #{@namespace}.#{module_name.upcase_first} do" out.indent do - render_moduledoc(out) - out.puts "use XDR.Base\n\n" + render_moduledoc(out, module_name) end yield ensure @@ -86,106 +75,504 @@ def render_define_block(out) out.break end + def render_typedef(typedef, is_struct) + build_typedef(typedef, is_struct) + end - def render_typedef(out, typedef) - out.puts "define_type(\"#{name typedef}\", #{build_type_args typedef.declaration.type})" + def render_const(const) + @constants["#{const.name.underscore.downcase}"] = const.value end - def render_const(out, const) - out.puts "define_type(\"#{const_name const}\", Const, #{const.value});" + def render_other_type(type) + begin + type_name_camelize = type.name.camelize + declaration_type = type.declaration.type + sub_type = declaration_type.sub_type + number = type_reference(type, type_name_camelize).scan(/\d+/).first + + case sub_type + when :optional + base_type = type_string(declaration_type) + name = type_reference(type, type_name_camelize) + build_optional_typedef(type, base_type, name) + when :var_array, :array + base_type = type_string(declaration_type) + name = type_reference(type, type_name_camelize) + if sub_type == :var_array + is_named, size = declaration_type.array_size + size = get_size(size, is_named, true) + length_nil = declaration_type.decl.resolved_size.nil? + name = "#{name}#{size unless length_nil}" + build_list_typedef(name, base_type, "VariableArray", declaration_type) + else + build_list_typedef(name, base_type, "FixedArray", declaration_type) + end + else + + unless number.nil? + render_typedef(type, true) + end + end + rescue => exception + end end - def render_struct(out, struct) - out.puts "define_type(\"#{name struct}\", Struct," - out.indent do - struct.members.each_with_index do |m, i| - out.puts "#{member_name m}: #{type_reference m.type}#{comma_unless_last(i, struct.members)}" + def render_struct(struct) + struct_name = name struct + file_name = "#{struct_name.underscore}.ex" + out = @output.open(file_name) + + render_define_block(out, struct_name) do + out.indent do + out.puts "alias #{@namespace}.{\n" + out.indent do + alias_list = [] + struct.members.each do |m| + name = type_reference m, m.name.camelize + unless alias_list.include?(name) + if m.declaration.type.sub_type == :var_array + name = add_size_to_name(m, name) + end + alias_list << name + render_other_type(m) + end + end + + alias_list.each_with_index do |m, i| + out.puts "#{m}#{comma_unless_last(i, alias_list)}" + end + end + out.puts "}\n\n" + + out.puts "@struct_spec XDR.Struct.new(" + out.indent do + struct.members.each_with_index do |m, i| + module_name = type_reference m, m.name.camelize + if m.declaration.type.sub_type == :var_array + module_name = add_size_to_name(m, module_name) + end + out.puts "#{m.name.underscore.downcase}: #{module_name}#{comma_unless_last(i, struct.members)}" + end + end + out.puts ")\n\n" + + struct.members.each_with_index do |m, i| + module_name = type_reference m, m.name.camelize + if m.declaration.type.sub_type == :var_array + module_name = add_size_to_name(m, module_name) + end + out.puts "@type #{m.name.underscore.downcase}_type :: #{module_name}.t()" + end + out.puts "\n" + + types = "@type t :: %__MODULE__{" + struct.members.each_with_index do |m, i| + types += "#{m.name.underscore.downcase}: #{m.name.underscore.downcase}_type()#{comma_and_space_unless_last(i, struct.members)}" + end + types += "}\n\n" + out.puts types + + def_struct = "defstruct [" + struct.members.each_with_index do |m, i| + def_struct += ":#{m.name.underscore.downcase}#{comma_and_space_unless_last(i, struct.members)}" + end + def_struct += "]\n\n" + out.puts def_struct + + spec = "@spec new(" + struct.members.each_with_index do |m, i| + spec += "#{m.name.underscore.downcase} :: #{m.name.underscore.downcase}_type()#{comma_and_space_unless_last(i, struct.members)}" + end + spec += ") :: t()\n" + out.puts spec + + out.puts "def new(" + out.indent do + struct.members.each_with_index do |m, i| + module_name = type_reference m, m.name.camelize + if m.declaration.type.sub_type == :var_array + module_name = add_size_to_name(m, module_name) + end + out.puts "%#{module_name}{} = #{m.name.underscore.downcase}#{comma_unless_last(i, struct.members)}" + end + end + out.puts "),\n" + function = "do: %__MODULE__{" + struct.members.each_with_index do |m, i| + function += "#{m.name.underscore.downcase}: #{m.name.underscore.downcase}#{comma_and_space_unless_last(i, struct.members)}" + end + function += "}\n\n" + out.puts function + + out.puts "@impl true\n" + impl = "def encode_xdr(%__MODULE__{" + struct.members.each_with_index do |m, i| + impl += "#{m.name.underscore.downcase}: #{m.name.underscore.downcase}#{comma_and_space_unless_last(i, struct.members)}" + end + impl += "}) do\n" + out.puts impl + args = "[" + out.indent do + struct.members.each_with_index do |m, i| + args += "#{m.name.underscore.downcase}: #{m.name.underscore.downcase}#{comma_and_space_unless_last(i, struct.members)}" + end + args += "]\n" + out.puts args + out.puts "|> XDR.Struct.new()" + out.puts "|> XDR.Struct.encode_xdr()" + end + out.puts "end\n\n" + + out.puts "@impl true\n" + impl = "def encode_xdr!(%__MODULE__{" + struct.members.each_with_index do |m, i| + impl += "#{m.name.underscore.downcase}: #{m.name.underscore.downcase}#{comma_and_space_unless_last(i, struct.members)}" + end + impl += "}) do\n" + out.puts impl + args = "[" + out.indent do + struct.members.each_with_index do |m, i| + args += "#{m.name.underscore.downcase}: #{m.name.underscore.downcase}#{comma_and_space_unless_last(i, struct.members)}" + end + args += "]\n" + out.puts args + out.puts "|> XDR.Struct.new()" + out.puts "|> XDR.Struct.encode_xdr!()" + end + out.puts "end\n\n" + + out.puts "@impl true\n" + out.puts "def decode_xdr(bytes, struct \\\\ @struct_spec)\n\n" + + out.puts "def decode_xdr(bytes, struct) do" + out.indent do + out.puts "case XDR.Struct.decode_xdr(bytes, struct) do" + out.indent do + comp = "{:ok, {%XDR.Struct{components: [" + struct.members.each_with_index do |m, i| + comp += "#{m.name.underscore.downcase}: #{m.name.underscore.downcase}#{comma_and_space_unless_last(i, struct.members)}" + end + comp += "]}, rest}} ->\n" + out.puts comp + out.indent do + new_comp = "{:ok, {new(" + struct.members.each_with_index do |m, i| + new_comp += "#{m.name.underscore.downcase}#{comma_and_space_unless_last(i, struct.members)}" + end + new_comp += "), rest}}" + out.puts new_comp + end + out.puts "error -> error" + end + out.puts "end" + end + out.puts "end\n\n" + + out.puts "@impl true\n" + out.puts "def decode_xdr!(bytes, struct \\\\ @struct_spec)\n\n" + + out.puts "def decode_xdr!(bytes, struct) do" + out.indent do + comp = "{%XDR.Struct{components: [" + struct.members.each_with_index do |m, i| + comp += "#{m.name.underscore.downcase}: #{m.name.underscore.downcase}#{comma_and_space_unless_last(i, struct.members)}" + end + comp += "]}, rest} =\n" + out.puts comp + out.indent do + out.puts "XDR.Struct.decode_xdr!(bytes, struct)" + end + new_comp = "{new(" + struct.members.each_with_index do |m, i| + new_comp += "#{m.name.underscore.downcase}#{comma_and_space_unless_last(i, struct.members)}" + end + new_comp += "), rest}" + out.puts new_comp + end + out.puts "end" end end - out.puts ")" + out.close end - def render_enum(out, enum) - out.puts "define_type(\"#{name enum}\", Enum," - out.indent do - enum.members.each_with_index do |m, i| - out.puts "#{member_name m}: #{m.value}#{comma_unless_last(i, enum.members)}" + def render_enum(enum) + enum_name = name enum + file_name = "#{enum_name.underscore}.ex" + out = @output.open(file_name) + + render_define_block(out, enum_name) do + out.indent do + out.puts "@declarations [\n" + out.indent do + enum.members.each_with_index do |m, i| + out.puts "#{m.name}: #{m.value}#{comma_unless_last(i, enum.members)}" + end + end + out.puts "]\n\n" + + out.puts "@enum_spec %XDR.Enum{declarations: @declarations, identifier: nil}\n\n" + + out.puts "@type t :: %__MODULE__{identifier: atom()}\n\n" + + out.puts "defstruct [:identifier]\n\n" + + out.puts "@spec new(type :: atom()) :: t()\n" + out.puts "def new(type \\\\ :#{enum.members.first.name}), do: %__MODULE__{identifier: type}\n\n" + + out.puts "@impl true" + out.puts "def encode_xdr(%__MODULE__{identifier: type}) do\n" + out.indent do + out.puts "@declarations\n" + out.puts "|> XDR.Enum.new(type)\n" + out.puts "|> XDR.Enum.encode_xdr()\n" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def encode_xdr!(%__MODULE__{identifier: type}) do\n" + out.indent do + out.puts "@declarations\n" + out.puts "|> XDR.Enum.new(type)\n" + out.puts "|> XDR.Enum.encode_xdr!()\n" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def decode_xdr(bytes, spec \\\\ @enum_spec)\n\n" + + out.puts "def decode_xdr(bytes, spec) do\n" + out.indent do + out.puts "case XDR.Enum.decode_xdr(bytes, spec) do\n" + out.indent do + out.puts "{:ok, {%XDR.Enum{identifier: type}, rest}} -> {:ok, {new(type), rest}}\n" + out.puts "error -> error\n" + end + out.puts "end\n" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def decode_xdr!(bytes, spec \\\\ @enum_spec)\n\n" + + out.puts "def decode_xdr!(bytes, spec) do\n" + out.indent do + out.puts "{%XDR.Enum{identifier: type}, rest} = XDR.Enum.decode_xdr!(bytes, spec)\n" + out.puts "{new(type), rest}\n" + end + out.puts "end\n" end end - out.puts ")" end - def render_union(out, union) - out.puts "define_type(\"#{name union}\", Union," - out.indent do - out.puts "switch_type: #{type_reference union.discriminant.type}," - out.puts "switch_name: :#{member_name union.discriminant}," + def render_union(union) + union_name = name union + union_name_camelize = union.name.camelize + union_discriminant = union.discriminant + is_number_type = is_number_type?(union) + + file_name = "#{union_name.underscore}.ex" + out = @output.open(file_name) - out.puts "switches: [" + render_define_block(out, union_name) do out.indent do - union.normal_arms.each do |arm| - arm_name = arm.void? ? "XDR.Type.Void" : ":#{member_name(arm)}" + out.puts "alias #{@namespace}.{\n" + out.indent do + out.puts "#{type_reference union_discriminant, union_name_camelize}," + alias_list = [] + union.arms.each do |m| + name = m.void? ? "Void" : "#{type_reference m, m.name.camelize}" + unless alias_list.include?(name) + unless m.void? + if m.declaration.type.sub_type == :var_array + name = add_size_to_name(m, name) + end + end + alias_list << name + render_other_type(m) + end + end + + alias_list.each_with_index do |m, i| + out.puts "#{m}#{comma_unless_last(i, alias_list)}" + end + end + out.puts "}\n\n" - arm.cases.each do |acase| - switch = if acase.value.is_a?(AST::Identifier) - ":#{member_name(acase.value)}" + out.puts "@arms #{is_number_type ? "%{" : "["}" + out.indent do + union.normal_arms.each_with_index do |arm, i| + arm_name = arm.void? ? "Void" : "#{type_reference arm, arm.name.camelize}" + unless arm.void? + if arm.declaration.type.sub_type == :var_array + arm_name = add_size_to_name(arm, arm_name) + end + end + arm.cases.each_with_index do |acase, o| + switch = if acase.value.is_a?(AST::Identifier) + "#{acase.value.text_value}:" + else + "#{acase.value.text_value} =>" + end + out.puts "#{switch} #{arm_name}#{(union.arms.count <= (i + 1)) && ((o + 1) >= arm.cases.count) ? "" : ","}" + end + end + + if union.default_arm.present? + out.puts "default: #{type_reference union.default_arm, union.default_arm.name.camelize}" + end + end + out.puts "#{is_number_type ? "}" : "]"}\n\n" + + out.puts "@type value ::" + out.indent(4) do + type_list = "" + union.arms.each_with_index do |m, i| + name = m.void? ? "Void" : "#{type_reference m, m.name.camelize}" + unless m.void? + if m.declaration.type.sub_type == :var_array + name = add_size_to_name(m, name) + end + end + if i == 0 + type_list += "#{name}.t()\n" else - acase.value.text_value + unless type_list.include?(name) + type_list += "| #{name}.t()\n" + end end + end + out.puts type_list - out.puts "{#{switch}, #{arm_name}}," + if union.default_arm.present? + out.puts "| any()" end + end - end - out.puts "]," + out.puts "\n" - out.puts "arms: [" - out.indent do - union.arms.each do |arm| - next if arm.void? - out.puts "#{member_name arm}: #{type_reference arm.type}," + out.puts "@type t :: %__MODULE__{value: value(), type: #{is_number_type ? "integer()" : "#{type_reference(union_discriminant, union_name_camelize)}.t()"}}\n\n" + + out.puts "defstruct [:value, :type]\n\n" + + out.puts "@spec new(value :: value(), type :: #{is_number_type ? "integer()" : "#{type_reference(union_discriminant, union_name_camelize)}.t()"}) :: t()\n" + + out.puts "def new(value, #{is_number_type ? "" : "%#{type_reference(union_discriminant, union_name_camelize)}{} = "}type), do: %__MODULE__{value: value, type: type}\n\n" + + out.puts "@impl true" + out.puts "def encode_xdr(%__MODULE__{value: value, type: type}) do\n" + out.indent do + out.puts "type\n" + out.puts "|> #{type_reference(union_discriminant, union_name_camelize)}.new()" if is_number_type + out.puts "|> XDR.Union.new(@arms, value)\n" + out.puts "|> XDR.Union.encode_xdr()\n" end - end - out.puts union.default_arm.present? ? "]," : "]" + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def encode_xdr!(%__MODULE__{value: value, type: type}) do\n" + out.indent do + out.puts "type\n" + out.puts "|> #{type_reference(union_discriminant, union_name_camelize)}.new()" if is_number_type + out.puts "|> XDR.Union.new(@arms, value)\n" + out.puts "|> XDR.Union.encode_xdr!()\n" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def decode_xdr(bytes, spec \\\\ union_spec())\n\n" - if union.default_arm.present? - arm = union.default_arm - arm_name = arm.void? ? "XDR.Type.Void" : member_name(arm) - out.puts "default_arm: #{arm_name}," + out.puts "def decode_xdr(bytes, spec) do\n" + out.indent do + out.puts "case XDR.Union.decode_xdr(bytes, spec) do\n" + out.indent do + out.puts "{:ok, {{type, value}, rest}} -> {:ok, {new(value, type), rest}}\n" + out.puts "error -> error\n" + end + out.puts "end\n" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def decode_xdr!(bytes, spec \\\\ union_spec())\n\n" + + out.puts "def decode_xdr!(bytes, spec) do\n" + out.indent do + out.puts "{{type, value}, rest} = XDR.Union.decode_xdr!(bytes, spec)\n" + out.puts "{new(value, type), rest}\n" + end + out.puts "end\n\n" + + out.puts "@spec union_spec() :: XDR.Union.t()" + out.puts "defp union_spec do" + out.indent do + out.puts "#{is_number_type ? 0 : "nil"}\n" + out.puts "|> #{type_reference union_discriminant, union_name_camelize}.new()\n" + out.puts "|> XDR.Union.new(@arms)\n" + end + out.puts "end\n" end end - out.puts ")" end private - def name(named) - return nil unless named.respond_to?(:name) - - parent = name named.parent_defn if named.is_a?(AST::Concerns::NestedDefinition) - - # NOTE: classify will strip plurality, so we restore it if necessary - plural = named.name.underscore.downcase.pluralize == named.name.underscore.downcase - base = named.name.underscore.classify - result = plural ? base.pluralize : base + def add_size_to_name(member, name) + is_named, size = member.declaration.type.array_size + size = get_size(size, is_named, true) + length_nil = member.declaration.type.decl.resolved_size.nil? + "#{name}#{size unless length_nil}" + end - "#{parent}#{result}" + def get_size(size, is_named = false, is_var_array_type = false) + if size + if is_var_array_type + is_named ? @constants["#{size.underscore.downcase}"] : (size || MAX_INT) + else + size.scan(/\D/).any? ? @constants["#{size.underscore.downcase}"] : size + end + end end - def const_name(named) - named.name.underscore.upcase + def render_base_classes + file_name = "base.ex" + out = @output.open(file_name) + base_py_content = IO.read(__dir__ + "/elixir/base.ex") + new_base_file = base_py_content.gsub("defmodule ", "defmodule #{@namespace}.") + out.puts new_base_file + out.close end - def member_name(member) - name(member).underscore + def is_number_type?(union) + value = false + union.normal_arms.each do |arm| + arm.cases.each do |acase| + value = if acase.value.is_a?(AST::Identifier) + false + else + true + end + end + end + value end - # this can be a string to reference a custom type - # or a build_type call like build_type(VariableOpaque, 100) - # args for build_type can be created with build_type_args - def type_reference(type) - build_args = build_type_args(type) + def type_reference(decl, container_name) + type_hint = type_string decl.type - build_args === "\"#{name type}\"" ? build_args : "build_type(#{build_args})" + if type_hint == container_name + type_hint = "#{type_hint}" + end + + case decl.type.sub_type + when :optional + "Optional#{type_hint}" + when :var_array + "#{type_hint}List" + when :array + "#{type_hint}FixedList" + else + type_hint + end end def comma_unless_last(index, collection) @@ -196,13 +583,26 @@ def comma_unless_last(index, collection) end end - # the args to supply build_type (or define_type(name, ...args)) - def build_type_args(type) - base_ref = case type + def comma_and_space_unless_last(index, collection) + if index + 1 >= collection.length + "" + else + ", " + end + end + + def type_string(type) + case type + when AST::Typespecs::Simple + "#{name type}" + when AST::Definitions::Base + "#{name type}" + when AST::Concerns::NestedDefinition + "#{name type}" when AST::Typespecs::Bool "Bool" when AST::Typespecs::Double - "Double" + "DoubleFloat" when AST::Typespecs::Float "Float" when AST::Typespecs::Hyper @@ -211,47 +611,590 @@ def build_type_args(type) "Int" when AST::Typespecs::Opaque if type.fixed? - "Opaque, #{type.size}" + "Opaque#{get_size(type.size)}" else - type.size ? "VariableOpaque, #{type.size}" : "VariableOpaque" + type.size ? "VariableOpaque#{get_size(type.size)}" : "VariableOpaque" end when AST::Typespecs::Quadruple raise "no quadruple support in elixir" when AST::Typespecs::String - "XDR.Type.String, #{type.size}" + "String#{get_size(type.size)}" when AST::Typespecs::UnsignedHyper - "UnsignedHyperInt" + "HyperUInt" when AST::Typespecs::UnsignedInt - "UnsignedInt" - when AST::Typespecs::Simple - "\"#{name type}\"" - when AST::Definitions::Base - "\"#{name type}\"" - when AST::Concerns::NestedDefinition - "\"#{name type}\"" + "UInt" else raise "Unknown reference type: #{type.class.name}, #{type.class.ancestors}" end + end + + def build_simple_typedef(typedef, type, module_name, is_struct) + unless is_struct + attribute = module_name.underscore.downcase + file_name = "#{attribute}.ex" + out = @output.open(file_name) + + render_define_block(out, module_name) do + out.indent do + out.puts "alias #{@namespace}.#{type}\n\n" + + out.puts "@type t :: %__MODULE__{#{attribute}: #{type}.t()}\n\n" + + out.puts "defstruct [:#{attribute}]\n\n" + + out.puts "@spec new(#{attribute} :: #{type}.t()) :: t()\n" + out.puts "def new(%#{type}{} = #{attribute}), do: %__MODULE__{#{attribute}: #{attribute}}\n\n" + + out.puts "@impl true" + out.puts "def encode_xdr(%__MODULE__{#{attribute}: #{attribute}}) do\n" + out.indent do + out.puts "#{type}.encode_xdr(#{attribute})\n" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def encode_xdr!(%__MODULE__{#{attribute}: #{attribute}}) do\n" + out.indent do + out.puts "#{type}.encode_xdr!(#{attribute})\n" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def decode_xdr(bytes, term \\\\ nil)\n\n" + + out.puts "def decode_xdr(bytes, _term) do\n" + out.indent do + out.puts "case #{type}.decode_xdr(bytes) do\n" + out.indent do + out.puts "{:ok, {%#{type}{} = #{attribute}, rest}} -> {:ok, {new(#{attribute}), rest}}\n" + out.puts "error -> error\n" + end + out.puts "end\n" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def decode_xdr!(bytes, term \\\\ nil)\n\n" + + out.puts "def decode_xdr!(bytes, _term) do\n" + out.indent do + out.puts "{%#{type}{} = #{attribute}, rest} = #{type}.decode_xdr!(bytes)\n" + out.puts "{new(#{attribute}), rest}\n" + end + out.puts "end\n" + end + end + out.close + end + end + + def build_number_typedef(typedef, number_type, type, attribute) + file_name = "#{typedef.name.underscore.downcase}.ex" + out = @output.open(file_name) - base_type = base_ref === "\"#{name type}\"" ? base_ref : "buid_type(base_ref)" + render_define_block(out, typedef.name) do + out.indent do + out.puts "@type t :: %__MODULE__{#{attribute}: #{number_type}()}\n\n" + + out.puts "defstruct [:#{attribute}]\n\n" + + out.puts "@spec new(value :: #{number_type}()) :: t()\n" + out.puts "def new(value), do: %__MODULE__{#{attribute}: value}\n\n" + + out.puts "@impl true" + out.puts "def encode_xdr(%__MODULE__{#{attribute}: value}) do\n" + out.indent do + out.puts "XDR.#{type}.encode_xdr(%XDR.#{type}{datum: value})\n" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def encode_xdr!(%__MODULE__{#{attribute}: value}) do\n" + out.indent do + out.puts "XDR.#{type}.encode_xdr!(%XDR.#{type}{datum: value})\n" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def decode_xdr(bytes, term \\\\ nil)\n\n" + + out.puts "def decode_xdr(bytes, _term) do\n" + out.indent do + out.puts "case XDR.#{type}.decode_xdr(bytes) do\n" + out.indent do + out.puts "{:ok, {%XDR.#{type}{datum: value}, rest}} -> {:ok, {new(value), rest}}\n" + out.puts "error -> error\n" + end + out.puts "end\n" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def decode_xdr!(bytes, term \\\\ nil)\n\n" + + out.puts "def decode_xdr!(bytes, _term) do\n" + out.indent do + out.puts "{%XDR.#{type}{datum: value}, rest} = XDR.#{type}.decode_xdr!(bytes)\n" + out.puts "{new(value), rest}\n" + end + out.puts "end\n" + end + end + out.close + end + + def build_bool_typedef(typedef, number_type, type, attribute) + file_name = "#{typedef.name.downcase.underscore}.ex" + out = @output.open(file_name) + + render_define_block(out, typedef.name.downcase) do + out.indent do + out.puts "@type t :: %__MODULE__{#{attribute}: #{number_type}()}\n\n" + + out.puts "defstruct [:#{attribute}]\n\n" + + out.puts "@spec new(value :: #{number_type}()) :: t()\n" + out.puts "def new(value), do: %__MODULE__{#{attribute}: value}\n\n" + + out.puts "@impl true" + out.puts "def encode_xdr(%__MODULE__{#{attribute}: value}) do\n" + out.indent do + out.puts "XDR.#{type}.encode_xdr(%XDR.#{type}{identifier: value})\n" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def encode_xdr!(%__MODULE__{#{attribute}: value}) do\n" + out.indent do + out.puts "XDR.#{type}.encode_xdr!(%XDR.#{type}{identifier: value})\n" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def decode_xdr(bytes, term \\\\ nil)\n\n" + + out.puts "def decode_xdr(bytes, _term) do\n" + out.indent do + out.puts "case XDR.#{type}.decode_xdr(bytes) do\n" + out.indent do + out.puts "{:ok, {%XDR.#{type}{identifier: value}, rest}} -> {:ok, {new(value), rest}}\n" + out.puts "error -> error\n" + end + out.puts "end\n" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def decode_xdr!(bytes, term \\\\ nil)\n\n" + + out.puts "def decode_xdr!(bytes, _term) do\n" + out.indent do + out.puts "{%XDR.#{type}{identifier: value}, rest} = XDR.#{type}.decode_xdr!(bytes)\n" + out.puts "{new(value), rest}\n" + end + out.puts "end\n" + end + end + out.close + end + + def build_string_typedef(typedef, is_struct) + name = is_struct ? type_string(typedef.declaration.type) : typedef.name + + file_name = "#{name.underscore.downcase}.ex" + out = @output.open(file_name) + + render_define_block(out, name) do + out.indent do + out.puts "@type t :: %__MODULE__{value: String.t()}\n\n" + + out.puts "defstruct [:value]\n\n" + + unless typedef.declaration.type.size.nil? + out.puts "@max_length #{get_size(typedef.declaration.type.size)}\n\n" + end + + out.puts "@spec new(value :: String.t()) :: t()\n" + out.puts "def new(value), do: %__MODULE__{value: value}\n\n" + + out.puts "@impl true" + out.puts "def encode_xdr(%__MODULE__{value: value}) do\n" + out.indent do + out.puts "value\n" + unless typedef.declaration.type.size.nil? + out.puts "|> XDR.String.new(@max_length)\n" + else + out.puts "|> XDR.String.new()\n" + end + out.puts "|> XDR.String.encode_xdr()" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def encode_xdr!(%__MODULE__{value: value}) do\n" + out.indent do + out.puts "value\n" + unless typedef.declaration.type.size.nil? + out.puts "|> XDR.String.new(@max_length)\n" + else + out.puts "|> XDR.String.new()\n" + end + out.puts "|> XDR.String.encode_xdr!()" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def decode_xdr(bytes, term \\\\ nil)\n\n" + + out.puts "def decode_xdr(bytes, _term) do\n" + out.indent do + out.puts "case XDR.String.decode_xdr(bytes) do\n" + out.indent do + out.puts "{:ok, {%XDR.String{string: value}, rest}} -> {:ok, {new(value), rest}}\n" + out.puts "error -> error\n" + end + out.puts "end\n" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def decode_xdr!(bytes, term \\\\ nil)\n\n" + + out.puts "def decode_xdr!(bytes, _term) do\n" + out.indent do + out.puts "{%XDR.String{string: value}, rest} = XDR.String.decode_xdr!(bytes)\n" + out.puts "{new(value), rest}\n" + end + out.puts "end\n" + end + end + out.close + end + + def build_optional_typedef(typedef, attribute, name) + file_name = "#{name.underscore.downcase}.ex" + out = @output.open(file_name) + + render_define_block(out, "#{name}") do + out.indent do + out.puts "alias #{@namespace}.#{attribute}\n\n" + + out.puts "@optional_spec XDR.Optional.new(#{attribute})\n\n" + + out.puts "@type #{attribute.underscore.downcase} :: #{attribute}.t() | nil\n\n" + + out.puts "@type t :: %__MODULE__{#{attribute.underscore.downcase}: #{attribute.underscore.downcase}()}\n\n" + + out.puts "defstruct [:#{attribute.underscore.downcase}]\n\n" + + + out.puts "@spec new(#{attribute.underscore.downcase} :: #{attribute.underscore.downcase}()) :: t()\n" + out.puts "def new(#{attribute.underscore.downcase} \\\\ nil), do: %__MODULE__{#{attribute.underscore.downcase}: #{attribute.underscore.downcase}}\n\n" + + out.puts "@impl true" + out.puts "def encode_xdr(%__MODULE__{#{attribute.underscore.downcase}: #{attribute.underscore.downcase}}) do\n" + out.indent do + out.puts "#{attribute.underscore.downcase}" + out.puts "|> XDR.Optional.new()" + out.puts "|> XDR.Optional.encode_xdr()" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def encode_xdr!(%__MODULE__{#{attribute.underscore.downcase}: #{attribute.underscore.downcase}}) do\n" + out.indent do + out.puts "#{attribute.underscore.downcase}" + out.puts "|> XDR.Optional.new()" + out.puts "|> XDR.Optional.encode_xdr!()" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def decode_xdr(bytes, optional_spec \\\\ @optional_spec)\n\n" + + out.puts "def decode_xdr(bytes, optional_spec) do\n" + out.indent do + out.puts "case XDR.Optional.decode_xdr(bytes, optional_spec) do\n" + out.indent do + out.puts "{:ok, {%XDR.Optional{type: #{attribute.underscore.downcase}}, rest}} -> {:ok, {new(#{attribute.underscore.downcase}), rest}}\n" + out.puts "{:ok, {nil, rest}} -> {:ok, {new(), rest}}" + out.puts "error -> error\n" + end + out.puts "end\n" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def decode_xdr!(bytes, optional_spec \\\\ @optional_spec)\n\n" + + out.puts "def decode_xdr!(bytes, optional_spec) do\n" + out.indent do + out.puts "case XDR.Optional.decode_xdr!(bytes, optional_spec) do\n" + out.indent do + out.puts "{%XDR.Optional{type: #{attribute.underscore.downcase}}, rest} -> {new(#{attribute.underscore.downcase}), rest}\n" + out.puts "{nil, rest} -> {new(), rest}" + end + out.puts "end\n" + end + out.puts "end\n\n" + end + end + out.close + end + + def build_opaque_typedef(typedef, type, xdr_module, size = nil, is_struct) + size = get_size(size) unless size.nil? + name = "#{type}#{size}" + + unless size.nil? + file_name = "#{type.underscore.downcase}#{size}.ex" + begin + out = @output.open(file_name) + render_define_block(out, name) do + out.indent do + out.puts "@type t :: %__MODULE__{opaque: binary()}\n\n" + + out.puts "defstruct [:opaque]\n\n" + + out.puts "@#{type.downcase == "opaque" ? "length" : "max_size"} #{size}\n\n" + + out.puts "@opaque_spec XDR.#{xdr_module}.new(nil, @#{type.downcase == "opaque" ? "length" : "max_size"})\n\n" + + out.puts "@spec new(opaque :: binary()) :: t()\n" + out.puts "def new(opaque), do: %__MODULE__{opaque: opaque}\n\n" + + out.puts "@impl true" + out.puts "def encode_xdr(%__MODULE__{opaque: opaque}) do\n" + out.indent do + out.puts "XDR.#{xdr_module}.encode_xdr(%XDR.#{xdr_module}{opaque: opaque, #{type.downcase == "opaque" ? "length: @length" : "max_size: @max_size"}})\n" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def encode_xdr!(%__MODULE__{opaque: opaque}) do\n" + out.indent do + out.puts "XDR.#{xdr_module}.encode_xdr!(%XDR.#{xdr_module}{opaque: opaque, #{type.downcase == "opaque" ? "length: @length" : "max_size: @max_size"}})\n" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def decode_xdr(bytes, spec \\\\ @opaque_spec)\n\n" + + out.puts "def decode_xdr(bytes, spec) do\n" + out.indent do + out.puts "case XDR.#{xdr_module}.decode_xdr(bytes, spec) do\n" + out.indent do + out.puts "{:ok, {%XDR.#{xdr_module}{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}}\n" + out.puts "error -> error\n" + end + out.puts "end\n" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def decode_xdr!(bytes, spec \\\\ @opaque_spec)\n\n" + + out.puts "def decode_xdr!(bytes, spec) do\n" + out.indent do + out.puts "{%XDR.#{xdr_module}{opaque: opaque}, rest} = XDR.#{xdr_module}.decode_xdr!(bytes, spec)\n" + out.puts "{new(opaque), rest}\n" + end + out.puts "end\n" + end + end + out.close + rescue => exception + end + end + + unless is_struct + file_name_main = "#{typedef.name.underscore.downcase}.ex" + out_main = @output.open(file_name_main) + render_define_block(out_main, typedef.name) do + out_main.indent do + out_main.puts "alias #{@namespace}.#{type}#{size}\n\n" + + out_main.puts "@type t :: %__MODULE__{value: binary()}\n\n" + + out_main.puts "defstruct [:value]\n\n" + + out_main.puts "@spec new(value :: binary()) :: t()\n" + out_main.puts "def new(value), do: %__MODULE__{value: value}\n\n" + + out_main.puts "@impl true" + out_main.puts "def encode_xdr(%__MODULE__{value: value}) do\n" + out_main.indent do + out_main.puts "value\n" + out_main.puts "|> #{type}#{size}.new()\n" + out_main.puts "|> #{type}#{size}.encode_xdr()\n" + end + out_main.puts "end\n\n" + + out_main.puts "@impl true" + out_main.puts "def encode_xdr!(%__MODULE__{value: value}) do\n" + out_main.indent do + out_main.puts "value\n" + out_main.puts "|> #{type}#{size}.new()\n" + out_main.puts "|> #{type}#{size}.encode_xdr!()\n" + end + out_main.puts "end\n\n" + + out_main.puts "@impl true" + out_main.puts "def decode_xdr(bytes, term \\\\ nil)\n\n" + + out_main.puts "def decode_xdr(bytes, _term) do\n" + out_main.indent do + out_main.puts "case #{type}#{size}.decode_xdr(bytes) do\n" + out_main.indent do + out_main.puts "{:ok, {%#{type}#{size}{opaque: value}, rest}} -> {:ok, {new(value), rest}}\n" + out_main.puts "error -> error\n" + end + out_main.puts "end\n" + end + out_main.puts "end\n\n" + + out_main.puts "@impl true" + out_main.puts "def decode_xdr!(bytes, term \\\\ nil)\n\n" + + out_main.puts "def decode_xdr!(bytes, _term) do\n" + out_main.indent do + out_main.puts "{%#{type}#{size}{opaque: value}, rest} = #{type}#{size}.decode_xdr!(bytes)\n" + out_main.puts "{new(value), rest}\n" + end + out_main.puts "end\n" + end + end + out_main.close + end + end + + def build_list_typedef(module_name, base_type, list_type, type) + file_name = "#{module_name.underscore.downcase}.ex" + out = @output.open(file_name) + + is_named, size = type.array_size + if type.sub_type == :var_array + size = get_size(size, is_named, true) + length_nil = type.decl.resolved_size.nil? + else + size = get_size(size, is_named) + length_nil = false + end + + render_define_block(out, module_name) do + out.indent do + out.puts "alias #{@namespace}.#{base_type}\n\n" + + unless length_nil + out.puts "@#{list_type.downcase == "fixedarray" ? "length" : "max_length"} #{size}\n\n" + end + + out.puts "@array_type #{base_type}\n\n" + + out.puts "@array_spec %{type: @array_type#{length_nil ? "" : ", #{list_type.downcase == "fixedarray"? "length: @length" : "max_length: @max_length"}"}}\n\n" + + out.puts "@type t :: %__MODULE__{items: list(#{base_type}.t())}\n\n" + + out.puts "defstruct [:items]\n\n" + + out.puts "@spec new(items :: list(#{base_type}.t())) :: t()\n" + out.puts "def new(items), do: %__MODULE__{items: items}\n\n" + + out.puts "@impl true" + out.puts "def encode_xdr(%__MODULE__{items: items}) do\n" + out.indent do + out.puts "items\n" + out.puts "|> XDR.#{list_type}.new(@array_type#{length_nil ? "" : ", @#{list_type.downcase == "fixedarray" ? "length" : "max_length"}"})\n" + out.puts "|> XDR.#{list_type}.encode_xdr()\n" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def encode_xdr!(%__MODULE__{items: items}) do\n" + out.indent do + out.puts "items\n" + out.puts "|> XDR.#{list_type}.new(@array_type#{length_nil ? "" : ", @#{list_type.downcase == "fixedarray" ? "length" : "max_length"}"})\n" + out.puts "|> XDR.#{list_type}.encode_xdr!()\n" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def decode_xdr(bytes, spec \\\\ @array_spec)\n\n" + + out.puts "def decode_xdr(bytes, spec) do\n" + out.indent do + out.puts "case XDR.#{list_type}.decode_xdr(bytes, spec) do\n" + out.indent do + out.puts "{:ok, {items, rest}} -> {:ok, {new(items), rest}}\n" + out.puts "error -> error\n" + end + out.puts "end\n" + end + out.puts "end\n\n" + + out.puts "@impl true" + out.puts "def decode_xdr!(bytes, spec \\\\ @array_spec)\n\n" + + out.puts "def decode_xdr!(bytes, spec) do\n" + out.indent do + out.puts "{items, rest} = XDR.#{list_type}.decode_xdr!(bytes, spec)\n" + out.puts "{new(items), rest}\n" + end + out.puts "end\n" + end + end + out.close + end + + def build_typedef(typedef, is_struct) + type = typedef.declaration.type + base_type = type_string(type) + name = typedef.name case type.sub_type - when :simple - base_ref when :optional - "Optional, #{base_type}" + build_optional_typedef(typedef, base_type, name) when :array - is_named, size = type.array_size - size = is_named ? "\"#{size}\"" : size - "Array, length: #{size}, type: #{base_type}" + build_list_typedef(name, base_type, "FixedArray", type) when :var_array - is_named, size = type.array_size - size = is_named ? "\"#{size}\"" : (size || MAX_INT) - "VariableArray, max_length: #{size}, type: #{base_type}" + build_list_typedef(name, base_type, "VariableArray", type) else - raise "Unknown sub_type: #{type.sub_type}" + case type + when AST::Typespecs::Bool + build_bool_typedef(typedef, "boolean", "Bool", "bool") + when AST::Typespecs::Double + build_number_typedef(typedef, "float_number", "DoubleFloat", "float") + when AST::Typespecs::Float + build_number_typedef(typedef, "float_number", "Float", "float") + when AST::Typespecs::Hyper + build_number_typedef(typedef, "integer", "HyperInt", "datum") + when AST::Typespecs::Int + build_number_typedef(typedef, "integer", "Int", "datum") + when AST::Typespecs::Opaque + if type.fixed? + build_opaque_typedef(typedef, "Opaque", "FixedOpaque", type.size, is_struct) + else + type.size ? build_opaque_typedef(typedef, "VariableOpaque", "VariableOpaque", type.size, is_struct) : build_opaque_typedef(typedef, "VariableOpaque", "VariableOpaque", is_struct) + end + when AST::Typespecs::Quadruple + raise "no quadruple support in elixir" + when AST::Typespecs::String + build_string_typedef(typedef, is_struct) + when AST::Typespecs::UnsignedHyper + build_number_typedef(typedef, "non_neg_integer", "HyperUInt", "datum") + when AST::Typespecs::UnsignedInt + build_number_typedef(typedef, "non_neg_integer", "UInt", "datum") + else + build_simple_typedef(typedef, base_type, typedef.name, is_struct) + end end end + + def name(named) + parent = name named.parent_defn if named.is_a?(AST::Concerns::NestedDefinition) + result = named.name.camelize + "#{parent}#{result}" + end end end end diff --git a/lib/xdrgen/generators/elixir/base.ex b/lib/xdrgen/generators/elixir/base.ex new file mode 100644 index 000000000..a2a8cdc5a --- /dev/null +++ b/lib/xdrgen/generators/elixir/base.ex @@ -0,0 +1,439 @@ +defmodule Int do + @moduledoc """ + Representation of Stellar `Int` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: integer()} + + defstruct [:datum] + + @spec new(int :: integer()) :: t() + def new(int), do: %__MODULE__{datum: int} + + @impl true + def encode_xdr(%__MODULE__{datum: int}) do + XDR.Int.encode_xdr(%XDR.Int{datum: int}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: int}) do + XDR.Int.encode_xdr!(%XDR.Int{datum: int}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Int.decode_xdr(bytes) do + {:ok, {%XDR.Int{datum: int}, rest}} -> {:ok, {new(int), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Int{datum: int}, rest} = XDR.Int.decode_xdr!(bytes) + {new(int), rest} + end +end + +defmodule Uint do + @moduledoc """ + Representation of Stellar `Uint` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: non_neg_integer()} + + defstruct [:datum] + + @spec new(uint :: non_neg_integer()) :: t() + def new(uint), do: %__MODULE__{datum: uint} + + @impl true + def encode_xdr(%__MODULE__{datum: uint}) do + XDR.UInt.encode_xdr(%XDR.UInt{datum: uint}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: uint}) do + XDR.UInt.encode_xdr!(%XDR.UInt{datum: uint}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.UInt.decode_xdr(bytes) do + {:ok, {%XDR.UInt{datum: uint}, rest}} -> {:ok, {new(uint), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.UInt{datum: uint}, rest} = XDR.UInt.decode_xdr!(bytes) + {new(uint), rest} + end +end + +defmodule Float do + @moduledoc """ + Representation of Stellar `Float` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{float: float()} + + defstruct [:float] + + @spec new(float :: float()) :: t() + def new(float), do: %__MODULE__{float: float} + + @impl true + def encode_xdr(%__MODULE__{float: float}) do + XDR.Float.encode_xdr(%XDR.Float{float: float}) + end + + @impl true + def encode_xdr!(%__MODULE__{float: float}) do + XDR.Float.encode_xdr!(%XDR.Float{float: float}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Float.decode_xdr(bytes) do + {:ok, {%XDR.Float{float: float}, rest}} -> {:ok, {new(float), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Float{float: float}, rest} = XDR.Float.decode_xdr!(bytes) + {new(float), rest} + end +end + +defmodule DoubleFloat do + @moduledoc """ + Representation of Stellar `DoubleFloat` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{float: float()} + + defstruct [:float] + + @spec new(float :: float()) :: t() + def new(float), do: %__MODULE__{float: float} + + @impl true + def encode_xdr(%__MODULE__{float: float}) do + XDR.DoubleFloat.encode_xdr(%XDR.DoubleFloat{float: float}) + end + + @impl true + def encode_xdr!(%__MODULE__{float: float}) do + XDR.DoubleFloat.encode_xdr!(%XDR.DoubleFloat{float: float}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.DoubleFloat.decode_xdr(bytes) do + {:ok, {%XDR.DoubleFloat{float: float}, rest}} -> {:ok, {new(float), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.DoubleFloat{float: float}, rest} = XDR.DoubleFloat.decode_xdr!(bytes) + {new(float), rest} + end +end + +defmodule HyperUInt do + @moduledoc """ + Representation of Stellar `HyperUInt` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: non_neg_integer()} + + defstruct [:datum] + + @spec new(uint :: non_neg_integer()) :: t() + def new(uint), do: %__MODULE__{datum: uint} + + @impl true + def encode_xdr(%__MODULE__{datum: uint}) do + XDR.HyperUInt.encode_xdr(%XDR.HyperUInt{datum: uint}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: uint}) do + XDR.HyperUInt.encode_xdr!(%XDR.HyperUInt{datum: uint}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.HyperUInt.decode_xdr(bytes) do + {:ok, {%XDR.HyperUInt{datum: uint}, rest}} -> {:ok, {new(uint), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.HyperUInt{datum: uint}, rest} = XDR.HyperUInt.decode_xdr!(bytes) + {new(uint), rest} + end +end + +defmodule Bool do + @moduledoc """ + Representation of Stellar `Bool` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: boolean()} + + defstruct [:value] + + @spec new(value :: boolean()) :: t() + def new(val), do: %__MODULE__{value: val} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + XDR.Bool.encode_xdr(%XDR.Bool{identifier: value}) + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + XDR.Bool.encode_xdr!(%XDR.Bool{identifier: value}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Bool.decode_xdr(bytes) do + {:ok, {%XDR.Bool{identifier: val}, rest}} -> {:ok, {new(val), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Bool{identifier: val}, rest} = XDR.Bool.decode_xdr!(bytes) + {new(val), rest} + end +end + +defmodule String do + @moduledoc """ + Representation of Stellar `String` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: String.t()} + + defstruct [:value] + + @spec new(value :: String.t()) :: t() + def new(value), do: %__MODULE__{value: value} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + value + |> XDR.String.new() + |> XDR.String.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + value + |> XDR.String.new() + |> XDR.String.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.String.decode_xdr(bytes) do + {:ok, {%XDR.String{string: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.String{string: value}, rest} = XDR.String.decode_xdr!(bytes) + {new(value), rest} + end +end + +defmodule FixedOpaque do + @moduledoc """ + Representation of Stellar `FixedOpaque` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{opaque: binary()} + + defstruct [:opaque] + + @length 4_294_967_295 + + @opaque_spec XDR.FixedOpaque.new(nil, @length) + + @spec new(opaque :: binary()) :: t() + def new(opaque), do: %__MODULE__{opaque: opaque} + + @impl true + def encode_xdr(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def encode_xdr!(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr!(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def decode_xdr(bytes, spec \\ @opaque_spec) + + def decode_xdr(bytes, spec) do + case XDR.FixedOpaque.decode_xdr(bytes, spec) do + {:ok, {%XDR.FixedOpaque{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @opaque_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.FixedOpaque{opaque: opaque}, rest} = XDR.FixedOpaque.decode_xdr!(bytes, spec) + {new(opaque), rest} + end +end + +defmodule VariableOpaque do + @moduledoc """ + Representation of Stellar `VariableOpaque` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{opaque: binary()} + + defstruct [:opaque] + + @opaque_spec XDR.VariableOpaque.new(nil) + + @spec new(opaque :: binary()) :: t() + def new(opaque), do: %__MODULE__{opaque: opaque} + + @impl true + def encode_xdr(%__MODULE__{opaque: opaque}) do + XDR.VariableOpaque.encode_xdr(%XDR.VariableOpaque{opaque: opaque}) + end + + @impl true + def encode_xdr!(%__MODULE__{opaque: opaque}) do + XDR.VariableOpaque.encode_xdr!(%XDR.VariableOpaque{opaque: opaque}) + end + + @impl true + def decode_xdr(bytes, spec \\ @opaque_spec) + + def decode_xdr(bytes, spec) do + case XDR.VariableOpaque.decode_xdr(bytes, spec) do + {:ok, {%XDR.VariableOpaque{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @opaque_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.VariableOpaque{opaque: opaque}, rest} = XDR.VariableOpaque.decode_xdr!(bytes, spec) + {new(opaque), rest} + end +end + +defmodule Void do + @moduledoc """ + Representation of Stellar `Void` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: nil} + + defstruct [:value] + + @spec new(value :: nil) :: t() + def new(_val \\ nil), do: %__MODULE__{value: nil} + + @impl true + def encode_xdr(%__MODULE__{}) do + XDR.Void.encode_xdr(%XDR.Void{}) + end + + @impl true + def encode_xdr!(%__MODULE__{}) do + XDR.Void.encode_xdr!(%XDR.Void{}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Void.decode_xdr(bytes) do + {:ok, {nil, rest}} -> {:ok, {new(), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {nil, rest} = XDR.Void.decode_xdr!(bytes) + {new(), rest} + end +end diff --git a/spec/output/generator_spec_elixir/block_comments.x/MyXDR_generated.ex b/spec/output/generator_spec_elixir/block_comments.x/MyXDR_generated.ex deleted file mode 100644 index 41d118c6b..000000000 --- a/spec/output/generator_spec_elixir/block_comments.x/MyXDR_generated.ex +++ /dev/null @@ -1,25 +0,0 @@ -defmodule MyXDR do - @moduledoc """ - Automatically generated by xdrgen - DO NOT EDIT or your changes may be overwritten - - Target implementation: exdr at https://hex.pm/packages/exdr - """ - - use XDR.Base - - comment ~S""" - === xdr source ============================================================ - - enum AccountFlags - { // masks for each flag - AUTH_REQUIRED_FLAG = 0x1 - }; - - =========================================================================== - """ - define_type("AccountFlags", Enum, - auth_required_flag: 1 - ) - -end diff --git a/spec/output/generator_spec_elixir/block_comments.x/account_flags.ex b/spec/output/generator_spec_elixir/block_comments.x/account_flags.ex new file mode 100644 index 000000000..497bc342d --- /dev/null +++ b/spec/output/generator_spec_elixir/block_comments.x/account_flags.ex @@ -0,0 +1,57 @@ +defmodule MyXDR.AccountFlags do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `AccountFlags` type. + """ + + @behaviour XDR.Declaration + + @declarations [ + AUTH_REQUIRED_FLAG: 1 + ] + + @enum_spec %XDR.Enum{declarations: @declarations, identifier: nil} + + @type t :: %__MODULE__{identifier: atom()} + + defstruct [:identifier] + + @spec new(type :: atom()) :: t() + def new(type \\ :AUTH_REQUIRED_FLAG), do: %__MODULE__{identifier: type} + + @impl true + def encode_xdr(%__MODULE__{identifier: type}) do + @declarations + |> XDR.Enum.new(type) + |> XDR.Enum.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{identifier: type}) do + @declarations + |> XDR.Enum.new(type) + |> XDR.Enum.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, spec \\ @enum_spec) + + def decode_xdr(bytes, spec) do + case XDR.Enum.decode_xdr(bytes, spec) do + {:ok, {%XDR.Enum{identifier: type}, rest}} -> {:ok, {new(type), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @enum_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.Enum{identifier: type}, rest} = XDR.Enum.decode_xdr!(bytes, spec) + {new(type), rest} + end +end diff --git a/spec/output/generator_spec_elixir/block_comments.x/base.ex b/spec/output/generator_spec_elixir/block_comments.x/base.ex new file mode 100644 index 000000000..3164dc83e --- /dev/null +++ b/spec/output/generator_spec_elixir/block_comments.x/base.ex @@ -0,0 +1,439 @@ +defmodule MyXDR.Int do + @moduledoc """ + Representation of Stellar `Int` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: integer()} + + defstruct [:datum] + + @spec new(int :: integer()) :: t() + def new(int), do: %__MODULE__{datum: int} + + @impl true + def encode_xdr(%__MODULE__{datum: int}) do + XDR.Int.encode_xdr(%XDR.Int{datum: int}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: int}) do + XDR.Int.encode_xdr!(%XDR.Int{datum: int}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Int.decode_xdr(bytes) do + {:ok, {%XDR.Int{datum: int}, rest}} -> {:ok, {new(int), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Int{datum: int}, rest} = XDR.Int.decode_xdr!(bytes) + {new(int), rest} + end +end + +defmodule MyXDR.Uint do + @moduledoc """ + Representation of Stellar `Uint` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: non_neg_integer()} + + defstruct [:datum] + + @spec new(uint :: non_neg_integer()) :: t() + def new(uint), do: %__MODULE__{datum: uint} + + @impl true + def encode_xdr(%__MODULE__{datum: uint}) do + XDR.UInt.encode_xdr(%XDR.UInt{datum: uint}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: uint}) do + XDR.UInt.encode_xdr!(%XDR.UInt{datum: uint}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.UInt.decode_xdr(bytes) do + {:ok, {%XDR.UInt{datum: uint}, rest}} -> {:ok, {new(uint), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.UInt{datum: uint}, rest} = XDR.UInt.decode_xdr!(bytes) + {new(uint), rest} + end +end + +defmodule MyXDR.Float do + @moduledoc """ + Representation of Stellar `Float` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{float: float()} + + defstruct [:float] + + @spec new(float :: float()) :: t() + def new(float), do: %__MODULE__{float: float} + + @impl true + def encode_xdr(%__MODULE__{float: float}) do + XDR.Float.encode_xdr(%XDR.Float{float: float}) + end + + @impl true + def encode_xdr!(%__MODULE__{float: float}) do + XDR.Float.encode_xdr!(%XDR.Float{float: float}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Float.decode_xdr(bytes) do + {:ok, {%XDR.Float{float: float}, rest}} -> {:ok, {new(float), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Float{float: float}, rest} = XDR.Float.decode_xdr!(bytes) + {new(float), rest} + end +end + +defmodule MyXDR.DoubleFloat do + @moduledoc """ + Representation of Stellar `DoubleFloat` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{float: float()} + + defstruct [:float] + + @spec new(float :: float()) :: t() + def new(float), do: %__MODULE__{float: float} + + @impl true + def encode_xdr(%__MODULE__{float: float}) do + XDR.DoubleFloat.encode_xdr(%XDR.DoubleFloat{float: float}) + end + + @impl true + def encode_xdr!(%__MODULE__{float: float}) do + XDR.DoubleFloat.encode_xdr!(%XDR.DoubleFloat{float: float}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.DoubleFloat.decode_xdr(bytes) do + {:ok, {%XDR.DoubleFloat{float: float}, rest}} -> {:ok, {new(float), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.DoubleFloat{float: float}, rest} = XDR.DoubleFloat.decode_xdr!(bytes) + {new(float), rest} + end +end + +defmodule MyXDR.HyperUInt do + @moduledoc """ + Representation of Stellar `HyperUInt` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: non_neg_integer()} + + defstruct [:datum] + + @spec new(uint :: non_neg_integer()) :: t() + def new(uint), do: %__MODULE__{datum: uint} + + @impl true + def encode_xdr(%__MODULE__{datum: uint}) do + XDR.HyperUInt.encode_xdr(%XDR.HyperUInt{datum: uint}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: uint}) do + XDR.HyperUInt.encode_xdr!(%XDR.HyperUInt{datum: uint}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.HyperUInt.decode_xdr(bytes) do + {:ok, {%XDR.HyperUInt{datum: uint}, rest}} -> {:ok, {new(uint), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.HyperUInt{datum: uint}, rest} = XDR.HyperUInt.decode_xdr!(bytes) + {new(uint), rest} + end +end + +defmodule MyXDR.Bool do + @moduledoc """ + Representation of Stellar `Bool` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: boolean()} + + defstruct [:value] + + @spec new(value :: boolean()) :: t() + def new(val), do: %__MODULE__{value: val} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + XDR.Bool.encode_xdr(%XDR.Bool{identifier: value}) + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + XDR.Bool.encode_xdr!(%XDR.Bool{identifier: value}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Bool.decode_xdr(bytes) do + {:ok, {%XDR.Bool{identifier: val}, rest}} -> {:ok, {new(val), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Bool{identifier: val}, rest} = XDR.Bool.decode_xdr!(bytes) + {new(val), rest} + end +end + +defmodule MyXDR.String do + @moduledoc """ + Representation of Stellar `String` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: String.t()} + + defstruct [:value] + + @spec new(value :: String.t()) :: t() + def new(value), do: %__MODULE__{value: value} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + value + |> XDR.String.new() + |> XDR.String.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + value + |> XDR.String.new() + |> XDR.String.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.String.decode_xdr(bytes) do + {:ok, {%XDR.String{string: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.String{string: value}, rest} = XDR.String.decode_xdr!(bytes) + {new(value), rest} + end +end + +defmodule MyXDR.FixedOpaque do + @moduledoc """ + Representation of Stellar `FixedOpaque` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{opaque: binary()} + + defstruct [:opaque] + + @length 4_294_967_295 + + @opaque_spec XDR.FixedOpaque.new(nil, @length) + + @spec new(opaque :: binary()) :: t() + def new(opaque), do: %__MODULE__{opaque: opaque} + + @impl true + def encode_xdr(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def encode_xdr!(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr!(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def decode_xdr(bytes, spec \\ @opaque_spec) + + def decode_xdr(bytes, spec) do + case XDR.FixedOpaque.decode_xdr(bytes, spec) do + {:ok, {%XDR.FixedOpaque{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @opaque_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.FixedOpaque{opaque: opaque}, rest} = XDR.FixedOpaque.decode_xdr!(bytes, spec) + {new(opaque), rest} + end +end + +defmodule MyXDR.VariableOpaque do + @moduledoc """ + Representation of Stellar `VariableOpaque` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{opaque: binary()} + + defstruct [:opaque] + + @opaque_spec XDR.VariableOpaque.new(nil) + + @spec new(opaque :: binary()) :: t() + def new(opaque), do: %__MODULE__{opaque: opaque} + + @impl true + def encode_xdr(%__MODULE__{opaque: opaque}) do + XDR.VariableOpaque.encode_xdr(%XDR.VariableOpaque{opaque: opaque}) + end + + @impl true + def encode_xdr!(%__MODULE__{opaque: opaque}) do + XDR.VariableOpaque.encode_xdr!(%XDR.VariableOpaque{opaque: opaque}) + end + + @impl true + def decode_xdr(bytes, spec \\ @opaque_spec) + + def decode_xdr(bytes, spec) do + case XDR.VariableOpaque.decode_xdr(bytes, spec) do + {:ok, {%XDR.VariableOpaque{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @opaque_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.VariableOpaque{opaque: opaque}, rest} = XDR.VariableOpaque.decode_xdr!(bytes, spec) + {new(opaque), rest} + end +end + +defmodule MyXDR.Void do + @moduledoc """ + Representation of Stellar `Void` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: nil} + + defstruct [:value] + + @spec new(value :: nil) :: t() + def new(_val \\ nil), do: %__MODULE__{value: nil} + + @impl true + def encode_xdr(%__MODULE__{}) do + XDR.Void.encode_xdr(%XDR.Void{}) + end + + @impl true + def encode_xdr!(%__MODULE__{}) do + XDR.Void.encode_xdr!(%XDR.Void{}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Void.decode_xdr(bytes) do + {:ok, {nil, rest}} -> {:ok, {new(), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {nil, rest} = XDR.Void.decode_xdr!(bytes) + {new(), rest} + end +end diff --git a/spec/output/generator_spec_elixir/const.x/MyXDR_generated.ex b/spec/output/generator_spec_elixir/const.x/MyXDR_generated.ex deleted file mode 100644 index 191b6b68a..000000000 --- a/spec/output/generator_spec_elixir/const.x/MyXDR_generated.ex +++ /dev/null @@ -1,38 +0,0 @@ -defmodule MyXDR do - @moduledoc """ - Automatically generated by xdrgen - DO NOT EDIT or your changes may be overwritten - - Target implementation: exdr at https://hex.pm/packages/exdr - """ - - use XDR.Base - - comment ~S""" - === xdr source ============================================================ - - const FOO = 1; - - =========================================================================== - """ - define_type("FOO", Const, 1); - - comment ~S""" - === xdr source ============================================================ - - typedef int TestArray[FOO]; - - =========================================================================== - """ - define_type("TestArray", Array, length: "FOO", type: buid_type(base_ref)) - - comment ~S""" - === xdr source ============================================================ - - typedef int TestArray2; - - =========================================================================== - """ - define_type("TestArray2", VariableArray, max_length: "FOO", type: buid_type(base_ref)) - -end diff --git a/spec/output/generator_spec_elixir/const.x/base.ex b/spec/output/generator_spec_elixir/const.x/base.ex new file mode 100644 index 000000000..3164dc83e --- /dev/null +++ b/spec/output/generator_spec_elixir/const.x/base.ex @@ -0,0 +1,439 @@ +defmodule MyXDR.Int do + @moduledoc """ + Representation of Stellar `Int` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: integer()} + + defstruct [:datum] + + @spec new(int :: integer()) :: t() + def new(int), do: %__MODULE__{datum: int} + + @impl true + def encode_xdr(%__MODULE__{datum: int}) do + XDR.Int.encode_xdr(%XDR.Int{datum: int}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: int}) do + XDR.Int.encode_xdr!(%XDR.Int{datum: int}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Int.decode_xdr(bytes) do + {:ok, {%XDR.Int{datum: int}, rest}} -> {:ok, {new(int), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Int{datum: int}, rest} = XDR.Int.decode_xdr!(bytes) + {new(int), rest} + end +end + +defmodule MyXDR.Uint do + @moduledoc """ + Representation of Stellar `Uint` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: non_neg_integer()} + + defstruct [:datum] + + @spec new(uint :: non_neg_integer()) :: t() + def new(uint), do: %__MODULE__{datum: uint} + + @impl true + def encode_xdr(%__MODULE__{datum: uint}) do + XDR.UInt.encode_xdr(%XDR.UInt{datum: uint}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: uint}) do + XDR.UInt.encode_xdr!(%XDR.UInt{datum: uint}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.UInt.decode_xdr(bytes) do + {:ok, {%XDR.UInt{datum: uint}, rest}} -> {:ok, {new(uint), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.UInt{datum: uint}, rest} = XDR.UInt.decode_xdr!(bytes) + {new(uint), rest} + end +end + +defmodule MyXDR.Float do + @moduledoc """ + Representation of Stellar `Float` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{float: float()} + + defstruct [:float] + + @spec new(float :: float()) :: t() + def new(float), do: %__MODULE__{float: float} + + @impl true + def encode_xdr(%__MODULE__{float: float}) do + XDR.Float.encode_xdr(%XDR.Float{float: float}) + end + + @impl true + def encode_xdr!(%__MODULE__{float: float}) do + XDR.Float.encode_xdr!(%XDR.Float{float: float}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Float.decode_xdr(bytes) do + {:ok, {%XDR.Float{float: float}, rest}} -> {:ok, {new(float), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Float{float: float}, rest} = XDR.Float.decode_xdr!(bytes) + {new(float), rest} + end +end + +defmodule MyXDR.DoubleFloat do + @moduledoc """ + Representation of Stellar `DoubleFloat` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{float: float()} + + defstruct [:float] + + @spec new(float :: float()) :: t() + def new(float), do: %__MODULE__{float: float} + + @impl true + def encode_xdr(%__MODULE__{float: float}) do + XDR.DoubleFloat.encode_xdr(%XDR.DoubleFloat{float: float}) + end + + @impl true + def encode_xdr!(%__MODULE__{float: float}) do + XDR.DoubleFloat.encode_xdr!(%XDR.DoubleFloat{float: float}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.DoubleFloat.decode_xdr(bytes) do + {:ok, {%XDR.DoubleFloat{float: float}, rest}} -> {:ok, {new(float), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.DoubleFloat{float: float}, rest} = XDR.DoubleFloat.decode_xdr!(bytes) + {new(float), rest} + end +end + +defmodule MyXDR.HyperUInt do + @moduledoc """ + Representation of Stellar `HyperUInt` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: non_neg_integer()} + + defstruct [:datum] + + @spec new(uint :: non_neg_integer()) :: t() + def new(uint), do: %__MODULE__{datum: uint} + + @impl true + def encode_xdr(%__MODULE__{datum: uint}) do + XDR.HyperUInt.encode_xdr(%XDR.HyperUInt{datum: uint}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: uint}) do + XDR.HyperUInt.encode_xdr!(%XDR.HyperUInt{datum: uint}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.HyperUInt.decode_xdr(bytes) do + {:ok, {%XDR.HyperUInt{datum: uint}, rest}} -> {:ok, {new(uint), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.HyperUInt{datum: uint}, rest} = XDR.HyperUInt.decode_xdr!(bytes) + {new(uint), rest} + end +end + +defmodule MyXDR.Bool do + @moduledoc """ + Representation of Stellar `Bool` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: boolean()} + + defstruct [:value] + + @spec new(value :: boolean()) :: t() + def new(val), do: %__MODULE__{value: val} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + XDR.Bool.encode_xdr(%XDR.Bool{identifier: value}) + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + XDR.Bool.encode_xdr!(%XDR.Bool{identifier: value}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Bool.decode_xdr(bytes) do + {:ok, {%XDR.Bool{identifier: val}, rest}} -> {:ok, {new(val), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Bool{identifier: val}, rest} = XDR.Bool.decode_xdr!(bytes) + {new(val), rest} + end +end + +defmodule MyXDR.String do + @moduledoc """ + Representation of Stellar `String` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: String.t()} + + defstruct [:value] + + @spec new(value :: String.t()) :: t() + def new(value), do: %__MODULE__{value: value} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + value + |> XDR.String.new() + |> XDR.String.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + value + |> XDR.String.new() + |> XDR.String.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.String.decode_xdr(bytes) do + {:ok, {%XDR.String{string: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.String{string: value}, rest} = XDR.String.decode_xdr!(bytes) + {new(value), rest} + end +end + +defmodule MyXDR.FixedOpaque do + @moduledoc """ + Representation of Stellar `FixedOpaque` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{opaque: binary()} + + defstruct [:opaque] + + @length 4_294_967_295 + + @opaque_spec XDR.FixedOpaque.new(nil, @length) + + @spec new(opaque :: binary()) :: t() + def new(opaque), do: %__MODULE__{opaque: opaque} + + @impl true + def encode_xdr(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def encode_xdr!(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr!(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def decode_xdr(bytes, spec \\ @opaque_spec) + + def decode_xdr(bytes, spec) do + case XDR.FixedOpaque.decode_xdr(bytes, spec) do + {:ok, {%XDR.FixedOpaque{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @opaque_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.FixedOpaque{opaque: opaque}, rest} = XDR.FixedOpaque.decode_xdr!(bytes, spec) + {new(opaque), rest} + end +end + +defmodule MyXDR.VariableOpaque do + @moduledoc """ + Representation of Stellar `VariableOpaque` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{opaque: binary()} + + defstruct [:opaque] + + @opaque_spec XDR.VariableOpaque.new(nil) + + @spec new(opaque :: binary()) :: t() + def new(opaque), do: %__MODULE__{opaque: opaque} + + @impl true + def encode_xdr(%__MODULE__{opaque: opaque}) do + XDR.VariableOpaque.encode_xdr(%XDR.VariableOpaque{opaque: opaque}) + end + + @impl true + def encode_xdr!(%__MODULE__{opaque: opaque}) do + XDR.VariableOpaque.encode_xdr!(%XDR.VariableOpaque{opaque: opaque}) + end + + @impl true + def decode_xdr(bytes, spec \\ @opaque_spec) + + def decode_xdr(bytes, spec) do + case XDR.VariableOpaque.decode_xdr(bytes, spec) do + {:ok, {%XDR.VariableOpaque{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @opaque_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.VariableOpaque{opaque: opaque}, rest} = XDR.VariableOpaque.decode_xdr!(bytes, spec) + {new(opaque), rest} + end +end + +defmodule MyXDR.Void do + @moduledoc """ + Representation of Stellar `Void` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: nil} + + defstruct [:value] + + @spec new(value :: nil) :: t() + def new(_val \\ nil), do: %__MODULE__{value: nil} + + @impl true + def encode_xdr(%__MODULE__{}) do + XDR.Void.encode_xdr(%XDR.Void{}) + end + + @impl true + def encode_xdr!(%__MODULE__{}) do + XDR.Void.encode_xdr!(%XDR.Void{}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Void.decode_xdr(bytes) do + {:ok, {nil, rest}} -> {:ok, {new(), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {nil, rest} = XDR.Void.decode_xdr!(bytes) + {new(), rest} + end +end diff --git a/spec/output/generator_spec_elixir/const.x/test_array.ex b/spec/output/generator_spec_elixir/const.x/test_array.ex new file mode 100644 index 000000000..432037bf3 --- /dev/null +++ b/spec/output/generator_spec_elixir/const.x/test_array.ex @@ -0,0 +1,59 @@ +defmodule MyXDR.TestArray do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `TestArray` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.Int + + @length 1 + + @array_type Int + + @array_spec %{type: @array_type, length: @length} + + @type t :: %__MODULE__{items: list(Int.t())} + + defstruct [:items] + + @spec new(items :: list(Int.t())) :: t() + def new(items), do: %__MODULE__{items: items} + + @impl true + def encode_xdr(%__MODULE__{items: items}) do + items + |> XDR.FixedArray.new(@array_type, @length) + |> XDR.FixedArray.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{items: items}) do + items + |> XDR.FixedArray.new(@array_type, @length) + |> XDR.FixedArray.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, spec \\ @array_spec) + + def decode_xdr(bytes, spec) do + case XDR.FixedArray.decode_xdr(bytes, spec) do + {:ok, {items, rest}} -> {:ok, {new(items), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @array_spec) + + def decode_xdr!(bytes, spec) do + {items, rest} = XDR.FixedArray.decode_xdr!(bytes, spec) + {new(items), rest} + end +end diff --git a/spec/output/generator_spec_elixir/const.x/test_array2.ex b/spec/output/generator_spec_elixir/const.x/test_array2.ex new file mode 100644 index 000000000..350d7c193 --- /dev/null +++ b/spec/output/generator_spec_elixir/const.x/test_array2.ex @@ -0,0 +1,59 @@ +defmodule MyXDR.TestArray2 do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `TestArray2` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.Int + + @max_length 1 + + @array_type Int + + @array_spec %{type: @array_type, max_length: @max_length} + + @type t :: %__MODULE__{items: list(Int.t())} + + defstruct [:items] + + @spec new(items :: list(Int.t())) :: t() + def new(items), do: %__MODULE__{items: items} + + @impl true + def encode_xdr(%__MODULE__{items: items}) do + items + |> XDR.VariableArray.new(@array_type, @max_length) + |> XDR.VariableArray.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{items: items}) do + items + |> XDR.VariableArray.new(@array_type, @max_length) + |> XDR.VariableArray.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, spec \\ @array_spec) + + def decode_xdr(bytes, spec) do + case XDR.VariableArray.decode_xdr(bytes, spec) do + {:ok, {items, rest}} -> {:ok, {new(items), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @array_spec) + + def decode_xdr!(bytes, spec) do + {items, rest} = XDR.VariableArray.decode_xdr!(bytes, spec) + {new(items), rest} + end +end diff --git a/spec/output/generator_spec_elixir/enum.x/MyXDR_generated.ex b/spec/output/generator_spec_elixir/enum.x/MyXDR_generated.ex deleted file mode 100644 index 85a9b236b..000000000 --- a/spec/output/generator_spec_elixir/enum.x/MyXDR_generated.ex +++ /dev/null @@ -1,91 +0,0 @@ -defmodule MyXDR do - @moduledoc """ - Automatically generated by xdrgen - DO NOT EDIT or your changes may be overwritten - - Target implementation: exdr at https://hex.pm/packages/exdr - """ - - use XDR.Base - - comment ~S""" - === xdr source ============================================================ - - enum MessageType - { - ERROR_MSG, - HELLO, - DONT_HAVE, - - GET_PEERS, // gets a list of peers this guy knows about - PEERS, - - GET_TX_SET, // gets a particular txset by hash - TX_SET, - - GET_VALIDATIONS, // gets validations for a given ledger hash - VALIDATIONS, - - TRANSACTION, //pass on a tx you have heard about - JSON_TRANSACTION, - - // FBA - GET_FBA_QUORUMSET, - FBA_QUORUMSET, - FBA_MESSAGE - }; - - =========================================================================== - """ - define_type("MessageType", Enum, - error_msg: 0, - hello: 1, - dont_have: 2, - get_peers: 3, - peers: 4, - get_tx_set: 5, - tx_set: 6, - get_validations: 7, - validations: 8, - transaction: 9, - json_transaction: 10, - get_fba_quorumset: 11, - fba_quorumset: 12, - fba_message: 13 - ) - - comment ~S""" - === xdr source ============================================================ - - enum Color { - RED=0, - GREEN=1, - BLUE=2 - }; - - =========================================================================== - """ - define_type("Color", Enum, - red: 0, - green: 1, - blue: 2 - ) - - comment ~S""" - === xdr source ============================================================ - - enum Color2 { - RED2=RED, - GREEN2=1, - BLUE2=2 - }; - - =========================================================================== - """ - define_type("Color2", Enum, - red2: 0, - green2: 1, - blue2: 2 - ) - -end diff --git a/spec/output/generator_spec_elixir/enum.x/base.ex b/spec/output/generator_spec_elixir/enum.x/base.ex new file mode 100644 index 000000000..3164dc83e --- /dev/null +++ b/spec/output/generator_spec_elixir/enum.x/base.ex @@ -0,0 +1,439 @@ +defmodule MyXDR.Int do + @moduledoc """ + Representation of Stellar `Int` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: integer()} + + defstruct [:datum] + + @spec new(int :: integer()) :: t() + def new(int), do: %__MODULE__{datum: int} + + @impl true + def encode_xdr(%__MODULE__{datum: int}) do + XDR.Int.encode_xdr(%XDR.Int{datum: int}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: int}) do + XDR.Int.encode_xdr!(%XDR.Int{datum: int}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Int.decode_xdr(bytes) do + {:ok, {%XDR.Int{datum: int}, rest}} -> {:ok, {new(int), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Int{datum: int}, rest} = XDR.Int.decode_xdr!(bytes) + {new(int), rest} + end +end + +defmodule MyXDR.Uint do + @moduledoc """ + Representation of Stellar `Uint` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: non_neg_integer()} + + defstruct [:datum] + + @spec new(uint :: non_neg_integer()) :: t() + def new(uint), do: %__MODULE__{datum: uint} + + @impl true + def encode_xdr(%__MODULE__{datum: uint}) do + XDR.UInt.encode_xdr(%XDR.UInt{datum: uint}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: uint}) do + XDR.UInt.encode_xdr!(%XDR.UInt{datum: uint}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.UInt.decode_xdr(bytes) do + {:ok, {%XDR.UInt{datum: uint}, rest}} -> {:ok, {new(uint), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.UInt{datum: uint}, rest} = XDR.UInt.decode_xdr!(bytes) + {new(uint), rest} + end +end + +defmodule MyXDR.Float do + @moduledoc """ + Representation of Stellar `Float` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{float: float()} + + defstruct [:float] + + @spec new(float :: float()) :: t() + def new(float), do: %__MODULE__{float: float} + + @impl true + def encode_xdr(%__MODULE__{float: float}) do + XDR.Float.encode_xdr(%XDR.Float{float: float}) + end + + @impl true + def encode_xdr!(%__MODULE__{float: float}) do + XDR.Float.encode_xdr!(%XDR.Float{float: float}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Float.decode_xdr(bytes) do + {:ok, {%XDR.Float{float: float}, rest}} -> {:ok, {new(float), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Float{float: float}, rest} = XDR.Float.decode_xdr!(bytes) + {new(float), rest} + end +end + +defmodule MyXDR.DoubleFloat do + @moduledoc """ + Representation of Stellar `DoubleFloat` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{float: float()} + + defstruct [:float] + + @spec new(float :: float()) :: t() + def new(float), do: %__MODULE__{float: float} + + @impl true + def encode_xdr(%__MODULE__{float: float}) do + XDR.DoubleFloat.encode_xdr(%XDR.DoubleFloat{float: float}) + end + + @impl true + def encode_xdr!(%__MODULE__{float: float}) do + XDR.DoubleFloat.encode_xdr!(%XDR.DoubleFloat{float: float}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.DoubleFloat.decode_xdr(bytes) do + {:ok, {%XDR.DoubleFloat{float: float}, rest}} -> {:ok, {new(float), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.DoubleFloat{float: float}, rest} = XDR.DoubleFloat.decode_xdr!(bytes) + {new(float), rest} + end +end + +defmodule MyXDR.HyperUInt do + @moduledoc """ + Representation of Stellar `HyperUInt` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: non_neg_integer()} + + defstruct [:datum] + + @spec new(uint :: non_neg_integer()) :: t() + def new(uint), do: %__MODULE__{datum: uint} + + @impl true + def encode_xdr(%__MODULE__{datum: uint}) do + XDR.HyperUInt.encode_xdr(%XDR.HyperUInt{datum: uint}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: uint}) do + XDR.HyperUInt.encode_xdr!(%XDR.HyperUInt{datum: uint}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.HyperUInt.decode_xdr(bytes) do + {:ok, {%XDR.HyperUInt{datum: uint}, rest}} -> {:ok, {new(uint), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.HyperUInt{datum: uint}, rest} = XDR.HyperUInt.decode_xdr!(bytes) + {new(uint), rest} + end +end + +defmodule MyXDR.Bool do + @moduledoc """ + Representation of Stellar `Bool` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: boolean()} + + defstruct [:value] + + @spec new(value :: boolean()) :: t() + def new(val), do: %__MODULE__{value: val} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + XDR.Bool.encode_xdr(%XDR.Bool{identifier: value}) + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + XDR.Bool.encode_xdr!(%XDR.Bool{identifier: value}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Bool.decode_xdr(bytes) do + {:ok, {%XDR.Bool{identifier: val}, rest}} -> {:ok, {new(val), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Bool{identifier: val}, rest} = XDR.Bool.decode_xdr!(bytes) + {new(val), rest} + end +end + +defmodule MyXDR.String do + @moduledoc """ + Representation of Stellar `String` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: String.t()} + + defstruct [:value] + + @spec new(value :: String.t()) :: t() + def new(value), do: %__MODULE__{value: value} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + value + |> XDR.String.new() + |> XDR.String.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + value + |> XDR.String.new() + |> XDR.String.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.String.decode_xdr(bytes) do + {:ok, {%XDR.String{string: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.String{string: value}, rest} = XDR.String.decode_xdr!(bytes) + {new(value), rest} + end +end + +defmodule MyXDR.FixedOpaque do + @moduledoc """ + Representation of Stellar `FixedOpaque` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{opaque: binary()} + + defstruct [:opaque] + + @length 4_294_967_295 + + @opaque_spec XDR.FixedOpaque.new(nil, @length) + + @spec new(opaque :: binary()) :: t() + def new(opaque), do: %__MODULE__{opaque: opaque} + + @impl true + def encode_xdr(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def encode_xdr!(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr!(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def decode_xdr(bytes, spec \\ @opaque_spec) + + def decode_xdr(bytes, spec) do + case XDR.FixedOpaque.decode_xdr(bytes, spec) do + {:ok, {%XDR.FixedOpaque{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @opaque_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.FixedOpaque{opaque: opaque}, rest} = XDR.FixedOpaque.decode_xdr!(bytes, spec) + {new(opaque), rest} + end +end + +defmodule MyXDR.VariableOpaque do + @moduledoc """ + Representation of Stellar `VariableOpaque` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{opaque: binary()} + + defstruct [:opaque] + + @opaque_spec XDR.VariableOpaque.new(nil) + + @spec new(opaque :: binary()) :: t() + def new(opaque), do: %__MODULE__{opaque: opaque} + + @impl true + def encode_xdr(%__MODULE__{opaque: opaque}) do + XDR.VariableOpaque.encode_xdr(%XDR.VariableOpaque{opaque: opaque}) + end + + @impl true + def encode_xdr!(%__MODULE__{opaque: opaque}) do + XDR.VariableOpaque.encode_xdr!(%XDR.VariableOpaque{opaque: opaque}) + end + + @impl true + def decode_xdr(bytes, spec \\ @opaque_spec) + + def decode_xdr(bytes, spec) do + case XDR.VariableOpaque.decode_xdr(bytes, spec) do + {:ok, {%XDR.VariableOpaque{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @opaque_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.VariableOpaque{opaque: opaque}, rest} = XDR.VariableOpaque.decode_xdr!(bytes, spec) + {new(opaque), rest} + end +end + +defmodule MyXDR.Void do + @moduledoc """ + Representation of Stellar `Void` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: nil} + + defstruct [:value] + + @spec new(value :: nil) :: t() + def new(_val \\ nil), do: %__MODULE__{value: nil} + + @impl true + def encode_xdr(%__MODULE__{}) do + XDR.Void.encode_xdr(%XDR.Void{}) + end + + @impl true + def encode_xdr!(%__MODULE__{}) do + XDR.Void.encode_xdr!(%XDR.Void{}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Void.decode_xdr(bytes) do + {:ok, {nil, rest}} -> {:ok, {new(), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {nil, rest} = XDR.Void.decode_xdr!(bytes) + {new(), rest} + end +end diff --git a/spec/output/generator_spec_elixir/enum.x/color.ex b/spec/output/generator_spec_elixir/enum.x/color.ex new file mode 100644 index 000000000..b35e175e1 --- /dev/null +++ b/spec/output/generator_spec_elixir/enum.x/color.ex @@ -0,0 +1,59 @@ +defmodule MyXDR.Color do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Color` type. + """ + + @behaviour XDR.Declaration + + @declarations [ + RED: 0, + GREEN: 1, + BLUE: 2 + ] + + @enum_spec %XDR.Enum{declarations: @declarations, identifier: nil} + + @type t :: %__MODULE__{identifier: atom()} + + defstruct [:identifier] + + @spec new(type :: atom()) :: t() + def new(type \\ :RED), do: %__MODULE__{identifier: type} + + @impl true + def encode_xdr(%__MODULE__{identifier: type}) do + @declarations + |> XDR.Enum.new(type) + |> XDR.Enum.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{identifier: type}) do + @declarations + |> XDR.Enum.new(type) + |> XDR.Enum.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, spec \\ @enum_spec) + + def decode_xdr(bytes, spec) do + case XDR.Enum.decode_xdr(bytes, spec) do + {:ok, {%XDR.Enum{identifier: type}, rest}} -> {:ok, {new(type), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @enum_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.Enum{identifier: type}, rest} = XDR.Enum.decode_xdr!(bytes, spec) + {new(type), rest} + end +end diff --git a/spec/output/generator_spec_elixir/enum.x/color2.ex b/spec/output/generator_spec_elixir/enum.x/color2.ex new file mode 100644 index 000000000..fbd0dd685 --- /dev/null +++ b/spec/output/generator_spec_elixir/enum.x/color2.ex @@ -0,0 +1,59 @@ +defmodule MyXDR.Color2 do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Color2` type. + """ + + @behaviour XDR.Declaration + + @declarations [ + RED2: 0, + GREEN2: 1, + BLUE2: 2 + ] + + @enum_spec %XDR.Enum{declarations: @declarations, identifier: nil} + + @type t :: %__MODULE__{identifier: atom()} + + defstruct [:identifier] + + @spec new(type :: atom()) :: t() + def new(type \\ :RED2), do: %__MODULE__{identifier: type} + + @impl true + def encode_xdr(%__MODULE__{identifier: type}) do + @declarations + |> XDR.Enum.new(type) + |> XDR.Enum.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{identifier: type}) do + @declarations + |> XDR.Enum.new(type) + |> XDR.Enum.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, spec \\ @enum_spec) + + def decode_xdr(bytes, spec) do + case XDR.Enum.decode_xdr(bytes, spec) do + {:ok, {%XDR.Enum{identifier: type}, rest}} -> {:ok, {new(type), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @enum_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.Enum{identifier: type}, rest} = XDR.Enum.decode_xdr!(bytes, spec) + {new(type), rest} + end +end diff --git a/spec/output/generator_spec_elixir/enum.x/message_type.ex b/spec/output/generator_spec_elixir/enum.x/message_type.ex new file mode 100644 index 000000000..5b7f126e3 --- /dev/null +++ b/spec/output/generator_spec_elixir/enum.x/message_type.ex @@ -0,0 +1,70 @@ +defmodule MyXDR.MessageType do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `MessageType` type. + """ + + @behaviour XDR.Declaration + + @declarations [ + ERROR_MSG: 0, + HELLO: 1, + DONT_HAVE: 2, + GET_PEERS: 3, + PEERS: 4, + GET_TX_SET: 5, + TX_SET: 6, + GET_VALIDATIONS: 7, + VALIDATIONS: 8, + TRANSACTION: 9, + JSON_TRANSACTION: 10, + GET_FBA_QUORUMSET: 11, + FBA_QUORUMSET: 12, + FBA_MESSAGE: 13 + ] + + @enum_spec %XDR.Enum{declarations: @declarations, identifier: nil} + + @type t :: %__MODULE__{identifier: atom()} + + defstruct [:identifier] + + @spec new(type :: atom()) :: t() + def new(type \\ :ERROR_MSG), do: %__MODULE__{identifier: type} + + @impl true + def encode_xdr(%__MODULE__{identifier: type}) do + @declarations + |> XDR.Enum.new(type) + |> XDR.Enum.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{identifier: type}) do + @declarations + |> XDR.Enum.new(type) + |> XDR.Enum.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, spec \\ @enum_spec) + + def decode_xdr(bytes, spec) do + case XDR.Enum.decode_xdr(bytes, spec) do + {:ok, {%XDR.Enum{identifier: type}, rest}} -> {:ok, {new(type), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @enum_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.Enum{identifier: type}, rest} = XDR.Enum.decode_xdr!(bytes, spec) + {new(type), rest} + end +end diff --git a/spec/output/generator_spec_elixir/nesting.x/MyXDR_generated.ex b/spec/output/generator_spec_elixir/nesting.x/MyXDR_generated.ex deleted file mode 100644 index 665fd7dfa..000000000 --- a/spec/output/generator_spec_elixir/nesting.x/MyXDR_generated.ex +++ /dev/null @@ -1,101 +0,0 @@ -defmodule MyXDR do - @moduledoc """ - Automatically generated by xdrgen - DO NOT EDIT or your changes may be overwritten - - Target implementation: exdr at https://hex.pm/packages/exdr - """ - - use XDR.Base - - comment ~S""" - === xdr source ============================================================ - - enum UnionKey { - ONE = 1, - TWO = 2, - OFFER = 3 - }; - - =========================================================================== - """ - define_type("UnionKey", Enum, - one: 1, - two: 2, - offer: 3 - ) - - comment ~S""" - === xdr source ============================================================ - - typedef int Foo; - - =========================================================================== - """ - define_type("Foo", Int) - - comment ~S""" - === xdr source ============================================================ - - struct { - int someInt; - } - - =========================================================================== - """ - define_type("MyUnionOne", Struct, - some_int: build_type(Int) - ) - - comment ~S""" - === xdr source ============================================================ - - struct { - int someInt; - Foo foo; - } - - =========================================================================== - """ - define_type("MyUnionTwo", Struct, - some_int: build_type(Int), - foo: "Foo" - ) - - comment ~S""" - === xdr source ============================================================ - - union MyUnion switch (UnionKey type) - { - case ONE: - struct { - int someInt; - } one; - - case TWO: - struct { - int someInt; - Foo foo; - } two; - - case OFFER: - void; - }; - - =========================================================================== - """ - define_type("MyUnion", Union, - switch_type: "UnionKey", - switch_name: :type, - switches: [ - {:one, :one}, - {:two, :two}, - {:offer, XDR.Type.Void}, - ], - arms: [ - one: "MyUnionOne", - two: "MyUnionTwo", - ] - ) - -end diff --git a/spec/output/generator_spec_elixir/nesting.x/base.ex b/spec/output/generator_spec_elixir/nesting.x/base.ex new file mode 100644 index 000000000..3164dc83e --- /dev/null +++ b/spec/output/generator_spec_elixir/nesting.x/base.ex @@ -0,0 +1,439 @@ +defmodule MyXDR.Int do + @moduledoc """ + Representation of Stellar `Int` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: integer()} + + defstruct [:datum] + + @spec new(int :: integer()) :: t() + def new(int), do: %__MODULE__{datum: int} + + @impl true + def encode_xdr(%__MODULE__{datum: int}) do + XDR.Int.encode_xdr(%XDR.Int{datum: int}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: int}) do + XDR.Int.encode_xdr!(%XDR.Int{datum: int}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Int.decode_xdr(bytes) do + {:ok, {%XDR.Int{datum: int}, rest}} -> {:ok, {new(int), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Int{datum: int}, rest} = XDR.Int.decode_xdr!(bytes) + {new(int), rest} + end +end + +defmodule MyXDR.Uint do + @moduledoc """ + Representation of Stellar `Uint` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: non_neg_integer()} + + defstruct [:datum] + + @spec new(uint :: non_neg_integer()) :: t() + def new(uint), do: %__MODULE__{datum: uint} + + @impl true + def encode_xdr(%__MODULE__{datum: uint}) do + XDR.UInt.encode_xdr(%XDR.UInt{datum: uint}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: uint}) do + XDR.UInt.encode_xdr!(%XDR.UInt{datum: uint}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.UInt.decode_xdr(bytes) do + {:ok, {%XDR.UInt{datum: uint}, rest}} -> {:ok, {new(uint), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.UInt{datum: uint}, rest} = XDR.UInt.decode_xdr!(bytes) + {new(uint), rest} + end +end + +defmodule MyXDR.Float do + @moduledoc """ + Representation of Stellar `Float` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{float: float()} + + defstruct [:float] + + @spec new(float :: float()) :: t() + def new(float), do: %__MODULE__{float: float} + + @impl true + def encode_xdr(%__MODULE__{float: float}) do + XDR.Float.encode_xdr(%XDR.Float{float: float}) + end + + @impl true + def encode_xdr!(%__MODULE__{float: float}) do + XDR.Float.encode_xdr!(%XDR.Float{float: float}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Float.decode_xdr(bytes) do + {:ok, {%XDR.Float{float: float}, rest}} -> {:ok, {new(float), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Float{float: float}, rest} = XDR.Float.decode_xdr!(bytes) + {new(float), rest} + end +end + +defmodule MyXDR.DoubleFloat do + @moduledoc """ + Representation of Stellar `DoubleFloat` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{float: float()} + + defstruct [:float] + + @spec new(float :: float()) :: t() + def new(float), do: %__MODULE__{float: float} + + @impl true + def encode_xdr(%__MODULE__{float: float}) do + XDR.DoubleFloat.encode_xdr(%XDR.DoubleFloat{float: float}) + end + + @impl true + def encode_xdr!(%__MODULE__{float: float}) do + XDR.DoubleFloat.encode_xdr!(%XDR.DoubleFloat{float: float}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.DoubleFloat.decode_xdr(bytes) do + {:ok, {%XDR.DoubleFloat{float: float}, rest}} -> {:ok, {new(float), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.DoubleFloat{float: float}, rest} = XDR.DoubleFloat.decode_xdr!(bytes) + {new(float), rest} + end +end + +defmodule MyXDR.HyperUInt do + @moduledoc """ + Representation of Stellar `HyperUInt` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: non_neg_integer()} + + defstruct [:datum] + + @spec new(uint :: non_neg_integer()) :: t() + def new(uint), do: %__MODULE__{datum: uint} + + @impl true + def encode_xdr(%__MODULE__{datum: uint}) do + XDR.HyperUInt.encode_xdr(%XDR.HyperUInt{datum: uint}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: uint}) do + XDR.HyperUInt.encode_xdr!(%XDR.HyperUInt{datum: uint}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.HyperUInt.decode_xdr(bytes) do + {:ok, {%XDR.HyperUInt{datum: uint}, rest}} -> {:ok, {new(uint), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.HyperUInt{datum: uint}, rest} = XDR.HyperUInt.decode_xdr!(bytes) + {new(uint), rest} + end +end + +defmodule MyXDR.Bool do + @moduledoc """ + Representation of Stellar `Bool` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: boolean()} + + defstruct [:value] + + @spec new(value :: boolean()) :: t() + def new(val), do: %__MODULE__{value: val} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + XDR.Bool.encode_xdr(%XDR.Bool{identifier: value}) + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + XDR.Bool.encode_xdr!(%XDR.Bool{identifier: value}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Bool.decode_xdr(bytes) do + {:ok, {%XDR.Bool{identifier: val}, rest}} -> {:ok, {new(val), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Bool{identifier: val}, rest} = XDR.Bool.decode_xdr!(bytes) + {new(val), rest} + end +end + +defmodule MyXDR.String do + @moduledoc """ + Representation of Stellar `String` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: String.t()} + + defstruct [:value] + + @spec new(value :: String.t()) :: t() + def new(value), do: %__MODULE__{value: value} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + value + |> XDR.String.new() + |> XDR.String.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + value + |> XDR.String.new() + |> XDR.String.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.String.decode_xdr(bytes) do + {:ok, {%XDR.String{string: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.String{string: value}, rest} = XDR.String.decode_xdr!(bytes) + {new(value), rest} + end +end + +defmodule MyXDR.FixedOpaque do + @moduledoc """ + Representation of Stellar `FixedOpaque` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{opaque: binary()} + + defstruct [:opaque] + + @length 4_294_967_295 + + @opaque_spec XDR.FixedOpaque.new(nil, @length) + + @spec new(opaque :: binary()) :: t() + def new(opaque), do: %__MODULE__{opaque: opaque} + + @impl true + def encode_xdr(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def encode_xdr!(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr!(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def decode_xdr(bytes, spec \\ @opaque_spec) + + def decode_xdr(bytes, spec) do + case XDR.FixedOpaque.decode_xdr(bytes, spec) do + {:ok, {%XDR.FixedOpaque{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @opaque_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.FixedOpaque{opaque: opaque}, rest} = XDR.FixedOpaque.decode_xdr!(bytes, spec) + {new(opaque), rest} + end +end + +defmodule MyXDR.VariableOpaque do + @moduledoc """ + Representation of Stellar `VariableOpaque` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{opaque: binary()} + + defstruct [:opaque] + + @opaque_spec XDR.VariableOpaque.new(nil) + + @spec new(opaque :: binary()) :: t() + def new(opaque), do: %__MODULE__{opaque: opaque} + + @impl true + def encode_xdr(%__MODULE__{opaque: opaque}) do + XDR.VariableOpaque.encode_xdr(%XDR.VariableOpaque{opaque: opaque}) + end + + @impl true + def encode_xdr!(%__MODULE__{opaque: opaque}) do + XDR.VariableOpaque.encode_xdr!(%XDR.VariableOpaque{opaque: opaque}) + end + + @impl true + def decode_xdr(bytes, spec \\ @opaque_spec) + + def decode_xdr(bytes, spec) do + case XDR.VariableOpaque.decode_xdr(bytes, spec) do + {:ok, {%XDR.VariableOpaque{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @opaque_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.VariableOpaque{opaque: opaque}, rest} = XDR.VariableOpaque.decode_xdr!(bytes, spec) + {new(opaque), rest} + end +end + +defmodule MyXDR.Void do + @moduledoc """ + Representation of Stellar `Void` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: nil} + + defstruct [:value] + + @spec new(value :: nil) :: t() + def new(_val \\ nil), do: %__MODULE__{value: nil} + + @impl true + def encode_xdr(%__MODULE__{}) do + XDR.Void.encode_xdr(%XDR.Void{}) + end + + @impl true + def encode_xdr!(%__MODULE__{}) do + XDR.Void.encode_xdr!(%XDR.Void{}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Void.decode_xdr(bytes) do + {:ok, {nil, rest}} -> {:ok, {new(), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {nil, rest} = XDR.Void.decode_xdr!(bytes) + {new(), rest} + end +end diff --git a/spec/output/generator_spec_elixir/nesting.x/foo.ex b/spec/output/generator_spec_elixir/nesting.x/foo.ex new file mode 100644 index 000000000..25c851c97 --- /dev/null +++ b/spec/output/generator_spec_elixir/nesting.x/foo.ex @@ -0,0 +1,47 @@ +defmodule MyXDR.Foo do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Foo` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: integer()} + + defstruct [:datum] + + @spec new(value :: integer()) :: t() + def new(value), do: %__MODULE__{datum: value} + + @impl true + def encode_xdr(%__MODULE__{datum: value}) do + XDR.Int.encode_xdr(%XDR.Int{datum: value}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: value}) do + XDR.Int.encode_xdr!(%XDR.Int{datum: value}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Int.decode_xdr(bytes) do + {:ok, {%XDR.Int{datum: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Int{datum: value}, rest} = XDR.Int.decode_xdr!(bytes) + {new(value), rest} + end +end diff --git a/spec/output/generator_spec_elixir/nesting.x/my_union.ex b/spec/output/generator_spec_elixir/nesting.x/my_union.ex new file mode 100644 index 000000000..4b0d4e393 --- /dev/null +++ b/spec/output/generator_spec_elixir/nesting.x/my_union.ex @@ -0,0 +1,76 @@ +defmodule MyXDR.MyUnion do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `MyUnion` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.{ + UnionKey, + MyUnionOne, + MyUnionTwo, + Void + } + + @arms [ + ONE: MyUnionOne, + TWO: MyUnionTwo, + OFFER: Void + ] + + @type value :: + MyUnionOne.t() + | MyUnionTwo.t() + | Void.t() + + @type t :: %__MODULE__{value: value(), type: UnionKey.t()} + + defstruct [:value, :type] + + @spec new(value :: value(), type :: UnionKey.t()) :: t() + def new(value, %UnionKey{} = type), do: %__MODULE__{value: value, type: type} + + @impl true + def encode_xdr(%__MODULE__{value: value, type: type}) do + type + |> XDR.Union.new(@arms, value) + |> XDR.Union.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{value: value, type: type}) do + type + |> XDR.Union.new(@arms, value) + |> XDR.Union.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, spec \\ union_spec()) + + def decode_xdr(bytes, spec) do + case XDR.Union.decode_xdr(bytes, spec) do + {:ok, {{type, value}, rest}} -> {:ok, {new(value, type), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ union_spec()) + + def decode_xdr!(bytes, spec) do + {{type, value}, rest} = XDR.Union.decode_xdr!(bytes, spec) + {new(value, type), rest} + end + + @spec union_spec() :: XDR.Union.t() + defp union_spec do + nil + |> UnionKey.new() + |> XDR.Union.new(@arms) + end +end diff --git a/spec/output/generator_spec_elixir/nesting.x/my_union_one.ex b/spec/output/generator_spec_elixir/nesting.x/my_union_one.ex new file mode 100644 index 000000000..74c987ffb --- /dev/null +++ b/spec/output/generator_spec_elixir/nesting.x/my_union_one.ex @@ -0,0 +1,66 @@ +defmodule MyXDR.MyUnionOne do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `MyUnionOne` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.{ + Int + } + + @struct_spec XDR.Struct.new( + some_int: Int + ) + + @type some_int_type :: Int.t() + + @type t :: %__MODULE__{some_int: some_int_type()} + + defstruct [:some_int] + + @spec new(some_int :: some_int_type()) :: t() + def new( + %Int{} = some_int + ), + do: %__MODULE__{some_int: some_int} + + @impl true + def encode_xdr(%__MODULE__{some_int: some_int}) do + [some_int: some_int] + |> XDR.Struct.new() + |> XDR.Struct.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{some_int: some_int}) do + [some_int: some_int] + |> XDR.Struct.new() + |> XDR.Struct.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, struct \\ @struct_spec) + + def decode_xdr(bytes, struct) do + case XDR.Struct.decode_xdr(bytes, struct) do + {:ok, {%XDR.Struct{components: [some_int: some_int]}, rest}} -> + {:ok, {new(some_int), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, struct \\ @struct_spec) + + def decode_xdr!(bytes, struct) do + {%XDR.Struct{components: [some_int: some_int]}, rest} = + XDR.Struct.decode_xdr!(bytes, struct) + {new(some_int), rest} + end +end diff --git a/spec/output/generator_spec_elixir/nesting.x/my_union_two.ex b/spec/output/generator_spec_elixir/nesting.x/my_union_two.ex new file mode 100644 index 000000000..bad1ea7ea --- /dev/null +++ b/spec/output/generator_spec_elixir/nesting.x/my_union_two.ex @@ -0,0 +1,70 @@ +defmodule MyXDR.MyUnionTwo do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `MyUnionTwo` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.{ + Int, + Foo + } + + @struct_spec XDR.Struct.new( + some_int: Int, + foo: Foo + ) + + @type some_int_type :: Int.t() + @type foo_type :: Foo.t() + + @type t :: %__MODULE__{some_int: some_int_type(), foo: foo_type()} + + defstruct [:some_int, :foo] + + @spec new(some_int :: some_int_type(), foo :: foo_type()) :: t() + def new( + %Int{} = some_int, + %Foo{} = foo + ), + do: %__MODULE__{some_int: some_int, foo: foo} + + @impl true + def encode_xdr(%__MODULE__{some_int: some_int, foo: foo}) do + [some_int: some_int, foo: foo] + |> XDR.Struct.new() + |> XDR.Struct.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{some_int: some_int, foo: foo}) do + [some_int: some_int, foo: foo] + |> XDR.Struct.new() + |> XDR.Struct.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, struct \\ @struct_spec) + + def decode_xdr(bytes, struct) do + case XDR.Struct.decode_xdr(bytes, struct) do + {:ok, {%XDR.Struct{components: [some_int: some_int, foo: foo]}, rest}} -> + {:ok, {new(some_int, foo), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, struct \\ @struct_spec) + + def decode_xdr!(bytes, struct) do + {%XDR.Struct{components: [some_int: some_int, foo: foo]}, rest} = + XDR.Struct.decode_xdr!(bytes, struct) + {new(some_int, foo), rest} + end +end diff --git a/spec/output/generator_spec_elixir/nesting.x/union_key.ex b/spec/output/generator_spec_elixir/nesting.x/union_key.ex new file mode 100644 index 000000000..14e5bfdba --- /dev/null +++ b/spec/output/generator_spec_elixir/nesting.x/union_key.ex @@ -0,0 +1,59 @@ +defmodule MyXDR.UnionKey do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `UnionKey` type. + """ + + @behaviour XDR.Declaration + + @declarations [ + ONE: 1, + TWO: 2, + OFFER: 3 + ] + + @enum_spec %XDR.Enum{declarations: @declarations, identifier: nil} + + @type t :: %__MODULE__{identifier: atom()} + + defstruct [:identifier] + + @spec new(type :: atom()) :: t() + def new(type \\ :ONE), do: %__MODULE__{identifier: type} + + @impl true + def encode_xdr(%__MODULE__{identifier: type}) do + @declarations + |> XDR.Enum.new(type) + |> XDR.Enum.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{identifier: type}) do + @declarations + |> XDR.Enum.new(type) + |> XDR.Enum.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, spec \\ @enum_spec) + + def decode_xdr(bytes, spec) do + case XDR.Enum.decode_xdr(bytes, spec) do + {:ok, {%XDR.Enum{identifier: type}, rest}} -> {:ok, {new(type), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @enum_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.Enum{identifier: type}, rest} = XDR.Enum.decode_xdr!(bytes, spec) + {new(type), rest} + end +end diff --git a/spec/output/generator_spec_elixir/optional.x/MyXDR_generated.ex b/spec/output/generator_spec_elixir/optional.x/MyXDR_generated.ex deleted file mode 100644 index 9b1531ec9..000000000 --- a/spec/output/generator_spec_elixir/optional.x/MyXDR_generated.ex +++ /dev/null @@ -1,38 +0,0 @@ -defmodule MyXDR do - @moduledoc """ - Automatically generated by xdrgen - DO NOT EDIT or your changes may be overwritten - - Target implementation: exdr at https://hex.pm/packages/exdr - """ - - use XDR.Base - - comment ~S""" - === xdr source ============================================================ - - typedef int Arr[2]; - - =========================================================================== - """ - define_type("Arr", Array, length: 2, type: buid_type(base_ref)) - - comment ~S""" - === xdr source ============================================================ - - struct HasOptions - { - int* firstOption; - int *secondOption; - Arr *thirdOption; - }; - - =========================================================================== - """ - define_type("HasOptions", Struct, - first_option: build_type(Optional, buid_type(base_ref)), - second_option: build_type(Optional, buid_type(base_ref)), - third_option: build_type(Optional, "Arr") - ) - -end diff --git a/spec/output/generator_spec_elixir/optional.x/arr.ex b/spec/output/generator_spec_elixir/optional.x/arr.ex new file mode 100644 index 000000000..74aad724c --- /dev/null +++ b/spec/output/generator_spec_elixir/optional.x/arr.ex @@ -0,0 +1,59 @@ +defmodule MyXDR.Arr do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Arr` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.Int + + @length 2 + + @array_type Int + + @array_spec %{type: @array_type, length: @length} + + @type t :: %__MODULE__{items: list(Int.t())} + + defstruct [:items] + + @spec new(items :: list(Int.t())) :: t() + def new(items), do: %__MODULE__{items: items} + + @impl true + def encode_xdr(%__MODULE__{items: items}) do + items + |> XDR.FixedArray.new(@array_type, @length) + |> XDR.FixedArray.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{items: items}) do + items + |> XDR.FixedArray.new(@array_type, @length) + |> XDR.FixedArray.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, spec \\ @array_spec) + + def decode_xdr(bytes, spec) do + case XDR.FixedArray.decode_xdr(bytes, spec) do + {:ok, {items, rest}} -> {:ok, {new(items), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @array_spec) + + def decode_xdr!(bytes, spec) do + {items, rest} = XDR.FixedArray.decode_xdr!(bytes, spec) + {new(items), rest} + end +end diff --git a/spec/output/generator_spec_elixir/optional.x/base.ex b/spec/output/generator_spec_elixir/optional.x/base.ex new file mode 100644 index 000000000..3164dc83e --- /dev/null +++ b/spec/output/generator_spec_elixir/optional.x/base.ex @@ -0,0 +1,439 @@ +defmodule MyXDR.Int do + @moduledoc """ + Representation of Stellar `Int` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: integer()} + + defstruct [:datum] + + @spec new(int :: integer()) :: t() + def new(int), do: %__MODULE__{datum: int} + + @impl true + def encode_xdr(%__MODULE__{datum: int}) do + XDR.Int.encode_xdr(%XDR.Int{datum: int}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: int}) do + XDR.Int.encode_xdr!(%XDR.Int{datum: int}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Int.decode_xdr(bytes) do + {:ok, {%XDR.Int{datum: int}, rest}} -> {:ok, {new(int), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Int{datum: int}, rest} = XDR.Int.decode_xdr!(bytes) + {new(int), rest} + end +end + +defmodule MyXDR.Uint do + @moduledoc """ + Representation of Stellar `Uint` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: non_neg_integer()} + + defstruct [:datum] + + @spec new(uint :: non_neg_integer()) :: t() + def new(uint), do: %__MODULE__{datum: uint} + + @impl true + def encode_xdr(%__MODULE__{datum: uint}) do + XDR.UInt.encode_xdr(%XDR.UInt{datum: uint}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: uint}) do + XDR.UInt.encode_xdr!(%XDR.UInt{datum: uint}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.UInt.decode_xdr(bytes) do + {:ok, {%XDR.UInt{datum: uint}, rest}} -> {:ok, {new(uint), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.UInt{datum: uint}, rest} = XDR.UInt.decode_xdr!(bytes) + {new(uint), rest} + end +end + +defmodule MyXDR.Float do + @moduledoc """ + Representation of Stellar `Float` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{float: float()} + + defstruct [:float] + + @spec new(float :: float()) :: t() + def new(float), do: %__MODULE__{float: float} + + @impl true + def encode_xdr(%__MODULE__{float: float}) do + XDR.Float.encode_xdr(%XDR.Float{float: float}) + end + + @impl true + def encode_xdr!(%__MODULE__{float: float}) do + XDR.Float.encode_xdr!(%XDR.Float{float: float}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Float.decode_xdr(bytes) do + {:ok, {%XDR.Float{float: float}, rest}} -> {:ok, {new(float), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Float{float: float}, rest} = XDR.Float.decode_xdr!(bytes) + {new(float), rest} + end +end + +defmodule MyXDR.DoubleFloat do + @moduledoc """ + Representation of Stellar `DoubleFloat` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{float: float()} + + defstruct [:float] + + @spec new(float :: float()) :: t() + def new(float), do: %__MODULE__{float: float} + + @impl true + def encode_xdr(%__MODULE__{float: float}) do + XDR.DoubleFloat.encode_xdr(%XDR.DoubleFloat{float: float}) + end + + @impl true + def encode_xdr!(%__MODULE__{float: float}) do + XDR.DoubleFloat.encode_xdr!(%XDR.DoubleFloat{float: float}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.DoubleFloat.decode_xdr(bytes) do + {:ok, {%XDR.DoubleFloat{float: float}, rest}} -> {:ok, {new(float), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.DoubleFloat{float: float}, rest} = XDR.DoubleFloat.decode_xdr!(bytes) + {new(float), rest} + end +end + +defmodule MyXDR.HyperUInt do + @moduledoc """ + Representation of Stellar `HyperUInt` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: non_neg_integer()} + + defstruct [:datum] + + @spec new(uint :: non_neg_integer()) :: t() + def new(uint), do: %__MODULE__{datum: uint} + + @impl true + def encode_xdr(%__MODULE__{datum: uint}) do + XDR.HyperUInt.encode_xdr(%XDR.HyperUInt{datum: uint}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: uint}) do + XDR.HyperUInt.encode_xdr!(%XDR.HyperUInt{datum: uint}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.HyperUInt.decode_xdr(bytes) do + {:ok, {%XDR.HyperUInt{datum: uint}, rest}} -> {:ok, {new(uint), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.HyperUInt{datum: uint}, rest} = XDR.HyperUInt.decode_xdr!(bytes) + {new(uint), rest} + end +end + +defmodule MyXDR.Bool do + @moduledoc """ + Representation of Stellar `Bool` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: boolean()} + + defstruct [:value] + + @spec new(value :: boolean()) :: t() + def new(val), do: %__MODULE__{value: val} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + XDR.Bool.encode_xdr(%XDR.Bool{identifier: value}) + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + XDR.Bool.encode_xdr!(%XDR.Bool{identifier: value}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Bool.decode_xdr(bytes) do + {:ok, {%XDR.Bool{identifier: val}, rest}} -> {:ok, {new(val), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Bool{identifier: val}, rest} = XDR.Bool.decode_xdr!(bytes) + {new(val), rest} + end +end + +defmodule MyXDR.String do + @moduledoc """ + Representation of Stellar `String` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: String.t()} + + defstruct [:value] + + @spec new(value :: String.t()) :: t() + def new(value), do: %__MODULE__{value: value} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + value + |> XDR.String.new() + |> XDR.String.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + value + |> XDR.String.new() + |> XDR.String.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.String.decode_xdr(bytes) do + {:ok, {%XDR.String{string: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.String{string: value}, rest} = XDR.String.decode_xdr!(bytes) + {new(value), rest} + end +end + +defmodule MyXDR.FixedOpaque do + @moduledoc """ + Representation of Stellar `FixedOpaque` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{opaque: binary()} + + defstruct [:opaque] + + @length 4_294_967_295 + + @opaque_spec XDR.FixedOpaque.new(nil, @length) + + @spec new(opaque :: binary()) :: t() + def new(opaque), do: %__MODULE__{opaque: opaque} + + @impl true + def encode_xdr(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def encode_xdr!(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr!(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def decode_xdr(bytes, spec \\ @opaque_spec) + + def decode_xdr(bytes, spec) do + case XDR.FixedOpaque.decode_xdr(bytes, spec) do + {:ok, {%XDR.FixedOpaque{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @opaque_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.FixedOpaque{opaque: opaque}, rest} = XDR.FixedOpaque.decode_xdr!(bytes, spec) + {new(opaque), rest} + end +end + +defmodule MyXDR.VariableOpaque do + @moduledoc """ + Representation of Stellar `VariableOpaque` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{opaque: binary()} + + defstruct [:opaque] + + @opaque_spec XDR.VariableOpaque.new(nil) + + @spec new(opaque :: binary()) :: t() + def new(opaque), do: %__MODULE__{opaque: opaque} + + @impl true + def encode_xdr(%__MODULE__{opaque: opaque}) do + XDR.VariableOpaque.encode_xdr(%XDR.VariableOpaque{opaque: opaque}) + end + + @impl true + def encode_xdr!(%__MODULE__{opaque: opaque}) do + XDR.VariableOpaque.encode_xdr!(%XDR.VariableOpaque{opaque: opaque}) + end + + @impl true + def decode_xdr(bytes, spec \\ @opaque_spec) + + def decode_xdr(bytes, spec) do + case XDR.VariableOpaque.decode_xdr(bytes, spec) do + {:ok, {%XDR.VariableOpaque{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @opaque_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.VariableOpaque{opaque: opaque}, rest} = XDR.VariableOpaque.decode_xdr!(bytes, spec) + {new(opaque), rest} + end +end + +defmodule MyXDR.Void do + @moduledoc """ + Representation of Stellar `Void` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: nil} + + defstruct [:value] + + @spec new(value :: nil) :: t() + def new(_val \\ nil), do: %__MODULE__{value: nil} + + @impl true + def encode_xdr(%__MODULE__{}) do + XDR.Void.encode_xdr(%XDR.Void{}) + end + + @impl true + def encode_xdr!(%__MODULE__{}) do + XDR.Void.encode_xdr!(%XDR.Void{}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Void.decode_xdr(bytes) do + {:ok, {nil, rest}} -> {:ok, {new(), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {nil, rest} = XDR.Void.decode_xdr!(bytes) + {new(), rest} + end +end diff --git a/spec/output/generator_spec_elixir/optional.x/has_options.ex b/spec/output/generator_spec_elixir/optional.x/has_options.ex new file mode 100644 index 000000000..0c3329d85 --- /dev/null +++ b/spec/output/generator_spec_elixir/optional.x/has_options.ex @@ -0,0 +1,73 @@ +defmodule MyXDR.HasOptions do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `HasOptions` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.{ + OptionalInt, + OptionalArr + } + + @struct_spec XDR.Struct.new( + first_option: OptionalInt, + second_option: OptionalInt, + third_option: OptionalArr + ) + + @type first_option_type :: OptionalInt.t() + @type second_option_type :: OptionalInt.t() + @type third_option_type :: OptionalArr.t() + + @type t :: %__MODULE__{first_option: first_option_type(), second_option: second_option_type(), third_option: third_option_type()} + + defstruct [:first_option, :second_option, :third_option] + + @spec new(first_option :: first_option_type(), second_option :: second_option_type(), third_option :: third_option_type()) :: t() + def new( + %OptionalInt{} = first_option, + %OptionalInt{} = second_option, + %OptionalArr{} = third_option + ), + do: %__MODULE__{first_option: first_option, second_option: second_option, third_option: third_option} + + @impl true + def encode_xdr(%__MODULE__{first_option: first_option, second_option: second_option, third_option: third_option}) do + [first_option: first_option, second_option: second_option, third_option: third_option] + |> XDR.Struct.new() + |> XDR.Struct.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{first_option: first_option, second_option: second_option, third_option: third_option}) do + [first_option: first_option, second_option: second_option, third_option: third_option] + |> XDR.Struct.new() + |> XDR.Struct.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, struct \\ @struct_spec) + + def decode_xdr(bytes, struct) do + case XDR.Struct.decode_xdr(bytes, struct) do + {:ok, {%XDR.Struct{components: [first_option: first_option, second_option: second_option, third_option: third_option]}, rest}} -> + {:ok, {new(first_option, second_option, third_option), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, struct \\ @struct_spec) + + def decode_xdr!(bytes, struct) do + {%XDR.Struct{components: [first_option: first_option, second_option: second_option, third_option: third_option]}, rest} = + XDR.Struct.decode_xdr!(bytes, struct) + {new(first_option, second_option, third_option), rest} + end +end diff --git a/spec/output/generator_spec_elixir/optional.x/optional_arr.ex b/spec/output/generator_spec_elixir/optional.x/optional_arr.ex new file mode 100644 index 000000000..a99a0c7fc --- /dev/null +++ b/spec/output/generator_spec_elixir/optional.x/optional_arr.ex @@ -0,0 +1,61 @@ +defmodule MyXDR.OptionalArr do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `OptionalArr` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.Arr + + @optional_spec XDR.Optional.new(Arr) + + @type arr :: Arr.t() | nil + + @type t :: %__MODULE__{arr: arr()} + + defstruct [:arr] + + @spec new(arr :: arr()) :: t() + def new(arr \\ nil), do: %__MODULE__{arr: arr} + + @impl true + def encode_xdr(%__MODULE__{arr: arr}) do + arr + |> XDR.Optional.new() + |> XDR.Optional.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{arr: arr}) do + arr + |> XDR.Optional.new() + |> XDR.Optional.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, optional_spec \\ @optional_spec) + + def decode_xdr(bytes, optional_spec) do + case XDR.Optional.decode_xdr(bytes, optional_spec) do + {:ok, {%XDR.Optional{type: arr}, rest}} -> {:ok, {new(arr), rest}} + {:ok, {nil, rest}} -> {:ok, {new(), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, optional_spec \\ @optional_spec) + + def decode_xdr!(bytes, optional_spec) do + case XDR.Optional.decode_xdr!(bytes, optional_spec) do + {%XDR.Optional{type: arr}, rest} -> {new(arr), rest} + {nil, rest} -> {new(), rest} + end + end + +end diff --git a/spec/output/generator_spec_elixir/optional.x/optional_int.ex b/spec/output/generator_spec_elixir/optional.x/optional_int.ex new file mode 100644 index 000000000..684121db9 --- /dev/null +++ b/spec/output/generator_spec_elixir/optional.x/optional_int.ex @@ -0,0 +1,61 @@ +defmodule MyXDR.OptionalInt do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `OptionalInt` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.Int + + @optional_spec XDR.Optional.new(Int) + + @type int :: Int.t() | nil + + @type t :: %__MODULE__{int: int()} + + defstruct [:int] + + @spec new(int :: int()) :: t() + def new(int \\ nil), do: %__MODULE__{int: int} + + @impl true + def encode_xdr(%__MODULE__{int: int}) do + int + |> XDR.Optional.new() + |> XDR.Optional.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{int: int}) do + int + |> XDR.Optional.new() + |> XDR.Optional.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, optional_spec \\ @optional_spec) + + def decode_xdr(bytes, optional_spec) do + case XDR.Optional.decode_xdr(bytes, optional_spec) do + {:ok, {%XDR.Optional{type: int}, rest}} -> {:ok, {new(int), rest}} + {:ok, {nil, rest}} -> {:ok, {new(), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, optional_spec \\ @optional_spec) + + def decode_xdr!(bytes, optional_spec) do + case XDR.Optional.decode_xdr!(bytes, optional_spec) do + {%XDR.Optional{type: int}, rest} -> {new(int), rest} + {nil, rest} -> {new(), rest} + end + end + +end diff --git a/spec/output/generator_spec_elixir/struct.x/MyXDR_generated.ex b/spec/output/generator_spec_elixir/struct.x/MyXDR_generated.ex deleted file mode 100644 index 6c859516e..000000000 --- a/spec/output/generator_spec_elixir/struct.x/MyXDR_generated.ex +++ /dev/null @@ -1,42 +0,0 @@ -defmodule MyXDR do - @moduledoc """ - Automatically generated by xdrgen - DO NOT EDIT or your changes may be overwritten - - Target implementation: exdr at https://hex.pm/packages/exdr - """ - - use XDR.Base - - comment ~S""" - === xdr source ============================================================ - - typedef hyper int64; - - =========================================================================== - """ - define_type("Int64", HyperInt) - - comment ~S""" - === xdr source ============================================================ - - struct MyStruct - { - int someInt; - int64 aBigInt; - opaque someOpaque[10]; - string someString<>; - string maxString<100>; - }; - - =========================================================================== - """ - define_type("MyStruct", Struct, - some_int: build_type(Int), - a_big_int: "Int64", - some_opaque: build_type(Opaque, 10), - some_string: build_type(XDR.Type.String, ), - max_string: build_type(XDR.Type.String, 100) - ) - -end diff --git a/spec/output/generator_spec_elixir/struct.x/base.ex b/spec/output/generator_spec_elixir/struct.x/base.ex new file mode 100644 index 000000000..3164dc83e --- /dev/null +++ b/spec/output/generator_spec_elixir/struct.x/base.ex @@ -0,0 +1,439 @@ +defmodule MyXDR.Int do + @moduledoc """ + Representation of Stellar `Int` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: integer()} + + defstruct [:datum] + + @spec new(int :: integer()) :: t() + def new(int), do: %__MODULE__{datum: int} + + @impl true + def encode_xdr(%__MODULE__{datum: int}) do + XDR.Int.encode_xdr(%XDR.Int{datum: int}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: int}) do + XDR.Int.encode_xdr!(%XDR.Int{datum: int}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Int.decode_xdr(bytes) do + {:ok, {%XDR.Int{datum: int}, rest}} -> {:ok, {new(int), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Int{datum: int}, rest} = XDR.Int.decode_xdr!(bytes) + {new(int), rest} + end +end + +defmodule MyXDR.Uint do + @moduledoc """ + Representation of Stellar `Uint` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: non_neg_integer()} + + defstruct [:datum] + + @spec new(uint :: non_neg_integer()) :: t() + def new(uint), do: %__MODULE__{datum: uint} + + @impl true + def encode_xdr(%__MODULE__{datum: uint}) do + XDR.UInt.encode_xdr(%XDR.UInt{datum: uint}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: uint}) do + XDR.UInt.encode_xdr!(%XDR.UInt{datum: uint}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.UInt.decode_xdr(bytes) do + {:ok, {%XDR.UInt{datum: uint}, rest}} -> {:ok, {new(uint), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.UInt{datum: uint}, rest} = XDR.UInt.decode_xdr!(bytes) + {new(uint), rest} + end +end + +defmodule MyXDR.Float do + @moduledoc """ + Representation of Stellar `Float` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{float: float()} + + defstruct [:float] + + @spec new(float :: float()) :: t() + def new(float), do: %__MODULE__{float: float} + + @impl true + def encode_xdr(%__MODULE__{float: float}) do + XDR.Float.encode_xdr(%XDR.Float{float: float}) + end + + @impl true + def encode_xdr!(%__MODULE__{float: float}) do + XDR.Float.encode_xdr!(%XDR.Float{float: float}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Float.decode_xdr(bytes) do + {:ok, {%XDR.Float{float: float}, rest}} -> {:ok, {new(float), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Float{float: float}, rest} = XDR.Float.decode_xdr!(bytes) + {new(float), rest} + end +end + +defmodule MyXDR.DoubleFloat do + @moduledoc """ + Representation of Stellar `DoubleFloat` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{float: float()} + + defstruct [:float] + + @spec new(float :: float()) :: t() + def new(float), do: %__MODULE__{float: float} + + @impl true + def encode_xdr(%__MODULE__{float: float}) do + XDR.DoubleFloat.encode_xdr(%XDR.DoubleFloat{float: float}) + end + + @impl true + def encode_xdr!(%__MODULE__{float: float}) do + XDR.DoubleFloat.encode_xdr!(%XDR.DoubleFloat{float: float}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.DoubleFloat.decode_xdr(bytes) do + {:ok, {%XDR.DoubleFloat{float: float}, rest}} -> {:ok, {new(float), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.DoubleFloat{float: float}, rest} = XDR.DoubleFloat.decode_xdr!(bytes) + {new(float), rest} + end +end + +defmodule MyXDR.HyperUInt do + @moduledoc """ + Representation of Stellar `HyperUInt` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: non_neg_integer()} + + defstruct [:datum] + + @spec new(uint :: non_neg_integer()) :: t() + def new(uint), do: %__MODULE__{datum: uint} + + @impl true + def encode_xdr(%__MODULE__{datum: uint}) do + XDR.HyperUInt.encode_xdr(%XDR.HyperUInt{datum: uint}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: uint}) do + XDR.HyperUInt.encode_xdr!(%XDR.HyperUInt{datum: uint}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.HyperUInt.decode_xdr(bytes) do + {:ok, {%XDR.HyperUInt{datum: uint}, rest}} -> {:ok, {new(uint), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.HyperUInt{datum: uint}, rest} = XDR.HyperUInt.decode_xdr!(bytes) + {new(uint), rest} + end +end + +defmodule MyXDR.Bool do + @moduledoc """ + Representation of Stellar `Bool` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: boolean()} + + defstruct [:value] + + @spec new(value :: boolean()) :: t() + def new(val), do: %__MODULE__{value: val} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + XDR.Bool.encode_xdr(%XDR.Bool{identifier: value}) + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + XDR.Bool.encode_xdr!(%XDR.Bool{identifier: value}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Bool.decode_xdr(bytes) do + {:ok, {%XDR.Bool{identifier: val}, rest}} -> {:ok, {new(val), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Bool{identifier: val}, rest} = XDR.Bool.decode_xdr!(bytes) + {new(val), rest} + end +end + +defmodule MyXDR.String do + @moduledoc """ + Representation of Stellar `String` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: String.t()} + + defstruct [:value] + + @spec new(value :: String.t()) :: t() + def new(value), do: %__MODULE__{value: value} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + value + |> XDR.String.new() + |> XDR.String.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + value + |> XDR.String.new() + |> XDR.String.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.String.decode_xdr(bytes) do + {:ok, {%XDR.String{string: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.String{string: value}, rest} = XDR.String.decode_xdr!(bytes) + {new(value), rest} + end +end + +defmodule MyXDR.FixedOpaque do + @moduledoc """ + Representation of Stellar `FixedOpaque` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{opaque: binary()} + + defstruct [:opaque] + + @length 4_294_967_295 + + @opaque_spec XDR.FixedOpaque.new(nil, @length) + + @spec new(opaque :: binary()) :: t() + def new(opaque), do: %__MODULE__{opaque: opaque} + + @impl true + def encode_xdr(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def encode_xdr!(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr!(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def decode_xdr(bytes, spec \\ @opaque_spec) + + def decode_xdr(bytes, spec) do + case XDR.FixedOpaque.decode_xdr(bytes, spec) do + {:ok, {%XDR.FixedOpaque{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @opaque_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.FixedOpaque{opaque: opaque}, rest} = XDR.FixedOpaque.decode_xdr!(bytes, spec) + {new(opaque), rest} + end +end + +defmodule MyXDR.VariableOpaque do + @moduledoc """ + Representation of Stellar `VariableOpaque` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{opaque: binary()} + + defstruct [:opaque] + + @opaque_spec XDR.VariableOpaque.new(nil) + + @spec new(opaque :: binary()) :: t() + def new(opaque), do: %__MODULE__{opaque: opaque} + + @impl true + def encode_xdr(%__MODULE__{opaque: opaque}) do + XDR.VariableOpaque.encode_xdr(%XDR.VariableOpaque{opaque: opaque}) + end + + @impl true + def encode_xdr!(%__MODULE__{opaque: opaque}) do + XDR.VariableOpaque.encode_xdr!(%XDR.VariableOpaque{opaque: opaque}) + end + + @impl true + def decode_xdr(bytes, spec \\ @opaque_spec) + + def decode_xdr(bytes, spec) do + case XDR.VariableOpaque.decode_xdr(bytes, spec) do + {:ok, {%XDR.VariableOpaque{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @opaque_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.VariableOpaque{opaque: opaque}, rest} = XDR.VariableOpaque.decode_xdr!(bytes, spec) + {new(opaque), rest} + end +end + +defmodule MyXDR.Void do + @moduledoc """ + Representation of Stellar `Void` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: nil} + + defstruct [:value] + + @spec new(value :: nil) :: t() + def new(_val \\ nil), do: %__MODULE__{value: nil} + + @impl true + def encode_xdr(%__MODULE__{}) do + XDR.Void.encode_xdr(%XDR.Void{}) + end + + @impl true + def encode_xdr!(%__MODULE__{}) do + XDR.Void.encode_xdr!(%XDR.Void{}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Void.decode_xdr(bytes) do + {:ok, {nil, rest}} -> {:ok, {new(), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {nil, rest} = XDR.Void.decode_xdr!(bytes) + {new(), rest} + end +end diff --git a/spec/output/generator_spec_elixir/struct.x/int64.ex b/spec/output/generator_spec_elixir/struct.x/int64.ex new file mode 100644 index 000000000..fe44820ba --- /dev/null +++ b/spec/output/generator_spec_elixir/struct.x/int64.ex @@ -0,0 +1,47 @@ +defmodule MyXDR.Int64 do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Int64` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: integer()} + + defstruct [:datum] + + @spec new(value :: integer()) :: t() + def new(value), do: %__MODULE__{datum: value} + + @impl true + def encode_xdr(%__MODULE__{datum: value}) do + XDR.HyperInt.encode_xdr(%XDR.HyperInt{datum: value}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: value}) do + XDR.HyperInt.encode_xdr!(%XDR.HyperInt{datum: value}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.HyperInt.decode_xdr(bytes) do + {:ok, {%XDR.HyperInt{datum: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.HyperInt{datum: value}, rest} = XDR.HyperInt.decode_xdr!(bytes) + {new(value), rest} + end +end diff --git a/spec/output/generator_spec_elixir/struct.x/my_struct.ex b/spec/output/generator_spec_elixir/struct.x/my_struct.ex new file mode 100644 index 000000000..bc4e094bb --- /dev/null +++ b/spec/output/generator_spec_elixir/struct.x/my_struct.ex @@ -0,0 +1,82 @@ +defmodule MyXDR.MyStruct do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `MyStruct` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.{ + Int, + Int64, + Opaque10, + String, + String100 + } + + @struct_spec XDR.Struct.new( + some_int: Int, + a_big_int: Int64, + some_opaque: Opaque10, + some_string: String, + max_string: String100 + ) + + @type some_int_type :: Int.t() + @type a_big_int_type :: Int64.t() + @type some_opaque_type :: Opaque10.t() + @type some_string_type :: String.t() + @type max_string_type :: String100.t() + + @type t :: %__MODULE__{some_int: some_int_type(), a_big_int: a_big_int_type(), some_opaque: some_opaque_type(), some_string: some_string_type(), max_string: max_string_type()} + + defstruct [:some_int, :a_big_int, :some_opaque, :some_string, :max_string] + + @spec new(some_int :: some_int_type(), a_big_int :: a_big_int_type(), some_opaque :: some_opaque_type(), some_string :: some_string_type(), max_string :: max_string_type()) :: t() + def new( + %Int{} = some_int, + %Int64{} = a_big_int, + %Opaque10{} = some_opaque, + %String{} = some_string, + %String100{} = max_string + ), + do: %__MODULE__{some_int: some_int, a_big_int: a_big_int, some_opaque: some_opaque, some_string: some_string, max_string: max_string} + + @impl true + def encode_xdr(%__MODULE__{some_int: some_int, a_big_int: a_big_int, some_opaque: some_opaque, some_string: some_string, max_string: max_string}) do + [some_int: some_int, a_big_int: a_big_int, some_opaque: some_opaque, some_string: some_string, max_string: max_string] + |> XDR.Struct.new() + |> XDR.Struct.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{some_int: some_int, a_big_int: a_big_int, some_opaque: some_opaque, some_string: some_string, max_string: max_string}) do + [some_int: some_int, a_big_int: a_big_int, some_opaque: some_opaque, some_string: some_string, max_string: max_string] + |> XDR.Struct.new() + |> XDR.Struct.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, struct \\ @struct_spec) + + def decode_xdr(bytes, struct) do + case XDR.Struct.decode_xdr(bytes, struct) do + {:ok, {%XDR.Struct{components: [some_int: some_int, a_big_int: a_big_int, some_opaque: some_opaque, some_string: some_string, max_string: max_string]}, rest}} -> + {:ok, {new(some_int, a_big_int, some_opaque, some_string, max_string), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, struct \\ @struct_spec) + + def decode_xdr!(bytes, struct) do + {%XDR.Struct{components: [some_int: some_int, a_big_int: a_big_int, some_opaque: some_opaque, some_string: some_string, max_string: max_string]}, rest} = + XDR.Struct.decode_xdr!(bytes, struct) + {new(some_int, a_big_int, some_opaque, some_string, max_string), rest} + end +end diff --git a/spec/output/generator_spec_elixir/struct.x/opaque10.ex b/spec/output/generator_spec_elixir/struct.x/opaque10.ex new file mode 100644 index 000000000..dc9af8053 --- /dev/null +++ b/spec/output/generator_spec_elixir/struct.x/opaque10.ex @@ -0,0 +1,51 @@ +defmodule MyXDR.Opaque10 do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Opaque10` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{opaque: binary()} + + defstruct [:opaque] + + @length 10 + + @opaque_spec XDR.FixedOpaque.new(nil, @length) + + @spec new(opaque :: binary()) :: t() + def new(opaque), do: %__MODULE__{opaque: opaque} + + @impl true + def encode_xdr(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def encode_xdr!(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr!(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def decode_xdr(bytes, spec \\ @opaque_spec) + + def decode_xdr(bytes, spec) do + case XDR.FixedOpaque.decode_xdr(bytes, spec) do + {:ok, {%XDR.FixedOpaque{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @opaque_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.FixedOpaque{opaque: opaque}, rest} = XDR.FixedOpaque.decode_xdr!(bytes, spec) + {new(opaque), rest} + end +end diff --git a/spec/output/generator_spec_elixir/struct.x/string100.ex b/spec/output/generator_spec_elixir/struct.x/string100.ex new file mode 100644 index 000000000..5c6da4943 --- /dev/null +++ b/spec/output/generator_spec_elixir/struct.x/string100.ex @@ -0,0 +1,53 @@ +defmodule MyXDR.String100 do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `String100` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: String.t()} + + defstruct [:value] + + @max_length 100 + + @spec new(value :: String.t()) :: t() + def new(value), do: %__MODULE__{value: value} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + value + |> XDR.String.new(@max_length) + |> XDR.String.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + value + |> XDR.String.new(@max_length) + |> XDR.String.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.String.decode_xdr(bytes) do + {:ok, {%XDR.String{string: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.String{string: value}, rest} = XDR.String.decode_xdr!(bytes) + {new(value), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/MyXDR_generated.ex b/spec/output/generator_spec_elixir/test.x/MyXDR_generated.ex deleted file mode 100644 index 4f6d2eb55..000000000 --- a/spec/output/generator_spec_elixir/test.x/MyXDR_generated.ex +++ /dev/null @@ -1,320 +0,0 @@ -defmodule MyXDR do - @moduledoc """ - Automatically generated by xdrgen - DO NOT EDIT or your changes may be overwritten - - Target implementation: exdr at https://hex.pm/packages/exdr - """ - - use XDR.Base - - - comment ~S""" - === xdr source ============================================================ - - typedef opaque uint512[64]; - - =========================================================================== - """ - define_type("Uint512", Opaque, 64) - - comment ~S""" - === xdr source ============================================================ - - typedef opaque uint513<64>; - - =========================================================================== - """ - define_type("Uint513", VariableOpaque, 64) - - comment ~S""" - === xdr source ============================================================ - - typedef opaque uint514<>; - - =========================================================================== - """ - define_type("Uint514", VariableOpaque) - - comment ~S""" - === xdr source ============================================================ - - typedef string str<64>; - - =========================================================================== - """ - define_type("Str", XDR.Type.String, 64) - - comment ~S""" - === xdr source ============================================================ - - typedef string str2<>; - - =========================================================================== - """ - define_type("Str2", XDR.Type.String, ) - - comment ~S""" - === xdr source ============================================================ - - typedef opaque Hash[32]; - - =========================================================================== - """ - define_type("Hash", Opaque, 32) - - comment ~S""" - === xdr source ============================================================ - - typedef Hash Hashes1[12]; - - =========================================================================== - """ - define_type("Hashes1", Array, length: 12, type: "Hash") - - comment ~S""" - === xdr source ============================================================ - - typedef Hash Hashes2<12>; - - =========================================================================== - """ - define_type("Hashes2", VariableArray, max_length: 12, type: "Hash") - - comment ~S""" - === xdr source ============================================================ - - typedef Hash Hashes3<>; - - =========================================================================== - """ - define_type("Hashes3", VariableArray, max_length: 2147483647, type: "Hash") - - comment ~S""" - === xdr source ============================================================ - - typedef Hash *optHash1; - - =========================================================================== - """ - define_type("OptHash1", Optional, "Hash") - - comment ~S""" - === xdr source ============================================================ - - typedef Hash* optHash2; - - =========================================================================== - """ - define_type("OptHash2", Optional, "Hash") - - comment ~S""" - === xdr source ============================================================ - - typedef int int1; - - =========================================================================== - """ - define_type("Int1", Int) - - comment ~S""" - === xdr source ============================================================ - - typedef hyper int2; - - =========================================================================== - """ - define_type("Int2", HyperInt) - - comment ~S""" - === xdr source ============================================================ - - typedef unsigned int int3; - - =========================================================================== - """ - define_type("Int3", UnsignedInt) - - comment ~S""" - === xdr source ============================================================ - - typedef unsigned hyper int4; - - =========================================================================== - """ - define_type("Int4", UnsignedHyperInt) - - comment ~S""" - === xdr source ============================================================ - - struct MyStruct - { - uint512 field1; - optHash1 field2; - int1 field3; - unsigned int field4; - float field5; - double field6; - bool field7; - }; - - =========================================================================== - """ - define_type("MyStruct", Struct, - field1: "Uint512", - field2: "OptHash1", - field3: "Int1", - field4: build_type(UnsignedInt), - field5: build_type(Float), - field6: build_type(Double), - field7: build_type(Bool) - ) - - comment ~S""" - === xdr source ============================================================ - - struct LotsOfMyStructs - { - MyStruct members<>; - }; - - =========================================================================== - """ - define_type("LotsOfMyStructs", Struct, - members: build_type(VariableArray, max_length: 2147483647, type: "MyStruct") - ) - - comment ~S""" - === xdr source ============================================================ - - struct HasStuff - { - LotsOfMyStructs data; - }; - - =========================================================================== - """ - define_type("HasStuff", Struct, - data: "LotsOfMyStructs" - ) - - comment ~S""" - === xdr source ============================================================ - - enum Color { - RED, - BLUE = 5, - GREEN - }; - - =========================================================================== - """ - define_type("Color", Enum, - red: 0, - blue: 5, - green: 6 - ) - - comment ~S""" - === xdr source ============================================================ - - const FOO = 1244; - - =========================================================================== - """ - define_type("FOO", Const, 1244); - - comment ~S""" - === xdr source ============================================================ - - const BAR = FOO; - - =========================================================================== - """ - define_type("BAR", Const, FOO); - - comment ~S""" - === xdr source ============================================================ - - enum { - BLAH_1, - BLAH_2 - } - - =========================================================================== - """ - define_type("NesterNestedEnum", Enum, - blah1: 0, - blah2: 1 - ) - - comment ~S""" - === xdr source ============================================================ - - struct { - int blah; - } - - =========================================================================== - """ - define_type("NesterNestedStruct", Struct, - blah: build_type(Int) - ) - - comment ~S""" - === xdr source ============================================================ - - union switch (Color color) { - case RED: - void; - default: - int blah2; - } - - =========================================================================== - """ - define_type("NesterNestedUnion", Union, - switch_type: "Color", - switch_name: :color, - switches: [ - {:red, XDR.Type.Void}, - ], - arms: [ - blah2: build_type(Int), - ], - default_arm: blah2, - ) - - comment ~S""" - === xdr source ============================================================ - - struct Nester - { - enum { - BLAH_1, - BLAH_2 - } nestedEnum; - - struct { - int blah; - } nestedStruct; - - union switch (Color color) { - case RED: - void; - default: - int blah2; - } nestedUnion; - - - }; - - =========================================================================== - """ - define_type("Nester", Struct, - nested_enum: "NesterNestedEnum", - nested_struct: "NesterNestedStruct", - nested_union: "NesterNestedUnion" - ) - -end diff --git a/spec/output/generator_spec_elixir/test.x/base.ex b/spec/output/generator_spec_elixir/test.x/base.ex new file mode 100644 index 000000000..3164dc83e --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/base.ex @@ -0,0 +1,439 @@ +defmodule MyXDR.Int do + @moduledoc """ + Representation of Stellar `Int` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: integer()} + + defstruct [:datum] + + @spec new(int :: integer()) :: t() + def new(int), do: %__MODULE__{datum: int} + + @impl true + def encode_xdr(%__MODULE__{datum: int}) do + XDR.Int.encode_xdr(%XDR.Int{datum: int}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: int}) do + XDR.Int.encode_xdr!(%XDR.Int{datum: int}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Int.decode_xdr(bytes) do + {:ok, {%XDR.Int{datum: int}, rest}} -> {:ok, {new(int), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Int{datum: int}, rest} = XDR.Int.decode_xdr!(bytes) + {new(int), rest} + end +end + +defmodule MyXDR.Uint do + @moduledoc """ + Representation of Stellar `Uint` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: non_neg_integer()} + + defstruct [:datum] + + @spec new(uint :: non_neg_integer()) :: t() + def new(uint), do: %__MODULE__{datum: uint} + + @impl true + def encode_xdr(%__MODULE__{datum: uint}) do + XDR.UInt.encode_xdr(%XDR.UInt{datum: uint}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: uint}) do + XDR.UInt.encode_xdr!(%XDR.UInt{datum: uint}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.UInt.decode_xdr(bytes) do + {:ok, {%XDR.UInt{datum: uint}, rest}} -> {:ok, {new(uint), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.UInt{datum: uint}, rest} = XDR.UInt.decode_xdr!(bytes) + {new(uint), rest} + end +end + +defmodule MyXDR.Float do + @moduledoc """ + Representation of Stellar `Float` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{float: float()} + + defstruct [:float] + + @spec new(float :: float()) :: t() + def new(float), do: %__MODULE__{float: float} + + @impl true + def encode_xdr(%__MODULE__{float: float}) do + XDR.Float.encode_xdr(%XDR.Float{float: float}) + end + + @impl true + def encode_xdr!(%__MODULE__{float: float}) do + XDR.Float.encode_xdr!(%XDR.Float{float: float}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Float.decode_xdr(bytes) do + {:ok, {%XDR.Float{float: float}, rest}} -> {:ok, {new(float), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Float{float: float}, rest} = XDR.Float.decode_xdr!(bytes) + {new(float), rest} + end +end + +defmodule MyXDR.DoubleFloat do + @moduledoc """ + Representation of Stellar `DoubleFloat` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{float: float()} + + defstruct [:float] + + @spec new(float :: float()) :: t() + def new(float), do: %__MODULE__{float: float} + + @impl true + def encode_xdr(%__MODULE__{float: float}) do + XDR.DoubleFloat.encode_xdr(%XDR.DoubleFloat{float: float}) + end + + @impl true + def encode_xdr!(%__MODULE__{float: float}) do + XDR.DoubleFloat.encode_xdr!(%XDR.DoubleFloat{float: float}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.DoubleFloat.decode_xdr(bytes) do + {:ok, {%XDR.DoubleFloat{float: float}, rest}} -> {:ok, {new(float), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.DoubleFloat{float: float}, rest} = XDR.DoubleFloat.decode_xdr!(bytes) + {new(float), rest} + end +end + +defmodule MyXDR.HyperUInt do + @moduledoc """ + Representation of Stellar `HyperUInt` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: non_neg_integer()} + + defstruct [:datum] + + @spec new(uint :: non_neg_integer()) :: t() + def new(uint), do: %__MODULE__{datum: uint} + + @impl true + def encode_xdr(%__MODULE__{datum: uint}) do + XDR.HyperUInt.encode_xdr(%XDR.HyperUInt{datum: uint}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: uint}) do + XDR.HyperUInt.encode_xdr!(%XDR.HyperUInt{datum: uint}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.HyperUInt.decode_xdr(bytes) do + {:ok, {%XDR.HyperUInt{datum: uint}, rest}} -> {:ok, {new(uint), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.HyperUInt{datum: uint}, rest} = XDR.HyperUInt.decode_xdr!(bytes) + {new(uint), rest} + end +end + +defmodule MyXDR.Bool do + @moduledoc """ + Representation of Stellar `Bool` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: boolean()} + + defstruct [:value] + + @spec new(value :: boolean()) :: t() + def new(val), do: %__MODULE__{value: val} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + XDR.Bool.encode_xdr(%XDR.Bool{identifier: value}) + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + XDR.Bool.encode_xdr!(%XDR.Bool{identifier: value}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Bool.decode_xdr(bytes) do + {:ok, {%XDR.Bool{identifier: val}, rest}} -> {:ok, {new(val), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Bool{identifier: val}, rest} = XDR.Bool.decode_xdr!(bytes) + {new(val), rest} + end +end + +defmodule MyXDR.String do + @moduledoc """ + Representation of Stellar `String` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: String.t()} + + defstruct [:value] + + @spec new(value :: String.t()) :: t() + def new(value), do: %__MODULE__{value: value} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + value + |> XDR.String.new() + |> XDR.String.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + value + |> XDR.String.new() + |> XDR.String.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.String.decode_xdr(bytes) do + {:ok, {%XDR.String{string: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.String{string: value}, rest} = XDR.String.decode_xdr!(bytes) + {new(value), rest} + end +end + +defmodule MyXDR.FixedOpaque do + @moduledoc """ + Representation of Stellar `FixedOpaque` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{opaque: binary()} + + defstruct [:opaque] + + @length 4_294_967_295 + + @opaque_spec XDR.FixedOpaque.new(nil, @length) + + @spec new(opaque :: binary()) :: t() + def new(opaque), do: %__MODULE__{opaque: opaque} + + @impl true + def encode_xdr(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def encode_xdr!(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr!(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def decode_xdr(bytes, spec \\ @opaque_spec) + + def decode_xdr(bytes, spec) do + case XDR.FixedOpaque.decode_xdr(bytes, spec) do + {:ok, {%XDR.FixedOpaque{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @opaque_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.FixedOpaque{opaque: opaque}, rest} = XDR.FixedOpaque.decode_xdr!(bytes, spec) + {new(opaque), rest} + end +end + +defmodule MyXDR.VariableOpaque do + @moduledoc """ + Representation of Stellar `VariableOpaque` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{opaque: binary()} + + defstruct [:opaque] + + @opaque_spec XDR.VariableOpaque.new(nil) + + @spec new(opaque :: binary()) :: t() + def new(opaque), do: %__MODULE__{opaque: opaque} + + @impl true + def encode_xdr(%__MODULE__{opaque: opaque}) do + XDR.VariableOpaque.encode_xdr(%XDR.VariableOpaque{opaque: opaque}) + end + + @impl true + def encode_xdr!(%__MODULE__{opaque: opaque}) do + XDR.VariableOpaque.encode_xdr!(%XDR.VariableOpaque{opaque: opaque}) + end + + @impl true + def decode_xdr(bytes, spec \\ @opaque_spec) + + def decode_xdr(bytes, spec) do + case XDR.VariableOpaque.decode_xdr(bytes, spec) do + {:ok, {%XDR.VariableOpaque{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @opaque_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.VariableOpaque{opaque: opaque}, rest} = XDR.VariableOpaque.decode_xdr!(bytes, spec) + {new(opaque), rest} + end +end + +defmodule MyXDR.Void do + @moduledoc """ + Representation of Stellar `Void` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: nil} + + defstruct [:value] + + @spec new(value :: nil) :: t() + def new(_val \\ nil), do: %__MODULE__{value: nil} + + @impl true + def encode_xdr(%__MODULE__{}) do + XDR.Void.encode_xdr(%XDR.Void{}) + end + + @impl true + def encode_xdr!(%__MODULE__{}) do + XDR.Void.encode_xdr!(%XDR.Void{}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Void.decode_xdr(bytes) do + {:ok, {nil, rest}} -> {:ok, {new(), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {nil, rest} = XDR.Void.decode_xdr!(bytes) + {new(), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/color.ex b/spec/output/generator_spec_elixir/test.x/color.ex new file mode 100644 index 000000000..80c0795df --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/color.ex @@ -0,0 +1,59 @@ +defmodule MyXDR.Color do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Color` type. + """ + + @behaviour XDR.Declaration + + @declarations [ + RED: 0, + BLUE: 5, + GREEN: 6 + ] + + @enum_spec %XDR.Enum{declarations: @declarations, identifier: nil} + + @type t :: %__MODULE__{identifier: atom()} + + defstruct [:identifier] + + @spec new(type :: atom()) :: t() + def new(type \\ :RED), do: %__MODULE__{identifier: type} + + @impl true + def encode_xdr(%__MODULE__{identifier: type}) do + @declarations + |> XDR.Enum.new(type) + |> XDR.Enum.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{identifier: type}) do + @declarations + |> XDR.Enum.new(type) + |> XDR.Enum.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, spec \\ @enum_spec) + + def decode_xdr(bytes, spec) do + case XDR.Enum.decode_xdr(bytes, spec) do + {:ok, {%XDR.Enum{identifier: type}, rest}} -> {:ok, {new(type), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @enum_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.Enum{identifier: type}, rest} = XDR.Enum.decode_xdr!(bytes, spec) + {new(type), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/has_stuff.ex b/spec/output/generator_spec_elixir/test.x/has_stuff.ex new file mode 100644 index 000000000..48c379773 --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/has_stuff.ex @@ -0,0 +1,66 @@ +defmodule MyXDR.HasStuff do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `HasStuff` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.{ + LotsOfMyStructs + } + + @struct_spec XDR.Struct.new( + data: LotsOfMyStructs + ) + + @type data_type :: LotsOfMyStructs.t() + + @type t :: %__MODULE__{data: data_type()} + + defstruct [:data] + + @spec new(data :: data_type()) :: t() + def new( + %LotsOfMyStructs{} = data + ), + do: %__MODULE__{data: data} + + @impl true + def encode_xdr(%__MODULE__{data: data}) do + [data: data] + |> XDR.Struct.new() + |> XDR.Struct.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{data: data}) do + [data: data] + |> XDR.Struct.new() + |> XDR.Struct.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, struct \\ @struct_spec) + + def decode_xdr(bytes, struct) do + case XDR.Struct.decode_xdr(bytes, struct) do + {:ok, {%XDR.Struct{components: [data: data]}, rest}} -> + {:ok, {new(data), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, struct \\ @struct_spec) + + def decode_xdr!(bytes, struct) do + {%XDR.Struct{components: [data: data]}, rest} = + XDR.Struct.decode_xdr!(bytes, struct) + {new(data), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/hash.ex b/spec/output/generator_spec_elixir/test.x/hash.ex new file mode 100644 index 000000000..ccbfb3489 --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/hash.ex @@ -0,0 +1,53 @@ +defmodule MyXDR.Hash do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Hash` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.Opaque32 + + @type t :: %__MODULE__{value: binary()} + + defstruct [:value] + + @spec new(value :: binary()) :: t() + def new(value), do: %__MODULE__{value: value} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + value + |> Opaque32.new() + |> Opaque32.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + value + |> Opaque32.new() + |> Opaque32.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case Opaque32.decode_xdr(bytes) do + {:ok, {%Opaque32{opaque: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%Opaque32{opaque: value}, rest} = Opaque32.decode_xdr!(bytes) + {new(value), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/hashes1.ex b/spec/output/generator_spec_elixir/test.x/hashes1.ex new file mode 100644 index 000000000..f9598d0ba --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/hashes1.ex @@ -0,0 +1,59 @@ +defmodule MyXDR.Hashes1 do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Hashes1` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.Hash + + @length 12 + + @array_type Hash + + @array_spec %{type: @array_type, length: @length} + + @type t :: %__MODULE__{items: list(Hash.t())} + + defstruct [:items] + + @spec new(items :: list(Hash.t())) :: t() + def new(items), do: %__MODULE__{items: items} + + @impl true + def encode_xdr(%__MODULE__{items: items}) do + items + |> XDR.FixedArray.new(@array_type, @length) + |> XDR.FixedArray.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{items: items}) do + items + |> XDR.FixedArray.new(@array_type, @length) + |> XDR.FixedArray.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, spec \\ @array_spec) + + def decode_xdr(bytes, spec) do + case XDR.FixedArray.decode_xdr(bytes, spec) do + {:ok, {items, rest}} -> {:ok, {new(items), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @array_spec) + + def decode_xdr!(bytes, spec) do + {items, rest} = XDR.FixedArray.decode_xdr!(bytes, spec) + {new(items), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/hashes2.ex b/spec/output/generator_spec_elixir/test.x/hashes2.ex new file mode 100644 index 000000000..d03319f9e --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/hashes2.ex @@ -0,0 +1,59 @@ +defmodule MyXDR.Hashes2 do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Hashes2` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.Hash + + @max_length 12 + + @array_type Hash + + @array_spec %{type: @array_type, max_length: @max_length} + + @type t :: %__MODULE__{items: list(Hash.t())} + + defstruct [:items] + + @spec new(items :: list(Hash.t())) :: t() + def new(items), do: %__MODULE__{items: items} + + @impl true + def encode_xdr(%__MODULE__{items: items}) do + items + |> XDR.VariableArray.new(@array_type, @max_length) + |> XDR.VariableArray.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{items: items}) do + items + |> XDR.VariableArray.new(@array_type, @max_length) + |> XDR.VariableArray.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, spec \\ @array_spec) + + def decode_xdr(bytes, spec) do + case XDR.VariableArray.decode_xdr(bytes, spec) do + {:ok, {items, rest}} -> {:ok, {new(items), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @array_spec) + + def decode_xdr!(bytes, spec) do + {items, rest} = XDR.VariableArray.decode_xdr!(bytes, spec) + {new(items), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/hashes3.ex b/spec/output/generator_spec_elixir/test.x/hashes3.ex new file mode 100644 index 000000000..76be0897e --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/hashes3.ex @@ -0,0 +1,57 @@ +defmodule MyXDR.Hashes3 do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Hashes3` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.Hash + + @array_type Hash + + @array_spec %{type: @array_type} + + @type t :: %__MODULE__{items: list(Hash.t())} + + defstruct [:items] + + @spec new(items :: list(Hash.t())) :: t() + def new(items), do: %__MODULE__{items: items} + + @impl true + def encode_xdr(%__MODULE__{items: items}) do + items + |> XDR.VariableArray.new(@array_type) + |> XDR.VariableArray.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{items: items}) do + items + |> XDR.VariableArray.new(@array_type) + |> XDR.VariableArray.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, spec \\ @array_spec) + + def decode_xdr(bytes, spec) do + case XDR.VariableArray.decode_xdr(bytes, spec) do + {:ok, {items, rest}} -> {:ok, {new(items), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @array_spec) + + def decode_xdr!(bytes, spec) do + {items, rest} = XDR.VariableArray.decode_xdr!(bytes, spec) + {new(items), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/int1.ex b/spec/output/generator_spec_elixir/test.x/int1.ex new file mode 100644 index 000000000..cce9dcb86 --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/int1.ex @@ -0,0 +1,47 @@ +defmodule MyXDR.Int1 do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Int1` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: integer()} + + defstruct [:datum] + + @spec new(value :: integer()) :: t() + def new(value), do: %__MODULE__{datum: value} + + @impl true + def encode_xdr(%__MODULE__{datum: value}) do + XDR.Int.encode_xdr(%XDR.Int{datum: value}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: value}) do + XDR.Int.encode_xdr!(%XDR.Int{datum: value}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Int.decode_xdr(bytes) do + {:ok, {%XDR.Int{datum: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Int{datum: value}, rest} = XDR.Int.decode_xdr!(bytes) + {new(value), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/int2.ex b/spec/output/generator_spec_elixir/test.x/int2.ex new file mode 100644 index 000000000..448877b56 --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/int2.ex @@ -0,0 +1,47 @@ +defmodule MyXDR.Int2 do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Int2` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: integer()} + + defstruct [:datum] + + @spec new(value :: integer()) :: t() + def new(value), do: %__MODULE__{datum: value} + + @impl true + def encode_xdr(%__MODULE__{datum: value}) do + XDR.HyperInt.encode_xdr(%XDR.HyperInt{datum: value}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: value}) do + XDR.HyperInt.encode_xdr!(%XDR.HyperInt{datum: value}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.HyperInt.decode_xdr(bytes) do + {:ok, {%XDR.HyperInt{datum: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.HyperInt{datum: value}, rest} = XDR.HyperInt.decode_xdr!(bytes) + {new(value), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/int3.ex b/spec/output/generator_spec_elixir/test.x/int3.ex new file mode 100644 index 000000000..69a976817 --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/int3.ex @@ -0,0 +1,47 @@ +defmodule MyXDR.Int3 do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Int3` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: non_neg_integer()} + + defstruct [:datum] + + @spec new(value :: non_neg_integer()) :: t() + def new(value), do: %__MODULE__{datum: value} + + @impl true + def encode_xdr(%__MODULE__{datum: value}) do + XDR.UInt.encode_xdr(%XDR.UInt{datum: value}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: value}) do + XDR.UInt.encode_xdr!(%XDR.UInt{datum: value}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.UInt.decode_xdr(bytes) do + {:ok, {%XDR.UInt{datum: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.UInt{datum: value}, rest} = XDR.UInt.decode_xdr!(bytes) + {new(value), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/int4.ex b/spec/output/generator_spec_elixir/test.x/int4.ex new file mode 100644 index 000000000..7ecf8d28f --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/int4.ex @@ -0,0 +1,47 @@ +defmodule MyXDR.Int4 do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Int4` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: non_neg_integer()} + + defstruct [:datum] + + @spec new(value :: non_neg_integer()) :: t() + def new(value), do: %__MODULE__{datum: value} + + @impl true + def encode_xdr(%__MODULE__{datum: value}) do + XDR.HyperUInt.encode_xdr(%XDR.HyperUInt{datum: value}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: value}) do + XDR.HyperUInt.encode_xdr!(%XDR.HyperUInt{datum: value}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.HyperUInt.decode_xdr(bytes) do + {:ok, {%XDR.HyperUInt{datum: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.HyperUInt{datum: value}, rest} = XDR.HyperUInt.decode_xdr!(bytes) + {new(value), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/lots_of_my_structs.ex b/spec/output/generator_spec_elixir/test.x/lots_of_my_structs.ex new file mode 100644 index 000000000..b1b87b08f --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/lots_of_my_structs.ex @@ -0,0 +1,66 @@ +defmodule MyXDR.LotsOfMyStructs do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `LotsOfMyStructs` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.{ + MyStructList + } + + @struct_spec XDR.Struct.new( + members: MyStructList + ) + + @type members_type :: MyStructList.t() + + @type t :: %__MODULE__{members: members_type()} + + defstruct [:members] + + @spec new(members :: members_type()) :: t() + def new( + %MyStructList{} = members + ), + do: %__MODULE__{members: members} + + @impl true + def encode_xdr(%__MODULE__{members: members}) do + [members: members] + |> XDR.Struct.new() + |> XDR.Struct.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{members: members}) do + [members: members] + |> XDR.Struct.new() + |> XDR.Struct.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, struct \\ @struct_spec) + + def decode_xdr(bytes, struct) do + case XDR.Struct.decode_xdr(bytes, struct) do + {:ok, {%XDR.Struct{components: [members: members]}, rest}} -> + {:ok, {new(members), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, struct \\ @struct_spec) + + def decode_xdr!(bytes, struct) do + {%XDR.Struct{components: [members: members]}, rest} = + XDR.Struct.decode_xdr!(bytes, struct) + {new(members), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/my_struct.ex b/spec/output/generator_spec_elixir/test.x/my_struct.ex new file mode 100644 index 000000000..f4c2aa8c1 --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/my_struct.ex @@ -0,0 +1,90 @@ +defmodule MyXDR.MyStruct do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `MyStruct` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.{ + Uint512, + OptHash1, + Int1, + UInt, + Float, + DoubleFloat, + Bool + } + + @struct_spec XDR.Struct.new( + field1: Uint512, + field2: OptHash1, + field3: Int1, + field4: UInt, + field5: Float, + field6: DoubleFloat, + field7: Bool + ) + + @type field1_type :: Uint512.t() + @type field2_type :: OptHash1.t() + @type field3_type :: Int1.t() + @type field4_type :: UInt.t() + @type field5_type :: Float.t() + @type field6_type :: DoubleFloat.t() + @type field7_type :: Bool.t() + + @type t :: %__MODULE__{field1: field1_type(), field2: field2_type(), field3: field3_type(), field4: field4_type(), field5: field5_type(), field6: field6_type(), field7: field7_type()} + + defstruct [:field1, :field2, :field3, :field4, :field5, :field6, :field7] + + @spec new(field1 :: field1_type(), field2 :: field2_type(), field3 :: field3_type(), field4 :: field4_type(), field5 :: field5_type(), field6 :: field6_type(), field7 :: field7_type()) :: t() + def new( + %Uint512{} = field1, + %OptHash1{} = field2, + %Int1{} = field3, + %UInt{} = field4, + %Float{} = field5, + %DoubleFloat{} = field6, + %Bool{} = field7 + ), + do: %__MODULE__{field1: field1, field2: field2, field3: field3, field4: field4, field5: field5, field6: field6, field7: field7} + + @impl true + def encode_xdr(%__MODULE__{field1: field1, field2: field2, field3: field3, field4: field4, field5: field5, field6: field6, field7: field7}) do + [field1: field1, field2: field2, field3: field3, field4: field4, field5: field5, field6: field6, field7: field7] + |> XDR.Struct.new() + |> XDR.Struct.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{field1: field1, field2: field2, field3: field3, field4: field4, field5: field5, field6: field6, field7: field7}) do + [field1: field1, field2: field2, field3: field3, field4: field4, field5: field5, field6: field6, field7: field7] + |> XDR.Struct.new() + |> XDR.Struct.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, struct \\ @struct_spec) + + def decode_xdr(bytes, struct) do + case XDR.Struct.decode_xdr(bytes, struct) do + {:ok, {%XDR.Struct{components: [field1: field1, field2: field2, field3: field3, field4: field4, field5: field5, field6: field6, field7: field7]}, rest}} -> + {:ok, {new(field1, field2, field3, field4, field5, field6, field7), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, struct \\ @struct_spec) + + def decode_xdr!(bytes, struct) do + {%XDR.Struct{components: [field1: field1, field2: field2, field3: field3, field4: field4, field5: field5, field6: field6, field7: field7]}, rest} = + XDR.Struct.decode_xdr!(bytes, struct) + {new(field1, field2, field3, field4, field5, field6, field7), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/my_struct_list.ex b/spec/output/generator_spec_elixir/test.x/my_struct_list.ex new file mode 100644 index 000000000..590d68c1f --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/my_struct_list.ex @@ -0,0 +1,57 @@ +defmodule MyXDR.MyStructList do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `MyStructList` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.MyStruct + + @array_type MyStruct + + @array_spec %{type: @array_type} + + @type t :: %__MODULE__{items: list(MyStruct.t())} + + defstruct [:items] + + @spec new(items :: list(MyStruct.t())) :: t() + def new(items), do: %__MODULE__{items: items} + + @impl true + def encode_xdr(%__MODULE__{items: items}) do + items + |> XDR.VariableArray.new(@array_type) + |> XDR.VariableArray.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{items: items}) do + items + |> XDR.VariableArray.new(@array_type) + |> XDR.VariableArray.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, spec \\ @array_spec) + + def decode_xdr(bytes, spec) do + case XDR.VariableArray.decode_xdr(bytes, spec) do + {:ok, {items, rest}} -> {:ok, {new(items), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @array_spec) + + def decode_xdr!(bytes, spec) do + {items, rest} = XDR.VariableArray.decode_xdr!(bytes, spec) + {new(items), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/nester.ex b/spec/output/generator_spec_elixir/test.x/nester.ex new file mode 100644 index 000000000..604732a7e --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/nester.ex @@ -0,0 +1,74 @@ +defmodule MyXDR.Nester do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Nester` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.{ + NesterNestedEnum, + NesterNestedStruct, + NesterNestedUnion + } + + @struct_spec XDR.Struct.new( + nested_enum: NesterNestedEnum, + nested_struct: NesterNestedStruct, + nested_union: NesterNestedUnion + ) + + @type nested_enum_type :: NesterNestedEnum.t() + @type nested_struct_type :: NesterNestedStruct.t() + @type nested_union_type :: NesterNestedUnion.t() + + @type t :: %__MODULE__{nested_enum: nested_enum_type(), nested_struct: nested_struct_type(), nested_union: nested_union_type()} + + defstruct [:nested_enum, :nested_struct, :nested_union] + + @spec new(nested_enum :: nested_enum_type(), nested_struct :: nested_struct_type(), nested_union :: nested_union_type()) :: t() + def new( + %NesterNestedEnum{} = nested_enum, + %NesterNestedStruct{} = nested_struct, + %NesterNestedUnion{} = nested_union + ), + do: %__MODULE__{nested_enum: nested_enum, nested_struct: nested_struct, nested_union: nested_union} + + @impl true + def encode_xdr(%__MODULE__{nested_enum: nested_enum, nested_struct: nested_struct, nested_union: nested_union}) do + [nested_enum: nested_enum, nested_struct: nested_struct, nested_union: nested_union] + |> XDR.Struct.new() + |> XDR.Struct.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{nested_enum: nested_enum, nested_struct: nested_struct, nested_union: nested_union}) do + [nested_enum: nested_enum, nested_struct: nested_struct, nested_union: nested_union] + |> XDR.Struct.new() + |> XDR.Struct.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, struct \\ @struct_spec) + + def decode_xdr(bytes, struct) do + case XDR.Struct.decode_xdr(bytes, struct) do + {:ok, {%XDR.Struct{components: [nested_enum: nested_enum, nested_struct: nested_struct, nested_union: nested_union]}, rest}} -> + {:ok, {new(nested_enum, nested_struct, nested_union), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, struct \\ @struct_spec) + + def decode_xdr!(bytes, struct) do + {%XDR.Struct{components: [nested_enum: nested_enum, nested_struct: nested_struct, nested_union: nested_union]}, rest} = + XDR.Struct.decode_xdr!(bytes, struct) + {new(nested_enum, nested_struct, nested_union), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/nester_nested_enum.ex b/spec/output/generator_spec_elixir/test.x/nester_nested_enum.ex new file mode 100644 index 000000000..de887c08c --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/nester_nested_enum.ex @@ -0,0 +1,58 @@ +defmodule MyXDR.NesterNestedEnum do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `NesterNestedEnum` type. + """ + + @behaviour XDR.Declaration + + @declarations [ + BLAH_1: 0, + BLAH_2: 1 + ] + + @enum_spec %XDR.Enum{declarations: @declarations, identifier: nil} + + @type t :: %__MODULE__{identifier: atom()} + + defstruct [:identifier] + + @spec new(type :: atom()) :: t() + def new(type \\ :BLAH_1), do: %__MODULE__{identifier: type} + + @impl true + def encode_xdr(%__MODULE__{identifier: type}) do + @declarations + |> XDR.Enum.new(type) + |> XDR.Enum.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{identifier: type}) do + @declarations + |> XDR.Enum.new(type) + |> XDR.Enum.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, spec \\ @enum_spec) + + def decode_xdr(bytes, spec) do + case XDR.Enum.decode_xdr(bytes, spec) do + {:ok, {%XDR.Enum{identifier: type}, rest}} -> {:ok, {new(type), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @enum_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.Enum{identifier: type}, rest} = XDR.Enum.decode_xdr!(bytes, spec) + {new(type), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/nester_nested_struct.ex b/spec/output/generator_spec_elixir/test.x/nester_nested_struct.ex new file mode 100644 index 000000000..8ecb9c3e7 --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/nester_nested_struct.ex @@ -0,0 +1,66 @@ +defmodule MyXDR.NesterNestedStruct do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `NesterNestedStruct` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.{ + Int + } + + @struct_spec XDR.Struct.new( + blah: Int + ) + + @type blah_type :: Int.t() + + @type t :: %__MODULE__{blah: blah_type()} + + defstruct [:blah] + + @spec new(blah :: blah_type()) :: t() + def new( + %Int{} = blah + ), + do: %__MODULE__{blah: blah} + + @impl true + def encode_xdr(%__MODULE__{blah: blah}) do + [blah: blah] + |> XDR.Struct.new() + |> XDR.Struct.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{blah: blah}) do + [blah: blah] + |> XDR.Struct.new() + |> XDR.Struct.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, struct \\ @struct_spec) + + def decode_xdr(bytes, struct) do + case XDR.Struct.decode_xdr(bytes, struct) do + {:ok, {%XDR.Struct{components: [blah: blah]}, rest}} -> + {:ok, {new(blah), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, struct \\ @struct_spec) + + def decode_xdr!(bytes, struct) do + {%XDR.Struct{components: [blah: blah]}, rest} = + XDR.Struct.decode_xdr!(bytes, struct) + {new(blah), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/nester_nested_union.ex b/spec/output/generator_spec_elixir/test.x/nester_nested_union.ex new file mode 100644 index 000000000..e6fca7277 --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/nester_nested_union.ex @@ -0,0 +1,74 @@ +defmodule MyXDR.NesterNestedUnion do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `NesterNestedUnion` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.{ + Color, + Void, + Int + } + + @arms [ + RED: Void, + default: Int + ] + + @type value :: + Void.t() + | Int.t() + | any() + + @type t :: %__MODULE__{value: value(), type: Color.t()} + + defstruct [:value, :type] + + @spec new(value :: value(), type :: Color.t()) :: t() + def new(value, %Color{} = type), do: %__MODULE__{value: value, type: type} + + @impl true + def encode_xdr(%__MODULE__{value: value, type: type}) do + type + |> XDR.Union.new(@arms, value) + |> XDR.Union.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{value: value, type: type}) do + type + |> XDR.Union.new(@arms, value) + |> XDR.Union.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, spec \\ union_spec()) + + def decode_xdr(bytes, spec) do + case XDR.Union.decode_xdr(bytes, spec) do + {:ok, {{type, value}, rest}} -> {:ok, {new(value, type), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ union_spec()) + + def decode_xdr!(bytes, spec) do + {{type, value}, rest} = XDR.Union.decode_xdr!(bytes, spec) + {new(value, type), rest} + end + + @spec union_spec() :: XDR.Union.t() + defp union_spec do + nil + |> Color.new() + |> XDR.Union.new(@arms) + end +end diff --git a/spec/output/generator_spec_elixir/test.x/opaque32.ex b/spec/output/generator_spec_elixir/test.x/opaque32.ex new file mode 100644 index 000000000..6810a6966 --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/opaque32.ex @@ -0,0 +1,51 @@ +defmodule MyXDR.Opaque32 do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Opaque32` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{opaque: binary()} + + defstruct [:opaque] + + @length 32 + + @opaque_spec XDR.FixedOpaque.new(nil, @length) + + @spec new(opaque :: binary()) :: t() + def new(opaque), do: %__MODULE__{opaque: opaque} + + @impl true + def encode_xdr(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def encode_xdr!(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr!(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def decode_xdr(bytes, spec \\ @opaque_spec) + + def decode_xdr(bytes, spec) do + case XDR.FixedOpaque.decode_xdr(bytes, spec) do + {:ok, {%XDR.FixedOpaque{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @opaque_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.FixedOpaque{opaque: opaque}, rest} = XDR.FixedOpaque.decode_xdr!(bytes, spec) + {new(opaque), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/opaque64.ex b/spec/output/generator_spec_elixir/test.x/opaque64.ex new file mode 100644 index 000000000..b9a38092a --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/opaque64.ex @@ -0,0 +1,51 @@ +defmodule MyXDR.Opaque64 do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Opaque64` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{opaque: binary()} + + defstruct [:opaque] + + @length 64 + + @opaque_spec XDR.FixedOpaque.new(nil, @length) + + @spec new(opaque :: binary()) :: t() + def new(opaque), do: %__MODULE__{opaque: opaque} + + @impl true + def encode_xdr(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def encode_xdr!(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr!(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def decode_xdr(bytes, spec \\ @opaque_spec) + + def decode_xdr(bytes, spec) do + case XDR.FixedOpaque.decode_xdr(bytes, spec) do + {:ok, {%XDR.FixedOpaque{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @opaque_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.FixedOpaque{opaque: opaque}, rest} = XDR.FixedOpaque.decode_xdr!(bytes, spec) + {new(opaque), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/opt_hash1.ex b/spec/output/generator_spec_elixir/test.x/opt_hash1.ex new file mode 100644 index 000000000..b588e1006 --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/opt_hash1.ex @@ -0,0 +1,61 @@ +defmodule MyXDR.OptHash1 do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `OptHash1` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.Hash + + @optional_spec XDR.Optional.new(Hash) + + @type hash :: Hash.t() | nil + + @type t :: %__MODULE__{hash: hash()} + + defstruct [:hash] + + @spec new(hash :: hash()) :: t() + def new(hash \\ nil), do: %__MODULE__{hash: hash} + + @impl true + def encode_xdr(%__MODULE__{hash: hash}) do + hash + |> XDR.Optional.new() + |> XDR.Optional.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{hash: hash}) do + hash + |> XDR.Optional.new() + |> XDR.Optional.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, optional_spec \\ @optional_spec) + + def decode_xdr(bytes, optional_spec) do + case XDR.Optional.decode_xdr(bytes, optional_spec) do + {:ok, {%XDR.Optional{type: hash}, rest}} -> {:ok, {new(hash), rest}} + {:ok, {nil, rest}} -> {:ok, {new(), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, optional_spec \\ @optional_spec) + + def decode_xdr!(bytes, optional_spec) do + case XDR.Optional.decode_xdr!(bytes, optional_spec) do + {%XDR.Optional{type: hash}, rest} -> {new(hash), rest} + {nil, rest} -> {new(), rest} + end + end + +end diff --git a/spec/output/generator_spec_elixir/test.x/opt_hash2.ex b/spec/output/generator_spec_elixir/test.x/opt_hash2.ex new file mode 100644 index 000000000..1fe8f376a --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/opt_hash2.ex @@ -0,0 +1,61 @@ +defmodule MyXDR.OptHash2 do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `OptHash2` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.Hash + + @optional_spec XDR.Optional.new(Hash) + + @type hash :: Hash.t() | nil + + @type t :: %__MODULE__{hash: hash()} + + defstruct [:hash] + + @spec new(hash :: hash()) :: t() + def new(hash \\ nil), do: %__MODULE__{hash: hash} + + @impl true + def encode_xdr(%__MODULE__{hash: hash}) do + hash + |> XDR.Optional.new() + |> XDR.Optional.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{hash: hash}) do + hash + |> XDR.Optional.new() + |> XDR.Optional.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, optional_spec \\ @optional_spec) + + def decode_xdr(bytes, optional_spec) do + case XDR.Optional.decode_xdr(bytes, optional_spec) do + {:ok, {%XDR.Optional{type: hash}, rest}} -> {:ok, {new(hash), rest}} + {:ok, {nil, rest}} -> {:ok, {new(), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, optional_spec \\ @optional_spec) + + def decode_xdr!(bytes, optional_spec) do + case XDR.Optional.decode_xdr!(bytes, optional_spec) do + {%XDR.Optional{type: hash}, rest} -> {new(hash), rest} + {nil, rest} -> {new(), rest} + end + end + +end diff --git a/spec/output/generator_spec_elixir/test.x/str.ex b/spec/output/generator_spec_elixir/test.x/str.ex new file mode 100644 index 000000000..5317acebe --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/str.ex @@ -0,0 +1,53 @@ +defmodule MyXDR.Str do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Str` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: String.t()} + + defstruct [:value] + + @max_length 64 + + @spec new(value :: String.t()) :: t() + def new(value), do: %__MODULE__{value: value} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + value + |> XDR.String.new(@max_length) + |> XDR.String.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + value + |> XDR.String.new(@max_length) + |> XDR.String.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.String.decode_xdr(bytes) do + {:ok, {%XDR.String{string: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.String{string: value}, rest} = XDR.String.decode_xdr!(bytes) + {new(value), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/str2.ex b/spec/output/generator_spec_elixir/test.x/str2.ex new file mode 100644 index 000000000..ae8e9e271 --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/str2.ex @@ -0,0 +1,51 @@ +defmodule MyXDR.Str2 do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Str2` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: String.t()} + + defstruct [:value] + + @spec new(value :: String.t()) :: t() + def new(value), do: %__MODULE__{value: value} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + value + |> XDR.String.new() + |> XDR.String.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + value + |> XDR.String.new() + |> XDR.String.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.String.decode_xdr(bytes) do + {:ok, {%XDR.String{string: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.String{string: value}, rest} = XDR.String.decode_xdr!(bytes) + {new(value), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/uint512.ex b/spec/output/generator_spec_elixir/test.x/uint512.ex new file mode 100644 index 000000000..f68066f3e --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/uint512.ex @@ -0,0 +1,53 @@ +defmodule MyXDR.Uint512 do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Uint512` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.Opaque64 + + @type t :: %__MODULE__{value: binary()} + + defstruct [:value] + + @spec new(value :: binary()) :: t() + def new(value), do: %__MODULE__{value: value} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + value + |> Opaque64.new() + |> Opaque64.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + value + |> Opaque64.new() + |> Opaque64.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case Opaque64.decode_xdr(bytes) do + {:ok, {%Opaque64{opaque: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%Opaque64{opaque: value}, rest} = Opaque64.decode_xdr!(bytes) + {new(value), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/uint513.ex b/spec/output/generator_spec_elixir/test.x/uint513.ex new file mode 100644 index 000000000..8ab304b73 --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/uint513.ex @@ -0,0 +1,53 @@ +defmodule MyXDR.Uint513 do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Uint513` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.VariableOpaque64 + + @type t :: %__MODULE__{value: binary()} + + defstruct [:value] + + @spec new(value :: binary()) :: t() + def new(value), do: %__MODULE__{value: value} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + value + |> VariableOpaque64.new() + |> VariableOpaque64.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + value + |> VariableOpaque64.new() + |> VariableOpaque64.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case VariableOpaque64.decode_xdr(bytes) do + {:ok, {%VariableOpaque64{opaque: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%VariableOpaque64{opaque: value}, rest} = VariableOpaque64.decode_xdr!(bytes) + {new(value), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/uint514.ex b/spec/output/generator_spec_elixir/test.x/uint514.ex new file mode 100644 index 000000000..5ce4981f2 --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/uint514.ex @@ -0,0 +1,53 @@ +defmodule MyXDR.Uint514 do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Uint514` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.VariableOpaque + + @type t :: %__MODULE__{value: binary()} + + defstruct [:value] + + @spec new(value :: binary()) :: t() + def new(value), do: %__MODULE__{value: value} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + value + |> VariableOpaque.new() + |> VariableOpaque.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + value + |> VariableOpaque.new() + |> VariableOpaque.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case VariableOpaque.decode_xdr(bytes) do + {:ok, {%VariableOpaque{opaque: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%VariableOpaque{opaque: value}, rest} = VariableOpaque.decode_xdr!(bytes) + {new(value), rest} + end +end diff --git a/spec/output/generator_spec_elixir/test.x/variable_opaque64.ex b/spec/output/generator_spec_elixir/test.x/variable_opaque64.ex new file mode 100644 index 000000000..257176546 --- /dev/null +++ b/spec/output/generator_spec_elixir/test.x/variable_opaque64.ex @@ -0,0 +1,51 @@ +defmodule MyXDR.VariableOpaque64 do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `VariableOpaque64` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{opaque: binary()} + + defstruct [:opaque] + + @max_size 64 + + @opaque_spec XDR.VariableOpaque.new(nil, @max_size) + + @spec new(opaque :: binary()) :: t() + def new(opaque), do: %__MODULE__{opaque: opaque} + + @impl true + def encode_xdr(%__MODULE__{opaque: opaque}) do + XDR.VariableOpaque.encode_xdr(%XDR.VariableOpaque{opaque: opaque, max_size: @max_size}) + end + + @impl true + def encode_xdr!(%__MODULE__{opaque: opaque}) do + XDR.VariableOpaque.encode_xdr!(%XDR.VariableOpaque{opaque: opaque, max_size: @max_size}) + end + + @impl true + def decode_xdr(bytes, spec \\ @opaque_spec) + + def decode_xdr(bytes, spec) do + case XDR.VariableOpaque.decode_xdr(bytes, spec) do + {:ok, {%XDR.VariableOpaque{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @opaque_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.VariableOpaque{opaque: opaque}, rest} = XDR.VariableOpaque.decode_xdr!(bytes, spec) + {new(opaque), rest} + end +end diff --git a/spec/output/generator_spec_elixir/union.x/MyXDR_generated.ex b/spec/output/generator_spec_elixir/union.x/MyXDR_generated.ex deleted file mode 100644 index ddcb67713..000000000 --- a/spec/output/generator_spec_elixir/union.x/MyXDR_generated.ex +++ /dev/null @@ -1,108 +0,0 @@ -defmodule MyXDR do - @moduledoc """ - Automatically generated by xdrgen - DO NOT EDIT or your changes may be overwritten - - Target implementation: exdr at https://hex.pm/packages/exdr - """ - - use XDR.Base - - comment ~S""" - === xdr source ============================================================ - - typedef int Error; - - =========================================================================== - """ - define_type("Error", Int) - - comment ~S""" - === xdr source ============================================================ - - typedef int Multi; - - =========================================================================== - """ - define_type("Multi", Int) - - comment ~S""" - === xdr source ============================================================ - - enum UnionKey { - ERROR, - MULTI - }; - - =========================================================================== - """ - define_type("UnionKey", Enum, - error: 0, - multi: 1 - ) - - comment ~S""" - === xdr source ============================================================ - - union MyUnion switch (UnionKey type) - { - case ERROR: - Error error; - case MULTI: - Multi things<>; - - - }; - - =========================================================================== - """ - define_type("MyUnion", Union, - switch_type: "UnionKey", - switch_name: :type, - switches: [ - {:error, :error}, - {:multi, :things}, - ], - arms: [ - error: "Error", - things: build_type(VariableArray, max_length: 2147483647, type: "Multi"), - ] - ) - - comment ~S""" - === xdr source ============================================================ - - union IntUnion switch (int type) - { - case 0: - Error error; - case 1: - Multi things<>; - - }; - - =========================================================================== - """ - define_type("IntUnion", Union, - switch_type: build_type(Int), - switch_name: :type, - switches: [ - {0, :error}, - {1, :things}, - ], - arms: [ - error: "Error", - things: build_type(VariableArray, max_length: 2147483647, type: "Multi"), - ] - ) - - comment ~S""" - === xdr source ============================================================ - - typedef IntUnion IntUnion2; - - =========================================================================== - """ - define_type("IntUnion2", "IntUnion") - -end diff --git a/spec/output/generator_spec_elixir/union.x/base.ex b/spec/output/generator_spec_elixir/union.x/base.ex new file mode 100644 index 000000000..3164dc83e --- /dev/null +++ b/spec/output/generator_spec_elixir/union.x/base.ex @@ -0,0 +1,439 @@ +defmodule MyXDR.Int do + @moduledoc """ + Representation of Stellar `Int` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: integer()} + + defstruct [:datum] + + @spec new(int :: integer()) :: t() + def new(int), do: %__MODULE__{datum: int} + + @impl true + def encode_xdr(%__MODULE__{datum: int}) do + XDR.Int.encode_xdr(%XDR.Int{datum: int}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: int}) do + XDR.Int.encode_xdr!(%XDR.Int{datum: int}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Int.decode_xdr(bytes) do + {:ok, {%XDR.Int{datum: int}, rest}} -> {:ok, {new(int), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Int{datum: int}, rest} = XDR.Int.decode_xdr!(bytes) + {new(int), rest} + end +end + +defmodule MyXDR.Uint do + @moduledoc """ + Representation of Stellar `Uint` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: non_neg_integer()} + + defstruct [:datum] + + @spec new(uint :: non_neg_integer()) :: t() + def new(uint), do: %__MODULE__{datum: uint} + + @impl true + def encode_xdr(%__MODULE__{datum: uint}) do + XDR.UInt.encode_xdr(%XDR.UInt{datum: uint}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: uint}) do + XDR.UInt.encode_xdr!(%XDR.UInt{datum: uint}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.UInt.decode_xdr(bytes) do + {:ok, {%XDR.UInt{datum: uint}, rest}} -> {:ok, {new(uint), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.UInt{datum: uint}, rest} = XDR.UInt.decode_xdr!(bytes) + {new(uint), rest} + end +end + +defmodule MyXDR.Float do + @moduledoc """ + Representation of Stellar `Float` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{float: float()} + + defstruct [:float] + + @spec new(float :: float()) :: t() + def new(float), do: %__MODULE__{float: float} + + @impl true + def encode_xdr(%__MODULE__{float: float}) do + XDR.Float.encode_xdr(%XDR.Float{float: float}) + end + + @impl true + def encode_xdr!(%__MODULE__{float: float}) do + XDR.Float.encode_xdr!(%XDR.Float{float: float}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Float.decode_xdr(bytes) do + {:ok, {%XDR.Float{float: float}, rest}} -> {:ok, {new(float), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Float{float: float}, rest} = XDR.Float.decode_xdr!(bytes) + {new(float), rest} + end +end + +defmodule MyXDR.DoubleFloat do + @moduledoc """ + Representation of Stellar `DoubleFloat` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{float: float()} + + defstruct [:float] + + @spec new(float :: float()) :: t() + def new(float), do: %__MODULE__{float: float} + + @impl true + def encode_xdr(%__MODULE__{float: float}) do + XDR.DoubleFloat.encode_xdr(%XDR.DoubleFloat{float: float}) + end + + @impl true + def encode_xdr!(%__MODULE__{float: float}) do + XDR.DoubleFloat.encode_xdr!(%XDR.DoubleFloat{float: float}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.DoubleFloat.decode_xdr(bytes) do + {:ok, {%XDR.DoubleFloat{float: float}, rest}} -> {:ok, {new(float), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.DoubleFloat{float: float}, rest} = XDR.DoubleFloat.decode_xdr!(bytes) + {new(float), rest} + end +end + +defmodule MyXDR.HyperUInt do + @moduledoc """ + Representation of Stellar `HyperUInt` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: non_neg_integer()} + + defstruct [:datum] + + @spec new(uint :: non_neg_integer()) :: t() + def new(uint), do: %__MODULE__{datum: uint} + + @impl true + def encode_xdr(%__MODULE__{datum: uint}) do + XDR.HyperUInt.encode_xdr(%XDR.HyperUInt{datum: uint}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: uint}) do + XDR.HyperUInt.encode_xdr!(%XDR.HyperUInt{datum: uint}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.HyperUInt.decode_xdr(bytes) do + {:ok, {%XDR.HyperUInt{datum: uint}, rest}} -> {:ok, {new(uint), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.HyperUInt{datum: uint}, rest} = XDR.HyperUInt.decode_xdr!(bytes) + {new(uint), rest} + end +end + +defmodule MyXDR.Bool do + @moduledoc """ + Representation of Stellar `Bool` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: boolean()} + + defstruct [:value] + + @spec new(value :: boolean()) :: t() + def new(val), do: %__MODULE__{value: val} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + XDR.Bool.encode_xdr(%XDR.Bool{identifier: value}) + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + XDR.Bool.encode_xdr!(%XDR.Bool{identifier: value}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Bool.decode_xdr(bytes) do + {:ok, {%XDR.Bool{identifier: val}, rest}} -> {:ok, {new(val), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Bool{identifier: val}, rest} = XDR.Bool.decode_xdr!(bytes) + {new(val), rest} + end +end + +defmodule MyXDR.String do + @moduledoc """ + Representation of Stellar `String` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: String.t()} + + defstruct [:value] + + @spec new(value :: String.t()) :: t() + def new(value), do: %__MODULE__{value: value} + + @impl true + def encode_xdr(%__MODULE__{value: value}) do + value + |> XDR.String.new() + |> XDR.String.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{value: value}) do + value + |> XDR.String.new() + |> XDR.String.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.String.decode_xdr(bytes) do + {:ok, {%XDR.String{string: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.String{string: value}, rest} = XDR.String.decode_xdr!(bytes) + {new(value), rest} + end +end + +defmodule MyXDR.FixedOpaque do + @moduledoc """ + Representation of Stellar `FixedOpaque` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{opaque: binary()} + + defstruct [:opaque] + + @length 4_294_967_295 + + @opaque_spec XDR.FixedOpaque.new(nil, @length) + + @spec new(opaque :: binary()) :: t() + def new(opaque), do: %__MODULE__{opaque: opaque} + + @impl true + def encode_xdr(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def encode_xdr!(%__MODULE__{opaque: opaque}) do + XDR.FixedOpaque.encode_xdr!(%XDR.FixedOpaque{opaque: opaque, length: @length}) + end + + @impl true + def decode_xdr(bytes, spec \\ @opaque_spec) + + def decode_xdr(bytes, spec) do + case XDR.FixedOpaque.decode_xdr(bytes, spec) do + {:ok, {%XDR.FixedOpaque{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @opaque_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.FixedOpaque{opaque: opaque}, rest} = XDR.FixedOpaque.decode_xdr!(bytes, spec) + {new(opaque), rest} + end +end + +defmodule MyXDR.VariableOpaque do + @moduledoc """ + Representation of Stellar `VariableOpaque` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{opaque: binary()} + + defstruct [:opaque] + + @opaque_spec XDR.VariableOpaque.new(nil) + + @spec new(opaque :: binary()) :: t() + def new(opaque), do: %__MODULE__{opaque: opaque} + + @impl true + def encode_xdr(%__MODULE__{opaque: opaque}) do + XDR.VariableOpaque.encode_xdr(%XDR.VariableOpaque{opaque: opaque}) + end + + @impl true + def encode_xdr!(%__MODULE__{opaque: opaque}) do + XDR.VariableOpaque.encode_xdr!(%XDR.VariableOpaque{opaque: opaque}) + end + + @impl true + def decode_xdr(bytes, spec \\ @opaque_spec) + + def decode_xdr(bytes, spec) do + case XDR.VariableOpaque.decode_xdr(bytes, spec) do + {:ok, {%XDR.VariableOpaque{opaque: opaque}, rest}} -> {:ok, {new(opaque), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @opaque_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.VariableOpaque{opaque: opaque}, rest} = XDR.VariableOpaque.decode_xdr!(bytes, spec) + {new(opaque), rest} + end +end + +defmodule MyXDR.Void do + @moduledoc """ + Representation of Stellar `Void` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{value: nil} + + defstruct [:value] + + @spec new(value :: nil) :: t() + def new(_val \\ nil), do: %__MODULE__{value: nil} + + @impl true + def encode_xdr(%__MODULE__{}) do + XDR.Void.encode_xdr(%XDR.Void{}) + end + + @impl true + def encode_xdr!(%__MODULE__{}) do + XDR.Void.encode_xdr!(%XDR.Void{}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Void.decode_xdr(bytes) do + {:ok, {nil, rest}} -> {:ok, {new(), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {nil, rest} = XDR.Void.decode_xdr!(bytes) + {new(), rest} + end +end diff --git a/spec/output/generator_spec_elixir/union.x/error.ex b/spec/output/generator_spec_elixir/union.x/error.ex new file mode 100644 index 000000000..43bd58362 --- /dev/null +++ b/spec/output/generator_spec_elixir/union.x/error.ex @@ -0,0 +1,47 @@ +defmodule MyXDR.Error do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Error` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: integer()} + + defstruct [:datum] + + @spec new(value :: integer()) :: t() + def new(value), do: %__MODULE__{datum: value} + + @impl true + def encode_xdr(%__MODULE__{datum: value}) do + XDR.Int.encode_xdr(%XDR.Int{datum: value}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: value}) do + XDR.Int.encode_xdr!(%XDR.Int{datum: value}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Int.decode_xdr(bytes) do + {:ok, {%XDR.Int{datum: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Int{datum: value}, rest} = XDR.Int.decode_xdr!(bytes) + {new(value), rest} + end +end diff --git a/spec/output/generator_spec_elixir/union.x/int_union.ex b/spec/output/generator_spec_elixir/union.x/int_union.ex new file mode 100644 index 000000000..eef96d507 --- /dev/null +++ b/spec/output/generator_spec_elixir/union.x/int_union.ex @@ -0,0 +1,75 @@ +defmodule MyXDR.IntUnion do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `IntUnion` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.{ + Int, + Error, + MultiList + } + + @arms %{ + 0 => Error, + 1 => MultiList + } + + @type value :: + Error.t() + | MultiList.t() + + @type t :: %__MODULE__{value: value(), type: integer()} + + defstruct [:value, :type] + + @spec new(value :: value(), type :: integer()) :: t() + def new(value, type), do: %__MODULE__{value: value, type: type} + + @impl true + def encode_xdr(%__MODULE__{value: value, type: type}) do + type + |> Int.new() + |> XDR.Union.new(@arms, value) + |> XDR.Union.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{value: value, type: type}) do + type + |> Int.new() + |> XDR.Union.new(@arms, value) + |> XDR.Union.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, spec \\ union_spec()) + + def decode_xdr(bytes, spec) do + case XDR.Union.decode_xdr(bytes, spec) do + {:ok, {{type, value}, rest}} -> {:ok, {new(value, type), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ union_spec()) + + def decode_xdr!(bytes, spec) do + {{type, value}, rest} = XDR.Union.decode_xdr!(bytes, spec) + {new(value, type), rest} + end + + @spec union_spec() :: XDR.Union.t() + defp union_spec do + 0 + |> Int.new() + |> XDR.Union.new(@arms) + end +end diff --git a/spec/output/generator_spec_elixir/union.x/int_union2.ex b/spec/output/generator_spec_elixir/union.x/int_union2.ex new file mode 100644 index 000000000..fb2103c3b --- /dev/null +++ b/spec/output/generator_spec_elixir/union.x/int_union2.ex @@ -0,0 +1,49 @@ +defmodule MyXDR.IntUnion2 do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `IntUnion2` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.IntUnion + + @type t :: %__MODULE__{int_union2: IntUnion.t()} + + defstruct [:int_union2] + + @spec new(int_union2 :: IntUnion.t()) :: t() + def new(%IntUnion{} = int_union2), do: %__MODULE__{int_union2: int_union2} + + @impl true + def encode_xdr(%__MODULE__{int_union2: int_union2}) do + IntUnion.encode_xdr(int_union2) + end + + @impl true + def encode_xdr!(%__MODULE__{int_union2: int_union2}) do + IntUnion.encode_xdr!(int_union2) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case IntUnion.decode_xdr(bytes) do + {:ok, {%IntUnion{} = int_union2, rest}} -> {:ok, {new(int_union2), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%IntUnion{} = int_union2, rest} = IntUnion.decode_xdr!(bytes) + {new(int_union2), rest} + end +end diff --git a/spec/output/generator_spec_elixir/union.x/multi.ex b/spec/output/generator_spec_elixir/union.x/multi.ex new file mode 100644 index 000000000..435faab99 --- /dev/null +++ b/spec/output/generator_spec_elixir/union.x/multi.ex @@ -0,0 +1,47 @@ +defmodule MyXDR.Multi do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `Multi` type. + """ + + @behaviour XDR.Declaration + + @type t :: %__MODULE__{datum: integer()} + + defstruct [:datum] + + @spec new(value :: integer()) :: t() + def new(value), do: %__MODULE__{datum: value} + + @impl true + def encode_xdr(%__MODULE__{datum: value}) do + XDR.Int.encode_xdr(%XDR.Int{datum: value}) + end + + @impl true + def encode_xdr!(%__MODULE__{datum: value}) do + XDR.Int.encode_xdr!(%XDR.Int{datum: value}) + end + + @impl true + def decode_xdr(bytes, term \\ nil) + + def decode_xdr(bytes, _term) do + case XDR.Int.decode_xdr(bytes) do + {:ok, {%XDR.Int{datum: value}, rest}} -> {:ok, {new(value), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, term \\ nil) + + def decode_xdr!(bytes, _term) do + {%XDR.Int{datum: value}, rest} = XDR.Int.decode_xdr!(bytes) + {new(value), rest} + end +end diff --git a/spec/output/generator_spec_elixir/union.x/multi_list.ex b/spec/output/generator_spec_elixir/union.x/multi_list.ex new file mode 100644 index 000000000..38b20e31d --- /dev/null +++ b/spec/output/generator_spec_elixir/union.x/multi_list.ex @@ -0,0 +1,57 @@ +defmodule MyXDR.MultiList do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `MultiList` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.Multi + + @array_type Multi + + @array_spec %{type: @array_type} + + @type t :: %__MODULE__{items: list(Multi.t())} + + defstruct [:items] + + @spec new(items :: list(Multi.t())) :: t() + def new(items), do: %__MODULE__{items: items} + + @impl true + def encode_xdr(%__MODULE__{items: items}) do + items + |> XDR.VariableArray.new(@array_type) + |> XDR.VariableArray.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{items: items}) do + items + |> XDR.VariableArray.new(@array_type) + |> XDR.VariableArray.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, spec \\ @array_spec) + + def decode_xdr(bytes, spec) do + case XDR.VariableArray.decode_xdr(bytes, spec) do + {:ok, {items, rest}} -> {:ok, {new(items), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @array_spec) + + def decode_xdr!(bytes, spec) do + {items, rest} = XDR.VariableArray.decode_xdr!(bytes, spec) + {new(items), rest} + end +end diff --git a/spec/output/generator_spec_elixir/union.x/my_union.ex b/spec/output/generator_spec_elixir/union.x/my_union.ex new file mode 100644 index 000000000..d5be55f6f --- /dev/null +++ b/spec/output/generator_spec_elixir/union.x/my_union.ex @@ -0,0 +1,73 @@ +defmodule MyXDR.MyUnion do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `MyUnion` type. + """ + + @behaviour XDR.Declaration + + alias MyXDR.{ + UnionKey, + Error, + MultiList + } + + @arms [ + ERROR: Error, + MULTI: MultiList + ] + + @type value :: + Error.t() + | MultiList.t() + + @type t :: %__MODULE__{value: value(), type: UnionKey.t()} + + defstruct [:value, :type] + + @spec new(value :: value(), type :: UnionKey.t()) :: t() + def new(value, %UnionKey{} = type), do: %__MODULE__{value: value, type: type} + + @impl true + def encode_xdr(%__MODULE__{value: value, type: type}) do + type + |> XDR.Union.new(@arms, value) + |> XDR.Union.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{value: value, type: type}) do + type + |> XDR.Union.new(@arms, value) + |> XDR.Union.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, spec \\ union_spec()) + + def decode_xdr(bytes, spec) do + case XDR.Union.decode_xdr(bytes, spec) do + {:ok, {{type, value}, rest}} -> {:ok, {new(value, type), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ union_spec()) + + def decode_xdr!(bytes, spec) do + {{type, value}, rest} = XDR.Union.decode_xdr!(bytes, spec) + {new(value, type), rest} + end + + @spec union_spec() :: XDR.Union.t() + defp union_spec do + nil + |> UnionKey.new() + |> XDR.Union.new(@arms) + end +end diff --git a/spec/output/generator_spec_elixir/union.x/union_key.ex b/spec/output/generator_spec_elixir/union.x/union_key.ex new file mode 100644 index 000000000..279ab4842 --- /dev/null +++ b/spec/output/generator_spec_elixir/union.x/union_key.ex @@ -0,0 +1,58 @@ +defmodule MyXDR.UnionKey do + @moduledoc """ + Automatically generated by xdrgen + DO NOT EDIT or your changes may be overwritten + + Target implementation: elixir_xdr at https://hex.pm/packages/elixir_xdr + + Representation of Stellar `UnionKey` type. + """ + + @behaviour XDR.Declaration + + @declarations [ + ERROR: 0, + MULTI: 1 + ] + + @enum_spec %XDR.Enum{declarations: @declarations, identifier: nil} + + @type t :: %__MODULE__{identifier: atom()} + + defstruct [:identifier] + + @spec new(type :: atom()) :: t() + def new(type \\ :ERROR), do: %__MODULE__{identifier: type} + + @impl true + def encode_xdr(%__MODULE__{identifier: type}) do + @declarations + |> XDR.Enum.new(type) + |> XDR.Enum.encode_xdr() + end + + @impl true + def encode_xdr!(%__MODULE__{identifier: type}) do + @declarations + |> XDR.Enum.new(type) + |> XDR.Enum.encode_xdr!() + end + + @impl true + def decode_xdr(bytes, spec \\ @enum_spec) + + def decode_xdr(bytes, spec) do + case XDR.Enum.decode_xdr(bytes, spec) do + {:ok, {%XDR.Enum{identifier: type}, rest}} -> {:ok, {new(type), rest}} + error -> error + end + end + + @impl true + def decode_xdr!(bytes, spec \\ @enum_spec) + + def decode_xdr!(bytes, spec) do + {%XDR.Enum{identifier: type}, rest} = XDR.Enum.decode_xdr!(bytes, spec) + {new(type), rest} + end +end