How to avoid large switch statements in C++ due to template parameters

Question

The scenario: I want to read a file which contains value with a data type defined in its header, copy its content to a temporary image, modify the content of the temporary image and save it again.

The problem is that the size of the data type requires different ways of accessing/modifying the content and results in large switch statements due to different data types (the list here is shortened). Also the type is only known at runtime, not at compile-time.

#include <stdint.h>
#include <stdlib.h>

typedef enum {
    DT_UCHAR,                   /** @brief Datatype 'unsigned char'     */
    DT_CHAR,                    /** @brief Datatype 'signed char'       */
    DT_USHORT,                  /** @brief Datatype 'unsigned short'    */
    DT_SHORT,                   /** @brief Datatype 'signed short'      */
    DT_UINT,                    /** @brief Datatype 'unsigned int'      */
    DT_INT,                     /** @brief Datatype 'signed int'        */
    DT_FLOAT,                   /** @brief Datatype 'float'             */
    DT_DOUBLE,                  /** @brief Datatype 'double'            */
} e_datatype;

struct image {
    e_datatype      type;
    size_t          size;
    void*           data;
};

image image1;
image image2;
image image3;

template <typename T>
void create_mask(void *const dst, const unsigned i_dst, const void *const src, const unsigned i_src, const void* const threshold) {
    if (static_cast<const T*>(src) < static_cast<const T*>(threshold))
        *(static_cast<T*>(dst)+i_dst) = 1;
}


void create_mask(image *const out, const unsigned out_i, const image *const in, const unsigned in_i, const image* const threshold) {

    if (in->type != threshold->type || out->type != DT_UCHAR)
        return;

    switch (out->type) {
    case DT_UCHAR:
        create_mask<unsigned char>(out->data, out_i, in->data, in_i, threshold->data);
        break;
    case DT_CHAR:
        create_mask<signed char>(out->data, out_i, in->data, in_i, threshold->data);
        break;
    case DT_USHORT:
        create_mask<unsigned short>(out->data, out_i, in->data, in_i, threshold->data);
        break;
    case DT_SHORT:
        create_mask<signed short>(out->data, out_i, in->data, in_i, threshold->data);
        break;
    case DT_UINT:
        create_mask<unsigned int>(out->data, out_i, in->data, in_i, threshold->data);
        break;
    case DT_INT:
        create_mask<signed int>(out->data, out_i, in->data, in_i, threshold->data);
        break;
    case DT_FLOAT:
        create_mask<float>(out->data, out_i, in->data, in_i, threshold->data);
        break;
    case DT_DOUBLE:
        create_mask<double>(out->data, out_i, in->data, in_i, threshold->data);
        break;
    default:
        //printf("ERROR. Unknown type.\n");
        break;
    }
}

size_t sizeof_image(e_datatype type) { return 1 /* another switch with the size of each datatype */;  }

void read_image() {

    image *my_image1 = &image1;
    image *my_image2 = &image2;
    image *threshold = &image3;

    // read header and save it in my_image and then
    // read data and copy it to the data field of my_image
    read_image_header("mydata_uint.dat", my_image1);
    my_image1->data = calloc(my_image1->size, sizeof_image(my_image1->type));
    read_image_data("mydata_uint.dat", my_image1);

    // create output mask
    my_image2->size = my_image1->size;
    my_image2->type = DT_UCHAR;
    my_image2->data = calloc(my_image2->size, sizeof_image(DT_UCHAR));

    // read threshold value from another image
    read_image_header("mydata_thresh.dat", threshold);
    threshold->data = calloc(threshold->size, sizeof_image(threshold->type));
    read_image_data("mydata_thresh.dat", threshold);

    for (unsigned i = 0; i < my_image1->size; i++)
        create_mask(my_image1, i, my_image2, i, threshold);
}

Is it possible to rewrite the image class/struct such that it would use a template class with the datatype being set at inside read_image()? Hence reducing the amount of switch statements.

My limitation is that I cannot use C++ Standard Library features and I am limited to C++03.

I found a solution with function pointers but this solution does not seem shorter than those large switch statements.

Answer 1

Without knowing more about the use cases for copy1D() and your other functions, it's difficult to provide a complete solution. In any case, a possible alternative to your solution would be to use dynamic polymorphism. For example:

Create an interface with all of methods you need

// Interface
struct Image {
    virtual Image* copy() = 0;
    virtual void manipulate() = 0;
    virtual void writeToFile() = 0;
    virtual ~Image() { }
};

Now let templates take care of the implementation of your interface

// Templated implementation
template <typename T>
struct ImageImpl : Image {

    size_t size;
    T* data;

    ImageImpl( const ImageImpl<T>& other ) {
        size = other.size;
        data = new T[size];
        memcpy( data, other.data, size * sizeof(T) );
    }

    ~ImageImpl() {
        delete[] data;
    }

    virtual Image* copy() {
        return new ImageImpl( *this );
    }

