SerialIo.h

#ifndef ROSE_BinaryAnalysis_SerialIo_H
#define ROSE_BinaryAnalysis_SerialIo_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <ROSE_UNUSED.h>
#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/BinaryAnalysis/Serialization/SerialFrame.h>
#include <Rose/Exception.h>
#include <Rose/Progress.h>
 
#include <Sawyer/Message.h>
#include <Sawyer/ProgressBar.h>
#include <Sawyer/Synchronization.h>
 
#include <boost/filesystem.hpp>
#include <boost/lexical_cast.hpp>
#include <functional>
#include <memory>
#include <type_traits>
#include <vector>
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
#endif
 
namespace Rose {
namespace BinaryAnalysis {
 
// SerialIo
 
class SerialIo {
  public:
    using Ptr = SerialIoPtr;
 
    class Deserializer;
    class Serializer;
 
    struct SerializationRegistration {
        Serialization::Format                          format = Serialization::BINARY;
        std::function<std::shared_ptr<Deserializer>()> deserializer;
        std::function<std::shared_ptr<Serializer>()>   serializer;
    };
 
    static void                                              registerSerialization(SerializationRegistration);
    static const Sawyer::Optional<SerializationRegistration> findSerialization(Serialization::Format);
 
  private:
    mutable SAWYER_THREAD_TRAITS::Mutex mutex_; // protects the following data members
    Serialization::Format               format_;
    Progress::Ptr                       progress_;
    bool                                isOpen_;
    Serialization::Savable              objectType_;
 
  protected:
    Sawyer::ProgressBar<size_t> progressBar_;
    int                         fd_; // Used by SerialFrame
 
  protected:
    SerialIo() :
      format_(Serialization::BINARY), progress_(Progress::instance()), isOpen_(false),
      objectType_(Serialization::NO_OBJECT), progressBar_(mlog[Sawyer::Message::MARCH]), fd_(-1) {
        init();
        progressBar_.suffix(" bytes");
    }
 
  public:
    static Sawyer::Message::Facility mlog;
 
    virtual ~SerialIo();
 
    static Serialization::Savable userSavable(unsigned offset);
 
    Serialization::Format format() const;
    void                  format(Serialization::Format);
    Progress::Ptr progress() const;
    void          progress(const Progress::Ptr&);
    virtual void open(const boost::filesystem::path&) = 0;
 
    virtual void close() = 0;
 
    bool isOpen() const;
 
    Serialization::Savable objectType() const;
 
  protected:
    // Set or clear the isOpen flag.
    void setIsOpen(bool b);
 
    // Set object type to ERROR to indicate that a read was unsuccessful
    void objectType(Serialization::Savable);
 
  private:
    void init();
 
  protected:
    Serialization::ProgressCallback makeProgressCB(const std::string& phase);
 
    /* Legacy declarations for compatibility */
  public:
    using Format                   = Serialization::Format;
    static constexpr Format BINARY = Serialization::BINARY;
    static constexpr Format TEXT   = Serialization::TEXT;
    static constexpr Format XML    = Serialization::XML;
};
 
class SerialIo::Serializer {
  public:
    virtual ~Serializer() = default;
 
    virtual std::vector<char>
    savePartitioner(const Partitioner2::PartitionerConstPtr& partitioner, Serialization::ProgressCallback progress) = 0;
};
 
class SerialIo::Deserializer {
  public:
    virtual ~Deserializer() = default;
 
    virtual Partitioner2::PartitionerPtr
    loadPartitioner(const std::vector<char>& data, Serialization::ProgressCallback progress);
 
    virtual Partitioner2::PartitionerPtr
    loadPartitioner(const std::vector<char>& data, const Partitioner2::BasePartitionerSettings& settings, Serialization::ProgressCallback progress) = 0;
};
 
// SerialOutput
 
class SerialOutput: public SerialIo {
  public:
    using Ptr = SerialOutputPtr;
 
  private:
    std::shared_ptr<Serialization::SerialFrame> frame_;
    std::shared_ptr<SerialIo::Serializer>       serializer_;
 
  protected:
    SerialOutput() {}
 
  public:
    ~SerialOutput();
    void open(const boost::filesystem::path& fileName) override;
    void close() override;
 
    static Ptr instance() { return Ptr(new SerialOutput); }
 
    void savePartitioner(const Partitioner2::PartitionerConstPtr&);
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
    void saveAst(SgAsmNode*);
    void saveAst(SgBinaryComposite*);
#endif
 
