StorageStream.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.
*/
 
#pragma once
 
#include <agx/agxPhysics_export.h>
#include <iostream>
#include <agx/Vec3.h>
#include <agx/AffineMatrix4x4.h>
#include <stack>
#include <memory>
 
namespace agx
{
  class RigidBody;
}
 
namespace agxWire
{
  class Node;
}
 
namespace agxCollide
{
  class Geometry;
}
 
namespace agxStream
{
  class AGXPHYSICS_EXPORT StorageStream
  {
  public:
 
    enum Mode
    {
      RESTORE,
      STORE
    };
 
    enum FloatMode
    {
      AS_DOUBLE = 0,
      AS_FLOAT = 1
    };
 
    StorageStream(Mode mode, bool useBlocks=false);
 
    virtual ~StorageStream();
 
    bool read(const agx::Vector<char>& buffer);
 
    bool write(agx::Vector<char>& buffer);
 
    void clear();
 
    enum Status
    {
      SUCCESS,
      MISSING_BODY,
      MISSING_GEOMETRY,
      INVALID_MD5,
      INVALID_HEADER,
      ERROR_WRITING_TO_OUTSTREAM,
      ERROR_READING_FROM_INSTREAM,
      ERROR_WRITING_TO_DATASTREAM,
      ERROR_READING_FROM_DATASTREAM,
      MIXING_MODES
    };
 
    agx::UInt32 getVersion() const;
 
    agx::UInt16 getSerializationVersion() const;
 
    agx::UInt16 getStorageStreamVersion() const;
 
    Status getStatus() const { return m_status; }
#ifndef SWIG
    virtual bool read(agx::RigidBody** body);
 
    virtual bool write(agx::RigidBody* body);
 
    virtual bool read(agxCollide::Geometry** geometry);
 
    virtual bool write(agxCollide::Geometry* geometry);
 
    virtual bool read(agxWire::Node* node);
 
    virtual bool write(agxWire::Node* node);
 
    virtual std::ostream& write(std::ostream& str);
 
    virtual std::istream& read(std::istream& str);
 
    inline Mode getMode() const;
 
    AGXPHYSICS_EXPORT friend std::ostream& operator<<(std::ostream& str, StorageStream& storage);
    AGXPHYSICS_EXPORT friend std::istream& operator>>(std::istream& str, StorageStream& storage);
 
    // --------- Restoring/reading
    virtual void read(agx::UInt8& val);
    virtual void read(agx::UInt16& val);
    virtual void read(agx::UInt64& val);
    virtual void read(agx::Int32& val);
 
    virtual void read(char& val);
    virtual void read(bool& val);
 
    virtual void read(float& val, bool readAsFloat = false);
    virtual void read(double& val, bool readAsFloat = false);
 
    virtual void read(std::string& val);
 
    virtual void read(agx::Vec3d& val, bool readAsFloat = false);
 
    virtual void read(agx::Vec3f& val, bool readAsFloat = false);
 
    virtual void read(agx::Quat64& val, bool readAsFloat = false);
 
    virtual void read(agx::Quat32& val, bool readAsFloat = false);
 
    virtual void read(agx::AffineMatrix4x4d& val, bool readAsFloat = false);
 
    virtual void read(agx::AffineMatrix4x4f& val, bool readAsFloat = false);
 
    // -------- Storing/writing
    virtual void write(agx::UInt8 val);
    virtual void write(agx::UInt16 val);
    virtual void write(agx::UInt64 val);
    virtual void write(agx::Int32  val);
 
    virtual void write(char val);
    virtual void write(bool val);
 
 
    virtual void write(float  val, FloatMode writeAsFloat = AS_FLOAT);
 
    virtual void write(double val, FloatMode writeAsFloat = AS_DOUBLE);
 
    virtual void write(const std::string& val);
 
    virtual void write(const agx::Vec3d& val, FloatMode writeAsFloat = AS_DOUBLE);
 
    virtual void write(const agx::Vec3f& val, FloatMode writeAsFloat = AS_DOUBLE);
 
    virtual void write(const agx::Quat64& val, FloatMode writeAsFloat = AS_DOUBLE);
 
    virtual void write(const agx::Quat32& val, FloatMode writeAsFloat = AS_DOUBLE);
 
    virtual void write(const agx::AffineMatrix4x4d& val, FloatMode writeAsFloat = AS_DOUBLE);
 
    virtual void write(const agx::AffineMatrix4x4f& val, FloatMode writeAsFloat = AS_DOUBLE);
 
    void beginBlock(const char* blockName);
 
    bool endBlock(const char* blockName);
 
    void skipBlock(const char* blockName);
 
    bool good() const;
 
    class AGXPHYSICS_EXPORT ScopedBlock
    {
      public:
        ScopedBlock(StorageStream& stream, const char* blockName);
        ~ScopedBlock();
       private:
        ScopedBlock(const ScopedBlock&);
        ScopedBlock& operator=(const ScopedBlock&);
      private:
        StorageStream& m_stream;
        const char* m_blockName;
    };
 
    void setEnableMD5(bool flag) { m_checkMD5 = flag; }
 
    bool getEnableMD5() const { return m_checkMD5; }
 
    std::stringstream &getStream();
    const std::stringstream &getStream() const;
 
#endif /* SWIG */
  protected:
 
    void readHeader(std::istream& str);
    void writeHeader(std::ostream& str, const char* data);
 
 
    void checkMD5();
 
    void checkMode(Mode newMode);
 
    StorageStream(const StorageStream&) {}
    StorageStream() {}
 
 
  private:
 
    // Internal class for storing stack of blocks
    class AGXPHYSICS_EXPORT StorageStack
    {
    public:
 
      StorageStack(std::shared_ptr<std::stringstream> root);
      StorageStack() { agxAbort(); }
 
      virtual ~StorageStack();
 
      std::string name() const;
 
      std::shared_ptr<std::stringstream> top();
 
      std::shared_ptr<const std::stringstream> top() const;
 
      uint32_t size() { return uint32_t(m_stack.size()); }
 
      void push(const std::string& blockName, std::shared_ptr<std::stringstream>);
 
      void pop();
 
      void clear(std::shared_ptr <std::stringstream> root);
 
      uint32_t numBytes();
      std::shared_ptr<std::stringstream> getNewStream();
 
 
      void flush();
 
    protected:
 
      void writeBuffer(const char* data, size_t numBytes, std::stringstream* stream);
 
      typedef std::stack<std::pair<std::string, std::shared_ptr<std::stringstream> > > StreamStack;
      StreamStack m_stack;
      std::shared_ptr<std::stringstream> m_root;
      std::stack<std::shared_ptr<std::stringstream> > m_streamPool;
 
      agx::VectorPOD<char> m_writeBuffer;
      agx::UInt32 m_bufferPosition;
      agx::UInt32 m_bufferSize;
 
    };
 
  private:
 
 
    bool m_checkMD5;
 
    std::string m_md5;
    agx::UInt8 m_generation, m_major, m_minor, m_patch;
    agx::UInt16 m_serializationVersion;
    agx::UInt16 m_storageStreamVersion;
 
    Status m_status;
    Mode m_mode;
 
    std::shared_ptr<std::stringstream> m_data;
    agx::UInt32 m_dataSize;
 
    StorageStack m_stack;
    bool m_useBlocks;
  };
 
  AGXPHYSICS_EXPORT std::ostream& operator<<(std::ostream& str, StorageStream& storage);
  AGXPHYSICS_EXPORT std::istream& operator>>(std::istream& str, StorageStream& storage);
 
  inline bool StorageStream::read(agx::RigidBody ** /*body*/) { return false; }
  inline bool StorageStream::write(agx::RigidBody * /*body*/) { return false; }
  inline bool StorageStream::read(agxCollide::Geometry ** /*geometry*/) { return false; }
  inline bool StorageStream::write(agxCollide::Geometry * /*geometry*/) { return false; }
  inline bool StorageStream::read(agxWire::Node * /*node*/) { return false; }
  inline bool StorageStream::write(agxWire::Node * /*node*/) { return false; }
 
 
  // ------------------- Reading
  inline StorageStream& operator>>(StorageStream& in, agx::UInt8& val)
  {
    in.read(val);
    return in;
  }
 
  inline StorageStream& operator>>(StorageStream& in, agx::UInt16& val)
  {
    in.read(val);
    return in;
  }
 
  inline StorageStream& operator>>(StorageStream& in, char& val)
  {
    in.read(val);
    return in;
  }
 
  inline StorageStream& operator>>(StorageStream& in, bool& val)
  {
    in.read(val);
    return in;
  }
 
  inline StorageStream& operator>>(StorageStream& in, int& val)
  {
    int32_t readVal = 0;
    in.read(readVal);
    val = int(readVal);
    return in;
  }
 
  inline StorageStream& operator>>(StorageStream& in, size_t& val)
  {
    uint64_t readVal = 0;
    in.read(readVal);
    val = size_t(readVal);
    return in;
  }
 
#ifdef __APPLE__
  inline StorageStream& operator>>(StorageStream& in, agx::UInt& val)
  {
    uint64_t readVal = 0;
    in.read(readVal);
    val = agx::UInt(readVal);
    return in;
  }
#endif
 
