hyperswarm-peer / swarmd / schema / swarmd_schema.c

// This file is autogenerated by hyperschema-c
// !!DO NOT EDIT!!

#include "swarmd_schema.h"

int
swarmd_hello_request_preencode (compact_state_t *state, const swarmd_hello_request_t *value)
{
  int err;
  if ((err = compact_preencode_utf8(state, value->name)) < 0) return err;
  if ((err = compact_preencode_fixed32(state, value->app_identity)) < 0) return err;
  if ((err = compact_preencode_uint(state, value->version)) < 0) return err;
  return 0;
}

int
swarmd_hello_request_encode (compact_state_t *state, const swarmd_hello_request_t *value)
{
  int err;
  if ((err = compact_encode_utf8(state, value->name)) < 0) return err;
  if ((err = compact_encode_fixed32(state, value->app_identity)) < 0) return err;
  if ((err = compact_encode_uint(state, value->version)) < 0) return err;
  return 0;
}

int
swarmd_hello_request_decode (compact_state_t *state, swarmd_hello_request_t *result)
{
  int err;
  if ((err = compact_decode_utf8(state, &result->name)) < 0) return err;
  if ((err = compact_decode_fixed32(state, result->app_identity)) < 0) return err;
  if ((err = compact_decode_uint(state, &result->version)) < 0) return err;
  return 0;
}

void
swarmd_hello_request_destroy (swarmd_hello_request_t *result)
{
}

int
swarmd_hello_response_preencode (compact_state_t *state, const swarmd_hello_response_t *value)
{
  int err;
  if ((err = compact_preencode_uint(state, value->client_id)) < 0) return err;
  if ((err = compact_preencode_fixed32(state, value->daemon_pubkey)) < 0) return err;
  return 0;
}

int
swarmd_hello_response_encode (compact_state_t *state, const swarmd_hello_response_t *value)
{
  int err;
  if ((err = compact_encode_uint(state, value->client_id)) < 0) return err;
  if ((err = compact_encode_fixed32(state, value->daemon_pubkey)) < 0) return err;
  return 0;
}

int
swarmd_hello_response_decode (compact_state_t *state, swarmd_hello_response_t *result)
{
  int err;
  if ((err = compact_decode_uint(state, &result->client_id)) < 0) return err;
  if ((err = compact_decode_fixed32(state, result->daemon_pubkey)) < 0) return err;
  return 0;
}

void
swarmd_hello_response_destroy (swarmd_hello_response_t *result)
{
}

int
swarmd_status_preencode (compact_state_t *state, const swarmd_status_t *value)
{
  int err;
  if ((err = compact_preencode_uint(state, value->dht_state)) < 0) return err;
  uint64_t flags = 0;
  if (value->bootstrapped) flags |= ((uint64_t)1 << 0);
  if ((err = compact_preencode_uint(state, flags)) < 0) return err;
  if ((err = compact_preencode_uint(state, value->peers_known)) < 0) return err;
  if ((err = compact_preencode_uint(state, value->peers_connected)) < 0) return err;
  if ((err = compact_preencode_uint(state, value->connecting)) < 0) return err;
  if ((err = compact_preencode_uint(state, value->queued)) < 0) return err;
  if ((err = compact_preencode_uint(state, value->local_clients)) < 0) return err;
  return 0;
}

int
swarmd_status_encode (compact_state_t *state, const swarmd_status_t *value)
{
  int err;
  if ((err = compact_encode_uint(state, value->dht_state)) < 0) return err;
  uint64_t flags = 0;
  if (value->bootstrapped) flags |= ((uint64_t)1 << 0);
  if ((err = compact_encode_uint(state, flags)) < 0) return err;
  if ((err = compact_encode_uint(state, value->peers_known)) < 0) return err;
  if ((err = compact_encode_uint(state, value->peers_connected)) < 0) return err;
  if ((err = compact_encode_uint(state, value->connecting)) < 0) return err;
  if ((err = compact_encode_uint(state, value->queued)) < 0) return err;
  if ((err = compact_encode_uint(state, value->local_clients)) < 0) return err;
  return 0;
}

