database.pb.cc

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: shaka/src/js/idb/database.proto

#include "shaka/src/js/idb/database.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
extern PROTOBUF_INTERNAL_EXPORT_shaka_2fsrc_2fjs_2fidb_2fdatabase_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Object_shaka_2fsrc_2fjs_2fidb_2fdatabase_2eproto;
namespace shaka {
namespace proto {
class Object_EntryDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Object_Entry> _instance;
} _Object_Entry_default_instance_;
class ObjectDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Object> _instance;
} _Object_default_instance_;
class ValueDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Value> _instance;
  bool value_bool_;
  double value_number_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_string_;
  const ::shaka::proto::Object* value_object_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_bytes_;
} _Value_default_instance_;
}  // namespace proto
}  // namespace shaka
static void InitDefaultsscc_info_Object_shaka_2fsrc_2fjs_2fidb_2fdatabase_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::shaka::proto::_Object_Entry_default_instance_;
    new (ptr) ::shaka::proto::Object_Entry();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  {
    void* ptr = &::shaka::proto::_Object_default_instance_;
    new (ptr) ::shaka::proto::Object();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  {
    void* ptr = &::shaka::proto::_Value_default_instance_;
    new (ptr) ::shaka::proto::Value();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::shaka::proto::Object_Entry::InitAsDefaultInstance();
  ::shaka::proto::Object::InitAsDefaultInstance();
  ::shaka::proto::Value::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Object_shaka_2fsrc_2fjs_2fidb_2fdatabase_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_Object_shaka_2fsrc_2fjs_2fidb_2fdatabase_2eproto}, {}};

namespace shaka {
namespace proto {
bool ValueType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
    case 22:
    case 23:
    case 24:
      return true;
    default:
      return false;
  }
}

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ValueType_strings[25] = {};

static const char ValueType_names[] =
  "Array"
  "ArrayBuffer"
  "Boolean"
  "BooleanObject"
  "DataView"
  "Float32Array"
  "Float64Array"
  "Function"
  "Int16Array"
  "Int32Array"
  "Int8Array"
  "Null"
  "Number"
  "NumberObject"
  "OtherObject"
  "Promise"
  "String"
  "StringObject"
  "Symbol"
  "Uint16Array"
  "Uint32Array"
  "Uint8Array"
  "Uint8ClampedArray"
  "Undefined"
  "Unknown";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ValueType_entries[] = {
  { {ValueType_names + 0, 5}, 8 },
  { {ValueType_names + 5, 11}, 13 },
  { {ValueType_names + 16, 7}, 3 },
  { {ValueType_names + 23, 13}, 10 },
  { {ValueType_names + 36, 8}, 23 },
  { {ValueType_names + 44, 12}, 21 },
  { {ValueType_names + 56, 12}, 22 },
  { {ValueType_names + 68, 8}, 7 },
  { {ValueType_names + 76, 10}, 17 },
  { {ValueType_names + 86, 10}, 19 },
  { {ValueType_names + 96, 9}, 14 },
  { {ValueType_names + 105, 4}, 2 },
  { {ValueType_names + 109, 6}, 4 },
  { {ValueType_names + 115, 12}, 11 },
  { {ValueType_names + 127, 11}, 24 },
  { {ValueType_names + 138, 7}, 9 },
  { {ValueType_names + 145, 6}, 5 },
  { {ValueType_names + 151, 12}, 12 },
  { {ValueType_names + 163, 6}, 6 },
  { {ValueType_names + 169, 11}, 18 },
  { {ValueType_names + 180, 11}, 20 },
  { {ValueType_names + 191, 10}, 15 },
  { {ValueType_names + 201, 17}, 16 },
  { {ValueType_names + 218, 9}, 1 },
  { {ValueType_names + 227, 7}, 0 },
};

