bare-rb 0.1.2 → 0.2.0

data/lib/types.rb

@@ -3,201 +3,214 @@ require_relative './exceptions'
 class BareTypes
 
   class BaseType
-  end
-
-  class BarePrimitive < BaseType
-    # Types which are always equivalent to another instantiation of themselves
-    # Eg. Uint.new == Uint.new
-    # But Union.new(types1) != Union.new(types2)
-    #   since unions could have different sets of types
-    def ==(other)
-      self.class == other.class
-    end
-  end
-
-  class Int < BarePrimitive
-    # https://developers.google.com/protocol-buffers/docs/encoding
-    # Easy to just convert to signed and re-use uint code
-    def encode(msg)
-      mappedInteger = msg < 0 ? -2 * msg - 1 : msg * 2
-      return Uint.new.encode(mappedInteger)
+    def initialize
+      @finalized = false
+      super
     end
-    def decode(msg)
-      output = Uint.new.decode(msg)
-      unmapped = output[:value]
-      unmapped = unmapped.odd? ? (unmapped + 1) / - 2 : unmapped / 2
-      return { value: unmapped, rest: output[:rest] }
+    def cycle_search(seen)
     end
   end
 
-  class Void < BarePrimitive
-    def encode(msg)
-      return "".b
+  class Schema
+    attr_accessor :types
+
+    def initialize(types)
+      @types = types.map { |k, v| [k.to_sym, v] }.to_h
+      @types.each do |k, v|
+        unless k.is_a?(Symbol)
+          raise("Keys to a schema must be symbols")
+        end
+        if v.nil?
+          raise("Schema values cannot be nil")
+        end
+      end
+
+      # Resolve references in schema
+      # type A u8
+      # type B A
+      # type C B
+      # first  loop would find B and make it a reference to A
+      # second loop would find C and make it a reference to B
+      progress = true
+      remaining = @types.keys.to_a
+      while progress
+        progress = false
+        remaining.each do |key|
+          val = @types[key]
+          if val.is_a?(Symbol) && !@types[val].is_a?(Symbol)
+            @types[key.to_sym] = BareTypes::Reference.new(key, @types[val])
+            progress = true
+          else
+          end
+        end
+      end
+
+      @types.each do |key, val|
+        if val.is_a?(Symbol)
+          raise ReferenceException.new("Your types contain an unresolved reference '#{val}'.")
+        end
+      end
+
+      @types.values.each do |val|
+        val.finalize_references(@types)
+      end
+
+      @types.each do |key, val|
+        val.cycle_search(SeenList.new)
+      end
     end
-    def decode(msg)
-      return {value: nil, rest: msg}
+
+    def ==(otherSchema)
+      return false unless otherSchema.is_a?(BareTypes::Schema)
+      @types == otherSchema.types
     end
-  end
 
-  class F32 < BarePrimitive
-    def encode(msg)
-      return [msg].pack("e")
+    def to_s
+      buffer = ""
+      @types.each do |name, type|
+        if type.is_a?(BareTypes::Enum)
+          buffer << "enum #{name} "
+          type.to_schema(buffer)
+          buffer << "\n"
+        else
+          buffer << "type #{name} "
+          type.to_schema(buffer)
+          buffer << "\n"
+        end
+      end
+      buffer
     end
-    def decode(msg)
-      return {value: msg.unpack("e")[0], rest: msg[4..msg.size]}
+
+    def [](key)
+      return @types[key]
     end
   end
 
-  class F64 < BarePrimitive
-    def encode(msg)
-      return [msg].pack("E")
+  # Used to represent a Type reference in a schema.
+  # eg. test8.schema's  address field on Customer contains 'Address'
+  # a reference to the Address type defined earlier.
+  class Reference < BaseType
+    attr_accessor :name
+    attr_accessor :ref
+
+    def cycle_search(seen)
+      seen.add(self)
+      @ref.cycle_search(seen)
+      seen.pop
     end
-    def decode(msg)
-      return {value: msg.unpack("E")[0], rest: msg[8..msg.size]}
+
+    def ==(other)
+      other.is_a?(Reference) && @name == other.name && @ref == other.ref
     end
-  end
 
