fix some inconsistencies

support passing a schema node directly to ecapnp:{get|set}_root.
treat named unions properly (being unnamed unions wrapped in a group).

Author: kaos

priv/samples/addressbook.sh

@@ -36,7 +36,7 @@ read([]) ->
     dump_message(read_stdin()).
 
 write([]) ->
-    {ok, Root} = ecapnp:set_root('AddressBook', addressbook_capnp),
+    {ok, Root} = ecapnp:set_root(addressbook_capnp:'AddressBook'()),
     [Alice, Bob, Steve] = ecapnp:set(people, 3, Root),
     [AlicePhone] = ecapnp:set(phones, 1, Alice),
     [BobPhone1, BobPhone2] = ecapnp:set(phones, 2, Bob),
@@ -91,7 +91,7 @@ dump_message(Data) ->
     {ok, Message, <<>>} = ecapnp_message:read(
                             ecapnp_serialize:unpack(Data)),
     {ok, Root} = ecapnp:get_root(
-                   'AddressBook', addressbook_capnp, Message),
+                   addressbook_capnp:'AddressBook'(), Message),
     People = ecapnp:get(people, Root),
     [dump_person(Person) || Person <- People].
 
@@ -103,8 +103,7 @@ dump_person(Person) ->
     [io:format("  ~s phone: ~s~n", [ecapnp:get(type, P),
                                     ecapnp:get(number, P)])
      || P <- Phones],
-    %% hmm... not the best looking api, this.. :/
-    case ecapnp:get(ecapnp:get(employment, Person)) of
+    case ecapnp:get(employment, Person) of
         unemployed -> io:format("  unemployed~n");
         {employer, Employer} ->
             io:format("  employer: ~s~n", [Employer]);

src/ecapnp.erl

@@ -29,8 +29,9 @@
 %% Public API
 %% ===================================================================
 
--export([get_root/3, get/1, get/2, set_root/2, set/2, set/3, init/2,
-         init/3, const/2, request/2, send/1, wait/1, wait/2]).
+-export([get_root/2, get_root/3, get/1, get/2, set_root/1, set_root/2,
+         set/2, set/3, init/2, init/3, const/2, request/2, send/1,
+         wait/1, wait/2]).
 
 %% ===================================================================
 %% Public Types
@@ -190,6 +191,9 @@
 get_root(Type, Schema, Segments) ->
     ecapnp_get:root(Type, Schema, Segments).
 
+get_root(Schema, Segments) ->
+    ecapnp_get:root(Schema, Segments).
+
 -spec set_root(type_name(), schema()) -> {ok, Root::object()}.
 %% @doc Set the root object for a new message.
 %% This creates a new empty message, ready to be filled with data.
@@ -199,6 +203,9 @@ get_root(Type, Schema, Segments) ->
 set_root(Type, Schema) ->
     ecapnp_set:root(Type, Schema).
 
+set_root(Schema) ->
+    ecapnp_set:root(Schema).
+
 -spec get(object()) -> {field_name(), field_value()} | field_name().
 %% @doc Read the unnamed union value of object.
 %% The result value is either a tuple, describing which union tag it

src/ecapnp_get.erl