static const int ValueType_entries_by_number[] = {
  24, // 0 -> Unknown
  23, // 1 -> Undefined
  11, // 2 -> Null
  2, // 3 -> Boolean
  12, // 4 -> Number
  16, // 5 -> String
  18, // 6 -> Symbol
  7, // 7 -> Function
  0, // 8 -> Array
  15, // 9 -> Promise
  3, // 10 -> BooleanObject
  13, // 11 -> NumberObject
  17, // 12 -> StringObject
  1, // 13 -> ArrayBuffer
  10, // 14 -> Int8Array
  21, // 15 -> Uint8Array
  22, // 16 -> Uint8ClampedArray
  8, // 17 -> Int16Array
  19, // 18 -> Uint16Array
  9, // 19 -> Int32Array
  20, // 20 -> Uint32Array
  5, // 21 -> Float32Array
  6, // 22 -> Float64Array
  4, // 23 -> DataView
  14, // 24 -> OtherObject
};

const std::string& ValueType_Name(
    ValueType value) {
  static const bool dummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          ValueType_entries,
          ValueType_entries_by_number,
          25, ValueType_strings);
  (void) dummy;
  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      ValueType_entries,
      ValueType_entries_by_number,
      25, value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
                     ValueType_strings[idx].get();
}
bool ValueType_Parse(
    const std::string& name, ValueType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      ValueType_entries, 25, name, &int_value);
  if (success) {
    *value = static_cast<ValueType>(int_value);
  }
  return success;
}

// ===================================================================

void Object_Entry::InitAsDefaultInstance() {
  ::shaka::proto::_Object_Entry_default_instance_._instance.get_mutable()->value_ = const_cast< ::shaka::proto::Value*>(
      ::shaka::proto::Value::internal_default_instance());
}
class Object_Entry::_Internal {
 public:
  using HasBits = decltype(std::declval<Object_Entry>()._has_bits_);
  static void set_has_key(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::shaka::proto::Value& value(const Object_Entry* msg);
  static void set_has_value(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::shaka::proto::Value&
Object_Entry::_Internal::value(const Object_Entry* msg) {
  return *msg->value_;
}
Object_Entry::Object_Entry()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:shaka.proto.Object.Entry)
}
Object_Entry::Object_Entry(const Object_Entry& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from.has_key()) {
    key_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.key_);
  }
  if (from.has_value()) {
    value_ = new ::shaka::proto::Value(*from.value_);
  } else {
    value_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:shaka.proto.Object.Entry)
}

void Object_Entry::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Object_shaka_2fsrc_2fjs_2fidb_2fdatabase_2eproto.base);
  key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  value_ = nullptr;
}

Object_Entry::~Object_Entry() {
  // @@protoc_insertion_point(destructor:shaka.proto.Object.Entry)
  SharedDtor();
}

void Object_Entry::SharedDtor() {
  key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete value_;
}

void Object_Entry::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const Object_Entry& Object_Entry::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Object_shaka_2fsrc_2fjs_2fidb_2fdatabase_2eproto.base);
  return *internal_default_instance();
}


void Object_Entry::Clear() {
// @@protoc_insertion_point(message_clear_start:shaka.proto.Object.Entry)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      key_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(value_ != nullptr);
      value_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Object_Entry::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required string key = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_key(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required .shaka.proto.Value value = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(mutable_value(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Object_Entry::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:shaka.proto.Object.Entry)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string key = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_key()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // required .shaka.proto.Value value = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_value()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:shaka.proto.Object.Entry)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:shaka.proto.Object.Entry)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void Object_Entry::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:shaka.proto.Object.Entry)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required string key = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->key(), output);
  }

  // required .shaka.proto.Value value = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
      2, _Internal::value(this), output);
  }

  output->WriteRaw(_internal_metadata_.unknown_fields().data(),
                   static_cast<int>(_internal_metadata_.unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:shaka.proto.Object.Entry)
}

size_t Object_Entry::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:shaka.proto.Object.Entry)
  size_t total_size = 0;

  if (has_key()) {
    // required string key = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->key());
  }

  if (has_value()) {
    // required .shaka.proto.Value value = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *value_);
  }

  return total_size;
}
size_t Object_Entry::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:shaka.proto.Object.Entry)
  size_t total_size = 0;

  total_size += _internal_metadata_.unknown_fields().size();

  if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) {  // All required fields are present.
    // required string key = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->key());

    // required .shaka.proto.Value value = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *value_);

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Object_Entry::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Object_Entry*>(
      &from));
}

