errors: replace From<&> conversions with a trait

Partially fixes #177.

Author: muzarski

scylla-rust-wrapper/src/cass_error.rs

@@ -4,20 +4,23 @@ use scylla::transport::errors::*;
 pub(crate) use crate::cass_error_types::{CassError, CassErrorSource};
 use crate::query_error::CassErrorResult;
 
-// TODO: From<ref> is bad practice. Will be replaced in the next commit.
-impl From<&CassErrorResult> for CassError {
-    fn from(error: &CassErrorResult) -> Self {
-        match error {
-            CassErrorResult::Query(query_error) => CassError::from(query_error),
+pub trait ToCassError {
+    fn to_cass_error(&self) -> CassError;
+}
+
+impl ToCassError for CassErrorResult {
+    fn to_cass_error(&self) -> CassError {
+        match self {
+            CassErrorResult::Query(query_error) => query_error.to_cass_error(),
         }
     }
 }
 
-impl From<&QueryError> for CassError {
-    fn from(error: &QueryError) -> Self {
-        match error {
-            QueryError::DbError(db_error, _string) => CassError::from(db_error),
-            QueryError::BadQuery(bad_query) => CassError::from(bad_query),
+impl ToCassError for QueryError {
+    fn to_cass_error(&self) -> CassError {
+        match self {
+            QueryError::DbError(db_error, _string) => db_error.to_cass_error(),
+            QueryError::BadQuery(bad_query) => bad_query.to_cass_error(),
             QueryError::ProtocolError(_str) => CassError::CASS_ERROR_SERVER_PROTOCOL_ERROR,
             QueryError::TimeoutError => CassError::CASS_ERROR_LIB_REQUEST_TIMED_OUT, // This may be either read or write timeout error
             QueryError::UnableToAllocStreamId => CassError::CASS_ERROR_LIB_NO_STREAMS,
@@ -42,9 +45,9 @@ impl From<&QueryError> for CassError {
     }
 }
 
-impl From<&DbError> for CassError {
-    fn from(error: &DbError) -> Self {
-        match error {
+impl ToCassError for DbError {
+    fn to_cass_error(&self) -> CassError {
+        match self {
             DbError::ServerError => CassError::CASS_ERROR_SERVER_SERVER_ERROR,
             DbError::ProtocolError => CassError::CASS_ERROR_SERVER_PROTOCOL_ERROR,
             DbError::AuthenticationError => CassError::CASS_ERROR_SERVER_BAD_CREDENTIALS,
@@ -72,9 +75,9 @@ impl From<&DbError> for CassError {
     }
 }
 
-impl From<&BadQuery> for CassError {
-    fn from(error: &BadQuery) -> Self {
-        match error {
+impl ToCassError for BadQuery {
+    fn to_cass_error(&self) -> CassError {
+        match self {
             BadQuery::SerializeValuesError(_serialize_values_error) => {
                 CassError::CASS_ERROR_LAST_ENTRY
             }
@@ -91,9 +94,9 @@ impl From<&BadQuery> for CassError {
     }
 }
 
-impl From<&NewSessionError> for CassError {
-    fn from(error: &NewSessionError) -> Self {
-        match error {
+impl ToCassError for NewSessionError {
+    fn to_cass_error(&self) -> CassError {
+        match self {
             NewSessionError::FailedToResolveAnyHostname(_hostnames) => {
                 CassError::CASS_ERROR_LIB_NO_HOSTS_AVAILABLE
             }
@@ -127,9 +130,9 @@ impl From<&NewSessionError> for CassError {
     }
 }
 
-impl From<&BadKeyspaceName> for CassError {
-    fn from(error: &BadKeyspaceName) -> Self {
-        match error {
+impl ToCassError for BadKeyspaceName {
+    fn to_cass_error(&self) -> CassError {
+        match self {
             BadKeyspaceName::Empty => CassError::CASS_ERROR_LAST_ENTRY,
             BadKeyspaceName::TooLong(_string, _usize) => CassError::CASS_ERROR_LAST_ENTRY,
             BadKeyspaceName::IllegalCharacter(_string, _char) => CassError::CASS_ERROR_LAST_ENTRY,

scylla-rust-wrapper/src/future.rs

@@ -1,6 +1,7 @@
 use crate::argconv::*;
 use crate::cass_error::CassError;
 use crate::cass_error::CassErrorMessage;
+use crate::cass_error::ToCassError;
 use crate::prepared::CassPrepared;
 use crate::query_error::CassErrorResult;
 use crate::query_result::CassResult;
@@ -320,7 +321,7 @@ pub unsafe extern "C" fn cass_future_ready(future_raw: *const CassFuture) -> cas
 #[no_mangle]
 pub unsafe extern "C" fn cass_future_error_code(future_raw: *const CassFuture) -> CassError {
     ptr_to_ref(future_raw).with_waited_result(|r: &mut CassFutureResult| match r {
-        Ok(CassResultValue::QueryError(err)) => CassError::from(err.as_ref()),
+        Ok(CassResultValue::QueryError(err)) => err.to_cass_error(),
         Err((err, _)) => *err,
         _ => CassError::CASS_OK,
     })

scylla-rust-wrapper/src/query_error.rs

@@ -55,7 +55,7 @@ pub unsafe extern "C" fn cass_error_result_free(error_result: *const CassErrorRe
 #[no_mangle]
 pub unsafe extern "C" fn cass_error_result_code(error_result: *const CassErrorResult) -> CassError {
     let error_result: &CassErrorResult = ptr_to_ref(error_result);
-    CassError::from(error_result)
+    error_result.to_cass_error()
 }
 
 #[no_mangle]

scylla-rust-wrapper/src/session.rs

@@ -128,7 +128,7 @@ impl CassSessionInner {
         let session = session_builder
             .build()
             .await
-            .map_err(|err| (CassError::from(&err), err.msg()))?;
+            .map_err(|err| (err.to_cass_error(), err.msg()))?;
 
         *session_guard = Some(CassSessionInner {
             session,
@@ -538,7 +538,7 @@ pub unsafe extern "C" fn cass_session_prepare_from_existing(
         let prepared = session
             .prepare(query.query.clone())
             .await
-            .map_err(|err| (CassError::from(&err), err.msg()))?;
+            .map_err(|err| (err.to_cass_error(), err.msg()))?;
 
         Ok(CassResultValue::Prepared(Arc::new(
             CassPrepared::new_from_prepared_statement(prepared),
@@ -582,7 +582,7 @@ pub unsafe extern "C" fn cass_session_prepare_n(
         let mut prepared = session
             .prepare(query)
             .await
-            .map_err(|err| (CassError::from(&err), err.msg()))?;
+            .map_err(|err| (err.to_cass_error(), err.msg()))?;
 
         // Set Cpp Driver default configuration for queries:
         prepared.set_consistency(Consistency::One);