359 lines
8.6 KiB
C++
359 lines
8.6 KiB
C++
/*
|
|
* (c) Copyright Ascensio System SIA 2010-2023
|
|
*
|
|
* This program is a free software product. You can redistribute it and/or
|
|
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
|
* version 3 as published by the Free Software Foundation. In accordance with
|
|
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
|
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
|
* of any third-party rights.
|
|
*
|
|
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
|
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
|
*
|
|
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
|
|
* street, Riga, Latvia, EU, LV-1050.
|
|
*
|
|
* The interactive user interfaces in modified source and object code versions
|
|
* of the Program must display Appropriate Legal Notices, as required under
|
|
* Section 5 of the GNU AGPL version 3.
|
|
*
|
|
* Pursuant to Section 7(b) of the License you must retain the original Product
|
|
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
|
* grant you any rights under trademark law for use of our trademarks.
|
|
*
|
|
* All the Product's GUI elements, including illustrations and icon sets, as
|
|
* well as technical writing content are licensed under the terms of the
|
|
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
|
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
|
*
|
|
*/
|
|
|
|
#include "../Base/Base.h"
|
|
#include "../Base/Unit.h"
|
|
#include "../../DesktopEditor/common/File.h"
|
|
#include "../../DesktopEditor/common/Directory.h"
|
|
#include "SystemUtility.h"
|
|
|
|
namespace OOX
|
|
{
|
|
CPath::CPath() : m_strFilename(L"")
|
|
{
|
|
CheckIsRoot();
|
|
}
|
|
|
|
CPath::CPath(const std::wstring& sName, bool bIsNorm) : m_strFilename(sName)
|
|
{
|
|
CheckIsRoot();
|
|
if (bIsNorm)
|
|
Normalize();
|
|
}
|
|
CPath::CPath(const char*& sName, bool bIsNorm)
|
|
{
|
|
std::string s(sName);
|
|
m_strFilename = std::wstring(s.begin(), s.end());
|
|
CheckIsRoot();
|
|
if (bIsNorm)
|
|
Normalize();
|
|
}
|
|
CPath::CPath(const wchar_t*& sName, bool bIsNorm) : m_strFilename(sName)
|
|
{
|
|
CheckIsRoot();
|
|
if (bIsNorm)
|
|
Normalize();
|
|
}
|
|
|
|
CPath::CPath(const CPath& oSrc)
|
|
{
|
|
*this = oSrc;
|
|
//считаем вызывать ли Normalize решает oSrc
|
|
//Normalize();
|
|
}
|
|
|
|
CPath& CPath::operator=(const CPath& oSrc)
|
|
{
|
|
m_strFilename = oSrc.m_strFilename;
|
|
m_bIsRoot = oSrc.m_bIsRoot;
|
|
//считаем вызывать ли Normalize решает oSrc
|
|
//Normalize();
|
|
return *this;
|
|
}
|
|
CPath& CPath::operator=(const std::wstring& oSrc)
|
|
{
|
|
m_strFilename = oSrc;
|
|
Normalize();
|
|
return *this;
|
|
}
|
|
CPath& CPath::operator=(const char* oSrc)
|
|
{
|
|
std::string s(oSrc);
|
|
m_strFilename = std::wstring(s.begin(), s.end());
|
|
Normalize();
|
|
return *this;
|
|
}
|
|
CPath& CPath::operator=(const wchar_t* oSrc)
|
|
{
|
|
m_strFilename = oSrc;
|
|
Normalize();
|
|
return *this;
|
|
}
|
|
void CPath::Normalize()
|
|
{
|
|
if (0 == m_strFilename.length())
|
|
return;
|
|
|
|
//todooo оптимизировать
|
|
XmlUtils::replace_all(m_strFilename, L"/", FILE_SEPARATOR_STR);
|
|
XmlUtils::replace_all(m_strFilename, L"\\", FILE_SEPARATOR_STR);
|
|
|
|
const wchar_t* pData = m_strFilename.c_str();
|
|
int nLen = (int) m_strFilename.length();
|
|
|
|
wchar_t* pDataNorm = new wchar_t [nLen + 1];
|
|
int* pSlashPoints = new int [nLen + 1];
|
|
|
|
int nStart = 0;
|
|
int nCurrent = 0;
|
|
int nCurrentSlash = -1;
|
|
int nCurrentW = 0;
|
|
bool bIsUp = false;
|
|
|
|
#if defined(_WIN32) || defined (_WIN64)
|
|
std::wstring prepending = std::wstring(FILE_SEPARATOR_STR) + FILE_SEPARATOR_STR + L"?";
|
|
if (0 == m_strFilename.find(prepending))
|
|
{
|
|
pDataNorm[nCurrentW++] = FILE_SEPARATOR_CHAR;
|
|
pDataNorm[nCurrentW++] = FILE_SEPARATOR_CHAR;
|
|
pDataNorm[nCurrentW++] = L'?';
|
|
pDataNorm[nCurrentW++] = FILE_SEPARATOR_CHAR;
|
|
|
|
nStart = nCurrent = 3;
|
|
}
|
|
#else
|
|
if (pData[nCurrent] == FILE_SEPARATOR_CHAR)
|
|
pDataNorm[nCurrentW++] = pData[nCurrent];
|
|
#endif
|
|
while (nCurrent < nLen)
|
|
{
|
|
if (pData[nCurrent] == FILE_SEPARATOR_CHAR)
|
|
{
|
|
if (nStart < nCurrent)
|
|
{
|
|
bIsUp = false;
|
|
if ((nCurrent - nStart) == 2)
|
|
{
|
|
if (pData[nStart] == (wchar_t)'.' && pData[nStart + 1] == (wchar_t)'.')
|
|
{
|
|
if (nCurrentSlash > 0)
|
|
{
|
|
--nCurrentSlash;
|
|
nCurrentW = pSlashPoints[nCurrentSlash];
|
|
bIsUp = true;
|
|
}
|
|
}
|
|
}
|
|
if (!bIsUp)
|
|
{
|
|
pDataNorm[nCurrentW++] = (wchar_t) FILE_SEPARATOR_CHAR;
|
|
++nCurrentSlash;
|
|
pSlashPoints[nCurrentSlash] = nCurrentW;
|
|
}
|
|
}
|
|
nStart = nCurrent + 1;
|
|
++nCurrent;
|
|
continue;
|
|
}
|
|
pDataNorm[nCurrentW++] = pData[nCurrent];
|
|
++nCurrent;
|
|
}
|
|
|
|
pDataNorm[nCurrentW] = (wchar_t)'\0';
|
|
|
|
m_strFilename = std::wstring(pDataNorm, nCurrentW);
|
|
|
|
delete []pSlashPoints;
|
|
delete []pDataNorm;
|
|
}
|
|
|
|
|
|
bool CPath::FileInDirectoryCorrect()
|
|
{
|
|
std::wstring fileDirectory = GetDirectory(false);
|
|
|
|
std::wstring lowerFileName = XmlUtils::GetLower(m_strFilename);
|
|
|
|
std::vector<std::wstring> trueArray;
|
|
|
|
NSDirectory::GetFiles2(fileDirectory, trueArray);
|
|
|
|
for (size_t i = 0; i < trueArray.size(); i++)
|
|
{
|
|
std::wstring lowerTest = XmlUtils::GetLower(trueArray[i]);
|
|
|
|
if (lowerTest == lowerFileName)
|
|
{
|
|
m_strFilename = trueArray[i];
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
CPath operator/(const CPath& path1, const CPath& path2)
|
|
{
|
|
CPath path(path1.m_strFilename + FILE_SEPARATOR_STR + path2.m_strFilename);
|
|
path.Normalize();
|
|
|
|
return path;
|
|
}
|
|
CPath operator/(const CPath& path1, const std::wstring& path2)
|
|
{
|
|
CPath path(path1.m_strFilename + FILE_SEPARATOR_STR + path2);
|
|
path.Normalize();
|
|
|
|
return path;
|
|
}
|
|
|
|
CPath operator+(const CPath& path1, const CPath& path2)
|
|
{
|
|
CPath path(path1.m_strFilename + path2.m_strFilename);
|
|
path.Normalize();
|
|
return path;
|
|
}
|
|
CPath operator+(const CPath& path1, const std::wstring& path2)
|
|
{
|
|
CPath path(path1.m_strFilename + path2);
|
|
path.Normalize();
|
|
return path;
|
|
}
|
|
CPath operator+(const std::wstring& path1, const CPath& path2)
|
|
{
|
|
CPath path(path1 + path2.m_strFilename);
|
|
path.Normalize();
|
|
return path;
|
|
}
|
|
|
|
std::wstring CPath::GetBasename() const
|
|
{
|
|
std::wstring sFilename = GetFilename();
|
|
std::wstring sExt = GetExtention();
|
|
return sFilename.substr(0, sFilename.length() - sExt.length());
|
|
}
|
|
std::wstring CPath::GetExtention(bool bIsPoint) const
|
|
{
|
|
size_t nFind = m_strFilename.rfind('.');
|
|
if (std::wstring::npos == nFind)
|
|
return L"";
|
|
|
|
if (!bIsPoint)
|
|
++nFind;
|
|
|
|
return m_strFilename.substr(nFind);
|
|
}
|
|
void CPath::SetExtention(const std::wstring& ext)
|
|
{
|
|
size_t nFind = m_strFilename.rfind('.');
|
|
if (std::wstring::npos == nFind)
|
|
{
|
|
m_strFilename += L"." + ext;
|
|
}
|
|
else
|
|
{
|
|
m_strFilename = m_strFilename.substr(0, nFind + 1) + ext;
|
|
}
|
|
|
|
}
|
|
std::wstring CPath::GetDirectory(bool bIsSlash) const
|
|
{
|
|
int nPos = (int)m_strFilename.rfind(FILE_SEPARATOR_CHAR);
|
|
if (-1 == nPos)
|
|
{
|
|
return m_strFilename;
|
|
}
|
|
else
|
|
{
|
|
if (bIsSlash)
|
|
++nPos;
|
|
return m_strFilename.substr(0, nPos);
|
|
}
|
|
}
|
|
std::wstring CPath::GetPath() const
|
|
{
|
|
return m_strFilename;
|
|
}
|
|
std::wstring CPath::GetFilename() const
|
|
{
|
|
int nPos = (int)m_strFilename.rfind(FILE_SEPARATOR_CHAR);
|
|
if (-1 == nPos)
|
|
{
|
|
return m_strFilename;
|
|
}
|
|
else
|
|
{
|
|
int nLast = (int) m_strFilename.length();
|
|
return m_strFilename.substr(nPos + 1, nLast);
|
|
}
|
|
}
|
|
|
|
void CPath::CheckIsRoot()
|
|
{
|
|
if(m_strFilename.length() > 0 && ( '/' == m_strFilename[0] ))
|
|
m_bIsRoot = true;
|
|
else
|
|
m_bIsRoot = false;
|
|
}
|
|
|
|
void CPath::SetName(std::wstring sName, bool bNormalize)
|
|
{
|
|
m_strFilename = sName;
|
|
CheckIsRoot();
|
|
if(bNormalize)
|
|
Normalize();
|
|
}
|
|
|
|
bool CPath::GetIsRoot()
|
|
{
|
|
return m_bIsRoot;
|
|
}
|
|
}
|
|
|
|
namespace OOX
|
|
{
|
|
bool CSystemUtility::IsFileExist(const std::wstring& strFileName)
|
|
{
|
|
return NSFile::CFileBinary::Exists(strFileName);
|
|
}
|
|
bool CSystemUtility::IsFileExist(const CPath& oPath)
|
|
{
|
|
return IsFileExist(oPath.GetPath());
|
|
}
|
|
|
|
std::wstring CSystemUtility::GetDirectoryName(const std::wstring& strFileName)
|
|
{
|
|
CPath oPath(strFileName);
|
|
return oPath.GetDirectory();
|
|
}
|
|
|
|
int CSystemUtility::GetFilesCount(const std::wstring& strDirPath, const bool& bRecursive)
|
|
{
|
|
return NSDirectory::GetFilesCount(strDirPath, bRecursive);
|
|
}
|
|
|
|
std::wstring CSystemUtility::GetFileExtention(const std::wstring& strFileName)
|
|
{
|
|
CPath oPath(strFileName);
|
|
return oPath.GetExtention();
|
|
}
|
|
|
|
bool CSystemUtility::CreateDirectories(const CPath& oPath)
|
|
{
|
|
return NSDirectory::CreateDirectory(oPath.GetPath());
|
|
}
|
|
|
|
void CSystemUtility::ReplaceExtention(std::wstring& strName, std::wstring& str1, std::wstring& str2)
|
|
{
|
|
return;
|
|
}
|
|
}
|