void Object_Entry::MergeFrom(const Object_Entry& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:shaka.proto.Object.Entry)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      key_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.key_);
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_value()->::shaka::proto::Value::MergeFrom(from.value());
    }
  }
}

void Object_Entry::CopyFrom(const Object_Entry& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:shaka.proto.Object.Entry)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Object_Entry::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
  if (has_value()) {
    if (!this->value_->IsInitialized()) return false;
  }
  return true;
}

void Object_Entry::InternalSwap(Object_Entry* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  key_.Swap(&other->key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(value_, other->value_);
}

std::string Object_Entry::GetTypeName() const {
  return "shaka.proto.Object.Entry";
}


// ===================================================================

void Object::InitAsDefaultInstance() {
}
class Object::_Internal {
 public:
  using HasBits = decltype(std::declval<Object>()._has_bits_);
  static void set_has_array_length(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

Object::Object()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:shaka.proto.Object)
}
Object::Object(const Object& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      entries_(from.entries_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  array_length_ = from.array_length_;
  // @@protoc_insertion_point(copy_constructor:shaka.proto.Object)
}

void Object::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Object_shaka_2fsrc_2fjs_2fidb_2fdatabase_2eproto.base);
  array_length_ = 0u;
}

Object::~Object() {
  // @@protoc_insertion_point(destructor:shaka.proto.Object)
  SharedDtor();
}

void Object::SharedDtor() {
}

void Object::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const Object& Object::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Object_shaka_2fsrc_2fjs_2fidb_2fdatabase_2eproto.base);
  return *internal_default_instance();
}


void Object::Clear() {
// @@protoc_insertion_point(message_clear_start:shaka.proto.Object)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  entries_.Clear();
  array_length_ = 0u;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Object::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated .shaka.proto.Object.Entry entries = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(add_entries(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10);
        } else goto handle_unusual;
        continue;
      // optional uint32 array_length = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_array_length(&has_bits);
          array_length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Object::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:shaka.proto.Object)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .shaka.proto.Object.Entry entries = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
                input, add_entries()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 array_length = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          _Internal::set_has_array_length(&_has_bits_);
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   ::PROTOBUF_NAMESPACE_ID::uint32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_UINT32>(
                 input, &array_length_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:shaka.proto.Object)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:shaka.proto.Object)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void Object::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:shaka.proto.Object)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .shaka.proto.Object.Entry entries = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->entries_size()); i < n; i++) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
      1,
      this->entries(static_cast<int>(i)),
      output);
  }

  cached_has_bits = _has_bits_[0];
  // optional uint32 array_length = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32(2, this->array_length(), output);
  }

  output->WriteRaw(_internal_metadata_.unknown_fields().data(),
                   static_cast<int>(_internal_metadata_.unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:shaka.proto.Object)
}

size_t Object::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:shaka.proto.Object)
  size_t total_size = 0;

  total_size += _internal_metadata_.unknown_fields().size();

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .shaka.proto.Object.Entry entries = 1;
  {
    unsigned int count = static_cast<unsigned int>(this->entries_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          this->entries(static_cast<int>(i)));
    }
  }

  // optional uint32 array_length = 2;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->array_length());
  }

  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Object::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Object*>(
      &from));
}

void Object::MergeFrom(const Object& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:shaka.proto.Object)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  entries_.MergeFrom(from.entries_);
  if (from.has_array_length()) {
    set_array_length(from.array_length());
  }
}

void Object::CopyFrom(const Object& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:shaka.proto.Object)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Object::IsInitialized() const {
  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(this->entries())) return false;
  return true;
}

void Object::InternalSwap(Object* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  CastToBase(&entries_)->InternalSwap(CastToBase(&other->entries_));
  swap(array_length_, other->array_length_);
}

std::string Object::GetTypeName() const {
  return "shaka.proto.Object";
}


// ===================================================================