int
swarmd_status_decode (compact_state_t *state, swarmd_status_t *result)
{
  int err;
  if ((err = compact_decode_uint(state, &result->dht_state)) < 0) return err;
  uint64_t flags = 0;
  if ((err = compact_decode_uint(state, &flags)) < 0) return err;
  result->bootstrapped = (flags & ((uint64_t)1 << 0)) != 0;
  if ((err = compact_decode_uint(state, &result->peers_known)) < 0) return err;
  if ((err = compact_decode_uint(state, &result->peers_connected)) < 0) return err;
  if ((err = compact_decode_uint(state, &result->connecting)) < 0) return err;
  if ((err = compact_decode_uint(state, &result->queued)) < 0) return err;
  if ((err = compact_decode_uint(state, &result->local_clients)) < 0) return err;
  return 0;
}

void
swarmd_status_destroy (swarmd_status_t *result)
{
}

int
swarmd_ok_preencode (compact_state_t *state, const swarmd_ok_t *value)
{
  int err;
  uint64_t flags = 0;
  if (value->ok) flags |= ((uint64_t)1 << 0);
  if ((err = compact_preencode_uint(state, flags)) < 0) return err;
  return 0;
}

int
swarmd_ok_encode (compact_state_t *state, const swarmd_ok_t *value)
{
  int err;
  uint64_t flags = 0;
  if (value->ok) flags |= ((uint64_t)1 << 0);
  if ((err = compact_encode_uint(state, flags)) < 0) return err;
  return 0;
}

int
swarmd_ok_decode (compact_state_t *state, swarmd_ok_t *result)
{
  int err;
  uint64_t flags = 0;
  if ((err = compact_decode_uint(state, &flags)) < 0) return err;
  result->ok = (flags & ((uint64_t)1 << 0)) != 0;
  return 0;
}

void
swarmd_ok_destroy (swarmd_ok_t *result)
{
}

int
swarmd_none_preencode (compact_state_t *state, const swarmd_none_t *value)
{
  int err;
  if ((err = compact_preencode_uint(state, value->reserved)) < 0) return err;
  return 0;
}

int
swarmd_none_encode (compact_state_t *state, const swarmd_none_t *value)
{
  int err;
  if ((err = compact_encode_uint(state, value->reserved)) < 0) return err;
  return 0;
}

int
swarmd_none_decode (compact_state_t *state, swarmd_none_t *result)
{
  int err;
  if ((err = compact_decode_uint(state, &result->reserved)) < 0) return err;
  return 0;
}

void
swarmd_none_destroy (swarmd_none_t *result)
{
}

int
swarmd_swarm_join_preencode (compact_state_t *state, const swarmd_swarm_join_t *value)
{
  int err;
  if ((err = compact_preencode_fixed32(state, value->topic)) < 0) return err;
  uint64_t flags = 0;
  if (value->server) flags |= ((uint64_t)1 << 0);
  if (value->client) flags |= ((uint64_t)1 << 1);
  if ((err = compact_preencode_uint(state, flags)) < 0) return err;
  return 0;
}

int
swarmd_swarm_join_encode (compact_state_t *state, const swarmd_swarm_join_t *value)
{
  int err;
  if ((err = compact_encode_fixed32(state, value->topic)) < 0) return err;
  uint64_t flags = 0;
  if (value->server) flags |= ((uint64_t)1 << 0);
  if (value->client) flags |= ((uint64_t)1 << 1);
  if ((err = compact_encode_uint(state, flags)) < 0) return err;
  return 0;
}

int
swarmd_swarm_join_decode (compact_state_t *state, swarmd_swarm_join_t *result)
{
  int err;
  if ((err = compact_decode_fixed32(state, result->topic)) < 0) return err;
  uint64_t flags = 0;
  if ((err = compact_decode_uint(state, &flags)) < 0) return err;
  result->server = (flags & ((uint64_t)1 << 0)) != 0;
  result->client = (flags & ((uint64_t)1 << 1)) != 0;
  return 0;
}

void
swarmd_swarm_join_destroy (swarmd_swarm_join_t *result)
{
}

int
swarmd_topic_ref_preencode (compact_state_t *state, const swarmd_topic_ref_t *value)
{
  int err;
  if ((err = compact_preencode_fixed32(state, value->topic)) < 0) return err;
  return 0;
}

int
swarmd_topic_ref_encode (compact_state_t *state, const swarmd_topic_ref_t *value)
{
  int err;
  if ((err = compact_encode_fixed32(state, value->topic)) < 0) return err;
  return 0;
}

