1 files changed, 15 insertions, 15 deletions

diff --git a/src/display.rs b/src/display.rs
index cc70aac..fc292f1 100644
--- a/src/display.rs
+++ b/src/display.rs
@@ -1,36 +1,36 @@
 //! Enables base64'd output anywhere you might use a `Display` implementation, like a format string.
 //!
 //! ```
-//! use base64::display::Base64Display;
+//! use base64::{display::Base64Display, engine::general_purpose::STANDARD};
 //!
 //! let data = vec![0x0, 0x1, 0x2, 0x3];
-//! let wrapper = Base64Display::with_config(&data, base64::STANDARD);
+//! let wrapper = Base64Display::new(&data, &STANDARD);
 //!
 //! assert_eq!("base64: AAECAw==", format!("base64: {}", wrapper));
 //! ```
 
 use super::chunked_encoder::ChunkedEncoder;
-use super::Config;
+use crate::engine::Engine;
 use core::fmt::{Display, Formatter};
 use core::{fmt, str};
 
 /// A convenience wrapper for base64'ing bytes into a format string without heap allocation.
-pub struct Base64Display<'a> {
+pub struct Base64Display<'a, 'e, E: Engine> {
     bytes: &'a [u8],
-    chunked_encoder: ChunkedEncoder,
+    chunked_encoder: ChunkedEncoder<'e, E>,
 }
 
-impl<'a> Base64Display<'a> {
-    /// Create a `Base64Display` with the provided config.
-    pub fn with_config(bytes: &[u8], config: Config) -> Base64Display {
+impl<'a, 'e, E: Engine> Base64Display<'a, 'e, E> {
+    /// Create a `Base64Display` with the provided engine.
+    pub fn new(bytes: &'a [u8], engine: &'e E) -> Base64Display<'a, 'e, E> {
         Base64Display {
             bytes,
-            chunked_encoder: ChunkedEncoder::new(config),
+            chunked_encoder: ChunkedEncoder::new(engine),
         }
     }
 }
 
-impl<'a> Display for Base64Display<'a> {
+impl<'a, 'e, E: Engine> Display for Base64Display<'a, 'e, E> {
     fn fmt(&self, formatter: &mut Formatter) -> Result<(), fmt::Error> {
         let mut sink = FormatterSink { f: formatter };
         self.chunked_encoder.encode(self.bytes, &mut sink)
@@ -57,18 +57,18 @@ mod tests {
     use super::super::chunked_encoder::tests::{
         chunked_encode_matches_normal_encode_random, SinkTestHelper,
     };
-    use super::super::*;
     use super::*;
+    use crate::engine::general_purpose::STANDARD;
 
     #[test]
     fn basic_display() {
         assert_eq!(
             "~$Zm9vYmFy#*",
-            format!("~${}#*", Base64Display::with_config(b"foobar", STANDARD))
+            format!("~${}#*", Base64Display::new(b"foobar", &STANDARD))
         );
         assert_eq!(
             "~$Zm9vYmFyZg==#*",
-            format!("~${}#*", Base64Display::with_config(b"foobarf", STANDARD))
+            format!("~${}#*", Base64Display::new(b"foobarf", &STANDARD))
         );
     }
 
@@ -81,8 +81,8 @@ mod tests {
     struct DisplaySinkTestHelper;
 
     impl SinkTestHelper for DisplaySinkTestHelper {
-        fn encode_to_string(&self, config: Config, bytes: &[u8]) -> String {
-            format!("{}", Base64Display::with_config(bytes, config))
+        fn encode_to_string<E: Engine>(&self, engine: &E, bytes: &[u8]) -> String {
+            format!("{}", Base64Display::new(bytes, engine))
         }
     }
 }