diff options
Diffstat (limited to 'NorthstarDedicatedTest/sv_rcon.pb.cc')
| -rw-r--r-- | NorthstarDedicatedTest/sv_rcon.pb.cc | 460 |
1 files changed, 460 insertions, 0 deletions
diff --git a/NorthstarDedicatedTest/sv_rcon.pb.cc b/NorthstarDedicatedTest/sv_rcon.pb.cc new file mode 100644 index 00000000..f352ef59 --- /dev/null +++ b/NorthstarDedicatedTest/sv_rcon.pb.cc @@ -0,0 +1,460 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: sv_rcon.proto + +#include "sv_rcon.pb.h" + +#include <algorithm> + +#include <protobuf/io/coded_stream.h> +#include <protobuf/extension_set.h> +#include <protobuf/wire_format_lite.h> +#include <protobuf/io/zero_copy_stream_impl_lite.h> +// @@protoc_insertion_point(includes) +#include <protobuf/port_def.inc> + +PROTOBUF_PRAGMA_INIT_SEG +namespace sv_rcon +{ +constexpr response::response(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : responsebuf_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string), + responseval_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string), responseid_(0), responsetype_(0) +{ +} +struct responseDefaultTypeInternal +{ + constexpr responseDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~responseDefaultTypeInternal() {} + union + { + response _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT responseDefaultTypeInternal _response_default_instance_; +} // namespace sv_rcon +namespace sv_rcon +{ +bool response_t_IsValid(int value) +{ + switch (value) + { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> response_t_strings[6] = {}; + +static const char response_t_names[] = "SERVERDATA_RESPONSE_AUTH" + "SERVERDATA_RESPONSE_CONSOLE_LOG" + "SERVERDATA_RESPONSE_REMOTEBUG" + "SERVERDATA_RESPONSE_STRING" + "SERVERDATA_RESPONSE_UPDATE" + "SERVERDATA_RESPONSE_VALUE"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry response_t_entries[] = { + {{response_t_names + 0, 24}, 2}, {{response_t_names + 24, 31}, 3}, {{response_t_names + 55, 29}, 5}, + {{response_t_names + 84, 26}, 4}, {{response_t_names + 110, 26}, 1}, {{response_t_names + 136, 25}, 0}, +}; + +static const int response_t_entries_by_number[] = { + 5, // 0 -> SERVERDATA_RESPONSE_VALUE + 4, // 1 -> SERVERDATA_RESPONSE_UPDATE + 0, // 2 -> SERVERDATA_RESPONSE_AUTH + 1, // 3 -> SERVERDATA_RESPONSE_CONSOLE_LOG + 3, // 4 -> SERVERDATA_RESPONSE_STRING + 2, // 5 -> SERVERDATA_RESPONSE_REMOTEBUG +}; + +const std::string& response_t_Name(response_t value) +{ + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(response_t_entries, response_t_entries_by_number, 6, response_t_strings); + (void)dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(response_t_entries, response_t_entries_by_number, 6, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : response_t_strings[idx].get(); +} +bool response_t_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, response_t* value) +{ + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(response_t_entries, 6, name, &int_value); + if (success) + { + *value = static_cast<response_t>(int_value); + } + return success; +} + +// =================================================================== + +class response::_Internal +{ + public: + using HasBits = decltype(std::declval<response>()._has_bits_); + static void set_has_responseid(HasBits* has_bits) { (*has_bits)[0] |= 4u; } + static void set_has_responsetype(HasBits* has_bits) { (*has_bits)[0] |= 8u; } + static void set_has_responsebuf(HasBits* has_bits) { (*has_bits)[0] |= 1u; } + static void set_has_responseval(HasBits* has_bits) { (*has_bits)[0] |= 2u; } +}; + +response::response(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) +{ + SharedCtor(); + if (!is_message_owned) + { + RegisterArenaDtor(arena); + } + // @@protoc_insertion_point(arena_constructor:sv_rcon.response) +} +response::response(const response& from) : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _has_bits_(from._has_bits_) +{ + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); + responsebuf_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + responsebuf_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_responsebuf()) + { + responsebuf_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_responsebuf(), GetArenaForAllocation()); + } + responseval_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + responseval_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_responseval()) + { + responseval_.Set( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_responseval(), GetArenaForAllocation()); + } + ::memcpy( + &responseid_, &from.responseid_, + static_cast<size_t>(reinterpret_cast<char*>(&responsetype_) - reinterpret_cast<char*>(&responseid_)) + sizeof(responsetype_)); + // @@protoc_insertion_point(copy_constructor:sv_rcon.response) +} + +inline void response::SharedCtor() +{ + responsebuf_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + responsebuf_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + responseval_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + responseval_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + ::memset( + reinterpret_cast<char*>(this) + static_cast<size_t>(reinterpret_cast<char*>(&responseid_) - reinterpret_cast<char*>(this)), 0, + static_cast<size_t>(reinterpret_cast<char*>(&responsetype_) - reinterpret_cast<char*>(&responseid_)) + sizeof(responsetype_)); +} + +response::~response() +{ + // @@protoc_insertion_point(destructor:sv_rcon.response) + if (GetArenaForAllocation() != nullptr) + return; + SharedDtor(); + _internal_metadata_.Delete<std::string>(); +} + +inline void response::SharedDtor() +{ + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + responsebuf_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + responseval_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void response::ArenaDtor(void* object) +{ + response* _this = reinterpret_cast<response*>(object); + (void)_this; +} +void response::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {} +void response::SetCachedSize(int size) const { _cached_size_.Set(size); } + +void response::Clear() +{ + // @@protoc_insertion_point(message_clear_start:sv_rcon.response) + uint32_t 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) + { + responsebuf_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) + { + responseval_.ClearNonDefaultToEmpty(); + } + } + if (cached_has_bits & 0x0000000cu) + { + ::memset( + &responseid_, 0, + static_cast<size_t>(reinterpret_cast<char*>(&responsetype_) - reinterpret_cast<char*>(&responseid_)) + sizeof(responsetype_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear<std::string>(); +} + +const char* response::_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)) + { + uint32_t tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) + { + // optional int32 responseID = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) + { + _Internal::set_has_responseid(&has_bits); + responseid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // optional .sv_rcon.response_t responseType = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) + { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_responsetype(static_cast<::sv_rcon::response_t>(val)); + } + else + goto handle_unusual; + continue; + // optional string responseBuf = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) + { + auto str = _internal_mutable_responsebuf(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr)); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + // optional string responseVal = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) + { + auto str = _internal_mutable_responseval(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, nullptr)); + CHK_(ptr); + } + else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) + { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse(tag, _internal_metadata_.mutable_unknown_fields<std::string>(), ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* response::_InternalSerialize(uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const +{ + // @@protoc_insertion_point(serialize_to_array_start:sv_rcon.response) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // optional int32 responseID = 1; + if (_internal_has_responseid()) + { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_responseid(), target); + } + + // optional .sv_rcon.response_t responseType = 2; + if (_internal_has_responsetype()) + { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(2, this->_internal_responsetype(), target); + } + + // optional string responseBuf = 3; + if (_internal_has_responsebuf()) + { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_responsebuf().data(), static_cast<int>(this->_internal_responsebuf().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "sv_rcon.response.responseBuf"); + target = stream->WriteStringMaybeAliased(3, this->_internal_responsebuf(), target); + } + + // optional string responseVal = 4; + if (_internal_has_responseval()) + { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_responseval().data(), static_cast<int>(this->_internal_responseval().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "sv_rcon.response.responseVal"); + target = stream->WriteStringMaybeAliased(4, this->_internal_responseval(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) + { + target = stream->WriteRaw( + _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(), + static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), + target); + } + // @@protoc_insertion_point(serialize_to_array_end:sv_rcon.response) + return target; +} + +size_t response::ByteSizeLong() const +{ + // @@protoc_insertion_point(message_byte_size_start:sv_rcon.response) + size_t total_size = 0; + + uint32_t 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 & 0x0000000fu) + { + // optional string responseBuf = 3; + if (cached_has_bits & 0x00000001u) + { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(this->_internal_responsebuf()); + } + + // optional string responseVal = 4; + if (cached_has_bits & 0x00000002u) + { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(this->_internal_responseval()); + } + + // optional int32 responseID = 1; + if (cached_has_bits & 0x00000004u) + { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_responseid()); + } + + // optional .sv_rcon.response_t responseType = 2; + if (cached_has_bits & 0x00000008u) + { + total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_responsetype()); + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) + { + total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size(); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void response::CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) +{ + MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const response*>(&from)); +} + +void response::MergeFrom(const response& from) +{ + // @@protoc_insertion_point(class_specific_merge_from_start:sv_rcon.response) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) + { + if (cached_has_bits & 0x00000001u) + { + _internal_set_responsebuf(from._internal_responsebuf()); + } + if (cached_has_bits & 0x00000002u) + { + _internal_set_responseval(from._internal_responseval()); + } + if (cached_has_bits & 0x00000004u) + { + responseid_ = from.responseid_; + } + if (cached_has_bits & 0x00000008u) + { + responsetype_ = from.responsetype_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_); +} + +void response::CopyFrom(const response& from) +{ + // @@protoc_insertion_point(class_specific_copy_from_start:sv_rcon.response) + if (&from == this) + return; + Clear(); + MergeFrom(from); +} + +bool response::IsInitialized() const { return true; } + +void response::InternalSwap(response* other) +{ + using std::swap; + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &responsebuf_, lhs_arena, &other->responsebuf_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &responseval_, lhs_arena, &other->responseval_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(response, responsetype_) + sizeof(response::responsetype_) - PROTOBUF_FIELD_OFFSET(response, responseid_)>( + reinterpret_cast<char*>(&responseid_), reinterpret_cast<char*>(&other->responseid_)); +} + +std::string response::GetTypeName() const { return "sv_rcon.response"; } + +// @@protoc_insertion_point(namespace_scope) +} // namespace sv_rcon +PROTOBUF_NAMESPACE_OPEN +template <> PROTOBUF_NOINLINE ::sv_rcon::response* Arena::CreateMaybeMessage<::sv_rcon::response>(Arena* arena) +{ + return Arena::CreateMessageInternal<::sv_rcon::response>(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include <protobuf/port_undef.inc> |