Skip to content

Commit c3d39bc

Browse files
melvinhealexander-e1off
melvinhe
authored and
alexander-e1off
committed
Fix: bmqp protocol Wconv warns (bloomberg#257)
Signed-off-by: Melvin He <[email protected]> Signed-off-by: Patrick M. Niedzielski <[email protected]>
1 parent f857157 commit c3d39bc

File tree

3 files changed

+95
-78
lines changed

3 files changed

+95
-78
lines changed

‎src/groups/bmq/bmqp/bmqp_protocol.cpp

+4-4
Original file line numberDiff line numberDiff line change
@@ -454,7 +454,7 @@ bool PutHeaderFlags::fromAscii(PutHeaderFlags::Enum* out,
454454
#define CHECKVALUE(M) \
455455
if (bdlb::String::areEqualCaseless(toAscii(PutHeaderFlags::e_##M), \
456456
str.data(), \
457-
str.length())) { \
457+
static_cast<int>(str.length()))) { \
458458
*out = PutHeaderFlags::e_##M; \
459459
return true; \
460460
}
@@ -628,7 +628,7 @@ bool PushHeaderFlags::fromAscii(PushHeaderFlags::Enum* out,
628628
#define CHECKVALUE(M) \
629629
if (bdlb::String::areEqualCaseless(toAscii(PushHeaderFlags::e_##M), \
630630
str.data(), \
631-
str.length())) { \
631+
static_cast<int>(str.length()))) { \
632632
*out = PushHeaderFlags::e_##M; \
633633
return true; \
634634
}
@@ -833,7 +833,7 @@ bool StorageHeaderFlags::fromAscii(StorageHeaderFlags::Enum* out,
833833
#define CHECKVALUE(M) \
834834
if (bdlb::String::areEqualCaseless(toAscii(StorageHeaderFlags::e_##M), \
835835
str.data(), \
836-
str.length())) { \
836+
static_cast<int>(str.length()))) { \
837837
*out = StorageHeaderFlags::e_##M; \
838838
return true; \
839839
}
@@ -909,7 +909,7 @@ int StorageHeaderFlagUtil::fromString(bsl::ostream& errorDescription,
909909
rc = -1;
910910
}
911911
else {
912-
*out |= value;
912+
*out |= static_cast<unsigned char>(value);
913913
}
914914
}
915915

‎src/groups/bmq/bmqp/bmqp_protocol.h

+72-66
Original file line numberDiff line numberDiff line change
@@ -3515,7 +3515,7 @@ inline bool MessagePropertiesInfo::isExtended() const
35153515
inline MessagePropertiesInfo::SchemaIdType
35163516
MessagePropertiesInfo::schemaId() const
35173517
{
3518-
return d_schemaWireId >> 1;
3518+
return static_cast<SchemaIdType>(d_schemaWireId >> 1);
35193519
}
35203520

35213521
inline bool
@@ -3565,7 +3565,7 @@ inline RdaInfo::RdaInfo(unsigned int internalRepresentation)
35653565
{
35663566
BSLS_ASSERT_SAFE(internalRepresentation <= k_MAX_INTERNAL_COUNTER_VALUE);
35673567

3568-
d_counter = internalRepresentation;
3568+
d_counter = static_cast<unsigned char>(internalRepresentation);
35693569
}
35703570

35713571
inline RdaInfo::RdaInfo(const RdaInfo& original)
@@ -3599,7 +3599,8 @@ inline RdaInfo& RdaInfo::setCounter(unsigned int counter)
35993599
{
36003600
BSLS_ASSERT_SAFE(counter <= k_MAX_COUNTER_VALUE);
36013601
// Drop e_UNLIMITED bit flag if set, but save e_POISONOUS bit
3602-
d_counter = counter | (d_counter & e_POISONOUS);
3602+
d_counter = static_cast<unsigned char>(counter |
3603+
(d_counter & e_POISONOUS));
36033604
return *this;
36043605
}
36053606

@@ -3665,7 +3666,7 @@ inline bsls::Types::Uint64 Protocol::combine(unsigned int upper,
36653666

36663667
inline unsigned int Protocol::getUpper(bsls::Types::Uint64 value)
36673668
{
3668-
return (value >> 32) & 0xFFFFFFFF;
3669+
return static_cast<unsigned int>((value >> 32) & 0xFFFFFFFF);
36693670
}
36703671

36713672
inline unsigned int Protocol::getLower(bsls::Types::Uint64 value)
@@ -3745,8 +3746,9 @@ inline EventHeader& EventHeader::setProtocolVersion(unsigned char value)
37453746
// PRECONDITIONS: protect against overflow
37463747
BSLS_ASSERT_SAFE(value <= (1 << k_PROTOCOL_VERSION_NUM_BITS) - 1);
37473748

3748-
d_protocolVersionAndType = (d_protocolVersionAndType & k_TYPE_MASK) |
3749-
(value << k_PROTOCOL_VERSION_START_IDX);
3749+
d_protocolVersionAndType = static_cast<unsigned char>(
3750+
(d_protocolVersionAndType & k_TYPE_MASK) |
3751+
(value << k_PROTOCOL_VERSION_START_IDX));
37503752

37513753
return *this;
37523754
}
@@ -3757,10 +3759,9 @@ inline EventHeader& EventHeader::setType(EventType::Enum value)
37573759
BSLS_ASSERT_SAFE(value >= 0 &&
37583760
static_cast<int>(value) <= (1 << k_TYPE_NUM_BITS) - 1);
37593761

3760-
d_protocolVersionAndType = (d_protocolVersionAndType &
3761-
k_PROTOCOL_VERSION_MASK) |
3762-
(static_cast<unsigned char>(value) &
3763-
k_TYPE_MASK);
3762+
d_protocolVersionAndType = static_cast<unsigned char>(
3763+
(d_protocolVersionAndType & k_PROTOCOL_VERSION_MASK) |
3764+
(static_cast<unsigned char>(value) & k_TYPE_MASK));
37643765

37653766
return *this;
37663767
}
@@ -3792,8 +3793,9 @@ inline int EventHeader::length() const
37923793

37933794
inline unsigned char EventHeader::protocolVersion() const
37943795
{
3795-
return (d_protocolVersionAndType & k_PROTOCOL_VERSION_MASK) >>
3796-
k_PROTOCOL_VERSION_START_IDX;
3796+
return static_cast<unsigned char>(
3797+
(d_protocolVersionAndType & k_PROTOCOL_VERSION_MASK) >>
3798+
k_PROTOCOL_VERSION_START_IDX);
37973799
}
37983800

37993801
inline EventType::Enum EventHeader::type() const
@@ -3827,10 +3829,11 @@ EventHeaderUtil::setControlEventEncodingType(EventHeader* eventHeader,
38273829
unsigned char typeSpecific = eventHeader->typeSpecific();
38283830

38293831
// Reset the bits for encoding type
3830-
typeSpecific &= ~k_CONTROL_EVENT_ENCODING_MASK;
3832+
typeSpecific &= static_cast<unsigned char>(~k_CONTROL_EVENT_ENCODING_MASK);
38313833

38323834
// Set those bits to represent 'type'
3833-
typeSpecific |= (type << k_CONTROL_EVENT_ENCODING_START_IDX);
3835+
typeSpecific |= static_cast<unsigned char>(
3836+
type << k_CONTROL_EVENT_ENCODING_START_IDX);
38343837

38353838
eventHeader->setTypeSpecific(typeSpecific);
38363839
}
@@ -3935,10 +3938,11 @@ inline MessagePropertiesHeader::MessagePropertiesHeader()
39353938
{
39363939
bsl::memset(this, 0, sizeof(MessagePropertiesHeader));
39373940
size_t headerSize = sizeof(MessagePropertiesHeader);
3938-
setHeaderSize(headerSize);
3941+
setHeaderSize(static_cast<int>(headerSize));
39393942

39403943
size_t roundedSize = headerSize + (headerSize % Protocol::k_WORD_SIZE);
3941-
setMessagePropertiesAreaWords(roundedSize / Protocol::k_WORD_SIZE);
3944+
setMessagePropertiesAreaWords(
3945+
static_cast<int>(roundedSize / Protocol::k_WORD_SIZE));
39423946

39433947
setMessagePropertyHeaderSize(sizeof(MessagePropertyHeader));
39443948
static_cast<void>(d_reserved);
@@ -3952,9 +3956,9 @@ MessagePropertiesHeader::setHeaderSize(int value)
39523956
BSLS_ASSERT_SAFE(value >= 0 &&
39533957
value <= ((1 << k_HEADER_SIZE_2X_NUM_BITS) - 1));
39543958

3955-
d_mphSize2xAndHeaderSize2x = (d_mphSize2xAndHeaderSize2x &
3956-
k_MPH_SIZE_2X_MASK) |
3957-
(value & k_HEADER_SIZE_2X_MASK);
3959+
d_mphSize2xAndHeaderSize2x = static_cast<char>(
3960+
(d_mphSize2xAndHeaderSize2x & k_MPH_SIZE_2X_MASK) |
3961+
(value & k_HEADER_SIZE_2X_MASK));
39583962
return *this;
39593963
}
39603964

@@ -3965,9 +3969,9 @@ MessagePropertiesHeader::setMessagePropertyHeaderSize(int value)
39653969
BSLS_ASSERT_SAFE(value >= 0 &&
39663970
value <= ((1 << k_MPH_SIZE_2X_NUM_BITS) - 1));
39673971

3968-
d_mphSize2xAndHeaderSize2x = (d_mphSize2xAndHeaderSize2x &
3969-
k_HEADER_SIZE_2X_MASK) |
3970-
(value << k_MPH_SIZE_2X_START_IDX);
3972+
d_mphSize2xAndHeaderSize2x = static_cast<unsigned char>(
3973+
(d_mphSize2xAndHeaderSize2x & k_HEADER_SIZE_2X_MASK) |
3974+
(value << k_MPH_SIZE_2X_START_IDX));
39713975
return *this;
39723976
}
39733977

@@ -3979,9 +3983,8 @@ MessagePropertiesHeader::setMessagePropertiesAreaWords(int value)
39793983
value <= ((1 << k_MSG_PROPS_AREA_WORDS_NUM_BITS) - 1));
39803984

