go/src/fidl/compiler/backend/typestest/tables.fidl.json.cc.golden

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

#include <tables.fidl.json.h>

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

extern "C" const fidl_type_t test_name_OlderSimpleTableTable;
const fidl_type_t* OlderSimpleTable::FidlType = &test_name_OlderSimpleTableTable;

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

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

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

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

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,
        encoder->Alloc(::fidl::CodingTraits<int64_t>::encoded_size));
    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, result->mutable_x());
    if (_status != ZX_OK)
      return _status;
  } else {
    result->clear_x();
  }
  return ZX_OK;
}

bool operator==(const OlderSimpleTable& lhs, const OlderSimpleTable& rhs) {
  if (lhs.has_x()) {
    if (!rhs.has_x()) {
      return false;
    }
    if (!::fidl::Equals(*lhs.x(), *rhs.x())) {
      return false;
    }
  } else if (rhs.has_x()) {
    return false;
  }
  return true;
}
extern "C" const fidl_type_t test_name_NewerSimpleTableTable;
const fidl_type_t* NewerSimpleTable::FidlType = &test_name_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, std::move(other.x_.value));
  }
  has_y_ = other.has_y_;
  if (has_y_) {
    Construct(&y_.value, std::move(other.y_.value));
  }
  has_z_ = other.has_z_;
  if (has_z_) {
    Construct(&z_.value, std::move(other.z_.value));
  }
}

NewerSimpleTable::~NewerSimpleTable() {
  if (has_x_) {
    Destruct(&x_.value);
  }
  if (has_y_) {
    Destruct(&y_.value);
  }
  if (has_z_) {
    Destruct(&z_.value);
  }
}

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

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,
        encoder->Alloc(::fidl::CodingTraits<int64_t>::encoded_size));
    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,
        encoder->Alloc(::fidl::CodingTraits<int64_t>::encoded_size));
    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,
        encoder->Alloc(::fidl::CodingTraits<int64_t>::encoded_size));
    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, result->mutable_x());
    if (_status != ZX_OK)
      return _status;
  } else {
    result->clear_x();
  }
  if (has_y_) {
    zx_status_t _status = ::fidl::Clone(y_.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, result->mutable_z());
    if (_status != ZX_OK)
      return _status;
  } else {
    result->clear_z();
  }
  return ZX_OK;
}

bool operator==(const NewerSimpleTable& lhs, const NewerSimpleTable& rhs) {
  if (lhs.has_x()) {
    if (!rhs.has_x()) {
      return false;
    }
    if (!::fidl::Equals(*lhs.x(), *rhs.x())) {
      return false;
    }
  } else if (rhs.has_x()) {
    return false;
  }
  if (lhs.has_y()) {
    if (!rhs.has_y()) {
      return false;
    }
    if (!::fidl::Equals(*lhs.y(), *rhs.y())) {
      return false;
    }
  } else if (rhs.has_y()) {
    return false;
  }
  if (lhs.has_z()) {
    if (!rhs.has_z()) {
      return false;
    }
    if (!::fidl::Equals(*lhs.z(), *rhs.z())) {
      return false;
    }
  } else if (rhs.has_z()) {
    return false;
  }
  return true;
}
extern "C" const fidl_type_t test_name_SimpleTableTable;
const fidl_type_t* SimpleTable::FidlType = &test_name_SimpleTableTable;

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

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

SimpleTable::~SimpleTable() {
  if (has_x_) {
    Destruct(&x_.value);
  }
  if (has_y_) {
    Destruct(&y_.value);
  }
}

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

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,
        encoder->Alloc(::fidl::CodingTraits<int64_t>::encoded_size));
    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,
        encoder->Alloc(::fidl::CodingTraits<int64_t>::encoded_size));
    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, result->mutable_x());
    if (_status != ZX_OK)
      return _status;
  } else {
    result->clear_x();
  }
  if (has_y_) {
    zx_status_t _status = ::fidl::Clone(y_.value, result->mutable_y());
    if (_status != ZX_OK)
      return _status;
  } else {
    result->clear_y();
  }
  return ZX_OK;
}

bool operator==(const SimpleTable& lhs, const SimpleTable& rhs) {
  if (lhs.has_x()) {
    if (!rhs.has_x()) {
      return false;
    }
    if (!::fidl::Equals(*lhs.x(), *rhs.x())) {
      return false;
    }
  } else if (rhs.has_x()) {
    return false;
  }
  if (lhs.has_y()) {
    if (!rhs.has_y()) {
      return false;
    }
    if (!::fidl::Equals(*lhs.y(), *rhs.y())) {
      return false;
    }
  } else if (rhs.has_y()) {
    return false;
  }
  return true;
}
}  // namespace name
}  // namespace test