Simplify Sequence iterations in package
Use range-based loops, STL and comphelper functions
Change-Id: Ibd836b9b2df2f30b42f2d7a621188d78f5b53196
Reviewed-on: https://gerrit.libreoffice.org/77246
Tested-by: Jenkins
Reviewed-by: Mike Kaganski <mike.kaganski@collabora.com>
Reviewed-by: Arkadiy Illarionov <qarkai@gmail.com>
diff --git a/package/source/manifest/ManifestExport.cxx b/package/source/manifest/ManifestExport.cxx
index f8c2d03..4b4d57c 100644
--- a/package/source/manifest/ManifestExport.cxx
+++ b/package/source/manifest/ManifestExport.cxx
@@ -111,33 +111,30 @@ ManifestExport::ManifestExport( uno::Reference< xml::sax::XDocumentHandler > con
const OUString sPGP_Name ( PGP_NAME );
::comphelper::AttributeList * pRootAttrList = new ::comphelper::AttributeList;
const uno::Sequence < beans::PropertyValue > *pSequence = rManList.getConstArray();
const sal_uInt32 nManLength = rManList.getLength();
// find the mediatype of the document if any
OUString aDocMediaType;
OUString aDocVersion;
sal_Int32 nRootFolderPropIndex=-1;
for (sal_uInt32 nInd = 0; nInd < nManLength ; nInd++ )
const uno::Sequence<beans::PropertyValue>* pRootFolderPropSeq = nullptr;
for (const uno::Sequence < beans::PropertyValue >& rSequence : rManList)
{
OUString aMediaType;
OUString aPath;
OUString aVersion;
const beans::PropertyValue *pValue = pSequence[nInd].getConstArray();
for (sal_uInt32 j = 0, nNum = pSequence[nInd].getLength(); j < nNum; j++, pValue++)
for (const beans::PropertyValue& rValue : rSequence)
{
if (pValue->Name == sMediaTypeProperty )
if (rValue.Name == sMediaTypeProperty )
{
pValue->Value >>= aMediaType;
rValue.Value >>= aMediaType;
}
else if (pValue->Name == sFullPathProperty )
else if (rValue.Name == sFullPathProperty )
{
pValue->Value >>= aPath;
rValue.Value >>= aPath;
}
else if (pValue->Name == sVersionProperty )
else if (rValue.Name == sVersionProperty )
{
pValue->Value >>= aVersion;
rValue.Value >>= aVersion;
}
if ( !aPath.isEmpty() && !aMediaType.isEmpty() && !aVersion.isEmpty() )
@@ -148,7 +145,7 @@ ManifestExport::ManifestExport( uno::Reference< xml::sax::XDocumentHandler > con
{
aDocMediaType = aMediaType;
aDocVersion = aVersion;
nRootFolderPropIndex = nInd;
pRootFolderPropSeq = &rSequence;
break;
}
}
@@ -217,15 +214,13 @@ ManifestExport::ManifestExport( uno::Reference< xml::sax::XDocumentHandler > con
xHandler->startElement( sManifestElement, xRootAttrList );
const uno::Any *pKeyInfoProperty = nullptr;
if ( nRootFolderPropIndex >= 0 )
if ( pRootFolderPropSeq )
{
// do we have package-wide encryption info?
const beans::PropertyValue *pValue =
pSequence[nRootFolderPropIndex].getConstArray();
for (sal_uInt32 j = 0, nNum = pSequence[nRootFolderPropIndex].getLength(); j < nNum; j++, pValue++)
for (const beans::PropertyValue& rValue : *pRootFolderPropSeq)
{
if (pValue->Name == sKeyInfo )
pKeyInfoProperty = &pValue->Value;
if (rValue.Name == sKeyInfo )
pKeyInfoProperty = &rValue.Value;
}
if ( pKeyInfoProperty )
@@ -242,22 +237,19 @@ ManifestExport::ManifestExport( uno::Reference< xml::sax::XDocumentHandler > con
uno::Sequence< uno::Sequence < beans::NamedValue > > aKeyInfoSequence;
*pKeyInfoProperty >>= aKeyInfoSequence;
const uno::Sequence < beans::NamedValue > *pKeyInfoSequence = aKeyInfoSequence.getConstArray();
const sal_uInt32 nKeyInfoLength = aKeyInfoSequence.getLength();
for (sal_uInt32 nInd = 0; nInd < nKeyInfoLength ; nInd++ )
for (const uno::Sequence<beans::NamedValue>& rKeyInfoSequence : std::as_const(aKeyInfoSequence))
{
uno::Sequence < sal_Int8 > aPgpKeyID;
uno::Sequence < sal_Int8 > aPgpKeyPacket;
uno::Sequence < sal_Int8 > aCipherValue;
const beans::NamedValue *pNValue = pKeyInfoSequence[nInd].getConstArray();
for (sal_uInt32 j = 0, nNum = pKeyInfoSequence[nInd].getLength(); j < nNum; j++, pNValue++)
for (const beans::NamedValue& rNValue : rKeyInfoSequence)
{
if (pNValue->Name == sPgpKeyIDProperty )
pNValue->Value >>= aPgpKeyID;
else if (pNValue->Name == sPgpKeyPacketProperty )
pNValue->Value >>= aPgpKeyPacket;
else if (pNValue->Name == sCipherValueProperty )
pNValue->Value >>= aCipherValue;
if (rNValue.Name == sPgpKeyIDProperty )
rNValue.Value >>= aPgpKeyID;
else if (rNValue.Name == sPgpKeyPacketProperty )
rNValue.Value >>= aPgpKeyPacket;
else if (rNValue.Name == sCipherValueProperty )
rNValue.Value >>= aCipherValue;
}
if (aPgpKeyID.hasElements() && aCipherValue.hasElements() )
@@ -326,55 +318,54 @@ ManifestExport::ManifestExport( uno::Reference< xml::sax::XDocumentHandler > con
}
// now write individual file entries
for (sal_uInt32 i = 0 ; i < nManLength ; i++)
for (const uno::Sequence<beans::PropertyValue>& rSequence : rManList)
{
::comphelper::AttributeList *pAttrList = new ::comphelper::AttributeList;
const beans::PropertyValue *pValue = pSequence[i].getConstArray();
OUString aString;
const uno::Any *pVector = nullptr, *pSalt = nullptr, *pIterationCount = nullptr, *pDigest = nullptr, *pDigestAlg = nullptr, *pEncryptAlg = nullptr, *pStartKeyAlg = nullptr, *pDerivedKeySize = nullptr;
for (sal_uInt32 j = 0, nNum = pSequence[i].getLength(); j < nNum; j++, pValue++)
for (const beans::PropertyValue& rValue : rSequence)
{
if (pValue->Name == sMediaTypeProperty )
if (rValue.Name == sMediaTypeProperty )
{
pValue->Value >>= aString;
rValue.Value >>= aString;
pAttrList->AddAttribute ( sMediaTypeAttribute, sCdataAttribute, aString );
}
else if (pValue->Name == sVersionProperty )
else if (rValue.Name == sVersionProperty )
{
pValue->Value >>= aString;
rValue.Value >>= aString;
// the version is stored only if it is not empty
if ( bAcceptNonemptyVersion && !aString.isEmpty() )
pAttrList->AddAttribute ( sVersionAttribute, sCdataAttribute, aString );
}
else if (pValue->Name == sFullPathProperty )
else if (rValue.Name == sFullPathProperty )
{
pValue->Value >>= aString;
rValue.Value >>= aString;
pAttrList->AddAttribute ( sFullPathAttribute, sCdataAttribute, aString );
}
else if (pValue->Name == sSizeProperty )
else if (rValue.Name == sSizeProperty )
{
sal_Int64 nSize = 0;
pValue->Value >>= nSize;
rValue.Value >>= nSize;
OUStringBuffer aBuffer;
aBuffer.append ( nSize );
pAttrList->AddAttribute ( sSizeAttribute, sCdataAttribute, aBuffer.makeStringAndClear() );
}
else if (pValue->Name == sInitialisationVectorProperty )
pVector = &pValue->Value;
else if (pValue->Name == sSaltProperty )
pSalt = &pValue->Value;
else if (pValue->Name == sIterationCountProperty )
pIterationCount = &pValue->Value;
else if (pValue->Name == sDigestProperty )
pDigest = &pValue->Value;
else if (pValue->Name == sDigestAlgProperty )
pDigestAlg = &pValue->Value;
else if (pValue->Name == sEncryptionAlgProperty )
pEncryptAlg = &pValue->Value;
else if (pValue->Name == sStartKeyAlgProperty )
pStartKeyAlg = &pValue->Value;
else if (pValue->Name == sDerivedKeySizeProperty )
pDerivedKeySize = &pValue->Value;
else if (rValue.Name == sInitialisationVectorProperty )
pVector = &rValue.Value;
else if (rValue.Name == sSaltProperty )
pSalt = &rValue.Value;
else if (rValue.Name == sIterationCountProperty )
pIterationCount = &rValue.Value;
else if (rValue.Name == sDigestProperty )
pDigest = &rValue.Value;
else if (rValue.Name == sDigestAlgProperty )
pDigestAlg = &rValue.Value;
else if (rValue.Name == sEncryptionAlgProperty )
pEncryptAlg = &rValue.Value;
else if (rValue.Name == sStartKeyAlgProperty )
pStartKeyAlg = &rValue.Value;
else if (rValue.Name == sDerivedKeySizeProperty )
pDerivedKeySize = &rValue.Value;
}
xHandler->ignorableWhitespace ( sWhiteSpace );
diff --git a/package/source/xstor/ocompinstream.cxx b/package/source/xstor/ocompinstream.cxx
index 52565b7..ac4e3f1 100644
--- a/package/source/xstor/ocompinstream.cxx
+++ b/package/source/xstor/ocompinstream.cxx
@@ -21,6 +21,7 @@
#include <com/sun/star/embed/StorageFormats.hpp>
#include <com/sun/star/io/IOException.hpp>
#include <com/sun/star/lang/DisposedException.hpp>
#include <comphelper/sequence.hxx>
#include <cppuhelper/queryinterface.hxx>
#include <osl/diagnose.h>
#include <sal/log.hxx>
@@ -285,6 +286,17 @@ sal_Bool SAL_CALL OInputCompStream::hasByID( const OUString& sID )
return false;
}
namespace
{
const beans::StringPair* lcl_findPairByName(const uno::Sequence<beans::StringPair>& rSeq, const OUString& rName)
{
return std::find_if(rSeq.begin(), rSeq.end(),
[&rName](const beans::StringPair& rPair) { return rPair.First == rName; });
}
}
OUString SAL_CALL OInputCompStream::getTargetByID( const OUString& sID )
{
::osl::MutexGuard aGuard( m_xMutex->GetMutex() );
@@ -298,10 +310,10 @@ OUString SAL_CALL OInputCompStream::getTargetByID( const OUString& sID )
if ( m_nStorageType != embed::StorageFormats::OFOPXML )
throw uno::RuntimeException();
uno::Sequence< beans::StringPair > aSeq = getRelationshipByID( sID );
for ( sal_Int32 nInd = 0; nInd < aSeq.getLength(); nInd++ )
if ( aSeq[nInd].First == "Target" )
return aSeq[nInd].Second;
const uno::Sequence< beans::StringPair > aSeq = getRelationshipByID( sID );
auto pRel = lcl_findPairByName(aSeq, "Target");
if (pRel != aSeq.end())
return pRel->Second;
return OUString();
}
@@ -319,10 +331,10 @@ OUString SAL_CALL OInputCompStream::getTypeByID( const OUString& sID )
if ( m_nStorageType != embed::StorageFormats::OFOPXML )
throw uno::RuntimeException();
uno::Sequence< beans::StringPair > aSeq = getRelationshipByID( sID );
for ( sal_Int32 nInd = 0; nInd < aSeq.getLength(); nInd++ )
if ( aSeq[nInd].First == "Type" )
return aSeq[nInd].Second;
const uno::Sequence< beans::StringPair > aSeq = getRelationshipByID( sID );
auto pRel = lcl_findPairByName(aSeq, "Type");
if (pRel != aSeq.end())
return pRel->Second;
return OUString();
}
@@ -341,15 +353,13 @@ uno::Sequence< beans::StringPair > SAL_CALL OInputCompStream::getRelationshipByI
throw uno::RuntimeException();
// TODO/LATER: in future the unification of the ID could be checked
uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
for ( sal_Int32 nInd1 = 0; nInd1 < aSeq.getLength(); nInd1++ )
for ( sal_Int32 nInd2 = 0; nInd2 < aSeq[nInd1].getLength(); nInd2++ )
if ( aSeq[nInd1][nInd2].First == "Id" )
{
if ( aSeq[nInd1][nInd2].Second == sID )
return aSeq[nInd1];
break;
}
const uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
const beans::StringPair aIDRel("Id", sID);
auto pRel = std::find_if(aSeq.begin(), aSeq.end(),
[&aIDRel](const uno::Sequence<beans::StringPair>& rRel){
return std::find(rRel.begin(), rRel.end(), aIDRel) != rRel.end(); });
if (pRel != aSeq.end())
return *pRel;
throw container::NoSuchElementException();
}
@@ -367,24 +377,17 @@ uno::Sequence< uno::Sequence< beans::StringPair > > SAL_CALL OInputCompStream::g
if ( m_nStorageType != embed::StorageFormats::OFOPXML )
throw uno::RuntimeException();
uno::Sequence< uno::Sequence< beans::StringPair > > aResult;
sal_Int32 nEntriesNum = 0;
// TODO/LATER: in future the unification of the ID could be checked
uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
for ( sal_Int32 nInd1 = 0; nInd1 < aSeq.getLength(); nInd1++ )
for ( sal_Int32 nInd2 = 0; nInd2 < aSeq[nInd1].getLength(); nInd2++ )
if ( aSeq[nInd1][nInd2].First == "Type" )
{
if ( aSeq[nInd1][nInd2].Second == sType )
{
aResult.realloc( nEntriesNum );
aResult[nEntriesNum-1] = aSeq[nInd1];
}
break;
}
const uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
const beans::StringPair aTypeRel("Type", sType);
std::vector< uno::Sequence<beans::StringPair> > aResult;
aResult.reserve(aSeq.getLength());
return aResult;
std::copy_if(aSeq.begin(), aSeq.end(), std::back_inserter(aResult),
[&aTypeRel](const uno::Sequence<beans::StringPair>& rRel) {
return std::find(rRel.begin(), rRel.end(), aTypeRel) != rRel.end(); });
return comphelper::containerToSequence(aResult);
}
uno::Sequence< uno::Sequence< beans::StringPair > > SAL_CALL OInputCompStream::getAllRelationships()
@@ -401,15 +404,14 @@ uno::Sequence< uno::Sequence< beans::StringPair > > SAL_CALL OInputCompStream::g
throw uno::RuntimeException();
// TODO/LATER: in future the information could be taken directly from m_pImpl when possible
uno::Sequence< uno::Sequence< beans::StringPair > > aResult;
for ( sal_Int32 aInd = 0; aInd < m_aProperties.getLength(); aInd++ )
if ( m_aProperties[aInd].Name == "RelationsInfo" )
{
if ( m_aProperties[aInd].Value >>= aResult )
return aResult;
break;
}
auto pProp = std::find_if(std::cbegin(m_aProperties), std::cend(m_aProperties),
[](const beans::PropertyValue& rProp) { return rProp.Name == "RelationsInfo"; });
if (pProp != std::cend(m_aProperties))
{
uno::Sequence< uno::Sequence< beans::StringPair > > aResult;
if (pProp->Value >>= aResult)
return aResult;
}
throw io::IOException(); // the relations info could not be read
}
@@ -503,13 +505,9 @@ void SAL_CALL OInputCompStream::setPropertyValue( const OUString& aPropertyName,
}
// all the provided properties are accessible
for ( sal_Int32 aInd = 0; aInd < m_aProperties.getLength(); aInd++ )
{
if ( m_aProperties[aInd].Name == aPropertyName )
{
throw beans::PropertyVetoException(); // TODO
}
}
if (std::any_of(std::cbegin(m_aProperties), std::cend(m_aProperties),
[&aPropertyName](const beans::PropertyValue& rProp) { return rProp.Name == aPropertyName; }))
throw beans::PropertyVetoException(); // TODO
throw beans::UnknownPropertyException(); // TODO
}
@@ -534,13 +532,10 @@ uno::Any SAL_CALL OInputCompStream::getPropertyValue( const OUString& aProp )
throw beans::UnknownPropertyException(); // TODO
// all the provided properties are accessible
for ( sal_Int32 aInd = 0; aInd < m_aProperties.getLength(); aInd++ )
{
if ( m_aProperties[aInd].Name == aPropertyName )
{
return m_aProperties[aInd].Value;
}
}
auto pProp = std::find_if(std::cbegin(m_aProperties), std::cend(m_aProperties),
[&aPropertyName](const beans::PropertyValue& rProp) { return rProp.Name == aPropertyName; });
if (pProp != std::cend(m_aProperties))
return pProp->Value;
throw beans::UnknownPropertyException(); // TODO
}
diff --git a/package/source/xstor/owriteablestream.cxx b/package/source/xstor/owriteablestream.cxx
index 1c9332e..27a3d4d 100644
--- a/package/source/xstor/owriteablestream.cxx
+++ b/package/source/xstor/owriteablestream.cxx
@@ -45,6 +45,7 @@
#include <comphelper/storagehelper.hxx>
#include <comphelper/ofopxmlhelper.hxx>
#include <comphelper/refcountedmutex.hxx>
#include <comphelper/sequence.hxx>
#include <rtl/digest.h>
#include <rtl/instance.hxx>
@@ -92,10 +93,9 @@ bool PackageEncryptionDatasEqual( const ::comphelper::SequenceAsHashMap& aHash1,
bResult = ( ( aIter->second >>= aKey1 ) && aKey1.hasElements() );
if ( bResult )
{
uno::Sequence< sal_Int8 > aKey2 = aHash2.getUnpackedValueOrDefault( aIter->first, uno::Sequence< sal_Int8 >() );
bResult = ( aKey1.getLength() == aKey2.getLength() );
for ( sal_Int32 nInd = 0; bResult && nInd < aKey1.getLength(); nInd++ )
bResult = ( aKey1[nInd] == aKey2[nInd] );
const uno::Sequence< sal_Int8 > aKey2 = aHash2.getUnpackedValueOrDefault( aIter->first, uno::Sequence< sal_Int8 >() );
bResult = aKey1.getLength() == aKey2.getLength()
&& std::equal(std::cbegin(aKey1), std::cend(aKey1), aKey2.begin(), aKey2.end());
}
}
@@ -142,14 +142,8 @@ uno::Any GetEncryptionKeyProperty_Impl( const uno::Reference< beans::XPropertySe
bool SequencesEqual( const uno::Sequence< sal_Int8 >& aSequence1, const uno::Sequence< sal_Int8 >& aSequence2 )
{
if ( aSequence1.getLength() != aSequence2.getLength() )
return false;
for ( sal_Int32 nInd = 0; nInd < aSequence1.getLength(); nInd++ )
if ( aSequence1[nInd] != aSequence2[nInd] )
return false;
return true;
return aSequence1.getLength() == aSequence2.getLength()
&& std::equal(aSequence1.begin(), aSequence1.end(), aSequence2.begin(), aSequence2.end());
}
bool SequencesEqual( const uno::Sequence< beans::NamedValue >& aSequence1, const uno::Sequence< beans::NamedValue >& aSequence2 )
@@ -157,35 +151,35 @@ bool SequencesEqual( const uno::Sequence< beans::NamedValue >& aSequence1, const
if ( aSequence1.getLength() != aSequence2.getLength() )
return false;
for ( sal_Int32 nInd = 0; nInd < aSequence1.getLength(); nInd++ )
for ( const auto& rProp1 : aSequence1 )
{
bool bHasMember = false;
uno::Sequence< sal_Int8 > aMember1;
sal_Int32 nMember1 = 0;
if ( aSequence1[nInd].Value >>= aMember1 )
if ( rProp1.Value >>= aMember1 )
{
for ( sal_Int32 nInd2 = 0; nInd2 < aSequence2.getLength(); nInd2++ )
for ( const auto& rProp2 : aSequence2 )
{
if ( aSequence1[nInd].Name == aSequence2[nInd2].Name )
if ( rProp1.Name == rProp2.Name )
{
bHasMember = true;
uno::Sequence< sal_Int8 > aMember2;
if ( !( aSequence2[nInd2].Value >>= aMember2 ) || !SequencesEqual( aMember1, aMember2 ) )
if ( !( rProp2.Value >>= aMember2 ) || !SequencesEqual( aMember1, aMember2 ) )
return false;
}
}
}
else if ( aSequence1[nInd].Value >>= nMember1 )
else if ( rProp1.Value >>= nMember1 )
{
for ( sal_Int32 nInd2 = 0; nInd2 < aSequence2.getLength(); nInd2++ )
for ( const auto& rProp2 : aSequence2 )
{
if ( aSequence1[nInd].Name == aSequence2[nInd2].Name )
if ( rProp1.Name == rProp2.Name )
{
bHasMember = true;
sal_Int32 nMember2 = 0;
if ( !( aSequence2[nInd2].Value >>= nMember2 ) || nMember1 != nMember2 )
if ( !( rProp2.Value >>= nMember2 ) || nMember1 != nMember2 )
return false;
}
}
@@ -253,6 +247,12 @@ uno::Reference< io::XStream > CreateMemoryStream( const uno::Reference< uno::XCo
uno::UNO_QUERY_THROW);
}
const beans::StringPair* lcl_findPairByName(const uno::Sequence<beans::StringPair>& rSeq, const OUString& rName)
{
return std::find_if(rSeq.begin(), rSeq.end(),
[&rName](const beans::StringPair& rPair) { return rPair.First == rName; });
}
} // anonymous namespace
OWriteStream_Impl::OWriteStream_Impl( OStorage_Impl* pParent,
@@ -371,11 +371,11 @@ bool OWriteStream_Impl::IsEncrypted()
}
bool bToBeEncr = false;
for ( sal_Int32 nInd = 0; nInd < m_aProps.getLength(); nInd++ )
for ( const auto& rProp : std::as_const(m_aProps) )
{
if ( m_aProps[nInd].Name == "Encrypted" )
if ( rProp.Name == "Encrypted" )
{
if ( !( m_aProps[nInd].Value >>= bToBeEncr ) )
if ( !( rProp.Value >>= bToBeEncr ) )
{
SAL_WARN( "package.xstor", "The property has wrong type!" );
}
@@ -421,10 +421,10 @@ void OWriteStream_Impl::SetDecrypted()
m_bHasCachedEncryptionData = false;
m_aEncryptionData.clear();
for ( sal_Int32 nInd = 0; nInd < m_aProps.getLength(); nInd++ )
for ( auto& rProp : m_aProps )
{
if ( m_aProps[nInd].Name == "Encrypted" )
m_aProps[nInd].Value <<= false;
if ( rProp.Name == "Encrypted" )
rProp.Value <<= false;
}
}
@@ -444,10 +444,10 @@ void OWriteStream_Impl::SetEncrypted( const ::comphelper::SequenceAsHashMap& aEn
m_bHasDataToFlush = true;
// introduce encryption info
for ( sal_Int32 nInd = 0; nInd < m_aProps.getLength(); nInd++ )
for ( auto& rProp : m_aProps )
{
if ( m_aProps[nInd].Name == "Encrypted" )
m_aProps[nInd].Value <<= true;
if ( rProp.Name == "Encrypted" )
rProp.Value <<= true;
}
m_bUseCommonEncryption = false; // very important to set it to false
@@ -714,29 +714,29 @@ void OWriteStream_Impl::InsertStreamDirectly( const uno::Reference< io::XInputSt
bool bCompressed = false;
OUString aComprPropName( "Compressed" );
OUString aMedTypePropName( "MediaType" );
for ( sal_Int32 nInd = 0; nInd < aProps.getLength(); nInd++ )
for ( const auto& rProp : aProps )
{
if ( aProps[nInd].Name == aComprPropName )
if ( rProp.Name == aComprPropName )
{
bCompressedIsSet = true;
aProps[nInd].Value >>= bCompressed;
rProp.Value >>= bCompressed;
}
else if ( ( m_nStorageType == embed::StorageFormats::OFOPXML || m_nStorageType == embed::StorageFormats::PACKAGE )
&& aProps[nInd].Name == aMedTypePropName )
&& rProp.Name == aMedTypePropName )
{
xPropertySet->setPropertyValue( aProps[nInd].Name, aProps[nInd].Value );
xPropertySet->setPropertyValue( rProp.Name, rProp.Value );
}
else if ( m_nStorageType == embed::StorageFormats::PACKAGE && aProps[nInd].Name == "UseCommonStoragePasswordEncryption" )
aProps[nInd].Value >>= m_bUseCommonEncryption;
else if ( m_nStorageType == embed::StorageFormats::PACKAGE && rProp.Name == "UseCommonStoragePasswordEncryption" )
rProp.Value >>= m_bUseCommonEncryption;
else
throw lang::IllegalArgumentException();
// if there are cached properties update them
if ( aProps[nInd].Name == aMedTypePropName || aProps[nInd].Name == aComprPropName )
for ( sal_Int32 nMemInd = 0; nMemInd < m_aProps.getLength(); nMemInd++ )
if ( rProp.Name == aMedTypePropName || rProp.Name == aComprPropName )
for ( auto& rMemProp : m_aProps )
{
if ( aProps[nInd].Name == m_aProps[nMemInd].Name )
m_aProps[nMemInd].Value = aProps[nInd].Value;
if ( rProp.Name == rMemProp.Name )
rMemProp.Value = rProp.Value;
}
}
@@ -823,18 +823,18 @@ void OWriteStream_Impl::Commit()
// copy properties to the package stream
uno::Reference< beans::XPropertySet > xPropertySet( xNewPackageStream, uno::UNO_QUERY_THROW );
for ( sal_Int32 nInd = 0; nInd < m_aProps.getLength(); nInd++ )
for ( auto& rProp : m_aProps )
{
if ( m_aProps[nInd].Name == "Size" )
if ( rProp.Name == "Size" )
{
if ( m_pAntiImpl && !m_bHasInsertedStreamOptimization && m_pAntiImpl->m_xSeekable.is() )
{
m_aProps[nInd].Value <<= m_pAntiImpl->m_xSeekable->getLength();
xPropertySet->setPropertyValue( m_aProps[nInd].Name, m_aProps[nInd].Value );
rProp.Value <<= m_pAntiImpl->m_xSeekable->getLength();
xPropertySet->setPropertyValue( rProp.Name, rProp.Value );
}
}
else
xPropertySet->setPropertyValue( m_aProps[nInd].Name, m_aProps[nInd].Value );
xPropertySet->setPropertyValue( rProp.Name, rProp.Value );
}
if ( m_bUseCommonEncryption )
@@ -1051,10 +1051,10 @@ uno::Sequence< beans::PropertyValue > OWriteStream_Impl::ReadPackageStreamProper
// TODO: may be also raw stream should be marked
uno::Reference< beans::XPropertySet > xPropSet( m_xPackageStream, uno::UNO_QUERY_THROW );
for ( sal_Int32 nInd = 0; nInd < aResult.getLength(); nInd++ )
for ( auto& rProp : aResult )
{
try {
aResult[nInd].Value = xPropSet->getPropertyValue( aResult[nInd].Name );
rProp.Value = xPropSet->getPropertyValue( rProp.Name );
}
catch( const uno::Exception& )
{
@@ -2186,10 +2186,10 @@ void OWriteStream::CloseOutput_Impl()
if ( !m_xSeekable.is() )
throw uno::RuntimeException();
for ( sal_Int32 nInd = 0; nInd < m_pImpl->m_aProps.getLength(); nInd++ )
for ( auto& rProp : m_pImpl->m_aProps )
{
if ( m_pImpl->m_aProps[nInd].Name == "Size" )
m_pImpl->m_aProps[nInd].Value <<= m_xSeekable->getLength();
if ( rProp.Name == "Size" )
rProp.Value <<= m_xSeekable->getLength();
}
}
}
@@ -2511,10 +2511,10 @@ OUString SAL_CALL OWriteStream::getTargetByID( const OUString& sID )
if ( m_pData->m_nStorageType != embed::StorageFormats::OFOPXML )
throw uno::RuntimeException();
uno::Sequence< beans::StringPair > aSeq = getRelationshipByID( sID );
for ( sal_Int32 nInd = 0; nInd < aSeq.getLength(); nInd++ )
if ( aSeq[nInd].First == "Target" )
return aSeq[nInd].Second;
const uno::Sequence< beans::StringPair > aSeq = getRelationshipByID( sID );
auto pRel = lcl_findPairByName(aSeq, "Target");
if (pRel != aSeq.end())
return pRel->Second;
return OUString();
}
@@ -2532,10 +2532,10 @@ OUString SAL_CALL OWriteStream::getTypeByID( const OUString& sID )
if ( m_pData->m_nStorageType != embed::StorageFormats::OFOPXML )
throw uno::RuntimeException();
uno::Sequence< beans::StringPair > aSeq = getRelationshipByID( sID );
for ( sal_Int32 nInd = 0; nInd < aSeq.getLength(); nInd++ )
if ( aSeq[nInd].First == "Type" )
return aSeq[nInd].Second;
const uno::Sequence< beans::StringPair > aSeq = getRelationshipByID( sID );
auto pRel = lcl_findPairByName(aSeq, "Type");
if (pRel != aSeq.end())
return pRel->Second;
return OUString();
}
@@ -2554,15 +2554,13 @@ uno::Sequence< beans::StringPair > SAL_CALL OWriteStream::getRelationshipByID(
throw uno::RuntimeException();
// TODO/LATER: in future the unification of the ID could be checked
uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
for ( sal_Int32 nInd1 = 0; nInd1 < aSeq.getLength(); nInd1++ )
for ( sal_Int32 nInd2 = 0; nInd2 < aSeq[nInd1].getLength(); nInd2++ )
if ( aSeq[nInd1][nInd2].First == "Id" )
{
if ( aSeq[nInd1][nInd2].Second == sID )
return aSeq[nInd1];
break;
}
const uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
const beans::StringPair aIDRel("Id", sID);
auto pRel = std::find_if(aSeq.begin(), aSeq.end(),
[&aIDRel](const uno::Sequence<beans::StringPair>& rRel) {
return std::find(rRel.begin(), rRel.end(), aIDRel) != rRel.end(); });
if (pRel != aSeq.end())
return *pRel;
throw container::NoSuchElementException();
}
@@ -2580,24 +2578,17 @@ uno::Sequence< uno::Sequence< beans::StringPair > > SAL_CALL OWriteStream::getRe
if ( m_pData->m_nStorageType != embed::StorageFormats::OFOPXML )
throw uno::RuntimeException();
uno::Sequence< uno::Sequence< beans::StringPair > > aResult;
sal_Int32 nEntriesNum = 0;
// TODO/LATER: in future the unification of the ID could be checked
uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
for ( sal_Int32 nInd1 = 0; nInd1 < aSeq.getLength(); nInd1++ )
for ( sal_Int32 nInd2 = 0; nInd2 < aSeq[nInd1].getLength(); nInd2++ )
if ( aSeq[nInd1][nInd2].First == "Type" )
{
if ( aSeq[nInd1][nInd2].Second == sType )
{
aResult.realloc( nEntriesNum );
aResult[nEntriesNum-1] = aSeq[nInd1];
}
break;
}
const uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
const beans::StringPair aTypeRel("Type", sType);
std::vector< uno::Sequence<beans::StringPair> > aResult;
aResult.reserve(aSeq.getLength());
return aResult;
std::copy_if(aSeq.begin(), aSeq.end(), std::back_inserter(aResult),
[&aTypeRel](const uno::Sequence<beans::StringPair>& rRel) {
return std::find(rRel.begin(), rRel.end(), aTypeRel) != rRel.end(); });
return comphelper::containerToSequence(aResult);
}
uno::Sequence< uno::Sequence< beans::StringPair > > SAL_CALL OWriteStream::getAllRelationships()
@@ -2629,21 +2620,18 @@ void SAL_CALL OWriteStream::insertRelationshipByID( const OUString& sID, const
if ( m_pData->m_nStorageType != embed::StorageFormats::OFOPXML )
throw uno::RuntimeException();
OUString aIDTag( "Id" );
const beans::StringPair aIDRel("Id", sID);
sal_Int32 nIDInd = -1;
// TODO/LATER: in future the unification of the ID could be checked
uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
for ( sal_Int32 nInd1 = 0; nInd1 < aSeq.getLength(); nInd1++ )
for ( sal_Int32 nInd2 = 0; nInd2 < aSeq[nInd1].getLength(); nInd2++ )
if ( aSeq[nInd1][nInd2].First == aIDTag )
{
if ( aSeq[nInd1][nInd2].Second == sID )
nIDInd = nInd1;
break;
}
for ( sal_Int32 nInd = 0; nInd < aSeq.getLength(); nInd++ )
{
const auto& rRel = aSeq[nInd];
if (std::find(rRel.begin(), rRel.end(), aIDRel) != rRel.end())
nIDInd = nInd;
}
if ( nIDInd != -1 && !bReplace )
throw container::ElementExistException(); // TODO
@@ -2654,20 +2642,14 @@ void SAL_CALL OWriteStream::insertRelationshipByID( const OUString& sID, const
aSeq.realloc( nIDInd + 1 );
}
aSeq[nIDInd].realloc( aEntry.getLength() + 1 );
std::vector<beans::StringPair> aResult;
aResult.reserve(aEntry.getLength() + 1);
aSeq[nIDInd][0].First = aIDTag;
aSeq[nIDInd][0].Second = sID;
sal_Int32 nIndTarget = 1;
for ( sal_Int32 nIndOrig = 0;
nIndOrig < aEntry.getLength();
nIndOrig++ )
{
if ( aEntry[nIndOrig].First != aIDTag )
aSeq[nIDInd][nIndTarget++] = aEntry[nIndOrig];
}
aResult.push_back(aIDRel);
std::copy_if(aEntry.begin(), aEntry.end(), std::back_inserter(aResult),
[](const beans::StringPair& rRel) { return rRel.First != "Id"; });
aSeq[nIDInd].realloc( nIndTarget );
aSeq[nIDInd] = comphelper::containerToSequence(aResult);
m_pImpl->m_aNewRelInfo = aSeq;
m_pImpl->m_xNewRelInfoStream.clear();
@@ -2688,26 +2670,22 @@ void SAL_CALL OWriteStream::removeRelationshipByID( const OUString& sID )
throw uno::RuntimeException();
uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
for ( sal_Int32 nInd1 = 0; nInd1 < aSeq.getLength(); nInd1++ )
for ( sal_Int32 nInd2 = 0; nInd2 < aSeq[nInd1].getLength(); nInd2++ )
if ( aSeq[nInd1][nInd2].First == "Id" )
{
if ( aSeq[nInd1][nInd2].Second == sID )
{
sal_Int32 nLength = aSeq.getLength();
aSeq[nInd1] = aSeq[nLength-1];
aSeq.realloc( nLength - 1 );
const beans::StringPair aIDRel("Id", sID);
auto pRel = std::find_if(std::cbegin(aSeq), std::cend(aSeq),
[&aIDRel](const uno::Sequence< beans::StringPair >& rRel) {
return std::find(rRel.begin(), rRel.end(), aIDRel) != rRel.end(); });
if (pRel != std::cend(aSeq))
{
auto nInd = static_cast<sal_Int32>(std::distance(std::cbegin(aSeq), pRel));
comphelper::removeElementAt(aSeq, nInd);
m_pImpl->m_aNewRelInfo = aSeq;
m_pImpl->m_xNewRelInfoStream.clear();
m_pImpl->m_nRelInfoStatus = RELINFO_CHANGED;
m_pImpl->m_aNewRelInfo = aSeq;
m_pImpl->m_xNewRelInfoStream.clear();
m_pImpl->m_nRelInfoStatus = RELINFO_CHANGED;
// TODO/LATER: in future the unification of the ID could be checked
return;
}
break;
}
// TODO/LATER: in future the unification of the ID could be checked
return;
}
throw container::NoSuchElementException();
}
@@ -2726,67 +2704,41 @@ void SAL_CALL OWriteStream::insertRelationships( const uno::Sequence< uno::Sequ
throw uno::RuntimeException();
OUString aIDTag( "Id" );
uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
uno::Sequence< uno::Sequence< beans::StringPair > > aResultSeq( aSeq.getLength() + aEntries.getLength() );
sal_Int32 nResultInd = 0;
const uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
std::vector< uno::Sequence<beans::StringPair> > aResultVec;
aResultVec.reserve(aSeq.getLength() + aEntries.getLength());
for ( sal_Int32 nIndTarget1 = 0; nIndTarget1 < aSeq.getLength(); nIndTarget1++ )
for ( sal_Int32 nIndTarget2 = 0; nIndTarget2 < aSeq[nIndTarget1].getLength(); nIndTarget2++ )
if ( aSeq[nIndTarget1][nIndTarget2].First == aIDTag )
{
sal_Int32 nIndSourceSame = -1;
std::copy_if(aSeq.begin(), aSeq.end(), std::back_inserter(aResultVec),
[&aIDTag, &aEntries, bReplace](const uno::Sequence<beans::StringPair>& rTargetRel) {
auto pTargetPair = lcl_findPairByName(rTargetRel, aIDTag);
if (pTargetPair == rTargetRel.end())
return false;
for ( sal_Int32 nIndSource1 = 0; nIndSource1 < aEntries.getLength(); nIndSource1++ )
for ( sal_Int32 nIndSource2 = 0; nIndSource2 < aEntries[nIndSource1].getLength(); nIndSource2++ )
{
if ( aEntries[nIndSource1][nIndSource2].First == aIDTag )
{
if ( aEntries[nIndSource1][nIndSource2].Second == aSeq[nIndTarget1][nIndTarget2].Second )
{
if ( !bReplace )
throw container::ElementExistException();
bool bIsSourceSame = std::any_of(aEntries.begin(), aEntries.end(),
[&pTargetPair](const uno::Sequence<beans::StringPair>& rSourceEntry) {
return std::find(rSourceEntry.begin(), rSourceEntry.end(), *pTargetPair) != rSourceEntry.end(); });
nIndSourceSame = nIndSource1;
}
if ( bIsSourceSame && !bReplace )
throw container::ElementExistException();
break;
}
}
// if no such element in the provided sequence
return !bIsSourceSame;
});
if ( nIndSourceSame == -1 )
{
// no such element in the provided sequence
aResultSeq[nResultInd++] = aSeq[nIndTarget1];
}
break;
}
for ( sal_Int32 nIndSource1 = 0; nIndSource1 < aEntries.getLength(); nIndSource1++ )
{
aResultSeq[nResultInd].realloc( aEntries[nIndSource1].getLength() );
bool bHasID = false;
sal_Int32 nResInd2 = 1;
for ( sal_Int32 nIndSource2 = 0; nIndSource2 < aEntries[nIndSource1].getLength(); nIndSource2++ )
if ( aEntries[nIndSource1][nIndSource2].First == aIDTag )
{
aResultSeq[nResultInd][0] = aEntries[nIndSource1][nIndSource2];
bHasID = true;
}
else if ( nResInd2 < aResultSeq[nResultInd].getLength() )
aResultSeq[nResultInd][nResInd2++] = aEntries[nIndSource1][nIndSource2];
else
std::transform(aEntries.begin(), aEntries.end(), std::back_inserter(aResultVec),
[&aIDTag](const uno::Sequence<beans::StringPair>& rEntry) -> uno::Sequence<beans::StringPair> {
auto pPair = lcl_findPairByName(rEntry, aIDTag);
if (pPair == rEntry.end())
throw io::IOException(); // TODO: illegal relation ( no ID )
if ( !bHasID )
throw io::IOException(); // TODO: illegal relations
auto aResult = comphelper::sequenceToContainer<std::vector<beans::StringPair>>(rEntry);
auto nIDInd = std::distance(rEntry.begin(), pPair);
std::rotate(aResult.begin(), std::next(aResult.begin(), nIDInd), std::next(aResult.begin(), nIDInd + 1));
nResultInd++;
}
return comphelper::containerToSequence(aResult);
});
aResultSeq.realloc( nResultInd );
m_pImpl->m_aNewRelInfo = aResultSeq;
m_pImpl->m_aNewRelInfo = comphelper::containerToSequence(aResultVec);
m_pImpl->m_xNewRelInfoStream.clear();
m_pImpl->m_nRelInfoStatus = RELINFO_CHANGED;
}
@@ -2843,22 +2795,22 @@ void SAL_CALL OWriteStream::setPropertyValue( const OUString& aPropertyName, con
bCompressedValueFromType = false;
}
for ( sal_Int32 nInd = 0; nInd < m_pImpl->m_aProps.getLength(); nInd++ )
for ( auto& rProp : m_pImpl->m_aProps )
{
if ( aPropertyName == m_pImpl->m_aProps[nInd].Name )
m_pImpl->m_aProps[nInd].Value = aValue;
else if ( !m_pImpl->m_bCompressedSetExplicit && aCompressedString == m_pImpl->m_aProps[nInd].Name )
m_pImpl->m_aProps[nInd].Value <<= bCompressedValueFromType;
if ( aPropertyName == rProp.Name )
rProp.Value = aValue;
else if ( !m_pImpl->m_bCompressedSetExplicit && aCompressedString == rProp.Name )
rProp.Value <<= bCompressedValueFromType;
}
}
else if ( aPropertyName == aCompressedString )
{
// if the "Compressed" property is not set explicitly, the MediaType can change the default value
m_pImpl->m_bCompressedSetExplicit = true;
for ( sal_Int32 nInd = 0; nInd < m_pImpl->m_aProps.getLength(); nInd++ )
for ( auto& rProp : m_pImpl->m_aProps )
{
if ( aPropertyName == m_pImpl->m_aProps[nInd].Name )
m_pImpl->m_aProps[nInd].Value = aValue;
if ( aPropertyName == rProp.Name )
rProp.Value = aValue;
}
}
else if ( m_pData->m_nStorageType == embed::StorageFormats::PACKAGE
@@ -2886,10 +2838,10 @@ void SAL_CALL OWriteStream::setPropertyValue( const OUString& aPropertyName, con
}
else if ( m_pData->m_nStorageType == embed::StorageFormats::OFOPXML && aPropertyName == aMediaTypeString )
{
for ( sal_Int32 nInd = 0; nInd < m_pImpl->m_aProps.getLength(); nInd++ )
for ( auto& rProp : m_pImpl->m_aProps )
{
if ( aPropertyName == m_pImpl->m_aProps[nInd].Name )
m_pImpl->m_aProps[nInd].Value = aValue;
if ( aPropertyName == rProp.Name )
rProp.Value = aValue;
}
}
else if ( m_pData->m_nStorageType == embed::StorageFormats::OFOPXML && aPropertyName == "RelationsInfoStream" )
@@ -2960,11 +2912,10 @@ uno::Any SAL_CALL OWriteStream::getPropertyValue( const OUString& aProp )
{
m_pImpl->GetStreamProperties();
for ( sal_Int32 nInd = 0; nInd < m_pImpl->m_aProps.getLength(); nInd++ )
{
if ( aPropertyName == m_pImpl->m_aProps[nInd].Name )
return m_pImpl->m_aProps[nInd].Value;
}
auto pProp = std::find_if(std::cbegin(m_pImpl->m_aProps), std::cend(m_pImpl->m_aProps),
[&aPropertyName](const css::beans::PropertyValue& rProp){ return aPropertyName == rProp.Name; });
if (pProp != std::cend(m_pImpl->m_aProps))
return pProp->Value;
}
else if ( m_pData->m_nStorageType == embed::StorageFormats::PACKAGE
&& aPropertyName == "UseCommonStoragePasswordEncryption" )
diff --git a/package/source/xstor/xfactory.cxx b/package/source/xstor/xfactory.cxx
index 2b28fdc..dcb8dd2 100644
--- a/package/source/xstor/xfactory.cxx
+++ b/package/source/xstor/xfactory.cxx
@@ -182,22 +182,23 @@ uno::Reference< uno::XInterface > SAL_CALL OStorageFactory::createInstanceWithAr
aPropsToSet[0].Value <<= aURL;
}
for ( sal_Int32 nInd = 0, nNumArgs = 1; nInd < aDescr.getLength(); nInd++ )
sal_Int32 nNumArgs = 1;
for ( const auto& rProp : std::as_const(aDescr) )
{
if ( aDescr[nInd].Name == "InteractionHandler"
|| aDescr[nInd].Name == "Password"
|| aDescr[nInd].Name == "RepairPackage"
|| aDescr[nInd].Name == "StatusIndicator" )
if ( rProp.Name == "InteractionHandler"
|| rProp.Name == "Password"
|| rProp.Name == "RepairPackage"
|| rProp.Name == "StatusIndicator" )
{
aPropsToSet.realloc( ++nNumArgs );
aPropsToSet[nNumArgs-1].Name = aDescr[nInd].Name;
aPropsToSet[nNumArgs-1].Value = aDescr[nInd].Value;
aPropsToSet[nNumArgs-1].Name = rProp.Name;
aPropsToSet[nNumArgs-1].Value = rProp.Value;
}
else if ( aDescr[nInd].Name == "StorageFormat" )
else if ( rProp.Name == "StorageFormat" )
{
OUString aFormatName;
sal_Int32 nFormatID = 0;
if ( aDescr[nInd].Value >>= aFormatName )
if ( rProp.Value >>= aFormatName )
{
if ( aFormatName == PACKAGE_STORAGE_FORMAT_STRING )
nStorageType = embed::StorageFormats::PACKAGE;
@@ -208,7 +209,7 @@ uno::Reference< uno::XInterface > SAL_CALL OStorageFactory::createInstanceWithAr
else
throw lang::IllegalArgumentException( THROW_WHERE, uno::Reference< uno::XInterface >(), 1 );
}
else if ( aDescr[nInd].Value >>= nFormatID )
else if ( rProp.Value >>= nFormatID )
{
if ( nFormatID != embed::StorageFormats::PACKAGE
&& nFormatID != embed::StorageFormats::ZIP
@@ -220,12 +221,12 @@ uno::Reference< uno::XInterface > SAL_CALL OStorageFactory::createInstanceWithAr
else
throw lang::IllegalArgumentException( THROW_WHERE, uno::Reference< uno::XInterface >(), 1 );
}
else if (aDescr[nInd].Name == "NoFileSync")
else if (rProp.Name == "NoFileSync")
{
// Forward NoFileSync to the storage.
aPropsToSet.realloc(++nNumArgs);
aPropsToSet[nNumArgs - 1].Name = aDescr[nInd].Name;
aPropsToSet[nNumArgs - 1].Value = aDescr[nInd].Value;
aPropsToSet[nNumArgs - 1].Name = rProp.Name;
aPropsToSet[nNumArgs - 1].Value = rProp.Value;
}
else
OSL_FAIL( "Unacceptable property, will be ignored!" );
diff --git a/package/source/xstor/xstorage.cxx b/package/source/xstor/xstorage.cxx
index 16ae4a9..f879273 100644
--- a/package/source/xstor/xstorage.cxx
+++ b/package/source/xstor/xstorage.cxx
@@ -141,8 +141,8 @@ void OStorage_Impl::completeStorageStreamCopy_Impl(
aPropNames[1] = "MediaType";
}
for ( int ind = 0; ind < aPropNames.getLength(); ind++ )
xDestProps->setPropertyValue( aPropNames[ind], xSourceProps->getPropertyValue( aPropNames[ind] ) );
for ( const auto& rPropName : std::as_const(aPropNames) )
xDestProps->setPropertyValue( rPropName, xSourceProps->getPropertyValue( rPropName ) );
}
static uno::Reference< io::XInputStream > GetSeekableTempCopy( const uno::Reference< io::XInputStream >& xInStream,
@@ -340,9 +340,9 @@ OStorage_Impl::~OStorage_Impl()
m_xPackage.clear();
OUString aPropertyName = "URL";
for ( sal_Int32 aInd = 0; aInd < m_xProperties.getLength(); ++aInd )
for ( const auto& rProp : std::as_const(m_xProperties) )
{
if ( m_xProperties[aInd].Name == aPropertyName )
if ( rProp.Name == aPropertyName )
{
// the storage is URL based so all the streams are opened by factory and should be closed
try
@@ -429,19 +429,18 @@ void OStorage_Impl::OpenOwnPackage()
uno::makeAny( false ) );
sal_Int32 nArgNum = 2;
for ( sal_Int32 aInd = 0; aInd < m_xProperties.getLength(); aInd++ )
for ( const auto& rProp : std::as_const(m_xProperties) )
{
if ( m_xProperties[aInd].Name == "RepairPackage"
|| m_xProperties[aInd].Name == "ProgressHandler"
|| m_xProperties[aInd].Name == "NoFileSync" )
if ( rProp.Name == "RepairPackage"
|| rProp.Name == "ProgressHandler"
|| rProp.Name == "NoFileSync" )
{
// Forward these to the package.
beans::NamedValue aNamedValue( m_xProperties[aInd].Name,
m_xProperties[aInd].Value );
beans::NamedValue aNamedValue( rProp.Name, rProp.Value );
aArguments.realloc( ++nArgNum );
aArguments[nArgNum-1] <<= aNamedValue;
}
else if ( m_xProperties[aInd].Name == "Password" )
else if ( rProp.Name == "Password" )
{
// TODO: implement password setting for documents
// the password entry must be removed after setting
@@ -771,15 +770,15 @@ void OStorage_Impl::CopyStorageElement( SotElement_Impl* pElement,
{
// fill in the properties for the stream
uno::Sequence< beans::PropertyValue > aStrProps(0);
uno::Sequence< beans::PropertyValue > aSrcPkgProps = pElement->m_xStream->GetStreamProperties();
const uno::Sequence< beans::PropertyValue > aSrcPkgProps = pElement->m_xStream->GetStreamProperties();
sal_Int32 nNum = 0;
for ( int ind = 0; ind < aSrcPkgProps.getLength(); ind++ )
for ( const auto& rSrcPkgProp : aSrcPkgProps )
{
if ( aSrcPkgProps[ind].Name == "MediaType" || aSrcPkgProps[ind].Name == "Compressed" )
if ( rSrcPkgProp.Name == "MediaType" || rSrcPkgProp.Name == "Compressed" )
{
aStrProps.realloc( ++nNum );
aStrProps[nNum-1].Name = aSrcPkgProps[ind].Name;
aStrProps[nNum-1].Value = aSrcPkgProps[ind].Value;
aStrProps[nNum-1].Name = rSrcPkgProp.Name;
aStrProps[nNum-1].Value = rSrcPkgProp.Value;
}
}
@@ -1684,7 +1683,7 @@ void OStorage_Impl::CommitRelInfo( const uno::Reference< container::XNameContain
if (m_nRelInfoStatus == RELINFO_CHANGED)
{
if (m_aRelInfo.getLength())
if (m_aRelInfo.hasElements())
{
CreateRelStorage();
@@ -3152,7 +3151,7 @@ uno::Reference< io::XStream > SAL_CALL OStorage::openEncryptedStream(
if ( ( nOpenMode & embed::ElementModes::WRITE ) && m_pData->m_bReadOnlyWrap )
throw io::IOException( THROW_WHERE ); // TODO: access denied
if ( !aEncryptionData.getLength() )
if ( !aEncryptionData.hasElements() )
throw lang::IllegalArgumentException( THROW_WHERE, uno::Reference< uno::XInterface >(), 3 );
uno::Reference< io::XStream > xResult;
@@ -3235,7 +3234,7 @@ uno::Reference< io::XStream > SAL_CALL OStorage::cloneEncryptedStream(
throw lang::DisposedException( THROW_WHERE );
}
if ( !aEncryptionData.getLength() )
if ( !aEncryptionData.hasElements() )
throw lang::IllegalArgumentException( THROW_WHERE, uno::Reference< uno::XInterface >(), 2 );
try
@@ -4102,7 +4101,7 @@ void SAL_CALL OStorage::setEncryptionData( const uno::Sequence< beans::NamedValu
if ( m_pData->m_nStorageType != embed::StorageFormats::PACKAGE )
throw uno::RuntimeException( THROW_WHERE ); // the interface must be visible only for package storage
if ( !aEncryptionData.getLength() )
if ( !aEncryptionData.hasElements() )
throw uno::RuntimeException( THROW_WHERE "Unexpected empty encryption data!" );
SAL_WARN_IF( !m_pData->m_bIsRoot, "package.xstor", "setEncryptionData() method is not available for nonroot storages!" );
@@ -4167,7 +4166,7 @@ void SAL_CALL OStorage::setEncryptionAlgorithms( const uno::Sequence< beans::Nam
if ( m_pData->m_nStorageType != embed::StorageFormats::PACKAGE )
throw uno::RuntimeException( THROW_WHERE ); // the interface must be visible only for package storage
if ( !aAlgorithms.getLength() )
if ( !aAlgorithms.hasElements() )
throw uno::RuntimeException( THROW_WHERE "Unexpected empty encryption algorithms list!" );
SAL_WARN_IF( !m_pData->m_bIsRoot, "package.xstor", "setEncryptionAlgorithms() method is not available for nonroot storages!" );
@@ -4227,7 +4226,7 @@ void SAL_CALL OStorage::setGpgProperties( const uno::Sequence< uno::Sequence< be
if ( m_pData->m_nStorageType != embed::StorageFormats::PACKAGE )
throw uno::RuntimeException( THROW_WHERE ); // the interface must be visible only for package storage
if ( !aProps.getLength() )
if ( !aProps.hasElements() )
throw uno::RuntimeException( THROW_WHERE "Unexpected empty encryption algorithms list!" );
SAL_WARN_IF( !m_pData->m_bIsRoot, "package.xstor", "setGpgProperties() method is not available for nonroot storages!" );
@@ -4501,11 +4500,10 @@ uno::Any SAL_CALL OStorage::getPropertyValue( const OUString& aPropertyName )
if ( aPropertyName == "URL"
|| aPropertyName == "RepairPackage" )
{
for ( sal_Int32 aInd = 0; aInd < m_pImpl->m_xProperties.getLength(); aInd++ )
{
if ( m_pImpl->m_xProperties[aInd].Name == aPropertyName )
return m_pImpl->m_xProperties[aInd].Value;
}
auto pProp = std::find_if(std::cbegin(m_pImpl->m_xProperties), std::cend(m_pImpl->m_xProperties),
[&aPropertyName](const css::beans::PropertyValue& rProp) { return rProp.Name == aPropertyName; });
if (pProp != std::cend(m_pImpl->m_xProperties))
return pProp->Value;
if ( aPropertyName == "URL" )
return uno::makeAny( OUString() );
@@ -4633,6 +4631,16 @@ sal_Bool SAL_CALL OStorage::hasByID( const OUString& sID )
return false;
}
namespace
{
const beans::StringPair* lcl_findPairByName(const uno::Sequence<beans::StringPair>& rSeq, const OUString& rName)
{
return std::find_if(rSeq.begin(), rSeq.end(), [&rName](const beans::StringPair& rPair) { return rPair.First == rName; });
}
}
OUString SAL_CALL OStorage::getTargetByID( const OUString& sID )
{
::osl::MutexGuard aGuard( m_pData->m_xSharedMutex->GetMutex() );
@@ -4646,10 +4654,10 @@ OUString SAL_CALL OStorage::getTargetByID( const OUString& sID )
if ( m_pData->m_nStorageType != embed::StorageFormats::OFOPXML )
throw uno::RuntimeException( THROW_WHERE );
uno::Sequence< beans::StringPair > aSeq = getRelationshipByID( sID );
for ( sal_Int32 nInd = 0; nInd < aSeq.getLength(); nInd++ )
if ( aSeq[nInd].First == "Target" )
return aSeq[nInd].Second;
const uno::Sequence< beans::StringPair > aSeq = getRelationshipByID( sID );
auto pRel = lcl_findPairByName(aSeq, "Target");
if (pRel != aSeq.end())
return pRel->Second;
return OUString();
}
@@ -4667,10 +4675,10 @@ OUString SAL_CALL OStorage::getTypeByID( const OUString& sID )
if ( m_pData->m_nStorageType != embed::StorageFormats::OFOPXML )
throw uno::RuntimeException( THROW_WHERE );
uno::Sequence< beans::StringPair > aSeq = getRelationshipByID( sID );
for ( sal_Int32 nInd = 0; nInd < aSeq.getLength(); nInd++ )
if ( aSeq[nInd].First == "Type" )
return aSeq[nInd].Second;
const uno::Sequence< beans::StringPair > aSeq = getRelationshipByID( sID );
auto pRel = lcl_findPairByName(aSeq, "Type");
if (pRel != aSeq.end())
return pRel->Second;
return OUString();
}
@@ -4689,15 +4697,14 @@ uno::Sequence< beans::StringPair > SAL_CALL OStorage::getRelationshipByID( cons
throw uno::RuntimeException( THROW_WHERE );
// TODO/LATER: in future the unification of the ID could be checked
uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
for ( sal_Int32 nInd1 = 0; nInd1 < aSeq.getLength(); nInd1++ )
for ( sal_Int32 nInd2 = 0; nInd2 < aSeq[nInd1].getLength(); nInd2++ )
if ( aSeq[nInd1][nInd2].First == "Id" )
{
if ( aSeq[nInd1][nInd2].Second == sID )
return aSeq[nInd1];
break;
}
const uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
const beans::StringPair aIDRel("Id", sID);
auto pRel = std::find_if(aSeq.begin(), aSeq.end(),
[&aIDRel](const uno::Sequence<beans::StringPair>& rRel) {
return std::find(rRel.begin(), rRel.end(), aIDRel) != rRel.end(); });
if (pRel != aSeq.end())
return *pRel;
throw container::NoSuchElementException( THROW_WHERE );
}
@@ -4715,25 +4722,20 @@ uno::Sequence< uno::Sequence< beans::StringPair > > SAL_CALL OStorage::getRelati
if ( m_pData->m_nStorageType != embed::StorageFormats::OFOPXML )
throw uno::RuntimeException( THROW_WHERE );
uno::Sequence< uno::Sequence< beans::StringPair > > aResult;
sal_Int32 nEntriesNum = 0;
// TODO/LATER: in future the unification of the ID could be checked
uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
for ( sal_Int32 nInd1 = 0; nInd1 < aSeq.getLength(); nInd1++ )
for ( sal_Int32 nInd2 = 0; nInd2 < aSeq[nInd1].getLength(); nInd2++ )
if ( aSeq[nInd1][nInd2].First == "Type" )
{
// the type is usually a URL, so the check should be case insensitive
if ( aSeq[nInd1][nInd2].Second.equalsIgnoreAsciiCase( sType ) )
{
aResult.realloc( ++nEntriesNum );
aResult[nEntriesNum-1] = aSeq[nInd1];
}
break;
}
const uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
std::vector< uno::Sequence< beans::StringPair > > aResult;
aResult.reserve(aSeq.getLength());
return aResult;
std::copy_if(aSeq.begin(), aSeq.end(), std::back_inserter(aResult),
[&sType](const uno::Sequence<beans::StringPair>& rRel) {
auto pRel = lcl_findPairByName(rRel, "Type");
return pRel != rRel.end()
// the type is usually a URL, so the check should be case insensitive
&& pRel->Second.equalsIgnoreAsciiCase( sType );
});
return comphelper::containerToSequence(aResult);
}
uno::Sequence< uno::Sequence< beans::StringPair > > SAL_CALL OStorage::getAllRelationships()
@@ -4786,21 +4788,18 @@ void SAL_CALL OStorage::insertRelationshipByID( const OUString& sID, const uno:
if ( m_pData->m_nStorageType != embed::StorageFormats::OFOPXML )
throw uno::RuntimeException( THROW_WHERE );
OUString aIDTag( "Id" );
const beans::StringPair aIDRel("Id", sID);
sal_Int32 nIDInd = -1;
// TODO/LATER: in future the unification of the ID could be checked
uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
for ( sal_Int32 nInd1 = 0; nInd1 < aSeq.getLength(); nInd1++ )
for ( sal_Int32 nInd2 = 0; nInd2 < aSeq[nInd1].getLength(); nInd2++ )
if ( aSeq[nInd1][nInd2].First == aIDTag )
{
if ( aSeq[nInd1][nInd2].Second == sID )
nIDInd = nInd1;
break;
}
for ( sal_Int32 nInd = 0; nInd < aSeq.getLength(); nInd++ )
{
const auto& rRel = aSeq[nInd];
if (std::find(rRel.begin(), rRel.end(), aIDRel) != rRel.end())
nIDInd = nInd;
}
if ( nIDInd != -1 && !bReplace )
throw container::ElementExistException( THROW_WHERE );
@@ -4811,20 +4810,14 @@ void SAL_CALL OStorage::insertRelationshipByID( const OUString& sID, const uno:
aSeq.realloc( nIDInd + 1 );
}
aSeq[nIDInd].realloc( aEntry.getLength() + 1 );
std::vector<beans::StringPair> aResult;
aResult.reserve(aEntry.getLength() + 1);
aSeq[nIDInd][0].First = aIDTag;
aSeq[nIDInd][0].Second = sID;
sal_Int32 nIndTarget = 1;
for ( sal_Int32 nIndOrig = 0;
nIndOrig < aEntry.getLength();
nIndOrig++ )
{
if ( aEntry[nIndOrig].First != aIDTag )
aSeq[nIDInd][nIndTarget++] = aEntry[nIndOrig];
}
aResult.push_back(aIDRel);
std::copy_if(aEntry.begin(), aEntry.end(), std::back_inserter(aResult),
[](const beans::StringPair& rPair) { return rPair.First != "Id"; });
aSeq[nIDInd].realloc( nIndTarget );
aSeq[nIDInd] = comphelper::containerToSequence(aResult);
m_pImpl->m_aRelInfo = aSeq;
m_pImpl->m_xNewRelInfoStream.clear();
@@ -4845,26 +4838,22 @@ void SAL_CALL OStorage::removeRelationshipByID( const OUString& sID )
throw uno::RuntimeException( THROW_WHERE );
uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
for ( sal_Int32 nInd1 = 0; nInd1 < aSeq.getLength(); nInd1++ )
for ( sal_Int32 nInd2 = 0; nInd2 < aSeq[nInd1].getLength(); nInd2++ )
if ( aSeq[nInd1][nInd2].First == "Id" )
{
if ( aSeq[nInd1][nInd2].Second == sID )
{
sal_Int32 nLength = aSeq.getLength();
aSeq[nInd1] = aSeq[nLength-1];
aSeq.realloc( nLength - 1 );
const beans::StringPair aIDRel("Id", sID);
auto pRel = std::find_if(std::cbegin(aSeq), std::cend(aSeq),
[&aIDRel](const uno::Sequence< beans::StringPair >& rRel) {
return std::find(rRel.begin(), rRel.end(), aIDRel) != rRel.end(); });
if (pRel != std::cend(aSeq))
{
auto nInd = static_cast<sal_Int32>(std::distance(std::cbegin(aSeq), pRel));
comphelper::removeElementAt(aSeq, nInd);
m_pImpl->m_aRelInfo = aSeq;
m_pImpl->m_xNewRelInfoStream.clear();
m_pImpl->m_nRelInfoStatus = RELINFO_CHANGED;
m_pImpl->m_aRelInfo = aSeq;
m_pImpl->m_xNewRelInfoStream.clear();
m_pImpl->m_nRelInfoStatus = RELINFO_CHANGED;
// TODO/LATER: in future the unification of the ID could be checked
return;
}
break;
}
// TODO/LATER: in future the unification of the ID could be checked
return;
}
throw container::NoSuchElementException( THROW_WHERE );
}
@@ -4883,67 +4872,41 @@ void SAL_CALL OStorage::insertRelationships( const uno::Sequence< uno::Sequence
throw uno::RuntimeException( THROW_WHERE );
OUString aIDTag( "Id" );
uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
uno::Sequence< uno::Sequence< beans::StringPair > > aResultSeq( aSeq.getLength() + aEntries.getLength() );
sal_Int32 nResultInd = 0;
const uno::Sequence< uno::Sequence< beans::StringPair > > aSeq = getAllRelationships();
std::vector< uno::Sequence<beans::StringPair> > aResultVec;
aResultVec.reserve(aSeq.getLength() + aEntries.getLength());
for ( sal_Int32 nIndTarget1 = 0; nIndTarget1 < aSeq.getLength(); nIndTarget1++ )
for ( sal_Int32 nIndTarget2 = 0; nIndTarget2 < aSeq[nIndTarget1].getLength(); nIndTarget2++ )
if ( aSeq[nIndTarget1][nIndTarget2].First == aIDTag )
{
sal_Int32 nIndSourceSame = -1;
std::copy_if(aSeq.begin(), aSeq.end(), std::back_inserter(aResultVec),
[&aIDTag, &aEntries, bReplace](const uno::Sequence<beans::StringPair>& rTargetRel) {
auto pTargetPair = lcl_findPairByName(rTargetRel, aIDTag);
if (pTargetPair == rTargetRel.end())
return false;
for ( sal_Int32 nIndSource1 = 0; nIndSource1 < aEntries.getLength(); nIndSource1++ )
for ( sal_Int32 nIndSource2 = 0; nIndSource2 < aEntries[nIndSource1].getLength(); nIndSource2++ )
{
if ( aEntries[nIndSource1][nIndSource2].First == aIDTag )
{
if ( aEntries[nIndSource1][nIndSource2].Second == aSeq[nIndTarget1][nIndTarget2].Second )
{
if ( !bReplace )
throw container::ElementExistException( THROW_WHERE );
bool bIsSourceSame = std::any_of(aEntries.begin(), aEntries.end(),
[&pTargetPair](const uno::Sequence<beans::StringPair>& rSourceEntry) {
return std::find(rSourceEntry.begin(), rSourceEntry.end(), *pTargetPair) != rSourceEntry.end(); });
nIndSourceSame = nIndSource1;
}
if ( bIsSourceSame && !bReplace )
throw container::ElementExistException( THROW_WHERE );
break;
}
}
// if no such element in the provided sequence
return !bIsSourceSame;
});
if ( nIndSourceSame == -1 )
{
// no such element in the provided sequence
aResultSeq[nResultInd++] = aSeq[nIndTarget1];
}
break;
}
for ( sal_Int32 nIndSource1 = 0; nIndSource1 < aEntries.getLength(); nIndSource1++ )
{
aResultSeq[nResultInd].realloc( aEntries[nIndSource1].getLength() );
bool bHasID = false;
sal_Int32 nResInd2 = 1;
for ( sal_Int32 nIndSource2 = 0; nIndSource2 < aEntries[nIndSource1].getLength(); nIndSource2++ )
if ( aEntries[nIndSource1][nIndSource2].First == aIDTag )
{
aResultSeq[nResultInd][0] = aEntries[nIndSource1][nIndSource2];
bHasID = true;
}
else if ( nResInd2 < aResultSeq[nResultInd].getLength() )
aResultSeq[nResultInd][nResInd2++] = aEntries[nIndSource1][nIndSource2];
else
std::transform(aEntries.begin(), aEntries.end(), std::back_inserter(aResultVec),
[&aIDTag](const uno::Sequence<beans::StringPair>& rEntry) -> uno::Sequence<beans::StringPair> {
auto pPair = lcl_findPairByName(rEntry, aIDTag);
if (pPair == rEntry.end())
throw io::IOException( THROW_WHERE ); // TODO: illegal relation ( no ID )
if ( !bHasID )
throw io::IOException( THROW_WHERE ); // TODO: illegal relations
auto aResult = comphelper::sequenceToContainer<std::vector<beans::StringPair>>(rEntry);
auto nIDInd = std::distance(rEntry.begin(), pPair);
std::rotate(aResult.begin(), std::next(aResult.begin(), nIDInd), std::next(aResult.begin(), nIDInd + 1));
nResultInd++;
}
return comphelper::containerToSequence(aResult);
});
aResultSeq.realloc( nResultInd );
m_pImpl->m_aRelInfo = aResultSeq;
m_pImpl->m_aRelInfo = comphelper::containerToSequence(aResultVec);
m_pImpl->m_xNewRelInfoStream.clear();
m_pImpl->m_nRelInfoStatus = RELINFO_CHANGED;
}
diff --git a/package/source/zippackage/ZipPackage.cxx b/package/source/zippackage/ZipPackage.cxx
index 574b7a4..4ade3f6 100644
--- a/package/source/zippackage/ZipPackage.cxx
+++ b/package/source/zippackage/ZipPackage.cxx
@@ -200,46 +200,43 @@ void ZipPackage::parseManifest()
const OUString sPropStartKeyAlgorithm ("StartKeyAlgorithm");
const OUString sKeyInfo ("KeyInfo");
uno::Sequence < uno::Sequence < PropertyValue > > aManifestSequence = xReader->readManifestSequence ( xSink->getInputStream() );
sal_Int32 nLength = aManifestSequence.getLength();
const uno::Sequence < PropertyValue > *pSequence = aManifestSequence.getConstArray();
const uno::Sequence < uno::Sequence < PropertyValue > > aManifestSequence = xReader->readManifestSequence ( xSink->getInputStream() );
ZipPackageStream *pStream = nullptr;
ZipPackageFolder *pFolder = nullptr;
const Any *pKeyInfo = nullptr;
for ( sal_Int32 i = 0; i < nLength ; i++, pSequence++ )
for ( const uno::Sequence<PropertyValue>& rSequence : aManifestSequence )
{
OUString sPath, sMediaType, sVersion;
const PropertyValue *pValue = pSequence->getConstArray();
const Any *pSalt = nullptr, *pVector = nullptr, *pCount = nullptr, *pSize = nullptr, *pDigest = nullptr, *pDigestAlg = nullptr, *pEncryptionAlg = nullptr, *pStartKeyAlg = nullptr, *pDerivedKeySize = nullptr;
for ( sal_Int32 j = 0, nNum = pSequence->getLength(); j < nNum; j++ )
for ( const PropertyValue& rValue : rSequence )
{
if ( pValue[j].Name == sPropFullPath )
pValue[j].Value >>= sPath;
else if ( pValue[j].Name == sPropVersion )
pValue[j].Value >>= sVersion;
else if ( pValue[j].Name == sPropMediaType )
pValue[j].Value >>= sMediaType;
else if ( pValue[j].Name == sPropSalt )
pSalt = &( pValue[j].Value );
else if ( pValue[j].Name == sPropInitialisationVector )
pVector = &( pValue[j].Value );
else if ( pValue[j].Name == sPropIterationCount )
pCount = &( pValue[j].Value );
else if ( pValue[j].Name == sPropSize )
pSize = &( pValue[j].Value );
else if ( pValue[j].Name == sPropDigest )
pDigest = &( pValue[j].Value );
else if ( pValue[j].Name == sPropDigestAlgorithm )
pDigestAlg = &( pValue[j].Value );
else if ( pValue[j].Name == sPropEncryptionAlgorithm )
pEncryptionAlg = &( pValue[j].Value );
else if ( pValue[j].Name == sPropStartKeyAlgorithm )
pStartKeyAlg = &( pValue[j].Value );
else if ( pValue[j].Name == sPropDerivedKeySize )
pDerivedKeySize = &( pValue[j].Value );
else if ( pValue[j].Name == sKeyInfo )
pKeyInfo = &( pValue[j].Value );
if ( rValue.Name == sPropFullPath )
rValue.Value >>= sPath;
else if ( rValue.Name == sPropVersion )
rValue.Value >>= sVersion;
else if ( rValue.Name == sPropMediaType )
rValue.Value >>= sMediaType;
else if ( rValue.Name == sPropSalt )
pSalt = &( rValue.Value );
else if ( rValue.Name == sPropInitialisationVector )
pVector = &( rValue.Value );
else if ( rValue.Name == sPropIterationCount )
pCount = &( rValue.Value );
else if ( rValue.Name == sPropSize )
pSize = &( rValue.Value );
else if ( rValue.Name == sPropDigest )
pDigest = &( rValue.Value );
else if ( rValue.Name == sPropDigestAlgorithm )
pDigestAlg = &( rValue.Value );
else if ( rValue.Name == sPropEncryptionAlgorithm )
pEncryptionAlg = &( rValue.Value );
else if ( rValue.Name == sPropStartKeyAlgorithm )
pStartKeyAlg = &( rValue.Value );
else if ( rValue.Name == sPropDerivedKeySize )
pDerivedKeySize = &( rValue.Value );
else if ( rValue.Name == sKeyInfo )
pKeyInfo = &( rValue.Value );
}
if ( !sPath.isEmpty() && hasByHierarchicalName ( sPath ) )
@@ -469,26 +466,25 @@ void ZipPackage::parseContentType()
uno::Reference< io::XInputStream > xInStream = xSink->getInputStream();
if ( xInStream.is() )
{
sal_Int32 nInd = 0;
// here aContentTypeInfo[0] - Defaults, and aContentTypeInfo[1] - Overrides
uno::Sequence< uno::Sequence< beans::StringPair > > aContentTypeInfo =
const uno::Sequence< uno::Sequence< beans::StringPair > > aContentTypeInfo =
::comphelper::OFOPXMLHelper::ReadContentTypeSequence( xInStream, m_xContext );
if ( aContentTypeInfo.getLength() != 2 )
throw io::IOException(THROW_WHERE );
// set the implicit types first
for ( nInd = 0; nInd < aContentTypeInfo[0].getLength(); nInd++ )
m_xRootFolder->setChildStreamsTypeByExtension( aContentTypeInfo[0][nInd] );
for ( const auto& rPair : aContentTypeInfo[0] )
m_xRootFolder->setChildStreamsTypeByExtension( rPair );
// now set the explicit types
for ( nInd = 0; nInd < aContentTypeInfo[1].getLength(); nInd++ )
for ( const auto& rPair : aContentTypeInfo[1] )
{
OUString aPath;
if ( aContentTypeInfo[1][nInd].First.toChar() == '/' )
aPath = aContentTypeInfo[1][nInd].First.copy( 1 );
if ( rPair.First.toChar() == '/' )
aPath = rPair.First.copy( 1 );
else
aPath = aContentTypeInfo[1][nInd].First;
aPath = rPair.First;
if ( !aPath.isEmpty() && hasByHierarchicalName( aPath ) )
{
@@ -500,7 +496,7 @@ void ZipPackage::parseContentType()
{
// this is a package stream, in OFOPXML format only streams can have mediatype
ZipPackageStream *pStream = reinterpret_cast < ZipPackageStream* > ( nTest );
pStream->SetMediaType( aContentTypeInfo[1][nInd].Second );
pStream->SetMediaType( rPair.Second );
}
}
}
@@ -604,10 +600,10 @@ void SAL_CALL ZipPackage::initialize( const uno::Sequence< Any >& aArguments )
{
bool bHaveZipFile = true;
for( int ind = 0; ind < aArguments.getLength(); ind++ )
for( const auto& rArgument : aArguments )
{
OUString aParamUrl;
if ( aArguments[ind] >>= aParamUrl )
if ( rArgument >>= aParamUrl )
{
m_eMode = e_IMode_URL;
try
@@ -670,17 +666,17 @@ void SAL_CALL ZipPackage::initialize( const uno::Sequence< Any >& aArguments )
bHaveZipFile = false;
}
}
else if ( aArguments[ind] >>= m_xStream )
else if ( rArgument >>= m_xStream )
{
// a writable stream can implement both XStream & XInputStream
m_eMode = e_IMode_XStream;
m_xContentStream = m_xStream->getInputStream();
}
else if ( aArguments[ind] >>= m_xContentStream )
else if ( rArgument >>= m_xContentStream )
{
m_eMode = e_IMode_XInputStream;
}
else if ( aArguments[ind] >>= aNamedValue )
else if ( rArgument >>= aNamedValue )
{
if ( aNamedValue.Name == "RepairPackage" )
aNamedValue.Value >>= m_bForceRecovery;
@@ -1642,9 +1638,9 @@ const uno::Sequence< sal_Int8 > ZipPackage::GetEncryptionKey()
else
throw uno::RuntimeException(THROW_WHERE "No expected key is provided!" );
for ( sal_Int32 nInd = 0; nInd < m_aStorageEncryptionKeys.getLength(); nInd++ )
if ( m_aStorageEncryptionKeys[nInd].Name == aNameToFind )
m_aStorageEncryptionKeys[nInd].Value >>= aResult;
for ( const auto& rKey : std::as_const(m_aStorageEncryptionKeys) )
if ( rKey.Name == aNameToFind )
rKey.Value >>= aResult;
// empty keys are not allowed here
// so it is not important whether there is no key, or the key is empty, it is an error
@@ -1759,11 +1755,11 @@ void SAL_CALL ZipPackage::setPropertyValue( const OUString& aPropertyName, const
{
bool bHasSHA256 = false;
bool bHasSHA1 = false;
for ( sal_Int32 nInd = 0; nInd < aKeys.getLength(); nInd++ )
for ( const auto& rKey : std::as_const(aKeys) )
{
if ( aKeys[nInd].Name == PACKAGE_ENCRYPTIONDATA_SHA256UTF8 )
if ( rKey.Name == PACKAGE_ENCRYPTIONDATA_SHA256UTF8 )
bHasSHA256 = true;
if ( aKeys[nInd].Name == PACKAGE_ENCRYPTIONDATA_SHA1UTF8 )
if ( rKey.Name == PACKAGE_ENCRYPTIONDATA_SHA1UTF8 )
bHasSHA1 = true;
}
@@ -1783,30 +1779,30 @@ void SAL_CALL ZipPackage::setPropertyValue( const OUString& aPropertyName, const
throw IllegalArgumentException(THROW_WHERE "unexpected algorithms list is provided.", uno::Reference< uno::XInterface >(), 2 );
}
for ( sal_Int32 nInd = 0; nInd < aAlgorithms.getLength(); nInd++ )
for ( const auto& rAlgorithm : std::as_const(aAlgorithms) )
{
if ( aAlgorithms[nInd].Name == "StartKeyGenerationAlgorithm" )
if ( rAlgorithm.Name == "StartKeyGenerationAlgorithm" )
{
sal_Int32 nID = 0;
if ( !( aAlgorithms[nInd].Value >>= nID )
if ( !( rAlgorithm.Value >>= nID )
|| ( nID != xml::crypto::DigestID::SHA256 && nID != xml::crypto::DigestID::SHA1 ) )
throw IllegalArgumentException(THROW_WHERE "Unexpected start key generation algorithm is provided!", uno::Reference< uno::XInterface >(), 2 );
m_nStartKeyGenerationID = nID;
}
else if ( aAlgorithms[nInd].Name == "EncryptionAlgorithm" )
else if ( rAlgorithm.Name == "EncryptionAlgorithm" )
{
sal_Int32 nID = 0;
if ( !( aAlgorithms[nInd].Value >>= nID )
if ( !( rAlgorithm.Value >>= nID )
|| ( nID != xml::crypto::CipherID::AES_CBC_W3C_PADDING && nID != xml::crypto::CipherID::BLOWFISH_CFB_8 ) )
throw IllegalArgumentException(THROW_WHERE "Unexpected start key generation algorithm is provided!", uno::Reference< uno::XInterface >(), 2 );
m_nCommonEncryptionID = nID;
}
else if ( aAlgorithms[nInd].Name == "ChecksumAlgorithm" )
else if ( rAlgorithm.Name == "ChecksumAlgorithm" )
{
sal_Int32 nID = 0;
if ( !( aAlgorithms[nInd].Value >>= nID )
if ( !( rAlgorithm.Value >>= nID )
|| ( nID != xml::crypto::DigestID::SHA1_1K && nID != xml::crypto::DigestID::SHA256_1K ) )
throw IllegalArgumentException(THROW_WHERE "Unexpected start key generation algorithm is provided!", uno::Reference< uno::XInterface >(), 2 );
diff --git a/package/source/zippackage/ZipPackageStream.cxx b/package/source/zippackage/ZipPackageStream.cxx
index dc49729..25c7050 100644
--- a/package/source/zippackage/ZipPackageStream.cxx
+++ b/package/source/zippackage/ZipPackageStream.cxx
@@ -237,9 +237,9 @@ uno::Sequence<sal_Int8> ZipPackageStream::GetEncryptionKey(Bugs const bugs)
else
throw uno::RuntimeException(THROW_WHERE "No expected key is provided!" );
for ( sal_Int32 nInd = 0; nInd < m_aStorageEncryptionKeys.getLength(); nInd++ )
if ( m_aStorageEncryptionKeys[nInd].Name == aNameToFind )
m_aStorageEncryptionKeys[nInd].Value >>= aResult;
for ( const auto& rKey : std::as_const(m_aStorageEncryptionKeys) )
if ( rKey.Name == aNameToFind )
rKey.Value >>= aResult;
// empty keys are not allowed here
// so it is not important whether there is no key, or the key is empty, it is an error
diff --git a/package/source/zippackage/zipfileaccess.cxx b/package/source/zippackage/zipfileaccess.cxx
index f5b0a4b..fe584de 100644
--- a/package/source/zippackage/zipfileaccess.cxx
+++ b/package/source/zippackage/zipfileaccess.cxx
@@ -214,10 +214,8 @@ void SAL_CALL OZipFileAccess::initialize( const uno::Sequence< uno::Any >& aArgu
}
else if (aArguments[0] >>= aArgs)
{
for (sal_Int32 i = 0; i < aArgs.getLength(); ++i)
for (const beans::NamedValue& rArg : std::as_const(aArgs))
{
const beans::NamedValue& rArg = aArgs[i];
if (rArg.Name == "URL")
rArg.Value >>= aParamURL;
}