  private:
    // The saveAstHelper is what actually gets called for the functions above. It doesn't descriminate between nodes
    // that support serialization and those that don't, which is why it's private. Use only the public functions because
    // they'll give you a nice compiler error if you try to save an Ast node type that isn't supported.
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
    void saveAstHelper(SgNode*);
#endif
 
  public:
    template <class T> void saveObject(Serialization::Savable objectTypeId, const T& object) {
        if (!isOpen())
            throw Exception("cannot save object when no file is open");
        if (Serialization::ERROR == objectType())
            throw Exception("cannot save object because stream is in error state");
        if (!frame_)
            throw Exception("frame container not initialized");
        if (!serializer_)
            throw Exception("serializer not initialized");
 
        // Save the object in a different thread and update the progress in this thread
        std::string                 errorMessage;
        boost::thread               worker(startWorker<T>, this, objectTypeId, object, errorMessage);
        boost::chrono::milliseconds timeout((unsigned)(1000 * Sawyer::ProgressBarSettings::minimumUpdateInterval()));
 
        progressBar_.prefix("writing");
 
        while (!worker.try_join_for(timeout)) {
            off_t cur = ::lseek(fd_, 0, SEEK_CUR);
            if (-1 == cur) {
                ++progressBar_; // so a spinner moves
            } else {
                progressBar_.value(cur);
                if (Progress::Ptr p = progress())
                    p->update(Progress::Report(cur, NAN));
            }
        }
        if (!errorMessage.empty())
            throw Exception(errorMessage);
    }
 
  private:
    template <class T>
    static void
    startWorker(SerialOutput* saver, Serialization::Savable objectTypeId, const T& object, std::string& errorMessage) {
        saver->saveWorker(objectTypeId, object, errorMessage);
    }
 
    template <class T>
    void saveWorker(Serialization::Savable objectTypeId, const T& object, std::string& errorMessage) {
        try {
            // Create a FrameRecord with appropriate metadata
            Serialization::FrameRecord frameRecord(objectTypeId, format());
 
            // Serialize the object into the frameRecord's payload
            frameRecord.serializeObject(object);
 
            // Write the frame record
            frame_->writeFrameRecord(frameRecord);
            this->objectType(objectTypeId);
        } catch (const std::exception& e) {
            errorMessage = std::string("Failed to save object using container: ") + e.what();
        } catch (...) {
            errorMessage = "failed to write object to output stream";
        }
    }
};
 
// SerialInput
 
class SerialInput: public SerialIo {
  public:
    using Ptr = SerialInputPtr;
 
  private:
    std::shared_ptr<Serialization::SerialFrame> frame_;
    std::shared_ptr<SerialIo::Deserializer>     deserializer_;
 
  protected:
    SerialInput() {}
 
  public:
    ~SerialInput();
    void open(const boost::filesystem::path& fileName) override;
    void close() override;
 
    static Ptr instance() { return Ptr(new SerialInput); }
 
    Serialization::FrameRecord readAndValidateRecord(Serialization::Savable expectedType);
 
    Serialization::Savable nextObjectType();
 
    Partitioner2::PartitionerPtr loadPartitioner();
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
    SgNode* loadAst();
#endif
 
    template <class T> T loadObject(Serialization::Savable objectTypeId) {
        if (!deserializer_)
            throw Exception("serialization backend not initialized");
 
        T object;
        loadObject<T>(objectTypeId, object);
        return object;
    }
    template <class T> void loadObject(Serialization::Savable objectTypeId, T& object) {
        if (!isOpen())
            throw Exception("cannot load object when no file is open");
        if (!frame_)
            throw Exception("frame container not initialized");
        if (!deserializer_)
            throw Exception("deserializer not initialized");
 
        try {
            // Read and validate the frame record
            auto frameRecord = readAndValidateRecord(objectTypeId);
 
            // Deserialize object from payload
            frameRecord.deserializeObject(object);
 
            objectType(Serialization::END_OF_DATA);
        } catch (const boost::archive::archive_exception& e) {
            throw Exception(std::string("Failed to load object from Boost archive: ") + e.what());
        } catch (const std::exception& e) {
            throw Exception(std::string("Failed to load object using container: ") + e.what());
        }
    }
 
  protected:
    // Read the next object type from the input stream
    void advanceObjectType();
 
    // Check ROSE version compatibility
    void checkCompatibility(const std::string& fileVersion);
};
 
} // namespace BinaryAnalysis
} // namespace Rose
 
#endif
#endif