39813985
d_msgPropsAreaWordsLower = static_cast<unsigned short>(value & 0xFFFF);
3982-
d_msgPropsAreaWordsUpper = (value >>
3983-
k_MSG_PROPS_AREA_WORDS_LOWER_NUM_BITS) &
3984-
0xFF;
3986+
d_msgPropsAreaWordsUpper = static_cast<unsigned char>(
3987+
(value >> k_MSG_PROPS_AREA_WORDS_LOWER_NUM_BITS) & 0xFF);
39853988

39863989
return *this;
39873990
}
@@ -3992,7 +3995,7 @@ MessagePropertiesHeader::setNumProperties(int value)
39923995
// PRECONDITIONS
39933996
BSLS_ASSERT_SAFE(value >= 0 && value <= k_MAX_NUM_PROPERTIES);
39943997

3995-
d_numProperties = value;
3998+
d_numProperties = static_cast<unsigned char>(value);
39963999
return *this;
39974000
}
39984001

@@ -4039,9 +4042,9 @@ inline MessagePropertyHeader& MessagePropertyHeader::setPropertyType(int value)
40394042
// PRECONDITIONS
40404043
BSLS_ASSERT_SAFE(value >= 0 && value <= ((1 << k_PROP_TYPE_NUM_BITS) - 1));
40414044

