Specimen.h

#ifndef ROSE_BinaryAnalysis_Concolic_Specimen_H
#define ROSE_BinaryAnalysis_Concolic_Specimen_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_CONCOLIC_TESTING
#include <Rose/BinaryAnalysis/Concolic/BasicTypes.h>
 
#include <boost/filesystem.hpp>
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#endif
 
#include <Sawyer/SharedObject.h>
#include <Sawyer/SharedPointer.h>
#include <string>
#include <vector>
 
namespace Rose {
namespace BinaryAnalysis {
namespace Concolic {
 
class Specimen: public Sawyer::SharedObject, public Sawyer::SharedFromThis<Specimen> {
public:
    typedef Sawyer::SharedPointer<Specimen> Ptr;
 
    typedef std::vector<uint8_t> BinaryData;
 
private:
    mutable SAWYER_THREAD_TRAITS::Mutex mutex_;         // protects the following data members
    std::string name_;                                  // name of specimen (e.g., for debugging)
    std::string timestamp_;                             // time of creation
    BinaryData content_;                                // content of the binary executable file
    mutable bool read_only_;                            // safe guards from writing content after it has been shared;
    bool empty_;                                        // indicates if this object is empty
 
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        s & BOOST_SERIALIZATION_NVP(name_);
        s & BOOST_SERIALIZATION_NVP(content_);
        s & BOOST_SERIALIZATION_NVP(empty_);
    }
 
protected:
    Specimen();
 
public:
    ~Specimen();
 
    static Ptr instance(const boost::filesystem::path &executableName);
    static Ptr instance();
    void open(const boost::filesystem::path &executableName);
 
    void close();
 
    bool isEmpty() const;
 
    std::string name() const;                           // value return is intentional for thread safety
    void name(const std::string&);
    std::string printableName(const DatabasePtr &db = DatabasePtr());
 
    void toYaml(std::ostream&, const DatabasePtr&, std::string prefix);
 
    std::string timestamp() const;
    void timestamp(const std::string&);
    const std::vector<uint8_t>& content() const;
 
    // FIXME[Robb Matzke 2019-08-12]: content is read-only, created by constructor. Therefore this member shouldn't be defined,
    // or at least should be private.
    void content(std::vector<uint8_t> binary_data);
};
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif