Question

I have an application which will be receiving messages from another application. These messages will be XML fomatted strings, and they will contain a <messageType> tag. The message type will identify this message as a type of internal message. The following code shows my internal message structures.

namespace
Application1{

enum ApplicationAttributes{
    ApplicationName = 1000,
    Start,
    Stop,
    Pause,
    Save,
    Discard,
    SelectRunway,
    DoAlignment,
    RedoAlignment,
    AlignmentOK,
    DoCalibrationStage1,
    SetCalibrationStage1,
    SetCalibrationStage2,
    SetCalibrationStage3,
    CancelCalibration,
    CalibrationOK
};


struct Alignment{
    int x;
    int y;
    int error;
};

struct Calibration{
    int x;
    int y;
    int error;
};

}

alignment and calibration are the two internal message structures.

What I’m trying to do is build a ‘message interpreter’ which will receive an XML string, decode it and return any one of the structs shown above; so if the <messageType> is ‘alignment’, the message interpreter will build an alignment struct, and return that.

So ultimately, I’m trying to make a template function, which can return an arbitrary struct, based on what i read in from <messageType>.

Are my objectives clear? is my approach the right one?

Let me know if I should clarify, or if I should take a different approach.

Answer 1

I don’t believe a template function makes sense. Your input is always going to be a string, and C++ can’t differentiate function signatures based on return type alone – so I don’t know how a template would help – what would the type argument be?

I’d suggest making your function a normal one that parses out the messageType and allocates a struct based on it – you can use whatever constructs you want for this.

The trick would be (in my mind) to derive all of your internal-message-classes from the same empty base class – you could then return a pointer to that base class back from your function, and it will hold whatever type got created.

It be a good idea to return an enumeration along with the pointer in a std::pair which you can use to determine the correct derived type that was created, that way you can cast the result directly to the correct derived type with a static_cast.