path: root/NorthstarDedicatedTest/sv_rcon.pb.cc

// 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>