Serializable.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/agxCore_export.h>
 
#include <agx/Integer.h>
#include <functional>
#include <agxStream/StorageAgent.h>
#include <agx/Uuid.h>
 
namespace agxStream
{
  class InputArchive;
  class OutputArchive;
  class StorageAgent;
  class StorageStream;
 
  class AGXCORE_EXPORT Serializable
  {
    public:
 
#if !defined(SWIG)
      virtual ~Serializable();
#endif
 
      void setFinished();
 
      bool isFinished() const;
 
      agx::Uuid getUuid() const;
 
      void setUuid( const agx::Uuid& uuid );
 
      agx::UInt32 getIndex() const;
 
      void setEnableSerialization( bool flag );
 
      bool getEnableSerialization( ) const;
 
#ifndef SWIG
      virtual StorageAgent* getStorageAgent() const = 0;
 
      virtual const char* getClassName() const;
#endif // SWIG
 
      static void setEnableUuidGeneration( bool flag );
 
      bool getEnableUuidGeneration( );
 
    public:
      DOXYGEN_START_INTERNAL_BLOCK()
 
#ifndef SWIG
      virtual void storeLightData( agxStream::StorageStream& ) const {}
 
      virtual void restoreLightData( agxStream::StorageStream& ) {}
 
      bool _store( agxStream::OutputArchive& out ) const;
      void _restore( agxStream::InputArchive& in );
      DOXYGEN_END_INTERNAL_BLOCK()
#endif
    protected:
 
#if defined(SWIG)
      virtual ~Serializable();
#endif
 
      DOXYGEN_START_INTERNAL_BLOCK()
 
      
      void setDynamicallyAllocated();
 
      bool isDynamicallyAllocated() const;
 
 
#ifndef SWIG
      virtual void store( agxStream::OutputArchive& out ) const = 0;
      virtual void restore( agxStream::InputArchive& in ) = 0;
#endif
 
      friend class InputArchive;
      friend class OutputArchive;
 
      void setArchive( InputArchive* archive );
 
      InputArchive* getArchive( );
      DOXYGEN_END_INTERNAL_BLOCK()
 
    private:
      int m_flags;
      static StorageAgent* s_storageAgent;
 
      enum {
        FINISHED = 1,
        DYNAMICALLY_ALLOCATED = 2
      };
 
    protected:
      Serializable();
 
      void generateUuid();
 
      Serializable(const Serializable& other);
 
    private:
      agx::observer_ptr<agx::Referenced> m_archive;
 
      agx::Uuid m_uuid;
      agx::UInt32 m_index;
      bool m_serializationEnabled;
      static bool s_uuidGeneration_enabled;
  };
#ifndef SWIG
#define AGXSTREAM_CLASS_NAME(T) \
 \
  inline const char* getClassName() const override { return #T; } \
 
 
#define AGXSTREAM_DECLARE_SERIALIZABLE_BASE( T ) \
  inline agxStream::StorageAgent* getStorageAgent() const override { return agxStream::StorageManager::instance()->find( #T );  } \
  inline static const char* getConstructClassId() { return #T; } \
  friend class agxStream::DefStorageAgent<T>; \
  AGXSTREAM_CLASS_NAME(T) \
  static agxStream::Serializable *create() { return new T(); } \
  virtual void store( agxStream::OutputArchive& out ) const override;\
  virtual void restore( agxStream::InputArchive& in ) override
 
#define AGXSTREAM_DECLARE_SERIALIZABLE( T ) \
  AGXSTREAM_DECLARE_SERIALIZABLE_BASE(T); \
  static agxStream::Serializable *create(agxStream::InputArchive& /*in*/) { return new T(); }
 
#define AGXSTREAM_DECLARE_SERIALIZABLE_CUSTOM_CREATE( T ) \
  AGXSTREAM_DECLARE_SERIALIZABLE_BASE(T); \
  static agxStream::Serializable *create(agxStream::InputArchive& in)
 
#define AGXSTREAM_DECLARE_ABSTRACT_SERIALIZABLE( T ) \
  inline agxStream::StorageAgent* getStorageAgent() const override { return agxStream::StorageManager::instance()->find(#T); } \
  inline static const char* getConstructClassId() { return  #T; } \
  AGXSTREAM_CLASS_NAME(T)
 
#define AGXSTREAM_INSTANTIATE_STORAGE( C ) \
  static agxStream::Storage<C> storage ## C;
 
#define AGXSTREAM_INSTANTIATE_STORAGE_VARIABLE( V,C ) \
  static agxStream::Storage<C> storage ## V;
 
 // Macro for delaying expansion of comma (,) in a macro argument. This allows for submitting arguments such as: "first", "second" etc..
#define AGXARCHIVE_MODIFICATIONS(...) {__VA_ARGS__}
 
 
#define AGXSTREAM_INSTANTIATE_STORAGE_DEPRECATION_CHECK_VARIABLE( VARIABLE, NEW_CLASS, DEPRECATED_CLASS, MODIFICATION_LIST ) \
  static agxStream::DeprecatedStorage<NEW_CLASS, DEPRECATED_CLASS> VARIABLE(MODIFICATION_LIST);
 
#define AGXSTREAM_INSTANTIATE_STORAGE_DEPRECATED_CLASS( VARIABLE, NAMESPACE, CLASS_NAME, DEPRECATED_CLASS_NAME ) \
namespace NAMESPACE { \
\
   class CLASS_NAME : public DEPRECATED_CLASS_NAME \
  {  \
  public:  \
    CLASS_NAME() {} \
    AGXSTREAM_DECLARE_SERIALIZABLE(NAMESPACE::CLASS_NAME); \
  }; \
  void CLASS_NAME::store(agxStream::OutputArchive&) const { LOGGER_ERROR() << #NAMESPACE << "::" << #CLASS_NAME << " is deprecated and should never be stored" << LOGGER_ENDL(); } \
  void CLASS_NAME::restore(agxStream::InputArchive&) { LOGGER_ERROR() << #NAMESPACE << "::" << #CLASS_NAME << " is deprecated and should never be restored" << LOGGER_ENDL(); }  \
} \
static agxStream::DeprecatedStorage<NAMESPACE::CLASS_NAME, DEPRECATED_CLASS_NAME> VARIABLE(AGXARCHIVE_MODIFICATIONS("\\-##-//83ddfJ4Dj"));
 
 
 
  AGX_FORCE_INLINE agx::UInt32 Serializable::getIndex() const
  {
    return m_index;
  }
 
  AGX_FORCE_INLINE bool Serializable::isFinished() const
  {
    return (m_flags & FINISHED) != 0;
  }
 
  AGX_FORCE_INLINE bool Serializable::isDynamicallyAllocated() const
  {
    return (m_flags & DYNAMICALLY_ALLOCATED) != 0;
  }
 
 
 
 
  AGX_FORCE_INLINE agx::Uuid Serializable::getUuid() const
  {
    return m_uuid;
  }
 
  AGX_FORCE_INLINE bool Serializable::getEnableSerialization() const
  {
    return m_serializationEnabled;
  }
 
#else
 
  // Prevent swig from seeing macro usage of hidden macros
  #define AGXSTREAM_DECLARE_SERIALIZABLE( T )
  #define AGXSTREAM_DECLARE_ABSTRACT_SERIALIZABLE( T )
  #define AGXSTREAM_DECLARE_SERIALIZABLE_CUSTOM_CREATE( T )
 
#endif // SWIG
} // Namespace agxStream