Replace "can't" with "cannot" in some logging

client/src/client.rs

@@ -160,7 +160,7 @@ impl Client {
         // Ask the server associated with the default endpoint for its list of endpoints
         let endpoints = match self.get_server_endpoints() {
             Result::Err(status_code) => {
-                error!("Can't get endpoints for server, error - {}", status_code);
+                error!("Cannot get endpoints for server, error - {}", status_code);
                 return Err(status_code);
             }
             Result::Ok(endpoints) => endpoints
@@ -449,7 +449,7 @@ impl Client {
                     Err(StatusCode::BadUnexpectedError)
                 }
             } else {
-                error!("Can't find an endpoint that we call register server on");
+                error!("Cannot find an endpoint that we call register server on");
                 Err(StatusCode::BadUnexpectedError)
             }
         }
@@ -535,7 +535,7 @@ impl Client {
                                   security_mode: MessageSecurityMode) -> Option<EndpointDescription>
     {
         if security_policy == SecurityPolicy::Unknown {
-            panic!("Can't match against unknown security policy");
+            panic!("Cannot match against unknown security policy");
         }
 
         let matching_endpoint = endpoints.iter().find(|e| {

core/src/comms/chunker.rs

@@ -195,7 +195,7 @@ impl Chunker {
                 }
             }
             Err(err) => {
-                debug!("Can't decode message {:?}, err = {:?}", object_id, err);
+                debug!("Cannot decode message {:?}, err = {:?}", object_id, err);
                 Err(StatusCode::BadServiceUnsupported)
             }
         }

core/src/comms/message_chunk_info.rs

@@ -46,7 +46,7 @@ impl ChunkInfo {
         let security_header = if chunk.is_open_secure_channel(&decoding_limits) {
             let result = AsymmetricSecurityHeader::decode(&mut stream, &decoding_limits);
             if result.is_err() {
-                error!("chunk_info() can't decode asymmetric security_header, {}", result.unwrap_err());
+                error!("chunk_info() cannot decode asymmetric security_header, {}", result.unwrap_err());
                 return Err(StatusCode::BadCommunicationError);
             }
             let security_header = result.unwrap();
@@ -67,7 +67,7 @@ impl ChunkInfo {
         } else {
             let result = SymmetricSecurityHeader::decode(&mut stream, &decoding_limits);
             if result.is_err() {
-                error!("chunk_info() can't decode symmetric security_header, {}", result.unwrap_err());
+                error!("chunk_info() cannot decode symmetric security_header, {}", result.unwrap_err());
                 return Err(StatusCode::BadCommunicationError);
             }
             SecurityHeader::Symmetric(result.unwrap())

samples/discovery-client/src/main.rs

@@ -43,7 +43,7 @@ fn main() {
                         // Ask the server associated with the default endpoint for its list of endpoints
                         match client.get_server_endpoints_from_url(discovery_url.as_ref()) {
                             Result::Err(status_code) => {
-                                println!("    ERROR: Can't get endpoints for this server url, error - {}", status_code);
+                                println!("    ERROR: Cannot get endpoints for this server url, error - {}", status_code);
                                 continue;
                             }
                             Result::Ok(endpoints) => {

server/src/comms/tcp_transport.rs

@@ -637,7 +637,7 @@ impl TcpTransport {
                     if let Some(publish_responses) = session.subscriptions.take_publish_responses() {
                         match subscription_tx.unbounded_send(SubscriptionEvent::PublishResponses(publish_responses)) {
                             Err(error) => {
-                                error!("Can't send publish responses, err = {}", error);
+                                error!("Cannot send publish responses, err = {}", error);
                             }
                             Ok(_) => {
                                 trace!("Sent publish responses to session task");

server/src/subscriptions/monitored_item.rs

@@ -255,7 +255,7 @@ impl MonitoredItem {
                 false
             }
         } else {
-            trace!("Can't find item to monitor, node {:?}", self.item_to_monitor.node_id);
+            trace!("Cannot find item to monitor, node {:?}", self.item_to_monitor.node_id);
             false
         }
     }

server/src/subscriptions/subscriptions.rs

@@ -282,11 +282,11 @@ impl Subscriptions {
                             debug!("Removing subscription {} sequence number {} from retransmission queue", subscription_id, sequence_number);
                             StatusCode::Good
                         } else {
-                            error!("Can't find acknowledged notification with sequence number {}", sequence_number);
+                            error!("Cannot find acknowledged notification with sequence number {}", sequence_number);
                             StatusCode::BadSequenceNumberUnknown
                         }
                     } else {
-                        error!("Can't find acknowledged notification subscription id {}", subscription_id);
+                        error!("Cannot find acknowledged notification subscription id {}", subscription_id);
                         StatusCode::BadSubscriptionIdInvalid
                     }
                 })

types/src/variant.rs

@@ -912,15 +912,15 @@ impl Variant {
             Variant::DataValue(_) => Some(DataTypeId::DataValue),
             Variant::Array(ref values) => {
                 if values.is_empty() {
-                    error!("Can't get the data type of an empty array");
+                    error!("Cannot get the data type of an empty array");
                     None
                 } else {
                     values[0].data_type()
                 }
             }
             Variant::MultiDimensionArray(ref mda) => {
                 if mda.values.is_empty() {
-                    error!("Can't get the data type of an empty array");
+                    error!("Cannot get the data type of an empty array");
                     None
                 } else {
                     mda.values[0].data_type()