int RseAuthState::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// required bool pass = 1;
if (has_pass()) {
total_size += 1 + 1;
}
// required int32 type = 2;
if (has_type()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->type());
}
// required int32 leftMin = 3;
if (has_leftmin()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->leftmin());
}
}
if (!unknown_fields().empty()) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
unknown_fields());
}
_cached_size_ = total_size;
return total_size;
}
int Sess::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional string id = 1;
if (has_id()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->id());
}
// optional int32 type = 2;
if (has_type()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->type());
}
// optional int64 lasttime = 3;
if (has_lasttime()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int64Size(
this->lasttime());
}
// optional string sessid = 4;
if (has_sessid()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->sessid());
}
// optional int32 consvid = 5;
if (has_consvid()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->consvid());
}
// optional string version = 6;
if (has_version()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->version());
}
}
// repeated .gim.Pair kvs = 7;
total_size += 1 * this->kvs_size();
for (int i = 0; i < this->kvs_size(); i++) {
total_size +=
::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
this->kvs(i));
}
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = total_size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
return total_size;
}
int Person_PhoneNumber::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// required string number = 1;
if (has_number()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->number());
}
// optional .tutorial.Person.PhoneType type = 2 [default = HOME];
if (has_type()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
}
}
total_size += unknown_fields().size();
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = total_size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
return total_size;
}
void zone_manager::deserialize( JsonIn &jsin )
{
zones.clear();
jsin.start_array();
while( !jsin.end_array() ) {
JsonObject jo_zone = jsin.get_object();
const std::string name = jo_zone.get_string( "name" );
const std::string type = jo_zone.get_string( "type" );
const bool invert = jo_zone.get_bool( "invert" );
const bool enabled = jo_zone.get_bool( "enabled" );
// Z coords need to have a default value - old saves won't have those
const int start_x = jo_zone.get_int( "start_x" );
const int start_y = jo_zone.get_int( "start_y" );
const int start_z = jo_zone.get_int( "start_z", 0 );
const int end_x = jo_zone.get_int( "end_x" );
const int end_y = jo_zone.get_int( "end_y" );
const int end_z = jo_zone.get_int( "end_z", 0 );
if( has_type( type ) ) {
add( name, type, invert, enabled,
tripoint( start_x, start_y, start_z ),
tripoint( end_x, end_y, end_z ) );
} else {
debugmsg( "Invalid zone type: %s", type.c_str() );
}
}
}
int RceQueryPvE::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional int32 type = 1;
if (has_type()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->type());
}
// optional int32 pass = 2;
if (has_pass()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->pass());
}
}
if (!unknown_fields().empty()) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
unknown_fields());
}
_cached_size_ = total_size;
return total_size;
}
void change_visibility(DexMethod* method) {
auto code = method->get_code();
always_assert(code != nullptr);
editable_cfg_adapter::iterate(code, [](MethodItemEntry& mie) {
auto insn = mie.insn;
if (insn->has_field()) {
auto cls = type_class(insn->get_field()->get_class());
if (cls != nullptr && !cls->is_external()) {
set_public(cls);
}
auto field =
resolve_field(insn->get_field(), is_sfield_op(insn->opcode())
? FieldSearch::Static : FieldSearch::Instance);
if (field != nullptr && field->is_concrete()) {
set_public(field);
set_public(type_class(field->get_class()));
// FIXME no point in rewriting opcodes in the method
insn->set_field(field);
}
} else if (insn->has_method()) {
auto cls = type_class(insn->get_method()->get_class());
if (cls != nullptr && !cls->is_external()) {
set_public(cls);
}
auto current_method = resolve_method(
insn->get_method(), opcode_to_search(insn));
if (current_method != nullptr && current_method->is_concrete()) {
set_public(current_method);
set_public(type_class(current_method->get_class()));
// FIXME no point in rewriting opcodes in the method
insn->set_method(current_method);
}
} else if (insn->has_type()) {
auto type = insn->get_type();
auto cls = type_class(type);
if (cls != nullptr && !cls->is_external()) {
set_public(cls);
}
}
return editable_cfg_adapter::LOOP_CONTINUE;
});
std::vector<DexType*> types;
if (code->editable_cfg_built()) {
code->cfg().gather_catch_types(types);
} else {
code->gather_catch_types(types);
}
for (auto type : types) {
auto cls = type_class(type);
if (cls != nullptr && !cls->is_external()) {
set_public(cls);
}
}
}
void *belle_sip_object_cast(belle_sip_object_t *obj, belle_sip_type_id_t id, const char *castname, const char *file, int fileno){
if (obj!=NULL){
if (has_type(obj,id)==0){
belle_sip_fatal("Bad cast to %s at %s:%i",castname,file,fileno);
return NULL;
}
}
return obj;
}
int reg_feature(struct feature_info* feature_info)
{
printk(KERN_INFO "registering feature '%s'\n", feature_info->name);
if(has_type(feature_info) == -1)
{
return -1;
}
return 0;
}
const Type&
Frame::Implementation::find_type (const Frame& frame, const symbol key) const
{
if (has_type (key))
return get_type (key);
daisy_assert (frame.parent ());
const Frame& parent = *frame.parent ();
return parent.impl->find_type (parent, key);
}
void zone_manager::deserialize( JsonIn &jsin )
{
jsin.read( zones );
for( auto it = zones.begin(); it != zones.end(); ++it ) {
const zone_type_id zone_type = it->get_type();
if( !has_type( zone_type ) ) {
zones.erase( it );
debugmsg( "Invalid zone type: %s", zone_type.c_str() );
}
}
}
void Message::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// optional string to = 1;
if (has_to()) {
::google::protobuf::internal::WireFormatLite::WriteString(
1, this->to(), output);
}
// optional int64 id = 2;
if (has_id()) {
::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->id(), output);
}
// optional int64 time = 3;
if (has_time()) {
::google::protobuf::internal::WireFormatLite::WriteInt64(3, this->time(), output);
}
// optional string from = 4;
if (has_from()) {
::google::protobuf::internal::WireFormatLite::WriteString(
4, this->from(), output);
}
// optional int32 type = 5;
if (has_type()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->type(), output);
}
// optional string sn = 6;
if (has_sn()) {
::google::protobuf::internal::WireFormatLite::WriteString(
6, this->sn(), output);
}
// optional bytes data = 7;
if (has_data()) {
::google::protobuf::internal::WireFormatLite::WriteBytes(
7, this->data(), output);
}
// optional int64 expire = 8;
if (has_expire()) {
::google::protobuf::internal::WireFormatLite::WriteInt64(8, this->expire(), output);
}
}
void Person_PhoneNumber::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// @@protoc_insertion_point(serialize_start:tutorial.Person.PhoneNumber)
// required string number = 1;
if (has_number()) {
::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
1, this->number(), output);
}
// optional .tutorial.Person.PhoneType type = 2 [default = HOME];
if (has_type()) {
::google::protobuf::internal::WireFormatLite::WriteEnum(
2, this->type(), output);
}
output->WriteRaw(unknown_fields().data(),
unknown_fields().size());
// @@protoc_insertion_point(serialize_end:tutorial.Person.PhoneNumber)
}
void Sess::SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const {
// optional string id = 1;
if (has_id()) {
::google::protobuf::internal::WireFormatLite::WriteString(
1, this->id(), output);
}
// optional int32 type = 2;
if (has_type()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->type(), output);
}
// optional int64 lasttime = 3;
if (has_lasttime()) {
::google::protobuf::internal::WireFormatLite::WriteInt64(3, this->lasttime(), output);
}
// optional string sessid = 4;
if (has_sessid()) {
::google::protobuf::internal::WireFormatLite::WriteString(
4, this->sessid(), output);
}
// optional int32 consvid = 5;
if (has_consvid()) {
::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->consvid(), output);
}
// optional string version = 6;
if (has_version()) {
::google::protobuf::internal::WireFormatLite::WriteString(
6, this->version(), output);
}
// repeated .gim.Pair kvs = 7;
for (int i = 0; i < this->kvs_size(); i++) {
::google::protobuf::internal::WireFormatLite::WriteMessage(
7, this->kvs(i), output);
}
}
uint64_t IRInstruction::hash() const {
std::vector<uint64_t> bits;
bits.push_back(opcode());
for (size_t i = 0; i < srcs_size(); i++) {
bits.push_back(src(i));
}
if (dests_size() > 0) {
bits.push_back(dest());
}
if (has_data()) {
size_t size = get_data()->data_size();
const auto& data = get_data()->data();
for (size_t i = 0; i < size; i++) {
bits.push_back(data[i]);
}
}
if (has_type()) {
bits.push_back(reinterpret_cast<uint64_t>(get_type()));
}
if (has_field()) {
bits.push_back(reinterpret_cast<uint64_t>(get_field()));
}
if (has_method()) {
bits.push_back(reinterpret_cast<uint64_t>(get_method()));
}
if (has_string()) {
bits.push_back(reinterpret_cast<uint64_t>(get_string()));
}
if (has_literal()) {
bits.push_back(get_literal());
}
uint64_t result = 0;
for (uint64_t elem : bits) {
result ^= elem;
}
return result;
}
int RceQueryRefuseReceiveWishItem::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional string type = 1;
if (has_type()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->type());
}
// optional string name = 2;
if (has_name()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->name());
}
// optional string playerId = 3;
if (has_playerid()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->playerid());
}
// optional string id = 4;
if (has_id()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->id());
}
// optional string guid = 5;
if (has_guid()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->guid());
}
// optional string planetId = 6;
if (has_planetid()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->planetid());
}
// optional string time = 7;
if (has_time()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->time());
}
// optional string msg = 8;
if (has_msg()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->msg());
}
}
if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
// optional string url = 9;
if (has_url()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->url());
}
}
if (!unknown_fields().empty()) {
total_size +=
::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
unknown_fields());
}
_cached_size_ = total_size;
return total_size;
}
void curr_attack() {
// see if nv status allow for attack
switch (CURR_POKEMON->nv.nvstatus) {
case NON_S:
case BRN_S:
case PSN_S:
case TXC_S:
break;
case FRZ_S:
if (roll(.2)) {
sprintf(msg, "%s thawed out!", CURR_PNAME); send();
CURR_POKEMON->nv.nvstatus = NON_S;
break;
} else {
sprintf(msg, "%s is frozen solid!", CURR_PNAME); send();
return;
}
case PAR_S:
if (roll(.25)) {
sprintf(msg, "%s is fully paralyzed!", CURR_PNAME); send();
return;
} else {
break;
}
case SLP_S:
if (CURR_POKEMON->nv.nv_arg > 0) {
sprintf(msg, "%s is fast asleep!", CURR_PNAME); send();
CURR_POKEMON->nv.nv_arg--;
return;
} else {
sprintf(msg, "%s woke up!", CURR_PNAME); send();
CURR_POKEMON->nv.nvstatus = NON_S;
break;
}
case FNT_S: // should never happen
default:
return;
}
// see if v status allows for attack
if (CURR_POKEMON->v.is_flinch) {
sprintf(msg, "%s flinched!", CURR_PNAME); send();
CURR_POKEMON->v.is_flinch = false;
return;
}
if (CURR_POKEMON->v.is_recharge) {
sprintf(msg, "%s is recharging!", CURR_PNAME); send();
CURR_POKEMON->v.is_recharge = false;
return;
}
if (CURR_POKEMON->v.is_confuse) {
sprintf(msg, "%s is confused!", CURR_PNAME); send();
if (roll(.25)) { // this is not quite how it works in Pokemon
sprintf(msg, "%s snapped out of confusion!", CURR_PNAME); send();
CURR_POKEMON->v.is_confuse = false;
} else {
if (roll(.5)) {
sprintf(msg, "%s hurt itself in confusion!", CURR_PNAME); send();
int damage = calc_damage(CURR_POKEMON, CURR_POKEMON, 40, PHYSICAL_MT);
// printf("[%s applied %i damage to himself]", CURR_PNAME, damage);
apply_damage(CURR_POKEMON, damage);
return;
}
}
}
move_s *move = curr_move();
sprintf(msg, "%s used %s!", CURR_PNAME, move->name); send();
// check if unique
if (move->unique) {
switch (move->unique) {
default: // no unique moves at the moment
return;
}
}
// check accuracy
if (is_aggressive(move)) {
if (!roll(move->accuracy * calc_accuracy(CURR_POKEMON, OTHR_POKEMON))) { // swift support?
sprintf(msg, "It missed!"); send();
return;
}
if (move->movetype != STATUS_MT) {
int damage = calc_damage(CURR_POKEMON, OTHR_POKEMON, move->damage, move->movetype);
double stab_bonus = (has_type(CURR_POKEMON, move->type) ? 1.5 : 1); // STAB bonus
double effective_bonus = calc_effective(move->type, OTHR_POKEMON); // type bonus
double crit_chance = (move->effect == HIGH_CRIT_E2 ? .125 : .0625);
double crit_bonus = (roll(crit_chance) ? 1.5 : 1.0); // this is not quite how it works in Pokemon
double rndm = (rand() % 16 + 85) / 100.0;
// printf("%i, %lf, %lf, %lf, %lf", damage, stab_bonus, effective_bonus, crit_bonus, rndm);
int total_damage = (int)(damage * stab_bonus * effective_bonus * crit_bonus * rndm);
// if burnt, physical damage output is halfed
if (CURR_POKEMON->nv.nvstatus == BRN_S && move->movetype == PHYSICAL_MT) {
total_damage /= 2;
}
if (effective_bonus > 1) {
sprintf(msg, "It's super effective!"); send();
} else if (effective_bonus == 0) {
sprintf(msg, "It has no effect!"); send();
} else if (effective_bonus < 1) {
sprintf(msg, "It's not very effective!"); send();
}
if (crit_bonus > 1) {
sprintf(msg, "Critical hit!"); send();
}
// printf("[%s applies %i damage to %s]", CURR_PNAME, total_damage, OTHR_PNAME);
apply_damage(OTHR_POKEMON, total_damage);
} else {
if (calc_effective(move->type, OTHR_POKEMON) == 0) { // thunder wave can't work on ground
sprintf(msg, "It has no effect!"); send();
return;
}
}
}
int calculation; // can be used for some of the switch cases
// check secondary effect
if (move->effect != NON_E2) {
if (roll(move->chance)) {
switch (move->effect) {
case APPLY_BRN_E2:
apply_nvstatus(OTHR_POKEMON, BRN_S);
break;
case APPLY_FRZ_E2:
apply_nvstatus(OTHR_POKEMON, FRZ_S);
break;
case APPLY_PAR_E2:
apply_nvstatus(OTHR_POKEMON, PAR_S);
break;
case APPLY_PSN_E2:
apply_nvstatus(OTHR_POKEMON, PSN_S);
break;
case APPLY_TXC_E2:
apply_nvstatus(OTHR_POKEMON, TXC_S);
break;
case APPLY_SLP_E2:
apply_nvstatus(OTHR_POKEMON, SLP_S);
break;
case APPLY_FLINCH_E2:
OTHR_POKEMON->v.is_flinch = true;
break;
case APPLY_CONFUSE_E2:
sprintf(msg, "%s became confused!", OTHR_PNAME); send();
OTHR_POKEMON->v.is_confuse = true;
break;
case HIGH_CRIT_E2:
break; // this doesn't happen here
case SELF_KILL_E2:
apply_nvstatus(CURR_POKEMON, FNT_S);
break;
case SELF_ATTACK_E2:
apply_attackstage(CURR_POKEMON, move->m_arg);
break;
case SELF_DEFENSE_E2:
apply_defensestage(CURR_POKEMON, move->m_arg);
break;
case SELF_SATTACK_E2:
apply_sattackstage(CURR_POKEMON, move->m_arg);
break;
case SELF_SDEFENSE_E2:
apply_sdefensestage(CURR_POKEMON, move->m_arg);
break;
case SELF_SPEED_E2:
apply_speedstage(CURR_POKEMON, move->m_arg);
break;
case SELF_ACCURACY_E2:
apply_accuracystage(CURR_POKEMON, move->m_arg);
break;
case SELF_EVASION_E2:
apply_evasionstage(CURR_POKEMON, move->m_arg);
break;
case OTHR_ATTACK_E2:
apply_attackstage(OTHR_POKEMON, move->m_arg);
break;
case OTHR_DEFENSE_E2:
apply_defensestage(OTHR_POKEMON, move->m_arg);
break;
case OTHR_SATTACK_E2:
apply_sattackstage(OTHR_POKEMON, move->m_arg);
break;
case OTHR_SDEFENSE_E2:
apply_sdefensestage(OTHR_POKEMON, move->m_arg);
break;
case OTHR_SPEED_E2:
apply_speedstage(OTHR_POKEMON, move->m_arg);
break;
case OTHR_ACCURACY_E2:
apply_accuracystage(OTHR_POKEMON, move->m_arg);
break;
case OTHR_EVASION_E2:
apply_evasionstage(OTHR_POKEMON, move->m_arg);
break;
case SELF_ATTACK_SATTACK_E2:
apply_attackstage(CURR_POKEMON, move->m_arg);
apply_sattackstage(CURR_POKEMON, move->m_arg);
break;
case HAZE_E2:
reset_stages(CURR_POKEMON);
reset_stages(OTHR_POKEMON);
break;
case RECOIL_E2:
calculation = battle.last_dmg / move->m_arg; // pos is recoil, neg is heal
if (calculation > 0) {
sprintf(msg, "%s was hit with recoil!", CURR_PNAME); send();
// printf("[%s took %i damage in recoil]", CURR_PNAME, calculation);
} else if (calculation < 0) {
sprintf(msg, "%s regained health!", CURR_PNAME); send();
// printf("[%s restored %i damage]", CURR_PNAME, calculation);
}
apply_damage(CURR_POKEMON, calculation);
break; // this doesn't happen here
case RECHARGE_E2:
CURR_POKEMON->v.is_recharge = true;
break;
case NON_E2: // shouldn't happen
break;
}
}
}
}
void apply_nvstatus(pokemon_s *pokemon, nvstatus_t status) {
if (status == FNT_S) {
sprintf(msg, "%s fainted!", pokemon->species->name); send();
pokemon->nv.nvstatus = FNT_S;
pokemon->nv.hp = 0;
return;
}
if (pokemon->nv.nvstatus == NON_S) {
switch (status) {
case BRN_S: // cant burn fire
if (!has_type(pokemon, FIRE_T)) {
sprintf(msg, "%s was burnt!", pokemon->species->name); send();
pokemon->nv.nvstatus = BRN_S;
display_hp();
} else {
sprintf(msg, "%s is immune to burns!", pokemon->species->name); send();
}
break;
case PSN_S: // cant poison poison
if (!has_type(pokemon, POISON_T)) {
sprintf(msg, "%s was poisoned!", pokemon->species->name); send();
pokemon->nv.nvstatus = PSN_S;
display_hp();
} else {
sprintf(msg, "%s is immune to poison!", pokemon->species->name); send();
}
break;
case TXC_S: // cant toxic poison
if (!has_type(pokemon, POISON_T)) {
sprintf(msg, "%s was badly poisoned!", pokemon->species->name); send();
pokemon->nv.nvstatus = TXC_S;
pokemon->nv.nv_arg = 1;
display_hp();
} else {
sprintf(msg, "%s is immune to toxic!", pokemon->species->name); send();
}
break;
case FRZ_S: // cant freeze ice
if (!has_type(pokemon, ICE_T)) {
sprintf(msg, "%s was frozen solid!", pokemon->species->name); send();
pokemon->nv.nvstatus = FRZ_S;
display_hp();
} else {
sprintf(msg, "%s is immune to freezing!", pokemon->species->name); send();
}
break;
case PAR_S: // cant paralyze electric
if (!has_type(pokemon, ELECTRIC_T)) {
sprintf(msg, "%s was paralyzed!", pokemon->species->name); send();
pokemon->nv.nvstatus = PAR_S;
display_hp();
} else {
sprintf(msg, "%s is immune to paralysis!", pokemon->species->name); send();
}
break;
case SLP_S:
sprintf(msg, "%s fell asleep!", pokemon->species->name); send();
pokemon->nv.nvstatus = SLP_S;
pokemon->nv.nv_arg = rand() % 3 + 1;
display_hp();
break;
case FNT_S: // shouldn't happen
case NON_S:
default:
return;
}
} else {
sprintf(msg, "%s is already %s!", pokemon->species->name, get_statusname(pokemon->nv.nvstatus));
}
}
int _belle_sip_object_is_instance_of(belle_sip_object_t * obj,belle_sip_type_id_t id) {
return has_type(obj,id);
}
int Message::ByteSize() const {
int total_size = 0;
if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
// optional string to = 1;
if (has_to()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->to());
}
// optional int64 id = 2;
if (has_id()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int64Size(
this->id());
}
// optional int64 time = 3;
if (has_time()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int64Size(
this->time());
}
// optional string from = 4;
if (has_from()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->from());
}
// optional int32 type = 5;
if (has_type()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int32Size(
this->type());
}
// optional string sn = 6;
if (has_sn()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::StringSize(
this->sn());
}
// optional bytes data = 7;
if (has_data()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::BytesSize(
this->data());
}
// optional int64 expire = 8;
if (has_expire()) {
total_size += 1 +
::google::protobuf::internal::WireFormatLite::Int64Size(
this->expire());
}
}
GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
_cached_size_ = total_size;
GOOGLE_SAFE_CONCURRENT_WRITES_END();
return total_size;
}