Make Codecs composable

Cargo.toml

@@ -29,8 +29,8 @@ serde_bytes = { version = "0.11.5", default-features = false, optional = true }
 
 [dev-dependencies]
 serde_derive = "1.0.197"
-serde_ipld_dagcbor = "0.6.0"
-serde_ipld_dagjson = "0.2.0"
+serde_ipld_dagcbor = { version = "*", git = "https://github.com/expede/serde_ipld_dagcbor", branch = "from_u64" }
+serde_ipld_dagjson = { version = "*", git = "https://github.com/expede/serde_ipld_dagjson", branch = "update-codec" }
 serde_json = "1.0.79"
 serde_test = "1.0.132"
 

README.md

@@ -21,7 +21,7 @@ Here's a full example of a function that can encode data with both [serde_ipld_d
 ```rust
 use std::str;
 
-use ipld_core::codec::Codec;
+use ipld_core::codec::{Codec, Links};
 use serde::{Deserialize, Serialize};
 use serde_ipld_dagcbor::codec::DagCborCodec;
 use serde_ipld_dagjson::codec::DagJsonCodec;
@@ -32,11 +32,9 @@ struct Tree {
     age: u8,
 }
 
-fn encode_generic<C, T>(value: &T) -> Result<Vec<u8>, C::Error>
-where
-    C: Codec<T>,
+fn encode_generic<C: Codec<T>, T>(codec: C, value: &T) -> Result<Vec<u8>, C::Error>
 {
-    C::encode_to_vec(value)
+    codec.encode_to_vec(value)
 }
 
 fn main() {
@@ -45,7 +43,7 @@ fn main() {
         age: 91,
     };
 
-    let cbor_encoded = encode_generic::<DagCborCodec, _>(&tree);
+    let cbor_encoded = encode_generic::<DagCborCodec, Tree>(DagCborCodec, &tree);
     #[allow(clippy::format_collect)]
     let cbor_hex = cbor_encoded
         .unwrap()
@@ -54,7 +52,7 @@ fn main() {
         .collect::<String>();
     // CBOR encoded: https://cbor.nemo157.com/#value=a2666865696768740c63616765185b
     println!("CBOR encoded: https://cbor.nemo157.com/#value={}", cbor_hex);
-    let json_encoded = encode_generic::<DagJsonCodec, _>(&tree).unwrap();
+    let json_encoded = encode_generic(DagJsonCodec, &tree).unwrap();
     // JSON encoded: {"height":12,"age":91}
     println!("JSON encoded: {}", str::from_utf8(&json_encoded).unwrap());
 }
@@ -65,17 +63,17 @@ fn main() {
 If you are only interested in the links (CIDs) of an encoded IPLD object, then you can extract them them directly with [`Codec::links()`]:
 
 ```rust
-use ipld_core::{codec::{Codec, Links}, ipld, cid::Cid};
+use ipld_core::{codec::{Codec, Links}, ipld, ipld::Ipld, cid::Cid};
 use serde_ipld_dagjson::codec::DagJsonCodec;
 
 fn main() {
     let cid = Cid::try_from("bafkreibme22gw2h7y2h7tg2fhqotaqjucnbc24deqo72b6mkl2egezxhvy").unwrap();
     let data = ipld!({"some": {"nested": cid}, "or": [cid, cid], "more": true});
 
     let mut encoded = Vec::new();
-    DagJsonCodec::encode(&mut encoded, &data).unwrap();
+    DagJsonCodec.encode(&mut encoded, &data).unwrap();
 
-    let links = DagJsonCodec::links(&encoded).unwrap().collect::<Vec<_>>();
+    let links = DagJsonCodec.links(&encoded).unwrap().collect::<Vec<_>>();
     // Extracted links: [Cid(bafkreibme22gw2h7y2h7tg2fhqotaqjucnbc24deqo72b6mkl2egezxhvy), Cid(bafkreibme22gw2h7y2h7tg2fhqotaqjucnbc24deqo72b6mkl2egezxhvy), Cid(bafkreibme22gw2h7y2h7tg2fhqotaqjucnbc24deqo72b6mkl2egezxhvy)]
     println!("Extracted links: {:?}", links);
 }

src/codec.rs

@@ -10,25 +10,28 @@ use std::io::{BufRead, Write};
 /// Each IPLD codec implementation should implement this Codec trait. This way codecs can be more
 /// easily exchanged or combined.
 pub trait Codec<T>: Links {
-    /// The multicodec code of the IPLD codec.
-    const CODE: u64;
     /// The error that is returned if encoding or decoding fails.
     type Error;
 
+    /// The multicodec code of the IPLD codec.
+    fn to_code(&self) -> u64;
+    /// Attempt to convert from a `u64` code to this `Codec`.
+    fn try_from_code(code: u64) -> Option<Self> where Self: Sized;
+
     /// Decode a reader into the desired type.
-    fn decode<R: BufRead>(reader: R) -> Result<T, Self::Error>;
+    fn decode<R: BufRead>(&self, reader: R) -> Result<T, Self::Error>;
     /// Encode a type into a writer.
-    fn encode<W: Write>(writer: W, data: &T) -> Result<(), Self::Error>;
+    fn encode<W: Write>(&self, writer: W, data: &T) -> Result<(), Self::Error>;
 
     /// Decode a slice into the desired type.
-    fn decode_from_slice(bytes: &[u8]) -> Result<T, Self::Error> {
-        Self::decode(bytes)
+    fn decode_from_slice(&self, bytes: &[u8]) -> Result<T, Self::Error> {
+        self.decode(bytes)
     }
 
     /// Encode a type into bytes.
-    fn encode_to_vec(data: &T) -> Result<Vec<u8>, Self::Error> {
+    fn encode_to_vec(&self, data: &T) -> Result<Vec<u8>, Self::Error> {
         let mut output = Vec::new();
-        Self::encode(&mut output, data)?;
+        self.encode(&mut output, data)?;
         Ok(output)
     }
 }
@@ -39,5 +42,5 @@ pub trait Links {
     type LinksError;
 
     /// Return all links (CIDs) that the given encoded data contains.
-    fn links(bytes: &[u8]) -> Result<impl Iterator<Item = Cid>, Self::LinksError>;
+    fn links(&self, bytes: &[u8]) -> Result<impl Iterator<Item = Cid>, Self::LinksError>;
 }