// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: cl_rcon.proto

#include "cl_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 cl_rcon
{
constexpr request::request(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
	: requestbuf_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string),
	  requestval_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string), requestid_(0), requesttype_(0)
{
}
struct requestDefaultTypeInternal
{
	constexpr requestDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
	~requestDefaultTypeInternal() {}
	union
	{
		request _instance;
	};
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT requestDefaultTypeInternal _request_default_instance_;
} // namespace cl_rcon
namespace cl_rcon
{
bool request_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> request_t_strings[6] = {};

static const char request_t_names[] = "SERVERDATA_REQUEST_AUTH"
									  "SERVERDATA_REQUEST_EXECCOMMAND"
									  "SERVERDATA_REQUEST_SEND_CONSOLE_LOG"
									  "SERVERDATA_REQUEST_SEND_REMOTEBUG"
									  "SERVERDATA_REQUEST_SETVALUE"
									  "SERVERDATA_REQUEST_VALUE";

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry request_t_entries[] = {
	{{request_t_names + 0, 23}, 3},	 {{request_t_names + 23, 30}, 2},  {{request_t_names + 53, 35}, 4},
	{{request_t_names + 88, 33}, 5}, {{request_t_names + 121, 27}, 1}, {{request_t_names + 148, 24}, 0},
};

static const int request_t_entries_by_number[] = {
	5, // 0 -> SERVERDATA_REQUEST_VALUE
	4, // 1 -> SERVERDATA_REQUEST_SETVALUE
	1, // 2 -> SERVERDATA_REQUEST_EXECCOMMAND
	0, // 3 -> SERVERDATA_REQUEST_AUTH
	2, // 4 -> SERVERDATA_REQUEST_SEND_CONSOLE_LOG
	3, // 5 -> SERVERDATA_REQUEST_SEND_REMOTEBUG
};

const std::string& request_t_Name(request_t value)
{
	static const bool dummy =
		::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(request_t_entries, request_t_entries_by_number, 6, request_t_strings);
	(void)dummy;
	int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(request_t_entries, request_t_entries_by_number, 6, value);
	return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() : request_t_strings[idx].get();
}
bool request_t_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, request_t* value)
{
	int int_value;
	bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(request_t_entries, 6, name, &int_value);
	if (success)
	{
		*value = static_cast<request_t>(int_value);
	}
	return success;
}

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

class request::_Internal
{
  public:
	using HasBits = decltype(std::declval<request>()._has_bits_);
	static void set_has_requestid(HasBits* has_bits) { (*has_bits)[0] |= 4u; }
	static void set_has_requesttype(HasBits* has_bits) { (*has_bits)[0] |= 8u; }
	static void set_has_requestbuf(HasBits* has_bits) { (*has_bits)[0] |= 1u; }
	static void set_has_requestval(HasBits* has_bits) { (*has_bits)[0] |= 2u; }
};

request::request(::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:cl_rcon.request)
}
request::request(const request& from) : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _has_bits_(from._has_bits_)
{
	_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
	requestbuf_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
	requestbuf_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
	if (from._internal_has_requestbuf())
	{
		requestbuf_.Set(
			::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_requestbuf(), GetArenaForAllocation());
	}
	requestval_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
	requestval_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
	if (from._internal_has_requestval())
	{
		requestval_.Set(
			::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_requestval(), GetArenaForAllocation());
	}
	::memcpy(
		&requestid_, &from.requestid_,
		static_cast<size_t>(reinterpret_cast<char*>(&requesttype_) - reinterpret_cast<char*>(&requestid_)) + sizeof(requesttype_));
	// @@protoc_insertion_point(copy_constructor:cl_rcon.request)
}

inline void request::SharedCtor()
{
	requestbuf_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
	requestbuf_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
	requestval_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
	requestval_.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*>(&requestid_) - reinterpret_cast<char*>(this)), 0,
		static_cast<size_t>(reinterpret_cast<char*>(&requesttype_) - reinterpret_cast<char*>(&requestid_)) + sizeof(requesttype_));
}

request::~request()
{
	// @@protoc_insertion_point(destructor:cl_rcon.request)
	if (GetArenaForAllocation() != nullptr)
		return;
	SharedDtor();
	_internal_metadata_.Delete<std::string>();
}

inline void request::SharedDtor()
{
	GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
	requestbuf_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
	requestval_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void request::ArenaDtor(void* object)
{
	request* _this = reinterpret_cast<request*>(object);
	(void)_this;
}
void request::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {}
void request::SetCachedSize(int size) const { _cached_size_.Set(size); }

void request::Clear()
{
	// @@protoc_insertion_point(message_clear_start:cl_rcon.request)
	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)
		{
			requestbuf_.ClearNonDefaultToEmpty();
		}
		if (cached_has_bits & 0x00000002u)
		{
			requestval_.ClearNonDefaultToEmpty();
		}
	}
	if (cached_has_bits & 0x0000000cu)
	{
		::memset(
			&requestid_, 0,
			static_cast<size_t>(reinterpret_cast<char*>(&requesttype_) - reinterpret_cast<char*>(&requestid_)) + sizeof(requesttype_));
	}
	_has_bits_.Clear();
	_internal_metadata_.Clear<std::string>();
}

