GCC 4.7 build breakers

comphelper/inc/comphelper/InlineContainer.hxx

@@ -95,7 +95,7 @@ public:
     explicit MakeSet(const T &a)
         : ::std::set< T >()
     {
-        insert(this->end(), a);
+        this->insert(this->end(), a);
     }
     MakeSet &operator()(const T &a)
     {

comphelper/inc/comphelper/sequenceasvector.hxx

@@ -139,7 +139,7 @@ class SequenceAsVector : public ::std::vector< TElementType >
             const TElementType* pSource = lSource.getConstArray();
 
             for (sal_Int32 i=0; i<c; ++i)
-                push_back(pSource[i]);
+                this->push_back(pSource[i]);
         }
 
         //---------------------------------------

cosv/inc/cosv/stringdata.hxx

@@ -26,7 +26,7 @@
 
 
 #include <cosv/str_types.hxx>
-
+#include <cstring>
 
 
 namespace csv

o3tl/inc/o3tl/lazy_update.hxx

@@ -97,12 +97,12 @@ output( myValue.getOutValue() );
 
             void               setInValue( input_type const& rIn ) { Functor::m_bCacheDirty = true; m_aInput = rIn; }
             input_type const&  getInValue()  const                 { return m_aInput; }
-            output_type const& getOutValue() const                 { return implUpdateValue(m_aInput); }
+            output_type const& getOutValue() const                 { return this->implUpdateValue(m_aInput); }
 
             input_type& operator*()  { Functor::m_bCacheDirty = true; return m_aInput;  }
             input_type* operator->() { Functor::m_bCacheDirty = true; return &m_aInput; }
 
-            output_type const& operator*() const  { return implUpdateValue(m_aInput);  }
+            output_type const& operator*() const  { return this->implUpdateValue(m_aInput);  }
             output_type const* operator->() const { return &implUpdateValue(m_aInput); }
 
         private:

o3tl/inc/o3tl/vector_pool.hxx

@@ -60,7 +60,7 @@ namespace o3tl
                 }
                 else
                 {
-                    push_back(value_type(rCopy));
+                    this->push_back(value_type(rCopy));
                     return this->size()-1;
                 }
             }

oox/inc/oox/drawingml/chart/modelbase.hxx

@@ -46,13 +46,13 @@ public:
 
     inline bool         is() const { return this->get() != 0; }
 
-    inline ModelType&   create() { reset( new ModelType ); return **this; }
+    inline ModelType&   create() { this->reset( new ModelType ); return **this; }
     template< typename Param1Type >
-    inline ModelType&   create( const Param1Type& rParam1 ) { reset( new ModelType( rParam1 ) ); return **this; }
+    inline ModelType&   create( const Param1Type& rParam1 ) { this->reset( new ModelType( rParam1 ) ); return **this; }
 
-    inline ModelType&   getOrCreate() { if( !*this ) reset( new ModelType ); return **this; }
+    inline ModelType&   getOrCreate() { if( !*this ) this->reset( new ModelType ); return **this; }
     template< typename Param1Type >
-    inline ModelType&   getOrCreate( const Param1Type& rParam1 ) { if( !*this ) reset( new ModelType( rParam1 ) ); return **this; }
+    inline ModelType&   getOrCreate( const Param1Type& rParam1 ) { if( !*this ) this->reset( new ModelType( rParam1 ) ); return **this; }
 };
 
 // ============================================================================

oox/inc/oox/helper/refmap.hxx

@@ -165,7 +165,7 @@ private:
 
     inline const mapped_type* getRef( key_type nKey ) const
                         {
-                            typename container_type::const_iterator aIt = find( nKey );
+                            typename container_type::const_iterator aIt = this->find( nKey );
                             return (aIt == this->end()) ? 0 : &aIt->second;
                         }
 };

sc/inc/compressedarray.hxx

@@ -546,18 +546,18 @@ public:
 template< typename A, typename D >
 void ScBitMaskCompressedArray<A,D>::AndValue( A nPos, const D& rValueToAnd )
 {
-    const D& rValue = GetValue( nPos);
+    const D& rValue = this->GetValue( nPos);
     if ((rValue & rValueToAnd) != rValue)
-        SetValue( nPos, rValue & rValueToAnd);
+        this->SetValue( nPos, rValue & rValueToAnd);
 }
 
 
 template< typename A, typename D >
 void ScBitMaskCompressedArray<A,D>::OrValue( A nPos, const D& rValueToOr )
 {
-    const D& rValue = GetValue( nPos);
+    const D& rValue = this->GetValue( nPos);
     if ((rValue | rValueToOr) != rValue)
-        SetValue( nPos, rValue | rValueToOr);
+        this->SetValue( nPos, rValue | rValueToOr);
 }
 
 

