writerperfect: astyle -> clang-format

< vmiklos> dtardon: are you strongly attached to astyle usage in
core.git writerperfect/? my problem is that 1) when less regular
contributors touch it, they don't run astyle  2) core.git has git hooks
in place to enforce consistent style for selected files, but that uses
clang-format. i wonder if switching to the standard core.git
clang-format would be an option to stop this reformat game

<@dtardon> vmiklos, clang-format is okay. we started to use astyle years
ago, before there were even any serious talk about automatic formatting
for the whole libreoffice

Change-Id: I844fc9c2e8560e54a49f26064cc0b3c55a5f034c
Reviewed-on: https://gerrit.libreoffice.org/53184
Reviewed-by: Miklos Vajna <vmiklos@collabora.co.uk>
Tested-by: Jenkins <ci@libreoffice.org>

1 files changed, 121 insertions, 113 deletions

diff --git a/writerperfect/source/common/WPXSvInputStream.cxx b/writerperfect/source/common/WPXSvInputStream.cxx
index 971280b8e25b..2dfee8a44799 100644
--- a/writerperfect/source/common/WPXSvInputStream.cxx
+++ b/writerperfect/source/common/WPXSvInputStream.cxx
@@ -30,7 +30,6 @@
 
 namespace writerperfect
 {
-
 using namespace ::com::sun::star::uno;
 using namespace ::com::sun::star::io;
 
@@ -39,21 +38,20 @@ namespace packages = com::sun::star::packages;
 
 namespace
 {
-
 class PositionHolder
 {
 public:
-    explicit PositionHolder(const Reference<XSeekable> &rxSeekable);
+    explicit PositionHolder(const Reference<XSeekable>& rxSeekable);
     ~PositionHolder();
-    PositionHolder(const PositionHolder &) = delete;
-    PositionHolder &operator=(const PositionHolder &) = delete;
+    PositionHolder(const PositionHolder&) = delete;
+    PositionHolder& operator=(const PositionHolder&) = delete;
 
 private:
     const Reference<XSeekable> mxSeekable;
     const sal_uInt64 mnPosition;
 };
 
-PositionHolder::PositionHolder(const Reference<XSeekable> &rxSeekable)
+PositionHolder::PositionHolder(const Reference<XSeekable>& rxSeekable)
     : mxSeekable(rxSeekable)
     , mnPosition(rxSeekable->getPosition())
 {
@@ -65,7 +63,9 @@ PositionHolder::~PositionHolder()
     {
         mxSeekable->seek(mnPosition);
     }
-    catch (...) {}
+    catch (...)
+    {
+    }
 }
 
 } // anonymous namespace
@@ -82,8 +82,7 @@ typedef struct
 
 namespace
 {
-
-rtl::OUString lcl_normalizeSubStreamPath(const rtl::OUString &rPath)
+rtl::OUString lcl_normalizeSubStreamPath(const rtl::OUString& rPath)
 {
     // accept paths which begin by '/'
     // TODO: maybe this should to a full normalization
@@ -91,13 +90,11 @@ rtl::OUString lcl_normalizeSubStreamPath(const rtl::OUString &rPath)
         return rPath.copy(1);
     return rPath;
 }
-
 }
 
 namespace
 {
-
-const rtl::OUString concatPath(const rtl::OUString &lhs, const rtl::OUString &rhs)
+const rtl::OUString concatPath(const rtl::OUString& lhs, const rtl::OUString& rhs)
 {
     if (lhs.isEmpty())
         return rhs;
@@ -106,7 +103,7 @@ const rtl::OUString concatPath(const rtl::OUString &lhs, const rtl::OUString &rh
 
 struct OLEStreamData
 {
-    OLEStreamData(const rtl::OString &rName, const rtl::OString &rvngName);
+    OLEStreamData(const rtl::OString& rName, const rtl::OString& rvngName);
 
     SotStorageStreamRefWrapper stream;
 
@@ -147,25 +144,25 @@ struct OLEStorageImpl
 {
     OLEStorageImpl();
 
-    void initialize(SvStream *pStream);
+    void initialize(SvStream* pStream);
 
-    tools::SvRef<SotStorageStream> getStream(const rtl::OUString &rPath);
-    tools::SvRef<SotStorageStream> const &getStream(std::size_t nId);
+    tools::SvRef<SotStorageStream> getStream(const rtl::OUString& rPath);
+    tools::SvRef<SotStorageStream> const& getStream(std::size_t nId);
 
 private:
-    void traverse(const tools::SvRef<SotStorage> &rStorage, const rtl::OUString &rPath);
+    void traverse(const tools::SvRef<SotStorage>& rStorage, const rtl::OUString& rPath);
 
-    tools::SvRef<SotStorageStream> createStream(const rtl::OUString &rPath);
+    tools::SvRef<SotStorageStream> createStream(const rtl::OUString& rPath);
 
 public:
     SotStorageRefWrapper mxRootStorage; //< root storage of the OLE2
     OLEStorageMap_t maStorageMap; //< map of all sub storages by name
-    ::std::vector< OLEStreamData > maStreams; //< list of streams and their names
+    ::std::vector<OLEStreamData> maStreams; //< list of streams and their names
     NameMap_t maNameMap; //< map of stream names to indexes (into @c maStreams)
     bool mbInitialized;
 };
 
-OLEStreamData::OLEStreamData(const rtl::OString &rName, const rtl::OString &rvngName)
+OLEStreamData::OLEStreamData(const rtl::OString& rName, const rtl::OString& rvngName)
     : stream()
     , name(rName)
     , RVNGname(rvngName)
@@ -181,7 +178,7 @@ OLEStorageImpl::OLEStorageImpl()
 {
 }
 
-void OLEStorageImpl::initialize(SvStream *const pStream)
+void OLEStorageImpl::initialize(SvStream* const pStream)
 {
     if (!pStream)
         return;
@@ -193,7 +190,7 @@ void OLEStorageImpl::initialize(SvStream *const pStream)
     mbInitialized = true;
 }
 
-tools::SvRef<SotStorageStream> OLEStorageImpl::getStream(const rtl::OUString &rPath)
+tools::SvRef<SotStorageStream> OLEStorageImpl::getStream(const rtl::OUString& rPath)
 {
     const rtl::OUString aPath(lcl_normalizeSubStreamPath(rPath));
     NameMap_t::iterator aIt = maNameMap.find(aPath);
@@ -205,20 +202,22 @@ tools::SvRef<SotStorageStream> OLEStorageImpl::getStream(const rtl::OUString &rP
         return tools::SvRef<SotStorageStream>();
 
     if (!maStreams[aIt->second].stream.ref.is())
-        maStreams[aIt->second].stream.ref = createStream(rtl::OStringToOUString(maStreams[aIt->second].name, RTL_TEXTENCODING_UTF8));
+        maStreams[aIt->second].stream.ref = createStream(
+            rtl::OStringToOUString(maStreams[aIt->second].name, RTL_TEXTENCODING_UTF8));
 
     return maStreams[aIt->second].stream.ref;
 }
 
-tools::SvRef<SotStorageStream> const &OLEStorageImpl::getStream(const std::size_t nId)
+tools::SvRef<SotStorageStream> const& OLEStorageImpl::getStream(const std::size_t nId)
 {
     if (!maStreams[nId].stream.ref.is())
-        maStreams[nId].stream.ref = createStream(rtl::OStringToOUString(maStreams[nId].name, RTL_TEXTENCODING_UTF8));
+        maStreams[nId].stream.ref
+            = createStream(rtl::OStringToOUString(maStreams[nId].name, RTL_TEXTENCODING_UTF8));
 
     return maStreams[nId].stream.ref;
 }
 
-void OLEStorageImpl::traverse(const tools::SvRef<SotStorage> &rStorage, const rtl::OUString &rPath)
+void OLEStorageImpl::traverse(const tools::SvRef<SotStorage>& rStorage, const rtl::OUString& rPath)
 {
     SvStorageInfoList infos;
 
@@ -228,12 +227,13 @@ void OLEStorageImpl::traverse(const tools::SvRef<SotStorage> &rStorage, const rt
     {
         if (aIt->IsStream())
         {
-            rtl::OUString baseName=aIt->GetName(), rvngName=baseName;
+            rtl::OUString baseName = aIt->GetName(), rvngName = baseName;
             // librevenge::RVNGOLEStream ignores the first character when is a control code, so ...
-            if (!rvngName.isEmpty() && rvngName.toChar()<32)
-                rvngName=rvngName.copy(1);
-            maStreams.emplace_back(rtl::OUStringToOString(concatPath(rPath, baseName), RTL_TEXTENCODING_UTF8),
-                                   rtl::OUStringToOString(concatPath(rPath, rvngName), RTL_TEXTENCODING_UTF8));
+            if (!rvngName.isEmpty() && rvngName.toChar() < 32)
+                rvngName = rvngName.copy(1);
+            maStreams.emplace_back(
+                rtl::OUStringToOString(concatPath(rPath, baseName), RTL_TEXTENCODING_UTF8),
+                rtl::OUStringToOString(concatPath(rPath, rvngName), RTL_TEXTENCODING_UTF8));
             maNameMap[concatPath(rPath, rvngName)] = maStreams.size() - 1;
         }
         else if (aIt->IsStorage())
@@ -248,12 +248,13 @@ void OLEStorageImpl::traverse(const tools::SvRef<SotStorage> &rStorage, const rt
         }
         else
         {
-            SAL_WARN("writerperfect", "OLEStorageImpl::traverse: invalid storage entry, neither stream nor file");
+            SAL_WARN("writerperfect",
+                     "OLEStorageImpl::traverse: invalid storage entry, neither stream nor file");
         }
     }
 }
 
-tools::SvRef<SotStorageStream> OLEStorageImpl::createStream(const rtl::OUString &rPath)
+tools::SvRef<SotStorageStream> OLEStorageImpl::createStream(const rtl::OUString& rPath)
 {
     const sal_Int32 nDelim = rPath.lastIndexOf(u'/');
 
@@ -270,15 +271,13 @@ tools::SvRef<SotStorageStream> OLEStorageImpl::createStream(const rtl::OUString
 
     return aIt->second.ref->OpenSotStream(aName, StreamMode::STD_READ);
 }
-
 }
 
 namespace
 {
-
 struct ZipStreamData
 {
-    explicit ZipStreamData(const rtl::OString &rName);
+    explicit ZipStreamData(const rtl::OString& rName);
 
     Reference<XInputStream> xStream;
 
@@ -297,7 +296,7 @@ struct ZipStreamData
   */
 struct ZipStorageImpl
 {
-    explicit ZipStorageImpl(const Reference<container::XNameAccess> &rxContainer);
+    explicit ZipStorageImpl(const Reference<container::XNameAccess>& rxContainer);
 
     /** Initialize for access.
       *
@@ -307,28 +306,28 @@ struct ZipStorageImpl
       */
     void initialize();
 
-    Reference<XInputStream> getStream(const rtl::OUString &rPath);
-    Reference<XInputStream> const &getStream(std::size_t nId);
+    Reference<XInputStream> getStream(const rtl::OUString& rPath);
+    Reference<XInputStream> const& getStream(std::size_t nId);
 
 private:
-    void traverse(const Reference<container::XNameAccess> &rxEnum);
+    void traverse(const Reference<container::XNameAccess>& rxEnum);
 
-    Reference<XInputStream> createStream(const rtl::OUString &rPath);
+    Reference<XInputStream> createStream(const rtl::OUString& rPath);
 
 public:
     Reference<container::XNameAccess> mxContainer; //< root of the Zip
-    ::std::vector< ZipStreamData > maStreams; //< list of streams and their names
+    ::std::vector<ZipStreamData> maStreams; //< list of streams and their names
     NameMap_t maNameMap; //< map of stream names to indexes (into @c maStreams)
     bool mbInitialized;
 };
 
-ZipStreamData::ZipStreamData(const rtl::OString &rName)
+ZipStreamData::ZipStreamData(const rtl::OString& rName)
     : xStream()
     , aName(rName)
 {
 }
 
-ZipStorageImpl::ZipStorageImpl(const Reference<container::XNameAccess> &rxContainer)
+ZipStorageImpl::ZipStorageImpl(const Reference<container::XNameAccess>& rxContainer)
     : mxContainer(rxContainer)
     , maStreams()
     , maNameMap()
@@ -344,7 +343,7 @@ void ZipStorageImpl::initialize()
     mbInitialized = true;
 }
 
-Reference<XInputStream> ZipStorageImpl::getStream(const rtl::OUString &rPath)
+Reference<XInputStream> ZipStorageImpl::getStream(const rtl::OUString& rPath)
 {
     const rtl::OUString aPath(lcl_normalizeSubStreamPath(rPath));
     NameMap_t::iterator aIt = maNameMap.find(aPath);
@@ -361,15 +360,16 @@ Reference<XInputStream> ZipStorageImpl::getStream(const rtl::OUString &rPath)
     return maStreams[aIt->second].xStream;
 }
 
-Reference<XInputStream> const &ZipStorageImpl::getStream(const std::size_t nId)
+Reference<XInputStream> const& ZipStorageImpl::getStream(const std::size_t nId)
 {
     if (!maStreams[nId].xStream.is())
-        maStreams[nId].xStream = createStream(rtl::OStringToOUString(maStreams[nId].aName, RTL_TEXTENCODING_UTF8));
+        maStreams[nId].xStream
+            = createStream(rtl::OStringToOUString(maStreams[nId].aName, RTL_TEXTENCODING_UTF8));
 
     return maStreams[nId].xStream;
 }
 
-void ZipStorageImpl::traverse(const Reference<container::XNameAccess> &rxContainer)
+void ZipStorageImpl::traverse(const Reference<container::XNameAccess>& rxContainer)
 {
     const Sequence<rtl::OUString> lNames = rxContainer->getElementNames();
 
@@ -385,7 +385,7 @@ void ZipStorageImpl::traverse(const Reference<container::XNameAccess> &rxContain
     }
 }
 
-Reference<XInputStream> ZipStorageImpl::createStream(const rtl::OUString &rPath)
+Reference<XInputStream> ZipStorageImpl::createStream(const rtl::OUString& rPath)
 {
     Reference<XInputStream> xStream;
 
@@ -397,32 +397,31 @@ Reference<XInputStream> ZipStorageImpl::createStream(const rtl::OUString &rPath)
         if (xSeekable.is())
             xStream = xInputStream;
         else
-            xStream.set(new comphelper::OSeekableInputWrapper(xInputStream, comphelper::getProcessComponentContext()));
+            xStream.set(new comphelper::OSeekableInputWrapper(
+                xInputStream, comphelper::getProcessComponentContext()));
     }
-    catch (const Exception &)
+    catch (const Exception&)
     {
         // nothing needed
     }
 
     return xStream;
 }
-
 }
 
 class WPXSvInputStreamImpl
 {
 public:
-    explicit WPXSvInputStreamImpl(css::uno::Reference<
-                                  css::io::XInputStream > const &xStream);
+    explicit WPXSvInputStreamImpl(css::uno::Reference<css::io::XInputStream> const& xStream);
 
     bool isStructured();
     unsigned subStreamCount();
-    const char *subStreamName(unsigned id);
-    bool existsSubStream(const char *name);
-    librevenge::RVNGInputStream *getSubStreamByName(const char *name);
-    librevenge::RVNGInputStream *getSubStreamById(unsigned id);
+    const char* subStreamName(unsigned id);
+    bool existsSubStream(const char* name);
+    librevenge::RVNGInputStream* getSubStreamByName(const char* name);
+    librevenge::RVNGInputStream* getSubStreamById(unsigned id);
 
-    const unsigned char *read(unsigned long numBytes, unsigned long &numBytesRead);
+    const unsigned char* read(unsigned long numBytes, unsigned long& numBytesRead);
     int seek(long offset);
     long tell();
     bool isEnd();
@@ -436,36 +435,38 @@ private:
     bool isZip();
     void ensureZipIsInitialized();
 
-    static librevenge::RVNGInputStream *createWPXStream(const tools::SvRef<SotStorageStream> &rxStorage);
-    static librevenge::RVNGInputStream *createWPXStream(const Reference<XInputStream> &rxStream);
+    static librevenge::RVNGInputStream*
+    createWPXStream(const tools::SvRef<SotStorageStream>& rxStorage);
+    static librevenge::RVNGInputStream* createWPXStream(const Reference<XInputStream>& rxStream);
 
 private:
-    css::uno::Reference< css::io::XInputStream > mxStream;
-    css::uno::Reference< css::io::XSeekable > mxSeekable;
-    css::uno::Sequence< sal_Int8 > maData;
-    std::unique_ptr< OLEStorageImpl > mpOLEStorage;
-    std::unique_ptr< ZipStorageImpl > mpZipStorage;
+    css::uno::Reference<css::io::XInputStream> mxStream;
+    css::uno::Reference<css::io::XSeekable> mxSeekable;
+    css::uno::Sequence<sal_Int8> maData;
+    std::unique_ptr<OLEStorageImpl> mpOLEStorage;
+    std::unique_ptr<ZipStorageImpl> mpZipStorage;
     bool mbCheckedOLE;
     bool mbCheckedZip;
+
 public:
     sal_Int64 mnLength;
-    const unsigned char *mpReadBuffer;
+    const unsigned char* mpReadBuffer;
     unsigned long mnReadBufferLength;
     unsigned long mnReadBufferPos;
 };
 
-WPXSvInputStreamImpl::WPXSvInputStreamImpl(Reference< XInputStream > const &xStream) :
-    mxStream(xStream),
-    mxSeekable(xStream, UNO_QUERY),
-    maData(0),
-    mpOLEStorage(nullptr),
-    mpZipStorage(nullptr),
-    mbCheckedOLE(false),
-    mbCheckedZip(false),
-    mnLength(0),
-    mpReadBuffer(nullptr),
-    mnReadBufferLength(0),
-    mnReadBufferPos(0)
+WPXSvInputStreamImpl::WPXSvInputStreamImpl(Reference<XInputStream> const& xStream)
+    : mxStream(xStream)
+    , mxSeekable(xStream, UNO_QUERY)
+    , maData(0)
+    , mpOLEStorage(nullptr)
+    , mpZipStorage(nullptr)
+    , mbCheckedOLE(false)
+    , mbCheckedZip(false)
+    , mnLength(0)
+    , mpReadBuffer(nullptr)
+    , mnReadBufferLength(0)
+    , mnReadBufferPos(0)
 {
     if (!xStream.is() || !mxStream.is())
         mnLength = 0;
@@ -490,7 +491,7 @@ WPXSvInputStreamImpl::WPXSvInputStreamImpl(Reference< XInputStream > const &xStr
     }
 }
 
-const unsigned char *WPXSvInputStreamImpl::read(unsigned long numBytes, unsigned long &numBytesRead)
+const unsigned char* WPXSvInputStreamImpl::read(unsigned long numBytes, unsigned long& numBytesRead)
 {
     numBytesRead = 0;
 
@@ -501,7 +502,7 @@ const unsigned char *WPXSvInputStreamImpl::read(unsigned long numBytes, unsigned
     if (numBytesRead == 0)
         return nullptr;
 
-    return reinterpret_cast<const unsigned char *>(maData.getConstArray());
+    return reinterpret_cast<const unsigned char*>(maData.getConstArray());
 }
 
 long WPXSvInputStreamImpl::tell()
@@ -588,7 +589,7 @@ unsigned WPXSvInputStreamImpl::subStreamCount()
     return 0;
 }
 
-const char *WPXSvInputStreamImpl::subStreamName(const unsigned id)
+const char* WPXSvInputStreamImpl::subStreamName(const unsigned id)
 {
     if ((mnLength == 0) || !mxStream.is() || !mxSeekable.is())
         return nullptr;
@@ -621,7 +622,7 @@ const char *WPXSvInputStreamImpl::subStreamName(const unsigned id)
     return nullptr;
 }
 
-bool WPXSvInputStreamImpl::existsSubStream(const char *const name)
+bool WPXSvInputStreamImpl::existsSubStream(const char* const name)
 {
     if (!name)
         return false;
@@ -651,7 +652,7 @@ bool WPXSvInputStreamImpl::existsSubStream(const char *const name)
     return false;
 }
 
-librevenge::RVNGInputStream *WPXSvInputStreamImpl::getSubStreamByName(const char *const name)
+librevenge::RVNGInputStream* WPXSvInputStreamImpl::getSubStreamByName(const char* const name)
 {
     if (!name)
         return nullptr;
@@ -680,7 +681,7 @@ librevenge::RVNGInputStream *WPXSvInputStreamImpl::getSubStreamByName(const char
         {
             return createWPXStream(mpZipStorage->getStream(aName));
         }
-        catch (const Exception &)
+        catch (const Exception&)
         {
             // nothing needed
         }
@@ -689,7 +690,7 @@ librevenge::RVNGInputStream *WPXSvInputStreamImpl::getSubStreamByName(const char
     return nullptr;
 }
 
-librevenge::RVNGInputStream *WPXSvInputStreamImpl::getSubStreamById(const unsigned id)
+librevenge::RVNGInputStream* WPXSvInputStreamImpl::getSubStreamById(const unsigned id)
 {
     if ((mnLength == 0) || !mxStream.is() || !mxSeekable.is())
         return nullptr;
@@ -720,7 +721,7 @@ librevenge::RVNGInputStream *WPXSvInputStreamImpl::getSubStreamById(const unsign
         {
             return createWPXStream(mpZipStorage->getStream(id));
         }
-        catch (const Exception &)
+        catch (const Exception&)
         {
             // nothing needed
         }
@@ -739,17 +740,19 @@ void WPXSvInputStreamImpl::invalidateReadBuffer()
     }
 }
 
-librevenge::RVNGInputStream *WPXSvInputStreamImpl::createWPXStream(const tools::SvRef<SotStorageStream> &rxStorage)
+librevenge::RVNGInputStream*
+WPXSvInputStreamImpl::createWPXStream(const tools::SvRef<SotStorageStream>& rxStorage)
 {
     if (rxStorage.is())
     {
-        Reference < XInputStream > xContents(new utl::OSeekableInputStreamWrapper(rxStorage.get()));
+        Reference<XInputStream> xContents(new utl::OSeekableInputStreamWrapper(rxStorage.get()));
         return new WPXSvInputStream(xContents);
     }
     return nullptr;
 }
 
-librevenge::RVNGInputStream *WPXSvInputStreamImpl::createWPXStream(const Reference<XInputStream> &rxStream)
+librevenge::RVNGInputStream*
+WPXSvInputStreamImpl::createWPXStream(const Reference<XInputStream>& rxStream)
 {
     if (rxStream.is())
         return new WPXSvInputStream(rxStream);
@@ -784,13 +787,15 @@ bool WPXSvInputStreamImpl::isZip()
             Sequence<Any> aArgs(1);
             aArgs[0] <<= mxStream;
 
-            const Reference<XComponentContext> xContext(comphelper::getProcessComponentContext(), UNO_QUERY_THROW);
+            const Reference<XComponentContext> xContext(comphelper::getProcessComponentContext(),
+                                                        UNO_QUERY_THROW);
             const Reference<packages::zip::XZipFileAccess2> xZip(
-                xContext->getServiceManager()->createInstanceWithArgumentsAndContext("com.sun.star.packages.zip.ZipFileAccess", aArgs, xContext),
+                xContext->getServiceManager()->createInstanceWithArgumentsAndContext(
+                    "com.sun.star.packages.zip.ZipFileAccess", aArgs, xContext),
                 UNO_QUERY_THROW);
             mpZipStorage.reset(new ZipStorageImpl(xZip));
         }
-        catch (const Exception &)
+        catch (const Exception&)
         {
             // ignore
         }
@@ -817,29 +822,28 @@ void WPXSvInputStreamImpl::ensureZipIsInitialized()
         mpZipStorage->initialize();
 }
 
-WPXSvInputStream::WPXSvInputStream(Reference< XInputStream > const &xStream) :
-    mpImpl(new WPXSvInputStreamImpl(xStream))
+WPXSvInputStream::WPXSvInputStream(Reference<XInputStream> const& xStream)
+    : mpImpl(new WPXSvInputStreamImpl(xStream))
 {
 }
 
-WPXSvInputStream::~WPXSvInputStream()
-{
-}
+WPXSvInputStream::~WPXSvInputStream() {}
 
 #define BUFFER_MAX 65536
 
-const unsigned char *WPXSvInputStream::read(unsigned long numBytes, unsigned long &numBytesRead)
+const unsigned char* WPXSvInputStream::read(unsigned long numBytes, unsigned long& numBytesRead)
 {
     numBytesRead = 0;
 
-    if (numBytes == 0 || numBytes > std::numeric_limits<unsigned long>::max()/2)
+    if (numBytes == 0 || numBytes > std::numeric_limits<unsigned long>::max() / 2)
         return nullptr;
 
     if (mpImpl->mpReadBuffer)
     {
-        if ((mpImpl->mnReadBufferPos + numBytes > mpImpl->mnReadBufferPos) && (mpImpl->mnReadBufferPos + numBytes <= mpImpl->mnReadBufferLength))
+        if ((mpImpl->mnReadBufferPos + numBytes > mpImpl->mnReadBufferPos)
+            && (mpImpl->mnReadBufferPos + numBytes <= mpImpl->mnReadBufferLength))
         {
-            const unsigned char *pTmp = mpImpl->mpReadBuffer + mpImpl->mnReadBufferPos;
+            const unsigned char* pTmp = mpImpl->mpReadBuffer + mpImpl->mnReadBufferPos;
             mpImpl->mnReadBufferPos += numBytes;
             numBytesRead = numBytes;
             return pTmp;
@@ -849,11 +853,12 @@ const unsigned char *WPXSvInputStream::read(unsigned long numBytes, unsigned lon
     }
 
     unsigned long curpos = static_cast<unsigned long>(mpImpl->tell());
-    if (curpos == static_cast<unsigned long>(-1))  // returned ERROR
+    if (curpos == static_cast<unsigned long>(-1)) // returned ERROR
         return nullptr;
 
-    if ((curpos + numBytes < curpos) /*overflow*/ ||
-            (curpos + numBytes >= static_cast<sal_uInt64>(mpImpl->mnLength)))  /*reading more than available*/
+    if ((curpos + numBytes < curpos) /*overflow*/
+        || (curpos + numBytes
+            >= static_cast<sal_uInt64>(mpImpl->mnLength))) /*reading more than available*/
     {
         numBytes = mpImpl->mnLength - curpos;
     }
@@ -889,7 +894,8 @@ const unsigned char *WPXSvInputStream::read(unsigned long numBytes, unsigned lon
 long WPXSvInputStream::tell()
 {
     long retVal = mpImpl->tell();
-    return retVal - static_cast<long>(mpImpl->mnReadBufferLength) + static_cast<long>(mpImpl->mnReadBufferPos);
+    return retVal - static_cast<long>(mpImpl->mnReadBufferLength)
+           + static_cast<long>(mpImpl->mnReadBufferPos);
 }
 
 int WPXSvInputStream::seek(long offset, librevenge::RVNG_SEEK_TYPE seekType)
@@ -912,9 +918,12 @@ int WPXSvInputStream::seek(long offset, librevenge::RVNG_SEEK_TYPE seekType)
         retVal = -1;
     }
 
-    if (tmpOffset < mpImpl->tell() && static_cast<unsigned long>(tmpOffset) >= static_cast<unsigned long>(mpImpl->tell()) - mpImpl->mnReadBufferLength)
+    if (tmpOffset < mpImpl->tell()
+        && static_cast<unsigned long>(tmpOffset)
+               >= static_cast<unsigned long>(mpImpl->tell()) - mpImpl->mnReadBufferLength)
     {
-        mpImpl->mnReadBufferPos = static_cast<unsigned long>(tmpOffset + static_cast<long>(mpImpl->mnReadBufferLength) - mpImpl->tell());
+        mpImpl->mnReadBufferPos = static_cast<unsigned long>(
+            tmpOffset + static_cast<long>(mpImpl->mnReadBufferLength) - mpImpl->tell());
         return retVal;
     }
 
@@ -942,30 +951,29 @@ unsigned WPXSvInputStream::subStreamCount()
     return mpImpl->subStreamCount();
 }
 
-const char *WPXSvInputStream::subStreamName(const unsigned id)
+const char* WPXSvInputStream::subStreamName(const unsigned id)
 {
     mpImpl->invalidateReadBuffer();
     return mpImpl->subStreamName(id);
 }
 
-bool WPXSvInputStream::existsSubStream(const char *const name)
+bool WPXSvInputStream::existsSubStream(const char* const name)
 {
     mpImpl->invalidateReadBuffer();
     return mpImpl->existsSubStream(name);
 }
 
-librevenge::RVNGInputStream *WPXSvInputStream::getSubStreamByName(const char *name)
+librevenge::RVNGInputStream* WPXSvInputStream::getSubStreamByName(const char* name)
 {
     mpImpl->invalidateReadBuffer();
     return mpImpl->getSubStreamByName(name);
 }
 
-librevenge::RVNGInputStream *WPXSvInputStream::getSubStreamById(const unsigned id)
+librevenge::RVNGInputStream* WPXSvInputStream::getSubStreamById(const unsigned id)
 {
     mpImpl->invalidateReadBuffer();
     return mpImpl->getSubStreamById(id);
 }
-
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */