Vijesh
Map Dispatcher Pattern 👨🏼💻
Have you ever heard of the map dispatcher pattern? 🤔 It’s a powerful technique that allows us to associate keys with functions using a map or dictionary. This enables efficient and flexible dispatching of actions based on the key 🔑.
In this blog post 📪, we’ll explore the map dispatcher pattern and how it can be used to improve our code. We’ll start by discussing what the pattern is and how it works, before diving into some practical examples.
So, what exactly is the map dispatcher pattern? At its core, it’s a simple concept: we create a map or dictionary where the keys represent different actions or events, and the values are functions that handle those actions or events. When an action or event occurs, we can simply look up the corresponding function in our map and execute it.
This pattern has several benefits. First, it allows us to easily add, remove, or modify the actions or events that our code can handle. We can simply update the map with the new functions as needed. Second, it makes our code more modular and easier to maintain. Each function in the map can be written and tested independently, making it easier to manage our codebase.
To demonstrate the benefits of the map dispatcher pattern let me show an example that does not use the pattern first and then provide you with another example that uses the pattern. In that way, you can get a clear picture of the use of this pattern.
Let me write the code which does not use the pattern:
package main
import (
"fmt"
"strconv"
)
func processInt(data string) {
i, err := strconv.Atoi(data)
if err != nil {
panic(err)
}
fmt.Println("Processing int:", i)
}
func processString(data string) {
fmt.Println("Processing string:", data)
}
func processFloat(data string) {
f, err := strconv.ParseFloat(data, 64)
if err != nil {
panic(err)
}
fmt.Println("Processing float:", f)
}
func processData(dataType, data string) {
switch dataType {
case "int":
processInt(data)
case "string":
processString(data)
case "float":
processFloat(data)
default:
panic("data type not supported")
}
}
func main() {
processData("int", "42")
processData("string", "hello")
processData("float", "3.14")
}
This code works fine for our current needs. However, let’s say we want to add support for
a new data type, such as boolean values.
We would need to add a new function to handle this data type and update the processData function to include a new case in the switch
statement.
This can quickly become cumbersome as we add more and more data types.
Now let’s see how we could rewrite this code using the map dispatcher pattern:
...
create a file named main.go and paste the below code…
package main
import (
"fmt"
"strconv"
)
type ProcessData func(string)
func processInt(data string) {
i, err := strconv.Atoi(data)
if err != nil {
panic(err)
}
fmt.Println("Processing int:", i)
}
func processString(data string) {
fmt.Println("Processing string:", data)
}
func processFloat(data string) {
f, err := strconv.ParseFloat(data, 64)
if err != nil {
panic(err)
}
fmt.Println("Processing float:", f)
}
var (
processors = map[string]ProcessData{
"int": processInt,
"string": processString,
"float": processFloat,
}
)
func processData(dataType, data string) {
process, ok := processors[dataType]
if !ok {
panic("data type not supported")
}
process(data)
}
func main() {
processData("int", "42")
processData("string", "hello")
processData("float", "3.14")
}
In this code version, we’ve created a map processors
that associates the keys (the data types) with the corresponding functions.
In the processData function, we can now look up the
appropriate function in the map and execute it.
This makes our code more flexible and easier to maintain.
For example, if we wanted to add support for a new data type, we could simply add a new
entry to the processors map.
Consider if I want to add another processor which supports datatype bool it's very easy. It's just a matter of adding an anonymous function like this…
var (
processors = map[string]ProcessData{
"int": processInt,
"string": processString,
"float": processFloat,
"bool" : func (data string) {
b, err := strconv.ParseBool(data)
if err != nil {
panic(err)
}
fmt.Println("Processing bool:", b)
},
}
)
Using the map dispatcher pattern can simplify the testing of code in several ways.
First, it makes it easier to test individual functions in isolation.
In the example code you provided, each function that processes a specific data type
(such as processInt, processString, and processFloat) can be tested independently of the other
functions.
This makes it easier to write focused unit tests that verify the behavior of each
function.
Second, it makes it easier to test the processData
function.
Instead of having to write a separate test case for each possible data type, you can
write a more general test that verifies that the processData function correctly dispatches to the
appropriate function based on the data type.
You can do this by creating a mock version of the processors map that associates each data type with a test
function that records which data type was passed to it.
Then, you can call the processData function with
different data types and verify that the correct test function was called.
Overall, using the map dispatcher pattern can make your code more modular and easier to test, which can help improve its reliability and maintainability.
Create a file named main_test.go and paste the below code…
To run the test use the command: go test
...
package main
import (
"testing"
)
func TestProcessData(t *testing.T) {
// Create a mock version of the processors map
mockProcessors := map[string]ProcessData{
"int": func(data string) {
if data != "42" {
t.Errorf("Expected data to be '42', got '%s'", data)
}
},
"string": func(data string) {
if data != "hello" {
t.Errorf("Expected data to be 'hello', got '%s'", data)
}
},
"float": func(data string) {
if data != "3.14" {
t.Errorf("Expected data to be '3.14', got '%s'", data)
}
},
}
// Temporarily replace the global processors map with the mock version
oldProcessors := processors
processors = mockProcessors
defer func() { processors = oldProcessors }()
// Test the processData function with different data types
processData("int", "42")
processData("string", "hello")
processData("float", "3.14")
}
In this test, we create a mock version of the processors
map that associates each data type with a test function.
Each test function checks that the data argument passed
to it is the expected value, and reports an error if it’s not.
We then temporarily replace the global processors map
with our mock version and call the processData function
with different data types.
This allows us to verify that the processData function
correctly dispatches to the appropriate test function based on the data type.
This is just one way to test the processData function.
You could also write tests that verify other aspects of its behavior, such as its error
handling.
Thank you for taking the time to read my blog. I hope it provided useful information to my fellow Go, developers. If you have any questions or comments, please feel free to leave them below. I’d love to hear your thoughts! 😁