garnet/go/src/fidl/compiler/backend/goldens/table.test.json.cc.golden

// WARNING: This file is machine generated by fidlgen.

#include <table.test.json.h>

#include "lib/fidl/cpp/internal/implementation.h"
namespace fidl {
namespace test {
namespace json {

extern "C" const fidl_type_t v1_fidl_test_json_SimpleTableTable;
const fidl_type_t* SimpleTable::FidlType = &v1_fidl_test_json_SimpleTableTable;

SimpleTable::SimpleTable() : has_x_(false), has_y_(false) {}

SimpleTable::SimpleTable(SimpleTable&& other) {
  has_x_ = other.has_x_;
  if (has_x_) {
    Construct(&x_value_.value, std::move(other.x_value_.value));
  }
  has_y_ = other.has_y_;
  if (has_y_) {
    Construct(&y_value_.value, std::move(other.y_value_.value));
  }
}

SimpleTable::~SimpleTable() {
  if (has_x_) {
    Destruct(&x_value_.value);
  }
  if (has_y_) {
    Destruct(&y_value_.value);
  }
}

SimpleTable& SimpleTable::operator=(SimpleTable&& other) {
  if (other.has_x_) {
    if (has_x_) {
      x_value_.value = std::move(other.x_value_.value);
    } else {
      has_x_ = true;
      Construct(&x_value_.value, std::move(other.x_value_.value));
    }
  } else if (has_x_) {
    has_x_ = false;
    Destruct(&x_value_.value);
  }
  if (other.has_y_) {
    if (has_y_) {
      y_value_.value = std::move(other.y_value_.value);
    } else {
      has_y_ = true;
      Construct(&y_value_.value, std::move(other.y_value_.value));
    }
  } else if (has_y_) {
    has_y_ = false;
    Destruct(&y_value_.value);
  }
  return *this;
}

bool SimpleTable::IsEmpty() const {
  if (has_x_) return false;
  if (has_y_) return false;
  return true;
}

void SimpleTable::Encode(::fidl::Encoder* _encoder, size_t _offset) {
  size_t max_ordinal = 0;
  if (has_x_) max_ordinal = 1;
  if (has_y_) max_ordinal = 5;
  ::fidl::EncodeVectorPointer(_encoder, max_ordinal, _offset);
  if (max_ordinal == 0) return;
  size_t base = _encoder->Alloc(max_ordinal * 2 * sizeof(uint64_t));
  if (has_x_) {
    const size_t length_before = _encoder->CurrentLength();
    const size_t handles_before = _encoder->CurrentHandleCount();
    ::fidl::Encode(
        _encoder, &x_value_.value,
        _encoder->Alloc(
            ::fidl::EncodingInlineSize<int64_t, ::fidl::Encoder>(_encoder)));
    size_t envelope_base = base + (1 - 1) * 2 * sizeof(uint64_t);
    uint64_t num_bytes_then_num_handles =
        (_encoder->CurrentLength() - length_before) |
        ((_encoder->CurrentHandleCount() - handles_before) << 32);
    ::fidl::Encode(_encoder, &num_bytes_then_num_handles, envelope_base);
    *_encoder->GetPtr<uintptr_t>(envelope_base + sizeof(uint64_t)) =
        FIDL_ALLOC_PRESENT;
  }
  if (has_y_) {
    const size_t length_before = _encoder->CurrentLength();
    const size_t handles_before = _encoder->CurrentHandleCount();
    ::fidl::Encode(
        _encoder, &y_value_.value,
        _encoder->Alloc(
            ::fidl::EncodingInlineSize<int64_t, ::fidl::Encoder>(_encoder)));
    size_t envelope_base = base + (5 - 1) * 2 * sizeof(uint64_t);
    uint64_t num_bytes_then_num_handles =
        (_encoder->CurrentLength() - length_before) |
        ((_encoder->CurrentHandleCount() - handles_before) << 32);
    ::fidl::Encode(_encoder, &num_bytes_then_num_handles, envelope_base);
    *_encoder->GetPtr<uintptr_t>(envelope_base + sizeof(uint64_t)) =
        FIDL_ALLOC_PRESENT;
  }
}

void SimpleTable::Decode(::fidl::Decoder* _decoder, SimpleTable* _value,
                         size_t _offset) {
  fidl_vector_t* encoded = _decoder->GetPtr<fidl_vector_t>(_offset);
  size_t base;
  size_t count;
  if (!encoded->data) {
    goto clear_all;
  }

  base = _decoder->GetOffset(encoded->data);
  count = encoded->count;
  if (count >= 1) {
    size_t envelope_base = base + (1 - 1) * 2 * sizeof(uint64_t);
    uint64_t presence;
    ::fidl::Decode(_decoder, &presence, envelope_base + sizeof(uint64_t));
    if (presence != 0) {
      ::fidl::Decode(_decoder, _value->mutable_x(),
                     _decoder->GetOffset(presence));
    } else {
      _value->clear_x();
    }
  } else {
    goto done_1;
  }
  if (count >= 5) {
    size_t envelope_base = base + (5 - 1) * 2 * sizeof(uint64_t);
    uint64_t presence;
    ::fidl::Decode(_decoder, &presence, envelope_base + sizeof(uint64_t));
    if (presence != 0) {
      ::fidl::Decode(_decoder, _value->mutable_y(),
                     _decoder->GetOffset(presence));
    } else {
      _value->clear_y();
    }
  } else {
    goto done_5;
  }

  return;

  // Clear unset values.
clear_all:
done_1:
  _value->clear_x();
done_5:
  _value->clear_y();
  return;
}

zx_status_t SimpleTable::Clone(SimpleTable* result) const {
  if (has_x_) {
    zx_status_t _status = ::fidl::Clone(x_value_.value, result->mutable_x());
    if (_status != ZX_OK) return _status;
  } else {
    result->clear_x();
  }
  if (has_y_) {
    zx_status_t _status = ::fidl::Clone(y_value_.value, result->mutable_y());
    if (_status != ZX_OK) return _status;
  } else {
    result->clear_y();
  }
  return ZX_OK;
}
extern "C" const fidl_type_t v1_fidl_test_json_ReverseOrdinalTableTable;
const fidl_type_t* ReverseOrdinalTable::FidlType =
    &v1_fidl_test_json_ReverseOrdinalTableTable;

ReverseOrdinalTable::ReverseOrdinalTable()
    : has_z_(false), has_y_(false), has_x_(false) {}

ReverseOrdinalTable::ReverseOrdinalTable(ReverseOrdinalTable&& other) {
  has_z_ = other.has_z_;
  if (has_z_) {
    Construct(&z_value_.value, std::move(other.z_value_.value));
  }
  has_y_ = other.has_y_;
  if (has_y_) {
    Construct(&y_value_.value, std::move(other.y_value_.value));
  }
  has_x_ = other.has_x_;
  if (has_x_) {
    Construct(&x_value_.value, std::move(other.x_value_.value));
  }
}

ReverseOrdinalTable::~ReverseOrdinalTable() {
  if (has_z_) {
    Destruct(&z_value_.value);
  }
  if (has_y_) {
    Destruct(&y_value_.value);
  }
  if (has_x_) {
    Destruct(&x_value_.value);
  }
}

ReverseOrdinalTable& ReverseOrdinalTable::operator=(
    ReverseOrdinalTable&& other) {
  if (other.has_z_) {
    if (has_z_) {
      z_value_.value = std::move(other.z_value_.value);
    } else {
      has_z_ = true;
      Construct(&z_value_.value, std::move(other.z_value_.value));
    }
  } else if (has_z_) {
    has_z_ = false;
    Destruct(&z_value_.value);
  }
  if (other.has_y_) {
    if (has_y_) {
      y_value_.value = std::move(other.y_value_.value);
    } else {
      has_y_ = true;
      Construct(&y_value_.value, std::move(other.y_value_.value));
    }
  } else if (has_y_) {
    has_y_ = false;
    Destruct(&y_value_.value);
  }
  if (other.has_x_) {
    if (has_x_) {
      x_value_.value = std::move(other.x_value_.value);
    } else {
      has_x_ = true;
      Construct(&x_value_.value, std::move(other.x_value_.value));
    }
  } else if (has_x_) {
    has_x_ = false;
    Destruct(&x_value_.value);
  }
  return *this;
}

bool ReverseOrdinalTable::IsEmpty() const {
  if (has_z_) return false;
  if (has_y_) return false;
  if (has_x_) return false;
  return true;
}

void ReverseOrdinalTable::Encode(::fidl::Encoder* _encoder, size_t _offset) {
  size_t max_ordinal = 0;
  if (has_z_) max_ordinal = 1;
  if (has_y_) max_ordinal = 2;
  if (has_x_) max_ordinal = 3;
  ::fidl::EncodeVectorPointer(_encoder, max_ordinal, _offset);
  if (max_ordinal == 0) return;
  size_t base = _encoder->Alloc(max_ordinal * 2 * sizeof(uint64_t));
  if (has_z_) {
    const size_t length_before = _encoder->CurrentLength();
    const size_t handles_before = _encoder->CurrentHandleCount();
    ::fidl::Encode(
        _encoder, &z_value_.value,
        _encoder->Alloc(
            ::fidl::EncodingInlineSize<int64_t, ::fidl::Encoder>(_encoder)));
    size_t envelope_base = base + (1 - 1) * 2 * sizeof(uint64_t);
    uint64_t num_bytes_then_num_handles =
        (_encoder->CurrentLength() - length_before) |
        ((_encoder->CurrentHandleCount() - handles_before) << 32);
    ::fidl::Encode(_encoder, &num_bytes_then_num_handles, envelope_base);
    *_encoder->GetPtr<uintptr_t>(envelope_base + sizeof(uint64_t)) =
        FIDL_ALLOC_PRESENT;
  }
  if (has_y_) {
    const size_t length_before = _encoder->CurrentLength();
    const size_t handles_before = _encoder->CurrentHandleCount();
    ::fidl::Encode(
        _encoder, &y_value_.value,
        _encoder->Alloc(
            ::fidl::EncodingInlineSize<int64_t, ::fidl::Encoder>(_encoder)));
    size_t envelope_base = base + (2 - 1) * 2 * sizeof(uint64_t);
    uint64_t num_bytes_then_num_handles =
        (_encoder->CurrentLength() - length_before) |
        ((_encoder->CurrentHandleCount() - handles_before) << 32);
    ::fidl::Encode(_encoder, &num_bytes_then_num_handles, envelope_base);
    *_encoder->GetPtr<uintptr_t>(envelope_base + sizeof(uint64_t)) =
        FIDL_ALLOC_PRESENT;
  }
  if (has_x_) {
    const size_t length_before = _encoder->CurrentLength();
    const size_t handles_before = _encoder->CurrentHandleCount();
    ::fidl::Encode(
        _encoder, &x_value_.value,
        _encoder->Alloc(
            ::fidl::EncodingInlineSize<int64_t, ::fidl::Encoder>(_encoder)));
    size_t envelope_base = base + (3 - 1) * 2 * sizeof(uint64_t);
    uint64_t num_bytes_then_num_handles =
        (_encoder->CurrentLength() - length_before) |
        ((_encoder->CurrentHandleCount() - handles_before) << 32);
    ::fidl::Encode(_encoder, &num_bytes_then_num_handles, envelope_base);
    *_encoder->GetPtr<uintptr_t>(envelope_base + sizeof(uint64_t)) =
        FIDL_ALLOC_PRESENT;
  }
}

void ReverseOrdinalTable::Decode(::fidl::Decoder* _decoder,
                                 ReverseOrdinalTable* _value, size_t _offset) {
  fidl_vector_t* encoded = _decoder->GetPtr<fidl_vector_t>(_offset);
  size_t base;
  size_t count;
  if (!encoded->data) {
    goto clear_all;
  }

  base = _decoder->GetOffset(encoded->data);
  count = encoded->count;
  if (count >= 1) {
    size_t envelope_base = base + (1 - 1) * 2 * sizeof(uint64_t);
    uint64_t presence;
    ::fidl::Decode(_decoder, &presence, envelope_base + sizeof(uint64_t));
    if (presence != 0) {
      ::fidl::Decode(_decoder, _value->mutable_z(),
                     _decoder->GetOffset(presence));
    } else {
      _value->clear_z();
    }
  } else {
    goto done_1;
  }
  if (count >= 2) {
    size_t envelope_base = base + (2 - 1) * 2 * sizeof(uint64_t);
    uint64_t presence;
    ::fidl::Decode(_decoder, &presence, envelope_base + sizeof(uint64_t));
    if (presence != 0) {
      ::fidl::Decode(_decoder, _value->mutable_y(),
                     _decoder->GetOffset(presence));
    } else {
      _value->clear_y();
    }
  } else {
    goto done_2;
  }
  if (count >= 3) {
    size_t envelope_base = base + (3 - 1) * 2 * sizeof(uint64_t);
    uint64_t presence;
    ::fidl::Decode(_decoder, &presence, envelope_base + sizeof(uint64_t));
    if (presence != 0) {
      ::fidl::Decode(_decoder, _value->mutable_x(),
                     _decoder->GetOffset(presence));
    } else {
      _value->clear_x();
    }
  } else {
    goto done_3;
  }

  return;

  // Clear unset values.
clear_all:
done_1:
  _value->clear_z();
done_2:
  _value->clear_y();
done_3:
  _value->clear_x();
  return;
}

zx_status_t ReverseOrdinalTable::Clone(ReverseOrdinalTable* result) const {
  if (has_z_) {
    zx_status_t _status = ::fidl::Clone(z_value_.value, result->mutable_z());
    if (_status != ZX_OK) return _status;
  } else {
    result->clear_z();
  }
  if (has_y_) {
    zx_status_t _status = ::fidl::Clone(y_value_.value, result->mutable_y());
    if (_status != ZX_OK) return _status;
  } else {
    result->clear_y();
  }
  if (has_x_) {
    zx_status_t _status = ::fidl::Clone(x_value_.value, result->mutable_x());
    if (_status != ZX_OK) return _status;
  } else {
    result->clear_x();
  }
  return ZX_OK;
}
extern "C" const fidl_type_t v1_fidl_test_json_OlderSimpleTableTable;
const fidl_type_t* OlderSimpleTable::FidlType =
    &v1_fidl_test_json_OlderSimpleTableTable;

OlderSimpleTable::OlderSimpleTable() : has_x_(false) {}

OlderSimpleTable::OlderSimpleTable(OlderSimpleTable&& other) {
  has_x_ = other.has_x_;
  if (has_x_) {
    Construct(&x_value_.value, std::move(other.x_value_.value));
  }
}

OlderSimpleTable::~OlderSimpleTable() {
  if (has_x_) {
    Destruct(&x_value_.value);
  }
}

OlderSimpleTable& OlderSimpleTable::operator=(OlderSimpleTable&& other) {
  if (other.has_x_) {
    if (has_x_) {
      x_value_.value = std::move(other.x_value_.value);
    } else {
      has_x_ = true;
      Construct(&x_value_.value, std::move(other.x_value_.value));
    }
  } else if (has_x_) {
    has_x_ = false;
    Destruct(&x_value_.value);
  }
  return *this;
}

bool OlderSimpleTable::IsEmpty() const {
  if (has_x_) return false;
  return true;
}

void OlderSimpleTable::Encode(::fidl::Encoder* _encoder, size_t _offset) {
  size_t max_ordinal = 0;
  if (has_x_) max_ordinal = 1;
  ::fidl::EncodeVectorPointer(_encoder, max_ordinal, _offset);
  if (max_ordinal == 0) return;
  size_t base = _encoder->Alloc(max_ordinal * 2 * sizeof(uint64_t));
  if (has_x_) {
    const size_t length_before = _encoder->CurrentLength();
    const size_t handles_before = _encoder->CurrentHandleCount();
    ::fidl::Encode(
        _encoder, &x_value_.value,
        _encoder->Alloc(
            ::fidl::EncodingInlineSize<int64_t, ::fidl::Encoder>(_encoder)));
    size_t envelope_base = base + (1 - 1) * 2 * sizeof(uint64_t);
    uint64_t num_bytes_then_num_handles =
        (_encoder->CurrentLength() - length_before) |
        ((_encoder->CurrentHandleCount() - handles_before) << 32);
    ::fidl::Encode(_encoder, &num_bytes_then_num_handles, envelope_base);
    *_encoder->GetPtr<uintptr_t>(envelope_base + sizeof(uint64_t)) =
        FIDL_ALLOC_PRESENT;
  }
}

void OlderSimpleTable::Decode(::fidl::Decoder* _decoder,
                              OlderSimpleTable* _value, size_t _offset) {
  fidl_vector_t* encoded = _decoder->GetPtr<fidl_vector_t>(_offset);
  size_t base;
  size_t count;
  if (!encoded->data) {
    goto clear_all;
  }

  base = _decoder->GetOffset(encoded->data);
  count = encoded->count;
  if (count >= 1) {
    size_t envelope_base = base + (1 - 1) * 2 * sizeof(uint64_t);
    uint64_t presence;
    ::fidl::Decode(_decoder, &presence, envelope_base + sizeof(uint64_t));
    if (presence != 0) {
      ::fidl::Decode(_decoder, _value->mutable_x(),
                     _decoder->GetOffset(presence));
    } else {
      _value->clear_x();
    }
  } else {
    goto done_1;
  }

  return;

  // Clear unset values.
clear_all:
done_1:
  _value->clear_x();
  return;
}

zx_status_t OlderSimpleTable::Clone(OlderSimpleTable* result) const {
  if (has_x_) {
    zx_status_t _status = ::fidl::Clone(x_value_.value, result->mutable_x());
    if (_status != ZX_OK) return _status;
  } else {
    result->clear_x();
  }
  return ZX_OK;
}
extern "C" const fidl_type_t v1_fidl_test_json_NewerSimpleTableTable;
const fidl_type_t* NewerSimpleTable::FidlType =
    &v1_fidl_test_json_NewerSimpleTableTable;

NewerSimpleTable::NewerSimpleTable()
    : has_x_(false), has_y_(false), has_z_(false) {}

NewerSimpleTable::NewerSimpleTable(NewerSimpleTable&& other) {
  has_x_ = other.has_x_;
  if (has_x_) {
    Construct(&x_value_.value, std::move(other.x_value_.value));
  }
  has_y_ = other.has_y_;
  if (has_y_) {
    Construct(&y_value_.value, std::move(other.y_value_.value));
  }
  has_z_ = other.has_z_;
  if (has_z_) {
    Construct(&z_value_.value, std::move(other.z_value_.value));
  }
}

NewerSimpleTable::~NewerSimpleTable() {
  if (has_x_) {
    Destruct(&x_value_.value);
  }
  if (has_y_) {
    Destruct(&y_value_.value);
  }
  if (has_z_) {
    Destruct(&z_value_.value);
  }
}

NewerSimpleTable& NewerSimpleTable::operator=(NewerSimpleTable&& other) {
  if (other.has_x_) {
    if (has_x_) {
      x_value_.value = std::move(other.x_value_.value);
    } else {
      has_x_ = true;
      Construct(&x_value_.value, std::move(other.x_value_.value));
    }
  } else if (has_x_) {
    has_x_ = false;
    Destruct(&x_value_.value);
  }
  if (other.has_y_) {
    if (has_y_) {
      y_value_.value = std::move(other.y_value_.value);
    } else {
      has_y_ = true;
      Construct(&y_value_.value, std::move(other.y_value_.value));
    }
  } else if (has_y_) {
    has_y_ = false;
    Destruct(&y_value_.value);
  }
  if (other.has_z_) {
    if (has_z_) {
      z_value_.value = std::move(other.z_value_.value);
    } else {
      has_z_ = true;
      Construct(&z_value_.value, std::move(other.z_value_.value));
    }
  } else if (has_z_) {
    has_z_ = false;
    Destruct(&z_value_.value);
  }
  return *this;
}

bool NewerSimpleTable::IsEmpty() const {
  if (has_x_) return false;
  if (has_y_) return false;
  if (has_z_) return false;
  return true;
}

void NewerSimpleTable::Encode(::fidl::Encoder* _encoder, size_t _offset) {
  size_t max_ordinal = 0;
  if (has_x_) max_ordinal = 1;
  if (has_y_) max_ordinal = 5;
  if (has_z_) max_ordinal = 6;
  ::fidl::EncodeVectorPointer(_encoder, max_ordinal, _offset);
  if (max_ordinal == 0) return;
  size_t base = _encoder->Alloc(max_ordinal * 2 * sizeof(uint64_t));
  if (has_x_) {
    const size_t length_before = _encoder->CurrentLength();
    const size_t handles_before = _encoder->CurrentHandleCount();
    ::fidl::Encode(
        _encoder, &x_value_.value,
        _encoder->Alloc(
            ::fidl::EncodingInlineSize<int64_t, ::fidl::Encoder>(_encoder)));
    size_t envelope_base = base + (1 - 1) * 2 * sizeof(uint64_t);
    uint64_t num_bytes_then_num_handles =
        (_encoder->CurrentLength() - length_before) |
        ((_encoder->CurrentHandleCount() - handles_before) << 32);
    ::fidl::Encode(_encoder, &num_bytes_then_num_handles, envelope_base);
    *_encoder->GetPtr<uintptr_t>(envelope_base + sizeof(uint64_t)) =
        FIDL_ALLOC_PRESENT;
  }
  if (has_y_) {
    const size_t length_before = _encoder->CurrentLength();
    const size_t handles_before = _encoder->CurrentHandleCount();
    ::fidl::Encode(
        _encoder, &y_value_.value,
        _encoder->Alloc(
            ::fidl::EncodingInlineSize<int64_t, ::fidl::Encoder>(_encoder)));
    size_t envelope_base = base + (5 - 1) * 2 * sizeof(uint64_t);
    uint64_t num_bytes_then_num_handles =
        (_encoder->CurrentLength() - length_before) |
        ((_encoder->CurrentHandleCount() - handles_before) << 32);
    ::fidl::Encode(_encoder, &num_bytes_then_num_handles, envelope_base);
    *_encoder->GetPtr<uintptr_t>(envelope_base + sizeof(uint64_t)) =
        FIDL_ALLOC_PRESENT;
  }
  if (has_z_) {
    const size_t length_before = _encoder->CurrentLength();
    const size_t handles_before = _encoder->CurrentHandleCount();
    ::fidl::Encode(
        _encoder, &z_value_.value,
        _encoder->Alloc(
            ::fidl::EncodingInlineSize<int64_t, ::fidl::Encoder>(_encoder)));
    size_t envelope_base = base + (6 - 1) * 2 * sizeof(uint64_t);
    uint64_t num_bytes_then_num_handles =
        (_encoder->CurrentLength() - length_before) |
        ((_encoder->CurrentHandleCount() - handles_before) << 32);
    ::fidl::Encode(_encoder, &num_bytes_then_num_handles, envelope_base);
    *_encoder->GetPtr<uintptr_t>(envelope_base + sizeof(uint64_t)) =
        FIDL_ALLOC_PRESENT;
  }
}

void NewerSimpleTable::Decode(::fidl::Decoder* _decoder,
                              NewerSimpleTable* _value, size_t _offset) {
  fidl_vector_t* encoded = _decoder->GetPtr<fidl_vector_t>(_offset);
  size_t base;
  size_t count;
  if (!encoded->data) {
    goto clear_all;
  }

  base = _decoder->GetOffset(encoded->data);
  count = encoded->count;
  if (count >= 1) {
    size_t envelope_base = base + (1 - 1) * 2 * sizeof(uint64_t);
    uint64_t presence;
    ::fidl::Decode(_decoder, &presence, envelope_base + sizeof(uint64_t));
    if (presence != 0) {
      ::fidl::Decode(_decoder, _value->mutable_x(),
                     _decoder->GetOffset(presence));
    } else {
      _value->clear_x();
    }
  } else {
    goto done_1;
  }
  if (count >= 5) {
    size_t envelope_base = base + (5 - 1) * 2 * sizeof(uint64_t);
    uint64_t presence;
    ::fidl::Decode(_decoder, &presence, envelope_base + sizeof(uint64_t));
    if (presence != 0) {
      ::fidl::Decode(_decoder, _value->mutable_y(),
                     _decoder->GetOffset(presence));
    } else {
      _value->clear_y();
    }
  } else {
    goto done_5;
  }
  if (count >= 6) {
    size_t envelope_base = base + (6 - 1) * 2 * sizeof(uint64_t);
    uint64_t presence;
    ::fidl::Decode(_decoder, &presence, envelope_base + sizeof(uint64_t));
    if (presence != 0) {
      ::fidl::Decode(_decoder, _value->mutable_z(),
                     _decoder->GetOffset(presence));
    } else {
      _value->clear_z();
    }
  } else {
    goto done_6;
  }

  return;

  // Clear unset values.
clear_all:
done_1:
  _value->clear_x();
done_5:
  _value->clear_y();
done_6:
  _value->clear_z();
  return;
}

zx_status_t NewerSimpleTable::Clone(NewerSimpleTable* result) const {
  if (has_x_) {
    zx_status_t _status = ::fidl::Clone(x_value_.value, result->mutable_x());
    if (_status != ZX_OK) return _status;
  } else {
    result->clear_x();
  }
  if (has_y_) {
    zx_status_t _status = ::fidl::Clone(y_value_.value, result->mutable_y());
    if (_status != ZX_OK) return _status;
  } else {
    result->clear_y();
  }
  if (has_z_) {
    zx_status_t _status = ::fidl::Clone(z_value_.value, result->mutable_z());
    if (_status != ZX_OK) return _status;
  } else {
    result->clear_z();
  }
  return ZX_OK;
}
extern "C" const fidl_type_t v1_fidl_test_json_EmptyTableTable;
const fidl_type_t* EmptyTable::FidlType = &v1_fidl_test_json_EmptyTableTable;

EmptyTable::EmptyTable() {}

EmptyTable::EmptyTable(EmptyTable&& other) {}

EmptyTable::~EmptyTable() {}

EmptyTable& EmptyTable::operator=(EmptyTable&& other) { return *this; }

bool EmptyTable::IsEmpty() const { return true; }

void EmptyTable::Encode(::fidl::Encoder* _encoder, size_t _offset) {
  size_t max_ordinal = 0;
  ::fidl::EncodeVectorPointer(_encoder, max_ordinal, _offset);
  if (max_ordinal == 0) return;
}

void EmptyTable::Decode(::fidl::Decoder* _decoder, EmptyTable* _value,
                        size_t _offset) {
  fidl_vector_t* encoded = _decoder->GetPtr<fidl_vector_t>(_offset);
  size_t base;
  size_t count;
  if (!encoded->data) {
    goto clear_all;
  }

  base = _decoder->GetOffset(encoded->data);
  count = encoded->count;

  return;

  // Clear unset values.
clear_all:
  return;
}

zx_status_t EmptyTable::Clone(EmptyTable* result) const { return ZX_OK; }
}  // namespace json
}  // namespace test
}  // namespace fidl