Design for Multi Version of a File.

[bean66]

I'd like some advice on how to lay out a design in C++ that can handle multiple versions of a file.

The file will contain enough information to identify version 5 from version 6 in a header. Most of the structures will be identical. However there may be the occasional oddity and certainly many new structures. In the newer versions.

This is an existing program written in C. I'm considering porting this to C++ while I learn C++.
The input for the files are complicated by marshaling. So its not a simple matter of reading a struct.

I was originally just considering implementing separate libraries for this one for version5 and the next for version10.. But I'd like input on handling this internally using C++.

Thanks,
Ken

[matsp]

If we assume that identifying the version is relatively simple, you could actually do something like this:

class baseversion
{
private:
    // Class members that are common to all versions for currently oldest supported version.    
public:
    virtual int readData() = 0;
    virtual int writeData() const = 0;
};

class version5: public baseversion
{
private:
    // Add version5 onwards data members. 
public:
   virtual int readData();
   virtual int writeData();
};

class version6: public version5
{
private:
    // Add version6 onwards data members. 
public:
   virtual int readData();
   virtual int writeData();
};

Then you have a factory function that does something like this:

baseversion *factory()
{
    int version = figureoutversion();
    baseversion *ptr;
    switch(version)
    {
       case 5:
          ptr = new version5;
          break;
       case 6:
          ptr = new version6;
          break;
       default:
          // Handle "unknown version" error. 
          break;
     }
}

This is of course just the principle. You'd need to write a fair bit more code, and you probably need some symbolic names and such for constants where I've used 5, 6 etc.

--
Mats

[bean66]

Thanks Mats,

Thats exactly what I was looking too see..

Each structure/Function has a corresponding on disk representation.

The current code is in "C" so my original thought was to create an array of pointers. Then simply initialize based upon the versions:

{
if (version == 5) {
   base[01] = func01_v5; 
   base[02] = func02_v5;
} else if (version == 6) {
   base[01] = func01_v6; 
   base[02] = func02_v6;
}
... 
}

However I like the C++ techniques since I can keep the same names and just add where needed. And not have to create duplicate header structures for each type.