void Value::InitAsDefaultInstance() {
}
class Value::_Internal {
 public:
  using HasBits = decltype(std::declval<Value>()._has_bits_);
  static void set_has_kind(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::shaka::proto::Object& value_object(const Value* msg);
};

const ::shaka::proto::Object&
Value::_Internal::value_object(const Value* msg) {
  return *msg->value_.value_object_;
}
void Value::set_allocated_value_object(::shaka::proto::Object* value_object) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  clear_value();
  if (value_object) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      value_object = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, value_object, submessage_arena);
    }
    set_has_value_object();
    value_.value_object_ = value_object;
  }
  // @@protoc_insertion_point(field_set_allocated:shaka.proto.Value.value_object)
}
Value::Value()
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:shaka.proto.Value)
}
Value::Value(const Value& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  kind_ = from.kind_;
  clear_has_value();
  switch (from.value_case()) {
    case kValueBool: {
      set_value_bool(from.value_bool());
      break;
    }
    case kValueNumber: {
      set_value_number(from.value_number());
      break;
    }
    case kValueString: {
      set_value_string(from.value_string());
      break;
    }
    case kValueObject: {
      mutable_value_object()->::shaka::proto::Object::MergeFrom(from.value_object());
      break;
    }
    case kValueBytes: {
      set_value_bytes(from.value_bytes());
      break;
    }
    case VALUE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:shaka.proto.Value)
}

void Value::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Object_shaka_2fsrc_2fjs_2fidb_2fdatabase_2eproto.base);
  kind_ = 0;
  clear_has_value();
}

Value::~Value() {
  // @@protoc_insertion_point(destructor:shaka.proto.Value)
  SharedDtor();
}

void Value::SharedDtor() {
  if (has_value()) {
    clear_value();
  }
}

void Value::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const Value& Value::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Object_shaka_2fsrc_2fjs_2fidb_2fdatabase_2eproto.base);
  return *internal_default_instance();
}


void Value::clear_value() {
// @@protoc_insertion_point(one_of_clear_start:shaka.proto.Value)
  switch (value_case()) {
    case kValueBool: {
      // No need to clear
      break;
    }
    case kValueNumber: {
      // No need to clear
      break;
    }
    case kValueString: {
      value_.value_string_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
      break;
    }
    case kValueObject: {
      delete value_.value_object_;
      break;
    }
    case kValueBytes: {
      value_.value_bytes_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
      break;
    }
    case VALUE_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = VALUE_NOT_SET;
}


void Value::Clear() {
// @@protoc_insertion_point(message_clear_start:shaka.proto.Value)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  kind_ = 0;
  clear_value();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
const char* Value::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required .shaka.proto.ValueType kind = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::shaka::proto::ValueType_IsValid(val))) {
            set_kind(static_cast<::shaka::proto::ValueType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional bool value_bool = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          set_value_bool(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional double value_number = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 25)) {
          set_value_number(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional string value_string = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_value_string(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .shaka.proto.Object value_object = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(mutable_value_object(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bytes value_bytes = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(mutable_value_bytes(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}
#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
bool Value::MergePartialFromCodedStream(
    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  ::PROTOBUF_NAMESPACE_ID::internal::LiteUnknownFieldSetter unknown_fields_setter(
      &_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::io::StringOutputStream unknown_fields_output(
      unknown_fields_setter.buffer());
  ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_output, false);
  // @@protoc_insertion_point(parse_start:shaka.proto.Value)
  for (;;) {
    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .shaka.proto.ValueType kind = 1;
      case 1: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
          int value = 0;
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::shaka::proto::ValueType_IsValid(value)) {
            set_kind(static_cast< ::shaka::proto::ValueType >(value));
          } else {
            unknown_fields_stream.WriteVarint32(8u);
            unknown_fields_stream.WriteVarint32(
                static_cast<::PROTOBUF_NAMESPACE_ID::uint32>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool value_bool = 2;
      case 2: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
          clear_value();
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
                 input, &value_.value_bool_)));
          set_has_value_bool();
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional double value_number = 3;
      case 3: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (25 & 0xFF)) {
          clear_value();
          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
                   double, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &value_.value_number_)));
          set_has_value_number();
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string value_string = 4;
      case 4: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (34 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
                input, this->mutable_value_string()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .shaka.proto.Object value_object = 5;
      case 5: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (42 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
               input, mutable_value_object()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bytes value_bytes = 6;
      case 6: {
        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (50 & 0xFF)) {
          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadBytes(
                input, this->mutable_value_bytes()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:shaka.proto.Value)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:shaka.proto.Value)
  return false;
#undef DO_
}
#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER

void Value::SerializeWithCachedSizes(
    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:shaka.proto.Value)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .shaka.proto.ValueType kind = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
      1, this->kind(), output);
  }

  switch (value_case()) {
    case kValueBool:
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(2, this->value_bool(), output);
      break;
    case kValueNumber:
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDouble(3, this->value_number(), output);
      break;
    case kValueString:
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
        4, this->value_string(), output);
      break;
    case kValueObject:
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessage(
        5, _Internal::value_object(this), output);
      break;
    case kValueBytes:
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBytesMaybeAliased(
        6, this->value_bytes(), output);
      break;
    default: ;
  }
  output->WriteRaw(_internal_metadata_.unknown_fields().data(),
                   static_cast<int>(_internal_metadata_.unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:shaka.proto.Value)
}

size_t Value::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:shaka.proto.Value)
  size_t total_size = 0;

  total_size += _internal_metadata_.unknown_fields().size();

  // required .shaka.proto.ValueType kind = 1;
  if (has_kind()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->kind());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (value_case()) {
    // optional bool value_bool = 2;
    case kValueBool: {
      total_size += 1 + 1;
      break;
    }
    // optional double value_number = 3;
    case kValueNumber: {
      total_size += 1 + 8;
      break;
    }
    // optional string value_string = 4;
    case kValueString: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->value_string());
      break;
    }
    // optional .shaka.proto.Object value_object = 5;
    case kValueObject: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *value_.value_object_);
      break;
    }
    // optional bytes value_bytes = 6;
    case kValueBytes: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
          this->value_bytes());
      break;
    }
    case VALUE_NOT_SET: {
      break;
    }
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Value::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const Value*>(
      &from));
}