-  class String < BarePrimitive
-    def encode(msg)
-      encodedString = nil
-      begin
-        encodedString = msg.encode("UTF-8").b
-      rescue Encoding::UndefinedConversionError => error
-        raise error.class, "Unable to convert string to UTF-8=, BARE strings are encoded as UTF8. If you can't convert your string to UTF-8 you can encode it with binary data"
+    def initialize(name, reference)
+      @name = name
+      @ref = reference
+      @finalized = false
+      unless reference.is_a?(BareTypes::BaseType)
+        raise ReferenceException.new("Reference must be to bare types")
       end
-      bytes = Uint.new.encode(encodedString.size)
-      bytes << encodedString
-      return bytes
     end
-    def decode(msg)
-      output = Uint.new.decode(msg)
-      strLen = output[:value]
-      string = output[:rest][0..strLen-1]
-      return {value: string.force_encoding("utf-8"), rest: output[:rest][strLen..output[:rest].size] }
+
+    def finalize_references(schema)
+      return if @finalized
+      @finalized = true
+      self.ref.finalize_references(schema)
     end
-  end
 
-  class Optional < BaseType
-    def ==(otherType)
-      return otherType.class == BareTypes::Optional && otherType.optionalType == @optionalType
+    def encode(msg, buffer)
+      @ref.encode(msg, buffer)
     end
 
-    def optionalType
-      @optionalType
+    def decode(msg)
+      @ref.decode(msg)
     end
 
-    def initialize(optionalType)
-      raise VoidUsedOutsideTaggedSet() if optionalType.class == BareTypes::Void
-      @optionalType = optionalType
+    def to_schema(buffer)
+      buffer << @name.to_s
     end
+  end
 
-    def encode(msg)
-      if msg.nil?
-        return "\x00".b
-      else
-        bytes = "\xFF".b
-        bytes << @optionalType.encode(msg)
-        return bytes
-      end
+  class BarePrimitive < BaseType
+
+    # Types which are always equivalent to another instantiation of themselves
+    # Eg. Uint.new == Uint.new
+    # But Union.new(types1) != Union.new(types2)
+    #   since unions could have different sets of types
+
+    def ==(other)
+      self.class == other.class
     end
 
-    def decode(msg)
-      if msg.unpack("C")[0] == 0
-        return {value: nil, rest: msg[1..msg.size]}
-      else
-        return @optionalType.decode(msg[1..msg.size])
-      end
+    def finalize_references(schema) end
+
+    def to_schema(buffer)
+      buffer << self.class.name.split('::').last.downcase
     end
+
   end
 
-  class Map < BaseType
-    def ==(otherType)
-      return otherType.class == BareTypes::Map && otherType.from == @from && otherType.to == @to
+  #region Primitives
+  class Int < BarePrimitive
+    # https://developers.google.com/protocol-buffers/docs/encoding
+    # Easy to just convert to signed and re-use uint code
+    def encode(msg, buffer)
+      mappedInteger = msg < 0 ? -2 * msg - 1 : msg * 2
+      Uint.new.encode(mappedInteger, buffer)
     end
 
-    def initialize(fromType, toType)
-      raise VoidUsedOutsideTaggedSet if fromType.class == BareTypes::Void or toType.class == BareTypes::Void
-      raise MapKeyError("Map keys must use a primitive type which is not data or data<length>.") if !fromType.class.ancestors.include?(BarePrimitive) || fromType.is_a?(BareTypes::Data) || fromType.is_a?(BareTypes::DataFixedLen)
-      @from = fromType
-      @to = toType
+    def decode(msg)
+      value, rest = Uint.new.decode(msg)
+      value = value.odd? ? (value + 1) / -2 : value / 2
+      return value, rest
     end
+  end
 
-    def from
-      @from
+  class Void < BarePrimitive
+    def encode(msg, buffer)
+      buffer << "".b
     end
 
-    def to
-      @to
+    def decode(msg)
+      return nil, msg
     end
+  end
 
-    def encode(msg)
-      bytes = Uint.new.encode(msg.size)
-      msg.each do |from, to|
-        bytes << @from.encode(from)
-        bytes << @to.encode(to)
-      end
-      return bytes
+  class F32 < BarePrimitive
+    def encode(msg, buffer)
+      buffer << [msg].pack("e")
     end
 
     def decode(msg)
