CPP-812 - Enable warnings for implicit casts and address problems (#292)

mikefero · web-flow · commit 6165cd92b026 · 2019-10-11T08:40:28.000-04:00
* msvc: Enable warnings for implicit casts and address problems * clang: Enable warnings for implicit casts and address problems * `-Wconversion` for GCC is unsustainable; see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=40752 for more context
diff --git a/cpp-driver/cmake/modules/CppDriver.cmake b/cpp-driver/cmake/modules/CppDriver.cmake
@@ -151,11 +151,18 @@ macro(CassConfigureShared prefix)
   if("${prefix}" STREQUAL "DSE")
     set(STATIC_COMPILE_FLAGS "${STATIC_COMPILE_FLAGS} -DCASS_BUILDING")
   endif()
-  if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR
-     "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+  if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+    set_property(
+        TARGET ${PROJECT_LIB_NAME}
+        APPEND PROPERTY COMPILE_FLAGS "${STATIC_COMPILE_FLAGS} -Wconversion -Wno-sign-conversion -Wno-shorten-64-to-32 -Wno-undefined-var-template -Werror")
+  elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") # To many superfluous warnings generated with GCC when using -Wconversion (see: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=40752)
     set_property(
         TARGET ${PROJECT_LIB_NAME}
         APPEND PROPERTY COMPILE_FLAGS "${STATIC_COMPILE_FLAGS} -Werror")
+  elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+    set_property(
+        TARGET ${PROJECT_LIB_NAME}
+        APPEND PROPERTY COMPILE_FLAGS "${STATIC_COMPILE_FLAGS} /we4800")
   endif()
 endmacro()
 
@@ -181,11 +188,18 @@ macro(CassConfigureStatic prefix)
   if("${prefix}" STREQUAL "DSE")
     set(STATIC_COMPILE_FLAGS "${STATIC_COMPILE_FLAGS} -DCASS_STATIC")
   endif()
-  if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR
-     "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+  if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+    set_property(
+        TARGET ${PROJECT_LIB_NAME_STATIC}
+        APPEND PROPERTY COMPILE_FLAGS "${STATIC_COMPILE_FLAGS} -Wconversion -Wno-sign-conversion -Wno-shorten-64-to-32 -Wno-undefined-var-template -Werror")
+  elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") # To many superfluous warnings generated with GCC when using -Wconversion (see: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=40752)
     set_property(
         TARGET ${PROJECT_LIB_NAME_STATIC}
         APPEND PROPERTY COMPILE_FLAGS "${STATIC_COMPILE_FLAGS} -Werror")
+  elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+    set_property(
+        TARGET ${PROJECT_LIB_NAME_STATIC}
+        APPEND PROPERTY COMPILE_FLAGS "${STATIC_COMPILE_FLAGS} /we4800")
   endif()
 
   # Update the CXX flags to indicate the use of the static library
@@ -874,7 +888,6 @@ macro(CassSetCompilerFlags)
     # TODO(mpenick): Fix these "possible loss of data" warnings
     add_definitions(/wd4244)
     add_definitions(/wd4267)
-    add_definitions(/wd4800) # Performance warning due to automatic compiler casting from int to bool
 
     # Add preprocessor definitions for proper compilation
     add_definitions(-D_CRT_SECURE_NO_WARNINGS)  # Remove warnings for not using safe functions (TODO: Fix codebase to be more secure for Visual Studio)