sc/source/core/data/compressedarray.cxx

@@ -363,7 +363,7 @@ A ScCompressedArray<A,D>::GetLastUnequalAccess( A nStart, const D& rCompare )
 template< typename A, typename D >
 unsigned long ScSummableCompressedArray<A,D>::SumValues( A nStart, A nEnd ) const
 {
-    size_t nIndex = Search( nStart);
+    size_t nIndex = this->Search( nStart);
     unsigned long nSum = SumValuesContinuation( nStart, nEnd, nIndex);
     if (nEnd > this->nMaxAccess)
         nSum += this->pData[this->nCount-1].aValue * (nEnd - this->nMaxAccess);
@@ -425,17 +425,17 @@ void ScBitMaskCompressedArray<A,D>::AndValue( A nStart, A nEnd,
     if (nStart > nEnd)
         return;
 
-    size_t nIndex = Search( nStart);
+    size_t nIndex = this->Search( nStart);
     do
     {
         if ((this->pData[nIndex].aValue & rValueToAnd) != this->pData[nIndex].aValue)
         {
             A nS = ::std::max( (nIndex>0 ? this->pData[nIndex-1].nEnd+1 : 0), nStart);
             A nE = ::std::min( this->pData[nIndex].nEnd, nEnd);
-            SetValue( nS, nE, this->pData[nIndex].aValue & rValueToAnd);
+            this->SetValue( nS, nE, this->pData[nIndex].aValue & rValueToAnd);
             if (nE >= nEnd)
                 break;  // while
-            nIndex = Search( nE + 1);
+            nIndex = this->Search( nE + 1);
         }
         else if (this->pData[nIndex].nEnd >= nEnd)
             break;  // while
@@ -452,17 +452,17 @@ void ScBitMaskCompressedArray<A,D>::OrValue( A nStart, A nEnd,
     if (nStart > nEnd)
         return;
 
-    size_t nIndex = Search( nStart);
+    size_t nIndex = this->Search( nStart);
     do
     {
         if ((this->pData[nIndex].aValue | rValueToOr) != this->pData[nIndex].aValue)
         {
             A nS = ::std::max( (nIndex>0 ? this->pData[nIndex-1].nEnd+1 : 0), nStart);
             A nE = ::std::min( this->pData[nIndex].nEnd, nEnd);
-            SetValue( nS, nE, this->pData[nIndex].aValue | rValueToOr);
+            this->SetValue( nS, nE, this->pData[nIndex].aValue | rValueToOr);
             if (nE >= nEnd)
                 break;  // while
-            nIndex = Search( nE + 1);
+            nIndex = this->Search( nE + 1);
         }
         else if (this->pData[nIndex].nEnd >= nEnd)
             break;  // while
@@ -487,7 +487,7 @@ void ScBitMaskCompressedArray<A,D>::CopyFromAnded(
         nRegionEnd -= nSourceDy;
         if (nRegionEnd > nEnd)
             nRegionEnd = nEnd;
-        SetValue( j, nRegionEnd, rValue & rValueToAnd);
+        this->SetValue( j, nRegionEnd, rValue & rValueToAnd);
         j = nRegionEnd;
     }
 }
@@ -508,7 +508,7 @@ void ScBitMaskCompressedArray<A,D>::CopyFromOred(
         nRegionEnd -= nSourceDy;
         if (nRegionEnd > nEnd)
             nRegionEnd = nEnd;
-        SetValue( j, nRegionEnd, rValue | rValueToOr);
+        this->SetValue( j, nRegionEnd, rValue | rValueToOr);
         j = nRegionEnd;
     }
 }
@@ -519,7 +519,7 @@ A ScBitMaskCompressedArray<A,D>::GetBitStateStart( A nEnd,
         const D& rBitMask, const D& rMaskedCompare ) const
 {
     A nStart = ::std::numeric_limits<A>::max();
-    size_t nIndex = Search( nEnd);
+    size_t nIndex = this->Search( nEnd);
     while ((this->pData[nIndex].aValue & rBitMask) == rMaskedCompare)
     {
         if (nIndex > 0)
@@ -542,7 +542,7 @@ A ScBitMaskCompressedArray<A,D>::GetBitStateEnd( A nStart,
         const D& rBitMask, const D& rMaskedCompare ) const
 {
     A nEnd = ::std::numeric_limits<A>::max();
-    size_t nIndex = Search( nStart);
+    size_t nIndex = this->Search( nStart);
     while (nIndex < this->nCount && (this->pData[nIndex].aValue & rBitMask) ==
             rMaskedCompare)
     {
@@ -557,7 +557,7 @@ template< typename A, typename D >
 A ScBitMaskCompressedArray<A,D>::GetFirstForCondition( A nStart, A nEnd,
         const D& rBitMask, const D& rMaskedCompare ) const
 {
-    size_t nIndex = Search( nStart);
+    size_t nIndex = this->Search( nStart);
     do
     {
         if ((this->pData[nIndex].aValue & rBitMask) == rMaskedCompare)
@@ -577,7 +577,7 @@ template< typename A, typename D >
 A ScBitMaskCompressedArray<A,D>::GetLastForCondition( A nStart, A nEnd,
         const D& rBitMask, const D& rMaskedCompare ) const
 {
-    size_t nIndex = Search( nEnd);
+    size_t nIndex = this->Search( nEnd);
     while (1)
     {
         if ((this->pData[nIndex].aValue & rBitMask) == rMaskedCompare)
@@ -601,7 +601,7 @@ A ScBitMaskCompressedArray<A,D>::CountForCondition( A nStart, A nEnd,
         const D& rBitMask, const D& rMaskedCompare ) const
 {
     A nRet = 0;
-    size_t nIndex = Search( nStart);
+    size_t nIndex = this->Search( nStart);
     do
     {
         if ((this->pData[nIndex].aValue & rBitMask) == rMaskedCompare)
@@ -624,7 +624,7 @@ size_t ScBitMaskCompressedArray<A,D>::FillArrayForCondition( A nStart, A nEnd,
         A * pArray, size_t nArraySize ) const
 {
     size_t nUsed = 0;
-    size_t nIndex = Search( nStart);
+    size_t nIndex = this->Search( nStart);
     while (nIndex < this->nCount && nUsed < nArraySize)
     {
         if ((this->pData[nIndex].aValue & rBitMask) == rMaskedCompare)
@@ -646,7 +646,7 @@ template< typename A, typename D >
 bool ScBitMaskCompressedArray<A,D>::HasCondition( A nStart, A nEnd,
         const D& rBitMask, const D& rMaskedCompare ) const
 {
-    size_t nIndex = Search( nStart);
+    size_t nIndex = this->Search( nStart);
     do
     {
         if ((this->pData[nIndex].aValue & rBitMask) == rMaskedCompare)
@@ -664,7 +664,7 @@ A ScBitMaskCompressedArray<A,D>::CountForAnyBitCondition( A nStart, A nEnd,
         const D& rBitMask ) const
 {
     A nRet = 0;
-    size_t nIndex = Search( nStart);
+    size_t nIndex = this->Search( nStart);
     do
     {
         if ((this->pData[nIndex].aValue & rBitMask) != 0)
@@ -718,7 +718,7 @@ unsigned long ScBitMaskCompressedArray<A,D>::SumCoupledArrayForCondition(
 {
     unsigned long nSum = 0;
     A nS = nStart;
-    size_t nIndex1 = Search( nStart);
+    size_t nIndex1 = this->Search( nStart);
     size_t nIndex2 = rArray.Search( nStart);
     do
     {
@@ -752,7 +752,7 @@ unsigned long ScBitMaskCompressedArray<A,D>::SumScaledCoupledArrayForCondition(
 {
     unsigned long nSum = 0;
     A nS = nStart;
-    size_t nIndex1 = Search( nStart);
+    size_t nIndex1 = this->Search( nStart);
     size_t nIndex2 = rArray.Search( nStart);
     do
     {

sc/source/filter/inc/ftools.hxx

@@ -233,14 +233,14 @@ public:
     /** Returns true, if the object accossiated to the passed key exists. */
     inline bool         has( key_type nKey ) const
                         {
-                            typename map_type::const_iterator aIt = find( nKey );
+                            typename map_type::const_iterator aIt = this->find( nKey );
                             return (aIt != this->end()) && aIt->second.is();
                         }
 
     /** Returns a reference to the object accossiated to the passed key, or 0 on error. */
     inline ref_type     get( key_type nKey ) const
                         {
-                            typename map_type::const_iterator aIt = find( nKey );
+                            typename map_type::const_iterator aIt = this->find( nKey );
                             if( aIt != this->end() ) return aIt->second;
                             return ref_type();
                         }

sfx2/inc/sfx2/controlwrapper.hxx

@@ -631,13 +631,13 @@ void MetricFieldWrapper< ValueT >::SetControlValue( ValueT nValue )
 template< typename ValueT >
 ValueT ListBoxWrapper< ValueT >::GetControlValue() const
 {
-    return GetValueFromPos( this->GetControl().GetSelectEntryPos() );
+    return this->GetValueFromPos( this->GetControl().GetSelectEntryPos() );
 }
 
 template< typename ValueT >
 void ListBoxWrapper< ValueT >::SetControlValue( ValueT nValue )
 {
-    sal_uInt16 nPos = GetPosFromValue( nValue );
+    sal_uInt16 nPos = this->GetPosFromValue( nValue );
     if( nPos != this->GetNotFoundPos() )
         this->GetControl().SelectEntryPos( nPos );
 }
@@ -647,13 +647,13 @@ void ListBoxWrapper< ValueT >::SetControlValue( ValueT nValue )
 template< typename ValueT >
 ValueT ValueSetWrapper< ValueT >::GetControlValue() const
 {
-    return GetValueFromPos( this->GetControl().GetSelectItemId() );
+    return this->GetValueFromPos( this->GetControl().GetSelectItemId() );
 }
 
 template< typename ValueT >
 void ValueSetWrapper< ValueT >::SetControlValue( ValueT nValue )
 {
-    sal_uInt16 nPos = GetPosFromValue( nValue );
+    sal_uInt16 nPos = this->GetPosFromValue( nValue );
     if( nPos != this->GetNotFoundPos() )
         this->GetControl().SelectItem( nPos );
 }

slideshow/source/inc/tools.hxx

@@ -71,6 +71,13 @@ namespace slideshow
 
         typedef ::boost::shared_ptr< GDIMetaFile > GDIMetaFileSharedPtr;
 
+        template <typename T>
+        inline ::std::size_t hash_value( T * const& p )
+        {
+            ::std::size_t d = static_cast< ::std::size_t >(
+                reinterpret_cast< ::std::ptrdiff_t >(p) );
+            return d + (d >> 3);
+        }
         // xxx todo: remove with boost::hash when 1.33 is available
         template <typename T>
         struct hash : ::std::unary_function<T, ::std::size_t>
@@ -79,14 +86,10 @@ namespace slideshow
                 return hash_value(val);
             }
         };
-        template <typename T>
-        inline ::std::size_t hash_value( T * const& p )
-        {
-            ::std::size_t d = static_cast< ::std::size_t >(
-                reinterpret_cast< ::std::ptrdiff_t >(p) );
-            return d + (d >> 3);
-        }
+    }
+}
 
+namespace com { namespace sun { namespace star { namespace uno {
         // xxx todo: shift to namespace com::sun::star::uno when
         //           1.33 is available
         template <typename T>
@@ -98,9 +101,14 @@ namespace slideshow
             ::com::sun::star::uno::Reference<
                   ::com::sun::star::uno::XInterface> const xRoot(
                       x, ::com::sun::star::uno::UNO_QUERY );
-            return hash<void *>()(xRoot.get());
+            return slideshow::internal::hash<void *>()(xRoot.get());
         }
+}}}}
 
+namespace slideshow
+{
+    namespace internal
+    {
         /** Cycle mode of intrinsic animations
          */
         enum CycleMode

soltools/inc/st_list.hxx

@@ -290,7 +290,7 @@ DynamicList<XY>::operator=( const DynamicList<XY> & i_rList )
           it != i_rList.end();
           ++it )
     {
-         push_back( new XY(*(*it)) );
+        this->push_back( new XY(*(*it)) );
     }
     return *this;
 }
@@ -303,7 +303,7 @@ DynamicList<XY>::Insert(unsigned pos, XY * const & elem_)
     if ( pos > this->len )
       return;
 
-    checkSize(DynamicList<XY>::len+2);
+    this->checkSize(DynamicList<XY>::len+2);
     memmove( DynamicList<XY>::inhalt+pos+1, DynamicList<XY>::inhalt+pos, (DynamicList<XY>::len-pos) * sizeof(XY*) );
     this->inhalt[pos] = elem_;
     this->len++;

xml2cmp/source/support/list.hxx

@@ -224,7 +224,7 @@ DynamicList<XY>::insert(unsigned pos, XY * const & elem_)
     if ( pos > this->len )
       return;
 
-    checkSize(this->len+2);
+    this->checkSize(this->len+2);
     memmove(this->inhalt[pos+1], this->inhalt[pos], (this->len-pos) * sizeof(XY*) );
     this->inhalt[pos] = elem_;
     this->len++;