der, spki: rename to_owned method (#835)

The naming of the `to_owned` method was a bit unfortunate as it
triggered conflicts with the `alloc::borrow::ToOwned` method. When used,
this would make for compiler messages asking things like:

```
error[E0034]: multiple applicable items in scope
   --> certval/src/validator/name_constraints_set.rs:748:34
    |
748 |                         value: a.to_owned(),
    |                                  ^^^^^^^^ multiple `to_owned` found
    |
    = note: candidate #1 is defined in an impl of the trait `RefToOwned` for the type `AnyRef<'a>`
    = note: candidate #2 is defined in an impl of the trait `ToOwned` for the type `T`
help: disambiguate the associated function for candidate #1
    |
748 |                         value: RefToOwned::to_owned(&a),
    |                                ~~~~~~~~~~~~~~~~~~~~~~~~
help: disambiguate the associated function for candidate #2
    |
748 |                         value: ToOwned::to_owned(&a),
    |                                ~~~~~~~~~~~~~~~~~~~~~
```

der/src/asn1/any.rs

@@ -277,7 +277,7 @@ mod allocating {
 
  impl<'a> RefToOwned<'a> for AnyRef<'a> {
  type Owned = Any;
- fn to_owned(&self) -> Self::Owned {
+ fn ref_to_owned(&self) -> Self::Owned {
  Any {
  tag: self.tag(),
  value: BytesOwned::from(self.value),
@@ -287,15 +287,15 @@ mod allocating {
 
  impl OwnedToRef for Any {
  type Borrowed<'a> = AnyRef<'a>;
- fn to_ref(&self) -> Self::Borrowed<'_> {
+ fn owned_to_ref(&self) -> Self::Borrowed<'_> {
  self.into()
  }
  }
 
  impl Any {
  /// Is this value an ASN.1 `NULL` value?
  pub fn is_null(&self) -> bool {
- self.to_ref() == AnyRef::NULL
+ self.owned_to_ref() == AnyRef::NULL
  }
  }
 }

der/src/asn1/bit_string.rs

@@ -379,7 +379,7 @@ mod allocating {
 
  impl<'a> RefToOwned<'a> for BitStringRef<'a> {
  type Owned = BitString;
- fn to_owned(&self) -> Self::Owned {
+ fn ref_to_owned(&self) -> Self::Owned {
  BitString {
  unused_bits: self.unused_bits,
  bit_length: self.bit_length,
@@ -390,7 +390,7 @@ mod allocating {
 
  impl OwnedToRef for BitString {
  type Borrowed<'a> = BitStringRef<'a>;
- fn to_ref(&self) -> Self::Borrowed<'_> {
+ fn owned_to_ref(&self) -> Self::Borrowed<'_> {
  self.into()
  }
  }

der/src/asn1/ia5_string.rs

@@ -150,18 +150,18 @@ mod allocation {
 
  impl<'a> RefToOwned<'a> for Ia5StringRef<'a> {
  type Owned = Ia5String;
- fn to_owned(&self) -> Self::Owned {
+ fn ref_to_owned(&self) -> Self::Owned {
  Ia5String {
- inner: self.inner.to_owned(),
+ inner: self.inner.ref_to_owned(),
  }
  }
  }
 
  impl OwnedToRef for Ia5String {
  type Borrowed<'a> = Ia5StringRef<'a>;
- fn to_ref(&self) -> Self::Borrowed<'_> {
+ fn owned_to_ref(&self) -> Self::Borrowed<'_> {
  Ia5StringRef {
- inner: self.inner.to_ref(),
+ inner: self.inner.owned_to_ref(),
  }
  }
  }

der/src/asn1/integer/bigint.rs

@@ -277,17 +277,17 @@ mod allocating {
 
  impl<'a> RefToOwned<'a> for IntRef<'a> {
  type Owned = Int;
- fn to_owned(&self) -> Self::Owned {
- let inner = self.inner.to_owned();
+ fn ref_to_owned(&self) -> Self::Owned {
+ let inner = self.inner.ref_to_owned();
 
  Int { inner }
  }
  }
 
  impl OwnedToRef for Int {
  type Borrowed<'a> = IntRef<'a>;
- fn to_ref(&self) -> Self::Borrowed<'_> {
- let inner = self.inner.to_ref();
+ fn owned_to_ref(&self) -> Self::Borrowed<'_> {
+ let inner = self.inner.owned_to_ref();
 
  IntRef { inner }
  }
@@ -384,17 +384,17 @@ mod allocating {
 
  impl<'a> RefToOwned<'a> for UintRef<'a> {
  type Owned = Uint;
- fn to_owned(&self) -> Self::Owned {
- let inner = self.inner.to_owned();
+ fn ref_to_owned(&self) -> Self::Owned {
+ let inner = self.inner.ref_to_owned();
 
  Uint { inner }
  }
  }
 
  impl OwnedToRef for Uint {
  type Borrowed<'a> = UintRef<'a>;
- fn to_ref(&self) -> Self::Borrowed<'_> {
- let inner = self.inner.to_ref();
+ fn owned_to_ref(&self) -> Self::Borrowed<'_> {
+ let inner = self.inner.owned_to_ref();
 
  UintRef { inner }
  }

der/src/asn1/printable_string.rs

@@ -221,18 +221,18 @@ mod allocation {
 
  impl<'a> RefToOwned<'a> for PrintableStringRef<'a> {
  type Owned = PrintableString;
- fn to_owned(&self) -> Self::Owned {
+ fn ref_to_owned(&self) -> Self::Owned {
  PrintableString {
- inner: self.inner.to_owned(),
+ inner: self.inner.ref_to_owned(),
  }
  }
  }
 
  impl OwnedToRef for PrintableString {
  type Borrowed<'a> = PrintableStringRef<'a>;
- fn to_ref(&self) -> Self::Borrowed<'_> {
+ fn owned_to_ref(&self) -> Self::Borrowed<'_> {
  PrintableStringRef {
- inner: self.inner.to_ref(),
+ inner: self.inner.owned_to_ref(),
  }
  }
  }

der/src/asn1/teletex_string.rs

@@ -179,18 +179,18 @@ mod allocation {
 
  impl<'a> RefToOwned<'a> for TeletexStringRef<'a> {
  type Owned = TeletexString;
- fn to_owned(&self) -> Self::Owned {
+ fn ref_to_owned(&self) -> Self::Owned {
  TeletexString {
- inner: self.inner.to_owned(),
+ inner: self.inner.ref_to_owned(),
  }
  }
  }
 
  impl OwnedToRef for TeletexString {
  type Borrowed<'a> = TeletexStringRef<'a>;
- fn to_ref(&self) -> Self::Borrowed<'_> {
+ fn owned_to_ref(&self) -> Self::Borrowed<'_> {
  TeletexStringRef {
- inner: self.inner.to_ref(),
+ inner: self.inner.owned_to_ref(),
  }
  }
  }

der/src/bytes_owned.rs

@@ -97,7 +97,7 @@ impl From<StrRef<'_>> for BytesOwned {
 
 impl OwnedToRef for BytesOwned {
  type Borrowed<'a> = BytesRef<'a>;
- fn to_ref(&self) -> Self::Borrowed<'_> {
+ fn owned_to_ref(&self) -> Self::Borrowed<'_> {
  BytesRef {
  length: self.length,
  inner: self.inner.as_ref(),

der/src/bytes_ref.rs

@@ -145,7 +145,7 @@ mod allocating {
 
  impl<'a> RefToOwned<'a> for BytesRef<'a> {
  type Owned = BytesOwned;
- fn to_owned(&self) -> Self::Owned {
+ fn ref_to_owned(&self) -> Self::Owned {
  BytesOwned::from(*self)
  }
  }

der/src/referenced.rs

@@ -8,7 +8,7 @@ pub trait OwnedToRef {
  Self: 'a;
 
  /// Creates a new object referencing back to the self for storage
- fn to_ref(&self) -> Self::Borrowed<'_>;
+ fn owned_to_ref(&self) -> Self::Borrowed<'_>;
 }
 
 /// A trait for cloning a referenced structure and getting owned objects
@@ -21,7 +21,7 @@ pub trait RefToOwned<'a> {
  Self: 'a;
 
  /// Creates a new object taking ownership of the data
- fn to_owned(&self) -> Self::Owned;
+ fn ref_to_owned(&self) -> Self::Owned;
 }
 
 impl<T> OwnedToRef for Option<T>
@@ -30,8 +30,8 @@ where
 {
  type Borrowed<'a> = Option<T::Borrowed<'a>> where T: 'a;
 
- fn to_ref(&self) -> Self::Borrowed<'_> {
- self.as_ref().map(|o| o.to_ref())
+ fn owned_to_ref(&self) -> Self::Borrowed<'_> {
+ self.as_ref().map(|o| o.owned_to_ref())
  }
 }
 
@@ -41,7 +41,7 @@ where
  T::Owned: OwnedToRef,
 {
  type Owned = Option<T::Owned>;
- fn to_owned(&self) -> Self::Owned {
- self.as_ref().map(|o| o.to_owned())
+ fn ref_to_owned(&self) -> Self::Owned {
+ self.as_ref().map(|o| o.ref_to_owned())
  }
 }

der/src/str_owned.rs

@@ -96,7 +96,7 @@ impl From<StrRef<'_>> for StrOwned {
 
 impl OwnedToRef for StrOwned {
  type Borrowed<'a> = StrRef<'a>;
- fn to_ref(&self) -> Self::Borrowed<'_> {
+ fn owned_to_ref(&self) -> Self::Borrowed<'_> {
  StrRef {
  length: self.length,
  inner: self.inner.as_ref(),

der/src/str_ref.rs

@@ -85,7 +85,7 @@ mod allocating {
 
  impl<'a> RefToOwned<'a> for StrRef<'a> {
  type Owned = StrOwned;
- fn to_owned(&self) -> Self::Owned {
+ fn ref_to_owned(&self) -> Self::Owned {
  StrOwned::from(*self)
  }
  }

spki/src/algorithm.rs

@@ -171,20 +171,20 @@ mod allocating {
 
  impl<'a> RefToOwned<'a> for AlgorithmIdentifierRef<'a> {
  type Owned = AlgorithmIdentifierOwned;
- fn to_owned(&self) -> Self::Owned {
+ fn ref_to_owned(&self) -> Self::Owned {
  AlgorithmIdentifier {
  oid: self.oid,
- parameters: self.parameters.to_owned(),
+ parameters: self.parameters.ref_to_owned(),
  }
  }
  }
 
  impl OwnedToRef for AlgorithmIdentifierOwned {
  type Borrowed<'a> = AlgorithmIdentifierRef<'a>;
- fn to_ref(&self) -> Self::Borrowed<'_> {
+ fn owned_to_ref(&self) -> Self::Borrowed<'_> {
  AlgorithmIdentifier {
  oid: self.oid,
- parameters: self.parameters.to_ref(),
+ parameters: self.parameters.owned_to_ref(),
  }
  }
  }

spki/src/spki.rs

@@ -193,20 +193,20 @@ mod allocating {
 
  impl<'a> RefToOwned<'a> for SubjectPublicKeyInfoRef<'a> {
  type Owned = SubjectPublicKeyInfoOwned;
- fn to_owned(&self) -> Self::Owned {
+ fn ref_to_owned(&self) -> Self::Owned {
  SubjectPublicKeyInfo {
- algorithm: self.algorithm.to_owned(),
- subject_public_key: self.subject_public_key.to_owned(),
+ algorithm: self.algorithm.ref_to_owned(),
+ subject_public_key: self.subject_public_key.ref_to_owned(),
  }
  }
  }
 
  impl OwnedToRef for SubjectPublicKeyInfoOwned {
  type Borrowed<'a> = SubjectPublicKeyInfoRef<'a>;
- fn to_ref(&self) -> Self::Borrowed<'_> {
+ fn owned_to_ref(&self) -> Self::Borrowed<'_> {
  SubjectPublicKeyInfo {
- algorithm: self.algorithm.to_ref(),
- subject_public_key: self.subject_public_key.to_ref(),
+ algorithm: self.algorithm.owned_to_ref(),
+ subject_public_key: self.subject_public_key.owned_to_ref(),
  }
  }
  }