From 531eefc3cc18f2e323ab9c4a26d842a6b7e078c5 Mon Sep 17 00:00:00 2001 From: Alex Helfet Date: Mon, 27 Mar 2017 03:30:37 +0100 Subject: [PATCH] Rewrite tests/example-test.cpp to use addressbook example from capnproto C++ project. --- Makefile.am | 6 +- README.md | 8 +- tests/addressbook.capnp | 58 +++++++++++ tests/addressbook.capnp.c | 200 ++++++++++++++++++++++++++++++++++++++ tests/addressbook.capnp.h | 134 +++++++++++++++++++++++++ tests/example-test.cpp | 102 +++++++++++++------ tests/example.capnp | 10 -- tests/example.capnp.c | 66 ------------- tests/example.capnp.h | 56 ----------- 9 files changed, 474 insertions(+), 166 deletions(-) create mode 100644 tests/addressbook.capnp create mode 100644 tests/addressbook.capnp.c create mode 100644 tests/addressbook.capnp.h delete mode 100644 tests/example.capnp delete mode 100644 tests/example.capnp.c delete mode 100644 tests/example.capnp.h diff --git a/Makefile.am b/Makefile.am index edf8d95..7847d78 100644 --- a/Makefile.am +++ b/Makefile.am @@ -63,19 +63,19 @@ capn_test_SOURCES = \ tests/capn-test.cpp \ tests/capn-stream-test.cpp \ tests/example-test.cpp \ - tests/example.capnp.c \ + tests/addressbook.capnp.c \ compiler/test.capnp.c \ compiler/schema-test.cpp \ compiler/schema.capnp.c noinst_HEADERS += \ compiler/test.capnp.h \ - tests/example.capnp.h + tests/addressbook.capnp.h EXTRA_DIST += \ compiler/c.capnp \ compiler/c++.capnp \ compiler/schema.capnp \ compiler/test.capnp \ - tests/example.capnp + tests/addressbook.capnp capn_test_CPPFLAGS = $(AM_CPPFLAGS) $(GTEST_CPPFLAGS) capn_test_CXXFLAGS = -std=gnu++11 -pthread capn_test_LDADD = libcapnp_c.la $(GTEST_LDADD) diff --git a/README.md b/README.md index d12cd5d..8b46dd2 100644 --- a/README.md +++ b/README.md @@ -58,7 +58,9 @@ struct MyStruct {} ### Example C code -See the unit tests in [`tests/example-test.cpp`](tests/example-test.cpp). The example schema file is [`tests/example.capnp`](tests/example.capnp). The tests are written in C++, but only use C features. +See the unit tests in [`tests/example-test.cpp`](tests/example-test.cpp). +The example schema file is [`tests/addressbook.capnp`](tests/addressbook.capnp). +The tests are written in C++, but only use C features. You need to compile these runtime library files and link them into your own project's binaries: @@ -66,7 +68,9 @@ You need to compile these runtime library files and link them into your own proj * [`lib/capn-malloc.c`](lib/capn-malloc.c) * [`lib/capn-stream.c`](lib/capn-stream.c) -Your include path must contain the runtime library directory [`lib`](lib). Header file [`lib/capnp_c.h`](lib/capnp_c.h) contains the public interfaces of the library. +Your include path must contain the runtime library directory +[`lib`](lib). Header file [`lib/capnp_c.h`](lib/capnp_c.h) contains +the public interfaces of the library. Using make-based builds, make may try to compile `${x}.capnp` from `${x}.capnp.c` using its built-in rule for compiling `${y}` from diff --git a/tests/addressbook.capnp b/tests/addressbook.capnp new file mode 100644 index 0000000..faedaa0 --- /dev/null +++ b/tests/addressbook.capnp @@ -0,0 +1,58 @@ +# From https://github.com/sandstorm-io/capnproto/blob/6816634a08b08bc8f52b4ee809afb58389f19655/c%2B%2B/samples/addressbook.capnp +# +# Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors +# Licensed under the MIT License: +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. + +@0x9eb32e19f86ee174; + +using C = import "/c.capnp"; +$C.fieldgetset; + +struct Person { + id @0 :UInt32; + name @1 :Text; + email @2 :Text; + phones @3 :List(PhoneNumber); + + struct PhoneNumber { + number @0 :Text; + type @1 :Type; + + enum Type { + mobile @0; + home @1; + work @2; + } + } + + employment :union { + unemployed @4 :Void; + employer @5 :Text; + school @6 :Text; + selfEmployed @7 :Void; + # We assume that a person is only one of these. + } +} + +struct AddressBook { + people @0 :List(Person); +} + diff --git a/tests/addressbook.capnp.c b/tests/addressbook.capnp.c new file mode 100644 index 0000000..db2ad3c --- /dev/null +++ b/tests/addressbook.capnp.c @@ -0,0 +1,200 @@ +#include "addressbook.capnp.h" +/* AUTO GENERATED - DO NOT EDIT */ +static const capn_text capn_val0 = {0,"",0}; + +Person_ptr new_Person(struct capn_segment *s) { + Person_ptr p; + p.p = capn_new_struct(s, 8, 4); + return p; +} +Person_list new_Person_list(struct capn_segment *s, int len) { + Person_list p; + p.p = capn_new_list(s, len, 8, 4); + return p; +} +void read_Person(struct Person *s, Person_ptr p) { + capn_resolve(&p.p); + s->id = capn_read32(p.p, 0); + s->name = capn_get_text(p.p, 0, capn_val0); + s->email = capn_get_text(p.p, 1, capn_val0); + s->phones.p = capn_getp(p.p, 2, 0); + s->employment_which = (enum Person_employment_which)(int) capn_read16(p.p, 4); + switch (s->employment_which) { + case Person_employment_employer: + case Person_employment_school: + s->employment.school = capn_get_text(p.p, 3, capn_val0); + break; + default: + break; + } +} +void write_Person(const struct Person *s, Person_ptr p) { + capn_resolve(&p.p); + capn_write32(p.p, 0, s->id); + capn_set_text(p.p, 0, s->name); + capn_set_text(p.p, 1, s->email); + capn_setp(p.p, 2, s->phones.p); + capn_write16(p.p, 4, s->employment_which); + switch (s->employment_which) { + case Person_employment_employer: + case Person_employment_school: + capn_set_text(p.p, 3, s->employment.school); + break; + default: + break; + } +} +void get_Person(struct Person *s, Person_list l, int i) { + Person_ptr p; + p.p = capn_getp(l.p, i, 0); + read_Person(s, p); +} +void set_Person(const struct Person *s, Person_list l, int i) { + Person_ptr p; + p.p = capn_getp(l.p, i, 0); + write_Person(s, p); +} + +uint32_t Person_get_id(Person_ptr p) +{ + uint32_t id; + id = capn_read32(p.p, 0); + return id; +} + +capn_text Person_get_name(Person_ptr p) +{ + capn_text name; + name = capn_get_text(p.p, 0, capn_val0); + return name; +} + +capn_text Person_get_email(Person_ptr p) +{ + capn_text email; + email = capn_get_text(p.p, 1, capn_val0); + return email; +} + +Person_PhoneNumber_list Person_get_phones(Person_ptr p) +{ + Person_PhoneNumber_list phones; + phones.p = capn_getp(p.p, 2, 0); + return phones; +} + +void Person_set_id(Person_ptr p, uint32_t id) +{ + capn_write32(p.p, 0, id); +} + +void Person_set_name(Person_ptr p, capn_text name) +{ + capn_set_text(p.p, 0, name); +} + +void Person_set_email(Person_ptr p, capn_text email) +{ + capn_set_text(p.p, 1, email); +} + +void Person_set_phones(Person_ptr p, Person_PhoneNumber_list phones) +{ + capn_setp(p.p, 2, phones.p); +} + +Person_PhoneNumber_ptr new_Person_PhoneNumber(struct capn_segment *s) { + Person_PhoneNumber_ptr p; + p.p = capn_new_struct(s, 8, 1); + return p; +} +Person_PhoneNumber_list new_Person_PhoneNumber_list(struct capn_segment *s, int len) { + Person_PhoneNumber_list p; + p.p = capn_new_list(s, len, 8, 1); + return p; +} +void read_Person_PhoneNumber(struct Person_PhoneNumber *s, Person_PhoneNumber_ptr p) { + capn_resolve(&p.p); + s->number = capn_get_text(p.p, 0, capn_val0); + s->type = (enum Person_PhoneNumber_Type)(int) capn_read16(p.p, 0); +} +void write_Person_PhoneNumber(const struct Person_PhoneNumber *s, Person_PhoneNumber_ptr p) { + capn_resolve(&p.p); + capn_set_text(p.p, 0, s->number); + capn_write16(p.p, 0, (uint16_t) (s->type)); +} +void get_Person_PhoneNumber(struct Person_PhoneNumber *s, Person_PhoneNumber_list l, int i) { + Person_PhoneNumber_ptr p; + p.p = capn_getp(l.p, i, 0); + read_Person_PhoneNumber(s, p); +} +void set_Person_PhoneNumber(const struct Person_PhoneNumber *s, Person_PhoneNumber_list l, int i) { + Person_PhoneNumber_ptr p; + p.p = capn_getp(l.p, i, 0); + write_Person_PhoneNumber(s, p); +} + +capn_text Person_PhoneNumber_get_number(Person_PhoneNumber_ptr p) +{ + capn_text number; + number = capn_get_text(p.p, 0, capn_val0); + return number; +} + +enum Person_PhoneNumber_Type Person_PhoneNumber_get_type(Person_PhoneNumber_ptr p) +{ + enum Person_PhoneNumber_Type type; + type = (enum Person_PhoneNumber_Type)(int) capn_read16(p.p, 0); + return type; +} + +void Person_PhoneNumber_set_number(Person_PhoneNumber_ptr p, capn_text number) +{ + capn_set_text(p.p, 0, number); +} + +void Person_PhoneNumber_set_type(Person_PhoneNumber_ptr p, enum Person_PhoneNumber_Type type) +{ + capn_write16(p.p, 0, (uint16_t) (type)); +} + +AddressBook_ptr new_AddressBook(struct capn_segment *s) { + AddressBook_ptr p; + p.p = capn_new_struct(s, 0, 1); + return p; +} +AddressBook_list new_AddressBook_list(struct capn_segment *s, int len) { + AddressBook_list p; + p.p = capn_new_list(s, len, 0, 1); + return p; +} +void read_AddressBook(struct AddressBook *s, AddressBook_ptr p) { + capn_resolve(&p.p); + s->people.p = capn_getp(p.p, 0, 0); +} +void write_AddressBook(const struct AddressBook *s, AddressBook_ptr p) { + capn_resolve(&p.p); + capn_setp(p.p, 0, s->people.p); +} +void get_AddressBook(struct AddressBook *s, AddressBook_list l, int i) { + AddressBook_ptr p; + p.p = capn_getp(l.p, i, 0); + read_AddressBook(s, p); +} +void set_AddressBook(const struct AddressBook *s, AddressBook_list l, int i) { + AddressBook_ptr p; + p.p = capn_getp(l.p, i, 0); + write_AddressBook(s, p); +} + +Person_list AddressBook_get_people(AddressBook_ptr p) +{ + Person_list people; + people.p = capn_getp(p.p, 0, 0); + return people; +} + +void AddressBook_set_people(AddressBook_ptr p, Person_list people) +{ + capn_setp(p.p, 0, people.p); +} diff --git a/tests/addressbook.capnp.h b/tests/addressbook.capnp.h new file mode 100644 index 0000000..80be6c8 --- /dev/null +++ b/tests/addressbook.capnp.h @@ -0,0 +1,134 @@ +#ifndef CAPN_9EB32E19F86EE174 +#define CAPN_9EB32E19F86EE174 +/* AUTO GENERATED - DO NOT EDIT */ +#include + +#if CAPN_VERSION != 1 +#error "version mismatch between capnp_c.h and generated code" +#endif + +#include "c.capnp.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct Person; +struct Person_PhoneNumber; +struct AddressBook; + +typedef struct {capn_ptr p;} Person_ptr; +typedef struct {capn_ptr p;} Person_PhoneNumber_ptr; +typedef struct {capn_ptr p;} AddressBook_ptr; + +typedef struct {capn_ptr p;} Person_list; +typedef struct {capn_ptr p;} Person_PhoneNumber_list; +typedef struct {capn_ptr p;} AddressBook_list; + +enum Person_PhoneNumber_Type { + Person_PhoneNumber_Type_mobile = 0, + Person_PhoneNumber_Type_home = 1, + Person_PhoneNumber_Type_work = 2 +}; +enum Person_employment_which { + Person_employment_unemployed = 0, + Person_employment_employer = 1, + Person_employment_school = 2, + Person_employment_selfEmployed = 3 +}; + +struct Person { + uint32_t id; + capn_text name; + capn_text email; + Person_PhoneNumber_list phones; + enum Person_employment_which employment_which; + union { + capn_text employer; + capn_text school; + } employment; +}; + +static const size_t Person_word_count = 1; + +static const size_t Person_pointer_count = 4; + +static const size_t Person_struct_bytes_count = 40; + +uint32_t Person_get_id(Person_ptr p); + +capn_text Person_get_name(Person_ptr p); + +capn_text Person_get_email(Person_ptr p); + +Person_PhoneNumber_list Person_get_phones(Person_ptr p); + +void Person_set_id(Person_ptr p, uint32_t id); + +void Person_set_name(Person_ptr p, capn_text name); + +void Person_set_email(Person_ptr p, capn_text email); + +void Person_set_phones(Person_ptr p, Person_PhoneNumber_list phones); + +struct Person_PhoneNumber { + capn_text number; + enum Person_PhoneNumber_Type type; +}; + +static const size_t Person_PhoneNumber_word_count = 1; + +static const size_t Person_PhoneNumber_pointer_count = 1; + +static const size_t Person_PhoneNumber_struct_bytes_count = 16; + +capn_text Person_PhoneNumber_get_number(Person_PhoneNumber_ptr p); + +enum Person_PhoneNumber_Type Person_PhoneNumber_get_type(Person_PhoneNumber_ptr p); + +void Person_PhoneNumber_set_number(Person_PhoneNumber_ptr p, capn_text number); + +void Person_PhoneNumber_set_type(Person_PhoneNumber_ptr p, enum Person_PhoneNumber_Type type); + +struct AddressBook { + Person_list people; +}; + +static const size_t AddressBook_word_count = 0; + +static const size_t AddressBook_pointer_count = 1; + +static const size_t AddressBook_struct_bytes_count = 8; + +Person_list AddressBook_get_people(AddressBook_ptr p); + +void AddressBook_set_people(AddressBook_ptr p, Person_list people); + +Person_ptr new_Person(struct capn_segment*); +Person_PhoneNumber_ptr new_Person_PhoneNumber(struct capn_segment*); +AddressBook_ptr new_AddressBook(struct capn_segment*); + +Person_list new_Person_list(struct capn_segment*, int len); +Person_PhoneNumber_list new_Person_PhoneNumber_list(struct capn_segment*, int len); +AddressBook_list new_AddressBook_list(struct capn_segment*, int len); + +void read_Person(struct Person*, Person_ptr); +void read_Person_PhoneNumber(struct Person_PhoneNumber*, Person_PhoneNumber_ptr); +void read_AddressBook(struct AddressBook*, AddressBook_ptr); + +void write_Person(const struct Person*, Person_ptr); +void write_Person_PhoneNumber(const struct Person_PhoneNumber*, Person_PhoneNumber_ptr); +void write_AddressBook(const struct AddressBook*, AddressBook_ptr); + +void get_Person(struct Person*, Person_list, int i); +void get_Person_PhoneNumber(struct Person_PhoneNumber*, Person_PhoneNumber_list, int i); +void get_AddressBook(struct AddressBook*, AddressBook_list, int i); + +void set_Person(const struct Person*, Person_list, int i); +void set_Person_PhoneNumber(const struct Person_PhoneNumber*, Person_PhoneNumber_list, int i); +void set_AddressBook(const struct AddressBook*, AddressBook_list, int i); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/tests/example-test.cpp b/tests/example-test.cpp index 4c4f202..39e31b0 100644 --- a/tests/example-test.cpp +++ b/tests/example-test.cpp @@ -12,34 +12,63 @@ #include #include "capnp_c.h" -#include "example.capnp.h" +#include "addressbook.capnp.h" -TEST(Examples, RoundTrip) { +static capn_text chars_to_text(const char *chars) { + return (capn_text) { + .len = (int) strlen(chars), + .str = chars, + .seg = NULL, + }; +} + +// EXPECT_CAPN_TEXT_EQ arguments: +// const char * expected +// capn_text t +#define EXPECT_CAPN_TEXT_EQ(expected, t) \ + do { \ + EXPECT_EQ(strlen((expected)), (uint32_t) (t).len); \ + EXPECT_STREQ((expected), (t).str); \ + } while(0); + +TEST(Examples, RoundTripPerson) { uint8_t buf[4096]; ssize_t sz = 0; - const char *s = "Hello."; + const char *name = "Firstname Lastname"; + const char *email = "username@domain.com"; + const char *school = "of life"; + + struct capn c; + capn_init_malloc(&c); + capn_ptr cr = capn_root(&c); + struct capn_segment *cs = cr.seg; { - // Set initial object in `g`. - const capn_text capn_val0 = { - .len = (int) strlen(s), - .str = s, - .seg = NULL - }; - struct Greeting g = { - .text = capn_val0, - .timesToSay = 17, + // Set initial object in `p`. + struct Person p = { + .id = 17, + .name = chars_to_text(name), + .email = chars_to_text(email), }; + p.employment_which = Person_employment_school; + p.employment.school = chars_to_text(school); - // Serialize `g` to `buf[0..sz-1]`. - struct capn c; - capn_init_malloc(&c); - capn_ptr cr = capn_root(&c); - struct capn_segment *cs = cr.seg; - Greeting_ptr gp = new_Greeting(cs); - write_Greeting(&g, gp); - int setp_ret = capn_setp(capn_root(&c), 0, gp.p); + p.phones = new_Person_PhoneNumber_list(cs, 2); + struct Person_PhoneNumber pn0 = { + .number = chars_to_text("123"), + .type = Person_PhoneNumber_Type_work, + }; + set_Person_PhoneNumber(&pn0, p.phones, 0); + struct Person_PhoneNumber pn1 = { + .number = chars_to_text("234"), + .type = Person_PhoneNumber_Type_home, + }; + set_Person_PhoneNumber(&pn1, p.phones, 1); + + Person_ptr pp = new_Person(cs); + write_Person(&p, pp); + int setp_ret = capn_setp(capn_root(&c), 0, pp.p); ASSERT_EQ(0, setp_ret); sz = capn_write_mem(&c, buf, sizeof(buf), 0 /* packed */); capn_free(&c); @@ -47,7 +76,7 @@ TEST(Examples, RoundTrip) { { // Write serialized object to file system. - FILE *f = fopen("tests/example-test.cpp.Greeting.out", "wb"); + FILE *f = fopen("tests/example-test.cpp.Person.out", "wb"); ASSERT_NE(f, (void*)0); fwrite(buf, 1 /* size */, sz /* count */, f); int close_ret = fclose(f); @@ -55,18 +84,33 @@ TEST(Examples, RoundTrip) { } { - // Deserialize `buf[0..sz-1]` to `rg`. + // Deserialize `buf[0..sz-1]` to `rp`. struct capn rc; int init_mem_ret = capn_init_mem(&rc, buf, sz, 0 /* packed */); ASSERT_EQ(0, init_mem_ret); - Greeting_ptr rroot; - struct Greeting rg; + Person_ptr rroot; + struct Person rp; rroot.p = capn_getp(capn_root(&rc), 0 /* off */, 1 /* resolve */); - read_Greeting(&rg, rroot); + read_Person(&rp, rroot); - // Assert deserialized values in `rg` - EXPECT_EQ(rg.timesToSay, (uint32_t) 17); - EXPECT_EQ(strlen(s), (uint32_t) rg.text.len); - EXPECT_EQ(0, strncmp(s, rg.text.str, strlen(s))); + // Assert deserialized values in `rp` + EXPECT_EQ(rp.id, (uint32_t) 17); + EXPECT_CAPN_TEXT_EQ(name, rp.name); + EXPECT_CAPN_TEXT_EQ(email, rp.email); + + EXPECT_EQ(rp.employment_which, Person_employment_school); + EXPECT_CAPN_TEXT_EQ(school, rp.employment.school); + + struct Person_PhoneNumber rpn0; + get_Person_PhoneNumber(&rpn0, rp.phones, 0); + EXPECT_CAPN_TEXT_EQ("123", rpn0.number); + EXPECT_EQ(rpn0.type, Person_PhoneNumber_Type_work); + + struct Person_PhoneNumber rpn1; + get_Person_PhoneNumber(&rpn1, rp.phones, 1); + EXPECT_CAPN_TEXT_EQ("234", rpn1.number); + EXPECT_EQ(rpn1.type, Person_PhoneNumber_Type_home); } } + +// TODO: Accessor read/write vs read_/write_. diff --git a/tests/example.capnp b/tests/example.capnp deleted file mode 100644 index cbf7c45..0000000 --- a/tests/example.capnp +++ /dev/null @@ -1,10 +0,0 @@ -@0xd120e9a4c43868ab; - -using C = import "/c.capnp"; - -$C.fieldgetset; - -struct Greeting { - text @0 :Text = "Default greeting: hello world!"; - timesToSay @1 :UInt32; -} diff --git a/tests/example.capnp.c b/tests/example.capnp.c deleted file mode 100644 index 0c4dfed..0000000 --- a/tests/example.capnp.c +++ /dev/null @@ -1,66 +0,0 @@ -#include "example.capnp.h" -/* AUTO GENERATED - DO NOT EDIT */ -static const capn_text capn_val0 = {0,"",0}; -static const uint8_t capn_buf[32] = { - 68,101,102,97,117,108,116,32, - 103,114,101,101,116,105,110,103, - 58,32,104,101,108,108,111,32, - 119,111,114,108,100,33,0,0 -}; -static const struct capn_segment capn_seg = {{0},0,0,0,(char*)&capn_buf[0],32,32,0}; -static capn_text capn_val1 = {30,(char*)&capn_buf[0],(struct capn_segment*)&capn_seg}; - -Greeting_ptr new_Greeting(struct capn_segment *s) { - Greeting_ptr p; - p.p = capn_new_struct(s, 8, 1); - return p; -} -Greeting_list new_Greeting_list(struct capn_segment *s, int len) { - Greeting_list p; - p.p = capn_new_list(s, len, 8, 1); - return p; -} -void read_Greeting(struct Greeting *s, Greeting_ptr p) { - capn_resolve(&p.p); - s->text = capn_get_text(p.p, 0, capn_val1); - s->timesToSay = capn_read32(p.p, 0); -} -void write_Greeting(const struct Greeting *s, Greeting_ptr p) { - capn_resolve(&p.p); - capn_set_text(p.p, 0, (s->text.str != capn_val1.str) ? s->text : capn_val0); - capn_write32(p.p, 0, s->timesToSay); -} -void get_Greeting(struct Greeting *s, Greeting_list l, int i) { - Greeting_ptr p; - p.p = capn_getp(l.p, i, 0); - read_Greeting(s, p); -} -void set_Greeting(const struct Greeting *s, Greeting_list l, int i) { - Greeting_ptr p; - p.p = capn_getp(l.p, i, 0); - write_Greeting(s, p); -} - -capn_text Greeting_get_text(Greeting_ptr p) -{ - capn_text text; - text = capn_get_text(p.p, 0, capn_val1); - return text; -} - -uint32_t Greeting_get_timesToSay(Greeting_ptr p) -{ - uint32_t timesToSay; - timesToSay = capn_read32(p.p, 0); - return timesToSay; -} - -void Greeting_set_text(Greeting_ptr p, capn_text text) -{ - capn_set_text(p.p, 0, (text.str != capn_val1.str) ? text : capn_val0); -} - -void Greeting_set_timesToSay(Greeting_ptr p, uint32_t timesToSay) -{ - capn_write32(p.p, 0, timesToSay); -} diff --git a/tests/example.capnp.h b/tests/example.capnp.h deleted file mode 100644 index 7a8fd17..0000000 --- a/tests/example.capnp.h +++ /dev/null @@ -1,56 +0,0 @@ -#ifndef CAPN_D120E9A4C43868AB -#define CAPN_D120E9A4C43868AB -/* AUTO GENERATED - DO NOT EDIT */ -#include - -#if CAPN_VERSION != 1 -#error "version mismatch between capnp_c.h and generated code" -#endif - -#include "c.capnp.h" - -#ifdef __cplusplus -extern "C" { -#endif - -struct Greeting; - -typedef struct {capn_ptr p;} Greeting_ptr; - -typedef struct {capn_ptr p;} Greeting_list; - -struct Greeting { - capn_text text; - uint32_t timesToSay; -}; - -static const size_t Greeting_word_count = 1; - -static const size_t Greeting_pointer_count = 1; - -static const size_t Greeting_struct_bytes_count = 16; - -capn_text Greeting_get_text(Greeting_ptr p); - -uint32_t Greeting_get_timesToSay(Greeting_ptr p); - -void Greeting_set_text(Greeting_ptr p, capn_text text); - -void Greeting_set_timesToSay(Greeting_ptr p, uint32_t timesToSay); - -Greeting_ptr new_Greeting(struct capn_segment*); - -Greeting_list new_Greeting_list(struct capn_segment*, int len); - -void read_Greeting(struct Greeting*, Greeting_ptr); - -void write_Greeting(const struct Greeting*, Greeting_ptr); - -void get_Greeting(struct Greeting*, Greeting_list, int i); - -void set_Greeting(const struct Greeting*, Greeting_list, int i); - -#ifdef __cplusplus -} -#endif -#endif