File parser using strategy-like pattern - how to get the results?

Question

Let's say I want to make a file parser which uses the strategy-like pattern to allow use of different specific parsers which would do all the hard work and then returned the results which could vary between them.

For example file contains A, B, C, D and E in each line and I want to get only A, C and E, so I create a specific parser that pulls out just them.

I should also note that I'm dealing with NMEA format and each parser would handle different statements (lines) from the file.

class FileParser
{
std::string file_path;
public:
    FileParser(std::string file_path, ??? parser);

    void parseFile() {
        // ...
        // for each line:
            parser.parseStatement(line);
        // end for
        // ...
    }

    ??? getResults() {
        return parser.getResults();
    }
};

class Parser
{
public:
    virtual void parseLine(std::string line);
    ??? getResults();
}

class SpecificParser : public Parser
{
    void parseLine(std::string line);
    SpecificFormat getResults();
}

And my problem is - how to correctly write such code? My first thought was templates, but I don't yet know how to use them, so as a second thought I got:

FileParser otherFunction() {
    ExampleParser ep();
    FileParser fp("example.txt", &ep);
    return fp;
}

void function() {
    FileParser fp = otherFunction(); // countains reference to deleted instance of ExampleParser
}

... but it's also buggy (I showed an edge case purposefully).

What's the proper way to structure that code?

Example use case (as requested below)

auto parser1 = FileParser<SpecificParserType1>(file_name);
parser1.parseFile();
auto parser1.getResults(); // returns instance of specific type 1, e.g. std::vector<Type1>

auto parser2 = FileParser<SpecificParserType2>(file_name);
parser2.parseFile();
auto parser2.getResults(); // returns instance of specific type 2, e.g. std::vector<Type2>

The main goal is to be able to have different strategies of getting data from the file.

Answer 1

From my point of view your idea how to use the strategy pattern here is the wrong way because:

You want to make a class hierarchy which have allways the nearly same signature which already shows up your problem: There is a design problem, because your concrete strategy method is not a variant of a strategy because it has a different return type.

If such a thing can be implemented with a hack like pointers to anything you run into the next problem. So let us define that anything can be reduced to data objects.

Your concrete file parser reading strategies methods delivers a huge amount of different data object types which must be described somewhere in your program to handle such. Hint: Which type of interface would your data objects have? Maybe you want to read some int values but also std::string objects and also container classes. Is there any common interface for that types?

If you don't have such a common interface for your data types you simply have to break a general OOP design rule: Never look from the outside of the details inside a class/object. You workaround could be something like:

switch ( dataobject[n].getType() ) 
{
    case INT:
        ...;
    case STRING:
        ...;

    ... and all the objects you have defined yourself!
}

You write now code like:

auto parser1.getResults();

your result must be always the same. auto did not mean it can change it type during runtime. So that is not a solution here.

Next problem: You program code seems to make some assumptions to the content of your file. The user of your strategie pattern must know how the objects are stored in the file in which concrete order. A better way is that the object contains some content and a parser can handle this. But here is the strategy pattern not the right one.

My hint: If your design, independent of any design pattern, results in defining a class hierarchy which have the some virtual functions which must have different return types ( which is not possible ), your design is broken!

Answer 2

Just use inheritance for your format as well:

class Format{
    public:
        virtual ~Format(){}
        virtual char *data() = 0;
};

class SpecificFormat: public Format{
    public:
        char *data(){return nullptr;}
};

Then return a std::unique_ptr for your getResults function:

class Parser{
    public:
        virtual std::unique_ptr<Format> get_results() = 0;
};

and in your concrete class:

class SpecificParser: public Parser{
    public:
        std::unique_ptr<Format> get_results(){
            return std::make_unique<SpecificFormat>();
        }
};

Then in your FileParser class:

class FileParser{
    public:
        FileParser(const std::string &file_path, std::unique_ptr<Parser> &&parser)
            : parser(std::move(parser)){}

        std::unique_ptr<Format> get_results(){
            return parser->get_results();
        }

    private:
        template<typename T>
        struct TypeTag{};

        template<typename T>
        FileParser(const std::string &file_path, TypeTag<T>)
            : parser(std::make_unique<T>()){}

        template<typename T>
        friend FileParser make_parser(const std::string &filepath);

        std::unique_ptr<Parser> parser;
};

template<typename T>
FileParser make_parser(const std::string &filepath){
    return FileParser(filepath, FileParser::TypeTag<T>{});
}

Of course, you would return a more filled out Format child class.

Use it like this:

int main(){
    auto parser = FileParser{"test_file.my_format", std::make_unique<SpecificFormat>()};
    auto results = parser.get_results();
    auto data = results->data();
}

or

int main(){
    auto parser = make_parser<SpecificFormat>("testfile");
    auto results = parser.get_results();
    auto data = results->data();
}

Answer 3

Templates seem to be the best way to go here, as you know the type you want to get from the parser. Therefore you can make the whole FileParser class a template, and take the specific parser class as a template parameter.

This way, you don't need a single base class for specific parsers, and you can get the correct return type for FileParser::getResults() by using the auto getResults() -> decltype(parser->getResults()) syntax. In C++14, you can even write just "auto getResults()", without the arrow part, and the compiler will automatically determine the return type based on the function's body.

template <typename Parser>
class FileParser
{
    std::string file_path;
    Parser parser;
public:
    FileParser(std::string file_path, Parser parser): file_path(file_path), parser(parser) {}

    void parseFile() {
        // ...
        // for each line:
            parser.parseStatement(line);
        // end for
        // ...
    }

    auto getResults() -> decltype(parser.getResults()) {
        return parser.getResults();
    }
};

class SpecificParser
{
    void parseStatement(std::string line);
    SpecificFormat getResults();
}