spki: add AlgorithmIdentifierRef::to_owned method

[baloo]

No description provided.

[tarcieri]

Perhaps we can define some traits for this, since we can't use std::borrow::ToOwned (since this isn't a reference conversion).

It would be nice to ensure there's always a reciprocal operation ala std::borrow::Borrow.

[baloo]

I'm pretty bad at naming things, but any opinion?

pub trait DerBorrow {
    type Borrowed<'b>
    where
        Self: 'b;

    fn der_borrow<'a>(&'a self) -> Self::Borrowed<'a>;
}

pub trait DerToOwned<'a> {
    type DerOwned: DerBorrow<Borrowed<'a> = Self>
    where
        Self: 'a;

    fn to_der_owned(&self) -> Self::DerOwned;
}

impl<'a> DerToOwned<'a> for AlgorithmIdentifierRef<'a> {
    type DerOwned = AlgorithmIdentifierOwned;

    fn to_der_owned(&self) -> Self::DerOwned {
        AlgorithmIdentifier {
            oid: self.oid,
            parameters: self.parameters.map(|p| p.into()),
        }
    }
}

impl DerBorrow for AlgorithmIdentifierOwned {
    type Borrowed<'a> = AlgorithmIdentifierRef<'a>;

    fn der_borrow<'a>(&'a self) -> AlgorithmIdentifierRef<'a> {
        AlgorithmIdentifier {
            oid: self.oid,
            parameters: self.parameters.as_ref().map(AnyRef::from),
        }
    }
}

Compiler seems happy.

[tarcieri]

That looks okay naming aside. Let me think about that for a bit.

[tarcieri]

Naming wise, for starters, the "borrowed" types are owned *Ref types, so perhaps ToRef instead of ToBorrowed?

[baloo]

pub trait OwnedToRef {
    type Borrowed<'b>
    where
        Self: 'b;

    fn to_ref<'a>(&'a self) -> Self::Borrowed<'a>;
}

pub trait RefToOwned<'a> {
    type Owned: OwnedToRef<Borrowed<'a> = Self>
    where
        Self: 'a;

    fn to_owned(&self) -> Self::Owned;
}

[tarcieri]

Looking better… maybe RefToOwned and OwnedToRef?