-      hash = Hash.new
-      output = Uint.new.decode(msg)
-      mapSize = output[:value]
-      (mapSize - 1).to_i.downto(0) do
-        output = @from.decode(output[:rest])
-        key = output[:value]
-        output = @to.decode(output[:rest])
-        hash[key] = output[:value]
-      end
-      return {value: hash, rest: output[:rest]}
+      return msg.unpack("e")[0], msg[4..msg.size]
     end
   end
 
-  class Union < BarePrimitive
-    def intToType
-      @intToType
-    end
-
-    def ==(otherType)
-      return false unless otherType.is_a?(BareTypes::Union)
-      @intToType.each do |int, type|
-        return false unless type == otherType.intToType[int]
-      end
-      return true
+  class F64 < BarePrimitive
+    def encode(msg, buffer)
+      buffer << [msg].pack("E")
     end
 
-    def initialize(intToType)
-      intToType.keys.each do |i|
-        raise MinimumSizeError("Union's integer representations must be > 0, instead got: #{i}") if i < 0 or !i.is_a?(Integer)
-      end
-      raise MinimumSizeError("Union must have at least one type") if intToType.keys.size < 1
-      @intToType = intToType
+    def decode(msg)
+      return msg.unpack("E")[0], msg[8..msg.size]
     end
+  end
 
-    def encode(msg)
-      type = msg[:type]
-      value = msg[:value]
-      unionTypeInt = nil
-      unionType = nil
-      @intToType.each do |int, typ|
-        if type.class == typ.class
-          unionTypeInt = int
-          unionType = typ
-          break
-        end
+  class String < BarePrimitive
+    def encode(msg, buffer)
+      begin
+        encodedString = msg.encode("UTF-8").b
+      rescue Encoding::UndefinedConversionError => error
+        raise error.class, "Unable to convert string to UTF-8=, BARE strings are encoded as UTF8. If you can't convert your string to UTF-8 you can encode it with binary data"
       end
-      raise SchemaMismatch("Unable to find given type in union: #{@intToType.inspect}, type: #{type}") if unionType.nil? || unionTypeInt.nil?
-      bytes = Uint.new.encode(unionTypeInt)
-      encoded = unionType.encode(value)
-      bytes << encoded
+      Uint.new.encode(encodedString.size, buffer)
+      buffer << encodedString
     end
 
     def decode(msg)
-      unionTypeInt = Uint.new.decode(msg)
-      int = unionTypeInt[:value]
-      type = @intToType[int]
-      value = type.decode(unionTypeInt[:rest])
-      return {value: {value: value[:value], type: type}, rest: value[:rest]}
+      strLen, rest = Uint.new.decode(msg)
+      string = rest[0..strLen - 1]
+      return string.force_encoding("utf-8"), rest[strLen..rest.size]
     end
   end
 
@@ -206,41 +219,53 @@ class BareTypes
       return otherType.class == BareTypes::DataFixedLen && otherType.length == self.length
     end
 
+    def to_schema(buffer)
+      buffer << "data<#{@length}>"
+    end
+
     def length
-      return @length
+      @length
     end
 
+    def finalize_references(schema) end
+
     def initialize(length)
-      raise MinimumSizeError("DataFixedLen must have a length greater than 0, got: #{length.inspect}") if length < 1
+      raise MinimumSizeError.new("DataFixedLen must have a length greater than 0, got: #{length.inspect}") if length < 1
       @length = length
     end
 
-    def encode(msg)
-      return msg
+    def encode(msg, buffer)
+      if msg.size != @length
+        raise FixedDataSizeWrong.new("Message is not proper sized for DataFixedLen should have been #{@length} but was #{msg.size}")
+      end
+      buffer << msg
     end
 
     def decode(msg)
-      return {value: msg[0..@length], rest: msg[@length..msg.size]}
+      return msg[0..@length-1], msg[@length..msg.size]
     end
   end
 
   class Data < BarePrimitive
-    def encode(msg)
-      bytes = Uint.new.encode(msg.size)
-      bytes << msg
-      return bytes
+
+    def finalize_references(schema) end
+
+    def encode(msg, buffer)
+      Uint.new.encode(msg.size, buffer)
+      buffer << msg
     end
 
     def decode(msg)