const char* request::_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 requestID = 1;
		case 1:
			if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8))
			{
				_Internal::set_has_requestid(&has_bits);
				requestid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
				CHK_(ptr);
			}
			else
				goto handle_unusual;
			continue;
		// optional .cl_rcon.request_t requestType = 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_requesttype(static_cast<::cl_rcon::request_t>(val));
			}
			else
				goto handle_unusual;
			continue;
		// optional string requestBuf = 3;
		case 3:
			if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26))
			{
				auto str = _internal_mutable_requestbuf();
				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 requestVal = 4;
		case 4:
			if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34))
			{
				auto str = _internal_mutable_requestval();
				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* request::_InternalSerialize(uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const
{
	// @@protoc_insertion_point(serialize_to_array_start:cl_rcon.request)
	uint32_t cached_has_bits = 0;
	(void)cached_has_bits;

	// optional int32 requestID = 1;
	if (_internal_has_requestid())
	{
		target = stream->EnsureSpace(target);
		target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_requestid(), target);
	}

	// optional .cl_rcon.request_t requestType = 2;
	if (_internal_has_requesttype())
	{
		target = stream->EnsureSpace(target);
		target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(2, this->_internal_requesttype(), target);
	}

	// optional string requestBuf = 3;
	if (_internal_has_requestbuf())
	{
		::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
			this->_internal_requestbuf().data(), static_cast<int>(this->_internal_requestbuf().length()),
			::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "cl_rcon.request.requestBuf");
		target = stream->WriteStringMaybeAliased(3, this->_internal_requestbuf(), target);
	}

	// optional string requestVal = 4;
	if (_internal_has_requestval())
	{
		::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
			this->_internal_requestval().data(), static_cast<int>(this->_internal_requestval().length()),
			::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "cl_rcon.request.requestVal");
		target = stream->WriteStringMaybeAliased(4, this->_internal_requestval(), 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:cl_rcon.request)
	return target;
}

size_t request::ByteSizeLong() const
{
	// @@protoc_insertion_point(message_byte_size_start:cl_rcon.request)
	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 requestBuf = 3;
		if (cached_has_bits & 0x00000001u)
		{
			total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(this->_internal_requestbuf());
		}

		// optional string requestVal = 4;
		if (cached_has_bits & 0x00000002u)
		{
			total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(this->_internal_requestval());
		}

		// optional int32 requestID = 1;
		if (cached_has_bits & 0x00000004u)
		{
			total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_requestid());
		}

		// optional .cl_rcon.request_t requestType = 2;
		if (cached_has_bits & 0x00000008u)
		{
			total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_requesttype());
		}
	}
	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 request::CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
{
	MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const request*>(&from));
}

void request::MergeFrom(const request& from)
{
	// @@protoc_insertion_point(class_specific_merge_from_start:cl_rcon.request)
	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_requestbuf(from._internal_requestbuf());
		}
		if (cached_has_bits & 0x00000002u)
		{
			_internal_set_requestval(from._internal_requestval());
		}
		if (cached_has_bits & 0x00000004u)
		{
			requestid_ = from.requestid_;
		}
		if (cached_has_bits & 0x00000008u)
		{
			requesttype_ = from.requesttype_;
		}
		_has_bits_[0] |= cached_has_bits;
	}
	_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

bool request::IsInitialized() const { return true; }

void request::InternalSwap(request* 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(), &requestbuf_, lhs_arena, &other->requestbuf_, rhs_arena);
	::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
		&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), &requestval_, lhs_arena, &other->requestval_, rhs_arena);
	::PROTOBUF_NAMESPACE_ID::internal::memswap<
		PROTOBUF_FIELD_OFFSET(request, requesttype_) + sizeof(request::requesttype_) - PROTOBUF_FIELD_OFFSET(request, requestid_)>(
		reinterpret_cast<char*>(&requestid_), reinterpret_cast<char*>(&other->requestid_));
}

std::string request::GetTypeName() const { return "cl_rcon.request"; }

// @@protoc_insertion_point(namespace_scope)
} // namespace cl_rcon
PROTOBUF_NAMESPACE_OPEN
template <> PROTOBUF_NOINLINE ::cl_rcon::request* Arena::CreateMaybeMessage<::cl_rcon::request>(Arena* arena)
{
	return Arena::CreateMessageInternal<::cl_rcon::request>(arena);
}
PROTOBUF_NAMESPACE_CLOSE

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