xerecord.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#pragma once
 
#include "xlconst.hxx"
#include "xestream.hxx"
#include "xlstream.hxx"
#include <salhelper/simplereferenceobject.hxx>
#include <rtl/ref.hxx>
#include <algorithm>
 
// Base classes to export Excel records =======================================
 
class XclExpRecordBase : public salhelper::SimpleReferenceObject
{
public:
    XclExpRecordBase() {}
 
    // this class is stored both ref-counted and by value
    XclExpRecordBase(XclExpRecordBase const &)
        : salhelper::SimpleReferenceObject() {}
    XclExpRecordBase(XclExpRecordBase &&)
        : salhelper::SimpleReferenceObject() {}
    XclExpRecordBase& operator=(XclExpRecordBase const &)
        { return *this; }
    XclExpRecordBase& operator=(XclExpRecordBase &&) noexcept
        { return *this; }
 
    virtual             ~XclExpRecordBase();
 
    virtual void        Save( XclExpStream& rStrm );
    virtual void        SaveXml( XclExpXmlStream& rStrm );
};
 
/*namespace std
{
    template<typename T,
            typename = typename std::enable_if<
                std::is_base_of<XclExpRecordBase,T>::value
              >::type>
    class shared_ptr
    {
        shared_ptr() {}
    };
};*/
 
class XclExpDelegatingRecord : public XclExpRecordBase
{
public:
                        XclExpDelegatingRecord( XclExpRecordBase* pRecord );
                        virtual ~XclExpDelegatingRecord() override;
 
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;
private:
    XclExpRecordBase*   mpRecord;
};
 
class XclExpXmlElementRecord : public XclExpRecordBase
{
public:
    explicit            XclExpXmlElementRecord(sal_Int32 nElement);
    virtual             ~XclExpXmlElementRecord() override;
 
protected:
    sal_Int32           mnElement;
};
 
class XclExpXmlStartElementRecord : public XclExpXmlElementRecord
{
public:
    explicit            XclExpXmlStartElementRecord(sal_Int32 nElement);
    virtual             ~XclExpXmlStartElementRecord() override;
 
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;
};
 
class XclExpXmlEndElementRecord : public XclExpXmlElementRecord
{
public:
    explicit            XclExpXmlEndElementRecord(sal_Int32 nElement);
    virtual             ~XclExpXmlEndElementRecord() override;
 
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;
};
 
class XclExpXmlStartSingleElementRecord : public XclExpXmlElementRecord
{
public:
    explicit            XclExpXmlStartSingleElementRecord(sal_Int32 nElement);
    virtual             ~XclExpXmlStartSingleElementRecord() override;
 
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;
};
 
class XclExpXmlEndSingleElementRecord : public XclExpRecordBase
{
public:
                        XclExpXmlEndSingleElementRecord();
    virtual             ~XclExpXmlEndSingleElementRecord() override;
 
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;
};
 
class XclExpRecord : public XclExpRecordBase
{
public:
    explicit            XclExpRecord(
                            sal_uInt16 nRecId = EXC_ID_UNKNOWN,
                            std::size_t nRecSize = 0 );
 
                        XclExpRecord(XclExpRecord const &) = default;
 
    virtual             ~XclExpRecord() override;
 
    sal_uInt16   GetRecId() const { return mnRecId; }
    std::size_t  GetRecSize() const { return mnRecSize; }
 
    void         SetRecId( sal_uInt16 nRecId ) { mnRecId = nRecId; }
    void         SetRecSize( std::size_t nRecSize ) { mnRecSize = nRecSize; }
    void         AddRecSize( std::size_t nRecSize ) { mnRecSize += nRecSize; }
    void                SetRecHeader( sal_uInt16 nRecId, std::size_t nRecSize );
 
    virtual void        Save( XclExpStream& rStrm ) override;
 
protected:
    virtual void        WriteBody( XclExpStream& rStrm );
 
private:
    std::size_t         mnRecSize;      
    sal_uInt16          mnRecId;        
};
 
class XclExpEmptyRecord : public XclExpRecord
{
public:
    inline explicit     XclExpEmptyRecord( sal_uInt16 nRecId );
};
 
inline XclExpEmptyRecord::XclExpEmptyRecord( sal_uInt16 nRecId ) :
    XclExpRecord( nRecId, 0 )
{
}
 
template< typename Type >
class XclExpValueRecord : public XclExpRecord
{
public:
    explicit     XclExpValueRecord( sal_uInt16 nRecId, const Type& rValue, std::size_t nSize = sizeof( Type ) ) :
                            XclExpRecord( nRecId, nSize ), maValue( rValue ), mnAttribute( -1 ) {}
 
    const Type&  GetValue() const { return maValue; }
    void         SetValue( const Type& rValue ) { maValue = rValue; }
 
    XclExpValueRecord*  SetAttribute( sal_Int32 nId );
 
    void                SaveXml( XclExpXmlStream& rStrm ) override;
 
private:
    virtual void WriteBody( XclExpStream& rStrm ) override { rStrm << maValue; }
    // inlining prevents warning in wntmsci10
 
private:
    Type                maValue;        
    sal_Int32           mnAttribute;    
};
 
template< typename Type >
void XclExpValueRecord< Type >::SaveXml( XclExpXmlStream& rStrm )
{
    if( mnAttribute == -1 )
        return;
    rStrm.WriteAttributes(mnAttribute, OUString::number(maValue));
}
 
template<>
void XclExpValueRecord<double>::SaveXml( XclExpXmlStream& rStrm );
 
