TXmlFileSerializerComp.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ACF-Commercial
#pragma once
 
 
// Qt includes
#include <QtCore/QObject>
#include <QtCore/QDir>
 
// ACF includes
#include <istd/CChangeNotifier.h>
#include <istd/CSystem.h>
#include <ibase/IProgressManager.h>
#include <ifile/CFileSerializerCompBase.h>
 
 
namespace ifile
{
 
 
template <class ReadArchive, class WriteArchive>
class TXmlFileSerializerComp: public CFileSerializerCompBase
{
public:       
       typedef CFileSerializerCompBase BaseClass;
 
       I_BEGIN_COMPONENT(TXmlFileSerializerComp);
              I_ASSIGN(m_autoCreateDirectoryAttrPtr, "AutoCreatePath", "Create directory/file path automatically if not exists", true, false);
              I_ASSIGN(m_serializeAcfHeaderAttrPtr, "SerializeAcfHeader", "Enable or disable serializing of standard ACF header with version information", true, true);
              I_ASSIGN(m_rootTagAttrPtr, "RootTag", "XML tag used as document root", true, "Acf");
       I_END_COMPONENT;
 
       // reimplemented (ifile::IFilePersistence)
       virtual ifile::IFilePersistence::OperationState LoadFromFile(
                            istd::IChangeable& data,
                            const QString& filePath = QString(),
                            ibase::IProgressManager* progressManagerPtr = nullptr) const override;
       virtual ifile::IFilePersistence::OperationState SaveToFile(
                            const istd::IChangeable& data,
                            const QString& filePath = QString(),
                            ibase::IProgressManager* progressManagerPtr = nullptr) const override;
 
protected:
       class ReadArchiveEx: public ReadArchive
       {
       public:
              typedef ReadArchive BaseClass;
 
              ReadArchiveEx(const QString& filePath,
                                   bool serializeHeader,
                                   const iser::CArchiveTag& rootTag,
                                   const TXmlFileSerializerComp* loggerPtr)
              :      ReadArchive(filePath, serializeHeader, rootTag),
                     m_loggerPtr(loggerPtr)
              {
              }
 
       protected:
              // reimplemented (istd::ILogger)
              virtual bool IsLogConsumed(
                                   const istd::IInformationProvider::InformationCategory* /*categoryPtr*/,
                                   const int* flagsPtr = nullptr) const override
              {
                     static const istd::IInformationProvider::InformationCategory slaveCategory = istd::IInformationProvider::IC_INFO;
 
                     return (m_loggerPtr != nullptr) && m_loggerPtr->IsLogConsumed(&slaveCategory, flagsPtr);
              }
 
              virtual bool SendLogMessage(
                                   istd::IInformationProvider::InformationCategory category,
                                   int id,
                                   const QString& message,
                                   const QString& messageSource,
                                   int flags = 0) const override
              {
                     if (m_loggerPtr != nullptr){
                            QString correctedMessage = message;
                            QString correctedMessageSource = messageSource;
 
                            BaseClass::DecorateMessage(category, id, flags, correctedMessage, correctedMessageSource);
 
                            return m_loggerPtr->SendLogMessage(istd::IInformationProvider::IC_INFO, id, correctedMessage, correctedMessageSource, flags);
                     }
 
                     return false;
              }
 
       private:
              const TXmlFileSerializerComp* m_loggerPtr;
       };
 
       class WriteArchiveEx: public WriteArchive
       {
       public:
              typedef WriteArchive BaseClass;
 
              WriteArchiveEx(
                                   const QString& filePath,
                                   const iser::IVersionInfo* infoPtr,
                                   bool serializeHeader,
                                   const iser::CArchiveTag& rootTag,
                                   const TXmlFileSerializerComp* loggerPtr)
              :WriteArchive(filePath, infoPtr, serializeHeader, rootTag),
                     m_loggerPtr(loggerPtr)
              {
              }
 
       protected:
              // reimplemented (istd::ILogger)
              virtual bool IsLogConsumed(
                                   const istd::IInformationProvider::InformationCategory* /*categoryPtr*/,
                                   const int* flagsPtr = nullptr) const override
              {
                     static const istd::IInformationProvider::InformationCategory slaveCategory = istd::IInformationProvider::IC_INFO;
 
                     return (m_loggerPtr != nullptr) && m_loggerPtr->IsLogConsumed(&slaveCategory, flagsPtr);
              }
 