@@ -120,7 +120,21 @@ read_field(#ptr{ idx=Idx }=Ptr, #object{ ref = Ref }=Object) ->
             Object),
     read_ptr(Ptr, Obj);
 read_field(#group{ id=Type }, Object) ->
-    ecapnp_obj:to_struct(Type, Object).
+    case ecapnp_obj:to_struct(Type, Object) of
+        #object{
+          schema = #schema_node{
+                      kind = #struct{
+                                union_field = Union,
+                                fields = []
+                               }}}=Group
+          when Union =/= none ->
+            %% when we read a named union, we want to get the union
+            %% value directly, but a named union is represented as a
+            %% unnamed union wrapped in a group
+            read_field(Union, Group);
+        Group ->
+            Group
+    end.
 
 read_ptr(#ptr{ type=Type, default=Default }, #object{ ref = Ref }=Obj) ->
     case Type of

src/ecapnp_set.erl

@@ -138,7 +138,7 @@ set_field(#ptr{ idx=Idx, type=Type, default=Default }=Ptr,
                                   {object, Value};
                              true ->
                                   throw({error, {invalid_object_value, Value}})
-                              end,
+                          end,
                     write_obj(ObjType, ObjValue, ecapnp_ref:ptr(Idx, StructRef), Obj)
             end;
         {struct, StructType} ->
@@ -200,7 +200,26 @@ set_field(#ptr{ idx=Idx, type=Type, default=Default }=Ptr,
 set_field(#group{ id=Type }, {default}, #object{ ref=StructRef }=Obj) ->
     ecapnp_obj:from_ref(StructRef, Type, Obj);
 set_field(#group{ id=Type }, Value, #object{ ref=StructRef }=Obj) ->
-    union(Value, ecapnp_obj:from_ref(StructRef, Type, Obj)).
+    case ecapnp_obj:from_ref(StructRef, Type, Obj) of
+        #object{
+           schema = #schema_node{
+                       kind = #struct{
+                                 union_field = Union,
+                                 fields = []
+                                }}}=Group
+          when Union =/= none ->
+            %% set named union (which are represented as an unnamed
+            %% union wrapped in a group)
+            set_field(Union, Value, Group);
+        Group ->
+            %% set group field (or group unnamed union)
+            case Value of
+                {FieldName, FieldValue} ->
+                    field(FieldName, FieldValue, Group);
+                _ ->
+                    field(Value, Group)
+            end
+    end.
 
 write_obj(Type, Value, Ref, Obj) when is_binary(Value) ->
     ecapnp_obj:from_ref(

test/ecapnp_get_tests.erl

@@ -46,8 +46,7 @@ check_default_values(Msg) ->
     ?assertEqual(33, ecapnp:get(intField, Root)),
     ?assertEqual(<<"test">>, ecapnp:get(textField, Root)),
     ?assertEqual({boolField, false}, ecapnp:get(Root)),
-    Grp = ecapnp:get(opts, Root),
-    ?assertEqual({bool, true}, ecapnp:get(Grp)),
+    ?assertEqual({bool, true}, ecapnp:get(opts, Root)),
     Meta = ecapnp:get(meta, Root),
     ?assertEqual(0, ecapnp:get(id, Meta)),
     ?assertEqual(<<>>, ecapnp:get(tag, Meta)),
@@ -105,8 +104,7 @@ field_values_test() ->
     ?assertEqual(-44, ecapnp:get(a, Union)),
     ?assertEqual(0, ecapnp:get(b, Union)),
     ?assertEqual(22, ecapnp:get(c, Union)),
-    Grp = ecapnp:get(opts, Root),
-    {object, Obj} = ecapnp:get(Grp),
+    {object, Obj} = ecapnp:get(opts, Root),
     Simple = ecapnp_obj:to_struct('Simple', Obj),
     ?assertEqual(<<"Hello World!">>, ecapnp:get(simpleMessage, Simple)),
     ?assertEqual(<<"default message">>, ecapnp:get(message, Simple)),

test/ecapnp_set_tests.erl

@@ -315,10 +315,10 @@ group_field_test() ->
          "foo bar",0
        >>], Data).
 
-group_union_test() ->
+named_union_test() ->
+    %% please note that a named union is the same as a unnamed union wrapped in a group
     {ok, Root} = ecapnp:set_root('Test', test_capnp),
-    Grp = ecapnp:get(opts, Root),
-    ok = ecapnp:set({text, <<"testing">>}, Grp),
+    ok = ecapnp:set(opts, {text, <<"testing">>}, Root),
     Data = ecapnp_data:get_segments((Root#object.ref)#ref.data#builder.pid),
     ?assertEqual(
       [<<0:32/integer, 2,0, 6,0, %% Test struct, 16 bytes, 6 ptrs