int
swarmd_topic_ref_decode (compact_state_t *state, swarmd_topic_ref_t *result)
{
  int err;
  if ((err = compact_decode_fixed32(state, result->topic)) < 0) return err;
  return 0;
}

void
swarmd_topic_ref_destroy (swarmd_topic_ref_t *result)
{
}

int
swarmd_peer_key_preencode (compact_state_t *state, const swarmd_peer_key_t *value)
{
  int err;
  if ((err = compact_preencode_fixed32(state, value->pubkey)) < 0) return err;
  return 0;
}

int
swarmd_peer_key_encode (compact_state_t *state, const swarmd_peer_key_t *value)
{
  int err;
  if ((err = compact_encode_fixed32(state, value->pubkey)) < 0) return err;
  return 0;
}

int
swarmd_peer_key_decode (compact_state_t *state, swarmd_peer_key_t *result)
{
  int err;
  if ((err = compact_decode_fixed32(state, result->pubkey)) < 0) return err;
  return 0;
}

void
swarmd_peer_key_destroy (swarmd_peer_key_t *result)
{
}

int
swarmd_channel_open_preencode (compact_state_t *state, const swarmd_channel_open_t *value)
{
  int err;
  if ((err = compact_preencode_utf8(state, value->protocol)) < 0) return err;
  if ((err = compact_preencode_uint8array(state, value->id, value->id_len)) < 0) return err;
  if ((err = compact_preencode_uint(state, value->slots)) < 0) return err;
  return 0;
}

int
swarmd_channel_open_encode (compact_state_t *state, const swarmd_channel_open_t *value)
{
  int err;
  if ((err = compact_encode_utf8(state, value->protocol)) < 0) return err;
  if ((err = compact_encode_uint8array(state, value->id, value->id_len)) < 0) return err;
  if ((err = compact_encode_uint(state, value->slots)) < 0) return err;
  return 0;
}

int
swarmd_channel_open_decode (compact_state_t *state, swarmd_channel_open_t *result)
{
  int err;
  if ((err = compact_decode_utf8(state, &result->protocol)) < 0) return err;
  if ((err = compact_decode_uint8array(state, &result->id, &result->id_len)) < 0) return err;
  if ((err = compact_decode_uint(state, &result->slots)) < 0) return err;
  return 0;
}

void
swarmd_channel_open_destroy (swarmd_channel_open_t *result)
{
}

int
swarmd_channel_ref_preencode (compact_state_t *state, const swarmd_channel_ref_t *value)
{
  int err;
  if ((err = compact_preencode_uint(state, value->channel)) < 0) return err;
  return 0;
}

int
swarmd_channel_ref_encode (compact_state_t *state, const swarmd_channel_ref_t *value)
{
  int err;
  if ((err = compact_encode_uint(state, value->channel)) < 0) return err;
  return 0;
}

int
swarmd_channel_ref_decode (compact_state_t *state, swarmd_channel_ref_t *result)
{
  int err;
  if ((err = compact_decode_uint(state, &result->channel)) < 0) return err;
  return 0;
}

void
swarmd_channel_ref_destroy (swarmd_channel_ref_t *result)
{
}

int
swarmd_send_request_preencode (compact_state_t *state, const swarmd_send_request_t *value)
{
  int err;
  if ((err = compact_preencode_uint(state, value->channel)) < 0) return err;
  if ((err = compact_preencode_uint(state, value->slot)) < 0) return err;
  if ((err = compact_preencode_uint(state, value->target)) < 0) return err;
  if ((err = compact_preencode_uint8array(state, value->bytes, value->bytes_len)) < 0) return err;
  return 0;
}

int
swarmd_send_request_encode (compact_state_t *state, const swarmd_send_request_t *value)
{
  int err;
  if ((err = compact_encode_uint(state, value->channel)) < 0) return err;
  if ((err = compact_encode_uint(state, value->slot)) < 0) return err;
  if ((err = compact_encode_uint(state, value->target)) < 0) return err;
  if ((err = compact_encode_uint8array(state, value->bytes, value->bytes_len)) < 0) return err;
  return 0;
}

int
swarmd_send_request_decode (compact_state_t *state, swarmd_send_request_t *result)
{
  int err;
  if ((err = compact_decode_uint(state, &result->channel)) < 0) return err;
  if ((err = compact_decode_uint(state, &result->slot)) < 0) return err;
  if ((err = compact_decode_uint(state, &result->target)) < 0) return err;
  if ((err = compact_decode_uint8array(state, &result->bytes, &result->bytes_len)) < 0) return err;
  return 0;
}