diff --git a/cpp-driver/src/batch_request.cpp b/cpp-driver/src/batch_request.cpp
@@ -130,7 +130,7 @@ int BatchRequest::encode(ProtocolVersion version, RequestCallback* callback,
     Buffer buf(buf_size);
 
     size_t pos = buf.encode_byte(0, type_);
-    buf.encode_uint16(pos, statements().size());
+    buf.encode_uint16(pos, static_cast<uint16_t>(statements().size()));
 
     bufs->push_back(buf);
     length += buf_size;
@@ -183,7 +183,7 @@ int BatchRequest::encode(ProtocolVersion version, RequestCallback* callback,
     if (version >= CASS_PROTOCOL_VERSION_V5) {
       pos = buf.encode_int32(pos, flags);
     } else {
-      pos = buf.encode_byte(pos, flags);
+      pos = buf.encode_byte(pos, static_cast<uint8_t>(flags));
     }
 
     if (callback->serial_consistency() != 0) {
@@ -195,7 +195,7 @@ int BatchRequest::encode(ProtocolVersion version, RequestCallback* callback,
     }
 
     if (version.supports_set_keyspace() && !keyspace().empty()) {
-      pos = buf.encode_string(pos, keyspace().data(), keyspace().size());
+      pos = buf.encode_string(pos, keyspace().data(), static_cast<uint16_t>(keyspace().size()));
     }
 
     bufs->push_back(buf);
diff --git a/cpp-driver/src/callback.hpp b/cpp-driver/src/callback.hpp
@@ -65,7 +65,7 @@ class Callback {
     return *this;
   }
 
-  operator bool() const { return invoker_; }
+  operator bool() const { return invoker_ != NULL; }
 
   R operator()(const Arg& arg) const { return invoker_->invoke(arg); }
 
diff --git a/cpp-driver/src/cluster_config.cpp b/cpp-driver/src/cluster_config.cpp
@@ -408,7 +408,7 @@ CassError cass_cluster_set_use_hostname_resolution(CassCluster* cluster, cass_bo
 
 CassError cass_cluster_set_use_randomized_contact_points(CassCluster* cluster,
                                                          cass_bool_t enabled) {
-  cluster->config().set_use_randomized_contact_points(enabled);
+  cluster->config().set_use_randomized_contact_points(enabled == cass_true);
   return CASS_OK;
 }
 
diff --git a/cpp-driver/src/data_type.cpp b/cpp-driver/src/data_type.cpp
@@ -72,13 +72,13 @@ CassDataType* cass_data_type_new_from_existing(const CassDataType* data_type) {
 }
 
 CassDataType* cass_data_type_new_tuple(size_t item_count) {
-  DataType* data_type = new CollectionType(CASS_VALUE_TYPE_TUPLE, item_count);
+  DataType* data_type = new CollectionType(CASS_VALUE_TYPE_TUPLE, item_count, false);
   data_type->inc_ref();
   return CassDataType::to(data_type);
 }
 
 CassDataType* cass_data_type_new_udt(size_t field_count) {
-  DataType* data_type = new UserType(field_count);
+  DataType* data_type = new UserType(field_count, false);
   data_type->inc_ref();
   return CassDataType::to(data_type);
 }
diff --git a/cpp-driver/src/data_type.hpp b/cpp-driver/src/data_type.hpp
@@ -192,15 +192,15 @@ class CollectionType : public CompositeType {
 public:
   typedef SharedRefPtr<const CollectionType> ConstPtr;
 
-  CollectionType(CassValueType collection_type, bool is_frozen)
+  explicit CollectionType(CassValueType collection_type, bool is_frozen)
       : CompositeType(collection_type, is_frozen) {}
 
-  CollectionType(CassValueType collection_type, size_t types_count, bool is_frozen)
+  explicit CollectionType(CassValueType collection_type, size_t types_count, bool is_frozen)
       : CompositeType(collection_type, is_frozen) {
     types_.reserve(types_count);
   }
 
-  CollectionType(CassValueType collection_type, const DataType::Vec& types, bool is_frozen)
+  explicit CollectionType(CassValueType collection_type, const DataType::Vec& types, bool is_frozen)
       : CompositeType(collection_type, types, is_frozen) {}
 
   virtual bool equals(const DataType::ConstPtr& data_type) const {
@@ -310,19 +310,20 @@ class UserType : public DataType {
 
   typedef CaseInsensitiveHashTable<Field>::EntryVec FieldVec;
 
-  UserType(bool is_frozen)
+  explicit UserType(bool is_frozen)
       : DataType(CASS_VALUE_TYPE_UDT, is_frozen) {}
 
-  UserType(size_t field_count, bool is_frozen)
+  explicit UserType(size_t field_count, bool is_frozen)
       : DataType(CASS_VALUE_TYPE_UDT, is_frozen)
       , fields_(field_count) {}
 
-  UserType(const String& keyspace, const String& type_name, bool is_frozen)
+  explicit UserType(const String& keyspace, const String& type_name, bool is_frozen)
       : DataType(CASS_VALUE_TYPE_UDT, is_frozen)
       , keyspace_(keyspace)
       , type_name_(type_name) {}
 
-  UserType(const String& keyspace, const String& type_name, const FieldVec& fields, bool is_frozen)
+  explicit UserType(const String& keyspace, const String& type_name, const FieldVec& fields,
+                    bool is_frozen)
       : DataType(CASS_VALUE_TYPE_UDT, is_frozen)
       , keyspace_(keyspace)
       , type_name_(type_name)
diff --git a/cpp-driver/src/dc_aware_policy.cpp b/cpp-driver/src/dc_aware_policy.cpp
@@ -92,7 +92,7 @@ QueryPlan* DCAwarePolicy::new_query_plan(const String& keyspace, RequestHandler*
 
 bool DCAwarePolicy::is_host_up(const Address& address) const {
   ScopedReadLock rl(&available_rwlock_);
-  return available_.count(address);
+  return available_.count(address) > 0;
 }
 
 void DCAwarePolicy::on_host_added(const Host::Ptr& host) {
diff --git a/cpp-driver/src/decoder.cpp b/cpp-driver/src/decoder.cpp
@@ -78,7 +78,7 @@ bool Decoder::decode_inet(CassInet* output) {
 }
 
 bool Decoder::as_inet(const int address_length, CassInet* output) const {
-  output->address_length = address_length;
+  output->address_length = static_cast<uint8_t>(address_length);
   if (output->address_length > CASS_INET_V6_LENGTH) {
     LOG_ERROR("Invalid inet address length of %d bytes", output->address_length);
     return false;
diff --git a/cpp-driver/src/encode.cpp b/cpp-driver/src/encode.cpp
@@ -23,7 +23,7 @@ namespace datastax { namespace internal { namespace core {
 static char* encode_vint(char* output, uint64_t value, size_t value_size) {
   if (value_size == 1) {
     // This is just a one byte value; write it and get out.
-    *output = value;
+    *output = static_cast<char>(value);
     return output + 1;
   }
 
diff --git a/cpp-driver/src/execute_request.cpp b/cpp-driver/src/execute_request.cpp
@@ -40,7 +40,7 @@ int ExecuteRequest::encode(ProtocolVersion version, RequestCallback* callback,
       length += bufs->back().size();
     }
   }
-  length += encode_begin(version, elements().size(), callback, bufs);
+  length += encode_begin(version, static_cast<uint16_t>(elements().size()), callback, bufs);
   int32_t result = encode_values(version, callback, bufs);
   if (result < 0) return result;
   length += result;
diff --git a/cpp-driver/src/md5.cpp b/cpp-driver/src/md5.cpp
@@ -116,33 +116,33 @@ void Md5::final(uint8_t* result) {
   memset(&buffer_[used], 0, free - 8);
 
   lo_ <<= 3;
-  buffer_[56] = lo_;
-  buffer_[57] = lo_ >> 8;
-  buffer_[58] = lo_ >> 16;
-  buffer_[59] = lo_ >> 24;
-  buffer_[60] = hi_;
-  buffer_[61] = hi_ >> 8;
-  buffer_[62] = hi_ >> 16;
-  buffer_[63] = hi_ >> 24;
+  buffer_[56] = static_cast<unsigned char>(lo_);
+  buffer_[57] = static_cast<unsigned char>(lo_ >> 8);
+  buffer_[58] = static_cast<unsigned char>(lo_ >> 16);
+  buffer_[59] = static_cast<unsigned char>(lo_ >> 24);
+  buffer_[60] = static_cast<unsigned char>(hi_);
+  buffer_[61] = static_cast<unsigned char>(hi_ >> 8);
+  buffer_[62] = static_cast<unsigned char>(hi_ >> 16);
+  buffer_[63] = static_cast<unsigned char>(hi_ >> 24);
 
   body(buffer_, 64);
 
-  result[0] = a_;
-  result[1] = a_ >> 8;
-  result[2] = a_ >> 16;
-  result[3] = a_ >> 24;
-  result[4] = b_;
-  result[5] = b_ >> 8;
-  result[6] = b_ >> 16;
-  result[7] = b_ >> 24;
-  result[8] = c_;
-  result[9] = c_ >> 8;
-  result[10] = c_ >> 16;
-  result[11] = c_ >> 24;
-  result[12] = d_;
-  result[13] = d_ >> 8;
-  result[14] = d_ >> 16;
-  result[15] = d_ >> 24;
+  result[0] = static_cast<uint8_t>(a_);
+  result[1] = static_cast<uint8_t>(a_ >> 8);
+  result[2] = static_cast<uint8_t>(a_ >> 16);
+  result[3] = static_cast<uint8_t>(a_ >> 24);
+  result[4] = static_cast<uint8_t>(b_);
+  result[5] = static_cast<uint8_t>(b_ >> 8);
+  result[6] = static_cast<uint8_t>(b_ >> 16);
+  result[7] = static_cast<uint8_t>(b_ >> 24);
+  result[8] = static_cast<uint8_t>(c_);
+  result[9] = static_cast<uint8_t>(c_ >> 8);
+  result[10] = static_cast<uint8_t>(c_ >> 16);
+  result[11] = static_cast<uint8_t>(c_ >> 24);
+  result[12] = static_cast<uint8_t>(d_);
+  result[13] = static_cast<uint8_t>(d_ >> 8);
+  result[14] = static_cast<uint8_t>(d_ >> 16);
+  result[15] = static_cast<uint8_t>(d_ >> 24);
 
   memset(this, 0, sizeof(Md5));
 }
diff --git a/cpp-driver/src/prepare_request.cpp b/cpp-driver/src/prepare_request.cpp
@@ -45,7 +45,7 @@ int PrepareRequest::encode(ProtocolVersion version, RequestCallback* callback,
     size_t pos = buf.encode_int32(0, flags);
 
     if (!keyspace().empty()) {
-      buf.encode_string(pos, keyspace().data(), keyspace().size());
+      buf.encode_string(pos, keyspace().data(), static_cast<uint16_t>(keyspace().size()));
     }
   }
   return length;
diff --git a/cpp-driver/src/prepared.hpp b/cpp-driver/src/prepared.hpp
@@ -69,7 +69,8 @@ class PreparedMetadata {
         , keyspace_(keyspace)
         , result_metadata_id_(sizeof(uint16_t) + result_metadata_id.size())
         , result_(result) {
-      result_metadata_id_.encode_string(0, result_metadata_id.data(), result_metadata_id.size());
+      result_metadata_id_.encode_string(0, result_metadata_id.data(),
+                                        static_cast<uint16_t>(result_metadata_id.size()));
     }
 
     const String& query() const { return query_; }
diff --git a/cpp-driver/src/protocol.hpp b/cpp-driver/src/protocol.hpp
@@ -83,6 +83,13 @@ class ProtocolVersion {
    */
   bool is_valid() const;
 
+  /**
+   * Check to see if the protocol version's value is DSE.
+   *
+   * @return true if DSE, otherwise false;
+   */
+  bool is_dse() const;
+
   /**
    * Check to see if the protocol version is a beta version.
    *
diff --git a/cpp-driver/src/query_request.cpp b/cpp-driver/src/query_request.cpp
@@ -29,10 +29,10 @@ int QueryRequest::encode(ProtocolVersion version, RequestCallback* callback,
   int32_t result;
   int32_t length = encode_query_or_id(bufs);
   if (has_names_for_values()) {
-    length += encode_begin(version, value_names_->size(), callback, bufs);
+    length += encode_begin(version, static_cast<uint16_t>(value_names_->size()), callback, bufs);
     result = encode_values_with_names(version, callback, bufs);
   } else {
-    length += encode_begin(version, elements().size(), callback, bufs);
+    length += encode_begin(version, static_cast<uint16_t>(elements().size()), callback, bufs);
     result = encode_values(version, callback, bufs);
   }
   if (result < 0) return result;
diff --git a/cpp-driver/src/query_request.hpp b/cpp-driver/src/query_request.hpp
@@ -50,7 +50,7 @@ class QueryRequest : public Statement {
     ValueName(const String& name)
         : name(name)
         , buf(sizeof(uint16_t) + name.size()) {
-      buf.encode_string(0, name.data(), name.size());
+      buf.encode_string(0, name.data(), static_cast<uint16_t>(name.size()));
     }
 
     String name;
diff --git a/cpp-driver/src/request.cpp b/cpp-driver/src/request.cpp
@@ -54,7 +54,7 @@ void cass_custom_payload_free(CassCustomPayload* payload) { payload->dec_ref();
 void CustomPayload::set(const char* name, size_t name_length, const uint8_t* value,
                         size_t value_size) {
   Buffer buf(sizeof(uint16_t) + name_length + sizeof(int32_t) + value_size);
-  size_t pos = buf.encode_string(0, name, name_length);
+  size_t pos = buf.encode_string(0, name, static_cast<uint16_t>(name_length));
   buf.encode_bytes(pos, reinterpret_cast<const char*>(value), value_size);
   items_[String(name, name_length)] = buf;
 }
diff --git a/cpp-driver/src/request_callback.cpp b/cpp-driver/src/request_callback.cpp
@@ -86,10 +86,10 @@ int32_t RequestCallback::encode(BufferVec* bufs) {
 
   Buffer buf(header_size);
   size_t pos = 0;
-  pos = buf.encode_byte(pos, version.value());
-  pos = buf.encode_byte(pos, flags);
+  pos = buf.encode_byte(pos, static_cast<uint8_t>(version.value()));
+  pos = buf.encode_byte(pos, static_cast<uint8_t>(flags));
 
-  pos = buf.encode_int16(pos, stream_);
+  pos = buf.encode_int16(pos, static_cast<int16_t>(stream_));
 
   pos = buf.encode_byte(pos, req->opcode());
   buf.encode_int32(pos, length);
diff --git a/cpp-driver/src/serialization.hpp b/cpp-driver/src/serialization.hpp
@@ -66,8 +66,8 @@ inline char* encode_uint16(char* output, uint16_t value) {
 }
 
 inline const char* decode_uint16(const char* input, uint16_t& output) {
-  output = (static_cast<uint16_t>(static_cast<uint8_t>(input[1])) << 0) |
-           (static_cast<uint16_t>(static_cast<uint8_t>(input[0])) << 8);
+  output = static_cast<uint16_t>((static_cast<uint16_t>(static_cast<uint8_t>(input[1])) << 0) |
+                                 (static_cast<uint16_t>(static_cast<uint8_t>(input[0])) << 8));
   return input + sizeof(uint16_t);
 }
 
@@ -78,8 +78,8 @@ inline char* encode_int16(char* output, int16_t value) {
 }
 
 inline const char* decode_int16(const char* input, int16_t& output) {
-  output = (static_cast<int16_t>(static_cast<uint8_t>(input[1])) << 0) |
-           (static_cast<int16_t>(static_cast<uint8_t>(input[0])) << 8);
+  output = static_cast<int16_t>((static_cast<int16_t>(static_cast<uint8_t>(input[1])) << 0) |
+                                (static_cast<int16_t>(static_cast<uint8_t>(input[0])) << 8));
   return input + sizeof(int16_t);
 }
 
diff --git a/cpp-driver/src/socket.cpp b/cpp-driver/src/socket.cpp
@@ -333,7 +333,7 @@ size_t Socket::flush() {
 }
 
 bool Socket::is_closing() const {
-  return uv_is_closing(reinterpret_cast<const uv_handle_t*>(&tcp_));
+  return uv_is_closing(reinterpret_cast<const uv_handle_t*>(&tcp_)) != 0;
 }
 
 void Socket::close() {
diff --git a/cpp-driver/src/statement.cpp b/cpp-driver/src/statement.cpp
diff --git a/cpp-driver/src/statement.hpp b/cpp-driver/src/statement.hpp
diff --git a/cpp-driver/src/third_party/http-parser/http_parser.c b/cpp-driver/src/third_party/http-parser/http_parser.c
diff --git a/cpp-driver/src/third_party/rapidjson/rapidjson/document.h b/cpp-driver/src/third_party/rapidjson/rapidjson/document.h
diff --git a/cpp-driver/src/third_party/rapidjson/rapidjson/encodings.h b/cpp-driver/src/third_party/rapidjson/rapidjson/encodings.h
diff --git a/cpp-driver/src/third_party/rapidjson/rapidjson/reader.h b/cpp-driver/src/third_party/rapidjson/rapidjson/reader.h
diff --git a/cpp-driver/src/uuids.cpp b/cpp-driver/src/uuids.cpp
diff --git a/src/protocol.cpp b/src/protocol.cpp

Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ class Callback {`
`65`	`65`	`return *this;`
`66`	`66`	`}`
`67`	`67`
`68`		`- operator bool() const { return invoker_; }`
	`68`	`+ operator bool() const { return invoker_ != NULL; }`
`69`	`69`
`70`	`70`	`R operator()(const Arg& arg) const { return invoker_->invoke(arg); }`
`71`	`71`
Original file line number	Diff line number	Diff line change
`@@ -408,7 +408,7 @@ CassError cass_cluster_set_use_hostname_resolution(CassCluster* cluster, cass_bo`
`408`	`408`
`409`	`409`	`CassError cass_cluster_set_use_randomized_contact_points(CassCluster* cluster,`
`410`	`410`	`cass_bool_t enabled) {`
`411`		`- cluster->config().set_use_randomized_contact_points(enabled);`
	`411`	`+ cluster->config().set_use_randomized_contact_points(enabled == cass_true);`
`412`	`412`	`return CASS_OK;`
`413`	`413`	`}`
`414`	`414`
Original file line number	Diff line number	Diff line change
`@@ -72,13 +72,13 @@ CassDataType* cass_data_type_new_from_existing(const CassDataType* data_type) {`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`CassDataType* cass_data_type_new_tuple(size_t item_count) {`
`75`		`- DataType* data_type = new CollectionType(CASS_VALUE_TYPE_TUPLE, item_count);`
	`75`	`+ DataType* data_type = new CollectionType(CASS_VALUE_TYPE_TUPLE, item_count, false);`
`76`	`76`	`data_type->inc_ref();`
`77`	`77`	`return CassDataType::to(data_type);`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`CassDataType* cass_data_type_new_udt(size_t field_count) {`
`81`		`- DataType* data_type = new UserType(field_count);`
	`81`	`+ DataType* data_type = new UserType(field_count, false);`
`82`	`82`	`data_type->inc_ref();`
`83`	`83`	`return CassDataType::to(data_type);`
`84`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ QueryPlan* DCAwarePolicy::new_query_plan(const String& keyspace, RequestHandler*`
`92`	`92`
`93`	`93`	`bool DCAwarePolicy::is_host_up(const Address& address) const {`
`94`	`94`	`ScopedReadLock rl(&available_rwlock_);`
`95`		`- return available_.count(address);`
	`95`	`+ return available_.count(address) > 0;`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`void DCAwarePolicy::on_host_added(const Host::Ptr& host) {`
Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ bool Decoder::decode_inet(CassInet* output) {`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`bool Decoder::as_inet(const int address_length, CassInet* output) const {`
`81`		`- output->address_length = address_length;`
	`81`	`+ output->address_length = static_cast<uint8_t>(address_length);`
`82`	`82`	`if (output->address_length > CASS_INET_V6_LENGTH) {`
`83`	`83`	`LOG_ERROR("Invalid inet address length of %d bytes", output->address_length);`
`84`	`84`	`return false;`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ namespace datastax { namespace internal { namespace core {`
`23`	`23`	`static char* encode_vint(char* output, uint64_t value, size_t value_size) {`
`24`	`24`	`if (value_size == 1) {`
`25`	`25`	`// This is just a one byte value; write it and get out.`
`26`		`- *output = value;`
	`26`	`+ *output = static_cast<char>(value);`
`27`	`27`	`return output + 1;`
`28`	`28`	`}`
`29`	`29`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ int ExecuteRequest::encode(ProtocolVersion version, RequestCallback* callback,`
`40`	`40`	`length += bufs->back().size();`
`41`	`41`	`}`
`42`	`42`	`}`
`43`		`- length += encode_begin(version, elements().size(), callback, bufs);`
	`43`	`+ length += encode_begin(version, static_cast<uint16_t>(elements().size()), callback, bufs);`
`44`	`44`	`int32_t result = encode_values(version, callback, bufs);`
`45`	`45`	`if (result < 0) return result;`
`46`	`46`	`length += result;`