gstreamerJSONFactory.h

Go to the documentation of this file.

#pragma once
 
// gstreamer
#include "gstreamer.h"
#include "gstreamerConventions.h"
 
// c++
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
 
class GstreamerJsonFactory : public GStreamer {
public:
    using GStreamer::GStreamer;
 
    GstreamerJsonFactory(const GstreamerJsonFactory&)            = delete;
    GstreamerJsonFactory& operator=(const GstreamerJsonFactory&) = delete;
    GstreamerJsonFactory(GstreamerJsonFactory&&)                 = delete;
    GstreamerJsonFactory& operator=(GstreamerJsonFactory&&)      = delete;
 
private:
    bool openConnection() override;
 
    bool closeConnectionImpl() override;
 
    bool startEventImpl(const std::shared_ptr<GEventDataCollection>& event_data) override;
 
    bool endEventImpl(const std::shared_ptr<GEventDataCollection>& event_data) override;
 
    bool publishEventHeaderImpl(const std::unique_ptr<GEventHeader>& gevent_header) override;
 
    bool publishEventTrueInfoDataImpl(const std::string& detectorName,
                                      const std::vector<const GTrueInfoData*>& trueInfoData) override;
 
    bool publishEventDigitizedDataImpl(const std::string& detectorName,
                                       const std::vector<const GDigitizedData*>& digitizedData) override;
 
    bool startStreamImpl(const GFrameDataCollection* frameRunData) override;
 
    bool endStreamImpl(const GFrameDataCollection* frameRunData) override;
 
    bool publishFrameHeaderImpl(const GFrameHeader* gframeHeader) override;
 
    bool publishPayloadImpl(const std::vector<GIntegralPayload*>* payload) override;
 
private:
    // Output stream (one instance per worker thread).
    std::ofstream ofile;
 
    // True if the file header (opening braces) has been written.
    bool is_file_initialized = false;
 
    // Tracks whether we've already written at least one entry inside the current top-level array.
    bool wrote_first_top_level_entry = false;
 
    // Active top-level mode: "event" or "stream".
    std::string top_level_type;
 
    // Event assembly state.
    bool is_building_event = false;
    std::ostringstream current_event;
    bool current_event_has_header = false;
    bool current_event_has_any_detector = false;
 
    // Frame assembly state (minimal support).
    bool is_building_frame = false;
    std::ostringstream current_frame;
    bool current_frame_has_header = false;
    bool current_frame_has_payload = false;
 
    // Cached header fields (used by event writers).
    std::string timestamp;
    int         event_number = -1;
    int         thread_id    = -1;
 
private:
    [[nodiscard]] std::string filename() const override { return gstreamer_definitions.rootname + ".json"; }
 
private:
    // Helper utilities (kept private and not cross-referenced).
    static std::string jsonEscape(const std::string& s);
    void              ensureFileInitializedForType(const std::string& type);
    void              writeTopLevelEntry(const std::string& entry_json);
    void              closeTopLevelObjectIfNeeded();
};