Change various functions to avoid the extra overhead using an intermi…

…diate CString object

Signed-off-by: Neil Jensen <neilgithub@jensenet.com>

CHANGELOG.md

@@ -10,6 +10,8 @@ version number is tracked in the file `VERSION`.
 ### Added
 
 ### Changed
+- Change various functions to avoid the extra overhead using an intermidiate
+  CString object.
 
 ### Fixed
 

src/cassandra/batch.rs

@@ -14,13 +14,13 @@ use crate::cassandra_sys::cass_batch_set_serial_consistency;
 use crate::cassandra_sys::cass_batch_set_timestamp;
 use crate::cassandra_sys::cass_custom_payload_free;
 use crate::cassandra_sys::cass_custom_payload_new;
-use crate::cassandra_sys::cass_custom_payload_set;
+use crate::cassandra_sys::cass_custom_payload_set_n;
 use crate::cassandra_sys::CassBatch as _Batch;
 use crate::cassandra_sys::CassBatchType_;
 use crate::cassandra_sys::CassConsistency;
 use crate::cassandra_sys::CassCustomPayload as _CassCustomPayload;
-use std::ffi::CString;
 use std::ffi::NulError;
+use std::os::raw::c_char;
 
 /// A group of statements that are executed as a single batch.
 /// <b>Note:</b> Batches are not supported by the binary protocol version 1.