void
swarmd_send_request_destroy (swarmd_send_request_t *result)
{
}

int
swarmd_send_result_preencode (compact_state_t *state, const swarmd_send_result_t *value)
{
  int err;
  uint64_t flags = 0;
  if (value->accepted) flags |= ((uint64_t)1 << 0);
  if (value->writable) flags |= ((uint64_t)1 << 1);
  if ((err = compact_preencode_uint(state, flags)) < 0) return err;
  return 0;
}

int
swarmd_send_result_encode (compact_state_t *state, const swarmd_send_result_t *value)
{
  int err;
  uint64_t flags = 0;
  if (value->accepted) flags |= ((uint64_t)1 << 0);
  if (value->writable) flags |= ((uint64_t)1 << 1);
  if ((err = compact_encode_uint(state, flags)) < 0) return err;
  return 0;
}

int
swarmd_send_result_decode (compact_state_t *state, swarmd_send_result_t *result)
{
  int err;
  uint64_t flags = 0;
  if ((err = compact_decode_uint(state, &flags)) < 0) return err;
  result->accepted = (flags & ((uint64_t)1 << 0)) != 0;
  result->writable = (flags & ((uint64_t)1 << 1)) != 0;
  return 0;
}

void
swarmd_send_result_destroy (swarmd_send_result_t *result)
{
}

int
swarmd_path_preencode (compact_state_t *state, const swarmd_path_t *value)
{
  int err;
  if ((err = compact_preencode_utf8(state, value->path)) < 0) return err;
  return 0;
}

int
swarmd_path_encode (compact_state_t *state, const swarmd_path_t *value)
{
  int err;
  if ((err = compact_encode_utf8(state, value->path)) < 0) return err;
  return 0;
}

int
swarmd_path_decode (compact_state_t *state, swarmd_path_t *result)
{
  int err;
  if ((err = compact_decode_utf8(state, &result->path)) < 0) return err;
  return 0;
}

void
swarmd_path_destroy (swarmd_path_t *result)
{
}

int
swarmd_hash_preencode (compact_state_t *state, const swarmd_hash_t *value)
{
  int err;
  if ((err = compact_preencode_fixed32(state, value->hash)) < 0) return err;
  return 0;
}

int
swarmd_hash_encode (compact_state_t *state, const swarmd_hash_t *value)
{
  int err;
  if ((err = compact_encode_fixed32(state, value->hash)) < 0) return err;
  return 0;
}

int
swarmd_hash_decode (compact_state_t *state, swarmd_hash_t *result)
{
  int err;
  if ((err = compact_decode_fixed32(state, result->hash)) < 0) return err;
  return 0;
}

void
swarmd_hash_destroy (swarmd_hash_t *result)
{
}

int
swarmd_content_serve_preencode (compact_state_t *state, const swarmd_content_serve_t *value)
{
  int err;
  if ((err = compact_preencode_fixed32(state, value->hash)) < 0) return err;
  if ((err = compact_preencode_utf8(state, value->path)) < 0) return err;
  return 0;
}

int
swarmd_content_serve_encode (compact_state_t *state, const swarmd_content_serve_t *value)
{
  int err;
  if ((err = compact_encode_fixed32(state, value->hash)) < 0) return err;
  if ((err = compact_encode_utf8(state, value->path)) < 0) return err;
  return 0;
}

int
swarmd_content_serve_decode (compact_state_t *state, swarmd_content_serve_t *result)
{
  int err;
  if ((err = compact_decode_fixed32(state, result->hash)) < 0) return err;
  if ((err = compact_decode_utf8(state, &result->path)) < 0) return err;
  return 0;
}

void
swarmd_content_serve_destroy (swarmd_content_serve_t *result)
{
}

int
swarmd_content_fetch_preencode (compact_state_t *state, const swarmd_content_fetch_t *value)
{
  int err;
  if ((err = compact_preencode_fixed32(state, value->hash)) < 0) return err;
  if ((err = compact_preencode_utf8(state, value->dest_path)) < 0) return err;
  return 0;
}