    virtual void manipulate() {
        for ( int i = 0; i < size; i++ ) {
            data[i] = data[i] + 1; // Do something with the data
        }
    }

    virtual void writeToFile( const char* filename ) {
        for ( int i = 0; i < size; i++ ) {
            write( data[i] );
        }
    }
};

Example usage:

Image* newFromFile( const char* filename )
{
    Image* i = NULL;

    if ( isIntFile( filename ) ) {
        i = new ImageImpl<int>( ... );
    }
    else if ( isFloatFile( filename ) ) {
        i = new ImageImpl<float>( ... );
    }
    ...

    return i;
}

int main()
{
    Image* i = newFromFile( "example.img" );

    Image* iCopy = i->copy();
    iCopy->manipulate();
    iCopy->writeToFile( "new.img" );

    delete iCopy;
    delete i;
}

Answer 2

Your problem is a classic one of "data being used to find code". There is no way around it other than to provide code for every valid pathway (i.e. every valid data type plus one error pathway).

Further template magic won't in the end reduce keystrokes. Macros might.

Answer 3

Overloaded functions, based on type, might help.

Also, a map of data type name (or ID) and function pointers could also help. This works in the C language.

Answer 4

Since your enum is contiguous, you don't need a fancy map and can use an old-fashioned array (if you can live without error-checking).

typedef void (*copyFunction)(void *const, const unsigned, const void *const, const unsigned);

void copy1D(image *const out, const unsigned out_i, const image *const in, const unsigned in_i)
{
    static const copyFunction functions[] =
    {
       copyValue<unsigned char>,
       copyValue<signed char>,
       copyValue<unsigned short>,
       copyValue<signed short>,
       copyValue<unsigned int>,
       copyValue<signed int>,
       copyValue<float>,
       copyValue<double>
    };
    functions[out->type](out->data, out_i, in->data, in_i);
}

You can generalise this using a macro:

#define MAKE_TABLE(function)\
   {\
       function<unsigned char>,\
       function<signed char>,\
       function<unsigned short>,\
       function<signed short>,\
       function<unsigned int>,\
       function<signed int>,\
       function<float>,\
       function<double>\
   }

typedef void (*copyFunction)(void *const, const unsigned, const void *const, const unsigned);

void copy1D(image *const out, const unsigned out_i, const image *const in, const unsigned in_i) 
{
   static const copyFunction functions[] = MAKE_TABLE(copyValue);
   functions[out->type](out->data, out_i, in->data, in_i);
}

Or, you can have the function pointer as a member of image (this is like a manually managed virtual function)

typedef void (*copyFunction)(void *const, const unsigned, const void *const, const unsigned);

struct image {
   e_datatype      type;
   size_t          size;
   void*           data;
   copyFunction    copy;
};

void read_image() 
{
    image *my_image = 0;
    // Read image...
    // ...

    // Set up the "virtual function"
    static const copyFunction functions[] = MAKE_TABLE(copyValue);
    my_image->copy = functions[my_image->type];
}

void copy1D(image *const out, const unsigned out_i, const image *const in, const unsigned in_i) 
{
   out->copy(out->data, out_i, in->data, in_i);
}

Answer 5

It's not clear from your code snippet what are the actual differences in processing of different data-types (other than sizeof-related).

One of C++ ways to handle a family of "typed" objects is to define traits in conjunction with a common object template (should be ok with C++03), then implement the type-specific handling in template-specializations with given "trait". Essentially, traits takes care of "enum". This may indeed compact the written code quite a bit, especially when handling for different data-types is much similar.

HOWEVER, in your case the decision about the data-type seems to be tied to the external data (file). Your data-type granularity is quite detailed (i.e. you define short, unsigned types), so a simple strtol/strtod() won't cut here to produce a templated object directly.

Thus you may want to include the data-type-ID in your external data and use it to create a traits object that in its turn would yield you a templated data-object which actually consumes the data. Otherwise you'd need to have at least one swtich statement after parsing the external data to map your external (string-based) type to internal (data-type-ID) type.

I find a good intro on traits is by Alexandrescu: http://erdani.com/publications/traits.html.

Answer 6

You are already going into the right direction by separating image IO from the image itself. In order to be able to use the type of the image in the writer you have multiple options. My approach would be:

#include <cstdint>
#include <vector>

using namespace std;

template <typename T> class Image
{
public:
    typedef T Pixel_t;
    vector<Pixel_t> data; // or any suitable data structure

// all other stuff that belongs to the Image Class
};

template <class T> ImageWriter
{
public:
    typedef T Image_t;

    void writeImage(const Image_t& image)
    {
        write(file, &image[0], image.size()*sizeof(Image_t::Pixel_t));
    }
// other stuff that belongs to the ImageWriter
private:
    void write(File& file, void* data, size_t size);
};

You can then use that in you application

typedef Image<uint32_t> img_t;

void myStuff()
{
    img_t img;
    ImageWriter<img_t::Pixel_t> writer;

    // ...
    writer.writeImage(img);
}