Wrap Class - Expanding Whole Class Behavior

Introduction

As we conclude this course and the entire course path, let's add one more tool to our tool belt. Since we covered wrap method in a previous lesson, it only makes sense to discuss the wrap class technique, which allows us to expand the behavior of an entire class without altering its original implementation. This approach is particularly useful when we need to add new functionality to a class while preserving its existing behavior, ensuring that the original class remains unchanged and reliable.

Understanding the Wrap Class Technique

The wrap class technique involves creating a new class that encapsulates an existing class to extend its functionality. This is achieved by implementing a shared trait that the original class also adheres to, allowing the new class to intercept and augment the behavior of the original class's methods. This technique is beneficial when we want to add new features without modifying the original class, thus maintaining its integrity and reducing the risk of introducing bugs.

Implementing Wrap Class

To implement a wrap class, we start by defining a trait that both the original and the new wrapping class will implement. This trait ensures that the new class can seamlessly replace the original class in any context where the trait is used. Let's look at a practical example: trait OrderProcessorInterface: def processOrder(order: Order): Boolean def cancelOrder(order: Order): Boolean class OrderProcessor extends OrderProcessorInterface: def processOrder(order: Order): Boolean = // Original processing logic println(s"Processing order: ${order.id}") true def cancelOrder(order: Order): Boolean = // Original cancellation logic println(s"Cancelling order: ${order.id}") true In this example, OrderProcessor implements the OrderProcessorInterface trait. To expand its behavior, we create a LoggingOrderProcessor that also implements the same trait: class LoggingOrderProcessor(wrapped: OrderProcessorInterface, logger: Logger) extends OrderProcessorInterface: def processOrder(order: Order): Boolean = logger.log(s"[LOG] Starting order processing: ${order.id}") val result = wrapped.processOrder(order) logger.log(s"[LOG] Processing complete: ${order.id}, Success: $result") result def cancelOrder(order: Order): Boolean = logger.log(s"[LOG] Attempting to cancel order: ${order.id}") val result = wrapped.cancelOrder(order) logger.log(s"[LOG] Cancellation result for ${order.id}: $result") result Here, LoggingOrderProcessor wraps an existing OrderProcessorInterface instance, adding new functionality (logging) to both processOrder and cancelOrder . This allows us to extend the behavior of OrderProcessor without modifying its original implementation.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Scala

trait OrderProcessorInterface:
  def processOrder(order: Order): Boolean
  def cancelOrder(order: Order): Boolean

class OrderProcessor extends OrderProcessorInterface:
  def processOrder(order: Order): Boolean =
    // Original processing logic
    println(s"Processing order: ${order.id}")
    true

  def cancelOrder(order: Order): Boolean =
    // Original cancellation logic
    println(s"Cancelling order: ${order.id}")
    true

trait OrderProcessorInterface:
  def processOrder(order: Order): Boolean
  def cancelOrder(order: Order): Boolean

class OrderProcessor extends OrderProcessorInterface:
  def processOrder(order: Order): Boolean =
    // Original processing logic
    println(s"Processing order: ${order.id}")
    true

  def cancelOrder(order: Order): Boolean =
    // Original cancellation logic
    println(s"Cancelling order: ${order.id}")
    true

Scala

class LoggingOrderProcessor(
  wrapped: OrderProcessorInterface,
  logger: Logger
) extends OrderProcessorInterface:

  def processOrder(order: Order): Boolean =
    logger.log(s"[LOG] Starting order processing: ${order.id}")
    val result = wrapped.processOrder(order)
    logger.log(s"[LOG] Processing complete: ${order.id}, Success: $result")
    result

  def cancelOrder(order: Order): Boolean =
    logger.log(s"[LOG] Attempting to cancel order: ${order.id}")
    val result = wrapped.cancelOrder(order)
    logger.log(s"[LOG] Cancellation result for ${order.id}: $result")
    result

class LoggingOrderProcessor(
  wrapped: OrderProcessorInterface,
  logger: Logger
) extends OrderProcessorInterface:

  def processOrder(order: Order): Boolean =
    logger.log(s"[LOG] Starting order processing: ${order.id}")
    val result = wrapped.processOrder(order)
    logger.log(s"[LOG] Processing complete: ${order.id}, Success: $result")
    result

  def cancelOrder(order: Order): Boolean =
    logger.log(s"[LOG] Attempting to cancel order: ${order.id}")
    val result = wrapped.cancelOrder(order)
    logger.log(s"[LOG] Cancellation result for ${order.id}: $result")
    result

Scala

trait OrderProcessorInterface:
  def processOrder(order: Order): Boolean
  def cancelOrder(order: Order): Boolean

class OrderProcessor extends OrderProcessorInterface:
  def processOrder(order: Order): Boolean =
    // Original processing logic
    println(s"Processing order: ${order.id}")
    true

  def cancelOrder(order: Order): Boolean =
    // Original cancellation logic
    println(s"Cancelling order: ${order.id}")
    true

Scala

class LoggingOrderProcessor(
  wrapped: OrderProcessorInterface,
  logger: Logger
) extends OrderProcessorInterface:

  def processOrder(order: Order): Boolean =
    logger.log(s"[LOG] Starting order processing: ${order.id}")
    val result = wrapped.processOrder(order)
    logger.log(s"[LOG] Processing complete: ${order.id}, Success: $result")
    result

  def cancelOrder(order: Order): Boolean =
    logger.log(s"[LOG] Attempting to cancel order: ${order.id}")
    val result = wrapped.cancelOrder(order)
    logger.log(s"[LOG] Cancellation result for ${order.id}: $result")
    result

Introduction

Understanding the Wrap Class Technique

Implementing Wrap Class

Join the 1M+ learners on CodeSignal

Benefits and Pitfalls

Comparison with Sprout Class

Summary and Preparation for Practice