template< typename Type >
XclExpValueRecord< Type >* XclExpValueRecord< Type >::SetAttribute( sal_Int32 nId )
{
    mnAttribute = nId;
    return this;
}
 
typedef XclExpValueRecord< sal_uInt16 >     XclExpUInt16Record;
 
typedef XclExpValueRecord< double >         XclExpDoubleRecord;
 
class XclExpBoolRecord : public XclExpRecord
{
public:
    explicit     XclExpBoolRecord( sal_uInt16 nRecId, bool bValue, sal_Int32 nAttribute = -1 ) :
                            XclExpRecord( nRecId, 2 ), mbValue( bValue ), mnAttribute( nAttribute ) {}
 
    bool         GetBool() const { return mbValue; }
 
    virtual void        SaveXml( XclExpXmlStream& rStrm ) override;
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    bool                mbValue;        
    sal_Int32           mnAttribute;    
};
 
class XclExpDummyRecord : public XclExpRecord
{
public:
    explicit            XclExpDummyRecord(
                            sal_uInt16 nRecId, const void* pRecData, std::size_t nRecSize );
 
    void                SetData( const void* pRecData, std::size_t nRecSize );
 
private:
    virtual void        WriteBody( XclExpStream& rStrm ) override;
 
private:
    const void*         mpData;         
};
 
// Future records =============================================================
 
class XclExpFutureRecord : public XclExpRecord
{
public:
    explicit            XclExpFutureRecord( XclFutureRecType eRecType,
                            sal_uInt16 nRecId, std::size_t nRecSize );
 
    virtual void        Save( XclExpStream& rStrm ) override;
 
private:
    XclFutureRecType    meRecType;
};
 
// List of records ============================================================
 
template< typename RecType = XclExpRecordBase >
class XclExpRecordList : public XclExpRecordBase
{
public:
    typedef rtl::Reference< RecType > RecordRefType;
 
    bool         IsEmpty() const { return maRecs.empty(); }
    size_t       GetSize() const { return maRecs.size(); }
 
    bool         HasRecord( size_t nPos ) const
                            { return nPos < maRecs.size(); }
    RecType*     GetRecord( size_t nPos ) const
                            { return nPos < maRecs.size() ? maRecs[ nPos ].get() : nullptr; }
    RecType*     GetFirstRecord() const
                            { return maRecs.empty() ? nullptr : maRecs.front().get(); }
    RecType*     GetLastRecord() const
                            { return maRecs.empty() ? nullptr : maRecs.back().get(); }
 
    void         InsertRecord( RecType* pRec, size_t nPos )
                            { assert(pRec); maRecs.insert( maRecs.begin() + ::std::min( nPos, maRecs.size() ), pRec ); }
    void         InsertRecord( RecordRefType pRec, size_t nPos )
                            { assert(pRec); maRecs.insert( maRecs.begin() + ::std::min( nPos, maRecs.size() ), std::move(pRec) ); }
    void         AppendRecord( RecType* pRec )
                            { if (pRec) maRecs.push_back( pRec ); }
    void         AppendRecord( const RecordRefType& xRec )
                            { if (xRec) maRecs.push_back( xRec.get() ); }
    void         AppendRecord( RecordRefType xRec ) &&
                            { if (xRec) maRecs.push_back( std::move(xRec) ); }
    void         ReplaceRecord( RecType* pRec, size_t nPos )
                            { if (pRec) maRecs[nPos] = pRec; else RemoveRecord( nPos ); }
    void         ReplaceRecord( RecordRefType const & xRec, size_t nPos )
                            { ReplaceRecord(xRec.get(), nPos); }
 
    void         AppendNewRecord( RecType* pRec )
                            { assert(pRec); maRecs.push_back( pRec ); }
    void         AppendNewRecord( RecordRefType const & xRec )
                            { AppendNewRecord(xRec.get()); }
    void         AppendNewRecord( RecordRefType xRec ) &&
                            { assert(xRec); maRecs.append(std::move(xRec)); }
 
    void         RemoveRecord( size_t nPos )
                            { maRecs.erase( maRecs.begin() + nPos ); }
    void         RemoveAllRecords() { maRecs.clear(); }
 
    virtual void Save( XclExpStream& rStrm ) override
    {
        // inlining prevents warning in wntmsci10
        for( typename RecordVec::iterator aIt = maRecs.begin(), aEnd = maRecs.end(); aIt != aEnd; ++aIt )
            (*aIt)->Save( rStrm );
    }
 
    virtual void SaveXml( XclExpXmlStream& rStrm ) override
    {
        // inlining prevents warning in wntmsci10
        for( typename RecordVec::iterator aIt = maRecs.begin(), aEnd = maRecs.end(); aIt != aEnd; ++aIt )
            (*aIt)->SaveXml( rStrm );
    }
 
    void        InvalidateRecord( size_t nPos ) { maRecs[ nPos ] = nullptr; }
    void        RemoveInvalidatedRecords()
    {
        maRecs.erase(
            std::remove_if( maRecs.begin(), maRecs.end(), [](const RecordRefType& xRec) { return xRec == nullptr; } ),
            maRecs.end());
    }
 
private:
    typedef ::std::vector< RecordRefType > RecordVec;
    RecordVec           maRecs;
};
 
class XclExpSubStream : public XclExpRecordList<>
{
public:
    explicit            XclExpSubStream( sal_uInt16 nSubStrmType );
 
    virtual void        Save( XclExpStream& rStrm ) override;
 
private:
    sal_uInt16          mnSubStrmType;  
};
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */