ExitStatusResult.h

#ifndef ROSE_BinaryAnalysis_Concolic_I386Linux_ExitStatusResult_H
#define ROSE_BinaryAnalysis_Concolic_I386Linux_ExitStatusResult_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_CONCOLIC_TESTING
#include <Rose/BinaryAnalysis/Concolic/BasicTypes.h>
 
#include <Rose/BinaryAnalysis/Concolic/ConcreteResult.h>
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#endif
 
#include <string>
 
namespace Rose {
namespace BinaryAnalysis {
namespace Concolic {
namespace I386Linux {
 
class ExitStatusResult: public Concolic::ConcreteResult {
    using Super = Concolic::ConcreteResult;
 
public:
    using Ptr = ExitStatusResultPtr;
 
protected:
    int         exitStatus_;   
    std::string exitKind_;     
    std::string capturedOut_;  
    std::string capturedErr_;  
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Super);
        s & BOOST_SERIALIZATION_NVP(exitStatus_);
        s & BOOST_SERIALIZATION_NVP(exitKind_);
        s & BOOST_SERIALIZATION_NVP(capturedOut_);
        s & BOOST_SERIALIZATION_NVP(capturedErr_);
    }
 
protected:
    ExitStatusResult(double rank, int exitStatus);
 
    // required for boost serialization
    ExitStatusResult();
 
public:
    ~ExitStatusResult();
 
public:
    static Ptr instance(double rank, int exitStatus);
 
    int exitStatus() const;
    void exitStatus(int);
    std::string out() const;
    void out(const std::string&);
 
    std::string err() const;
    void err(const std::string&);
    std::string exitKind() const;
};
 
} // namespace
} // namespace
} // namespace
} // namespace
 
#endif
#endif