boost->std

Change-Id: I8371b942d915f777a29ca01cd0aed674db0ca853

8 files changed, 77 insertions, 77 deletions

diff --git a/xmloff/inc/RDFaImportHelper.hxx b/xmloff/inc/RDFaImportHelper.hxx
index 75c10dd4c095..ceb4c2e50467 100644
--- a/xmloff/inc/RDFaImportHelper.hxx
+++ b/xmloff/inc/RDFaImportHelper.hxx
@@ -20,10 +20,9 @@
 #ifndef INCLUDED_XMLOFF_INC_RDFAIMPORTHELPER_HXX
 #define INCLUDED_XMLOFF_INC_RDFAIMPORTHELPER_HXX
 
+#include <memory>
 #include <vector>
 
-#include <boost/shared_ptr.hpp>
-
 #include <com/sun/star/uno/Reference.h>
 #include <rtl/ustring.hxx>
 
@@ -59,7 +58,7 @@ public:
     ~RDFaImportHelper();
 
     /** Parse RDFa attributes */
-    ::boost::shared_ptr<ParsedRDFaAttributes> ParseRDFa(
+    std::shared_ptr<ParsedRDFaAttributes> ParseRDFa(
         OUString const & i_rAbout,
         OUString const & i_rProperty,
         OUString const & i_rContent,
@@ -69,7 +68,7 @@ public:
     void AddRDFa(
         ::com::sun::star::uno::Reference< ::com::sun::star::rdf::XMetadatable>
             const & i_xObject,
-        ::boost::shared_ptr<ParsedRDFaAttributes> & i_pRDFaAttributes);
+        std::shared_ptr<ParsedRDFaAttributes> & i_pRDFaAttributes);
 
     /** Parse and add a RDFa statement; parameters are XML attribute values */
     void ParseAndAddRDFa(
diff --git a/xmloff/source/chart/SchXMLTools.cxx b/xmloff/source/chart/SchXMLTools.cxx
index cf195df204ab..64304271ca04 100644
--- a/xmloff/source/chart/SchXMLTools.cxx
+++ b/xmloff/source/chart/SchXMLTools.cxx
@@ -47,6 +47,7 @@
 #include <com/sun/star/lang/XServiceName.hpp>
 
 #include <comphelper/processfactory.hxx>
+#include <algorithm>
 
 using namespace com::sun::star;
 using namespace ::xmloff::token;
diff --git a/xmloff/source/core/RDFaImportHelper.cxx b/xmloff/source/core/RDFaImportHelper.cxx
index 5b801560e6e9..0cf3061586d0 100644
--- a/xmloff/source/core/RDFaImportHelper.cxx
+++ b/xmloff/source/core/RDFaImportHelper.cxx
@@ -137,12 +137,12 @@ struct ParsedRDFaAttributes
 struct RDFaEntry
 {
     uno::Reference<rdf::XMetadatable> m_xObject;
-    ::boost::shared_ptr<ParsedRDFaAttributes> m_pRDFaAttributes;
+    std::shared_ptr<ParsedRDFaAttributes> m_xRDFaAttributes;
 
     RDFaEntry(uno::Reference<rdf::XMetadatable> const & i_xObject,
-            ::boost::shared_ptr<ParsedRDFaAttributes> const& i_pRDFaAttributes)
+            std::shared_ptr<ParsedRDFaAttributes> const& i_pRDFaAttributes)
         : m_xObject(i_xObject)
-        , m_pRDFaAttributes(i_pRDFaAttributes)
+        , m_xRDFaAttributes(i_pRDFaAttributes)
     { }
 };
 
@@ -331,7 +331,7 @@ void RDFaInserter::InsertRDFaEntry(
     if (!i_rEntry.m_xObject.is()) return;
 
     const uno::Reference< rdf::XResource > xSubject(
-        MakeResource( i_rEntry.m_pRDFaAttributes->m_About ) );
+        MakeResource( i_rEntry.m_xRDFaAttributes->m_About ) );
     if (!xSubject.is())
     {
         return; // invalid
@@ -339,15 +339,15 @@ void RDFaInserter::InsertRDFaEntry(
 
     ::std::vector< uno::Reference< rdf::XURI > > predicates;
 
-    predicates.reserve(i_rEntry.m_pRDFaAttributes->m_Properties.size());
+    predicates.reserve(i_rEntry.m_xRDFaAttributes->m_Properties.size());
 
     ::std::remove_copy_if(
         ::boost::make_transform_iterator(
-            i_rEntry.m_pRDFaAttributes->m_Properties.begin(),
+            i_rEntry.m_xRDFaAttributes->m_Properties.begin(),
             ::boost::bind(&RDFaInserter::MakeURI, this, _1)),
         // argh, this must be the same type :(
         ::boost::make_transform_iterator(
-            i_rEntry.m_pRDFaAttributes->m_Properties.end(),
+            i_rEntry.m_xRDFaAttributes->m_Properties.end(),
             ::boost::bind(&RDFaInserter::MakeURI, this, _1)),
         ::std::back_inserter(predicates),
         ref_is_null() );
@@ -364,9 +364,9 @@ void RDFaInserter::InsertRDFaEntry(
     }
 
     uno::Reference<rdf::XURI> xDatatype;
-    if (!i_rEntry.m_pRDFaAttributes->m_Datatype.isEmpty())
+    if (!i_rEntry.m_xRDFaAttributes->m_Datatype.isEmpty())
     {
-        xDatatype = MakeURI( i_rEntry.m_pRDFaAttributes->m_Datatype );
+        xDatatype = MakeURI( i_rEntry.m_xRDFaAttributes->m_Datatype );
     }
 
     try
@@ -376,7 +376,7 @@ void RDFaInserter::InsertRDFaEntry(
         // to prevent collision between generated ids and ids in the file
         m_xRepository->setStatementRDFa(xSubject, comphelper::containerToSequence(predicates),
             i_rEntry.m_xObject,
-            i_rEntry.m_pRDFaAttributes->m_Content, xDatatype);
+            i_rEntry.m_xRDFaAttributes->m_Content, xDatatype);
     }
     catch (uno::Exception &)
     {
@@ -393,7 +393,7 @@ RDFaImportHelper::~RDFaImportHelper()
 {
 }
 
-::boost::shared_ptr<ParsedRDFaAttributes>
+std::shared_ptr<ParsedRDFaAttributes>
 RDFaImportHelper::ParseRDFa(
     OUString const & i_rAbout,
     OUString const & i_rProperty,
@@ -403,30 +403,30 @@ RDFaImportHelper::ParseRDFa(
     if (i_rProperty.isEmpty())
     {
         SAL_INFO("xmloff.core", "AddRDFa: invalid input: xhtml:property empty");
-        return ::boost::shared_ptr<ParsedRDFaAttributes>();
+        return std::shared_ptr<ParsedRDFaAttributes>();
     }
     // must parse CURIEs here: need namespace declaration context
     RDFaReader reader(GetImport());
     const OUString about( reader.ReadURIOrSafeCURIE(i_rAbout) );
     if (about.isEmpty()) {
-        return ::boost::shared_ptr<ParsedRDFaAttributes>();
+        return std::shared_ptr<ParsedRDFaAttributes>();
     }
     const ::std::vector< OUString > properties(
         reader.ReadCURIEs(i_rProperty) );
     if (!properties.size()) {
-        return ::boost::shared_ptr<ParsedRDFaAttributes>();
+        return std::shared_ptr<ParsedRDFaAttributes>();
     }
     const OUString datatype( !i_rDatatype.isEmpty()
         ?   reader.ReadCURIE(i_rDatatype)
         :   OUString() );
-    return ::boost::shared_ptr<ParsedRDFaAttributes>(
+    return std::shared_ptr<ParsedRDFaAttributes>(
             new ParsedRDFaAttributes(about, properties, i_rContent, datatype));
 }
 
 void
 RDFaImportHelper::AddRDFa(
     uno::Reference<rdf::XMetadatable> const & i_xObject,
-    ::boost::shared_ptr<ParsedRDFaAttributes> & i_pRDFaAttributes)
+    std::shared_ptr<ParsedRDFaAttributes> & i_pRDFaAttributes)
 {
     if (!i_xObject.is())
     {
@@ -449,7 +449,7 @@ RDFaImportHelper::ParseAndAddRDFa(
     OUString const & i_rContent,
     OUString const & i_rDatatype)
 {
-    ::boost::shared_ptr<ParsedRDFaAttributes> pAttributes(
+    std::shared_ptr<ParsedRDFaAttributes> pAttributes(
         ParseRDFa(i_rAbout, i_rProperty, i_rContent, i_rDatatype) );
     if (pAttributes.get())
     {
diff --git a/xmloff/source/table/XMLTableExport.cxx b/xmloff/source/table/XMLTableExport.cxx
index 405c9db021a8..ab86020132be 100644
--- a/xmloff/source/table/XMLTableExport.cxx
+++ b/xmloff/source/table/XMLTableExport.cxx
@@ -200,8 +200,8 @@ static bool has_states( const std::vector< XMLPropertyState >& xPropStates )
      if( !mbExportTables )
          return;
 
-    boost::shared_ptr< XMLTableInfo > pTableInfo( new XMLTableInfo() );
-    maTableInfoMap[xColumnRowRange] = pTableInfo;
+    std::shared_ptr< XMLTableInfo > xTableInfo( new XMLTableInfo() );
+    maTableInfoMap[xColumnRowRange] = xTableInfo;
 
     try
     {
@@ -216,7 +216,7 @@ static bool has_states( const std::vector< XMLPropertyState >& xPropStates )
             {
                 const OUString sStyleName( mrExport.GetAutoStylePool()->Add(XML_STYLE_FAMILY_TABLE_COLUMN, xPropStates) );
                 Reference< XInterface > xKey( xPropSet, UNO_QUERY );
-                pTableInfo->maColumnStyleMap[xKey] = sStyleName;
+                xTableInfo->maColumnStyleMap[xKey] = sStyleName;
             }
         }
         catch(const Exception&)
@@ -226,7 +226,7 @@ static bool has_states( const std::vector< XMLPropertyState >& xPropStates )
 
         Reference< XIndexAccess > xIndexAccessRows( xColumnRowRange->getRows(), UNO_QUERY_THROW );
         const sal_Int32 nRowCount = xIndexAccessRows->getCount();
-        pTableInfo->maDefaultRowCellStyles.resize(nRowCount);
+        xTableInfo->maDefaultRowCellStyles.resize(nRowCount);
 
         StringStatisticHelper aStringStatistic;
 
@@ -239,7 +239,7 @@ static bool has_states( const std::vector< XMLPropertyState >& xPropStates )
             {
                 const OUString sStyleName( mrExport.GetAutoStylePool()->Add(XML_STYLE_FAMILY_TABLE_ROW, xRowPropStates) );
                 Reference< XInterface > xKey( xPropSet, UNO_QUERY );
-                pTableInfo->maRowStyleMap[xKey] = sStyleName;
+                xTableInfo->maRowStyleMap[xKey] = sStyleName;
             }
 
             // get the current row
@@ -270,7 +270,7 @@ static bool has_states( const std::vector< XMLPropertyState >& xPropStates )
                 if( !sStyleName.isEmpty() )
                 {
                     Reference< XInterface > xKey( xCellSet, UNO_QUERY );
-                    pTableInfo->maCellStyleMap[xKey] = sStyleName;
+                    xTableInfo->maCellStyleMap[xKey] = sStyleName;
                 }
 
                 // create auto style for text
@@ -283,7 +283,7 @@ static bool has_states( const std::vector< XMLPropertyState >& xPropStates )
 
             OUString sDefaultCellStyle;
             if( aStringStatistic.getModeString( sDefaultCellStyle ) > 1 )
-                pTableInfo->maDefaultRowCellStyles[nRow] = sDefaultCellStyle;
+                xTableInfo->maDefaultRowCellStyles[nRow] = sDefaultCellStyle;
 
             aStringStatistic.clear();
         }
@@ -300,12 +300,12 @@ static bool has_states( const std::vector< XMLPropertyState >& xPropStates )
 
  void XMLTableExport::exportTable( const Reference < XColumnRowRange >& xColumnRowRange )
  {
-     if( !mbExportTables )
-         return;
+    if( !mbExportTables )
+        return;
 
-     try
+    try
     {
-        boost::shared_ptr< XMLTableInfo > pTableInfo( maTableInfoMap[xColumnRowRange] );
+        std::shared_ptr< XMLTableInfo > xTableInfo( maTableInfoMap[xColumnRowRange] );
 
         // get row and column count
         Reference< XIndexAccess > xIndexAccess( xColumnRowRange->getRows(), UNO_QUERY_THROW );
@@ -317,7 +317,7 @@ static bool has_states( const std::vector< XMLPropertyState >& xPropStates )
         SvXMLElementExport tableElement( mrExport, XML_NAMESPACE_TABLE, XML_TABLE, true, true );
 
         // export table columns
-        ExportTableColumns( xIndexAccessCols, pTableInfo );
+        ExportTableColumns( xIndexAccessCols, xTableInfo );
 
         // start iterating rows and columns
         for ( sal_Int32 rowIndex = 0; rowIndex < rowCount; rowIndex++ )
@@ -328,14 +328,14 @@ static bool has_states( const std::vector< XMLPropertyState >& xPropStates )
             OUString sDefaultCellStyle;
 
             // table:style-name
-            if( pTableInfo.get() )
+            if( xTableInfo.get() )
             {
                 Reference< XInterface > xKey( xCellRange, UNO_QUERY );
-                const OUString sStyleName( pTableInfo->maRowStyleMap[xKey] );
+                const OUString sStyleName( xTableInfo->maRowStyleMap[xKey] );
                 if( !sStyleName.isEmpty() )
                     mrExport.AddAttribute(XML_NAMESPACE_TABLE, XML_STYLE_NAME, sStyleName );
 
-                sDefaultCellStyle = pTableInfo->maDefaultRowCellStyles[rowIndex];
+                sDefaultCellStyle = xTableInfo->maDefaultRowCellStyles[rowIndex];
                 if( !sDefaultCellStyle.isEmpty() )
                     mrExport.AddAttribute(XML_NAMESPACE_TABLE, XML_DEFAULT_CELL_STYLE_NAME, sDefaultCellStyle );
             }
@@ -352,7 +352,7 @@ static bool has_states( const std::vector< XMLPropertyState >& xPropStates )
                 Reference< XMergeableCell > xMergeableCell( xCell, UNO_QUERY_THROW );
 
                 // export cell
-                ExportCell( xCell, pTableInfo, sDefaultCellStyle );
+                ExportCell( xCell, xTableInfo, sDefaultCellStyle );
             }
         }
      }
@@ -364,7 +364,7 @@ static bool has_states( const std::vector< XMLPropertyState >& xPropStates )
 
 // Export the table columns
 
- void XMLTableExport::ExportTableColumns( const Reference < XIndexAccess >& xtableColumnsIndexAccess, const boost::shared_ptr< XMLTableInfo >& pTableInfo )
+ void XMLTableExport::ExportTableColumns( const Reference < XIndexAccess >& xtableColumnsIndexAccess, const std::shared_ptr< XMLTableInfo >& rTableInfo )
  {
     const sal_Int32 nColumnCount = xtableColumnsIndexAccess->getCount();
      for( sal_Int32 nColumn = 0; nColumn < nColumnCount; ++nColumn )
@@ -373,10 +373,10 @@ static bool has_states( const std::vector< XMLPropertyState >& xPropStates )
          if ( xColumnProperties.is() )
         {
             // table:style-name
-            if( pTableInfo.get() )
+            if( rTableInfo.get() )
             {
                 Reference< XInterface > xKey( xColumnProperties, UNO_QUERY );
-                const OUString sStyleName( pTableInfo->maColumnStyleMap[xKey] );
+                const OUString sStyleName( rTableInfo->maColumnStyleMap[xKey] );
                 if( !sStyleName.isEmpty() )
                     mrExport.AddAttribute(XML_NAMESPACE_TABLE, XML_STYLE_NAME, sStyleName );
             }
@@ -391,19 +391,19 @@ static bool has_states( const std::vector< XMLPropertyState >& xPropStates )
 
 // ODF export for a table cell.
 
- void XMLTableExport::ExportCell( const Reference < XCell >& xCell, const boost::shared_ptr< XMLTableInfo >& pTableInfo, const OUString& rDefaultCellStyle )
+ void XMLTableExport::ExportCell( const Reference < XCell >& xCell, const std::shared_ptr< XMLTableInfo >& rTableInfo, const OUString& rDefaultCellStyle )
  {
     bool bIsMerged = false;
     sal_Int32 nRowSpan = 0;
     sal_Int32 nColSpan = 0;
 
-     try
+    try
     {
-        if( pTableInfo.get() )
+        if( rTableInfo.get() )
         {
             // table:style-name
             Reference< XInterface > xKey( xCell, UNO_QUERY );
-            const OUString sStyleName( pTableInfo->maCellStyleMap[xKey] );
+            const OUString sStyleName( rTableInfo->maCellStyleMap[xKey] );
             if( !sStyleName.isEmpty() && (sStyleName != rDefaultCellStyle) )
                 mrExport.AddAttribute(XML_NAMESPACE_TABLE, XML_STYLE_NAME, sStyleName );
         }
diff --git a/xmloff/source/table/XMLTableImport.cxx b/xmloff/source/table/XMLTableImport.cxx
index dc47fde7db86..729014afff5a 100644
--- a/xmloff/source/table/XMLTableImport.cxx
+++ b/xmloff/source/table/XMLTableImport.cxx
@@ -41,7 +41,7 @@
 
 #include <osl/diagnose.h>
 
-#include <boost/shared_ptr.hpp>
+#include <memory>
 
 using namespace ::xmloff::token;
 using namespace ::com::sun::star::beans;
@@ -86,7 +86,7 @@ struct MergeInfo
         : mnStartColumn( nStartColumn ), mnStartRow( nStartRow ), mnEndColumn( nStartColumn + nColumnSpan - 1 ), mnEndRow( nStartRow + nRowSpan - 1 ) {};
 };
 
-typedef std::vector< boost::shared_ptr< MergeInfo > > MergeInfoVector;
+typedef std::vector< std::shared_ptr< MergeInfo > > MergeInfoVector;
 
 class XMLTableImportContext : public SvXMLImportContext
 {
@@ -113,7 +113,7 @@ public:
     Reference< XTableColumns > mxColumns;
     Reference< XTableRows > mxRows;
 
-    std::vector< boost::shared_ptr< ColumnInfo > > maColumnInfos;
+    std::vector< std::shared_ptr< ColumnInfo > > maColumnInfos;
     sal_Int32 mnCurrentRow;
     sal_Int32 mnCurrentColumn;
 
@@ -214,7 +214,7 @@ SvXMLStyleContext* XMLTableImport::CreateTableTemplateContext( sal_uInt16 nPrfx,
 
 void XMLTableImport::addTableTemplate( const OUString& rsStyleName, XMLTableTemplate& xTableTemplate )
 {
-    boost::shared_ptr< XMLTableTemplate > xPtr( new XMLTableTemplate );
+    std::shared_ptr< XMLTableTemplate > xPtr( new XMLTableTemplate );
     xPtr->swap( xTableTemplate );
     maTableTemplates[rsStyleName] = xPtr;
 }
@@ -238,7 +238,7 @@ void XMLTableImport::finishStyles()
             const OUString sTemplateName( (*aTemplateIter).first );
             Reference< XNameReplace > xTemplate( xFactory->createInstance(), UNO_QUERY_THROW );
 
-            boost::shared_ptr< XMLTableTemplate > xT( (*aTemplateIter).second );
+            std::shared_ptr< XMLTableTemplate > xT( (*aTemplateIter).second );
 
             for( XMLTableTemplate::iterator aStyleIter( xT->begin() ); aStyleIter != xT->end(); ++aStyleIter ) try
             {
@@ -292,7 +292,7 @@ SvXMLImportContext * XMLTableImportContext::ImportColumn( sal_uInt16 nPrefix, co
 {
     if( mxColumns.is() && (mnCurrentRow == -1) ) try
     {
-        boost::shared_ptr< ColumnInfo > xInfo ( new ColumnInfo );
+        std::shared_ptr< ColumnInfo > xInfo ( new ColumnInfo );
 
         sal_Int32 nRepeated = 1;
 
@@ -362,7 +362,7 @@ void XMLTableImportContext::InitColumns()
 
         for( sal_Int32 nCol = 0; nCol < nCount2; nCol++ )
         {
-            boost::shared_ptr< ColumnInfo > xInfo( maColumnInfos[nCol] );
+            std::shared_ptr< ColumnInfo > xInfo( maColumnInfos[nCol] );
 
             if( pAutoStyles && !xInfo->msStyleName.isEmpty() )
             {
@@ -469,7 +469,7 @@ SvXMLImportContext * XMLTableImportContext::ImportCell( sal_uInt16 nPrefix, cons
         const sal_Int32 nColumnSpan = pCellContext->getColumnSpan();
         const sal_Int32 nRowSpan = pCellContext->getRowSpan();
         if( (nColumnSpan > 1) || (nRowSpan > 1) )
-            maMergeInfos.push_back( boost::shared_ptr< MergeInfo >( new MergeInfo( mnCurrentColumn, mnCurrentRow, nColumnSpan, nRowSpan ) ) );
+            maMergeInfos.push_back( std::shared_ptr< MergeInfo >( new MergeInfo( mnCurrentColumn, mnCurrentRow, nColumnSpan, nRowSpan ) ) );
 
         const sal_Int32 nRepeated = pCellContext->getRepeated();
         if( nRepeated > 1 )
@@ -519,7 +519,7 @@ void XMLTableImportContext::EndElement()
         MergeInfoVector::iterator aIter( maMergeInfos.begin() );
         while( aIter != maMergeInfos.end() )
         {
-            boost::shared_ptr< MergeInfo > xInfo( (*aIter++) );
+            std::shared_ptr< MergeInfo > xInfo( (*aIter++) );
 
             if( xInfo.get() ) try
             {
diff --git a/xmloff/source/text/XMLPropertyBackpatcher.cxx b/xmloff/source/text/XMLPropertyBackpatcher.cxx
index 9b514a0b5a4c..f244d0a54c6f 100644
--- a/xmloff/source/text/XMLPropertyBackpatcher.cxx
+++ b/xmloff/source/text/XMLPropertyBackpatcher.cxx
@@ -164,11 +164,11 @@ struct XMLTextImportHelper::BackpatcherImpl
         m_pSequenceNameBackpatcher;
 };
 
-::boost::shared_ptr<XMLTextImportHelper::BackpatcherImpl>
+std::shared_ptr<XMLTextImportHelper::BackpatcherImpl>
 XMLTextImportHelper::MakeBackpatcherImpl()
 {
     // n.b.: the shared_ptr stores the dtor!
-    return ::boost::shared_ptr<BackpatcherImpl>(new BackpatcherImpl);
+    return std::shared_ptr<BackpatcherImpl>(new BackpatcherImpl);
 }
 
 static OUString GetSequenceNumber()
@@ -192,33 +192,33 @@ static OUString GetSequenceNumber()
 
 XMLPropertyBackpatcher<sal_Int16>& XMLTextImportHelper::GetFootnoteBP()
 {
-    if (!m_pBackpatcherImpl->m_pFootnoteBackpatcher.get())
+    if (!m_xBackpatcherImpl->m_pFootnoteBackpatcher.get())
     {
-        m_pBackpatcherImpl->m_pFootnoteBackpatcher.reset(
+        m_xBackpatcherImpl->m_pFootnoteBackpatcher.reset(
             new XMLPropertyBackpatcher<sal_Int16>(GetSequenceNumber()));
     }
-    return *m_pBackpatcherImpl->m_pFootnoteBackpatcher;
+    return *m_xBackpatcherImpl->m_pFootnoteBackpatcher;
 }
 
 XMLPropertyBackpatcher<sal_Int16>& XMLTextImportHelper::GetSequenceIdBP()
 {
-    if (!m_pBackpatcherImpl->m_pSequenceIdBackpatcher.get())
+    if (!m_xBackpatcherImpl->m_pSequenceIdBackpatcher.get())
     {
-        m_pBackpatcherImpl->m_pSequenceIdBackpatcher.reset(
+        m_xBackpatcherImpl->m_pSequenceIdBackpatcher.reset(
             new XMLPropertyBackpatcher<sal_Int16>(GetSequenceNumber()));
     }
-    return *m_pBackpatcherImpl->m_pSequenceIdBackpatcher;
+    return *m_xBackpatcherImpl->m_pSequenceIdBackpatcher;
 }
 
 XMLPropertyBackpatcher<OUString>& XMLTextImportHelper::GetSequenceNameBP()
 {
     static const char s_SourceName[] = "SourceName";
-    if (!m_pBackpatcherImpl->m_pSequenceNameBackpatcher.get())
+    if (!m_xBackpatcherImpl->m_pSequenceNameBackpatcher.get())
     {
-        m_pBackpatcherImpl->m_pSequenceNameBackpatcher.reset(
+        m_xBackpatcherImpl->m_pSequenceNameBackpatcher.reset(
             new XMLPropertyBackpatcher<OUString>(s_SourceName));
     }
-    return *m_pBackpatcherImpl->m_pSequenceNameBackpatcher;
+    return *m_xBackpatcherImpl->m_pSequenceNameBackpatcher;
 }
 
 void XMLTextImportHelper::InsertFootnoteID(
diff --git a/xmloff/source/text/XMLTextMarkImportContext.cxx b/xmloff/source/text/XMLTextMarkImportContext.cxx
index ba4b2d822ed0..f0d34582f180 100644
--- a/xmloff/source/text/XMLTextMarkImportContext.cxx
+++ b/xmloff/source/text/XMLTextMarkImportContext.cxx
@@ -233,12 +233,12 @@ void XMLTextMarkImportContext::EndElement()
                 case TypeBookmarkStart:
                     // save XTextRange for later construction of bookmark
                     {
-                        ::boost::shared_ptr< ::xmloff::ParsedRDFaAttributes >
-                            pRDFaAttributes;
+                        std::shared_ptr< ::xmloff::ParsedRDFaAttributes >
+                            xRDFaAttributes;
                         if (m_bHaveAbout && (TypeBookmarkStart
                                 == static_cast<lcl_MarkType>(nTmp)))
                         {
-                            pRDFaAttributes =
+                            xRDFaAttributes =
                                 GetImport().GetRDFaImportHelper().ParseRDFa(
                                     m_sAbout, m_sProperty,
                                     m_sContent, m_sDatatype);
@@ -246,7 +246,7 @@ void XMLTextMarkImportContext::EndElement()
                         m_rHelper.InsertBookmarkStartRange(
                             m_sBookmarkName,
                             m_rHelper.GetCursorAsRange()->getStart(),
-                            m_sXmlId, pRDFaAttributes);
+                            m_sXmlId, xRDFaAttributes);
                     }
                     break;
 
@@ -255,11 +255,11 @@ void XMLTextMarkImportContext::EndElement()
                 {
                     // get old range, and construct
                     Reference<XTextRange> xStartRange;
-                    ::boost::shared_ptr< ::xmloff::ParsedRDFaAttributes >
-                        pRDFaAttributes;
+                    std::shared_ptr< ::xmloff::ParsedRDFaAttributes >
+                        xRDFaAttributes;
                     if (m_rHelper.FindAndRemoveBookmarkStartRange(
                             m_sBookmarkName, xStartRange,
-                            m_sXmlId, pRDFaAttributes))
+                            m_sXmlId, xRDFaAttributes))
                     {
                         Reference<XTextRange> xEndRange(
                             m_rHelper.GetCursorAsRange()->getStart());
@@ -313,12 +313,12 @@ void XMLTextMarkImportContext::EndElement()
                                         m_sBookmarkName,
                                         xInsertionCursor,
                                         m_sXmlId);
-                                if (pRDFaAttributes)
+                                if (xRDFaAttributes)
                                 {
                                     const Reference<rdf::XMetadatable>
                                         xMeta(xContent, UNO_QUERY);
                                     GetImport().GetRDFaImportHelper().AddRDFa(
-                                        xMeta, pRDFaAttributes);
+                                        xMeta, xRDFaAttributes);
                                 }
                             }
 
diff --git a/xmloff/source/text/txtimp.cxx b/xmloff/source/text/txtimp.cxx
index de4fc70b22a9..d5c6fe378d9e 100644
--- a/xmloff/source/text/txtimp.cxx
+++ b/xmloff/source/text/txtimp.cxx
@@ -525,7 +525,7 @@ struct XMLTextImportHelper::Impl
     // start range, xml:id, RDFa stuff
     typedef ::boost::tuple<
         uno::Reference<text::XTextRange>, OUString,
-        ::boost::shared_ptr< ::xmloff::ParsedRDFaAttributes > >
+        std::shared_ptr< ::xmloff::ParsedRDFaAttributes > >
             BookmarkMapEntry_t;
     /// start ranges for open bookmarks
     ::std::map< OUString, BookmarkMapEntry_t > m_BookmarkStartRanges;
@@ -879,7 +879,7 @@ XMLTextImportHelper::XMLTextImportHelper(
         bool const bOrganizerMode)
     : m_xImpl( new Impl(rModel, rImport, bInsertMode, bStylesOnlyMode,
                     bProgress, bBlockMode, bOrganizerMode) )
-    , m_pBackpatcherImpl( MakeBackpatcherImpl() )
+    , m_xBackpatcherImpl( MakeBackpatcherImpl() )
 {
     static const char s_PropNameDefaultListId[] = "DefaultListId";
 
@@ -2485,7 +2485,7 @@ void XMLTextImportHelper::InsertBookmarkStartRange(
     const OUString & sName,
     const Reference<XTextRange> & rRange,
     OUString const& i_rXmlId,
-    ::boost::shared_ptr< ::xmloff::ParsedRDFaAttributes > & i_rpRDFaAttributes)
+    std::shared_ptr< ::xmloff::ParsedRDFaAttributes > & i_rpRDFaAttributes)
 {
     m_xImpl->m_BookmarkStartRanges[sName] =
         ::boost::make_tuple(rRange, i_rXmlId, i_rpRDFaAttributes);
@@ -2496,7 +2496,7 @@ bool XMLTextImportHelper::FindAndRemoveBookmarkStartRange(
     const OUString & sName,
     Reference<XTextRange> & o_rRange,
     OUString & o_rXmlId,
-    ::boost::shared_ptr< ::xmloff::ParsedRDFaAttributes > & o_rpRDFaAttributes)
+    std::shared_ptr< ::xmloff::ParsedRDFaAttributes > & o_rpRDFaAttributes)
 {
     if (m_xImpl->m_BookmarkStartRanges.count(sName))
     {