[bfreisen] 72804: [ATL] Add atlpath.h, which provides the CPathT class template and the classes CPath, CPathA and CPathW. CORE-12034

Author: bfreisen
Date: Sun Sep 25 19:58:22 2016
New Revision: 72804

URL: http://svn.reactos.org/svn/reactos?rev=72804&view=rev
Log:
[ATL] Add atlpath.h, which provides the CPathT class template and the classes CPath,
CPathA and CPathW.  CORE-12034

Added:
    trunk/reactos/sdk/lib/atl/atlpath.h   (with props)

Added: trunk/reactos/sdk/lib/atl/atlpath.h
URL: http://svn.reactos.org/svn/reactos/trunk/reactos/sdk/lib/atl/atlpath.h?rev=…
==============================================================================
--- trunk/reactos/sdk/lib/atl/atlpath.h	(added)
+++ trunk/reactos/sdk/lib/atl/atlpath.h	[iso-8859-1] Sun Sep 25 19:58:22 2016
@@ -0,0 +1,388 @@
+// PROJECT:        ReactOS ATL CPathT
+// LICENSE:        Public Domain
+// PURPOSE:        Provides compatibility to Microsoft ATL
+// PROGRAMMERS:    Benedikt Freisen
+
+#ifndef __ATLPATH_H__
+#define __ATLPATH_H__
+
+// WARNING: Untested code
+
+#pragma once
+
+#include <atlcore.h>
+#include <atlstr.h>
+#include <shlwapi.h>
+
+namespace ATL
+{
+
+template<typename StringType>
+class CPathT
+{
+    // const
+    inline BOOL PathFileExistsX(LPCSTR pszPath) { return PathFileExistsA(pszPath); }
+    inline BOOL PathFileExistsX(LPCWSTR pszPath) { return PathFileExistsW(pszPath); }
+    inline int PathFindExtensionX(LPCSTR pszPath) { return PathFindExtensionA(pszPath);
}
+    inline int PathFindExtensionX(LPCWSTR pszPath) { return PathFindExtensionW(pszPath);
}
+    inline int PathFindFileNameX(LPCSTR pszPath) { return PathFindFileNameA(pszPath); }
+    inline int PathFindFileNameX(LPCWSTR pszPath) { return PathFindFileNameW(pszPath); }
+    inline int PathGetDriveNumberX(LPCSTR pszPath) { return PathGetDriveNumberA(pszPath);
}
+    inline int PathGetDriveNumberX(LPCWSTR pszPath) { return
PathGetDriveNumberW(pszPath); }
+    inline BOOL PathIsDirectoryX(LPCSTR pszPath) { return PathIsDirectoryA(pszPath); }
+    inline BOOL PathIsDirectoryX(LPCWSTR pszPath) { return PathIsDirectoryW(pszPath); }
+    inline BOOL PathIsFileSpecX(LPCSTR pszPath) { return PathIsFileSpecA(pszPath); }
+    inline BOOL PathIsFileSpecX(LPCWSTR pszPath) { return PathIsFileSpecW(pszPath); }
+    inline BOOL PathIsPrefixX(LPCSTR pszPath, LPCSTR pszPrefix) { return
PathIsPrefixA(pszPath, pszPrefix); }
+    inline BOOL PathIsPrefixX(LPCWSTR pszPath, LPCWSTR pszPrefix) { return
PathIsPrefixW(pszPath, pszPrefix); }
+    inline BOOL PathIsRelativeX(LPCSTR pszPath) { return PathIsRelativeA(pszPath); }
+    inline BOOL PathIsRelativeX(LPCWSTR pszPath) { return PathIsRelativeW(pszPath); }
+    inline BOOL PathIsRootX(LPCSTR pszPath) { return PathIsRootA(pszPath); }
+    inline BOOL PathIsRootX(LPCWSTR pszPath) { return PathIsRootW(pszPath); }
+    inline BOOL PathIsSameRootX(LPCSTR pszPath, LPCSTR pszOther) { return
PathIsSameRootA(pszPath, pszOther); }
+    inline BOOL PathIsSameRootX(LPCWSTR pszPath, LPCWSTR pszOther) { return
PathIsSameRootW(pszPath, pszOther); }
+    inline BOOL PathIsUNCX(LPCSTR pszPath) { return PathIsUNCA(pszPath); }
+    inline BOOL PathIsUNCX(LPCWSTR pszPath) { return PathIsUNCW(pszPath); }
+    inline BOOL PathIsUNCServerX(LPCSTR pszPath) { return PathIsUNCServerA(pszPath); }
+    inline BOOL PathIsUNCServerX(LPCWSTR pszPath) { return PathIsUNCServerW(pszPath); }
+    inline BOOL PathIsUNCServerShareX(LPCSTR pszPath) { return
PathIsUNCServerShareA(pszPath); }
+    inline BOOL PathIsUNCServerShareX(LPCWSTR pszPath) { return
PathIsUNCServerShareW(pszPath); }
+    inline BOOL PathMatchSpecX(LPCSTR pszPath, LPCSTR pszSpec) { return
PathMatchSpecA(pszPath, pszSpec); }
+    inline BOOL PathMatchSpecX(LPCWSTR pszPath, LPCWSTR pszSpec) { return
PathMatchSpecW(pszPath, pszSpec); }
+    inline int PathSkipRootX(LPCSTR pszPath) { return PathSkipRootA(pszPath); }
+    inline int PathSkipRootX(LPCWSTR pszPath) { return PathSkipRootW(pszPath); }
+
+    // non-const
+    inline void PathAddBackslashX(LPSTR pszPath) { return PathAddBackslashA(pszPath); }
+    inline void PathAddBackslashX(LPWSTR pszPath) { return PathAddBackslashW(pszPath); }
+    inline BOOL PathAddExtensionX(LPSTR pszPath, LPCSTR pszExt) { return
PathAddExtensionA(pszPath, pszExt); }
+    inline BOOL PathAddExtensionX(LPWSTR pszPath, LPCWSTR pszExt) { return
PathAddExtensionW(pszPath, pszExt); }
+    inline BOOL PathAppendX(LPSTR pszPath, LPCSTR pszMore) { return PathAppendA(pszPath,
pszMore); }
+    inline BOOL PathAppendX(LPWSTR pszPath, LPCWSTR pszMore) { return
PathAppendW(pszPath, pszMore); }
+    inline void PathBuildRootX(LPSTR pszRoot, int iDrive) { return
PathBuildRootA(pszRoot, iDrive); }
+    inline void PathBuildRootX(LPWSTR pszRoot, int iDrive) { return
PathBuildRootW(pszRoot, iDrive); }
+    inline void PathCanonicalizeX(LPSTR pszDst, LPCSTR pszSrc) { return
PathCanonicalizeA(pszDst, pszSrc); }
+    inline void PathCanonicalizeX(LPWSTR pszDst, LPCWSTR pszSrc) { return
PathCanonicalizeW(pszDst, pszSrc); }
+    inline void PathCombineX(LPSTR pszPathOut, LPCSTR pszPathIn, LPCSTR pszMore) { return
PathCombineA(pszPathOut, pszPathIn, pszMore); }
+    inline void PathCombineX(LPWSTR pszPathOut, LPCWSTR pszPathIn, LPCWSTR pszMore) {
return PathCombineW(pszPathOut, pszPathIn, pszMore); }
+    inline CPathT<StringType> PathCommonPrefixX(LPCSTR pszFile1, LPCSTR pszFile2,
LPSTR pszPath) { return PathCommonPrefixA(pszFile1, pszFile2, pszPath); }
+    inline CPathT<StringType> PathCommonPrefixX(LPCWSTR pszFile1, LPCWSTR pszFile2,
LPWSTR pszPath) { return PathCommonPrefixW(pszFile1, pszFile2, pszPath); }
+    inline BOOL PathCompactPathX(HDC hDC, LPSTR pszPath, UINT dx) { return
PathCompactPathA(hDC, pszPath, dx); }
+    inline BOOL PathCompactPathX(HDC hDC, LPWSTR pszPath, UINT dx) { return
PathCompactPathW(hDC, pszPath, dx); }
+    inline BOOL PathCompactPathExX(LPSTR pszOut, LPCSTR pszSrc, UINT cchMax, DWORD
dwFlags) { return PathCompactPathExA(pszOut, pszSrc, cchMax, dwFlags); }
+    inline BOOL PathCompactPathExX(LPWSTR pszOut, LPCWSTR pszSrc, UINT cchMax, DWORD
dwFlags) { return PathCompactPathExW(pszOut, pszSrc, cchMax, dwFlags); }
+    inline BOOL PathMakePrettyX(LPSTR pszPath) { return PathMakePrettyA(pszPath); }
+    inline BOOL PathMakePrettyX(LPWSTR pszPath) { return PathMakePrettyW(pszPath); }
+    inline void PathQuoteSpacesX(LPSTR pszPath) { return PathQuoteSpacesA(pszPath); }
+    inline void PathQuoteSpacesX(LPWSTR pszPath) { return PathQuoteSpacesW(pszPath); }
+    inline BOOL PathRelativePathToX(LPSTR pszPath, LPCSTR pszFrom, DWORD dwAttrFrom,
LPCSTR pszTo, DWORD dwAttrTo) { return PathRelativePathToA(pszPath, pszFrom, dwAttrFrom,
pszTo, dwAttrTo); }
+    inline BOOL PathRelativePathToX(LPWSTR pszPath, LPCWSTR pszFrom, DWORD dwAttrFrom,
LPCWSTR pszTo, DWORD dwAttrTo) { return PathRelativePathToW(pszPath, pszFrom, dwAttrFrom,
pszTo, dwAttrTo); }
+    inline void PathRemoveArgsX(LPSTR pszPath) { return PathRemoveArgsA(pszPath); }
+    inline void PathRemoveArgsX(LPWSTR pszPath) { return PathRemoveArgsW(pszPath); }
+    inline void PathRemoveBackslashX(LPSTR pszPath) { return
PathRemoveBackslashA(pszPath); }
+    inline void PathRemoveBackslashX(LPWSTR pszPath) { return
PathRemoveBackslashW(pszPath); }
+    inline void PathRemoveBlanksX(LPSTR pszPath) { return PathRemoveBlanksA(pszPath); }
+    inline void PathRemoveBlanksX(LPWSTR pszPath) { return PathRemoveBlanksW(pszPath); }
+    inline void PathRemoveExtensionX(LPSTR pszPath) { return
PathRemoveExtensionA(pszPath); }
+    inline void PathRemoveExtensionX(LPWSTR pszPath) { return
PathRemoveExtensionW(pszPath); }
+    inline BOOL PathRemoveFileSpecX(LPSTR pszPath) { return PathRemoveFileSpecA(pszPath);
}
+    inline BOOL PathRemoveFileSpecX(LPWSTR pszPath) { return
PathRemoveFileSpecW(pszPath); }
+    inline BOOL PathRenameExtensionX(LPSTR pszPath, LPCSTR pszExt) { return
PathRenameExtensionA(pszPath, pszExt); }
+    inline BOOL PathRenameExtensionX(LPWSTR pszPath, LPCWSTR pszExt) { return
PathRenameExtensionW(pszPath, pszExt); }
+    inline void PathStripPathX(LPSTR pszPath) { return PathStripPathA(pszPath); }
+    inline void PathStripPathX(LPWSTR pszPath) { return PathStripPathW(pszPath); }
+    inline BOOL PathStripToRootX(LPSTR pszPath) { return PathStripToRootA(pszPath); }
+    inline BOOL PathStripToRootX(LPWSTR pszPath) { return PathStripToRootW(pszPath); }
+    inline void PathUnquoteSpacesX(LPSTR pszPath) { return PathUnquoteSpacesA(pszPath);
}
+    inline void PathUnquoteSpacesX(LPWSTR pszPath) { return PathUnquoteSpacesW(pszPath);
}
+
+public:
+    typedef typename StringType::PCXSTR PCXSTR;
+    typedef typename StringType::PXSTR PXSTR;
+    typedef typename StringType::XCHAR XCHAR;
+
+    StringType m_strPath;
+
+    CPathT(PCXSTR pszPath)
+    {
+        m_strPath = StringType(pszPath);
+    }
+
+    CPathT(const CPathT<StringType>& path)
+    {
+        m_strPath = path.m_strPath;
+    }
+
+    CPathT() throw()
+    {
+        // do nothing, m_strPath initializes itself
+    }
+
+    void AddBackslash()
+    {
+        PXSTR str = m_strPath.GetBuffer(MAX_PATH);
+        PathAddBackslashX(str);
+        m_strPath.ReleaseBuffer();
+    }
+
+    BOOL AddExtension(PCXSTR pszExtension)
+    {
+        PXSTR str = m_strPath.GetBuffer(MAX_PATH);
+        BOOL result = PathAddExtensionX(str, pszExtension);
+        m_strPath.ReleaseBuffer();
+        return result;
+    }
+
+    BOOL Append(PCXSTR pszMore)
+    {
+        PXSTR str = m_strPath.GetBuffer(MAX_PATH);
+        BOOL result = PathAppendX(str, pszMore);
+        m_strPath.ReleaseBuffer();
+        return result;
+    }
+
+    void BuildRoot(int iDrive)
+    {
+        PXSTR str = m_strPath.GetBuffer(4);
+        PathBuildRootX(str, iDrive);
+        m_strPath.ReleaseBuffer();
+    }
+
+    void Canonicalize()
+    {
+        StringType strTemp;
+        PXSTR str = strTemp.GetBuffer(MAX_PATH);
+        PathCanonicalizeX(str, m_strPath);
+        strTemp.ReleaseBuffer();
+        m_strPath = strTemp;
+    }
+
+    void Combine(PCXSTR pszDir, PCXSTR pszFile)
+    {
+        PXSTR str = m_strPath.GetBuffer(MAX_PATH);
+        PathCombineX(str, pszDir, pszFile);
+        m_strPath.ReleaseBuffer();
+    }
+
+    CPathT<StringType> CommonPrefix(PCXSTR pszOther)
+    {
+        StringType result;
+        result.SetString(m_strPath, PathCommonPrefixX(m_strPath, pszOther, NULL));
+        return result;
+    }
+
+    BOOL CompactPath(HDC hDC, UINT nWidth)
+    {
+        PXSTR str = m_strPath.GetBuffer(MAX_PATH);
+        BOOL result = PathCompactPathX(hDC, str, nWidth);
+        m_strPath.ReleaseBuffer();
+        return result;
+    }
+
+    BOOL CompactPathEx(UINT nMaxChars, DWORD dwFlags = 0)
+    {
+        StringType result;
+        PXSTR str = result.GetBuffer(nMaxChars);
+        PathCompactPathExX(str, m_strPath, nMaxChars, dwFlags);
+        result.ReleaseBuffer();
+        return result;
+    }
+
+    BOOL FileExists() const
+    {
+        return PathFileExistsX(m_strPath);
+    }
+
+    int FindExtension() const
+    {
+        return PathFindExtensionX(m_strPath);
+    }
+
+    int FindFileName() const
+    {
+        return PathFindFileNameX(m_strPath);
+    }
+
+    int GetDriveNumber() const
+    {
+        return PathGetDriveNumberX(m_strPath);
+    }
+
+    StringType GetExtension() const
+    {
+        return StringType(PathFindExtensionX(m_strPath));
+    }
+
+    BOOL IsDirectory() const
+    {
+        return PathIsDirectoryX(m_strPath);
+    }
+
+    BOOL IsFileSpec() const
+    {
+        return PathIsFileSpecX(m_strPath);
+    }
+
+    BOOL IsPrefix(PCXSTR pszPrefix) const
+    {
+        return PathIsPrefixX(m_strPath);
+    }
+
+    BOOL IsRelative() const
+    {
+        return PathIsRelativeX(m_strPath);
+    }
+
+    BOOL IsRoot() const
+    {
+        return PathIsRootX(m_strPath);
+    }
+
+    BOOL IsSameRoot(PCXSTR pszOther) const
+    {
+        return PathIsSameRootX(m_strPath, pszOther);
+    }
+
+    BOOL IsUNC() const
+    {
+        return PathIsUNCX(m_strPath);
+    }
+
+    BOOL IsUNCServer() const
+    {
+        return PathIsUNCServerX(m_strPath);
+    }
+
+    BOOL IsUNCServerShare() const
+    {
+        return PathIsUNCServerShareX(m_strPath);
+    }
+
+    BOOL MakePretty()
+    {
+        PXSTR str = m_strPath.GetBuffer(MAX_PATH);
+        BOOL result = PathMakePrettyX(str);
+        m_strPath.ReleaseBuffer();
+        return result;
+    }
+
+    BOOL MatchSpec(PCXSTR pszSpec) const
+    {
+        return PathMatchSpecX(m_strPath, pszSpec);
+    }
+
+    void QuoteSpaces()
+    {
+        PXSTR str = m_strPath.GetBuffer(MAX_PATH);
+        PathQuoteSpacesX(str);
+        m_strPath.ReleaseBuffer();
+    }
+
+    BOOL RelativePathTo(PCXSTR pszFrom, DWORD dwAttrFrom, PCXSTR pszTo, DWORD dwAttrTo)
+    {
+        PXSTR str = m_strPath.GetBuffer(MAX_PATH);
+        BOOL result = PathRelativePathToX(str, pszFrom, dwAttrFrom, pszTo, dwAttrTo);
+        m_strPath.ReleaseBuffer();
+        return result;
+    }
+
+    void RemoveArgs()
+    {
+        PXSTR str = m_strPath.GetBuffer(MAX_PATH);
+        PathRemoveArgsX(str);
+        m_strPath.ReleaseBuffer();
+    }
+
+    void RemoveBackslash()
+    {
+        PXSTR str = m_strPath.GetBuffer(MAX_PATH);
+        PathRemoveBackslashX(str);
+        m_strPath.ReleaseBuffer();
+    }
+
+    void RemoveBlanks()
+    {
+        PXSTR str = m_strPath.GetBuffer(MAX_PATH);
+        PathRemoveBlanksX(str);
+        m_strPath.ReleaseBuffer();
+    }
+
+    void RemoveExtension()
+    {
+        PXSTR str = m_strPath.GetBuffer(MAX_PATH);
+        PathRemoveExtensionX(str);
+        m_strPath.ReleaseBuffer();
+    }
+
+    BOOL RemoveFileSpec()
+    {
+        PXSTR str = m_strPath.GetBuffer(MAX_PATH);
+        BOOL result = PathRemoveFileSpecX(str);
+        m_strPath.ReleaseBuffer();
+        return result;
+    }
+
+    BOOL RenameExtension(PCXSTR pszExtension)
+    {
+        PXSTR str = m_strPath.GetBuffer(MAX_PATH);
+        BOOL result = PathRenameExtensionX(str, pszExtension);
+        m_strPath.ReleaseBuffer();
+        return result;
+    }
+
+    int SkipRoot() const
+    {
+        return PathSkipRootX(m_strPath);
+    }
+
+    void StripPath()
+    {
+        PXSTR str = m_strPath.GetBuffer(MAX_PATH);
+        PathStripPathX(str);
+        m_strPath.ReleaseBuffer();
+    }
+
+    BOOL StripToRoot()
+    {
+        PXSTR str = m_strPath.GetBuffer(MAX_PATH);
+        BOOL result = PathStripToRootX(str);
+        m_strPath.ReleaseBuffer();
+        return result;
+    }
+
+    void UnquoteSpaces()
+    {
+        PXSTR str = m_strPath.GetBuffer(MAX_PATH);
+        PathUnquoteSpacesX(str);
+        m_strPath.ReleaseBuffer();
+    }
+
+    operator const StringType&() const throw()
+    {
+        return m_strPath;
+    }
+
+    operator PCXSTR() const throw()
+    {
+        return m_strPath;
+    }
+
+    operator StringType&() throw()
+    {
+        return m_strPath;
+    }
+
+    CPathT<StringType>& operator+=(PCXSTR pszMore)
+    {
+        m_strPath += pszMore;
+    }
+
+};
+
+typedef CPathT<CString> CPath;
+typedef CPathT<CStringA> CPathA;
+typedef CPathT<CStringW> CPathW;
+
+}  // namespace ATL
+
+#endif

Propchange: trunk/reactos/sdk/lib/atl/atlpath.h
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: trunk/reactos/sdk/lib/atl/atlpath.h
------------------------------------------------------------------------------
    svn:mime-type = text/plain