@@ -69,10 +69,11 @@ impl CustomPayload {
     /// Sets an item to the custom payload.
     pub fn set(&self, name: String, value: &[u8]) -> Result<()> {
         unsafe {
-            let name_cstr = CString::new(name)?;
-            Ok(cass_custom_payload_set(
+            let name_ptr = name.as_ptr() as *const c_char;
+            Ok(cass_custom_payload_set_n(
                 self.0,
-                name_cstr.as_ptr(),
+                name_ptr,
+                name.len(),
                 value.as_ptr(),
                 value.len(),
             ))

src/cassandra/cluster.rs

@@ -11,14 +11,14 @@ use crate::cassandra_sys::cass_cluster_new;
 use crate::cassandra_sys::cass_cluster_set_connect_timeout;
 use crate::cassandra_sys::cass_cluster_set_connection_heartbeat_interval;
 use crate::cassandra_sys::cass_cluster_set_connection_idle_timeout;
-use crate::cassandra_sys::cass_cluster_set_contact_points;
+use crate::cassandra_sys::cass_cluster_set_contact_points_n;
 use crate::cassandra_sys::cass_cluster_set_core_connections_per_host;
-use crate::cassandra_sys::cass_cluster_set_credentials;
+use crate::cassandra_sys::cass_cluster_set_credentials_n;
 use crate::cassandra_sys::cass_cluster_set_latency_aware_routing;
 use crate::cassandra_sys::cass_cluster_set_latency_aware_routing_settings;
-use crate::cassandra_sys::cass_cluster_set_load_balance_dc_aware;
+use crate::cassandra_sys::cass_cluster_set_load_balance_dc_aware_n;
 use crate::cassandra_sys::cass_cluster_set_load_balance_round_robin;
-use crate::cassandra_sys::cass_cluster_set_local_address;
+use crate::cassandra_sys::cass_cluster_set_local_address_n;
 use crate::cassandra_sys::cass_cluster_set_max_concurrent_creation;
 use crate::cassandra_sys::cass_cluster_set_max_concurrent_requests_threshold;
 use crate::cassandra_sys::cass_cluster_set_max_connections_per_host;
@@ -50,12 +50,13 @@ use crate::cassandra_sys::cass_true;
 use crate::cassandra_sys::CassCluster as _Cluster;
 
 use std::ffi::NulError;
-use std::ffi::{CStr, CString};
+use std::ffi::CStr;
 use std::fmt;
 use std::fmt::Display;
 use std::iter::Map;
 use std::net::AddrParseError;
 use std::net::Ipv4Addr;
+use std::os::raw::c_char;
 use std::result;
 use std::str::FromStr;
 use time::Duration;
@@ -120,8 +121,8 @@ impl Cluster {
     ///
     pub fn set_contact_points(&mut self, contact_points: &str) -> Result<&mut Self> {
         unsafe {
-            let s = CString::new(contact_points.clone())?;
-            let err = cass_cluster_set_contact_points(self.0, s.as_ptr());
+            let cp_ptr = contact_points.as_ptr() as *const c_char;
+            let err = cass_cluster_set_contact_points_n(self.0, cp_ptr, contact_points.len());
             err.to_result(self)
         }
     }
@@ -132,8 +133,8 @@ impl Cluster {
     /// Only numeric addresses are supported.
     pub fn set_local_address(&mut self, name: &str) -> Result<&mut Self> {
         unsafe {
-            let s = CString::new(name.clone())?;
-            let err = cass_cluster_set_local_address(self.0, s.as_ptr());
+            let name_ptr = name.as_ptr() as *const c_char;
+            let err = cass_cluster_set_local_address_n(self.0, name_ptr, name.len());
             err.to_result(self)
         }
     }
@@ -358,9 +359,15 @@ impl Cluster {
     /// Sets credentials for plain text authentication.
     pub fn set_credentials(&mut self, username: &str, password: &str) -> Result<&mut Self> {
         unsafe {
-            let username_cstr = CString::new(username)?;
-            let password_cstr = CString::new(password)?;
-            cass_cluster_set_credentials(self.0, username_cstr.as_ptr(), password_cstr.as_ptr());
+            let username_ptr = username.as_ptr() as *const c_char;
+            let password_ptr = password.as_ptr() as *const c_char;
+            cass_cluster_set_credentials_n(
+                self.0,
+                username_ptr,
+                username.len(),
+                password_ptr,
+                password.len(),
+            );
         }
         Ok(self)
     }
@@ -394,10 +401,11 @@ impl Cluster {
     ) -> Result<&mut Self> {
         unsafe {
             {
-                let local_dc = CString::new(local_dc)?;
-                cass_cluster_set_load_balance_dc_aware(
+                let local_dc_ptr = local_dc.as_ptr() as *const c_char;
+                cass_cluster_set_load_balance_dc_aware_n(
                     self.0,
-                    local_dc.as_ptr(),
+                    local_dc_ptr,
+                    local_dc.len(),
                     used_hosts_per_remote_dc,
                     if allow_remote_dcs_for_local_cl {
                         cass_true

src/cassandra/collection.rs

@@ -18,7 +18,7 @@ use crate::cassandra_sys::cass_collection_append_int16;
 use crate::cassandra_sys::cass_collection_append_int32;
 use crate::cassandra_sys::cass_collection_append_int64;
 use crate::cassandra_sys::cass_collection_append_int8;
-use crate::cassandra_sys::cass_collection_append_string;
+use crate::cassandra_sys::cass_collection_append_string_n;
 use crate::cassandra_sys::cass_collection_append_tuple;
 use crate::cassandra_sys::cass_collection_append_uint32;
 use crate::cassandra_sys::cass_collection_append_user_type;
@@ -34,7 +34,7 @@ use crate::cassandra_sys::CASS_COLLECTION_TYPE_LIST;
 use crate::cassandra_sys::CASS_COLLECTION_TYPE_MAP;
 use crate::cassandra_sys::CASS_COLLECTION_TYPE_SET;
 
-use std::ffi::CString;
+use std::os::raw::c_char;
 
 // #[repr(C)]
 // #[derive(Debug,Copy,Clone)]
@@ -230,8 +230,8 @@ impl CassCollection for List {
     /// Appends an "ascii", "text" or "varchar" to the collection.
     fn append_string(&mut self, value: &str) -> Result<&mut Self> {
         unsafe {
-            let cstr = CString::new(value)?;
-            let result = cass_collection_append_string(self.inner(), cstr.as_ptr());
+            let value_ptr = value.as_ptr() as *const c_char;
+            let result = cass_collection_append_string_n(self.inner(), value_ptr, value.len());
             result.to_result(self)
         }
     }
@@ -366,8 +366,8 @@ impl CassCollection for Set {
     /// Appends an "ascii", "text" or "varchar" to the collection.
     fn append_string(&mut self, value: &str) -> Result<&mut Self> {
         unsafe {
-            let cstr = CString::new(value)?;
-            let result = cass_collection_append_string(self.inner(), cstr.as_ptr());
+            let value_ptr = value.as_ptr() as *const c_char;
+            let result = cass_collection_append_string_n(self.inner(), value_ptr, value.len());
             result.to_result(self)
         }
     }
@@ -498,8 +498,8 @@ impl CassCollection for Map {
     /// Appends an "ascii", "text" or "varchar" to the collection.
     fn append_string(&mut self, value: &str) -> Result<&mut Self> {
         unsafe {
-            let cstr = CString::new(value)?;
-            let result = cass_collection_append_string(self.inner(), cstr.as_ptr());
+            let value_ptr = value.as_ptr() as *const c_char;
+            let result = cass_collection_append_string_n(self.inner(), value_ptr, value.len());
             result.to_result(self)
         }
     }

src/cassandra/data_type.rs

@@ -5,28 +5,29 @@ use crate::cassandra::value::ValueType;
 
 use crate::cassandra_sys::cass_data_sub_type_count;
 use crate::cassandra_sys::cass_data_type_add_sub_type;
-use crate::cassandra_sys::cass_data_type_add_sub_type_by_name;
+use crate::cassandra_sys::cass_data_type_add_sub_type_by_name_n;
 use crate::cassandra_sys::cass_data_type_add_sub_value_type;
-use crate::cassandra_sys::cass_data_type_add_sub_value_type_by_name;
+use crate::cassandra_sys::cass_data_type_add_sub_value_type_by_name_n;
 use crate::cassandra_sys::cass_data_type_class_name;
 use crate::cassandra_sys::cass_data_type_free;
 use crate::cassandra_sys::cass_data_type_keyspace;
 use crate::cassandra_sys::cass_data_type_new;
 use crate::cassandra_sys::cass_data_type_new_from_existing;
 use crate::cassandra_sys::cass_data_type_new_tuple;
 use crate::cassandra_sys::cass_data_type_new_udt;
-use crate::cassandra_sys::cass_data_type_set_class_name;
-use crate::cassandra_sys::cass_data_type_set_keyspace;
-use crate::cassandra_sys::cass_data_type_set_type_name;
+use crate::cassandra_sys::cass_data_type_set_class_name_n;
+use crate::cassandra_sys::cass_data_type_set_keyspace_n;
+use crate::cassandra_sys::cass_data_type_set_type_name_n;
 use crate::cassandra_sys::cass_data_type_sub_data_type;
-use crate::cassandra_sys::cass_data_type_sub_data_type_by_name;
+use crate::cassandra_sys::cass_data_type_sub_data_type_by_name_n;
 use crate::cassandra_sys::cass_data_type_sub_type_name;
 use crate::cassandra_sys::cass_data_type_type;
 use crate::cassandra_sys::cass_data_type_type_name;
 use crate::cassandra_sys::cass_user_type_new_from_data_type;
 use crate::cassandra_sys::CassDataType as _CassDataType;
 
 use std::ffi::CString;
+use std::os::raw::c_char;
 
 /// Any cassandra datatype
 #[derive(Debug)]
@@ -126,8 +127,10 @@ impl DataType {
         S: Into<String>,
     {
         unsafe {
-            let type_name_cstr = CString::new(type_name.into())?;
-            cass_data_type_set_type_name(data_type.0, type_name_cstr.as_ptr()).to_result(())
+            let type_name_str = type_name.into();
+            let type_name_ptr = type_name_str.as_ptr() as *const c_char;
+            cass_data_type_set_type_name_n(data_type.0, type_name_ptr, type_name_str.len())
+                .to_result(())
         }
     }
 
@@ -157,8 +160,10 @@ impl DataType {
         S: Into<String>,
     {
         unsafe {
-            let keyspace_cstr = CString::new(keyspace.into())?;
-            cass_data_type_set_keyspace(data_type.0, keyspace_cstr.as_ptr()).to_result(())
+            let keyspace_str = keyspace.into();
+            let keyspace_ptr = keyspace_str.as_ptr() as *const c_char;
+            cass_data_type_set_keyspace_n(data_type.0, keyspace_ptr, keyspace_str.len())
+                .to_result(())
         }
     }
 
@@ -188,8 +193,10 @@ impl DataType {
         S: Into<String>,
     {
         unsafe {
-            let class_name_cstr = CString::new(class_name.into())?;
-            cass_data_type_set_class_name(self.0, class_name_cstr.as_ptr()).to_result(())
+            let class_name_str = class_name.into();
+            let class_name_ptr = class_name_str.as_ptr() as *const c_char;
+            cass_data_type_set_class_name_n(self.0, class_name_ptr, class_name_str.len())
+                .to_result(())
         }
     }
 
@@ -218,11 +225,13 @@ impl DataType {
         S: Into<String>,
     {
         unsafe {
-            let name_cstr = CString::new(name.into()).expect("must be utf8");
+            let name_str = name.into();
+            let name_ptr = name_str.as_ptr() as *const c_char;
             // TODO: can return NULL
-            ConstDataType::build(cass_data_type_sub_data_type_by_name(
+            ConstDataType::build(cass_data_type_sub_data_type_by_name_n(
                 data_type.0,
-                name_cstr.as_ptr(),
+                name_ptr,
+                name_str.len(),
             ))
         }
     }
@@ -261,13 +270,10 @@ impl DataType {
         S: Into<String>,
     {
         unsafe {
-            let sub_data_type_cstr = CString::new(name.into())?;
-            cass_data_type_add_sub_type_by_name(
-                self.0,
-                sub_data_type_cstr.as_ptr(),
-                sub_data_type.0,
-            )
-            .to_result(())
+            let name_str = name.into();
+            let name_ptr = name_str.as_ptr() as *const c_char;
+            cass_data_type_add_sub_type_by_name_n(self.0, name_ptr, name_str.len(), sub_data_type.0)
+                .to_result(())
         }
     }
 
@@ -284,14 +290,20 @@ impl DataType {
     /// Adds a sub-data type to a tuple or collection using a value type.
     ///
     /// <b>Note:</b> Only valid for tuple and collection data types.
-    pub fn add_sub_value_type_by_name<S>(&self, name: &str, typ: ValueType) -> Result<()>
+    pub fn add_sub_value_type_by_name<S>(&self, name: S, typ: ValueType) -> Result<()>
     where
         S: Into<String>,
     {
         unsafe {
-            let name_cstr = CString::new(name)?;
-            cass_data_type_add_sub_value_type_by_name(self.0, name_cstr.as_ptr(), typ.inner())
-                .to_result(())
+            let name_str = name.into();
+            let name_ptr = name_str.as_ptr() as *const c_char;
+            cass_data_type_add_sub_value_type_by_name_n(
+                self.0,
+                name_ptr,
+                name_str.len(),
+                typ.inner(),
+            )
+            .to_result(())
         }
     }
 

src/cassandra/inet.rs

@@ -1,17 +1,17 @@
 use crate::cassandra::error::*;
 use crate::cassandra::util::Protected;
-use crate::cassandra_sys::cass_inet_from_string;
+use crate::cassandra_sys::cass_inet_from_string_n;
 use crate::cassandra_sys::cass_inet_init_v4;
 use crate::cassandra_sys::cass_inet_init_v6;
 use crate::cassandra_sys::cass_inet_string;
 use crate::cassandra_sys::CassInet as _Inet;
 use std::default::Default;
 use std::ffi::CStr;
-use std::ffi::CString;
 use std::fmt;
 use std::fmt::{Debug, Formatter};
 use std::mem;
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+use std::os::raw::c_char;
 use std::str::FromStr;
 use std::string::ToString;
 
@@ -87,8 +87,8 @@ impl FromStr for Inet {
         unsafe {
             let mut inet = mem::zeroed();
 
-            let str = CString::new(s)?;
-            cass_inet_from_string(str.as_ptr(), &mut inet)
+            let s_ptr = s.as_ptr() as *const c_char;
+            cass_inet_from_string_n(s_ptr, s.len(), &mut inet)
                 .to_result(())
                 .and_then(|_| Ok(Inet(inet)))
         }

src/cassandra/prepared.rs

@@ -6,10 +6,10 @@ use crate::cassandra::util::Protected;
 use crate::cassandra_sys::cass_prepared_bind;
 use crate::cassandra_sys::cass_prepared_free;
 use crate::cassandra_sys::cass_prepared_parameter_data_type;
-use crate::cassandra_sys::cass_prepared_parameter_data_type_by_name;
+use crate::cassandra_sys::cass_prepared_parameter_data_type_by_name_n;
 use crate::cassandra_sys::cass_prepared_parameter_name;
 use crate::cassandra_sys::CassPrepared as _PreparedStatement;
-use std::ffi::CString;
+use std::os::raw::c_char;
 use std::{mem, slice, str};
 
 /// A statement that has been prepared against at least one Cassandra node.
@@ -78,10 +78,11 @@ impl PreparedStatement {
     /// this reference as it is bound to the lifetime of the prepared.
     pub fn parameter_data_type_by_name(&self, name: &str) -> ConstDataType {
         unsafe {
-            let name_cstr = CString::new(name).expect("must be utf8");
-            ConstDataType::build(cass_prepared_parameter_data_type_by_name(
+            let name_ptr = name.as_ptr() as *const c_char;
+            ConstDataType::build(cass_prepared_parameter_data_type_by_name_n(
                 self.0,
-                name_cstr.as_ptr(),
+                name_ptr,
+                name.len(),
             ))
         }
     }