Wrap Class - Expanding Whole Class Behavior

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.

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.

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.