-      output = Uint.new.decode(msg)
-      rest = output[:rest]
-      dataSize = output[:value]
-      return {value: rest[0..dataSize-1], rest: rest[dataSize..]}
+      dataSize, rest = Uint.new.decode(msg)
+      return rest[0..dataSize - 1], rest[dataSize..rest.size]
     end
   end
 
   class Uint < BarePrimitive
-    def encode(msg)
+
+    def finalize_references(schema) end
+
+    def encode(msg, buffer)
       bytes = "".b
       _get_next_7_bits_as_byte(msg, 128) do |byte|
         bytes << byte
@@ -253,12 +278,12 @@ class BareTypes
         end
       end
       bytes[bytes.size - 1] = [bytes.bytes[bytes.size - 1] & 127].pack('C')[0]
-      raise MaximumSizeError("Maximum u/int allowed is 64 bit precision") if bytes.size > 9
-      return bytes
+      raise MaximumSizeError.new("Maximum u/int allowed is 64 bit precision") if bytes.size > 9
+      buffer << bytes
     end
 
     def decode(msg)
-      ints = msg.unpack("CCCCCCCCC")
+      ints = msg.unpack("CCCCCCCC")
       relevantInts = []
       i = 0
       while ints[i] & 0b10000000 == 128
@@ -270,220 +295,478 @@ class BareTypes
       relevantInts.each_with_index do |int, idx|
         sum += int << (idx * 7)
       end
-      return {value: sum, rest: msg[(i + 1)..msg.size]}
+      return sum, msg[(i + 1)..msg.size]
     end
   end
 
   class U8 < BarePrimitive
-    def encode(msg)
-      return [msg].pack("C")
+    def encode(msg, buffer)
+      buffer << [msg].pack("C")
     end
 
     def decode(msg)
-      return {value: msg[0].unpack("C")[0], rest: msg[1..msg.size]}
+      return msg[0].unpack("C")[0], msg[1..msg.size]
     end
   end
 
   class U16 < BarePrimitive
-    def encode(msg)
-      return [msg].pack("v")
+    def encode(msg, buffer)
+      buffer << [msg].pack("v")
     end
 
     def decode(msg)
-      return {value: msg.unpack("v")[0], rest: msg[2..msg.size]}
+      return msg.unpack("v")[0], msg[2..msg.size]
     end
   end
 
   class U32 < BarePrimitive
-    def encode(msg)
-      return [msg].pack("V")
+    def encode(msg, buffer)
+      buffer << [msg].pack("V")
     end
 
     def decode(msg)
-      return {value: msg.unpack("V")[0], rest: msg[4..msg.size]}
+      return msg.unpack("V")[0], msg[4..msg.size]
     end
   end
 
   class U64 < BarePrimitive
-    def encode(msg)
-      return [msg].pack("Q")
+    def encode(msg, buffer)
+      buffer << [msg].pack("Q")
     end
 
     def decode(msg)
-      return {value: msg.unpack("Q")[0], rest: [8..msg.size]}
+      return msg.unpack("Q")[0], msg[8..msg.size]
     end
   end
 
   class I8 < BarePrimitive
-    def encode(msg)
-      return [msg].pack("c")
+    def encode(msg, buffer)
+      buffer << [msg].pack("c")
     end
 
     def decode(msg)
-      return {value: msg[0].unpack("c")[0], rest: msg[1..msg.size]}
+      return msg[0].unpack("c")[0], msg[1..msg.size]
     end
   end
 
   class I16 < BarePrimitive
-    def encode(msg)
-      return [msg].pack("s<")
+    def encode(msg, buffer)
+      buffer << [msg].pack("s<")
     end
 
     def decode(msg)
-      return {value: msg.unpack('s<')[0], rest: msg[2..msg.size]}
+      return msg.unpack('s<')[0], msg[2..msg.size]
     end
   end
 
   class I32 < BarePrimitive
-    def encode(msg)
-      return [msg].pack("l<")
+    def encode(msg, buffer)
+      buffer << [msg].pack("l<")
     end
 
     def decode(msg)