4042-
d_propTypeAndPropValueLenUpper = (d_propTypeAndPropValueLenUpper &
4043-
k_PROP_VALUE_LEN_UPPER_MASK) |
4044-
(value << k_PROP_TYPE_START_IDX);
4045+
d_propTypeAndPropValueLenUpper = static_cast<unsigned short>(
4046+
(d_propTypeAndPropValueLenUpper & k_PROP_VALUE_LEN_UPPER_MASK) |
4047+
(static_cast<unsigned short>(value) << k_PROP_TYPE_START_IDX));
40454048

40464049
return *this;
40474050
}
@@ -4054,10 +4057,11 @@ MessagePropertyHeader::setPropertyValueLength(int value)
40544057

40554058
d_propValueLenLower = static_cast<unsigned short>(value & 0xFFFF);
40564059

4057-
d_propTypeAndPropValueLenUpper =
4060+
d_propTypeAndPropValueLenUpper = static_cast<unsigned short>(
40584061
(d_propTypeAndPropValueLenUpper & k_PROP_TYPE_MASK) |
4059-
((value >> k_PROP_VALUE_LEN_LOWER_NUM_BITS) &
4060-
k_PROP_VALUE_LEN_UPPER_MASK);
4062+
(static_cast<unsigned short>(value >>
4063+
k_PROP_VALUE_LEN_LOWER_NUM_BITS) &
4064+
k_PROP_VALUE_LEN_UPPER_MASK));
40614065

40624066
return *this;
40634067
}
@@ -4068,7 +4072,8 @@ MessagePropertyHeader::setPropertyNameLength(int value)
40684072
// PRECONDITIONS
40694073
BSLS_ASSERT_SAFE(value >= 0 && value <= k_MAX_PROPERTY_NAME_LENGTH);
40704074

4071-
d_reservedAndPropNameLen = value & k_PROP_NAME_LEN_MASK;
4075+
d_reservedAndPropNameLen = static_cast<unsigned short>(
4076+
value & k_PROP_NAME_LEN_MASK);
40724077

