20#include <config_features.h>
64 pSrc_->Convert(
eType);
97 if( nIdx > SBX_MAXINDEX32 )
99 SetError( ERRCODE_BASIC_OUT_OF_RANGE );
102 if ( mVarEntries.size() <= nIdx )
103 mVarEntries.resize(nIdx+1);
105 return mVarEntries[nIdx].mpVar;
108SbxVariable* SbxArray::Get( sal_uInt32 nIdx )
112 SetError( ERRCODE_BASIC_PROP_WRITEONLY );
115 SbxVariableRef& rRef = GetRef( nIdx );
118 rRef = new SbxVariable( eType );
123void SbxArray::Put( SbxVariable* pVar, sal_uInt32 nIdx )
126 SetError( ERRCODE_BASIC_PROP_READONLY );
130 if( eType != SbxVARIANT )
131 // Convert no objects
132 if( eType != SbxOBJECT || pVar->GetClass() != SbxClassType::Object )
133 pVar->Convert( eType );
134 SbxVariableRef& rRef = GetRef( nIdx );
135 // tdf#122250. It is possible that I hold the last reference to myself, so check, otherwise I might
136 // call SetFlag on myself after I have died.
137 bool removingMyself = rRef && rRef->GetParameters() == this && GetRefCount() == 1;
138 if( rRef.get() != pVar )
142 SetFlag( SbxFlagBits::Modified );
147OUString SbxArray::GetAlias( sal_uInt32 nIdx )
151 SetError( ERRCODE_BASIC_PROP_WRITEONLY );
154 SbxVarEntry& rRef = reinterpret_cast<SbxVarEntry&>(GetRef( nIdx ));
159 return *rRef.maAlias;
162void SbxArray::PutAlias( const OUString& rAlias, sal_uInt32 nIdx )
166 SetError( ERRCODE_BASIC_PROP_READONLY );
170 SbxVarEntry& rRef = reinterpret_cast<SbxVarEntry&>( GetRef( nIdx ) );
171 rRef.maAlias = rAlias;
175void SbxArray::Insert( SbxVariable* pVar, sal_uInt32 nIdx )
177 DBG_ASSERT( mVarEntries.size() <= SBX_MAXINDEX32, "SBX: Array gets too big
" );
178 if( mVarEntries.size() > SBX_MAXINDEX32 )
184 size_t nSize = mVarEntries.size();
189 if( eType != SbxVARIANT && pVar )
191 p.mpVar->Convert(eType);
195 mVarEntries.push_back( p );
199 mVarEntries.insert( mVarEntries.begin() + nIdx, p );
201 SetFlag( SbxFlagBits::Modified );
204void SbxArray::Remove( sal_uInt32 nIdx )
206 if( nIdx < mVarEntries.size() )
208 mVarEntries.erase( mVarEntries.begin() + nIdx );
209 SetFlag( SbxFlagBits::Modified );
213void SbxArray::Remove( SbxVariable const * pVar )
217 for( size_t i = 0; i < mVarEntries.size(); i++ )
219 if (mVarEntries[i].mpVar.get() == pVar)
227// Taking over of the data from the passed array, at which
228// the variable of the same name will be overwritten.
230void SbxArray::Merge( SbxArray* p )
235 for (auto& rEntry1: p->mVarEntries)
237 if (!rEntry1.mpVar.is())
240 OUString aName = rEntry1.mpVar->GetName();
241 sal_uInt16 nHash = rEntry1.mpVar->GetHashCode();
243 // Is the element by the same name already inside?
245 for (auto& rEntry2: mVarEntries)
247 if (!rEntry2.mpVar.is())
250 if (rEntry2.mpVar->GetHashCode() == nHash &&
251 rEntry2.mpVar->GetName().equalsIgnoreAsciiCase(aName))
253 // Take this element and clear the original.
254 rEntry2.mpVar = rEntry1.mpVar;
255 rEntry1.mpVar.clear();
260 if (rEntry1.mpVar.is())
262 // We don't have element with the same name. Add a new entry.
263 SbxVarEntry aNewEntry;
264 aNewEntry.mpVar = rEntry1.mpVar;
266 aNewEntry.maAlias = *rEntry1.maAlias;
267 mVarEntries.push_back(aNewEntry);
272// Search of an element by his name and type. If an element is an object,
273// it will also be scanned...
275SbxVariable* SbxArray::Find( const OUString& rName, SbxClassType t )
277 SbxVariable* p = nullptr;
278 if( mVarEntries.empty() )
280 bool bExtSearch = IsSet( SbxFlagBits::ExtSearch );
281 sal_uInt16 nHash = SbxVariable::MakeHashCode( rName );
282 const OUString aNameCI = SbxVariable::NameToCaseInsensitiveName(rName);
283 for (auto& rEntry : mVarEntries)
285 if (!rEntry.mpVar.is() || !rEntry.mpVar->IsVisible())
288 // The very secure search works as well, if there is no hashcode!
289 sal_uInt16 nVarHash = rEntry.mpVar->GetHashCode();
290 // tdf#148358 - compare the names case-insensitive
291 if ( (!nVarHash || nVarHash == nHash)
292 && (t == SbxClassType::DontCare || rEntry.mpVar->GetClass() == t)
293 && (rEntry.mpVar->GetName(SbxNameType::CaseInsensitive) == aNameCI))
295 p = rEntry.mpVar.get();
296 p->ResetFlag(SbxFlagBits::ExtFound);
300 // Did we have an array/object with extended search?
301 if (bExtSearch && rEntry.mpVar->IsSet(SbxFlagBits::ExtSearch))
303 switch (rEntry.mpVar->GetClass())
305 case SbxClassType::Object:
307 // Objects are not allowed to scan their parent.
308 SbxFlagBits nOld = rEntry.mpVar->GetFlags();
309 rEntry.mpVar->ResetFlag(SbxFlagBits::GlobalSearch);
310 p = static_cast<SbxObject&>(*rEntry.mpVar).Find(rName, t);
311 rEntry.mpVar->SetFlags(nOld);
314 case SbxClassType::Array:
315 // Casting SbxVariable to SbxArray? Really?
316 p = reinterpret_cast<SbxArray&>(*rEntry.mpVar).Find(rName, t);
324 p->SetFlag(SbxFlagBits::ExtFound);
332bool SbxArray::LoadData( SvStream& rStrm, sal_uInt16 /*nVer*/ )
337 SbxFlagBits f = nFlags;
338 nFlags |= SbxFlagBits::Write;
339 rStrm.ReadUInt16( nElem );
341 for( sal_uInt32 n = 0; n < nElem; n++ )
344 rStrm.ReadUInt16( nIdx );
345 SbxVariableRef pVar = static_cast<SbxVariable*>(Load( rStrm ).get());
348 SbxVariableRef& rRef = GetRef( nIdx );
361std::pair<bool, sal_uInt32> SbxArray::StoreData( SvStream& rStrm ) const
363 sal_uInt32 nElem = 0;
364 // Which elements are even defined?
365 for( auto& rEntry: mVarEntries )
367 if (rEntry.mpVar.is() && !(rEntry.mpVar->GetFlags() & SbxFlagBits::DontStore))
370 rStrm.WriteUInt16( nElem );
372 sal_uInt32 nVersion = B_IMG_VERSION_12;
373 for( size_t n = 0; n < mVarEntries.size(); n++ )
375 const SbxVarEntry& rEntry = mVarEntries[n];
376 if (rEntry.mpVar.is() && !(rEntry.mpVar->GetFlags() & SbxFlagBits::DontStore))
378 rStrm.WriteUInt16( n );
379 const auto& [bSuccess, nVersionModule] = rEntry.mpVar->Store(rStrm);
382 else if (nVersionModule > nVersion)
384 nVersion = nVersionModule;
388 return { true, nVersion };
391// #100883 Method to set method directly to parameter array
392void SbxArray::PutDirect( SbxVariable* pVar, sal_uInt32 nIdx )
394 SbxVariableRef& rRef = GetRef( nIdx );
401SbxDimArray::SbxDimArray( SbxDataType t ) : SbxArray( t ), mbHasFixedSize( false )
405SbxDimArray& SbxDimArray::operator=( const SbxDimArray& rArray )
407 if( &rArray != this )
409 SbxArray::operator=( static_cast<const SbxArray&>(rArray) );
410 m_vDimensions = rArray.m_vDimensions;
411 mbHasFixedSize = rArray.mbHasFixedSize;
416SbxDimArray::~SbxDimArray()
420void SbxDimArray::Clear()
422 m_vDimensions.clear();
428void SbxDimArray::AddDimImpl( sal_Int32 lb, sal_Int32 ub, bool bAllowSize0 )
430 ErrCode eRes = ERRCODE_NONE;
431 if( ub < lb && !bAllowSize0 )
433 eRes = ERRCODE_BASIC_OUT_OF_RANGE;
439 d.nSize = ub - lb + 1;
440 m_vDimensions.push_back(d);
445void SbxDimArray::AddDim( sal_Int32 lb, sal_Int32 ub )
447 AddDimImpl( lb, ub, false );
450void SbxDimArray::unoAddDim( sal_Int32 lb, sal_Int32 ub )
452 AddDimImpl( lb, ub, true );
456// Readout dimension data
458bool SbxDimArray::GetDim( sal_Int32 n, sal_Int32& rlb, sal_Int32& rub ) const
460 if( n < 1 || o3tl::make_unsigned(n) > m_vDimensions.size() )
462 SetError( ERRCODE_BASIC_OUT_OF_RANGE );
466 SbxDim d = m_vDimensions[n - 1];
472// Element-Ptr with the help of an index list
474sal_uInt32 SbxDimArray::Offset( const sal_Int32* pIdx )
477 for( const auto& rDimension : m_vDimensions )
479 sal_Int32 nIdx = *pIdx++;
480 if( nIdx < rDimension.nLbound || nIdx > rDimension.nUbound )
482 nPos = sal_uInt32(SBX_MAXINDEX32) + 1; break;
484 nPos = nPos * rDimension.nSize + nIdx - rDimension.nLbound;
486 if( m_vDimensions.empty() || nPos > SBX_MAXINDEX32 )
488 SetError( ERRCODE_BASIC_OUT_OF_RANGE );
494SbxVariable* SbxDimArray::Get( const sal_Int32* pIdx )
496 return SbxArray::Get( Offset( pIdx ) );
499void SbxDimArray::Put( SbxVariable* p, const sal_Int32* pIdx )
501 SbxArray::Put( p, Offset( pIdx ) );
504// Element-Number with the help of Parameter-Array
505sal_uInt32 SbxDimArray::Offset( SbxArray* pPar )
507#if HAVE_FEATURE_SCRIPTING
508 if (m_vDimensions.empty() || !pPar ||
509 ((m_vDimensions.size() != sal::static_int_cast<size_t>(pPar->Count() - 1))
510 && SbiRuntime::isVBAEnabled()))
512 SetError( ERRCODE_BASIC_OUT_OF_RANGE );
517 sal_uInt32 nOff = 1; // Non element 0!
518 for (auto const& vDimension : m_vDimensions)
520 sal_Int32 nIdx = pPar->Get( nOff++ )->GetLong();
521 if( nIdx < vDimension.nLbound || nIdx > vDimension.nUbound )
523 nPos = sal_uInt32(SBX_MAXINDEX32)+1;
526 nPos = nPos * vDimension.nSize + nIdx - vDimension.nLbound;
530 if( nPos > o3tl::make_unsigned(SBX_MAXINDEX32) )
532 SetError( ERRCODE_BASIC_OUT_OF_RANGE );
538SbxVariable* SbxDimArray::Get( SbxArray* pPar )
540 return SbxArray::Get( Offset( pPar ) );
543bool SbxDimArray::LoadData( SvStream& rStrm, sal_uInt16 nVer )
546 rStrm.ReadInt16(nTmp);
550 auto nDimension = o3tl::make_unsigned(nTmp);
552 const size_t nMinRecordSize = 4;
553 const size_t nMaxPossibleRecords = rStrm.remainingSize() / nMinRecordSize;
554 if (nDimension > nMaxPossibleRecords)
560 for (decltype(nDimension) i = 0; i < nDimension && rStrm.GetError() == ERRCODE_NONE; ++i)
562 sal_Int16 lb(0), ub(0);
563 rStrm.ReadInt16( lb ).ReadInt16( ub );
567 return SbxArray::LoadData( rStrm, nVer );
570std::pair<bool, sal_uInt32> SbxDimArray::StoreData( SvStream& rStrm ) const
572 assert(m_vDimensions.size() <= sal::static_int_cast<size_t>(std::numeric_limits<sal_Int16>::max()));
573 rStrm.WriteInt16( m_vDimensions.size() );
574 for( std::size_t i = 1; i <= m_vDimensions.size(); i++ )
576 sal_Int32 lb32, ub32;
577 GetDim(i, lb32, ub32);
578 assert(lb32 >= -SBX_MAXINDEX && ub32 <= SBX_MAXINDEX);
579 rStrm.WriteInt16(lb32).WriteInt16(ub32);
581 return SbxArray::StoreData( rStrm );
584/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
SbxArray & operator=(const SbxArray &)
virtual SbxDataType GetType() const override
SbxVariableRef & GetRef(sal_uInt32)
SbxArray(SbxDataType=SbxVARIANT)
virtual void Clear() override
std::vector< SbxVarEntry > mVarEntries
virtual ~SbxArray() override
void SetFlag(SbxFlagBits n)
virtual bool LoadData(SvStream &, sal_uInt16) override
#define DBG_ASSERT(sCon, aError)
constexpr auto SBX_MAXINDEX32
std::optional< OUString > maAlias