-      return {value: msg.unpack('l<')[0], rest: msg[4..msg.size]}
+      return msg.unpack('l<')[0], msg[4..msg.size]
     end
   end
 
   class I64 < BarePrimitive
-    def encode(msg)
-      return [msg].pack("q<")
+    def encode(msg, buffer)
+      buffer << [msg].pack("q<")
     end
 
     def decode(msg)
-      return {value: msg.unpack('q<')[0], rest: msg[8..msg.size]}
+      return msg.unpack('q<')[0], msg[8..msg.size]
     end
   end
 
   class Bool < BarePrimitive
-    def encode(msg)
-      return msg ? "\xFF\xFF".b : "\x00\x00".b
+    def encode(msg, buffer)
+      buffer << (msg ? "\x00".b : "\x01".b)
+    end
+
+    def decode(msg)
+      if msg != "\x00" && msg != "\x01"
+        raise InvalidBool.new("Expected a bool but found #{msg.inspect}. Standard requires bool to be 0x00 or 0x01")
+      end
+      return (msg == "\x00" ? true : false), msg[1..msg.size]
+    end
+  end
+  #endregion
+
+  class Optional < BaseType
+    def ==(otherType)
+      return otherType.class == BareTypes::Optional && otherType.optionalType == @optionalType
+    end
+
+    def to_schema(buffer)
+      buffer << "optional<"
+      @optionalType.to_schema(buffer)
+      buffer << ">"
+    end
+
+    def finalize_references(schema)
+      return if @finalized
+      @finalized = true
+      if @optionalType.is_a?(Symbol)
+        @optionalType = Reference.new(@optionalType, schema[@optionalType])
+      else
+        @optionalType.finalize_references(schema)
+      end
+    end
+
+    def optionalType
+      @optionalType
+    end
+
+    def initialize(optionalType)
+      raise VoidUsedOutsideTaggedSet() if optionalType.class == BareTypes::Void
+      @optionalType = optionalType
+    end
+
+    def encode(msg, buffer)
+      if msg.nil?
+        buffer << "\x00".b
+      else
+        buffer << "\x01".b
+        @optionalType.encode(msg, buffer)
+      end
+    end
+
+    def decode(msg)
+      if msg.unpack("C")[0] == 0
+        return nil, msg[1..msg.size]
+      else
+        return @optionalType.decode(msg[1..msg.size])
+      end
+    end
+  end
+
+  class Map < BaseType
+    def ==(otherType)
+      return otherType.class == BareTypes::Map && otherType.from == @from && otherType.to == @to
+    end
+
+    def to_schema(buffer)
+      buffer << "map["
+      @from.to_schema(buffer)
+      buffer << "]"
+      @to.to_schema(buffer)
+    end
+
+    def finalize_references(schema)
+      return if @finalized
+      @finalized = true
+      if @from.is_a?(Symbol)
+        @to = Reference.new(@from, schema[@to])
+      else
+        @to.finalize_references(schema)
+      end
+    end
+
+    def initialize(fromType, toType)
+      raise VoidUsedOutsideTaggedSet if fromType.class == BareTypes::Void or toType.class == BareTypes::Void
+      if !fromType.class.ancestors.include?(BarePrimitive) ||
+        fromType.is_a?(BareTypes::Data) ||
+        fromType.is_a?(BareTypes::DataFixedLen)
+        raise MapKeyError("Map keys must use a primitive type which is not data or data<length>.")
+      end
+      @from = fromType
+      @to = toType
+    end
+
+    def from
+      @from
+    end
+
+    def to
+      @to
+    end
+
+    def encode(msg, buffer)
+      Uint.new.encode(msg.size, buffer)
+      msg.each do |from, to|
+        @from.encode(from, buffer)
+        @to.encode(to, buffer)
+      end
     end
 
     def decode(msg)
