libreoffice/comphelper/source/misc/DirectoryHelper.cxx

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */

#include <comphelper/DirectoryHelper.hxx>

#include <sal/config.h>
#include <osl/file.hxx>
#include <rtl/uri.hxx>

#include <memory>

namespace comphelper
{
typedef std::shared_ptr<osl::File> FileSharedPtr;

std::u16string_view DirectoryHelper::splitAtLastToken(std::u16string_view rSrc, sal_Unicode aToken,
                                                      OUString& rRight)
{
    const size_t nIndex(rSrc.rfind(aToken));
    std::u16string_view aRetval;

    if (std::u16string_view::npos == nIndex)
    {
        aRetval = rSrc;
        rRight.clear();
    }
    else if (nIndex > 0)
    {
        aRetval = rSrc.substr(0, nIndex);

        if (rSrc.size() > nIndex + 1)
        {
            rRight = rSrc.substr(nIndex + 1);
        }
    }

    return aRetval;
}

bool DirectoryHelper::fileExists(const OUString& rBaseURL)
{
    if (!rBaseURL.isEmpty())
    {
        FileSharedPtr aBaseFile = std::make_shared<osl::File>(rBaseURL);

        return (osl::File::E_None == aBaseFile->open(osl_File_OpenFlag_Read));
    }

    return false;
}

bool DirectoryHelper::dirExists(const OUString& rDirURL)
{
    if (!rDirURL.isEmpty())
    {
        osl::Directory aDirectory(rDirURL);

        return (osl::FileBase::E_None == aDirectory.open());
    }

    return false;
}

void DirectoryHelper::scanDirsAndFiles(const OUString& rDirURL, std::set<OUString>& rDirs,
                                       std::set<std::pair<OUString, OUString>>& rFiles)
{
    if (rDirURL.isEmpty())
        return;

    osl::Directory aDirectory(rDirURL);

    if (osl::FileBase::E_None != aDirectory.open())
        return;

    auto lcl_encodeUriSegment = [](OUString const& rPath) {
        return rtl::Uri::encode(rPath, rtl_UriCharClassUricNoSlash, rtl_UriEncodeIgnoreEscapes,
                                RTL_TEXTENCODING_UTF8);
    };

    osl::DirectoryItem aDirectoryItem;

    while (osl::FileBase::E_None == aDirectory.getNextItem(aDirectoryItem))
    {
        osl::FileStatus aFileStatus(osl_FileStatus_Mask_Type | osl_FileStatus_Mask_FileName);

        if (osl::FileBase::E_None == aDirectoryItem.getFileStatus(aFileStatus))
        {
            if (aFileStatus.isDirectory())
            {
                const OUString aFileName(aFileStatus.getFileName());

                if (!aFileName.isEmpty())
                {
                    rDirs.insert(lcl_encodeUriSegment(aFileName));
                }
            }
            else if (aFileStatus.isRegular())
            {
                OUString aFileName(aFileStatus.getFileName());
                OUString aExtension;
                aFileName = splitAtLastToken(aFileName, '.', aExtension);

                if (!aFileName.isEmpty())
                {
                    rFiles.insert(std::pair<OUString, OUString>(lcl_encodeUriSegment(aFileName),
                                                                lcl_encodeUriSegment(aExtension)));
                }
            }
        }
    }
}

bool DirectoryHelper::deleteDirRecursively(const OUString& rDirURL)
{
    std::set<OUString> aDirs;
    std::set<std::pair<OUString, OUString>> aFiles;
    bool bError(false);

    scanDirsAndFiles(rDirURL, aDirs, aFiles);

    for (const auto& dir : aDirs)
    {
        const OUString aNewDirURL(rDirURL + "/" + dir);

        bError |= deleteDirRecursively(aNewDirURL);
    }

    for (const auto& file : aFiles)
    {
        OUString aNewFileURL(rDirURL + "/" + file.first);

        if (!file.second.isEmpty())
        {
            aNewFileURL += "." + file.second;
        }
        bError |= (osl::FileBase::E_None != osl::File::remove(aNewFileURL));
    }

    bError |= (osl::FileBase::E_None != osl::Directory::remove(rDirURL));

    return bError;
}

// both exist, move content
bool DirectoryHelper::moveDirContent(const OUString& rSourceDirURL,
                                     std::u16string_view rTargetDirURL,
                                     const std::set<OUString>& rExcludeList)
{
    std::set<OUString> aDirs;
    std::set<std::pair<OUString, OUString>> aFiles;
    bool bError(false);

    scanDirsAndFiles(rSourceDirURL, aDirs, aFiles);

    for (const auto& dir : aDirs)
    {
        const bool bExcluded(!rExcludeList.empty() && rExcludeList.find(dir) != rExcludeList.end());

        if (!bExcluded)
        {
            const OUString aNewSourceDirURL(rSourceDirURL + "/" + dir);

            if (dirExists(aNewSourceDirURL))
            {
                const OUString aNewTargetDirURL(OUString::Concat(rTargetDirURL) + "/" + dir);

                if (dirExists(aNewTargetDirURL))
                {
                    deleteDirRecursively(aNewTargetDirURL);
                }

                bError |= (osl::FileBase::E_None
                           != osl::File::move(aNewSourceDirURL, aNewTargetDirURL));
            }
        }
    }

    for (const auto& file : aFiles)
    {
        OUString aSourceFileURL(rSourceDirURL + "/" + file.first);

        if (!file.second.isEmpty())
        {
            aSourceFileURL += "." + file.second;
        }

        if (fileExists(aSourceFileURL))
        {
            OUString aTargetFileURL(OUString::Concat(rTargetDirURL) + "/" + file.first);

            if (!file.second.isEmpty())
            {
                aTargetFileURL += "." + file.second;
            }

            if (fileExists(aTargetFileURL))
            {
                osl::File::remove(aTargetFileURL);
            }

            bError |= (osl::FileBase::E_None != osl::File::move(aSourceFileURL, aTargetFileURL));
        }
    }

    return bError;
}
}