Drop :: prefix from std in [a-b]*/

Change-Id: I0422aaf39bbce889c95ed9a81a0784cb03a1badd
Reviewed-on: https://gerrit.libreoffice.org/34320
Tested-by: Jenkins <ci@libreoffice.org>
Reviewed-by: Tor Lillqvist <tml@collabora.com>

24 files changed, 113 insertions, 113 deletions

diff --git a/basegfx/source/color/bcolortools.cxx b/basegfx/source/color/bcolortools.cxx
index 095ea50aa5f9..b28607bf298d 100644
--- a/basegfx/source/color/bcolortools.cxx
+++ b/basegfx/source/color/bcolortools.cxx
@@ -26,8 +26,8 @@ namespace basegfx { namespace tools
     BColor rgb2hsl(const BColor& rRGBColor)
     {
         const double r=rRGBColor.getRed(), g=rRGBColor.getGreen(), b=rRGBColor.getBlue();
-        const double minVal = ::std::min( ::std::min( r, g ), b );
-        const double maxVal = ::std::max( ::std::max( r, g ), b );
+        const double minVal = std::min( std::min( r, g ), b );
+        const double maxVal = std::max( std::max( r, g ), b );
         const double d = maxVal - minVal;
 
         double h=0, s=0, l=0;
diff --git a/basegfx/source/curve/b2dbeziertools.cxx b/basegfx/source/curve/b2dbeziertools.cxx
index d1e98c980f8e..ec6ef1c63213 100644
--- a/basegfx/source/curve/b2dbeziertools.cxx
+++ b/basegfx/source/curve/b2dbeziertools.cxx
@@ -104,7 +104,7 @@ namespace basegfx
         }
 
         // it is a bezier
-        ::std::vector< double >::const_iterator aIter = ::std::lower_bound(maLengthArray.begin(), maLengthArray.end(), fDistance);
+        std::vector< double >::const_iterator aIter = std::lower_bound(maLengthArray.begin(), maLengthArray.end(), fDistance);
         const sal_uInt32 nIndex(aIter - maLengthArray.begin());
         const double fHighBound(maLengthArray[nIndex]);
         const double fLowBound(nIndex ?  maLengthArray[nIndex - 1] : 0.0);
diff --git a/basegfx/source/curve/b2dcubicbezier.cxx b/basegfx/source/curve/b2dcubicbezier.cxx
index ed81ea37b194..ca4aa090625f 100644
--- a/basegfx/source/curve/b2dcubicbezier.cxx
+++ b/basegfx/source/curve/b2dcubicbezier.cxx
@@ -281,7 +281,7 @@ namespace basegfx
                 const double fJ1y(rfEA.getY() - rfPA.getY() - 1.0/3.0*(rfPB.getY() - rfPA.getY()));
                 const double fJ2x(rfEB.getX() - rfPA.getX() - 2.0/3.0*(rfPB.getX() - rfPA.getX()));
                 const double fJ2y(rfEB.getY() - rfPA.getY() - 2.0/3.0*(rfPB.getY() - rfPA.getY()));
-                const double fDistanceError2(::std::max(fJ1x*fJ1x + fJ1y*fJ1y, fJ2x*fJ2x + fJ2y*fJ2y));
+                const double fDistanceError2(std::max(fJ1x*fJ1x + fJ1y*fJ1y, fJ2x*fJ2x + fJ2y*fJ2y));
 
                 // stop if error measure does not improve anymore. This is a
                 // safety guard against floating point inaccuracies.
@@ -640,7 +640,7 @@ namespace basegfx
         if(isBezier())
         {
             ImpSubDivDistance(maStartPoint, maControlPointA, maControlPointB, maEndPoint, rTarget,
-                fDistanceBound * fDistanceBound, ::std::numeric_limits<double>::max(), 30);
+                fDistanceBound * fDistanceBound, std::numeric_limits<double>::max(), 30);
         }
         else
         {
@@ -912,7 +912,7 @@ namespace basegfx
 
     bool B2DCubicBezier::getMinimumExtremumPosition(double& rfResult) const
     {
-        ::std::vector< double > aAllResults;
+        std::vector< double > aAllResults;
 
         aAllResults.reserve(4);
         getAllExtremumPositions(aAllResults);
@@ -930,14 +930,14 @@ namespace basegfx
         }
         else
         {
-            rfResult = *(::std::min_element(aAllResults.begin(), aAllResults.end()));
+            rfResult = *(std::min_element(aAllResults.begin(), aAllResults.end()));
             return true;
         }
     }
 
     namespace
     {
-        inline void impCheckExtremumResult(double fCandidate, ::std::vector< double >& rResult)
+        inline void impCheckExtremumResult(double fCandidate, std::vector< double >& rResult)
         {
             // check for range ]0.0 .. 1.0[ with excluding 1.0 and 0.0 clearly
             // by using the equalZero test, NOT ::more or ::less which will use the
@@ -952,7 +952,7 @@ namespace basegfx
         }
     }
 
-    void B2DCubicBezier::getAllExtremumPositions(::std::vector< double >& rResults) const
+    void B2DCubicBezier::getAllExtremumPositions(std::vector< double >& rResults) const
     {
         rResults.clear();
 
diff --git a/basegfx/source/polygon/b2dlinegeometry.cxx b/basegfx/source/polygon/b2dlinegeometry.cxx
index 1b5b7be6da61..916d5263a5d6 100644
--- a/basegfx/source/polygon/b2dlinegeometry.cxx
+++ b/basegfx/source/polygon/b2dlinegeometry.cxx
@@ -245,7 +245,7 @@ namespace basegfx
                     {
                         // before splitting recursively with internal simple criteria, use
                         // ExtremumPosFinder to remove those
-                        ::std::vector< double > aExtremumPositions;
+                        std::vector< double > aExtremumPositions;
 
                         aExtremumPositions.reserve(4);
                         aEdge.getAllExtremumPositions(aExtremumPositions);
@@ -257,7 +257,7 @@ namespace basegfx
                             if(nCount > 1)
                             {
                                 // create order from left to right
-                                ::std::sort(aExtremumPositions.begin(), aExtremumPositions.end());
+                                std::sort(aExtremumPositions.begin(), aExtremumPositions.end());
                             }
 
                             for(sal_uInt32 b(0); b < nCount;)
diff --git a/basegfx/source/polygon/b2dpolygon.cxx b/basegfx/source/polygon/b2dpolygon.cxx
index 2cf40a12175c..8ec8d63104bc 100644
--- a/basegfx/source/polygon/b2dpolygon.cxx
+++ b/basegfx/source/polygon/b2dpolygon.cxx
@@ -52,7 +52,7 @@ public:
 
 class CoordinateDataArray2D
 {
-    typedef ::std::vector< CoordinateData2D > CoordinateData2DVector;
+    typedef std::vector< CoordinateData2D > CoordinateData2DVector;
 
     CoordinateData2DVector                          maVector;
 
@@ -152,7 +152,7 @@ public:
 
             for(sal_uInt32 a(0); a < nHalfSize; a++)
             {
-                ::std::swap(*aStart, *aEnd);
+                std::swap(*aStart, *aEnd);
                 ++aStart;
                 --aEnd;
             }
@@ -239,13 +239,13 @@ public:
 
     void flip()
     {
-        ::std::swap(maPrevVector, maNextVector);
+        std::swap(maPrevVector, maNextVector);
     }
 };
 
 class ControlVectorArray2D
 {
-    typedef ::std::vector< ControlVectorPair2D > ControlVectorPair2DVector;
+    typedef std::vector< ControlVectorPair2D > ControlVectorPair2DVector;
 
     ControlVectorPair2DVector                           maVector;
     sal_uInt32                                          mnUsedVectors;
@@ -443,7 +443,7 @@ public:
                 aEnd->flip();
 
                 // swap entries
-                ::std::swap(*aStart, *aEnd);
+                std::swap(*aStart, *aEnd);
 
                 ++aStart;
                 --aEnd;
@@ -530,7 +530,7 @@ public:
                                     // subdividing the bezier segment.
                                     // Ideal here is a subdivision at the extreme values, so use
                                     // getAllExtremumPositions to get all extremas in one run
-                                    ::std::vector< double > aExtremas;
+                                    std::vector< double > aExtremas;
 
                                     aExtremas.reserve(4);
                                     aEdge.getAllExtremumPositions(aExtremas);
diff --git a/basegfx/source/polygon/b2dpolygoncutandtouch.cxx b/basegfx/source/polygon/b2dpolygoncutandtouch.cxx
index 9b8bf8413158..22c2e9219854 100644
--- a/basegfx/source/polygon/b2dpolygoncutandtouch.cxx
+++ b/basegfx/source/polygon/b2dpolygoncutandtouch.cxx
@@ -67,7 +67,7 @@ namespace basegfx
             double getCut() const { return mfCut; }
         };
 
-        typedef ::std::vector< temporaryPoint > temporaryPointVector;
+        typedef std::vector< temporaryPoint > temporaryPointVector;
 
         class temporaryPolygonData
         {
@@ -97,7 +97,7 @@ namespace basegfx
                 if(nCount)
                 {
                     // sort temp points to assure increasing fCut values and increasing indices
-                    ::std::sort(rTempPoints.begin(), rTempPoints.end());
+                    std::sort(rTempPoints.begin(), rTempPoints.end());
 
                     // prepare loop
                     B2DCubicBezier aEdge;
diff --git a/basegfx/source/polygon/b2dpolygontools.cxx b/basegfx/source/polygon/b2dpolygontools.cxx
index 23e01233852c..8253c24f6226 100644
--- a/basegfx/source/polygon/b2dpolygontools.cxx
+++ b/basegfx/source/polygon/b2dpolygontools.cxx
@@ -1123,14 +1123,14 @@ namespace basegfx
             return false;
         }
 
-        void applyLineDashing(const B2DPolygon& rCandidate, const ::std::vector<double>& rDotDashArray, B2DPolyPolygon* pLineTarget, B2DPolyPolygon* pGapTarget, double fDotDashLength)
+        void applyLineDashing(const B2DPolygon& rCandidate, const std::vector<double>& rDotDashArray, B2DPolyPolygon* pLineTarget, B2DPolyPolygon* pGapTarget, double fDotDashLength)
         {
             const sal_uInt32 nPointCount(rCandidate.count());
             const sal_uInt32 nDotDashCount(rDotDashArray.size());
 
             if(fTools::lessOrEqual(fDotDashLength, 0.0))
             {
-                fDotDashLength = ::std::accumulate(rDotDashArray.begin(), rDotDashArray.end(), 0.0);
+                fDotDashLength = std::accumulate(rDotDashArray.begin(), rDotDashArray.end(), 0.0);
             }
 
             if(fTools::more(fDotDashLength, 0.0) && (pLineTarget || pGapTarget) && nPointCount)
diff --git a/basegfx/source/polygon/b2dpolygontriangulator.cxx b/basegfx/source/polygon/b2dpolygontriangulator.cxx
index c54a700aef6a..a986a7cff4e2 100644
--- a/basegfx/source/polygon/b2dpolygontriangulator.cxx
+++ b/basegfx/source/polygon/b2dpolygontriangulator.cxx
@@ -104,8 +104,8 @@ namespace basegfx
             void setNext(EdgeEntry* pNext) { mpNext = pNext; }
         };
 
-        typedef ::std::vector< EdgeEntry > EdgeEntries;
-        typedef ::std::vector< EdgeEntry* > EdgeEntryPointers;
+        typedef std::vector< EdgeEntry > EdgeEntries;
+        typedef std::vector< EdgeEntry* > EdgeEntryPointers;
 
         class Triangulator
         {
@@ -245,7 +245,7 @@ namespace basegfx
                 if(!maStartEntries.empty())
                 {
                     // sort initial list
-                    ::std::sort(maStartEntries.begin(), maStartEntries.end());
+                    std::sort(maStartEntries.begin(), maStartEntries.end());
 
                     // insert to own simply linked list
                     EdgeEntries::iterator aPos(maStartEntries.begin());
diff --git a/basegfx/source/polygon/b2dpolypolygoncutter.cxx b/basegfx/source/polygon/b2dpolypolygoncutter.cxx
index dce8afd48d63..88cafdedcd39 100644
--- a/basegfx/source/polygon/b2dpolypolygoncutter.cxx
+++ b/basegfx/source/polygon/b2dpolypolygoncutter.cxx
@@ -90,11 +90,11 @@ namespace basegfx
             }
         };
 
-        typedef ::std::vector< PN > PNV;
-        typedef ::std::vector< VN > VNV;
-        typedef ::std::vector< SN > SNV;
-        typedef ::std::pair< basegfx::B2DPoint /*orig*/, basegfx::B2DPoint /*repl*/ > CorrectionPair;
-        typedef ::std::vector< CorrectionPair > CorrectionTable;
+        typedef std::vector< PN > PNV;
+        typedef std::vector< VN > VNV;
+        typedef std::vector< SN > SNV;
+        typedef std::pair< basegfx::B2DPoint /*orig*/, basegfx::B2DPoint /*repl*/ > CorrectionPair;
+        typedef std::vector< CorrectionPair > CorrectionTable;
 
         class solver
         {
@@ -161,14 +161,14 @@ namespace basegfx
 
             void impSwitchNext(PN& rPNa, PN& rPNb)
             {
-                ::std::swap(rPNa.mnIN, rPNb.mnIN);
+                std::swap(rPNa.mnIN, rPNb.mnIN);
 
                 if(mbIsCurve)
                 {
                     VN& rVNa = maVNV[rPNa.mnI];
                     VN& rVNb = maVNV[rPNb.mnI];
 
-                    ::std::swap(rVNa.maNext, rVNb.maNext);
+                    std::swap(rVNa.maNext, rVNb.maNext);
                 }
 
                 if(!mbChanged)
@@ -429,7 +429,7 @@ namespace basegfx
             void impSolve()
             {
                 // sort by point to identify common nodes easier
-                ::std::sort(maSNV.begin(), maSNV.end());
+                std::sort(maSNV.begin(), maSNV.end());
 
                 // handle common nodes
                 const sal_uInt32 nNodeCount(maSNV.size());
@@ -745,7 +745,7 @@ namespace basegfx
             if(nCount > 1)
             {
                 sal_uInt32 a, b;
-                ::std::vector< StripHelper > aHelpers;
+                std::vector< StripHelper > aHelpers;
                 aHelpers.resize(nCount);
 
                 for(a = 0; a < nCount; a++)
@@ -825,7 +825,7 @@ namespace basegfx
                 else
                 {
                     sal_uInt32 a, b;
-                    ::std::vector< StripHelper > aHelpers;
+                    std::vector< StripHelper > aHelpers;
                     aHelpers.resize(nCount);
 
                     for(a = 0; a < nCount; a++)
diff --git a/basegfx/source/polygon/b2dpolypolygontools.cxx b/basegfx/source/polygon/b2dpolypolygontools.cxx
index 8e8f4c505abc..990ec1b331b8 100644
--- a/basegfx/source/polygon/b2dpolypolygontools.cxx
+++ b/basegfx/source/polygon/b2dpolypolygontools.cxx
@@ -231,12 +231,12 @@ namespace basegfx
             return fabs(getSignedArea(rCandidate));
         }
 
-        void applyLineDashing(const B2DPolyPolygon& rCandidate, const ::std::vector<double>& rDotDashArray, B2DPolyPolygon* pLineTarget, B2DPolyPolygon* pGapTarget, double fFullDashDotLen)
+        void applyLineDashing(const B2DPolyPolygon& rCandidate, const std::vector<double>& rDotDashArray, B2DPolyPolygon* pLineTarget, B2DPolyPolygon* pGapTarget, double fFullDashDotLen)
         {
             if(0.0 == fFullDashDotLen && rDotDashArray.size())
             {
                 // calculate fFullDashDotLen from rDotDashArray
-                fFullDashDotLen = ::std::accumulate(rDotDashArray.begin(), rDotDashArray.end(), 0.0);
+                fFullDashDotLen = std::accumulate(rDotDashArray.begin(), rDotDashArray.end(), 0.0);
             }
 
             if(rCandidate.count() && fFullDashDotLen > 0.0)
diff --git a/basegfx/source/polygon/b2dtrapezoid.cxx b/basegfx/source/polygon/b2dtrapezoid.cxx
index 21c5c86cc9db..c707e61b218c 100644
--- a/basegfx/source/polygon/b2dtrapezoid.cxx
+++ b/basegfx/source/polygon/b2dtrapezoid.cxx
@@ -59,7 +59,7 @@ namespace basegfx
 
         // define vector of simple edges
 
-        typedef ::std::vector< TrDeSimpleEdge > TrDeSimpleEdges;
+        typedef std::vector< TrDeSimpleEdge > TrDeSimpleEdges;
 
         // helper class for holding a traversing edge. It will always have some
         // distance in YPos. The slope (in a numerically useful form, see comments) is
@@ -180,7 +180,7 @@ namespace basegfx
 
         // define double linked list of edges (for fast random insert)
 
-        typedef ::std::list< TrDeEdgeEntry > TrDeEdgeEntries;
+        typedef std::list< TrDeEdgeEntry > TrDeEdgeEntries;
 
     } // end of anonymous namespace
 } // end of namespace basegfx
@@ -250,7 +250,7 @@ namespace basegfx
             // local data
             sal_uInt32                  mnInitialEdgeEntryCount;
             TrDeEdgeEntries             maTrDeEdgeEntries;
-            ::std::vector< B2DPoint >   maPoints;
+            std::vector< B2DPoint >   maPoints;
             /// new points allocated for cuts
             PointBlockAllocator         maNewPoints;
 
diff --git a/basegfx/source/polygon/b3dpolygon.cxx b/basegfx/source/polygon/b3dpolygon.cxx
index 69a375eed4c5..e77143c58cef 100644
--- a/basegfx/source/polygon/b3dpolygon.cxx
+++ b/basegfx/source/polygon/b3dpolygon.cxx
@@ -67,7 +67,7 @@ public:
 
 class CoordinateDataArray3D
 {
-    typedef ::std::vector< CoordinateData3D > CoordinateData3DVector;
+    typedef std::vector< CoordinateData3D > CoordinateData3DVector;
 
     CoordinateData3DVector                          maVector;
 
@@ -222,7 +222,7 @@ public:
 
             for(sal_uInt32 a(0); a < nHalfSize; a++)
             {
-                ::std::swap(*aStart, *aEnd);
+                std::swap(*aStart, *aEnd);
                 ++aStart;
                 --aEnd;
             }
@@ -243,7 +243,7 @@ public:
 
 class BColorArray
 {
-    typedef ::std::vector< ::basegfx::BColor > BColorDataVector;
+    typedef std::vector< ::basegfx::BColor > BColorDataVector;
 
     BColorDataVector                                    maVector;
     sal_uInt32                                          mnUsedEntries;
@@ -387,7 +387,7 @@ public:
 
             for(sal_uInt32 a(0); a < nHalfSize; a++)
             {
-                ::std::swap(*aStart, *aEnd);
+                std::swap(*aStart, *aEnd);
                 ++aStart;
                 --aEnd;
             }
@@ -397,7 +397,7 @@ public:
 
 class NormalsArray3D
 {
-    typedef ::std::vector< ::basegfx::B3DVector > NormalsData3DVector;
+    typedef std::vector< ::basegfx::B3DVector > NormalsData3DVector;
 
     NormalsData3DVector                                 maVector;
     sal_uInt32                                          mnUsedEntries;
@@ -540,7 +540,7 @@ public:
 
             for(sal_uInt32 a(0); a < nHalfSize; a++)
             {
-                ::std::swap(*aStart, *aEnd);
+                std::swap(*aStart, *aEnd);
                 ++aStart;
                 --aEnd;
             }
@@ -560,7 +560,7 @@ public:
 
 class TextureCoordinate2D
 {
-    typedef ::std::vector< ::basegfx::B2DPoint > TextureData2DVector;
+    typedef std::vector< ::basegfx::B2DPoint > TextureData2DVector;
 
     TextureData2DVector                                 maVector;
     sal_uInt32                                          mnUsedEntries;
@@ -703,7 +703,7 @@ public:
 
             for(sal_uInt32 a(0); a < nHalfSize; a++)
             {
-                ::std::swap(*aStart, *aEnd);
+                std::swap(*aStart, *aEnd);
                 ++aStart;
                 --aEnd;
             }
diff --git a/basegfx/source/polygon/b3dpolygontools.cxx b/basegfx/source/polygon/b3dpolygontools.cxx
index 95b0bef4e046..0e09d996dd37 100644
--- a/basegfx/source/polygon/b3dpolygontools.cxx
+++ b/basegfx/source/polygon/b3dpolygontools.cxx
@@ -94,14 +94,14 @@ namespace basegfx
             return fRetval;
         }
 
-        void applyLineDashing(const B3DPolygon& rCandidate, const ::std::vector<double>& rDotDashArray, B3DPolyPolygon* pLineTarget, B3DPolyPolygon* pGapTarget, double fDotDashLength)
+        void applyLineDashing(const B3DPolygon& rCandidate, const std::vector<double>& rDotDashArray, B3DPolyPolygon* pLineTarget, B3DPolyPolygon* pGapTarget, double fDotDashLength)
         {
             const sal_uInt32 nPointCount(rCandidate.count());
             const sal_uInt32 nDotDashCount(rDotDashArray.size());
 
             if(fTools::lessOrEqual(fDotDashLength, 0.0))
             {
-                fDotDashLength = ::std::accumulate(rDotDashArray.begin(), rDotDashArray.end(), 0.0);
+                fDotDashLength = std::accumulate(rDotDashArray.begin(), rDotDashArray.end(), 0.0);
             }
 
             if(fTools::more(fDotDashLength, 0.0) && (pLineTarget || pGapTarget) && nPointCount)
diff --git a/basegfx/source/polygon/b3dpolypolygon.cxx b/basegfx/source/polygon/b3dpolypolygon.cxx
index 1ff3cac901b9..74c8b835298a 100644
--- a/basegfx/source/polygon/b3dpolypolygon.cxx
+++ b/basegfx/source/polygon/b3dpolypolygon.cxx
@@ -29,7 +29,7 @@
 
 class ImplB3DPolyPolygon
 {
-    typedef ::std::vector< ::basegfx::B3DPolygon >  PolygonVector;
+    typedef std::vector< ::basegfx::B3DPolygon >  PolygonVector;
 
     PolygonVector                                   maPolygons;
 
diff --git a/basegfx/source/polygon/b3dpolypolygontools.cxx b/basegfx/source/polygon/b3dpolypolygontools.cxx
index 79ff6e91d6a1..b097f1c82886 100644
--- a/basegfx/source/polygon/b3dpolypolygontools.cxx
+++ b/basegfx/source/polygon/b3dpolypolygontools.cxx
@@ -243,7 +243,7 @@ namespace basegfx
             }
 
             // min/max limitations
-            nHorSeg = ::std::min(nMaxSegments, ::std::max(nMinSegments, nHorSeg));
+            nHorSeg = std::min(nMaxSegments, std::max(nMinSegments, nHorSeg));
 
             if(!nVerSeg)
             {
@@ -251,7 +251,7 @@ namespace basegfx
             }
 
             // min/max limitations
-            nVerSeg = ::std::min(nMaxSegments, ::std::max(nMinSegments, nVerSeg));
+            nVerSeg = std::min(nMaxSegments, std::max(nMinSegments, nVerSeg));
 
             // create constants
             const double fVerDiffPerStep((fVerStop - fVerStart) / (double)nVerSeg);
@@ -342,7 +342,7 @@ namespace basegfx
             }
 
             // min/max limitations
-            nHorSeg = ::std::min(nMaxSegments, ::std::max(nMinSegments, nHorSeg));
+            nHorSeg = std::min(nMaxSegments, std::max(nMinSegments, nHorSeg));
 
             if(!nVerSeg)
             {
@@ -350,7 +350,7 @@ namespace basegfx
             }
 
             // min/max limitations
-            nVerSeg = ::std::min(nMaxSegments, ::std::max(nMinSegments, nVerSeg));
+            nVerSeg = std::min(nMaxSegments, std::max(nMinSegments, nVerSeg));
 
             // vertical loop
             for(sal_uInt32 a(0); a < nVerSeg; a++)
diff --git a/basegfx/source/range/b2xrange.cxx b/basegfx/source/range/b2xrange.cxx
index 9ee5b9060026..5f68e95fd5ca 100644
--- a/basegfx/source/range/b2xrange.cxx
+++ b/basegfx/source/range/b2xrange.cxx
@@ -32,7 +32,7 @@ namespace basegfx
             nested types.
          */
         template< class RangeType > void doComputeSetDifference(
-            ::std::vector< RangeType >& o_rRanges,
+            std::vector< RangeType >& o_rRanges,
             const RangeType&            a,
             const RangeType&            b )
         {
@@ -98,7 +98,7 @@ namespace basegfx
         }
     }
 
-    ::std::vector< B2IRange >& computeSetDifference( ::std::vector< B2IRange >& o_rResult,
+    std::vector< B2IRange >& computeSetDifference( std::vector< B2IRange >& o_rResult,
                                                      const B2IRange&            rFirst,
                                                      const B2IRange&            rSecond )
     {
@@ -107,7 +107,7 @@ namespace basegfx
         return o_rResult;
     }
 
-    ::std::vector< B2DRange >& computeSetDifference( ::std::vector< B2DRange >& o_rResult,
+    std::vector< B2DRange >& computeSetDifference( std::vector< B2DRange >& o_rResult,
                                                      const B2DRange&            rFirst,
                                                      const B2DRange&            rSecond )
     {
diff --git a/basegfx/source/raster/rasterconvert3d.cxx b/basegfx/source/raster/rasterconvert3d.cxx
index 2ccd4a3ab031..859ed47721e8 100644
--- a/basegfx/source/raster/rasterconvert3d.cxx
+++ b/basegfx/source/raster/rasterconvert3d.cxx
@@ -62,17 +62,17 @@ namespace basegfx
 
             // sort global entries by Y, X once. After this, the vector
             // is seen as frozen. Pointers to its entries will be used in the following code.
-            ::std::sort(maLineEntries.begin(), maLineEntries.end());
+            std::sort(maLineEntries.begin(), maLineEntries.end());
 
             // local parameters
-            ::std::vector< RasterConversionLineEntry3D >::iterator aCurrentEntry(maLineEntries.begin());
-            ::std::vector< RasterConversionLineEntry3D* > aCurrentLine;
-            ::std::vector< RasterConversionLineEntry3D* > aNextLine;
-            ::std::vector< RasterConversionLineEntry3D* >::iterator aRasterConversionLineEntry3D;
+            std::vector< RasterConversionLineEntry3D >::iterator aCurrentEntry(maLineEntries.begin());
+            std::vector< RasterConversionLineEntry3D* > aCurrentLine;
+            std::vector< RasterConversionLineEntry3D* > aNextLine;
+            std::vector< RasterConversionLineEntry3D* >::iterator aRasterConversionLineEntry3D;
             sal_uInt32 nPairCount(0);
 
             // get scanlines first LineNumber as start
-            sal_Int32 nLineNumber(::std::max(aCurrentEntry->getY(), nStartLine));
+            sal_Int32 nLineNumber(std::max(aCurrentEntry->getY(), nStartLine));
 
             while((aCurrentLine.size() || aCurrentEntry != maLineEntries.end()) && (nLineNumber < nStopLine))
             {
@@ -112,7 +112,7 @@ namespace basegfx
                 // since all entries are already in one processed line. This needs to be done
                 // every time since not only new spans may have benn added or old removed,
                 // but incrementing may also have changed the order
-                ::std::sort(aCurrentLine.begin(), aCurrentLine.end(), lineComparator());
+                std::sort(aCurrentLine.begin(), aCurrentLine.end(), lineComparator());
 
                 // process current scanline
                 aRasterConversionLineEntry3D = aCurrentLine.begin();
@@ -161,9 +161,9 @@ namespace basegfx
         {
             if(nYStart > nYEnd)
             {
-                ::std::swap(aStart, aEnd);
-                ::std::swap(nYStart, nYEnd);
-                ::std::swap(a, b);
+                std::swap(aStart, aEnd);
+                std::swap(nYStart, nYEnd);
+                std::swap(a, b);
             }
 
             const sal_uInt32 nYDelta(nYEnd - nYStart);
@@ -278,8 +278,8 @@ namespace basegfx
 
                 if(nYStart > nYEnd)
                 {
-                    ::std::swap(aStart, aEnd);
-                    ::std::swap(nYStart, nYEnd);
+                    std::swap(aStart, aEnd);
+                    std::swap(nYStart, nYEnd);
                 }
 
                 const sal_uInt32 nYDelta(static_cast<sal_uInt32>(nYEnd - nYStart));
diff --git a/basegfx/source/tools/keystoplerp.cxx b/basegfx/source/tools/keystoplerp.cxx
index 5819663cfd44..2ffede92ef9a 100644
--- a/basegfx/source/tools/keystoplerp.cxx
+++ b/basegfx/source/tools/keystoplerp.cxx
@@ -31,7 +31,7 @@ static void validateInput(const std::vector<double>& rKeyStops)
                 "KeyStopLerp::KeyStopLerp(): key stop vector must have two entries or more" );
 
     // rKeyStops must be sorted in ascending order
-    for( ::std::size_t i=1, len=rKeyStops.size(); i<len; ++i )
+    for( std::size_t i=1, len=rKeyStops.size(); i<len; ++i )
     {
         if( rKeyStops[i-1] > rKeyStops[i] )
             OSL_FAIL( "KeyStopLerp::KeyStopLerp(): time vector is not sorted in ascending order!" );
diff --git a/basegfx/source/tools/tools.cxx b/basegfx/source/tools/tools.cxx
index 95ed692c859d..ec7170b513a7 100644
--- a/basegfx/source/tools/tools.cxx
+++ b/basegfx/source/tools/tools.cxx
@@ -46,19 +46,19 @@ namespace basegfx
 
                 // calc maximum orthogonal distance for all four bound
                 // rect corners to the line
-                const double nMaxDistance( ::std::max(
+                const double nMaxDistance( std::max(
                                                0.0,
-                                               ::std::max(
+                                               std::max(
                                                    distance(rFitTarget.getMinX(),
                                                             rFitTarget.getMinY(),
                                                             rMoveDirection,
                                                             nC),
-                                                   ::std::max(
+                                                   std::max(
                                                        distance(rFitTarget.getMinX(),
                                                                 rFitTarget.getMaxY(),
                                                                 rMoveDirection,
                                                                 nC),
-                                                       ::std::max(
+                                                       std::max(
                                                            distance(rFitTarget.getMaxX(),
                                                                     rFitTarget.getMinY(),
                                                                     rMoveDirection,
diff --git a/basegfx/source/workbench/bezierclip.cxx b/basegfx/source/workbench/bezierclip.cxx
index 478f2899bf30..86a439ea297b 100644
--- a/basegfx/source/workbench/bezierclip.cxx
+++ b/basegfx/source/workbench/bezierclip.cxx
@@ -106,13 +106,13 @@ void Impl_calcFatLine( FatLine& line, const Bezier& c )
     // worth the overhead)
     if( dP2 * dP3 > 0.0 )
     {
-        line.dMin = 3.0/4.0 * ::std::min(0.0, ::std::min(dP2, dP3));
-        line.dMax = 3.0/4.0 * ::std::max(0.0, ::std::max(dP2, dP3));
+        line.dMin = 3.0/4.0 * std::min(0.0, std::min(dP2, dP3));
+        line.dMax = 3.0/4.0 * std::max(0.0, std::max(dP2, dP3));
     }
     else
     {
-        line.dMin = 4.0/9.0 * ::std::min(0.0, ::std::min(dP2, dP3));
-        line.dMax = 4.0/9.0 * ::std::max(0.0, ::std::max(dP2, dP3));
+        line.dMin = 4.0/9.0 * std::min(0.0, std::min(dP2, dP3));
+        line.dMax = 4.0/9.0 * std::max(0.0, std::max(dP2, dP3));
     }
 }
 
@@ -120,10 +120,10 @@ void Impl_calcBounds( Point2D&          leftTop,
                       Point2D&          rightBottom,
                       const Bezier&     c1          )
 {
-    leftTop.x = ::std::min( c1.p0.x, ::std::min( c1.p1.x, ::std::min( c1.p2.x, c1.p3.x ) ) );
-    leftTop.y = ::std::min( c1.p0.y, ::std::min( c1.p1.y, ::std::min( c1.p2.y, c1.p3.y ) ) );
-    rightBottom.x = ::std::max( c1.p0.x, ::std::max( c1.p1.x, ::std::max( c1.p2.x, c1.p3.x ) ) );
-    rightBottom.y = ::std::max( c1.p0.y, ::std::max( c1.p1.y, ::std::max( c1.p2.y, c1.p3.y ) ) );
+    leftTop.x = std::min( c1.p0.x, std::min( c1.p1.x, std::min( c1.p2.x, c1.p3.x ) ) );
+    leftTop.y = std::min( c1.p0.y, std::min( c1.p1.y, std::min( c1.p2.y, c1.p3.y ) ) );
+    rightBottom.x = std::max( c1.p0.x, std::max( c1.p1.x, std::max( c1.p2.x, c1.p3.x ) ) );
+    rightBottom.y = std::max( c1.p0.y, std::max( c1.p1.y, std::max( c1.p2.y, c1.p3.y ) ) );
 }
 
 bool Impl_doBBoxIntersect( const Bezier& c1,
@@ -138,8 +138,8 @@ bool Impl_doBBoxIntersect( const Bezier& c1,
     Impl_calcBounds( lt1, rb1, c1 );
     Impl_calcBounds( lt2, rb2, c2 );
 
-    if( ::std::min(rb1.x, rb2.x) < ::std::max(lt1.x, lt2.x) ||
-        ::std::min(rb1.y, rb2.y) < ::std::max(lt1.y, lt2.y) )
+    if( std::min(rb1.x, rb2.x) < std::max(lt1.x, lt2.x) ||
+        std::min(rb1.y, rb2.y) < std::max(lt1.y, lt2.y) )
     {
         return false;
     }
@@ -220,8 +220,8 @@ bool Impl_calcSafeParams( double&           t1,
                     tolEqual(p0.y, upperYBound) )
                 {
                     // yes, simulate intersection then
-                    currLowerT = ::std::min(currLowerT, ::std::min(p0.x, p1.x));
-                    currHigherT = ::std::max(currHigherT, ::std::max(p0.x, p1.x));
+                    currLowerT = std::min(currLowerT, std::min(p0.x, p1.x));
+                    currHigherT = std::max(currHigherT, std::max(p0.x, p1.x));
                 }
             }
             else
@@ -236,8 +236,8 @@ bool Impl_calcSafeParams( double&           t1,
                 // calc intersection with horizontal dMax line
                 const double currTHigh( (upperYBound - p0.y) * r_x / r_y + p0.x );
 
-                currLowerT = ::std::min(currLowerT, ::std::min(currTLow, currTHigh));
-                currHigherT = ::std::max(currHigherT, ::std::max(currTLow, currTHigh));
+                currLowerT = std::min(currLowerT, std::min(currTLow, currTHigh));
+                currHigherT = std::max(currHigherT, std::max(currTLow, currTHigh));
             }
 
             // set flag that at least one segment is contained or
@@ -248,8 +248,8 @@ bool Impl_calcSafeParams( double&           t1,
 
 #ifndef WITH_SAFEPARAMBASE_TEST
     // limit intersections found to permissible t parameter range
-    t1 = ::std::max(0.0, currLowerT);
-    t2 = ::std::min(1.0, currHigherT);
+    t1 = std::max(0.0, currLowerT);
+    t2 = std::min(1.0, currHigherT);
 #endif
 
     return bIntersection;
@@ -810,7 +810,7 @@ bool Impl_calcSafeParams_focus( double&         t1,
         for( j=0; j<j_card; ++j )
         {
             // calc single d_{ij} sum:
-            for( d=0.0, k=::std::max(0,i-n); k<=k_max && k<=i; ++k )
+            for( d=0.0, k=std::max(0,i-n); k<=k_max && k<=i; ++k )
             {
                 l = i - k; // invariant: k + l = i
                 assert(k>=0 && k<=n-1); // k \in {0,...,n-1}
@@ -895,7 +895,7 @@ bool Impl_calcSafeParams_focus( double&         t1,
     c1_orig, where c1_orig is 'safe' from c2_part. If the whole
     c1_orig is safe, false must be returned, true otherwise.
  */
-template <class Functor> void Impl_applySafeRanges_rec( ::std::back_insert_iterator< ::std::vector< ::std::pair<double, double> > >&    result,
+template <class Functor> void Impl_applySafeRanges_rec( std::back_insert_iterator< std::vector< std::pair<double, double> > >&    result,
                                                         double                                                                          delta,
                                                         const Functor&                                                                  safeRangeFunctor,
                                                         int                                                                             recursionLevel,
@@ -970,8 +970,8 @@ template <class Functor> void Impl_applySafeRanges_rec( ::std::back_insert_itera
             // [last_t1,last_t2], on the other hand, so values
             // of [t1,t2] outside that range are irrelevant
             // here. Clip range appropriately.
-            t1_c1 = ::std::max(t1_c1, last_t1_c1);
-            t2_c1 = ::std::min(t2_c1, last_t2_c1);
+            t1_c1 = std::max(t1_c1, last_t1_c1);
+            t2_c1 = std::min(t2_c1, last_t2_c1);
 
             // TODO: respect delta
             // for now, end condition is just a fixed threshold on the t's
@@ -991,12 +991,12 @@ template <class Functor> void Impl_applySafeRanges_rec( ::std::back_insert_itera
                 if( recursionLevel % 2 )
                 {
                     // uneven level: have to swap the t's, since curves are swapped, too
-                    *result++ = ::std::make_pair( last_t1_c2 + (last_t2_c2 - last_t1_c2)/2.0,
+                    *result++ = std::make_pair( last_t1_c2 + (last_t2_c2 - last_t1_c2)/2.0,
                                                   last_t1_c1 + (last_t2_c1 - last_t1_c1)/2.0 );
                 }
                 else
                 {
-                    *result++ = ::std::make_pair( last_t1_c1 + (last_t2_c1 - last_t1_c1)/2.0,
+                    *result++ = std::make_pair( last_t1_c1 + (last_t2_c1 - last_t1_c1)/2.0,
                                                   last_t1_c2 + (last_t2_c2 - last_t1_c2)/2.0 );
                 }
 
@@ -1157,7 +1157,7 @@ struct BezierTangencyFunctor
     Maximal allowed distance to true intersection (measured in the
     original curve's coordinate system)
  */
-void clipBezier( ::std::back_insert_iterator< ::std::vector< ::std::pair<double, double> > >&   result,
+void clipBezier( std::back_insert_iterator< std::vector< std::pair<double, double> > >&   result,
                  double                                                                         delta,
                  const Bezier&                                                                  c1,
                  const Bezier&                                                                  c2        )
@@ -1173,8 +1173,8 @@ void clipBezier( ::std::back_insert_iterator< ::std::vector< ::std::pair<double,
     // tangencies. Sederberg et al. state that collinear normal
     // algorithm then degrades quickly.
 
-    ::std::vector< ::std::pair<double,double> > results;
-    ::std::back_insert_iterator< ::std::vector< ::std::pair<double, double> > > ii(results);
+    std::vector< std::pair<double,double> > results;
+    std::back_insert_iterator< std::vector< std::pair<double, double> > > ii(results);
 
     Impl_calcCollinearNormals( ii, delta, 0, c1, c1, 0.0, 1.0, c2, c2, 0.0, 1.0 );
 
@@ -1187,8 +1187,8 @@ void clipBezier( ::std::back_insert_iterator< ::std::vector< ::std::pair<double,
     // e.g. intersect with the right part of curve 2.
 
     // divide c1 and c2 at collinear normal intersection points
-    ::std::vector< Bezier > c1_segments( results.size()+1 );
-    ::std::vector< Bezier > c2_segments( results.size()+1 );
+    std::vector< Bezier > c1_segments( results.size()+1 );
+    std::vector< Bezier > c2_segments( results.size()+1 );
     Bezier c1_remainder( c1 );
     Bezier c2_remainder( c2 );
     unsigned int i;
@@ -1898,8 +1898,8 @@ int main(int argc, const char *argv[])
 #endif
 
 #ifdef WITH_BEZIERCLIP_TEST
-    ::std::vector< ::std::pair<double, double> >                                result;
-    ::std::back_insert_iterator< ::std::vector< ::std::pair<double, double> > > ii(result);
+    std::vector< std::pair<double, double> >                                result;
+    std::back_insert_iterator< std::vector< std::pair<double, double> > > ii(result);
 
     // test full bezier clipping
     const double bezierClip_xOffset( curr_Offset );
diff --git a/basegfx/source/workbench/bezierclip.hxx b/basegfx/source/workbench/bezierclip.hxx
index 11ab32109414..adb92009ad69 100644
--- a/basegfx/source/workbench/bezierclip.hxx
+++ b/basegfx/source/workbench/bezierclip.hxx
@@ -63,7 +63,7 @@ template <typename DataType> DataType calcLineDistance( const DataType& a,
     return a*x + b*y + c;
 }
 
-typedef ::std::vector< Point2D > Polygon2D;
+typedef std::vector< Point2D > Polygon2D;
 
 /* little abs template */
 template <typename NumType> NumType absval( NumType x )
@@ -73,7 +73,7 @@ template <typename NumType> NumType absval( NumType x )
 
 Polygon2D convexHull( const Polygon2D& rPoly );
 
-// TODO: find proper epsilon here (try ::std::numeric_limits<NumType>::epsilon()?)!
+// TODO: find proper epsilon here (try std::numeric_limits<NumType>::epsilon()?)!
 #define DBL_EPSILON 1.0e-100
 
 /* little approximate comparisons */
diff --git a/basegfx/source/workbench/convexhull.cxx b/basegfx/source/workbench/convexhull.cxx
index e94c2d76045a..3e728777ace8 100644
--- a/basegfx/source/workbench/convexhull.cxx
+++ b/basegfx/source/workbench/convexhull.cxx
@@ -43,7 +43,7 @@ template <class PointType> double theta( const PointType& p1, const PointType& p
 /* Model of LessThanComparable for theta sort.
  * Uses the theta function from Sedgewick: Algorithms in XXX, chapter 24
  */
-template <class PointType> class ThetaCompare : public ::std::binary_function< const PointType&, const PointType&, bool >
+template <class PointType> class ThetaCompare : public std::binary_function< const PointType&, const PointType&, bool >
 {
 public:
     explicit ThetaCompare( const PointType& rRefPoint ) : maRefPoint( rRefPoint ) {}
@@ -152,7 +152,7 @@ Polygon2D convexHull( const Polygon2D& rPoly )
 {
     const Polygon2D::size_type N( rPoly.size() );
     Polygon2D result( N + 1 );
-    ::std::copy(rPoly.begin(), rPoly.end(), result.begin()+1 );
+    std::copy(rPoly.begin(), rPoly.end(), result.begin()+1 );
     Polygon2D::size_type min, i;
 
     // determine safe point on hull (smallest y value)
@@ -173,12 +173,12 @@ Polygon2D convexHull( const Polygon2D& rPoly )
     }
 
     // TODO: add inner elimination optimization from Sedgewick: Algorithms in XXX, chapter 25
-    // TODO: use radix sort instead of ::std::sort(), calc theta only once and store
+    // TODO: use radix sort instead of std::sort(), calc theta only once and store
 
     // setup first point and sort
-    ::std::swap( result[1], result[min] );
+    std::swap( result[1], result[min] );
     ThetaCompare<Point2D> cmpFunc(result[1]);
-    ::std::sort( result.begin()+1, result.end(), cmpFunc );
+    std::sort( result.begin()+1, result.end(), cmpFunc );
 
     // setup sentinel
     result[0] = result[N];
@@ -191,7 +191,7 @@ Polygon2D convexHull( const Polygon2D& rPoly )
             --M;
 
         ++M;
-        ::std::swap( result[M], result[i] );
+        std::swap( result[M], result[i] );
     }
 
     // copy range [1,M] to output
diff --git a/basegfx/test/boxclipper.cxx b/basegfx/test/boxclipper.cxx
index e13d156c3e2f..989f78ecabc4 100644
--- a/basegfx/test/boxclipper.cxx
+++ b/basegfx/test/boxclipper.cxx
@@ -42,7 +42,7 @@ using namespace ::basegfx;
 namespace basegfx2d
 {
 /// Gets a random ordinal [0,n)
-double getRandomOrdinal( const ::std::size_t n )
+double getRandomOrdinal( const std::size_t n )
 {
     // use this one when displaying polygons in OOo, which still sucks
     // great rocks when trying to import non-integer svg:d attributes
diff --git a/basegfx/test/boxclipper.hxx b/basegfx/test/boxclipper.hxx
index 70eed2adcee5..95dd2c7df849 100644
--- a/basegfx/test/boxclipper.hxx
+++ b/basegfx/test/boxclipper.hxx
@@ -26,7 +26,7 @@
 
 namespace basegfx2d {
 
-double getRandomOrdinal( const ::std::size_t n );
+double getRandomOrdinal( const std::size_t n );
 
 }