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>
#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#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