  inline StorageStream& operator>>(StorageStream& in, float& val)
  {
    in.read(val);
    return in;
  }
 
  inline StorageStream& operator>>(StorageStream& in, double& val)
  {
    in.read(val);
    return in;
  }
 
  inline StorageStream& operator>>(StorageStream& in, std::string& val)
  {
    in.read(val);
    return in;
  }
 
  inline StorageStream& operator>>(StorageStream& in, agx::RigidBody** rb)
  {
    in.read(rb);
    return in;
  }
 
  inline StorageStream& operator>>(StorageStream& in, agxCollide::Geometry** geometry)
  {
    in.read(geometry);
    return in;
  }
 
  inline StorageStream& operator>>(StorageStream& in, agx::Vec3d& val)
  {
    in.read(val);
    return in;
  }
 
  inline StorageStream& operator>>(StorageStream& in, agx::Vec3f& val)
  {
    in.read(val);
    return in;
  }
 
  inline StorageStream& operator>>(StorageStream& in, agx::Quat64& q)
  {
    in.read(q);
    return in;
  }
 
  inline StorageStream& operator>>(StorageStream& in, agx::Quat32& q)
  {
    in.read(q);
    return in;
  }
 
  inline StorageStream& operator>>(StorageStream& in, agx::AffineMatrix4x4d& val)
  {
    in.read(val);
    return in;
  }
 
  inline StorageStream& operator>>(StorageStream& in, agx::AffineMatrix4x4f& val)
  {
    in.read(val);
    return in;
  }
 
  inline StorageStream& operator>>(StorageStream& in, agxWire::Node* node)
  {
    in.read(node);
    return in;
  }
 
  // ---------------- Writing
  inline StorageStream& operator<<(StorageStream& out, agx::UInt8 val)
  {
    out.write(val);
    return out;
  }
 
  inline StorageStream& operator<<(StorageStream& out, agx::UInt16 val)
  {
    out.write(val);
    return out;
  }
 
 
  inline StorageStream& operator<<(StorageStream& out, char val)
  {
    out.write(val);
    return out;
  }
 
  inline StorageStream& operator<<(StorageStream& out, bool val)
  {
    out.write(val);
    return out;
  }
 
 
  inline StorageStream& operator<<(StorageStream& out, int val)
  {
    out.write(int32_t(val));
    return out;
  }
 
  inline StorageStream& operator<<(StorageStream& out, size_t val)
  {
    out.write(uint64_t(val));
    return out;
  }
 
#ifdef __APPLE__
  inline StorageStream& operator<<(StorageStream& out, agx::UInt val)
  {
    out.write(uint64_t(val));
    return out;
  }
#endif
 
  inline StorageStream& operator<<(StorageStream& out, float val)
  {
    out.write(val);
    return out;
  }
 
  inline StorageStream& operator<<(StorageStream& out, double val)
  {
    out.write(val);
    return out;
  }
 
  inline StorageStream& operator<<(StorageStream& out, const std::string& val)
  {
    out.write(val);
    return out;
  }
 
  inline StorageStream& operator<<(StorageStream& out, const agx::RigidBody* rb)
  {
    out.write(const_cast< agx::RigidBody* >(rb));
    return out;
  }
 
  inline StorageStream& operator<<(StorageStream& out, const agxCollide::Geometry* geometry)
  {
    out.write(const_cast< agxCollide::Geometry* >(geometry));
    return out;
  }
 
  inline StorageStream& operator<<(StorageStream& out, const agx::AffineMatrix4x4f& v)
  {
    out.write(v);
    return out;
  }
 
  inline StorageStream& operator<<(StorageStream& out, const agx::AffineMatrix4x4d& v)
  {
    out.write(v);
    return out;
  }
 
  inline StorageStream& operator<<(StorageStream& out, const agx::Vec3d& v)
  {
    out.write(v);
    return out;
  }
 
  inline StorageStream& operator<<(StorageStream& out, const agx::Vec3f& v)
  {
    out.write(v);
    return out;
  }
 
  inline StorageStream& operator<<(StorageStream& out, const agx::Quat64& q)
  {
    out.write(q);
    return out;
  }
 
  inline StorageStream& operator<<(StorageStream& out, const agx::Quat32& q)
  {
    out.write(q);
    return out;
  }
 
  inline StorageStream& operator<<(StorageStream& out, const agxWire::Node* node)
  {
    out.write(const_cast< agxWire::Node* >(node));
    return out;
  }
 
  inline StorageStream::Mode StorageStream::getMode() const
  {
    return m_mode;
  }
} // namespace agxStream