int
swarmd_content_fetch_encode (compact_state_t *state, const swarmd_content_fetch_t *value)
{
  int err;
  if ((err = compact_encode_fixed32(state, value->hash)) < 0) return err;
  if ((err = compact_encode_utf8(state, value->dest_path)) < 0) return err;
  return 0;
}

int
swarmd_content_fetch_decode (compact_state_t *state, swarmd_content_fetch_t *result)
{
  int err;
  if ((err = compact_decode_fixed32(state, result->hash)) < 0) return err;
  if ((err = compact_decode_utf8(state, &result->dest_path)) < 0) return err;
  return 0;
}

void
swarmd_content_fetch_destroy (swarmd_content_fetch_t *result)
{
}

int
swarmd_content_cancel_preencode (compact_state_t *state, const swarmd_content_cancel_t *value)
{
  int err;
  if ((err = compact_preencode_fixed32(state, value->hash)) < 0) return err;
  uint64_t flags = 0;
  if (value->discard) flags |= ((uint64_t)1 << 0);
  if ((err = compact_preencode_uint(state, flags)) < 0) return err;
  return 0;
}

int
swarmd_content_cancel_encode (compact_state_t *state, const swarmd_content_cancel_t *value)
{
  int err;
  if ((err = compact_encode_fixed32(state, value->hash)) < 0) return err;
  uint64_t flags = 0;
  if (value->discard) flags |= ((uint64_t)1 << 0);
  if ((err = compact_encode_uint(state, flags)) < 0) return err;
  return 0;
}

int
swarmd_content_cancel_decode (compact_state_t *state, swarmd_content_cancel_t *result)
{
  int err;
  if ((err = compact_decode_fixed32(state, result->hash)) < 0) return err;
  uint64_t flags = 0;
  if ((err = compact_decode_uint(state, &flags)) < 0) return err;
  result->discard = (flags & ((uint64_t)1 << 0)) != 0;
  return 0;
}

void
swarmd_content_cancel_destroy (swarmd_content_cancel_t *result)
{
}

int
swarmd_content_progress_preencode (compact_state_t *state, const swarmd_content_progress_t *value)
{
  int err;
  if ((err = compact_preencode_fixed32(state, value->hash)) < 0) return err;
  if ((err = compact_preencode_uint(state, value->received)) < 0) return err;
  if ((err = compact_preencode_uint(state, value->total)) < 0) return err;
  return 0;
}

int
swarmd_content_progress_encode (compact_state_t *state, const swarmd_content_progress_t *value)
{
  int err;
  if ((err = compact_encode_fixed32(state, value->hash)) < 0) return err;
  if ((err = compact_encode_uint(state, value->received)) < 0) return err;
  if ((err = compact_encode_uint(state, value->total)) < 0) return err;
  return 0;
}

int
swarmd_content_progress_decode (compact_state_t *state, swarmd_content_progress_t *result)
{
  int err;
  if ((err = compact_decode_fixed32(state, result->hash)) < 0) return err;
  if ((err = compact_decode_uint(state, &result->received)) < 0) return err;
  if ((err = compact_decode_uint(state, &result->total)) < 0) return err;
  return 0;
}

void
swarmd_content_progress_destroy (swarmd_content_progress_t *result)
{
}

int
swarmd_content_done_preencode (compact_state_t *state, const swarmd_content_done_t *value)
{
  int err;
  if ((err = compact_preencode_fixed32(state, value->hash)) < 0) return err;
  if ((err = compact_preencode_utf8(state, value->path)) < 0) return err;
  return 0;
}

int
swarmd_content_done_encode (compact_state_t *state, const swarmd_content_done_t *value)
{
  int err;
  if ((err = compact_encode_fixed32(state, value->hash)) < 0) return err;
  if ((err = compact_encode_utf8(state, value->path)) < 0) return err;
  return 0;
}

int
swarmd_content_done_decode (compact_state_t *state, swarmd_content_done_t *result)
{
  int err;
  if ((err = compact_decode_fixed32(state, result->hash)) < 0) return err;
  if ((err = compact_decode_utf8(state, &result->path)) < 0) return err;
  return 0;
}

void
swarmd_content_done_destroy (swarmd_content_done_t *result)
{
}

int
swarmd_content_failed_preencode (compact_state_t *state, const swarmd_content_failed_t *value)
{
  int err;
  if ((err = compact_preencode_fixed32(state, value->hash)) < 0) return err;
  if ((err = compact_preencode_utf8(state, value->reason)) < 0) return err;
  return 0;
}