-      return {value: msg == "\x00\x00" ? false : true, rest: msg[1..msg.size]}
+      hash = Hash.new
+      mapSize, rest = Uint.new.decode(msg)
+      # (0..mapSize).each do
+      (mapSize - 1).to_i.downto(0) do
+        key, rest = @from.decode(rest)
+        value, rest = @to.decode(rest)
+        hash[key] = value
+      end
+      return hash, rest
+    end
+  end
+
+  class Union < BaseType
+    attr_accessor :intToType
+
+    def cycle_search(seen)
+      if @intToType.size == 1
+        seen.add(self)
+        @intToType.values.each do |type|
+          type.cycle_search(seen)
+        end
+        seen.pop
+      end
+    end
+
+    def finalize_references(schema)
+      return if @finalized
+      @finalized = true
+      @intToType.keys.each do |key|
+        if @intToType[key].is_a?(Symbol)
+          @intToType[key] = Reference.new(@intToType[key], schema[@intToType[key]])
+        else
+          @intToType[key].finalize_references(schema)
+        end
+      end
+    end
+
+    def ==(otherType)
+      return false unless otherType.is_a?(BareTypes::Union)
+      @intToType.each do |int, type|
+        return false unless type == otherType.intToType[int]
+      end
+      true
+    end
+
+    def initialize(intToType)
+      intToType.keys.each do |i|
+        raise MinimumSizeError("Union's integer representations must be > 0, instead got: #{i}") if i < 0 or !i.is_a?(Integer)
+      end
+      raise MinimumSizeError("Union must have at least one type") if intToType.keys.size < 1
+      @intToType = intToType
+    end
+
+    def to_schema(buffer)
+      buffer << "("
+      strs = []
+      @intToType.size.times do
+        strs << ""
+      end
+      @intToType.values.each_with_index.map { |type, i| type.to_schema(strs[i]) }
+      buffer << strs.join(" | ")
+      buffer << ")"
+    end
+
+    def encode(msg, buffer)
+      type = msg[:type]
+      value = msg[:value]
+      unionTypeInt = nil
+      unionType = nil
+      @intToType.each do |int, typ|
+        if type.class == typ.class
+          unionTypeInt = int
+          unionType = typ
+          break
+        end
+      end
+      raise SchemaMismatch("Unable to find given type in union: #{@intToType.inspect}, type: #{type}") if unionType.nil? || unionTypeInt.nil?
+      Uint.new.encode(unionTypeInt, buffer)
+      unionType.encode(value, buffer)
+    end
+
+    def decode(msg)
+      int, rest = Uint.new.decode(msg)
+      type = @intToType[int]
+      value, rest = type.decode(rest)
+      return { value: value, type: type }, rest
     end
   end
 
   class Struct < BaseType
+    attr_accessor :mapping
+
+    def cycle_search(seen)
+      seen.add(self)
+      @mapping.values.each do |val|
+        val.cycle_search(seen)
+      end
+      seen.pop
+    end
+
+    def [](key)
+      @mapping[key]
+    end
+
     def ==(otherType)
       return false unless otherType.class == BareTypes::Struct
       @mapping.each do |k, v|
         return false unless otherType.mapping[k] == v
       end
-      return true
-    end
-
-    def mapping
-      @mapping
+      true
+    end
+
+    def finalize_references(schema)
+      return if @finalized
+      @finalized = true
+      @mapping.each do |key, val|
+        if val.is_a?(Symbol)
+          @mapping[key] = Reference.new(val, schema[val])
+          begin
+            @mapping[key].ref.finalize_references(schema)
+          rescue NoMethodError => e
+            puts "err"
+          end
+        else
+          val.finalize_references(schema)
+        end
+      end
     end
 
     def initialize(symbolToType)
-      # Mapping from symbols to Bare types
+      # Mapping from symbols to Bare types (or possibly symbols before finalizing)
       symbolToType.keys.each do |k|