40734078
return *this;
40744079
}
@@ -4127,12 +4132,13 @@ inline SchemaWireId::SchemaWireId()
41274132
// PUBLIC MODIFIERS
41284133
inline void SchemaWireId::set(unsigned value)
41294134
{
4130-
d_value = value;
4135+
// Include precondition check or adjust function signature?
4136+
d_value = static_cast<short unsigned int>(value);
41314137
}
41324138

41334139
inline unsigned SchemaWireId::value() const
41344140
{
4135-
return d_value;
4141+
return static_cast<short unsigned int>(d_value);
41364142
}
41374143

41384144
// ---------------
@@ -4341,9 +4347,9 @@ inline AckHeader& AckHeader::setHeaderWords(int value)
43414347
BSLS_ASSERT_SAFE(value >= 0 &&
43424348
value <= (1 << k_HEADER_WORDS_NUM_BITS) - 1);
43434349

4344-
d_headerWordsAndPerMsgWords = (d_headerWordsAndPerMsgWords &
4345-
k_PER_MSG_WORDS_MASK) |
4346-
(value << k_HEADER_WORDS_START_IDX);
4350+
d_headerWordsAndPerMsgWords = static_cast<unsigned char>(
4351+
(d_headerWordsAndPerMsgWords & k_PER_MSG_WORDS_MASK) |
4352+
(value << k_HEADER_WORDS_START_IDX));
43474353
return *this;
43484354
}
43494355

@@ -4353,9 +4359,9 @@ inline AckHeader& AckHeader::setPerMessageWords(int value)
43534359
BSLS_ASSERT_SAFE(value >= 0 &&
43544360
value <= (1 << k_PER_MSG_WORDS_NUM_BITS) - 1);
43554361

4356-
d_headerWordsAndPerMsgWords = (d_headerWordsAndPerMsgWords &
4357-
k_HEADER_WORDS_MASK) |
4358-
(value & k_PER_MSG_WORDS_MASK);
4362+
d_headerWordsAndPerMsgWords = static_cast<unsigned char>(
4363+
(d_headerWordsAndPerMsgWords & k_HEADER_WORDS_MASK) |
4364+
(value & k_PER_MSG_WORDS_MASK));
43594365
return *this;
43604366
}
43614367

@@ -4647,9 +4653,9 @@ inline ConfirmHeader& ConfirmHeader::setHeaderWords(int value)
46474653
BSLS_ASSERT_SAFE(value >= 0 &&
46484654
value <= (1 << k_HEADER_WORDS_NUM_BITS) - 1);
46494655

4650-
d_headerWordsAndPerMsgWords = (d_headerWordsAndPerMsgWords &
4651-
k_PER_MSG_WORDS_MASK) |
4652-
(value << k_HEADER_WORDS_START_IDX);
4656+
d_headerWordsAndPerMsgWords = static_cast<unsigned char>(
4657+
(d_headerWordsAndPerMsgWords & k_PER_MSG_WORDS_MASK) |
4658+
(value << k_HEADER_WORDS_START_IDX));
46534659
return *this;
46544660
}
46554661

@@ -4659,9 +4665,9 @@ inline ConfirmHeader& ConfirmHeader::setPerMessageWords(int value)
46594665
BSLS_ASSERT_SAFE(value >= 0 &&
46604666
value <= (1 << k_PER_MSG_WORDS_NUM_BITS) - 1);
46614667

4662-
d_headerWordsAndPerMsgWords = (d_headerWordsAndPerMsgWords &
4663-
k_HEADER_WORDS_MASK) |
4664-
(value & k_PER_MSG_WORDS_MASK);
4668+
d_headerWordsAndPerMsgWords = static_cast<unsigned char>(
4669+
(d_headerWordsAndPerMsgWords & k_HEADER_WORDS_MASK) |
4670+
(value & k_PER_MSG_WORDS_MASK));
46654671
return *this;
46664672
}
46674673

@@ -4742,9 +4748,9 @@ inline RejectHeader& RejectHeader::setHeaderWords(int value)
47424748
BSLS_ASSERT_SAFE(value >= 0 &&
47434749
value <= (1 << k_HEADER_WORDS_NUM_BITS) - 1);
47444750

4745-
d_headerWordsAndPerMsgWords = (d_headerWordsAndPerMsgWords &
4746-
k_PER_MSG_WORDS_MASK) |
4747-
(value << k_HEADER_WORDS_START_IDX);
4751+
d_headerWordsAndPerMsgWords = static_cast<unsigned char>(
4752+
(d_headerWordsAndPerMsgWords & k_PER_MSG_WORDS_MASK) |
4753+
(value << k_HEADER_WORDS_START_IDX));
47484754
return *this;
47494755
}
47504756

@@ -4754,9 +4760,9 @@ inline RejectHeader& RejectHeader::setPerMessageWords(int value)
47544760
BSLS_ASSERT_SAFE(value >= 0 &&
47554761
value <= (1 << k_PER_MSG_WORDS_NUM_BITS) - 1);
47564762

4757-
d_headerWordsAndPerMsgWords = (d_headerWordsAndPerMsgWords &
4758-
k_HEADER_WORDS_MASK) |
4759-
(value & k_PER_MSG_WORDS_MASK);
4763+
d_headerWordsAndPerMsgWords = static_cast<unsigned char>(
4764+
(d_headerWordsAndPerMsgWords & k_HEADER_WORDS_MASK) |
4765+
(value & k_PER_MSG_WORDS_MASK));
47604766
return *this;
47614767
}
47624768

@@ -4907,9 +4913,9 @@ inline StorageHeader& StorageHeader::setStorageProtocolVersion(int value)
49074913
// PRECONDITIONS: protect against overflow
49084914
BSLS_ASSERT_SAFE(value >= 0 && value <= (1 << k_SPV_NUM_BITS) - 1);
49094915

4910-
d_reservedAndSpvAndHeaderWords = (d_reservedAndSpvAndHeaderWords &
4911-
k_HEADER_WORDS_MASK) |
4912-
(value << k_SPV_START_IDX);
4916+
d_reservedAndSpvAndHeaderWords = static_cast<unsigned char>(
4917+
(d_reservedAndSpvAndHeaderWords & k_HEADER_WORDS_MASK) |
4918+
(value << k_SPV_START_IDX));
49134919
return *this;
49144920
}
49154921

@@ -4918,9 +4924,9 @@ inline StorageHeader& StorageHeader::setHeaderWords(unsigned int value)
49184924
// PRECONDITIONS: protect against overflow
49194925
BSLS_ASSERT_SAFE(value <= (1 << k_HEADER_WORDS_NUM_BITS) - 1);
49204926

4921-
d_reservedAndSpvAndHeaderWords = (d_reservedAndSpvAndHeaderWords &
4922-
k_SPV_MASK) |
4923-
(value & k_HEADER_WORDS_MASK);
4927+
d_reservedAndSpvAndHeaderWords = static_cast<unsigned char>(
4928+
(d_reservedAndSpvAndHeaderWords & k_SPV_MASK) |
4929+
(value & k_HEADER_WORDS_MASK));
49244930
return *this;
49254931
}
49264932

@@ -5041,25 +5047,25 @@ inline RecoveryHeader& RecoveryHeader::setHeaderWords(int value)
50415047
BSLS_ASSERT_SAFE(value >= 0 &&
50425048
value <= (1 << k_HEADER_WORDS_NUM_BITS) - 1);
50435049

5044-
d_headerWordsAndFileChunkType = (d_headerWordsAndFileChunkType &
5045-
k_FILE_CHUNK_TYPE_MASK) |
5046-
(value << k_HEADER_WORDS_START_IDX);
5050+
d_headerWordsAndFileChunkType = static_cast<unsigned char>(
5051+
(d_headerWordsAndFileChunkType & k_FILE_CHUNK_TYPE_MASK) |
5052+
(value << k_HEADER_WORDS_START_IDX));
50475053

50485054
return *this;
50495055
}
50505056

50515057
inline RecoveryHeader&
50525058
RecoveryHeader::setFileChunkType(RecoveryFileChunkType::Enum value)
50535059
{
5054-
d_headerWordsAndFileChunkType = (d_headerWordsAndFileChunkType &
5055-
k_HEADER_WORDS_MASK) |
5056-
(value & k_FILE_CHUNK_TYPE_MASK);
5060+
d_headerWordsAndFileChunkType = static_cast<unsigned char>(
5061+
(d_headerWordsAndFileChunkType & k_HEADER_WORDS_MASK) |
5062+
(value & k_FILE_CHUNK_TYPE_MASK));
50575063
return *this;
50585064
}
50595065

50605066
inline RecoveryHeader& RecoveryHeader::setPartitionId(unsigned int value)
50615067
{
5062-
d_partitionId = value;
5068+
d_partitionId = static_cast<short unsigned int>(value);
50635069
return *this;
50645070
}
50655071

0 commit comments

Comments
 (0)