void Value::MergeFrom(const Value& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:shaka.proto.Value)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_kind()) {
    set_kind(from.kind());
  }
  switch (from.value_case()) {
    case kValueBool: {
      set_value_bool(from.value_bool());
      break;
    }
    case kValueNumber: {
      set_value_number(from.value_number());
      break;
    }
    case kValueString: {
      set_value_string(from.value_string());
      break;
    }
    case kValueObject: {
      mutable_value_object()->::shaka::proto::Object::MergeFrom(from.value_object());
      break;
    }
    case kValueBytes: {
      set_value_bytes(from.value_bytes());
      break;
    }
    case VALUE_NOT_SET: {
      break;
    }
  }
}

void Value::CopyFrom(const Value& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:shaka.proto.Value)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Value::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  switch (value_case()) {
    case kValueBool: {
      break;
    }
    case kValueNumber: {
      break;
    }
    case kValueString: {
      break;
    }
    case kValueObject: {
      if (has_value_object()) {
        if (!this->value_object().IsInitialized()) return false;
      }
      break;
    }
    case kValueBytes: {
      break;
    }
    case VALUE_NOT_SET: {
      break;
    }
  }
  return true;
}

void Value::InternalSwap(Value* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(kind_, other->kind_);
  swap(value_, other->value_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

std::string Value::GetTypeName() const {
  return "shaka.proto.Value";
}


// @@protoc_insertion_point(namespace_scope)
}  // namespace proto
}  // namespace shaka
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::shaka::proto::Object_Entry* Arena::CreateMaybeMessage< ::shaka::proto::Object_Entry >(Arena* arena) {
  return Arena::CreateInternal< ::shaka::proto::Object_Entry >(arena);
}
template<> PROTOBUF_NOINLINE ::shaka::proto::Object* Arena::CreateMaybeMessage< ::shaka::proto::Object >(Arena* arena) {
  return Arena::CreateInternal< ::shaka::proto::Object >(arena);
}
template<> PROTOBUF_NOINLINE ::shaka::proto::Value* Arena::CreateMaybeMessage< ::shaka::proto::Value >(Arena* arena) {
  return Arena::CreateInternal< ::shaka::proto::Value >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>