-        raise BareException("Struct keys must be symbols") unless k.is_a?(Symbol)
-        raise BareException("Struct values must be a BareTypes::TYPE\nInstead got: #{symbolToType[k].inspect}") unless symbolToType[k].class.ancestors.include?(BaseType)
-        raise VoidUsedOutsideTaggedSet("Void types may only be used as members of the set of types in a tagged union. Void type used as struct key") if symbolToType.class == BareTypes::Void
+        raise BareException.new("Struct keys must be symbols") unless k.is_a?(Symbol)
+        if (!symbolToType[k].class.ancestors.include?(BaseType) && !symbolToType[k].is_a?(Symbol))
+          raise BareException.new("Struct values must be a BareTypes::TYPE or a symbol with the same
+                name as a user defined type\nInstead got: #{symbolToType[k].inspect}")
+        end
+        raise VoidUsedOutsideTaggedSet.new("Void types may only be used as members of the set of types in a tagged union. Void type used as struct key") if symbolToType.class == BareTypes::Void
       end
       raise("Struct must have at least one field") if symbolToType.keys.size == 0
       @mapping = symbolToType
     end
 
-    def encode(msg)
-      bytes = "".b
+    def encode(msg, buffer)
       @mapping.keys.each do |symbol|
-        raise SchemaMismatch("All struct fields must be specified, missing: #{symbol.inspect}") unless msg.keys.include?(symbol)
-        bytes << @mapping[symbol].encode(msg[symbol])
+        raise SchemaMismatch.new("All struct fields must be specified, missing: #{symbol.inspect}") unless msg.keys.include?(symbol)
+        @mapping[symbol].encode(msg[symbol], buffer)
       end
-      return bytes
     end
 
     def decode(msg)
       hash = Hash.new
       rest = msg
       @mapping.keys.each do |symbol|
-        output = @mapping[symbol].decode(rest)
-        hash[symbol] = output[:value]
-        rest = output[:rest]
+        value, rest = @mapping[symbol].decode(rest)
+        hash[symbol] = value
       end
-      return {value: hash, rest: rest}
+      return hash, rest
+    end
+
+    def to_schema(buffer)
+      buffer << "{"
+      @mapping.each do |symbol, type|
+        buffer << "    #{symbol}: "
+        type.to_schema(buffer)
+        buffer << "\n"
+      end
+      buffer << "}"
     end
   end
 
   class Array < BaseType
     def ==(otherType)
-      return otherType.class == BareTypes::Array && otherType.type == self.type
+      otherType.class == BareTypes::Array && otherType.type == self.type
+    end
+
+    def cycle_search(seen)
+      seen.add(self)
+      @type.cycle_search(seen)
+      seen.pop
     end
 
     def type
-      return @type
+      @type
+    end
+
+    def to_schema(buffer)
+      buffer << "[]"
+      @type.to_schema(buffer)
+    end
+
+    def finalize_references(schema)
+      return if @finalized
+      @finalized = true
+      if @type.is_a?(Symbol)
+        @type = Reference.new(@type, schema[@type])
+      else
+        @type.finalize_references(schema)
+      end
     end
 
     def initialize(type)
-      raise VoidUsedOutsideTaggedSet("Void types may only be used as members of the set of types in a tagged union.") if type.class == BareTypes::Void
+      raise VoidUsedOutsideTaggedSet.new("Void types may only be used as members of the set of types in a tagged union.") if type.class == BareTypes::Void
       @type = type
     end
 
-    def encode(msg)
-      bytes = Uint.new.encode(msg.size)
+    def encode(msg, buffer)
+      Uint.new.encode(msg.size, buffer)
       msg.each do |item|
-        bytes << @type.encode(item)
+        @type.encode(item, buffer)
       end
-      return bytes
     end
 
     def decode(msg)
-      output = Uint.new.decode(msg)
       arr = []
-      arrayLen = output[:value]
+      arrayLen, rest = Uint.new.decode(msg)
       lastSize = msg.size + 1 # Make sure msg size monotonically decreasing
       (arrayLen - 1).downto(0) do
-        output = @type.decode(output[:rest])
-        arr << output[:value]
-        break if output[:rest].nil? || output[:rest].size == 0 || lastSize <= output[:rest].size
-        lastSize = output[:rest].size
+        arrVal, rest = @type.decode(rest)
+        arr << arrVal
+        break if rest.nil? || rest.size == 0 || lastSize <= rest.size
+        lastSize = rest.size
       end
-      return {value: arr, rest: output[:rest]}
+      return arr, rest
     end
   end
 
   class ArrayFixedLen < BaseType
+    attr_accessor :type, :size
+
+    def cycle_search(seen)
+      seen.add(self)
+      @type.cycle_search(seen)
+      seen.pop
+    end
+
     def ==(otherType)
       return otherType.class == BareTypes::ArrayFixedLen && otherType.type == @type && otherType.size == @size
     end
 
+    def finalize_references(schema)
+      return if @finalized
+      @finalized = true
+      if @type.is_a?(Symbol)
+        @type = Reference.new(@type, schema[@type])
+      else
+        @type.finalize_references(schema)
+      end
+    end
+
     def initialize(type, size)
       @type = type
       @size = size
-      raise VoidUsedOutsideTaggedSet("Void type may not be used as type of fixed length array.") if type.class == BareTypes::Void
-      raise MinimumSizeError("FixedLenArray size must be > 0") if size < 1
-    end
-
-    def type
-      @type
-    end
-
-    def size
-      @size
+      raise VoidUsedOutsideTaggedSet.new("Void type may not be used as type of fixed length array.") if type.class == BareTypes::Void
+      raise MinimumSizeError.new("ArrayFixedLen size must be > 0") if size < 1
     end
 
-    def encode(arr)
-      raise SchemaMismatch("This FixLenArray is of length #{@size.to_s} but you passed an array of length #{arr.size}") if arr.size != @size
-      bytes = ""
+    def encode(arr, buffer)
+      raise SchemaMismatch.new("This ArrayFixedLen is of length #{@size.to_s} but you passed an array of length #{arr.size}") if arr.size != @size
       arr.each do |item|
-        bytes << @type.encode(item)
+        @type.encode(item, buffer)
       end
-      return bytes
     end
 
-    def decode(msg)
+    def decode(rest)
       array = []
-      rest = msg
       @size.times do
-        output = @type.decode(rest)
-        rest = output[:rest]
-        array << output[:value]
+        arrVal, rest = @type.decode(rest)
+        array << arrVal
       end
-      return {value: array, rest: rest}
+      return array, rest
+    end
+
+    def to_schema(buffer)
+      buffer << "[#{@size}]"
+      @type.to_schema(buffer)
     end
   end
 
@@ -496,6 +779,16 @@ class BareTypes
       return true
     end
 
+    def to_schema(buffer)
+      buffer << "{\n"
+      @valToInt.each do |name, repr|
+        buffer << "   #{name} = #{repr}\n"
+      end
+      buffer << "}"
+    end
+
+    def finalize_references(schema) end
+
     def intToVal
       @intToVal
     end
@@ -503,9 +796,9 @@ class BareTypes
     def initialize(source)
       @intToVal = {}
       @valToInt = {}
-      raise BareException("Enum must initialized with a hash from integers to anything") if !source.is_a?(Hash)
-      raise BareException("Enum must have unique positive integer assignments") if Set.new(source.keys).size != source.keys.size
-      raise EnumValueError("Enum must have unique values") if source.values.to_set.size != source.values.size
+      raise BareException.new("Enum must initialized with a hash from integers to anything") if !source.is_a?(Hash)
+      raise BareException.new("Enum must have unique positive integer assignments") if Set.new(source.keys).size != source.keys.size
+      raise EnumValueError.new("Enum must have unique values") if source.values.to_set.size != source.values.size
       source.each do |k, v|
         raise("Enum keys must be positive integers") if k < 0
         @intToVal[k.to_i] = v
@@ -513,18 +806,15 @@ class BareTypes
       end
     end
 
-    def encode(msg)
-      raise SchemaMismatch("#{msg.inspect} is not part of this enum: #{@intToVal}") if !@valToInt.keys.include?(msg)
+    def encode(msg, buffer)
+      raise SchemaMismatch.new("#{msg.inspect} is not part of this enum: #{@intToVal}") if !@valToInt.keys.include?(msg)
       integerRep = @valToInt[msg]
-      encoded = BareTypes::Uint.new.encode(integerRep)
-      return encoded
+      BareTypes::Uint.new.encode(integerRep, buffer)
     end
 
     def decode(msg)
-      output = BareTypes::Uint.new.decode(msg)
-      value = output[:value]
-      rest = output[:rest]
-      return {value: @intToVal[value], rest: rest}
+      value, rest = BareTypes::Uint.new.decode(msg)
+      return @intToVal[value], rest
     end
   end
 end
@@ -540,4 +830,4 @@ def _get_next_7_bits_as_byte(integer, base = 128)
     end
     yield(byte)
   end
-end
+end