Dynamic Switch-Case Design Pattern

• Download source - 85.3 Kb

Overview

This design pattern solves the problem of having to implement huge switch - case statements and makes dynamic switch - case not dependent on the number of cases.

Problem Description

If we have a program used for interpreting and executing commands, as like a Linux shell, and if we assume that we have 300 commands that needs to interpreted and executed, we would need to make a switch - case statement containing 300 cases, and what if we have more than 300 commands? Then, we would need more than 300 cases to handle all those commands. Here, we make a Design Pattern to solve this problem.

Design Pattern Steps

Step 1

Create for every case, only one separate function to handle all the logic of the case.

void  HandleCase1 (int caseNumber) 
{
    printf(" The Handled Case Number Is = %d",caseNumber);
}
void  HandleCase2 (int caseNumber) 
{
    printf(" The Handled Case Number Is = %d",caseNumber);
}
void  HandleCase3 (int caseNumber) 
{
    printf(" The Handled Case Number Is = %d",caseNumber);
}

Put all of above function into a separate file and name it as HandleCases.cpp.

Step 2

Compile the above file as a shared object (dynamic library) using the following commands:

1. g++ -c -fpic HandleCases.cpp

   The above command generates an object file HandleCases.o.

2. g++ -shared -lc -o HandleCases.so HandleCases.o

   Now, we have a dynamic library containing all the case implementations.

Step 3

Create your main application where we will use this library instead of switch-cases.

1. Define a handle to our dynamic library.

   void* FunctionLib;

2. Define a pointer to the called function.

   void  (*Function)(int);

3. Open the dynamic library using the dlopen function.

   FunctionLib = dlopen("dynamic library path", RTLD_LAZY);

4. Get the desired function pointer using the dlsym function.

   Function =(void(*)(int))dlsym( FunctionLib, "HandleCase1");

5. Call this function using the above function pointer.

   (*Function)(1);

6. Finally, close the dynamic library.

   dlclose(FunctionLib);

Complete Code of Step 3

#include <span class="code-keyword"><stdlib.h></span>
#include <span class="code-keyword"><stdio.h></span>
#include <span class="code-keyword"><dlfcn.h> // </span>
int main(int argc,char*argv[])
{
    // handle to Dynamic Libary
    void* FunctionLib; 

    // Pointer to called function
    void  (*Function)(int); 

    // Pointer to read the error
    char *error; 

    // Open Dynamic Loadable Libary with absolute path 
    FunctionLib = dlopen("HandleCases.so",RTLD_LAZY);
    
    if ((error = dlerror()) != NULL)
    {
        printf ("%s \n", error);
        exit(1);
    }

    // point to our function need to call
    Function =(void(*)(int))dlsym( FunctionLib, "HandleCase1"); 

    if ((error = dlerror()) != NULL) 
    {
        printf ("%s\n", error);
        exit(1);
    }

    // call our function
    (*Function)(1);

    // close Dynamic libary
    dlclose(FunctionLib); 

    return (0);
}