int
swarmd_content_failed_encode (compact_state_t *state, const swarmd_content_failed_t *value)
{
  int err;
  if ((err = compact_encode_fixed32(state, value->hash)) < 0) return err;
  if ((err = compact_encode_utf8(state, value->reason)) < 0) return err;
  return 0;
}

int
swarmd_content_failed_decode (compact_state_t *state, swarmd_content_failed_t *result)
{
  int err;
  if ((err = compact_decode_fixed32(state, result->hash)) < 0) return err;
  if ((err = compact_decode_utf8(state, &result->reason)) < 0) return err;
  return 0;
}

void
swarmd_content_failed_destroy (swarmd_content_failed_t *result)
{
}

int
swarmd_peer_up_preencode (compact_state_t *state, const swarmd_peer_up_t *value)
{
  int err;
  if ((err = compact_preencode_uint(state, value->peer)) < 0) return err;
  if ((err = compact_preencode_fixed32(state, value->pubkey)) < 0) return err;
  return 0;
}

int
swarmd_peer_up_encode (compact_state_t *state, const swarmd_peer_up_t *value)
{
  int err;
  if ((err = compact_encode_uint(state, value->peer)) < 0) return err;
  if ((err = compact_encode_fixed32(state, value->pubkey)) < 0) return err;
  return 0;
}

int
swarmd_peer_up_decode (compact_state_t *state, swarmd_peer_up_t *result)
{
  int err;
  if ((err = compact_decode_uint(state, &result->peer)) < 0) return err;
  if ((err = compact_decode_fixed32(state, result->pubkey)) < 0) return err;
  return 0;
}

void
swarmd_peer_up_destroy (swarmd_peer_up_t *result)
{
}

int
swarmd_peer_down_preencode (compact_state_t *state, const swarmd_peer_down_t *value)
{
  int err;
  if ((err = compact_preencode_uint(state, value->peer)) < 0) return err;
  return 0;
}

int
swarmd_peer_down_encode (compact_state_t *state, const swarmd_peer_down_t *value)
{
  int err;
  if ((err = compact_encode_uint(state, value->peer)) < 0) return err;
  return 0;
}

int
swarmd_peer_down_decode (compact_state_t *state, swarmd_peer_down_t *result)
{
  int err;
  if ((err = compact_decode_uint(state, &result->peer)) < 0) return err;
  return 0;
}

void
swarmd_peer_down_destroy (swarmd_peer_down_t *result)
{
}

int
swarmd_message_preencode (compact_state_t *state, const swarmd_message_t *value)
{
  int err;
  if ((err = compact_preencode_uint(state, value->channel)) < 0) return err;
  if ((err = compact_preencode_uint(state, value->slot)) < 0) return err;
  if ((err = compact_preencode_uint(state, value->origin_kind)) < 0) return err;
  if ((err = compact_preencode_uint(state, value->origin_id)) < 0) return err;
  if ((err = compact_preencode_uint8array(state, value->bytes, value->bytes_len)) < 0) return err;
  return 0;
}

int
swarmd_message_encode (compact_state_t *state, const swarmd_message_t *value)
{
  int err;
  if ((err = compact_encode_uint(state, value->channel)) < 0) return err;
  if ((err = compact_encode_uint(state, value->slot)) < 0) return err;
  if ((err = compact_encode_uint(state, value->origin_kind)) < 0) return err;
  if ((err = compact_encode_uint(state, value->origin_id)) < 0) return err;
  if ((err = compact_encode_uint8array(state, value->bytes, value->bytes_len)) < 0) return err;
  return 0;
}

int
swarmd_message_decode (compact_state_t *state, swarmd_message_t *result)
{
  int err;
  if ((err = compact_decode_uint(state, &result->channel)) < 0) return err;
  if ((err = compact_decode_uint(state, &result->slot)) < 0) return err;
  if ((err = compact_decode_uint(state, &result->origin_kind)) < 0) return err;
  if ((err = compact_decode_uint(state, &result->origin_id)) < 0) return err;
  if ((err = compact_decode_uint8array(state, &result->bytes, &result->bytes_len)) < 0) return err;
  return 0;
}

void
swarmd_message_destroy (swarmd_message_t *result)
{
}