TMultiPageDocumentWrap.h

Go to the documentation of this file.

/********************************************************************************
**  This file is part of the ICF Framework. Copyright (C) Witold Gantzke & Kirill Lepskiy
**  ICF Framework may be used under the terms of the LGPL License v. 2.1 by the Free Software Foundation.
********************************************************************************/
 
#pragma once
 
 
// Qt includes
#include <QtCore/QList>
 
// ICF includes
#include <istd/CChangeNotifier.h>
#include <iser/IArchive.h>
#include <iser/CArchiveTag.h>
#include <iprm/IOptionsList.h>
#include <idoc/IMultiPageDocument.h>
#include <idoc/IMultiPageDocumentProvider.h>
#include <idoc/CStandardDocumentMetaInfo.h>
 
 
namespace idoc
{
 
 
template <class Base>
class TMultiPageDocumentWrap:
        virtual public Base,
        public CStandardDocumentMetaInfo,
        virtual public iprm::IOptionsList
{
public:
    typedef Base BaseClass;
    typedef CStandardDocumentMetaInfo BaseClass2;
 
    // pseudo-reimplemented (idoc::IMultiPageDocument)
    int GetPagesCount() const override;
    const istd::IChangeable& GetDocumentPage(int pageIndex) const override;
    const idoc::IDocumentMetaInfo* GetPageMetaInfo(int pageIndex) const override;
    void ResetPages() override;
    bool RemovePage(int pageIndex) override;
    const IDocumentMetaInfo& GetDocumentMetaInfo() const override;
 
    // reimplemented (iprm::IOptionsList)
    int GetOptionsFlags() const override;
    int GetOptionsCount() const override;
    QString GetOptionName(int index) const override;
    QString GetOptionDescription(int index) const override;
    QByteArray GetOptionId(int index) const override;
    bool IsOptionEnabled(int index) const override;
 
    // reimplemented (iser::ISerializable)
    bool Serialize(iser::IArchive& archive) override;
 
    // reimplemented (istd::IChangeable)
    bool CopyFrom(const istd::IChangeable& object, CompatibilityMode mode = CM_WITHOUT_REFS) override;
    bool ResetData(CompatibilityMode mode) override;
 
protected:
    struct Page
    {
        idoc::CStandardDocumentMetaInfo pageMetaInfo;
        std::unique_ptr<istd::IChangeable> pagePtr;
    };
 
protected:
    virtual bool SerializePage(iser::IArchive& archive, Page& pageItem);
 
protected:
    typedef std::vector<Page> Pages;
 
    Pages m_documentPages;
};
 
 
// public methods
 
// pseudo-reimplemented (idoc::IMultiPageDocument)
 
template <class Base>
int TMultiPageDocumentWrap<Base>::GetPagesCount() const
{
    return int(m_documentPages.size());
}
 
 
template <class Base>
const istd::IChangeable& TMultiPageDocumentWrap<Base>::GetDocumentPage(int pageIndex) const
{
    Q_ASSERT(pageIndex < int(m_documentPages.size()));
    Q_ASSERT(pageIndex >= 0);
    Q_ASSERT(m_documentPages.at(pageIndex).pagePtr != nullptr);
 
    return *m_documentPages.at(pageIndex).pagePtr.get();
}
 
 
template <class Base>
const idoc::IDocumentMetaInfo* TMultiPageDocumentWrap<Base>::GetPageMetaInfo(int pageIndex) const
{
    Q_ASSERT(pageIndex < int(m_documentPages.size()));
    Q_ASSERT(pageIndex >= 0);
 
    return &m_documentPages.at(pageIndex).pageMetaInfo;
}
 
 
template <class Base>
void TMultiPageDocumentWrap<Base>::ResetPages()
{
    istd::CChangeNotifier changePtr(this);
 
    m_documentPages.clear();
}
 
 
template <class Base>
bool TMultiPageDocumentWrap<Base>::RemovePage(int pageIndex)
{
    Q_ASSERT(pageIndex < int(m_documentPages.size()));
    Q_ASSERT(pageIndex >= 0);
 
    istd::CChangeNotifier changePtr(this);
 
    auto it = m_documentPages.begin();
    it += pageIndex;
    m_documentPages.erase(it);
 
    return true;
}
 
 
template <class Base>
const IDocumentMetaInfo& TMultiPageDocumentWrap<Base>::GetDocumentMetaInfo() const
{
    return *this;
}
 
 
// reimplemented (iprm::IOptionsList)
 
template <class Base>
int TMultiPageDocumentWrap<Base>::GetOptionsFlags() const
{
    return SCF_NONE;
}
 
 
template <class Base>
int TMultiPageDocumentWrap<Base>::GetOptionsCount() const
{
    return GetPagesCount();
}
 
 
template <class Base>
QString TMultiPageDocumentWrap<Base>::GetOptionName(int index) const
{
    Q_ASSERT(index < int(m_documentPages.size()));
    Q_ASSERT(index >= 0);
 
    return m_documentPages[index].pageMetaInfo.GetMetaInfo(idoc::IDocumentMetaInfo::MIT_TITLE).toString();
}
 
 
template <class Base>
QString TMultiPageDocumentWrap<Base>::GetOptionDescription(int /*index*/) const
{
    return QString();
}
 
 
template <class Base>
QByteArray TMultiPageDocumentWrap<Base>::GetOptionId(int index) const
{
    return GetOptionName(index).toUtf8();
}
 
 
template <class Base>
bool TMultiPageDocumentWrap<Base>::IsOptionEnabled(int /*index*/) const
{
    return true;
}
 
 
// reimplemented (iser::ISerializable)
 
template <class Base>
bool TMultiPageDocumentWrap<Base>::Serialize(iser::IArchive& archive)
{
    static iser::CArchiveTag metaInfoTag("MetaInfo", "Meta information about the document", iser::CArchiveTag::Type::Group);
    static iser::CArchiveTag pagesTag("Pages", "Container of the document pages", iser::CArchiveTag::Type::Multiple);
    static iser::CArchiveTag pageTag("Page", "Single document page", iser::CArchiveTag::Type::Group, &pagesTag);
 
    istd::CChangeNotifier changePtr(archive.IsChanging() ? this : nullptr);
 
    // Serialize meta info:
    bool isMetaInfoOk = archive.ProcessGroup(metaInfoTag,
        [&](auto& archive) {
            return BaseClass2::Serialize(archive);
        });
 
    // Serialize document pages:
    return isMetaInfoOk && archive.ProcessGroupList(pagesTag, pageTag, GetPagesCount(),
        [&](int pageIndex, auto& archive) {
            this->InsertPage(nullptr, nullptr, pageIndex);
 
            return SerializePage(archive, m_documentPages[pageIndex]);
        },
        [&](int pagesCount) {
            if (pagesCount <= 0) {
                ResetPages();
            }
            else {
                int oldCount = GetPagesCount();
                for (int i = pagesCount - 1; i >= oldCount; --i) {
                    RemovePage(i);
                }
                for (int i = oldCount; i < pagesCount; ++i) {
                    this->InsertPage(nullptr, nullptr, i);
                }
            }
 
            return true;
        });
}
 
 
// reimplemented (istd::IChangeable)
 
template <class Base>
bool TMultiPageDocumentWrap<Base>::CopyFrom(const istd::IChangeable& object, CompatibilityMode mode)
{
    // native copy
    const TMultiPageDocumentWrap<Base>* sourcePtr = dynamic_cast<const TMultiPageDocumentWrap<Base>*>(&object);
    if (sourcePtr != nullptr) {
        istd::CChangeNotifier changePtr(this);
 
        m_documentPages.clear();
 
        for (auto& sourcePageInfo : sourcePtr->m_documentPages) {
            Q_ASSERT(sourcePageInfo.pagePtr != nullptr);
 
            istd::IChangeable* pagePtr = this->InsertPage();
            if (pagePtr == nullptr) {
                return false;
            }
 
            if (!pagePtr->CopyFrom(*sourcePageInfo.pagePtr)) {
                return false;
            }
 
            if (!m_documentPages[m_documentPages.size()].pageMetaInfo.CopyFrom(sourcePageInfo.pageMetaInfo)) {
                return false;
            }
        }
 
        if (!BaseClass2::CopyFrom(object, mode)) {
            return false;
        }
 
        return true;
    }
 
    // copy via idoc::IMultiPageDocument
    const idoc::IMultiPageDocument* docPtr = dynamic_cast<const idoc::IMultiPageDocument*>(&object);
    if (docPtr != nullptr) {
        istd::CChangeNotifier changePtr(this);
 
        m_documentPages.clear();
 
        int pagesCount = docPtr->GetPagesCount();
        for (int pageIndex = 0; pageIndex < pagesCount; ++pageIndex) {
            istd::IChangeable* pagePtr = this->InsertPage();
            if (pagePtr == nullptr) {
                return false;
            }
 
            const istd::IChangeable& sourcePage = docPtr->GetDocumentPage(pageIndex);
            if (!pagePtr->CopyFrom(sourcePage)) {
                return false;
            }
 
            const idoc::IDocumentMetaInfo* metaInfoPtr = docPtr->GetPageMetaInfo(pageIndex);
            if (metaInfoPtr != nullptr) {
                if (!m_documentPages[pageIndex].pageMetaInfo.CopyFrom(*metaInfoPtr)) {
                    return false;
                }
            }
        }
 
        if (!BaseClass2::CopyFrom(object, mode)) {
            return false;
        }
 
        return true;
    }
 
    // copy via idoc::IMultiPageDocumentProvider
    const idoc::IMultiPageDocumentProvider* docProviderPtr = dynamic_cast<const idoc::IMultiPageDocumentProvider*>(&object);
    if (docProviderPtr != nullptr) {
        const idoc::IMultiPageDocument* sourceDocPtr = docProviderPtr->GetDocument();
        if (sourceDocPtr != nullptr) {
            // recursive call
            return CopyFrom(*sourceDocPtr, mode);
        }
    }
 
    return false;
}
 
 
template <class Base>
bool TMultiPageDocumentWrap<Base>::ResetData(CompatibilityMode /*mode*/)
{
    ResetPages();
 
    return true;
}
 
 
// protected methods
 
template <class Base>
bool TMultiPageDocumentWrap<Base>::SerializePage(iser::IArchive& archive, Page& pageItem)
{
    static iser::CArchiveTag pageTitleTag("PageTitle", "Title of the page", iser::CArchiveTag::Type::Group);
    static iser::CArchiveTag pageContentTag("PageContent", "The contents of the page", iser::CArchiveTag::Type::Group);
 
    bool retVal = archive.ProcessObject(pageTitleTag, pageItem.pageMetaInfo);
 
    iser::ISerializable* serializablePagePtr = dynamic_cast<iser::ISerializable*>(pageItem.pagePtr.get());
    if (serializablePagePtr != nullptr) {
        retVal = retVal && archive.ProcessObject(pageContentTag, *serializablePagePtr);
    }
    else {
        qWarning("Page object doesn't support serialization");
 
        return false;
    }
 
    return retVal;
}
 
 
typedef idoc::TMultiPageDocumentWrap<idoc::IMultiPageDocument> CMultiPageDocumentBase;
 
 
} // namespace idoc