Bridge Pattern

Diagram of the bridge pattern

The Bridge design pattern is used to separate the implementation from the abstract interface presented to the caller. This is also colloquially known as the "pimpl" pattern, since the abstract interface forwards all method calls to an underlying implementation via a "pointer to the implementation" or "pimpl".

The Bridge pattern separates the abstraction from the implementation so that both abstraction and, more importantly, implementation can vary without affecting the other side of the bridge. The Bridge pattern is not limited to a single class with one or more implementations. The abstract side can have a hierarchy of classes inheriting from a base abstraction. The implementation side can also have a parallel hierarchy of inherited classes.

The key idea is the caller is presented with an abstract class that knows how to create a specific implementation based on input from the caller. The definition of the implementation is completely hidden from the caller, who sees only the abstract class.

That abstract class must be a class since it must contain some kind of reference to the underlying implementation.

How to Use

Links to the Logger classes (interfaces, functions)

C++	C#	Python	C
Logger class	Logger class	Logger class	ILogger interface CreateLogger() DestroyLogger()

In this example, the Logger class is what the program uses for all logging. The program logs information at various levels of granularity to some output. The program doesn't care where the logged output ends up.

The Logger abstract class can make use of three different implementations of loggers: File, Console, Null. Each of these loggers implements the ILogger interface so the Logger object doesn't have to care about the implementation details. And the user of the Logger class has no idea of how the Logger class does what it does, only that it provides the same methods regardless of the actual implementation.

In this way, the Logger class is the bridge between the program and the logger implementations.

Note: The Bridge_NullLogger class is an example of the Null Object pattern.

An alternative implementation would use a class factory method to take the LoggerType and optional parameter as arguments and return an actual implementation represented by the ILogger class. This eliminates the need for a bridge class altogether and completely hides any details of the implementation. In other words, the interface itself is the "bridge".

Basically, the use of an interface and a class factory can hide any implementation and it works in any programming language that supports the idea of a base class or interface.

C++

    void Bridge_Exercise()
    {
        std::cout << std::endl;
        std::cout << "Bridge Exercise" << std::endl;
 
        // Note: Use local contexts to automatically close the various loggers
        // when the loggers go out of scope.
        {
            Logger logger("Bridge.log"); // Logger::LoggerTypes::ToFile type
            std::cout << "  Example of writing to a log file..." << std::endl;
            _Bridge_Exercise_Demonstrate_Logging(logger, "file");
        }
 
        {
            Logger logger(Logger::LoggerTypes::ToConsole);
            std::cout << "  Example of writing to the console..." << std::endl;
            _Bridge_Exercise_Demonstrate_Logging(logger, "console");
        }
 
        {
            Logger logger(Logger::LoggerTypes::ToNull);
            std::cout << "  Example of writing to a Null object (no output)..."
                << std::endl;
            // Note: The resulting log lines will not be shown anywhere.
            _Bridge_Exercise_Demonstrate_Logging(logger, "null");
        }
 
        std::cout << "  Done." << std::endl;
    }

C#

        public void Run()
        {
            Console.WriteLine();
            Console.WriteLine("Bridge Exercise");
            using (Logger logger = new Logger(Logger.LoggerTypes.ToFile, "Bridge.log"))
            {
                Console.WriteLine("  Example of writing to a log file...");
                _Bridge_Exercise_Demonstrate_Logging(logger, "file");
            }
 
            using (Logger logger = new Logger(Logger.LoggerTypes.ToConsole))
            {
                Console.WriteLine("  Example of writing to the console...");
                _Bridge_Exercise_Demonstrate_Logging(logger, "console");
            }
 
            using (Logger logger = new Logger(Logger.LoggerTypes.ToNull))
            {
                Console.WriteLine("  Example of writing to a Null object (no output)...");
                // Note: The resulting log lines will not be shown anywhere.
                _Bridge_Exercise_Demonstrate_Logging(logger, "null");
            }
            Console.WriteLine("  Done.");
        }

Python

def Bridge_Exercise():
    print()
    print("Bridge Exercise")
 
    with Logger(Logger.LoggerTypes.ToFile, "Bridge.log") as logger:
        print("  Example of writing to a log file...")
        _Bridge_Exercise_Demonstrate_Logging(logger, "file")
 
    with Logger(Logger.LoggerTypes.ToConsole) as logger:
        print("  Example of writing to the console...")
        _Bridge_Exercise_Demonstrate_Logging(logger, "console")
 
    with Logger(Logger.LoggerTypes.ToNull) as logger:
        print("  Example of writing to a Null object (no output)...")
        # Note: The resulting log lines will not be shown anywhere.
        _Bridge_Exercise_Demonstrate_Logging(logger, "null")
 
    print("  Done.")

C

void Bridge_Exercise(void)
{
    printf("\nBridge_Exercise\n");
 
    {
        ILogger* fileLogger = CreateLogger(LoggerType_ToFile, "Bridge.log");
        if (fileLogger != NULL)
        {
            printf("  Example of writing to a log file...\n");
            _Bridge_Exercise_Demonstrate_Logging(fileLogger, "file");
            DestroyLogger(fileLogger);
        }
        else
        {
            printf("  Error! Failed to create a file logger\n");
        }
    }
 
    {
        ILogger* consoleLogger = CreateLogger(LoggerType_ToConsole, NULL);
        if (consoleLogger != NULL)
        {
            printf("  Example of writing to the console...\n");
            _Bridge_Exercise_Demonstrate_Logging(consoleLogger, "console");
            DestroyLogger(consoleLogger);
        }
        else
        {
            printf("  Error! Failed to create a console logger\n");
        }
    }
 
    {
        ILogger* nullLogger = CreateLogger(LoggerType_ToNull, NULL);
        if (nullLogger != NULL)
        {
            printf("  Example of writing to a Null object (no output)...\n");
            _Bridge_Exercise_Demonstrate_Logging(nullLogger, "null");
            DestroyLogger(nullLogger);
        }
        else
        {
            printf("  Error! Failed to create a console logger\n");
        }
    }
 
    printf("  Done.\n");
}

Rust

(Apologies. Doxygen does not understand Rust syntax and therefore cannot colorize the code.)

pub fn bridge_exercise() -> Result<(), String> {
    println!("");
    println!("Bridge Exercise");
 
    {
        let mut logger = create_logger(LoggerType::ToFile, "bridge.log");
        println!("  Example of writing to a log file...");
        _bridge_exercise_demonstrate_logging(&mut logger, "file");
    }
 
    {
        let mut logger = create_logger(LoggerType::ToConsole, "");
        println!("  Example of writing to the console...");
        _bridge_exercise_demonstrate_logging(&mut logger, "console");
    }
 
    {
        let mut logger = create_logger(LoggerType::ToNull, "");
        println!("  Example of writing to a Null object (no output)...");
        _bridge_exercise_demonstrate_logging(&mut logger, "null");
    }
 
    println!("  Done.");
 
    Ok(())
}

See Also

• Main Page