ConcreteExecutor.h

#ifndef ROSE_BinaryAnalysis_Concolic_ConcreteExecutor_H
#define ROSE_BinaryAnalysis_Concolic_ConcreteExecutor_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_CONCOLIC_TESTING
#include <Rose/BinaryAnalysis/Concolic/BasicTypes.h>

#include <boost/filesystem.hpp>
#include <Sawyer/SharedObject.h>
#include <Sawyer/SharedPointer.h>

namespace Rose {
namespace BinaryAnalysis {
namespace Concolic {

class ConcreteExecutor: public Sawyer::SharedObject {
public:
    using Ptr = ConcreteExecutorPtr;

private:
    std::string name_;
    DatabasePtr db_;

protected:
    // Allocating `instance` constructors should be implemented by the non-abstract subclasses.
    explicit ConcreteExecutor(const std::string&);      // for instantiating factories
    explicit ConcreteExecutor(const DatabasePtr&);
public:
    ~ConcreteExecutor();

    // Factories
public:
    static void registerFactory(const Ptr &factory);

    static bool deregisterFactory(const Ptr &factory);

    static std::vector<Ptr> registeredFactories();

    static Ptr forge(const DatabasePtr&, const std::string &name);

    virtual bool matchFactory(const std::string &name) const = 0;

    virtual Ptr instanceFromFactory(const DatabasePtr&) = 0;

    bool isFactory() const;

    // Properties
public:
    const std::string& name() const;
    void name(const std::string&);
    DatabasePtr database() const;

    // Execution
public:
    virtual ConcreteResultPtr execute(const TestCasePtr&) = 0;

    // Old stuff
public:
    // FIXME[Robb Matzke 2020-07-14]: This should be in a subclass
    void executionMonitor(const boost::filesystem::path& executorName)
    {
      execmon = executorName;
    }

    // FIXME[Robb Matzke 2020-07-14]: This should be in a subclass
    boost::filesystem::path executionMonitor() const
    {
      return execmon;
    }
private:
    // FIXME[Robb Matzke 2020-07-14]: This should be in a subclass
    boost::filesystem::path execmon; // the execution monitor
};

} // namespace
} // namespace
} // namespace

#endif
#endif