JournalArchive.h

Go to the documentation of this file.

/*
Copyright 2007-2025. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material unless having a written signed agreement with Algoryx Simulation AB, or having been
advised so by Algoryx Simulation AB for a time limited evaluation, or having purchased a
valid commercial license from Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
 
#ifndef AGXDATA_JOURNALARCHIVE_H
#define AGXDATA_JOURNALARCHIVE_H
 
#include <agx/Device.h>
#include <agx/Component.h>
#include <agx/Range.h>
#include <agx/Date.h>
#include <agxNet/FramePacket.h>
#include <agxData/SerializedFrame.h>
#include <agxData/FrameIO.h>
 
 
namespace agxData
{
  class DiskFrameReader;
  class DiskFrameWriter;
 
 
 
  class AGXCORE_EXPORT JournalArchive : public agx::Referenced
  {
  public:
    AGX_DECLARE_POINTER_TYPES( Session );
 
 
    typedef agx::HashTable<agx::Name, agxData::JournalArchive::SessionRef> SessionTable;
 
 
    const agx::Name& getName() const;
 
    const agx::String& getPath() const;
 
    void listSessionNames( agx::Vector<agx::Name>& result ) const;
 
    agxData::JournalArchive::Session* getSession( const agx::Name& name );
 
    const agxData::JournalArchive::Session* getSession( const agx::Name& name ) const;
 
    const SessionTable& getSessions() const;
 
    virtual agxData::JournalArchive::Session* createNewSession( const agx::Name& name ) = 0;
 
    bool removeSession( const agx::Name& name );
 
    virtual bool removeSession( agxData::JournalArchive::Session* session ) = 0;
 
    virtual bool renameSession( agxData::JournalArchive::Session* session, const agx::Name& newName ) = 0;
 
 
    bool copySession( agxData::JournalArchive::Session* session, agxData::JournalArchive* target );
 
    bool transferSession( agxData::JournalArchive::Session* session, agxData::JournalArchive* target );
 
 
 
    virtual agx::String getCustomFilesPath(bool create = true) const = 0;
 
 
    virtual agx::String getCustomFilesPath( const agx::Name& sessionName, bool create = true ) const = 0;
 
    bool isOwnerOf( const agxData::JournalArchive::Session* session) const;
 
    size_t getNumSessions() const;
 
 
    virtual DiskFrameReader* createFrameReader(agxData::JournalArchive::Session* session) = 0;
    virtual DiskFrameWriter* createFrameWriter(agxData::JournalArchive::Session* session) = 0;
 
  protected:
    JournalArchive( const agx::Name& name, const agx::String& path );
    JournalArchive();
 
    virtual ~JournalArchive();
 
    void setName( const agx::Name& name );
    void setPath( const agx::String& path );
 
    bool registerSession( agxData::JournalArchive::Session* newSession );
 
    bool unregisterSession( agxData::JournalArchive::Session* removedSession );
 
    bool updateSessionAndTableWithNewName( agxData::JournalArchive::Session* session, const agx::Name& newName );
 
    virtual agxData::JournalArchive::Session* makeCopy( agxData::JournalArchive::Session* session ) = 0;
 
  private:
    agx::Name m_name;
    agx::String m_path;
    SessionTable m_sessions;
 
  };
  AGX_DECLARE_POINTER_TYPES(JournalArchive);
 
 
 
  /*
  The JournalArchive::Session class is a handle to a particular session in a journal. Every journal storage format
  that has a JournalArchive subclass should also provide a JournalArchive::Session derivation.
  */
  class AGXCORE_EXPORT JournalArchive::Session : public agx::Referenced
  {
  public:
    static agx::String generateNameFromCurrentDate();
 
  public:
 
    const agx::Name& getName() const;
 
    virtual agx::String getPath() const = 0;
 
 
    agxData::JournalArchive* getJournal();
    const agxData::JournalArchive* getJournal() const;
 
    void setHeaderFormat(SerializedFrame::HeaderFormat format);
 
    SerializedFrame::HeaderFormat getHeaderFormat() const;
 
    virtual bool truncate( agx::UInt firstFrameToRemove ) = 0;
 
 
    bool copyTo( agxData::JournalArchive* target );
 
    bool transferTo( agxData::JournalArchive* target );
 
 
    virtual agx::String getScenePath(bool create = true) const = 0;
 
 
    virtual bool unpackSceneFile() = 0;
 
    virtual bool packSceneData(std::stringstream& sceneData) = 0;
 
    virtual bool unpackSceneData(std::stringstream& sceneData) = 0;
 
    virtual bool packSceneData(std::istream& sceneData) = 0;
 
    virtual bool unpackSceneData(std::ostream& sceneData) = 0;
 
 
    virtual agx::String getCustomFilesPath(bool create = true) const = 0;
 
    virtual bool recordExtraData( const agx::String& key, const agx::String& value ) = 0;
 
    virtual bool retrieveExtraData( const agx::String& key, agx::String& value ) = 0;
    agx::String retrieveExtraData(const agx::String& key);
 
    bool recordExtraDataAsJSon(const agx::String& key, const agx::String& value);
 
    bool retrieveExtraDataAsJSon(const agx::String& key, agx::String& value);
    agx::String retrieveExtraDataAsJSon(const agx::String& key);
 
    virtual agxData::Frame::Header getFrameHeader( agx::UInt frameIndex ) const = 0;
 
    void setFrameIO(agxData::FrameIO* frameIO);
    agxData::FrameIO* getFrameIO();
 
    typedef agxNet::StructuredMessage PlotData;
    typedef agx::ref_ptr<PlotData> PlotDataRef;
    typedef agx::Vector<PlotDataRef> PlotDataRefVector;
 
    virtual void savePlot(const PlotData* plot) = 0;
    virtual void removePlot(const agx::String& plotName) = 0;
    virtual PlotData* getPlot(const agx::String& plotName) = 0;
    virtual void getAllPlots(PlotDataRefVector& result) = 0;
    virtual void getPlotList(agx::StringVector& result) = 0;
 
    virtual agx::UInt getNextFrameIndex(agx::UInt currentFrameIndex, agx::Int offset) const = 0;
 
  public:
    virtual void writeHeader() = 0;
    virtual void finalizeHeader() = 0;
 
    void setDate(agx::Date* date);
    const agx::Date* getDate() const;
 
    void setFirstFrameIndex(agx::UInt64 startFrame);
    agx::UInt64 getFirstFrameIndex() const;
 
    void setFirstFrameTimeStamp(agx::Real64 startTime);
    agx::Real64 getFirstFrameTimeStamp() const;
 
    void setLastFrameIndex(agx::UInt64 endFrame);
    agx::UInt64 getLastFrameIndex() const;
 
    void setLastFrameTimeStamp(agx::Real64 endTime);
    agx::Real64 getLastFrameTimeStamp() const;
 
    void setTimeStep(agx::Real64 timeStep);
    agx::Real64 getTimeStep() const;
 
    void setFrameStride(agx::UInt64 stride);
    agx::UInt64 getFrameStride() const;
 
    void setNumFrames(agx::UInt64 numFrames);
    agx::UInt64 getNumFrames() const;
 
    void setComputationTime(agx::Real64 computationTime);
    agx::Real64 getComputationTime() const;
 
    void setAgxVersionString(const agx::String& version);
    const agx::String& getAgxVersionString() const;
    void setAgxVersionNumber( const agx::UInt32 version);
    agx::UInt32 getAgxVersionNumber() const;
 
    bool is64BitReal() const;
    bool is64BitArchitecture() const;
    bool isLittleEndian() const;
 
    void set64BitReal(bool flag);
    void set64BitArchitecture(bool flag);
    void setLittleEndian(bool flag);
 
    void setSimulationHeader(agx::Component* header);
    agx::Component* getSimulationHeader();
 
  protected:
#ifndef SWIG
    Session( const agx::Name& name );
#endif
    virtual ~Session();
 
    bool rename( const agx::Name& name );
 
  private:
    friend class JournalArchive;
    void setName( const agx::Name& newName );
    void setJournal( agxData::JournalArchive* journal );
 
    virtual bool transferDiskData( agxData::JournalArchive* target ) = 0;
 
 
  private:
    agx::Name m_name;
    agxData::JournalArchive* m_journal;
    agx::DateRef m_date;
    bool m_is64BitReal;
    bool m_is64BitArchitecture;
    bool m_isLittleEndian;
    agx::ComponentRef m_simulationHeader;
    agx::UInt64 m_numFrames;
    agx::UInt64 m_frameStride;
    agx::UInt64 m_startFrame;
    agx::Real64 m_startTime;
    agx::UInt64 m_endFrame;
    agx::Real64 m_endTime;
    agx::Real64 m_timeStep;
    agx::Real64 m_computationTime;
    agx::String m_agxVersionString;
    agx::UInt32 m_agxVersionNumber;
    SerializedFrame::HeaderFormat m_headerFormat;
    agxData::FrameIOObserver m_frameIO;
  };
 
 
 
 
  /* Implementation */
 
  DOXYGEN_START_INTERNAL_BLOCK()
 
  AGX_FORCE_INLINE bool JournalArchive::Session::is64BitReal() const { return m_is64BitReal; }
  AGX_FORCE_INLINE bool JournalArchive::Session::is64BitArchitecture() const { return m_is64BitArchitecture; }
  AGX_FORCE_INLINE bool JournalArchive::Session::isLittleEndian() const { return m_isLittleEndian; }
 
  AGX_FORCE_INLINE const agx::Date* JournalArchive::Session::getDate() const { return m_date; }
  AGX_FORCE_INLINE agx::UInt64 JournalArchive::Session::getFirstFrameIndex() const { return m_startFrame; }
  AGX_FORCE_INLINE agx::Real64 JournalArchive::Session::getFirstFrameTimeStamp() const { return m_startTime; }
  AGX_FORCE_INLINE agx::UInt64 JournalArchive::Session::getLastFrameIndex() const { return m_endFrame; }
  AGX_FORCE_INLINE agx::Real64 JournalArchive::Session::getLastFrameTimeStamp() const { return m_endTime; }
  AGX_FORCE_INLINE agx::Real64 JournalArchive::Session::getTimeStep() const { return m_timeStep; }
  AGX_FORCE_INLINE agx::UInt64 JournalArchive::Session::getFrameStride() const { return m_frameStride; }
  AGX_FORCE_INLINE const agx::String& JournalArchive::Session::getAgxVersionString() const { return m_agxVersionString; }
  AGX_FORCE_INLINE agx::UInt32 JournalArchive::Session::getAgxVersionNumber() const { return m_agxVersionNumber; }
  // AGX_FORCE_INLINE agx::UInt JournalArchive::Session::getNumFrames() const { return m_numFrames; }
  AGX_FORCE_INLINE agx::UInt64 JournalArchive::Session::getNumFrames() const { return m_numFrames; }
  AGX_FORCE_INLINE SerializedFrame::HeaderFormat JournalArchive::Session::getHeaderFormat() const { return m_headerFormat; }
 
  DOXYGEN_END_INTERNAL_BLOCK()
 
}
 
 
#endif /* AGXDATA_JOURNALARCHIVE_H */