              virtual bool SendLogMessage(
                                   istd::IInformationProvider::InformationCategory category,
                                   int id,
                                   const QString& message,
                                   const QString& messageSource,
                                   int flags = 0) const override
              {
                     if (m_loggerPtr != nullptr){
                            QString correctedMessage = message;
                            QString correctedMessageSource = messageSource;
 
                            BaseClass::DecorateMessage(category, id, flags, correctedMessage, correctedMessageSource);
 
                            return m_loggerPtr->SendLogMessage(category, id, correctedMessage, correctedMessageSource, flags);
                     }
 
                     return false;
              }
 
       private:
              const TXmlFileSerializerComp* m_loggerPtr;
       };
 
       virtual void OnReadError(const ReadArchive& archive, const istd::IChangeable& data, const QString& filePath) const;
 
protected:
       I_ATTR(bool, m_autoCreateDirectoryAttrPtr);
       I_ATTR(bool, m_serializeAcfHeaderAttrPtr);
       I_ATTR(QByteArray, m_rootTagAttrPtr);
};
 
 
// public methods
 
// reimplemented (ifile::IFilePersistence)
 
template <class ReadArchive, class WriteArchive>
ifile::IFilePersistence::OperationState TXmlFileSerializerComp<ReadArchive, WriteArchive>::LoadFromFile(
                     istd::IChangeable& data,
                     const QString& filePath,
                     ibase::IProgressManager* /*progressManagerPtr*/) const
{
       if (IsOperationSupported(&data, &filePath, QF_LOAD | QF_FILE, *m_beQuiteOnLoadAttrPtr)){
              iser::CArchiveTag rootTag(*m_rootTagAttrPtr, "Root of document", iser::CArchiveTag::TT_GROUP);
 
              ReadArchiveEx archive(filePath, *m_serializeAcfHeaderAttrPtr, rootTag, this);
 
              Q_ASSERT(!archive.IsStoring());
 
              iser::ISerializable* serializablePtr = dynamic_cast<iser::ISerializable*>(&data);
              if (serializablePtr == nullptr){
                     serializablePtr = CompCastPtr<iser::ISerializable>(&data);
              }
 
              Q_ASSERT(serializablePtr != nullptr);
 
              if (serializablePtr->Serialize(archive)){
                     return OS_OK;
              }
              else{
                     OnReadError(archive, data, filePath);
              }
       }
 
       return OS_FAILED;
}
 
 
template <class ReadArchive, class WriteArchive>
ifile::IFilePersistence::OperationState TXmlFileSerializerComp<ReadArchive, WriteArchive>::SaveToFile(
                     const istd::IChangeable& data,
                     const QString& filePath,
                     ibase::IProgressManager* /*progressManagerPtr*/) const
{
       if (*m_autoCreateDirectoryAttrPtr){
              QFileInfo fileInfo(filePath);
 
              if (!istd::CSystem::EnsurePathExists(fileInfo.dir().absolutePath())){
                     SendErrorMessage(MI_FILE_NOT_EXIST, QObject::tr("Cannot create path to file"));
              }
       }
 
       if (IsOperationSupported(&data, &filePath, QF_SAVE | QF_FILE, false)){
              iser::CArchiveTag rootTag(*m_rootTagAttrPtr, "Root of document", iser::CArchiveTag::TT_GROUP);
 
              WriteArchiveEx archive(filePath, GetVersionInfo(), *m_serializeAcfHeaderAttrPtr, rootTag, this);
              Q_ASSERT(archive.IsStoring());
 
              const iser::ISerializable* serializablePtr = dynamic_cast<const iser::ISerializable*>(&data);
              if(serializablePtr == nullptr){
                     serializablePtr = CompCastPtr<iser::ISerializable>(&data);
              }
              Q_ASSERT(serializablePtr != nullptr);
 
              if (!CheckMinimalVersion(*serializablePtr, archive.GetVersionInfo())){
                     SendWarningMessage(MI_UNSUPPORTED_VERSION, QObject::tr("Archive version is not supported, possible lost of data"));
              }
 
              if ((const_cast<iser::ISerializable*>(serializablePtr))->Serialize(archive)){
                     return OS_OK;
              }
              else{
                     SendInfoMessage(MI_CANNOT_SAVE, QObject::tr("Cannot serialize object to file: '%1'").arg(filePath));
              }
       }
 
       return OS_FAILED;
}
 
 
// protected methods
 
template <class ReadArchive, class WriteArchive>
void TXmlFileSerializerComp<ReadArchive, WriteArchive>::OnReadError(
                     const ReadArchive& /*archive*/,
                     const istd::IChangeable& /*data*/,
                     const QString& filePath) const
{
       SendWarningMessage(MI_CANNOT_LOAD, QString(QObject::tr("Cannot load object from file ")) + filePath);
}
 
 
} // namespace ifile